|
|
/******************************Module*Header*******************************\
* Module Name: mcdpoint.c** Contains all of the point-rendering routines for the Cirrus Logic 546X MCD driver.** (based on mcdpoint.c from NT4.0 DDK)** Copyright (c) 1996 Microsoft Corporation* Copyright (c) 1997 Cirrus Logic, Inc.\**************************************************************************/
#include "precomp.h"
#include "mcdhw.h"
#include "mcdutil.h"
#include "mcdmath.h"
#define TRUNCCOORD(value, intValue)\
intValue = __MCD_VERTEX_FIXED_TO_INT(__MCD_VERTEX_FLOAT_TO_FIXED(value))
VOID FASTCALL __MCDRenderPoint(DEVRC *pRc, MCDVERTEX *a){ ULONG clipNum; RECTL *pClip;
LONG lCoord;
PDEV *ppdev = pRc->ppdev; unsigned int *pdwNext = ppdev->LL_State.pDL->pdwNext;
// output queue stuff...
DWORD *pSrc; DWORD *pDest = ppdev->LL_State.pRegs + HOST_3D_DATA_PORT; DWORD *pdwStart = ppdev->LL_State.pDL->pdwStartOutPtr;
DWORD dwFlags=0; // MCD_TEMP - dwflags initialized to 0
DWORD *dwOrig; /* Temp display list pointer */ DWORD dwOpcode; // Built opcode
LONG ax, ay; if ((clipNum = pRc->pEnumClip->c) > 1) { pClip = &pRc->pEnumClip->arcl[0]; SET_HW_CLIP_REGS(pRc,pdwNext) pClip++; }
// window coords are float values, and need to have
// viewportadjust (MCDVIEWPORT) values subtracted to get to real screen space
// color values are 0->1 floats and must be multiplied by scale values (MCDRCINFO)
// to get to nbits range (scale = 0xff for 8 bit, 0x7 for 3 bit, etc.)
// Z values are 0->1 floats(?) and must be multiplied by zscale(?) values (MCDRCINFO)
#if 0 // FUTURE - need to enable 3d control regs setup for texture
// Turn on alpha blending if it is required and is not already on
// Also turn it off if it is on and is not required
//
// Note: LL_ALPHA bit should be 1
//
if( (dwFlags ^ (LL_State.dwControl0>>15)) & 1 ) { // Alpha enable is bit 15 in control0, so toggle it
//
LL_State.dwControl0 ^= 0x00008000; // bit 15
*pdwNext++ = write_register( CONTROL0_3D, 1 ); *pdwNext++ = LL_State.dwControl0; }
#if 0 // MCD never uses alpha_mode 0
// Set up the da_main, da_ortho registers necessary for
// constant alpha blending
// ========
if( (dwFlags & LL_ALPHA) && (LL_State.Control0.Alpha_Mode == 0) ) { // Check if a new value needs to be set
//
if( LL_State.rDA_MAIN != LL_State.AlphaConstSource || LL_State.rDA_ORTHO != LL_State.AlphaConstDest ) { *(pdwNext+0) = write_register( DA_MAIN_3D, 2 ); *(pdwNext+1) = LL_State.rDA_MAIN = LL_State.AlphaConstSource; *(pdwNext+2) = LL_State.rDA_ORTHO = LL_State.AlphaConstDest;
pdwNext += 3; } } #endif
// NOTE!!! - caller (MCDPrimDrawPoints) will put this in outlist, which will be sent at end of this proc
// *pdwNext++ = write_register( Y_COUNT_3D, 1 );
// *pdwNext++ = 0;
#endif 0 // FUTURE - (end 3d control regs setup for texture)
// Store the first address for the opcode
//
dwOrig = pdwNext;
// Start with a plain point instruction (no modifiers)
// and assume same color. Count=2 for x,y
//
dwOpcode = POINT | SAME_COLOR | 2; // Set flags as requested from the dwFlags field of a batch.
// These bits have 1-1 correspondence to their instruction
// counterparts.
//
// Flags : LL_DITHER - Use dither pattern
// LL_PATTERN - Draw pattern
// LL_STIPPLE - Use stipple mask
// LL_LIGHTING - Do lighting
// LL_Z_BUFFER - Use Z buffer
// FETCH_COLOR - Appended for alpha blending
// LL_GOURAUD - Use Gouraud shading
// LL_TEXTURE - Texture mapping
//
/*
dwOpcode |= dwFlags & ( LL_DITHER | LL_PATTERN | LL_STIPPLE | LL_LIGHTING | LL_Z_BUFFER | FETCH_COLOR | LL_GOURAUD | LL_TEXTURE ); */ // no point stippling for OpenGL
dwOpcode |= pRc->privateEnables & __MCDENABLE_Z ; dwOpcode |= pRc->privateEnables & __MCDENABLE_DITHER ;
//SNAPCOORD(a->windowCoord.x, ax);
TRUNCCOORD(a->windowCoord.x, ax); lCoord = ax + pRc->xOffset; // adds window offset, removes a000 offset
*(pdwNext+1) = (DWORD) (lCoord << 16 );
//SNAPCOORD(a->windowCoord.y, ay);
TRUNCCOORD(a->windowCoord.y, ay); lCoord = ay + pRc->yOffset; // adds window offset, removes a000 offset
*(pdwNext+2) = (DWORD) ((lCoord << 16) + 1);
pdwNext += 3;
if( !(dwFlags & LL_SAME_COLOR) ) { register DWORD color;
// Clear same_color flag
//
dwOpcode ^= LL_SAME_COLOR; *pdwNext = FTOL(a->colors[0].r * pRc->rScale);
*(pdwNext+1) = FTOL(a->colors[0].g * pRc->gScale); *(pdwNext+2) = FTOL(a->colors[0].b * pRc->bScale);
dwOpcode += 3; pdwNext += 3; }
if( pRc->privateEnables & __MCDENABLE_Z) {
*pdwNext++ = FTOL(a->windowCoord.z * pRc->zScale); dwOpcode += 1; }
#if 0
if( dwFlags & LL_TEXTURE ) { ... ... ... }
#endif
if (pRc->privateEnables & (__MCDENABLE_BLEND|__MCDENABLE_FOG)) { float v1alp;
if (pRc->privateEnables & __MCDENABLE_BLEND) { // recall that if both blending and fog active, all prims punted back to software
v1alp = a->colors[0].a * pRc->aScale; } else { v1alp = a->fog * (float)16777215.0; // convert from 0->1.0 val to 0->ff.ffff val
}
*pdwNext++ = FTOL(v1alp) & 0x00ffff00;// bits 31->24 and 7->0 reserved
dwOpcode += ( FETCH_COLOR | ALPHA + 1 );
}
// Store the final opcode
//
*dwOrig = dwOpcode;
while (--clipNum) { int len = (dwOpcode & 0x3F) + 1; // num words for line primitive
SET_HW_CLIP_REGS(pRc,pdwNext) pClip++;
// dump same pt regs again to draw while clipping against occlusion rectangle
pSrc = dwOrig; while( len-- ) *pdwNext++ = *pSrc++; }
// output queued data here....
#if 0 // FUTURE - enable queueing algorithm - just outputting everything for now
OUTPUT_COPROCMODE_QUEUE#else // 0
{ pSrc = pdwStart; while (pSrc != pdwNext) { /* Get the amount of data for this opcode */ int len = (*pSrc & 0x3F) + 1;
USB_TIMEOUT_FIX(ppdev) while( len-- ) *pDest = *pSrc++; } } #endif // 0
ppdev->LL_State.pDL->pdwNext = ppdev->LL_State.pDL->pdwStartOutPtr = pdwStart;}
VOID FASTCALL __MCDRenderGenPoint(DEVRC *pRc, MCDVERTEX *pv){ // MGA and S3 MCD's have no code in this proc
MCDBG_PRINT("__MCDRenderGenPoint - EMPTY ROUTINE");}
|
