218ca90543
Source code release, imported from: https://www.gamefront.com/games/aliens-vs-predator-3/file/avp-gold-complete-source-code All text files were converted to Unix format.
2830 lines
No EOL
61 KiB
C
2830 lines
No EOL
61 KiB
C
/*KJL*********************************************************************
|
|
* krender.c - Kevin's scandrawing code. (New render, new danger.) *
|
|
* *
|
|
* The new scandraws are called by patching the functions below into the *
|
|
* jumptables used in item.c. If the KRENDER_ON flag in krender.h is zero *
|
|
* then the old scandraws will be used. *
|
|
*********************************************************************KJL*/
|
|
|
|
/* this file is a bit messy at the moment, but I'll be back later... */
|
|
#include "3dc.h"
|
|
#include "inline.h"
|
|
#include "module.h"
|
|
#include "gamedef.h"
|
|
#include "krender.h"
|
|
#include "vision.h"
|
|
|
|
#define UseLocalAssert Yes
|
|
#include "ourasert.h"
|
|
|
|
#define PENTIUM_PROFILING_ON 0
|
|
#if PENTIUM_PROFILING_ON
|
|
#include "pentime.h"
|
|
#else
|
|
#define ProfileStart();
|
|
#define ProfileStop(x);
|
|
#endif
|
|
|
|
int ReciprocalTable[321];
|
|
#if 1
|
|
#define DIVIDE(a,b) ((a)/(b))
|
|
#else
|
|
#define DIVIDE(a,b) (MUL_FIXED((a),ReciprocalTable[(b)]))
|
|
#endif
|
|
|
|
|
|
int Transparent;
|
|
|
|
/* assembler fns */
|
|
extern void ScanDraw2D_Gouraud(void);
|
|
extern void ScanDraw2D_GouraudTransparent(void);
|
|
extern void ScanDraw2D_VAlignedTransparent(void);
|
|
extern void ScanDraw2D_VAlignedOpaque(void);
|
|
extern void ScanDraw2D_Transparent(void);
|
|
extern void ScanDraw2D_TransparentLit(void);
|
|
extern void ScanDraw2D_Opaque(void);
|
|
extern void ScanDraw_GouraudScan(void);
|
|
extern void ScanDrawF3D_Gouraud(void);
|
|
|
|
/* globals accessed by the assembler routines */
|
|
unsigned char *SCASM_Lighting;
|
|
unsigned char *SCASM_Destination;
|
|
unsigned char *SCASM_Bitmap;
|
|
int SCASM_StartU;
|
|
int SCASM_StartV;
|
|
int SCASM_StartI;
|
|
int SCASM_DeltaU;
|
|
int SCASM_DeltaV;
|
|
int SCASM_DeltaI;
|
|
int SCASM_ScanLength;
|
|
int SCASM_ShadingTableSize;
|
|
int SCASM_TextureDeltaScan;
|
|
|
|
/* things from item.c */
|
|
extern int NumScans;
|
|
extern int ItemColour;
|
|
extern IMAGEHEADER *ImageHeaderPtrs[MaxImages];
|
|
extern SCREENDESCRIPTORBLOCK ScreenDescriptorBlock;
|
|
extern unsigned char *TextureLightingTable;
|
|
extern int MIP_Index;
|
|
extern int ScanData[maxpolys*maxscansize];
|
|
extern unsigned char *ScreenBuffer;
|
|
extern long BackBufferPitch;
|
|
|
|
void Draw_Gouraud3dTexture_Spans(int *itemptr);
|
|
|
|
int KRenderDrawMode = 0;
|
|
|
|
/***********/
|
|
|
|
void KR_ScanDraw_Item_Gouraud2dTexturePolygon_VideoModeType_8(int *itemptr)
|
|
{
|
|
POLYHEADER *pheader = (POLYHEADER *) itemptr;
|
|
I_GOURAUD2DTEXTUREPOLYGON_SCAN *sptr;
|
|
|
|
if(NumScans)
|
|
{
|
|
int y = NumScans;
|
|
/* Get the Image Data required for the Draw */
|
|
{
|
|
IMAGEHEADER *ImageHdr;
|
|
{
|
|
int TxIndex = ItemColour & ClrTxDefn;
|
|
ImageHdr = ImageHeaderPtrs[TxIndex];
|
|
}
|
|
if(ScreenDescriptorBlock.SDB_Flags & SDB_Flag_MIP && ImageHdr->ImageFlags & ih_flag_mip)
|
|
{
|
|
TEXTURE **TxImagePtr = &ImageHdr->ImagePtr;
|
|
SCASM_Bitmap = TxImagePtr[MIP_Index];
|
|
GLOBALASSERT(SCASM_Bitmap);
|
|
SCASM_TextureDeltaScan = ImageHdr->ImageWidth >> MIP_Index;
|
|
#if MIP_ROUNDUP
|
|
if (ImageHdr->ImageWidth & (1<<MIP_Index)-1) ++SCASM_TextureDeltaScan;
|
|
#endif
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
SCASM_TextureDeltaScan = ImageHdr->ImageWidth;
|
|
SCASM_Bitmap = ImageHdr->ImagePtr;
|
|
GLOBALASSERT(SCASM_Bitmap);
|
|
}
|
|
}
|
|
SCASM_Lighting = TextureLightingTable;
|
|
|
|
if(ScreenDescriptorBlock.SDB_Flags & SDB_Flag_Raw256) SCASM_ShadingTableSize = 256;
|
|
else SCASM_ShadingTableSize = 64;
|
|
|
|
sptr = (I_GOURAUD2DTEXTUREPOLYGON_SCAN *) ScanData;
|
|
do
|
|
{
|
|
int dx = sptr->ig2s_x2 - sptr->ig2s_x1;
|
|
if (dx>0 && !(sptr->ig2s_y & KRenderDrawMode) )
|
|
{
|
|
/* Fixed Point U for Interpolation */
|
|
{
|
|
int StartU = sptr->ig2s_u1;
|
|
SCASM_DeltaU = DIVIDE((sptr->ig2s_u2 - StartU),dx);
|
|
SCASM_StartU = StartU;
|
|
}
|
|
|
|
/* Fixed Point V for Interpolation */
|
|
{
|
|
int StartV = sptr->ig2s_v1;
|
|
SCASM_DeltaV = DIVIDE((sptr->ig2s_v2 - StartV),dx);
|
|
SCASM_StartV = StartV;
|
|
}
|
|
/* Fixed Point I for Interpolation */
|
|
{
|
|
int StartI = sptr->ig2s_c1;
|
|
SCASM_DeltaI = DIVIDE((sptr->ig2s_c2 - StartI),dx);
|
|
SCASM_StartI = StartI;
|
|
}
|
|
/* Draw the Gouraud 2d Texture Scan */
|
|
|
|
SCASM_Destination = ScreenBuffer + (sptr->ig2s_y * BackBufferPitch) + sptr->ig2s_x1;
|
|
SCASM_ScanLength = dx;
|
|
|
|
if(pheader->PolyFlags & iflag_ignore0)
|
|
{
|
|
ScanDraw2D_GouraudTransparent();
|
|
}
|
|
else
|
|
{
|
|
ScanDraw2D_Gouraud();
|
|
}
|
|
}
|
|
sptr++;
|
|
y--;
|
|
}
|
|
while(y);
|
|
}
|
|
|
|
}
|
|
|
|
void Draw3DScan(I_GOURAUD3DTEXTUREPOLYGON_SCAN *scanPtr, POLYHEADER *pheader)
|
|
{
|
|
int dx = scanPtr->ig3s_x2 - scanPtr->ig3s_x1;
|
|
|
|
if(dx > 0)
|
|
{
|
|
float uf;
|
|
float vf;
|
|
float uf2;
|
|
float vf2;
|
|
/* Get start and end UVs */
|
|
{
|
|
float ooz1;
|
|
ooz1 = 65536.0 / scanPtr->ig3s_z1;
|
|
uf = scanPtr->ig3s_u1 * ooz1;
|
|
vf = scanPtr->ig3s_v1 * ooz1;
|
|
}
|
|
{
|
|
float ooz2;
|
|
ooz2 = 65536.0 / scanPtr->ig3s_z2;
|
|
uf2 = scanPtr->ig3s_u2 * ooz2;
|
|
vf2 = scanPtr->ig3s_v2 * ooz2;
|
|
}
|
|
if ( (uf>16700000.0)
|
|
||(uf<0.0)
|
|
||(vf>16700000.0)
|
|
||(vf<0.0) )
|
|
{
|
|
textprint("WARNING: UV coords invalid\n");
|
|
// LOCALASSERT(0);
|
|
return;
|
|
}
|
|
if ( (uf2>16700000.0)
|
|
||(uf2<0.0)
|
|
||(vf2>16700000.0)
|
|
||(vf2<0.0) )
|
|
{
|
|
textprint("WARNING: UV coords invalid\n");
|
|
// LOCALASSERT(0);
|
|
return;
|
|
}
|
|
/* For UV interpolation */
|
|
f2i(SCASM_StartU,uf);
|
|
f2i(SCASM_StartV,vf);
|
|
{
|
|
int EndU,EndV;
|
|
f2i(EndU,uf2);
|
|
f2i(EndV,vf2);
|
|
SCASM_DeltaU =(EndU-SCASM_StartU)/dx;
|
|
SCASM_DeltaV =(EndV-SCASM_StartV)/dx;
|
|
}
|
|
|
|
/* Fixed Point I for Interpolation */
|
|
{
|
|
int StartI = scanPtr->ig3s_c1;
|
|
SCASM_DeltaI = (scanPtr->ig3s_c2 - StartI)/dx;
|
|
SCASM_StartI = StartI;
|
|
}
|
|
|
|
/* Draw the 3d Texture Scan */
|
|
SCASM_Destination = ScreenBuffer + (scanPtr->ig3s_y * BackBufferPitch) + scanPtr->ig3s_x1;
|
|
SCASM_ScanLength = dx;
|
|
|
|
if(pheader->PolyFlags & iflag_ignore0)
|
|
{
|
|
ScanDraw2D_GouraudTransparent();
|
|
}
|
|
else
|
|
{
|
|
ScanDraw2D_Gouraud();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void KR_ScanDraw_Item_Gouraud3dTexturePolygon_Linear_S_VideoModeType_8(int *itemptr)
|
|
{
|
|
POLYHEADER *pheader = (POLYHEADER *) itemptr;
|
|
|
|
int num_scans_s;
|
|
I_GOURAUD3DTEXTUREPOLYGON_SCAN *sptr_array_ptr;
|
|
I_GOURAUD3DTEXTUREPOLYGON_SCAN *next_free_sptr;
|
|
I_GOURAUD3DTEXTUREPOLYGON_SCAN sptr_array[lin_s_max + 1];
|
|
int StillSubdividing;
|
|
int i;
|
|
|
|
|
|
if(NumScans)
|
|
{
|
|
I_GOURAUD3DTEXTUREPOLYGON_SCAN *sptr;
|
|
int y;
|
|
/* Get the Image Data required for the Draw */
|
|
{
|
|
IMAGEHEADER *ImageHdr;
|
|
{
|
|
int TxIndex = ItemColour & ClrTxDefn;
|
|
ImageHdr = ImageHeaderPtrs[TxIndex];
|
|
}
|
|
if(ScreenDescriptorBlock.SDB_Flags & SDB_Flag_MIP && ImageHdr->ImageFlags & ih_flag_mip)
|
|
{
|
|
TEXTURE **TxImagePtr = &ImageHdr->ImagePtr;
|
|
SCASM_Bitmap = TxImagePtr[MIP_Index];
|
|
GLOBALASSERT(SCASM_Bitmap);
|
|
SCASM_TextureDeltaScan = ImageHdr->ImageWidth >> MIP_Index;
|
|
#if MIP_ROUNDUP
|
|
if (ImageHdr->ImageWidth & (1<<MIP_Index)-1) ++SCASM_TextureDeltaScan;
|
|
#endif
|
|
|
|
}
|
|
else
|
|
{
|
|
SCASM_TextureDeltaScan = ImageHdr->ImageWidth;
|
|
SCASM_Bitmap = ImageHdr->ImagePtr;
|
|
GLOBALASSERT(SCASM_Bitmap);
|
|
}
|
|
}
|
|
SCASM_Lighting = TextureLightingTable;
|
|
|
|
if(ScreenDescriptorBlock.SDB_Flags & SDB_Flag_Raw256) SCASM_ShadingTableSize = 256;
|
|
else SCASM_ShadingTableSize = 64;
|
|
|
|
|
|
sptr = (I_GOURAUD3DTEXTUREPOLYGON_SCAN *) ScanData;
|
|
|
|
for(y = NumScans; y!=0; y--)
|
|
{
|
|
int dx = sptr->ig3s_x2 - sptr->ig3s_x1;
|
|
if (dx>0 && !(sptr->ig3s_y & KRenderDrawMode) )
|
|
{
|
|
float zmax, zmin, z_ratio;
|
|
|
|
/* Have a look at the z-ratio */
|
|
if(sptr->ig3s_z1 > sptr->ig3s_z2)
|
|
{
|
|
zmax = sptr->ig3s_z1;
|
|
zmin = sptr->ig3s_z2;
|
|
}
|
|
else
|
|
{
|
|
zmax = sptr->ig3s_z2;
|
|
zmin = sptr->ig3s_z1;
|
|
}
|
|
z_ratio = (zmax * 256);
|
|
|
|
|
|
/* Draw if the z ratio is inside the threshold */
|
|
if(z_ratio < lin_s_zthr*zmin)
|
|
{
|
|
Draw3DScan(sptr,pheader);
|
|
}
|
|
/* Else subdivide until scan segments are inside threshold */
|
|
else
|
|
{
|
|
/* Copy the current scan to the subdivision array */
|
|
sptr_array_ptr = sptr_array;
|
|
num_scans_s = 1;
|
|
|
|
sptr_array_ptr->ig3s_u1 = sptr->ig3s_u1;
|
|
sptr_array_ptr->ig3s_v1 = sptr->ig3s_v1;
|
|
sptr_array_ptr->ig3s_z1 = sptr->ig3s_z1;
|
|
sptr_array_ptr->ig3s_c1 = sptr->ig3s_c1;
|
|
|
|
sptr_array_ptr->ig3s_u2 = sptr->ig3s_u2;
|
|
sptr_array_ptr->ig3s_v2 = sptr->ig3s_v2;
|
|
sptr_array_ptr->ig3s_z2 = sptr->ig3s_z2;
|
|
sptr_array_ptr->ig3s_c2 = sptr->ig3s_c2;
|
|
|
|
sptr_array_ptr->ig3s_x1 = sptr->ig3s_x1;
|
|
sptr_array_ptr->ig3s_x2 = sptr->ig3s_x2;
|
|
|
|
sptr_array_ptr->ig3s_y = sptr->ig3s_y;
|
|
|
|
|
|
/* Subdivide until no further divisions are needed */
|
|
|
|
next_free_sptr = sptr_array_ptr + 1;
|
|
do
|
|
{
|
|
sptr_array_ptr = sptr_array;
|
|
|
|
StillSubdividing = No; /* Assume not */
|
|
|
|
for(i = num_scans_s; i!=0; i--)
|
|
{
|
|
#if 0
|
|
/* z ratio of this scan */
|
|
if(sptr_array_ptr->ig3s_z1 > sptr_array_ptr->ig3s_z2)
|
|
{
|
|
z_ratio = (sptr_array_ptr->ig3s_z1 * 256) /
|
|
sptr_array_ptr->ig3s_z2;
|
|
}
|
|
else
|
|
{
|
|
z_ratio = (sptr_array_ptr->ig3s_z2 * 256) /
|
|
sptr_array_ptr->ig3s_z1;
|
|
}
|
|
/* Is it within the threshold? */
|
|
if(z_ratio > lin_s_zthr && num_scans_s < lin_s_max)
|
|
#endif
|
|
int overThreshold=0;
|
|
/* z ratio of this scan */
|
|
if(sptr_array_ptr->ig3s_z1 > sptr_array_ptr->ig3s_z2)
|
|
{
|
|
if ( (sptr_array_ptr->ig3s_z1 * 256) > (lin_s_zthr*sptr_array_ptr->ig3s_z2))
|
|
overThreshold=1;
|
|
}
|
|
else
|
|
{
|
|
if ( (sptr_array_ptr->ig3s_z2 * 256) > (lin_s_zthr*sptr_array_ptr->ig3s_z1))
|
|
overThreshold=1;
|
|
}
|
|
/* Is it within the threshold? */
|
|
if(overThreshold && num_scans_s < lin_s_max)
|
|
{
|
|
int mid_x, mid_c;
|
|
float mid_u, mid_v, mid_z;
|
|
/* No - subdivide */
|
|
StillSubdividing = Yes;
|
|
|
|
mid_u = (sptr_array_ptr->ig3s_u1 + sptr_array_ptr->ig3s_u2) / 2;
|
|
|
|
mid_v = (sptr_array_ptr->ig3s_v1 + sptr_array_ptr->ig3s_v2) / 2;
|
|
|
|
mid_z = (sptr_array_ptr->ig3s_z1 + sptr_array_ptr->ig3s_z2) / 2;
|
|
|
|
mid_c = (sptr_array_ptr->ig3s_c1 + sptr_array_ptr->ig3s_c2) / 2;
|
|
|
|
mid_x = (sptr_array_ptr->ig3s_x1 + sptr_array_ptr->ig3s_x2) / 2;
|
|
|
|
/* Create new scan */
|
|
|
|
next_free_sptr->ig3s_u1 = mid_u;
|
|
next_free_sptr->ig3s_v1 = mid_v;
|
|
next_free_sptr->ig3s_z1 = mid_z;
|
|
next_free_sptr->ig3s_c1 = mid_c;
|
|
next_free_sptr->ig3s_x1 = mid_x;
|
|
next_free_sptr->ig3s_u2 = sptr_array_ptr->ig3s_u2;
|
|
next_free_sptr->ig3s_v2 = sptr_array_ptr->ig3s_v2;
|
|
next_free_sptr->ig3s_z2 = sptr_array_ptr->ig3s_z2;
|
|
next_free_sptr->ig3s_c2 = sptr_array_ptr->ig3s_c2;
|
|
next_free_sptr->ig3s_x2 = sptr_array_ptr->ig3s_x2;
|
|
next_free_sptr->ig3s_y = sptr_array_ptr->ig3s_y;
|
|
/* Redefine old scan */
|
|
|
|
sptr_array_ptr->ig3s_u2 = mid_u;
|
|
sptr_array_ptr->ig3s_v2 = mid_v;
|
|
sptr_array_ptr->ig3s_z2 = mid_z;
|
|
sptr_array_ptr->ig3s_c2 = mid_c;
|
|
sptr_array_ptr->ig3s_x2 = mid_x;
|
|
|
|
/* Update pointer and counter */
|
|
|
|
next_free_sptr++;
|
|
num_scans_s++;
|
|
|
|
}
|
|
sptr_array_ptr++;
|
|
}
|
|
|
|
}
|
|
while(StillSubdividing);
|
|
|
|
/* Draw the scan array */
|
|
sptr_array_ptr = sptr_array;
|
|
for(i = num_scans_s; i!=0; i--)
|
|
{
|
|
Draw3DScan(sptr_array_ptr,pheader);
|
|
sptr_array_ptr++;
|
|
}
|
|
}
|
|
}
|
|
sptr++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void KR_ScanDraw_Item_2dTexturePolygon_VideoModeType_8(int *itemptr)
|
|
{
|
|
POLYHEADER *pheader = (POLYHEADER *) itemptr;
|
|
if(NumScans)
|
|
{
|
|
if(pheader->PolyFlags & iflag_nolight)
|
|
{
|
|
int y;
|
|
I_2DTEXTUREPOLYGON_SCAN *sptr = (I_2DTEXTUREPOLYGON_SCAN *) ScanData;
|
|
|
|
/* Offset in Screen Buffer */
|
|
{
|
|
IMAGEHEADER *ImageHdr;
|
|
{
|
|
int TxIndex = ItemColour & ClrTxDefn;
|
|
ImageHdr = ImageHeaderPtrs[TxIndex];
|
|
}
|
|
if(ScreenDescriptorBlock.SDB_Flags & SDB_Flag_MIP && ImageHdr->ImageFlags & ih_flag_mip)
|
|
{
|
|
TEXTURE **TxImagePtr = &ImageHdr->ImagePtr;
|
|
SCASM_Bitmap = TxImagePtr[MIP_Index];
|
|
GLOBALASSERT(SCASM_Bitmap);
|
|
SCASM_TextureDeltaScan = ImageHdr->ImageWidth >> MIP_Index;
|
|
#if MIP_ROUNDUP
|
|
if (ImageHdr->ImageWidth & (1<<MIP_Index)-1) ++SCASM_TextureDeltaScan;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
SCASM_TextureDeltaScan = ImageHdr->ImageWidth;
|
|
SCASM_Bitmap = ImageHdr->ImagePtr;
|
|
GLOBALASSERT(SCASM_Bitmap);
|
|
}
|
|
}
|
|
|
|
/* Get the Image Data required for the Draw */
|
|
for(y=NumScans; y!=0; y--)
|
|
{
|
|
int dx = sptr->i2s_x2 - sptr->i2s_x1;
|
|
|
|
if (dx>0 && !(sptr->i2s_y & KRenderDrawMode) )
|
|
{
|
|
/* Fixed Point U for Interpolation */
|
|
{
|
|
int StartU = sptr->i2s_u1;
|
|
SCASM_DeltaU = (sptr->i2s_u2 - StartU)/dx;
|
|
SCASM_StartU = StartU;
|
|
}
|
|
|
|
/* Fixed Point V for Interpolation */
|
|
{
|
|
int StartV = sptr->i2s_v1;
|
|
SCASM_DeltaV = (sptr->i2s_v2 - StartV)/dx;
|
|
SCASM_StartV = StartV;
|
|
}
|
|
|
|
SCASM_Destination = ScreenBuffer + (sptr->i2s_y * BackBufferPitch) + sptr->i2s_x1;
|
|
SCASM_ScanLength = dx;
|
|
|
|
|
|
/* Is VDelta = 0? */
|
|
if(SCASM_DeltaV == 0)
|
|
{
|
|
if(pheader->PolyFlags & iflag_ignore0)
|
|
{
|
|
ScanDraw2D_VAlignedTransparent();
|
|
}
|
|
else
|
|
{
|
|
ScanDraw2D_VAlignedOpaque();
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if(pheader->PolyFlags & iflag_ignore0)
|
|
{
|
|
ScanDraw2D_Transparent();
|
|
}
|
|
else
|
|
{
|
|
ScanDraw2D_Opaque();
|
|
}
|
|
}
|
|
}
|
|
sptr++;
|
|
}
|
|
}
|
|
#if 1
|
|
else
|
|
{
|
|
int y;
|
|
I_2DTEXTUREPOLYGON_SCAN *sptr = (I_2DTEXTUREPOLYGON_SCAN *) ScanData;
|
|
/* Offset in Screen Buffer */
|
|
{
|
|
IMAGEHEADER *ImageHdr;
|
|
{
|
|
int TxIndex = ItemColour & ClrTxDefn;
|
|
ImageHdr = ImageHeaderPtrs[TxIndex];
|
|
}
|
|
if(ScreenDescriptorBlock.SDB_Flags & SDB_Flag_MIP && ImageHdr->ImageFlags & ih_flag_mip)
|
|
{
|
|
TEXTURE **TxImagePtr = &ImageHdr->ImagePtr;
|
|
SCASM_Bitmap = TxImagePtr[MIP_Index];
|
|
GLOBALASSERT(SCASM_Bitmap);
|
|
SCASM_TextureDeltaScan = ImageHdr->ImageWidth >> MIP_Index;
|
|
#if MIP_ROUNDUP
|
|
if (ImageHdr->ImageWidth & (1<<MIP_Index)-1) ++SCASM_TextureDeltaScan;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
SCASM_TextureDeltaScan = ImageHdr->ImageWidth;
|
|
SCASM_Bitmap = ImageHdr->ImagePtr;
|
|
GLOBALASSERT(SCASM_Bitmap);
|
|
}
|
|
}
|
|
SCASM_StartI = ItemColour >> TxDefn;
|
|
|
|
SCASM_Lighting = TextureLightingTable;
|
|
|
|
if(ScreenDescriptorBlock.SDB_Flags & SDB_Flag_Raw256) SCASM_ShadingTableSize = 256;
|
|
else SCASM_ShadingTableSize = 64;
|
|
|
|
|
|
/* Get the Image Data required for the Draw */
|
|
for(y=NumScans; y!=0; y--)
|
|
{
|
|
int dx = sptr->i2s_x2 - sptr->i2s_x1;
|
|
if (dx>0 && !(sptr->i2s_y & KRenderDrawMode) )
|
|
{
|
|
/* Fixed Point U for Interpolation */
|
|
{
|
|
int StartU = sptr->i2s_u1;
|
|
SCASM_DeltaU = (sptr->i2s_u2 - StartU)/dx;
|
|
SCASM_StartU = StartU;
|
|
}
|
|
|
|
/* Fixed Point V for Interpolation */
|
|
{
|
|
int StartV = sptr->i2s_v1;
|
|
SCASM_DeltaV = (sptr->i2s_v2 - StartV)/dx;
|
|
SCASM_StartV = StartV;
|
|
}
|
|
|
|
SCASM_Destination = ScreenBuffer + (sptr->i2s_y * BackBufferPitch) + sptr->i2s_x1;
|
|
SCASM_ScanLength = dx;
|
|
|
|
ScanDraw2D_TransparentLit();
|
|
// PredatorScanDraw();
|
|
}
|
|
sptr++;
|
|
}
|
|
|
|
|
|
}
|
|
#endif
|
|
}
|
|
|
|
}
|
|
unsigned char LighterTable[255];
|
|
int predatorTimer = 0;
|
|
void ScanDraw_CloakedScan(void)
|
|
{
|
|
unsigned char *screen = SCASM_Destination;
|
|
int x = SCASM_ScanLength;
|
|
|
|
unsigned char buffer[1000];
|
|
do
|
|
{
|
|
buffer[x] = *screen++;
|
|
}
|
|
while(--x);
|
|
|
|
screen = SCASM_Destination;
|
|
x = SCASM_ScanLength;
|
|
|
|
if (FastRandom()&3==3 && x>2)
|
|
{
|
|
x--;
|
|
screen++;
|
|
}
|
|
if (FastRandom()&3==3 && x>2)
|
|
{
|
|
x--;
|
|
}
|
|
|
|
do
|
|
{
|
|
{
|
|
extern sine[];
|
|
extern cosine[];
|
|
unsigned char colour;
|
|
int offset = (GetCos( ((x*2047)/SCASM_ScanLength + predatorTimer)&4095 )+65536)/2;
|
|
offset = MUL_FIXED(offset,offset);
|
|
colour = (buffer[SCASM_ScanLength-x+1]);
|
|
// colour = (buffer[x]);
|
|
#if 0
|
|
int i;
|
|
for (i=0; i<=255;i++)
|
|
{
|
|
if (colour==*(TextureLightingTable + 256*200 + i)) break;
|
|
}
|
|
#endif
|
|
colour=*(TextureLightingTable + 256*(60+MUL_FIXED(4,GetCos(predatorTimer&4095)) ) + colour);
|
|
*screen++ = colour;
|
|
|
|
}
|
|
}
|
|
while(--x);
|
|
|
|
}
|
|
#if 0
|
|
void PredatorScanDraw(void)
|
|
{
|
|
unsigned char *screen = SCASM_Destination;
|
|
unsigned char *source;
|
|
|
|
do
|
|
{
|
|
source = SCASM_Bitmap+ (SCASM_StartU>>16) + (SCASM_StartV>>16)*SCASM_TextureDeltaScan;
|
|
|
|
*screen++ = *source++;
|
|
|
|
SCASM_StartU += SCASM_DeltaU;
|
|
SCASM_StartV += SCASM_DeltaV;
|
|
}
|
|
while(--SCASM_ScanLength);
|
|
|
|
}
|
|
#else
|
|
void PredatorScanDraw(void)
|
|
{
|
|
unsigned char *screen = SCASM_Destination;
|
|
unsigned char *source;
|
|
int x = SCASM_ScanLength;
|
|
do
|
|
{
|
|
source = SCASM_Bitmap+ (SCASM_StartU>>16) + (SCASM_StartV>>16)*SCASM_TextureDeltaScan;
|
|
|
|
if (*source)
|
|
{
|
|
extern sine[];
|
|
extern cosine[];
|
|
unsigned char colour = *(screen);
|
|
*screen = LighterTable[colour];
|
|
}
|
|
screen++;
|
|
SCASM_StartU += SCASM_DeltaU;
|
|
SCASM_StartV += SCASM_DeltaV;
|
|
}
|
|
while(--x);
|
|
|
|
}
|
|
#endif
|
|
|
|
void Draw_Item_CloakedPolygon(int *itemptr)
|
|
{
|
|
POLYHEADER *pheader = (POLYHEADER *)itemptr;
|
|
int minYVertex = 0;
|
|
int maxYVertex = 0;
|
|
int maxVertexNum = 0;
|
|
|
|
{
|
|
I_GOURAUDPOLYGON_PT *vertexPtr = (I_GOURAUDPOLYGON_PT*)&pheader->Poly1stPt;
|
|
int minY = vertexPtr->i_y;
|
|
int maxY = vertexPtr->i_y;
|
|
vertexPtr++;
|
|
|
|
do
|
|
{
|
|
maxVertexNum++;
|
|
|
|
if (minY > vertexPtr->i_y)
|
|
{
|
|
minY = vertexPtr->i_y;
|
|
minYVertex = maxVertexNum;
|
|
}
|
|
else if (maxY < vertexPtr->i_y)
|
|
{
|
|
maxY = vertexPtr->i_y;
|
|
maxYVertex = maxVertexNum;
|
|
}
|
|
vertexPtr++;
|
|
}
|
|
while(vertexPtr->i_x != Term);
|
|
|
|
}
|
|
|
|
|
|
/* Initialise the Scan Data Buffer */
|
|
{
|
|
I_GOURAUDPOLYGON_PT *vertexPtr = (I_GOURAUDPOLYGON_PT*)&pheader->Poly1stPt;
|
|
I_GOURAUDPOLYGON_SCAN *polyScan;
|
|
int curVertex;
|
|
int SecondOpinion=0;
|
|
|
|
NumScans=0;
|
|
/* scan out the right edge */
|
|
polyScan = (I_GOURAUDPOLYGON_SCAN*)ScanData;
|
|
curVertex = minYVertex;
|
|
do
|
|
{
|
|
int height;
|
|
int i,x,y;
|
|
int deltaX,deltaI;
|
|
|
|
int nextVertex = curVertex-1;
|
|
if (nextVertex<0) nextVertex = maxVertexNum;
|
|
|
|
height = vertexPtr[nextVertex].i_y - vertexPtr[curVertex].i_y;
|
|
if (height!=0)
|
|
{
|
|
int width = vertexPtr[nextVertex].i_x - vertexPtr[curVertex].i_x;
|
|
int contrast = vertexPtr[nextVertex].i_int - vertexPtr[curVertex].i_int;
|
|
|
|
deltaX = (width<<16)/height;
|
|
deltaI = contrast/height;
|
|
|
|
x = vertexPtr[curVertex].i_x<<16;
|
|
i = vertexPtr[curVertex].i_int;
|
|
|
|
for (y=vertexPtr[curVertex].i_y; y<vertexPtr[nextVertex].i_y; y++)
|
|
{
|
|
polyScan->igs_x2 = x>>16;
|
|
x+=deltaX;
|
|
polyScan->igs_c2 = i;
|
|
i+=deltaI;
|
|
|
|
polyScan->igs_y = y;
|
|
NumScans++;
|
|
polyScan++;
|
|
}
|
|
}
|
|
curVertex--;
|
|
if (curVertex<0) curVertex = maxVertexNum;
|
|
|
|
}
|
|
while(curVertex!=maxYVertex);
|
|
|
|
/* scan out the left edge */
|
|
polyScan = (I_GOURAUDPOLYGON_SCAN*)ScanData;
|
|
curVertex = minYVertex;
|
|
do
|
|
{
|
|
int height;
|
|
int i,x,y;
|
|
int deltaX,deltaI;
|
|
|
|
int nextVertex = curVertex+1;
|
|
if (nextVertex>maxVertexNum) nextVertex = 0;
|
|
|
|
height = vertexPtr[nextVertex].i_y - vertexPtr[curVertex].i_y;
|
|
if (height!=0)
|
|
{
|
|
int width = vertexPtr[nextVertex].i_x - vertexPtr[curVertex].i_x;
|
|
int contrast = vertexPtr[nextVertex].i_int - vertexPtr[curVertex].i_int;
|
|
|
|
deltaX = (width<<16)/height;
|
|
deltaI = contrast/height;
|
|
|
|
x = vertexPtr[curVertex].i_x<<16;
|
|
i = vertexPtr[curVertex].i_int;
|
|
|
|
for (y=vertexPtr[curVertex].i_y; y<vertexPtr[nextVertex].i_y; y++)
|
|
{
|
|
polyScan->igs_x1 = x>>16;
|
|
x+=deltaX;
|
|
polyScan->igs_c1 = i;
|
|
i+=deltaI;
|
|
|
|
SecondOpinion++;
|
|
polyScan++;
|
|
}
|
|
}
|
|
curVertex++;
|
|
if (curVertex>maxVertexNum) curVertex = 0;
|
|
|
|
}
|
|
while(curVertex!=maxYVertex);
|
|
|
|
if (SecondOpinion<NumScans)
|
|
{
|
|
textprint("WARNING: Rasterization error\n");
|
|
NumScans = SecondOpinion;
|
|
// LOCALASSERT(0);
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
//draw 'em
|
|
|
|
{
|
|
unsigned char colour= pheader->PolyColour;
|
|
I_GOURAUDPOLYGON_SCAN *polyScan;
|
|
polyScan = (I_GOURAUDPOLYGON_SCAN*)ScanData;
|
|
SCASM_Lighting = TextureLightingTable+colour;
|
|
SCASM_ShadingTableSize = 256;
|
|
|
|
while(NumScans)
|
|
{
|
|
int dx = polyScan->igs_x2 - polyScan->igs_x1;
|
|
if (dx>0)
|
|
{
|
|
SCASM_Destination = ScreenBuffer+(polyScan->igs_y * BackBufferPitch) + polyScan->igs_x1;
|
|
SCASM_ScanLength = dx;
|
|
SCASM_DeltaI = (polyScan->igs_c2-polyScan->igs_c1)/dx;
|
|
SCASM_StartI = polyScan->igs_c1;
|
|
ScanDraw_CloakedScan();
|
|
}
|
|
NumScans--;
|
|
polyScan++;
|
|
}
|
|
}
|
|
}
|
|
#if 1
|
|
void KDraw_Item_GouraudPolygon(int *itemptr)
|
|
{
|
|
POLYHEADER *pheader = (POLYHEADER *)itemptr;
|
|
int minYVertex = 0;
|
|
int maxYVertex = 0;
|
|
int maxVertexNum = 0;
|
|
|
|
{
|
|
I_GOURAUDPOLYGON_PT *vertexPtr = (I_GOURAUDPOLYGON_PT*)&pheader->Poly1stPt;
|
|
int minY = vertexPtr->i_y;
|
|
int maxY = vertexPtr->i_y;
|
|
vertexPtr++;
|
|
|
|
do
|
|
{
|
|
maxVertexNum++;
|
|
|
|
if (minY > vertexPtr->i_y)
|
|
{
|
|
minY = vertexPtr->i_y;
|
|
minYVertex = maxVertexNum;
|
|
}
|
|
else if (maxY < vertexPtr->i_y)
|
|
{
|
|
maxY = vertexPtr->i_y;
|
|
maxYVertex = maxVertexNum;
|
|
}
|
|
vertexPtr++;
|
|
}
|
|
while(vertexPtr->i_x != Term);
|
|
|
|
}
|
|
|
|
|
|
/* Initialise the Scan Data Buffer */
|
|
{
|
|
I_GOURAUDPOLYGON_PT *vertexPtr = (I_GOURAUDPOLYGON_PT*)&pheader->Poly1stPt;
|
|
I_GOURAUDPOLYGON_SCAN *polyScan;
|
|
int curVertex;
|
|
int SecondOpinion=0;
|
|
|
|
NumScans=0;
|
|
/* scan out the right edge */
|
|
polyScan = (I_GOURAUDPOLYGON_SCAN*)ScanData;
|
|
curVertex = minYVertex;
|
|
do
|
|
{
|
|
int height;
|
|
int i,x,y;
|
|
int deltaX,deltaI;
|
|
|
|
int nextVertex = curVertex-1;
|
|
if (nextVertex<0) nextVertex = maxVertexNum;
|
|
|
|
height = vertexPtr[nextVertex].i_y - vertexPtr[curVertex].i_y;
|
|
if (height!=0)
|
|
{
|
|
int width = vertexPtr[nextVertex].i_x - vertexPtr[curVertex].i_x;
|
|
int contrast = vertexPtr[nextVertex].i_int - vertexPtr[curVertex].i_int;
|
|
|
|
deltaX = (width<<16)/height;
|
|
deltaI = contrast/height;
|
|
|
|
x = vertexPtr[curVertex].i_x<<16;
|
|
i = vertexPtr[curVertex].i_int;
|
|
|
|
for (y=vertexPtr[curVertex].i_y; y<vertexPtr[nextVertex].i_y; y++)
|
|
{
|
|
polyScan->igs_x2 = x>>16;
|
|
x+=deltaX;
|
|
polyScan->igs_c2 = i;
|
|
i+=deltaI;
|
|
|
|
polyScan->igs_y = y;
|
|
NumScans++;
|
|
polyScan++;
|
|
}
|
|
}
|
|
curVertex--;
|
|
if (curVertex<0) curVertex = maxVertexNum;
|
|
|
|
}
|
|
while(curVertex!=maxYVertex);
|
|
|
|
/* scan out the left edge */
|
|
polyScan = (I_GOURAUDPOLYGON_SCAN*)ScanData;
|
|
curVertex = minYVertex;
|
|
do
|
|
{
|
|
int height;
|
|
int i,x,y;
|
|
int deltaX,deltaI;
|
|
|
|
int nextVertex = curVertex+1;
|
|
if (nextVertex>maxVertexNum) nextVertex = 0;
|
|
|
|
height = vertexPtr[nextVertex].i_y - vertexPtr[curVertex].i_y;
|
|
if (height!=0)
|
|
{
|
|
int width = vertexPtr[nextVertex].i_x - vertexPtr[curVertex].i_x;
|
|
int contrast = vertexPtr[nextVertex].i_int - vertexPtr[curVertex].i_int;
|
|
|
|
deltaX = (width<<16)/height;
|
|
deltaI = contrast/height;
|
|
|
|
x = vertexPtr[curVertex].i_x<<16;
|
|
i = vertexPtr[curVertex].i_int;
|
|
|
|
for (y=vertexPtr[curVertex].i_y; y<vertexPtr[nextVertex].i_y; y++)
|
|
{
|
|
polyScan->igs_x1 = x>>16;
|
|
x+=deltaX;
|
|
polyScan->igs_c1 = i;
|
|
i+=deltaI;
|
|
|
|
SecondOpinion++;
|
|
polyScan++;
|
|
}
|
|
}
|
|
curVertex++;
|
|
if (curVertex>maxVertexNum) curVertex = 0;
|
|
|
|
}
|
|
while(curVertex!=maxYVertex);
|
|
|
|
if (SecondOpinion<NumScans)
|
|
{
|
|
textprint("WARNING: Rasterization error\n");
|
|
NumScans = SecondOpinion;
|
|
// LOCALASSERT(0);
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
//draw 'em
|
|
|
|
{
|
|
unsigned char colour= pheader->PolyColour;
|
|
I_GOURAUDPOLYGON_SCAN *polyScan;
|
|
polyScan = (I_GOURAUDPOLYGON_SCAN*)ScanData;
|
|
SCASM_Lighting = TextureLightingTable+colour;
|
|
SCASM_ShadingTableSize = 256;
|
|
|
|
while(NumScans)
|
|
{
|
|
int dx = polyScan->igs_x2 - polyScan->igs_x1;
|
|
if (dx>0)
|
|
{
|
|
SCASM_Destination = ScreenBuffer+(polyScan->igs_y * BackBufferPitch) + polyScan->igs_x1;
|
|
SCASM_ScanLength = dx;
|
|
SCASM_DeltaI = (polyScan->igs_c2-polyScan->igs_c1)/dx;
|
|
SCASM_StartI = polyScan->igs_c1;
|
|
ScanDraw_GouraudScan();
|
|
}
|
|
NumScans--;
|
|
polyScan++;
|
|
}
|
|
}
|
|
}
|
|
void KDraw_Item_2dTexturePolygon(int *itemptr)
|
|
{
|
|
|
|
POLYHEADER *pheader = (POLYHEADER *) itemptr;
|
|
int TxIndex;
|
|
IMAGEHEADER *ImageHdr;
|
|
ItemColour = pheader->PolyColour;
|
|
|
|
TxIndex = ItemColour & ClrTxDefn;
|
|
ImageHdr = ImageHeaderPtrs[TxIndex];
|
|
|
|
|
|
/* Colour */
|
|
|
|
/* If MIP Mapping, calculate the scale */
|
|
|
|
if(ScreenDescriptorBlock.SDB_Flags & SDB_Flag_MIP && ImageHdr->ImageFlags & ih_flag_mip)
|
|
{
|
|
I_2DTEXTUREPOLYGON_PT *vector1;
|
|
I_2DTEXTUREPOLYGON_PT *vector2;
|
|
I_2DTEXTUREPOLYGON_PT *vector3;
|
|
int mip1, mip2;
|
|
int xyd, uvd;
|
|
VECTOR2D s0, s1;
|
|
VECTOR2D t0, t1;
|
|
|
|
|
|
/* Screen and Texture Space Vectors */
|
|
/* Express the "uvd / xyd" ratio as a binary scale */
|
|
|
|
vector1 = (I_2DTEXTUREPOLYGON_PT *) &pheader->Poly1stPt;
|
|
vector2 = &vector1[1];
|
|
vector3 = &vector1[2];
|
|
|
|
|
|
/* Vector 1 */
|
|
|
|
s0.vx = vector1->i_x;
|
|
s0.vy = vector1->i_y;
|
|
s1.vx = vector2->i_x;
|
|
s1.vy = vector2->i_y;
|
|
|
|
t0.vx = vector1->i_u >> 16;
|
|
t0.vy = vector1->i_v >> 16;
|
|
t1.vx = vector2->i_u >> 16;
|
|
t1.vy = vector2->i_v >> 16;
|
|
|
|
xyd = FandVD_Distance_2d(&s0, &s1);
|
|
uvd = FandVD_Distance_2d(&t0, &t1);
|
|
|
|
mip1 = FindShift32(uvd, xyd);
|
|
|
|
|
|
/* Vector 2 */
|
|
|
|
s0.vx = vector2->i_x;
|
|
s0.vy = vector2->i_y;
|
|
s1.vx = vector3->i_x;
|
|
s1.vy = vector3->i_y;
|
|
|
|
t0.vx = t1.vx;
|
|
t0.vy = t1.vy;
|
|
t1.vx = vector3->i_u >> 16;
|
|
t1.vy = vector3->i_v >> 16;
|
|
|
|
xyd = FandVD_Distance_2d(&s0, &s1);
|
|
uvd = FandVD_Distance_2d(&t0, &t1);
|
|
|
|
mip2 = FindShift32(uvd, xyd);
|
|
|
|
|
|
/* Choose the larger of the two */
|
|
|
|
if(pheader->PolyFlags & iflag_no_mip) {
|
|
|
|
MIP_Index = 0;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
#if UseMIPMax
|
|
if(mip1 > mip2)
|
|
MIP_Index = mip1;
|
|
else
|
|
MIP_Index = mip2;
|
|
#endif
|
|
|
|
#if UseMIPMin
|
|
if(mip1 > mip2)
|
|
MIP_Index = mip2;
|
|
else
|
|
MIP_Index = mip1;
|
|
#endif
|
|
|
|
#if UseMIPAvg
|
|
MIP_Index = (mip1 + mip2) >> 1;
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
/* Clamp "MIP_Index" */
|
|
|
|
#if MIP_INDEX_SUBTRACT
|
|
|
|
MIP_Index -= MIP_INDEX_SUBTRACT;
|
|
if(MIP_Index < 0) MIP_Index = 0;
|
|
else if(MIP_Index > 6) MIP_Index = 6;
|
|
|
|
#else
|
|
|
|
if(MIP_Index > 6) MIP_Index = 6;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
{
|
|
int minYVertex = 0;
|
|
int maxYVertex = 0;
|
|
int maxVertexNum = 0;
|
|
|
|
{
|
|
I_2DTEXTUREPOLYGON_PT *vertexPtr = (I_2DTEXTUREPOLYGON_PT*)&pheader->Poly1stPt;
|
|
int minY = vertexPtr->i_y;
|
|
int maxY = vertexPtr->i_y;
|
|
|
|
if(ScreenDescriptorBlock.SDB_Flags & SDB_Flag_MIP && ImageHdr->ImageFlags & ih_flag_mip)
|
|
{
|
|
vertexPtr->i_u >>= MIP_Index;
|
|
vertexPtr->i_v >>= MIP_Index;
|
|
}
|
|
vertexPtr++;
|
|
|
|
do
|
|
{
|
|
maxVertexNum++;
|
|
|
|
if (minY > vertexPtr->i_y)
|
|
{
|
|
minY = vertexPtr->i_y;
|
|
minYVertex = maxVertexNum;
|
|
}
|
|
else if (maxY < vertexPtr->i_y)
|
|
{
|
|
maxY = vertexPtr->i_y;
|
|
maxYVertex = maxVertexNum;
|
|
}
|
|
|
|
if(ScreenDescriptorBlock.SDB_Flags & SDB_Flag_MIP && ImageHdr->ImageFlags & ih_flag_mip)
|
|
{
|
|
vertexPtr->i_u >>= MIP_Index;
|
|
vertexPtr->i_v >>= MIP_Index;
|
|
}
|
|
|
|
vertexPtr++;
|
|
}
|
|
while(vertexPtr->i_x != Term);
|
|
|
|
}
|
|
|
|
|
|
/* Initialise the Scan Data Buffer */
|
|
{
|
|
I_2DTEXTUREPOLYGON_PT *vertexPtr = (I_2DTEXTUREPOLYGON_PT*)&pheader->Poly1stPt;
|
|
I_2DTEXTUREPOLYGON_SCAN *polyScan;
|
|
int curVertex;
|
|
int SecondOpinion = 0;
|
|
|
|
NumScans=0;
|
|
/* scan out the right edge */
|
|
polyScan = (I_2DTEXTUREPOLYGON_SCAN*)ScanData;
|
|
curVertex = minYVertex;
|
|
do
|
|
{
|
|
int height;
|
|
|
|
int nextVertex = curVertex-1;
|
|
if (nextVertex<0) nextVertex = maxVertexNum;
|
|
|
|
height = vertexPtr[nextVertex].i_y - vertexPtr[curVertex].i_y;
|
|
if (height!=0)
|
|
{
|
|
int x,y,u,v;
|
|
int deltaX,deltaU,deltaV;
|
|
int width = vertexPtr[nextVertex].i_x - vertexPtr[curVertex].i_x;
|
|
int widthU = vertexPtr[nextVertex].i_u - vertexPtr[curVertex].i_u;
|
|
int widthV = vertexPtr[nextVertex].i_v - vertexPtr[curVertex].i_v;
|
|
|
|
deltaX = (width<<16)/height;
|
|
deltaU = widthU/height;
|
|
deltaV = widthV/height;
|
|
|
|
x = vertexPtr[curVertex].i_x<<16;
|
|
u = vertexPtr[curVertex].i_u;
|
|
v = vertexPtr[curVertex].i_v;
|
|
|
|
for (y=vertexPtr[curVertex].i_y; y<vertexPtr[nextVertex].i_y; y++)
|
|
{
|
|
polyScan->i2s_x2 = x>>16;
|
|
x+=deltaX;
|
|
polyScan->i2s_u2 = u;
|
|
u+=deltaU;
|
|
polyScan->i2s_v2 = v;
|
|
v+=deltaV;
|
|
|
|
polyScan->i2s_y = y;
|
|
NumScans++;
|
|
polyScan++;
|
|
}
|
|
}
|
|
curVertex--;
|
|
if (curVertex<0) curVertex = maxVertexNum;
|
|
|
|
}
|
|
while(curVertex!=maxYVertex);
|
|
|
|
/* scan out the left edge */
|
|
polyScan = (I_2DTEXTUREPOLYGON_SCAN*)ScanData;
|
|
curVertex = minYVertex;
|
|
do
|
|
{
|
|
int height;
|
|
|
|
int nextVertex = curVertex+1;
|
|
if (nextVertex>maxVertexNum) nextVertex = 0;
|
|
|
|
height = vertexPtr[nextVertex].i_y - vertexPtr[curVertex].i_y;
|
|
if (height!=0)
|
|
{
|
|
int x,y,u,v;
|
|
int deltaX,deltaU,deltaV;
|
|
int width = vertexPtr[nextVertex].i_x - vertexPtr[curVertex].i_x;
|
|
int widthU = vertexPtr[nextVertex].i_u - vertexPtr[curVertex].i_u;
|
|
int widthV = vertexPtr[nextVertex].i_v - vertexPtr[curVertex].i_v;
|
|
|
|
deltaX = (width<<16)/height;
|
|
deltaU = widthU/height;
|
|
deltaV = widthV/height;
|
|
|
|
x = vertexPtr[curVertex].i_x<<16;
|
|
u = vertexPtr[curVertex].i_u;
|
|
v = vertexPtr[curVertex].i_v;
|
|
|
|
for (y=vertexPtr[curVertex].i_y; y<vertexPtr[nextVertex].i_y; y++)
|
|
{
|
|
polyScan->i2s_x1 = x>>16;
|
|
x+=deltaX;
|
|
polyScan->i2s_u1 = u;
|
|
u+=deltaU;
|
|
polyScan->i2s_v1 = v;
|
|
v+=deltaV;
|
|
|
|
SecondOpinion++;
|
|
polyScan++;
|
|
}
|
|
}
|
|
curVertex++;
|
|
if (curVertex>maxVertexNum) curVertex = 0;
|
|
|
|
}
|
|
while(curVertex!=maxYVertex);
|
|
|
|
if (SecondOpinion<NumScans)
|
|
{
|
|
textprint("WARNING: Rasterization error\n");
|
|
NumScans = SecondOpinion;
|
|
// LOCALASSERT(0);
|
|
return;
|
|
}
|
|
}
|
|
|
|
//draw 'em
|
|
KR_ScanDraw_Item_2dTexturePolygon_VideoModeType_8(itemptr);
|
|
|
|
}
|
|
}
|
|
void KDraw_Item_Gouraud2dTexturePolygon(int *itemptr)
|
|
{
|
|
POLYHEADER *pheader = (POLYHEADER *) itemptr;
|
|
int TxIndex;
|
|
IMAGEHEADER *ImageHdr;
|
|
ItemColour = pheader->PolyColour;
|
|
|
|
TxIndex = ItemColour & ClrTxDefn;
|
|
ImageHdr = ImageHeaderPtrs[TxIndex];
|
|
|
|
|
|
|
|
/* Colour */
|
|
|
|
|
|
/* If MIP Mapping, calculate the scale */
|
|
|
|
if(ScreenDescriptorBlock.SDB_Flags & SDB_Flag_MIP && ImageHdr->ImageFlags & ih_flag_mip)
|
|
{
|
|
I_GOURAUD2DTEXTUREPOLYGON_PT *vector1;
|
|
I_GOURAUD2DTEXTUREPOLYGON_PT *vector2;
|
|
I_GOURAUD2DTEXTUREPOLYGON_PT *vector3;
|
|
int mip1, mip2;
|
|
int xyd, uvd;
|
|
VECTOR2D s0, s1;
|
|
VECTOR2D t0, t1;
|
|
|
|
|
|
/* Screen and Texture Space Vectors */
|
|
/* Express the "uvd / xyd" ratio as a binary scale */
|
|
|
|
vector1 = (I_GOURAUD2DTEXTUREPOLYGON_PT *) &pheader->Poly1stPt;
|
|
vector2 = &vector1[1];
|
|
vector3 = &vector1[2];
|
|
|
|
|
|
/* Vector 1 */
|
|
|
|
s0.vx = vector1->i_x;
|
|
s0.vy = vector1->i_y;
|
|
s1.vx = vector2->i_x;
|
|
s1.vy = vector2->i_y;
|
|
|
|
t0.vx = vector1->i_u >> 16;
|
|
t0.vy = vector1->i_v >> 16;
|
|
t1.vx = vector2->i_u >> 16;
|
|
t1.vy = vector2->i_v >> 16;
|
|
|
|
xyd = FandVD_Distance_2d(&s0, &s1);
|
|
uvd = FandVD_Distance_2d(&t0, &t1);
|
|
|
|
mip1 = FindShift32(uvd, xyd);
|
|
|
|
|
|
/* Vector 2 */
|
|
|
|
s0.vx = vector2->i_x;
|
|
s0.vy = vector2->i_y;
|
|
s1.vx = vector3->i_x;
|
|
s1.vy = vector3->i_y;
|
|
|
|
t0.vx = t1.vx;
|
|
t0.vy = t1.vy;
|
|
t1.vx = vector3->i_u >> 16;
|
|
t1.vy = vector3->i_v >> 16;
|
|
|
|
xyd = FandVD_Distance_2d(&s0, &s1);
|
|
uvd = FandVD_Distance_2d(&t0, &t1);
|
|
|
|
mip2 = FindShift32(uvd, xyd);
|
|
|
|
|
|
/* Choose the larger of the two */
|
|
|
|
if(pheader->PolyFlags & iflag_no_mip) {
|
|
|
|
MIP_Index = 0;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
#if UseMIPMax
|
|
if(mip1 > mip2)
|
|
MIP_Index = mip1;
|
|
else
|
|
MIP_Index = mip2;
|
|
#endif
|
|
|
|
#if UseMIPMin
|
|
if(mip1 > mip2)
|
|
MIP_Index = mip2;
|
|
else
|
|
MIP_Index = mip1;
|
|
#endif
|
|
|
|
#if UseMIPAvg
|
|
MIP_Index = (mip1 + mip2) >> 1;
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
/* Clamp "MIP_Index" */
|
|
|
|
#if MIP_INDEX_SUBTRACT
|
|
|
|
MIP_Index -= MIP_INDEX_SUBTRACT;
|
|
if(MIP_Index < 0) MIP_Index = 0;
|
|
else if(MIP_Index > 6) MIP_Index = 6;
|
|
|
|
#else
|
|
|
|
if(MIP_Index > 6) MIP_Index = 6;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
{
|
|
int minYVertex = 0;
|
|
int maxYVertex = 0;
|
|
int maxVertexNum = 0;
|
|
|
|
{
|
|
I_GOURAUD2DTEXTUREPOLYGON_PT *vertexPtr = (I_GOURAUD2DTEXTUREPOLYGON_PT*)&pheader->Poly1stPt;
|
|
int minY = vertexPtr->i_y;
|
|
int maxY = vertexPtr->i_y;
|
|
|
|
if(ScreenDescriptorBlock.SDB_Flags & SDB_Flag_MIP && ImageHdr->ImageFlags & ih_flag_mip)
|
|
{
|
|
vertexPtr->i_u >>= MIP_Index;
|
|
vertexPtr->i_v >>= MIP_Index;
|
|
}
|
|
vertexPtr++;
|
|
|
|
do
|
|
{
|
|
maxVertexNum++;
|
|
|
|
if (minY > vertexPtr->i_y)
|
|
{
|
|
minY = vertexPtr->i_y;
|
|
minYVertex = maxVertexNum;
|
|
}
|
|
else if (maxY < vertexPtr->i_y)
|
|
{
|
|
maxY = vertexPtr->i_y;
|
|
maxYVertex = maxVertexNum;
|
|
}
|
|
|
|
if(ScreenDescriptorBlock.SDB_Flags & SDB_Flag_MIP && ImageHdr->ImageFlags & ih_flag_mip)
|
|
{
|
|
vertexPtr->i_u >>= MIP_Index;
|
|
vertexPtr->i_v >>= MIP_Index;
|
|
}
|
|
|
|
vertexPtr++;
|
|
}
|
|
while(vertexPtr->i_x != Term);
|
|
|
|
}
|
|
|
|
|
|
/* Initialise the Scan Data Buffer */
|
|
{
|
|
I_GOURAUD2DTEXTUREPOLYGON_PT *vertexPtr = (I_GOURAUD2DTEXTUREPOLYGON_PT*)&pheader->Poly1stPt;
|
|
I_GOURAUD2DTEXTUREPOLYGON_SCAN *polyScan;
|
|
int curVertex;
|
|
int SecondOpinion=0;
|
|
|
|
NumScans=0;
|
|
/* scan out the right edge */
|
|
polyScan = (I_GOURAUD2DTEXTUREPOLYGON_SCAN*)ScanData;
|
|
curVertex = minYVertex;
|
|
do
|
|
{
|
|
int height;
|
|
|
|
int nextVertex = curVertex-1;
|
|
if (nextVertex<0) nextVertex = maxVertexNum;
|
|
|
|
height = vertexPtr[nextVertex].i_y - vertexPtr[curVertex].i_y;
|
|
if (height!=0)
|
|
{
|
|
int i,x,y,u,v;
|
|
int deltaX,deltaI,deltaU,deltaV;
|
|
int width = vertexPtr[nextVertex].i_x - vertexPtr[curVertex].i_x;
|
|
int contrast = vertexPtr[nextVertex].i_i - vertexPtr[curVertex].i_i;
|
|
int widthU = vertexPtr[nextVertex].i_u - vertexPtr[curVertex].i_u;
|
|
int widthV = vertexPtr[nextVertex].i_v - vertexPtr[curVertex].i_v;
|
|
|
|
deltaX = (width<<16)/height;
|
|
deltaI = contrast/height;
|
|
deltaU = widthU/height;
|
|
deltaV = widthV/height;
|
|
|
|
x = vertexPtr[curVertex].i_x<<16;
|
|
i = vertexPtr[curVertex].i_i;
|
|
u = vertexPtr[curVertex].i_u;
|
|
v = vertexPtr[curVertex].i_v;
|
|
|
|
for (y=vertexPtr[curVertex].i_y; y<vertexPtr[nextVertex].i_y; y++)
|
|
{
|
|
polyScan->ig2s_x2 = x>>16;
|
|
x+=deltaX;
|
|
polyScan->ig2s_c2 = i;
|
|
i+=deltaI;
|
|
polyScan->ig2s_u2 = u;
|
|
u+=deltaU;
|
|
polyScan->ig2s_v2 = v;
|
|
v+=deltaV;
|
|
|
|
polyScan->ig2s_y = y;
|
|
NumScans++;
|
|
polyScan++;
|
|
}
|
|
}
|
|
curVertex--;
|
|
if (curVertex<0) curVertex = maxVertexNum;
|
|
|
|
}
|
|
while(curVertex!=maxYVertex);
|
|
|
|
/* scan out the left edge */
|
|
polyScan = (I_GOURAUD2DTEXTUREPOLYGON_SCAN*)ScanData;
|
|
curVertex = minYVertex;
|
|
do
|
|
{
|
|
int height;
|
|
|
|
int nextVertex = curVertex+1;
|
|
if (nextVertex>maxVertexNum) nextVertex = 0;
|
|
|
|
height = vertexPtr[nextVertex].i_y - vertexPtr[curVertex].i_y;
|
|
if (height!=0)
|
|
{
|
|
int i,x,y,u,v;
|
|
int deltaX,deltaI,deltaU,deltaV;
|
|
int width = vertexPtr[nextVertex].i_x - vertexPtr[curVertex].i_x;
|
|
int contrast = vertexPtr[nextVertex].i_i - vertexPtr[curVertex].i_i;
|
|
int widthU = vertexPtr[nextVertex].i_u - vertexPtr[curVertex].i_u;
|
|
int widthV = vertexPtr[nextVertex].i_v - vertexPtr[curVertex].i_v;
|
|
|
|
deltaX = (width<<16)/height;
|
|
deltaI = contrast/height;
|
|
deltaU = widthU/height;
|
|
deltaV = widthV/height;
|
|
|
|
x = vertexPtr[curVertex].i_x<<16;
|
|
i = vertexPtr[curVertex].i_i;
|
|
u = vertexPtr[curVertex].i_u;
|
|
v = vertexPtr[curVertex].i_v;
|
|
|
|
for (y=vertexPtr[curVertex].i_y; y<vertexPtr[nextVertex].i_y; y++)
|
|
{
|
|
polyScan->ig2s_x1 = x>>16;
|
|
x+=deltaX;
|
|
polyScan->ig2s_c1 = i;
|
|
i+=deltaI;
|
|
polyScan->ig2s_u1 = u;
|
|
u+=deltaU;
|
|
polyScan->ig2s_v1 = v;
|
|
v+=deltaV;
|
|
|
|
SecondOpinion++;
|
|
polyScan++;
|
|
}
|
|
}
|
|
curVertex++;
|
|
if (curVertex>maxVertexNum) curVertex = 0;
|
|
|
|
}
|
|
while(curVertex!=maxYVertex);
|
|
|
|
if (SecondOpinion<NumScans)
|
|
{
|
|
textprint("WARNING: Rasterization error\n");
|
|
NumScans = SecondOpinion;
|
|
// LOCALASSERT(0);
|
|
return;
|
|
}
|
|
}
|
|
//draw 'em
|
|
KR_ScanDraw_Item_Gouraud2dTexturePolygon_VideoModeType_8(itemptr);
|
|
|
|
#if 0
|
|
{
|
|
unsigned char colour= pheader->PolyColour;
|
|
I_GOURAUD2DTEXTUREPOLYGON_SCAN *polyScan;
|
|
polyScan = (I_GOURAUD2DTEXTUREPOLYGON_SCAN*)ScanData;
|
|
SCASM_Lighting = TextureLightingTable+colour;
|
|
SCASM_ShadingTableSize = 256;
|
|
|
|
while(NumScans)
|
|
{
|
|
int dx = polyScan->ig2s_x2 - polyScan->ig2s_x1;
|
|
if (dx>0)
|
|
{
|
|
SCASM_Destination = ScreenBuffer+(polyScan->ig2s_y * BackBufferPitch) + polyScan->ig2s_x1;
|
|
SCASM_ScanLength = dx;
|
|
SCASM_DeltaI = (polyScan->ig2s_c2-polyScan->ig2s_c1)/dx;
|
|
SCASM_StartI = polyScan->ig2s_c1;
|
|
ScanDraw_GouraudScan();
|
|
}
|
|
NumScans--;
|
|
polyScan++;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
#endif
|
|
#if 0
|
|
void KDraw_Item_Gouraud3dTexturePolygon(int *itemptr)
|
|
{
|
|
POLYHEADER *pheader = (POLYHEADER *) itemptr;
|
|
int TxIndex;
|
|
IMAGEHEADER *ImageHdr;
|
|
ItemColour = pheader->PolyColour;
|
|
|
|
TxIndex = ItemColour & ClrTxDefn;
|
|
ImageHdr = ImageHeaderPtrs[TxIndex];
|
|
|
|
|
|
|
|
/* Colour */
|
|
|
|
|
|
/* If MIP Mapping, calculate the scale */
|
|
|
|
if(ScreenDescriptorBlock.SDB_Flags & SDB_Flag_MIP && ImageHdr->ImageFlags & ih_flag_mip)
|
|
{
|
|
I_GOURAUD3DTEXTUREPOLYGON_PT *vector1;
|
|
I_GOURAUD3DTEXTUREPOLYGON_PT *vector2;
|
|
I_GOURAUD3DTEXTUREPOLYGON_PT *vector3;
|
|
int mip1, mip2;
|
|
int xyd, uvd;
|
|
VECTOR2D s0, s1;
|
|
VECTOR2D t0, t1;
|
|
|
|
|
|
/* Screen and Texture Space Vectors */
|
|
/* Express the "uvd / xyd" ratio as a binary scale */
|
|
|
|
vector1 = (I_GOURAUD3DTEXTUREPOLYGON_PT *) &pheader->Poly1stPt;
|
|
vector2 = &vector1[1];
|
|
vector3 = &vector1[2];
|
|
|
|
|
|
/* Vector 1 */
|
|
|
|
s0.vx = vector1->i_x;
|
|
s0.vy = vector1->i_y;
|
|
s1.vx = vector2->i_x;
|
|
s1.vy = vector2->i_y;
|
|
|
|
t0.vx = vector1->i_gtx3d_u / vector1->i_gtx3d_z;
|
|
t0.vy = vector1->i_gtx3d_v / vector1->i_gtx3d_z;
|
|
t1.vx = vector2->i_gtx3d_u / vector2->i_gtx3d_z;
|
|
t1.vy = vector2->i_gtx3d_v / vector2->i_gtx3d_z;
|
|
|
|
xyd = FandVD_Distance_2d(&s0, &s1);
|
|
uvd = FandVD_Distance_2d(&t0, &t1);
|
|
|
|
mip1 = FindShift32(uvd, xyd);
|
|
|
|
|
|
/* Vector 2 */
|
|
|
|
s0.vx = vector2->i_x;
|
|
s0.vy = vector2->i_y;
|
|
s1.vx = vector3->i_x;
|
|
s1.vy = vector3->i_y;
|
|
|
|
t0.vx = t1.vx;
|
|
t0.vy = t1.vy;
|
|
t1.vx = vector3->i_gtx3d_u / vector3->i_gtx3d_z;
|
|
t1.vy = vector3->i_gtx3d_v / vector3->i_gtx3d_z;
|
|
|
|
xyd = FandVD_Distance_2d(&s0, &s1);
|
|
uvd = FandVD_Distance_2d(&t0, &t1);
|
|
|
|
mip2 = FindShift32(uvd, xyd);
|
|
|
|
|
|
/* Choose the larger of the two */
|
|
|
|
if(pheader->PolyFlags & iflag_no_mip) {
|
|
|
|
MIP_Index = 0;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
#if UseMIPMax
|
|
if(mip1 > mip2)
|
|
MIP_Index = mip1;
|
|
else
|
|
MIP_Index = mip2;
|
|
#endif
|
|
|
|
#if UseMIPMin
|
|
if(mip1 > mip2)
|
|
MIP_Index = mip2;
|
|
else
|
|
MIP_Index = mip1;
|
|
#endif
|
|
|
|
#if UseMIPAvg
|
|
MIP_Index = (mip1 + mip2) >> 1;
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
/* Clamp "MIP_Index" */
|
|
|
|
#if MIP_INDEX_SUBTRACT
|
|
|
|
MIP_Index -= MIP_INDEX_SUBTRACT;
|
|
if(MIP_Index < 0) MIP_Index = 0;
|
|
else if(MIP_Index > 6) MIP_Index = 6;
|
|
|
|
#else
|
|
|
|
if(MIP_Index > 6) MIP_Index = 6;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
{
|
|
int minYVertex = 0;
|
|
int maxYVertex = 0;
|
|
int maxVertexNum = 0;
|
|
float MIP_Divide = 1<<MIP_Index;
|
|
|
|
{
|
|
I_GOURAUD3DTEXTUREPOLYGON_PT *vertexPtr = (I_GOURAUD3DTEXTUREPOLYGON_PT*)&pheader->Poly1stPt;
|
|
int minY = vertexPtr->i_y;
|
|
int maxY = vertexPtr->i_y;
|
|
|
|
if(ScreenDescriptorBlock.SDB_Flags & SDB_Flag_MIP && ImageHdr->ImageFlags & ih_flag_mip)
|
|
{
|
|
vertexPtr->i_gtx3d_u /= MIP_Divide;
|
|
vertexPtr->i_gtx3d_v /= MIP_Divide;
|
|
}
|
|
vertexPtr++;
|
|
|
|
do
|
|
{
|
|
maxVertexNum++;
|
|
|
|
if (minY > vertexPtr->i_y)
|
|
{
|
|
minY = vertexPtr->i_y;
|
|
minYVertex = maxVertexNum;
|
|
}
|
|
else if (maxY < vertexPtr->i_y)
|
|
{
|
|
maxY = vertexPtr->i_y;
|
|
maxYVertex = maxVertexNum;
|
|
}
|
|
|
|
if(ScreenDescriptorBlock.SDB_Flags & SDB_Flag_MIP && ImageHdr->ImageFlags & ih_flag_mip)
|
|
{
|
|
vertexPtr->i_gtx3d_u /= MIP_Divide;
|
|
vertexPtr->i_gtx3d_v /= MIP_Divide;
|
|
}
|
|
|
|
vertexPtr++;
|
|
}
|
|
while(vertexPtr->i_x != Term);
|
|
|
|
}
|
|
|
|
|
|
/* Initialise the Scan Data Buffer */
|
|
{
|
|
I_GOURAUD3DTEXTUREPOLYGON_PT *vertexPtr = (I_GOURAUD3DTEXTUREPOLYGON_PT*)&pheader->Poly1stPt;
|
|
I_GOURAUD3DTEXTUREPOLYGON_SCAN *polyScan;
|
|
int curVertex;
|
|
int SecondOpinion=0;
|
|
|
|
NumScans=0;
|
|
|
|
/* scan out the right edge */
|
|
polyScan = (I_GOURAUD3DTEXTUREPOLYGON_SCAN*)ScanData;
|
|
curVertex = minYVertex;
|
|
do
|
|
{
|
|
int height;
|
|
|
|
int nextVertex = curVertex-1;
|
|
if (nextVertex<0) nextVertex = maxVertexNum;
|
|
|
|
height = vertexPtr[nextVertex].i_y - vertexPtr[curVertex].i_y;
|
|
if (height!=0)
|
|
{
|
|
int i,x,y;
|
|
float u,v,z;
|
|
int deltaX,deltaI;
|
|
float deltaU,deltaV,deltaZ;
|
|
|
|
int width = vertexPtr[nextVertex].i_x - vertexPtr[curVertex].i_x;
|
|
int contrast = vertexPtr[nextVertex].i_gtx3d_i - vertexPtr[curVertex].i_gtx3d_i;
|
|
float widthU = vertexPtr[nextVertex].i_gtx3d_u - vertexPtr[curVertex].i_gtx3d_u;
|
|
float widthV = vertexPtr[nextVertex].i_gtx3d_v - vertexPtr[curVertex].i_gtx3d_v;
|
|
float widthZ = vertexPtr[nextVertex].i_gtx3d_z - vertexPtr[curVertex].i_gtx3d_z;
|
|
|
|
deltaX = (width<<16)/height;
|
|
deltaI = contrast/height;
|
|
deltaU = widthU/height;
|
|
deltaV = widthV/height;
|
|
deltaZ = widthZ/height;
|
|
|
|
x = vertexPtr[curVertex].i_x<<16;
|
|
i = vertexPtr[curVertex].i_gtx3d_i;
|
|
u = vertexPtr[curVertex].i_gtx3d_u;
|
|
v = vertexPtr[curVertex].i_gtx3d_v;
|
|
z = vertexPtr[curVertex].i_gtx3d_z;
|
|
|
|
for (y=vertexPtr[curVertex].i_y; y<vertexPtr[nextVertex].i_y; y++)
|
|
{
|
|
polyScan->ig3s_x2 = x>>16;
|
|
x+=deltaX;
|
|
polyScan->ig3s_c2 = i;
|
|
i+=deltaI;
|
|
polyScan->ig3s_u2 = u;
|
|
u+=deltaU;
|
|
polyScan->ig3s_v2 = v;
|
|
v+=deltaV;
|
|
polyScan->ig3s_z2 = z;
|
|
z+=deltaZ;
|
|
|
|
polyScan->ig3s_y = y;
|
|
NumScans++;
|
|
polyScan++;
|
|
}
|
|
}
|
|
curVertex--;
|
|
if (curVertex<0) curVertex = maxVertexNum;
|
|
|
|
}
|
|
while(curVertex!=maxYVertex);
|
|
|
|
/* scan out the left edge */
|
|
polyScan = (I_GOURAUD3DTEXTUREPOLYGON_SCAN*)ScanData;
|
|
curVertex = minYVertex;
|
|
do
|
|
{
|
|
int height;
|
|
|
|
int nextVertex = curVertex+1;
|
|
if (nextVertex>maxVertexNum) nextVertex = 0;
|
|
|
|
height = vertexPtr[nextVertex].i_y - vertexPtr[curVertex].i_y;
|
|
if (height!=0)
|
|
{
|
|
int i,x,y;
|
|
float u,v,z;
|
|
int deltaX,deltaI;
|
|
float deltaU,deltaV,deltaZ;
|
|
|
|
int width = vertexPtr[nextVertex].i_x - vertexPtr[curVertex].i_x;
|
|
int contrast = vertexPtr[nextVertex].i_gtx3d_i - vertexPtr[curVertex].i_gtx3d_i;
|
|
float widthU = vertexPtr[nextVertex].i_gtx3d_u - vertexPtr[curVertex].i_gtx3d_u;
|
|
float widthV = vertexPtr[nextVertex].i_gtx3d_v - vertexPtr[curVertex].i_gtx3d_v;
|
|
float widthZ = vertexPtr[nextVertex].i_gtx3d_z - vertexPtr[curVertex].i_gtx3d_z;
|
|
|
|
deltaX = (width<<16)/height;
|
|
deltaI = contrast/height;
|
|
deltaU = widthU/height;
|
|
deltaV = widthV/height;
|
|
deltaZ = widthZ/height;
|
|
|
|
x = vertexPtr[curVertex].i_x<<16;
|
|
i = vertexPtr[curVertex].i_gtx3d_i;
|
|
u = vertexPtr[curVertex].i_gtx3d_u;
|
|
v = vertexPtr[curVertex].i_gtx3d_v;
|
|
z = vertexPtr[curVertex].i_gtx3d_z;
|
|
|
|
for (y=vertexPtr[curVertex].i_y; y<vertexPtr[nextVertex].i_y; y++)
|
|
{
|
|
polyScan->ig3s_x1 = x>>16;
|
|
x+=deltaX;
|
|
polyScan->ig3s_c1 = i;
|
|
i+=deltaI;
|
|
polyScan->ig3s_u1 = u;
|
|
u+=deltaU;
|
|
polyScan->ig3s_v1 = v;
|
|
v+=deltaV;
|
|
polyScan->ig3s_z1 = z;
|
|
z+=deltaZ;
|
|
|
|
SecondOpinion++;
|
|
polyScan++;
|
|
}
|
|
}
|
|
curVertex++;
|
|
if (curVertex>maxVertexNum) curVertex = 0;
|
|
|
|
}
|
|
while(curVertex!=maxYVertex);
|
|
|
|
if (SecondOpinion<NumScans)
|
|
{
|
|
textprint("WARNING: Rasterization error\n");
|
|
NumScans = SecondOpinion;
|
|
// LOCALASSERT(0);
|
|
return;
|
|
}
|
|
}
|
|
|
|
//draw 'em
|
|
KR_ScanDraw_Item_Gouraud3dTexturePolygon_Linear_S_VideoModeType_8(itemptr);
|
|
}
|
|
}
|
|
#else
|
|
void KDraw_Item_Gouraud3dTexturePolygon(int *itemptr)
|
|
{
|
|
POLYHEADER *pheader = (POLYHEADER *) itemptr;
|
|
int TxIndex;
|
|
IMAGEHEADER *ImageHdr;
|
|
ItemColour = pheader->PolyColour;
|
|
|
|
TxIndex = ItemColour & ClrTxDefn;
|
|
ImageHdr = ImageHeaderPtrs[TxIndex];
|
|
|
|
|
|
|
|
{
|
|
int minYVertex = 0;
|
|
int maxYVertex = 0;
|
|
int maxVertexNum = 0;
|
|
|
|
|
|
{
|
|
I_GOURAUD3DTEXTUREPOLYGON_PT *vertexPtr = (I_GOURAUD3DTEXTUREPOLYGON_PT*)&pheader->Poly1stPt;
|
|
int minY = vertexPtr->i_y;
|
|
int maxY = vertexPtr->i_y;
|
|
|
|
vertexPtr++;
|
|
|
|
do
|
|
{
|
|
maxVertexNum++;
|
|
|
|
if (minY > vertexPtr->i_y)
|
|
{
|
|
minY = vertexPtr->i_y;
|
|
minYVertex = maxVertexNum;
|
|
}
|
|
else if (maxY < vertexPtr->i_y)
|
|
{
|
|
maxY = vertexPtr->i_y;
|
|
maxYVertex = maxVertexNum;
|
|
}
|
|
|
|
vertexPtr++;
|
|
}
|
|
while(vertexPtr->i_x != Term);
|
|
|
|
}
|
|
|
|
|
|
/* Initialise the Scan Data Buffer */
|
|
{
|
|
I_GOURAUD3DTEXTUREPOLYGON_PT *vertexPtr = (I_GOURAUD3DTEXTUREPOLYGON_PT*)&pheader->Poly1stPt;
|
|
I_GOURAUD3DTEXTUREPOLYGON_SCAN *polyScan;
|
|
int curVertex;
|
|
int SecondOpinion=0;
|
|
|
|
NumScans=0;
|
|
|
|
/* scan out the right edge */
|
|
polyScan = (I_GOURAUD3DTEXTUREPOLYGON_SCAN*)ScanData;
|
|
curVertex = minYVertex;
|
|
do
|
|
{
|
|
int height;
|
|
|
|
int nextVertex = curVertex-1;
|
|
if (nextVertex<0) nextVertex = maxVertexNum;
|
|
|
|
height = vertexPtr[nextVertex].i_y - vertexPtr[curVertex].i_y;
|
|
if (height!=0)
|
|
{
|
|
int i,x,y;
|
|
float u,v,z;
|
|
int deltaX,deltaI;
|
|
float deltaU,deltaV,deltaZ;
|
|
|
|
int width = vertexPtr[nextVertex].i_x - vertexPtr[curVertex].i_x;
|
|
int contrast = vertexPtr[nextVertex].i_gtx3d_i - vertexPtr[curVertex].i_gtx3d_i;
|
|
float widthU = vertexPtr[nextVertex].i_gtx3d_u - vertexPtr[curVertex].i_gtx3d_u;
|
|
float widthV = vertexPtr[nextVertex].i_gtx3d_v - vertexPtr[curVertex].i_gtx3d_v;
|
|
float widthZ = vertexPtr[nextVertex].i_gtx3d_z - vertexPtr[curVertex].i_gtx3d_z;
|
|
|
|
deltaX = (width<<16)/height;
|
|
deltaI = contrast/height;
|
|
deltaU = widthU/height;
|
|
deltaV = widthV/height;
|
|
deltaZ = widthZ/height;
|
|
|
|
x = vertexPtr[curVertex].i_x<<16;
|
|
i = vertexPtr[curVertex].i_gtx3d_i;
|
|
u = vertexPtr[curVertex].i_gtx3d_u;
|
|
v = vertexPtr[curVertex].i_gtx3d_v;
|
|
z = vertexPtr[curVertex].i_gtx3d_z;
|
|
|
|
for (y=vertexPtr[curVertex].i_y; y<vertexPtr[nextVertex].i_y; y++)
|
|
{
|
|
polyScan->ig3s_x2 = x>>16;
|
|
x+=deltaX;
|
|
polyScan->ig3s_c2 = i;
|
|
i+=deltaI;
|
|
polyScan->ig3s_u2 = u;
|
|
u+=deltaU;
|
|
polyScan->ig3s_v2 = v;
|
|
v+=deltaV;
|
|
polyScan->ig3s_z2 = z;
|
|
z+=deltaZ;
|
|
|
|
polyScan->ig3s_y = y;
|
|
NumScans++;
|
|
polyScan++;
|
|
}
|
|
}
|
|
curVertex--;
|
|
if (curVertex<0) curVertex = maxVertexNum;
|
|
|
|
}
|
|
while(curVertex!=maxYVertex);
|
|
|
|
/* scan out the left edge */
|
|
polyScan = (I_GOURAUD3DTEXTUREPOLYGON_SCAN*)ScanData;
|
|
curVertex = minYVertex;
|
|
do
|
|
{
|
|
int height;
|
|
|
|
int nextVertex = curVertex+1;
|
|
if (nextVertex>maxVertexNum) nextVertex = 0;
|
|
|
|
height = vertexPtr[nextVertex].i_y - vertexPtr[curVertex].i_y;
|
|
if (height!=0)
|
|
{
|
|
int i,x,y;
|
|
float u,v,z;
|
|
int deltaX,deltaI;
|
|
float deltaU,deltaV,deltaZ;
|
|
|
|
int width = vertexPtr[nextVertex].i_x - vertexPtr[curVertex].i_x;
|
|
int contrast = vertexPtr[nextVertex].i_gtx3d_i - vertexPtr[curVertex].i_gtx3d_i;
|
|
float widthU = vertexPtr[nextVertex].i_gtx3d_u - vertexPtr[curVertex].i_gtx3d_u;
|
|
float widthV = vertexPtr[nextVertex].i_gtx3d_v - vertexPtr[curVertex].i_gtx3d_v;
|
|
float widthZ = vertexPtr[nextVertex].i_gtx3d_z - vertexPtr[curVertex].i_gtx3d_z;
|
|
|
|
deltaX = (width<<16)/height;
|
|
deltaI = contrast/height;
|
|
deltaU = widthU/height;
|
|
deltaV = widthV/height;
|
|
deltaZ = widthZ/height;
|
|
|
|
x = vertexPtr[curVertex].i_x<<16;
|
|
i = vertexPtr[curVertex].i_gtx3d_i;
|
|
u = vertexPtr[curVertex].i_gtx3d_u;
|
|
v = vertexPtr[curVertex].i_gtx3d_v;
|
|
z = vertexPtr[curVertex].i_gtx3d_z;
|
|
|
|
for (y=vertexPtr[curVertex].i_y; y<vertexPtr[nextVertex].i_y; y++)
|
|
{
|
|
polyScan->ig3s_x1 = x>>16;
|
|
x+=deltaX;
|
|
polyScan->ig3s_c1 = i;
|
|
i+=deltaI;
|
|
polyScan->ig3s_u1 = u;
|
|
u+=deltaU;
|
|
polyScan->ig3s_v1 = v;
|
|
v+=deltaV;
|
|
polyScan->ig3s_z1 = z;
|
|
z+=deltaZ;
|
|
|
|
SecondOpinion++;
|
|
polyScan++;
|
|
}
|
|
}
|
|
curVertex++;
|
|
if (curVertex>maxVertexNum) curVertex = 0;
|
|
|
|
}
|
|
while(curVertex!=maxYVertex);
|
|
|
|
if (SecondOpinion<NumScans)
|
|
{
|
|
textprint("WARNING: Rasterization error\n");
|
|
NumScans = SecondOpinion;
|
|
// LOCALASSERT(0);
|
|
return;
|
|
}
|
|
}
|
|
|
|
//draw 'em
|
|
Draw_Gouraud3dTexture_Spans(itemptr);
|
|
}
|
|
}
|
|
|
|
#define PERS_STEP 16
|
|
void Draw_Gouraud3dTexture_Spans(int *itemptr)
|
|
{
|
|
I_GOURAUD3DTEXTUREPOLYGON_SCAN *sptr;
|
|
|
|
if(NumScans)
|
|
{
|
|
int y = NumScans;
|
|
/* Get the Image Data required for the Draw */
|
|
{
|
|
IMAGEHEADER *ImageHdr;
|
|
{
|
|
int TxIndex = ItemColour & ClrTxDefn;
|
|
ImageHdr = ImageHeaderPtrs[TxIndex];
|
|
}
|
|
{
|
|
SCASM_TextureDeltaScan = ImageHdr->ImageWidth;
|
|
SCASM_Bitmap = ImageHdr->ImagePtr;
|
|
GLOBALASSERT(SCASM_Bitmap);
|
|
}
|
|
}
|
|
SCASM_Lighting = TextureLightingTable;
|
|
|
|
sptr = (I_GOURAUD3DTEXTUREPOLYGON_SCAN *) ScanData;
|
|
do
|
|
{
|
|
int length = sptr->ig3s_x2 - sptr->ig3s_x1;
|
|
int dx=length;
|
|
|
|
if (dx>0 && !(sptr->ig3s_y & KRenderDrawMode) )
|
|
{
|
|
float deltaZ;
|
|
float endZ;
|
|
|
|
float endU,endV;
|
|
float deltaU,deltaV;
|
|
|
|
{
|
|
int StartI = sptr->ig3s_c1;
|
|
SCASM_DeltaI = (sptr->ig3s_c2 - StartI)/dx;
|
|
SCASM_StartI = StartI;
|
|
}
|
|
|
|
SCASM_Destination = ScreenBuffer + (sptr->ig3s_y * BackBufferPitch) + sptr->ig3s_x1;
|
|
SCASM_ScanLength = PERS_STEP;
|
|
|
|
{
|
|
float oneOverdx = 1.0/dx;
|
|
|
|
endZ = sptr->ig3s_z1;
|
|
deltaZ = (sptr->ig3s_z2 - endZ)*oneOverdx;
|
|
|
|
endU = sptr->ig3s_u1;
|
|
deltaU = (sptr->ig3s_u2 - endU)*oneOverdx;
|
|
|
|
endV = sptr->ig3s_v1;
|
|
deltaV = (sptr->ig3s_v2 - endV)*oneOverdx;
|
|
}
|
|
{
|
|
float z = 65536.0/endZ;
|
|
SCASM_StartU = endU*z;
|
|
SCASM_StartV = endV*z;
|
|
}
|
|
while(dx>PERS_STEP)
|
|
{
|
|
/* subdivide! */
|
|
int u,v;
|
|
|
|
dx -= PERS_STEP;
|
|
|
|
endZ += PERS_STEP*deltaZ;
|
|
endU += PERS_STEP*deltaU;
|
|
endV += PERS_STEP*deltaV;
|
|
|
|
{
|
|
float z = 65536.0/endZ;
|
|
u = endU*z;
|
|
v = endV*z;
|
|
}
|
|
SCASM_DeltaU = (u-SCASM_StartU)/PERS_STEP;
|
|
SCASM_DeltaV = (v-SCASM_StartV)/PERS_STEP;
|
|
|
|
/* draw PERS_STEP pixels */
|
|
ScanDraw2D_Gouraud();
|
|
|
|
SCASM_StartU = u;
|
|
SCASM_StartV = v;
|
|
|
|
SCASM_Destination +=PERS_STEP;
|
|
SCASM_StartI += PERS_STEP*SCASM_DeltaI;
|
|
}
|
|
if (dx>0)
|
|
{
|
|
int u,v;
|
|
SCASM_ScanLength = dx;
|
|
{
|
|
float z = 65536.0/sptr->ig3s_z2;
|
|
u = sptr->ig3s_u2*z;
|
|
v = sptr->ig3s_v2*z;
|
|
}
|
|
SCASM_DeltaU = (u-SCASM_StartU)/dx;
|
|
SCASM_DeltaV = (v-SCASM_StartV)/dx;
|
|
|
|
/* draw 8 pixels */
|
|
ScanDraw2D_Gouraud();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
sptr++;
|
|
y--;
|
|
}
|
|
while(y);
|
|
}
|
|
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#if 0
|
|
void MakeInverseLightingTable(void)
|
|
{
|
|
int lookingForColour;
|
|
|
|
for(lookingForColour=1; lookingForColour<=255; lookingForColour++)
|
|
{
|
|
int exit =0;
|
|
int table;
|
|
for (table=128; (table>0 && (!exit)); table--)
|
|
{
|
|
int entry;
|
|
for(entry=1; (entry<=255 && (!exit)); entry++)
|
|
{
|
|
if(lookingForColour == *(TextureLightingTable + 256*(table) + entry))
|
|
{
|
|
LighterTable[lookingForColour] = entry;
|
|
exit=1;
|
|
}
|
|
}
|
|
}
|
|
if (exit==0) LighterTable[lookingForColour] = 255;
|
|
}
|
|
}
|
|
#endif
|
|
struct ColourVector
|
|
{
|
|
VECTORCH Direction;
|
|
int Magnitude;
|
|
};
|
|
|
|
struct ColourVector ColourTable[256];
|
|
|
|
void MakeInverseLightingTable(void)
|
|
{
|
|
extern unsigned char TestPalette[];
|
|
unsigned char *palPtr = TestPalette;
|
|
int i;
|
|
|
|
for(i = 0; i < 256; i++)
|
|
{
|
|
VECTORCH colour;
|
|
int mag;
|
|
|
|
colour.vx = *palPtr++;
|
|
colour.vy = *palPtr++;
|
|
colour.vz = *palPtr++;
|
|
mag = Magnitude(&colour);
|
|
|
|
if (mag!=0)
|
|
{
|
|
colour.vx = (colour.vx*32)/mag;
|
|
colour.vy = (colour.vy*32)/mag;
|
|
colour.vz = (colour.vz*32)/mag;
|
|
}
|
|
ColourTable[i].Magnitude = mag;
|
|
ColourTable[i].Direction = colour;
|
|
}
|
|
|
|
for(i = 0; i < 256; i++)
|
|
{
|
|
int entry;
|
|
int brightest=0;
|
|
|
|
for(entry = 0; entry < 256; entry++)
|
|
{
|
|
VECTORCH v1 = ColourTable[i].Direction;
|
|
VECTORCH v2 = ColourTable[entry].Direction;
|
|
|
|
if ((v1.vx == v2.vx)
|
|
&&(v1.vy == v2.vy)
|
|
&&(v1.vz == v2.vz)
|
|
&&(ColourTable[i].Magnitude < ColourTable[entry].Magnitude)
|
|
&&(ColourTable[brightest].Magnitude > ColourTable[entry].Magnitude ||(!brightest)))
|
|
brightest = entry;
|
|
}
|
|
if (brightest==0)
|
|
{
|
|
for(entry = 0; entry < 256; entry++)
|
|
{
|
|
VECTORCH v1 = ColourTable[i].Direction;
|
|
VECTORCH v2 = ColourTable[entry].Direction;
|
|
|
|
if ((v1.vx>>2 == v2.vx>>1)
|
|
&&(v1.vy>>2 == v2.vy>>1)
|
|
&&(v1.vz>>2 == v2.vz>>1)
|
|
&&(ColourTable[i].Magnitude < ColourTable[entry].Magnitude)
|
|
&&(ColourTable[brightest].Magnitude > ColourTable[entry].Magnitude ||(!brightest)))
|
|
|
|
brightest = entry;
|
|
}
|
|
}
|
|
|
|
if (brightest==0)
|
|
{
|
|
for(entry = 0; entry < 256; entry++)
|
|
{
|
|
VECTORCH v1 = ColourTable[i].Direction;
|
|
VECTORCH v2 = ColourTable[entry].Direction;
|
|
|
|
if ((v1.vx>>2 == v2.vx>>2)
|
|
&&(v1.vy>>2 == v2.vy>>2)
|
|
&&(v1.vz>>2 == v2.vz>>2)
|
|
&&(ColourTable[i].Magnitude < ColourTable[entry].Magnitude)
|
|
&&(ColourTable[brightest].Magnitude > ColourTable[entry].Magnitude ||(!brightest)))
|
|
brightest = entry;
|
|
}
|
|
}
|
|
#if 0
|
|
if (brightest==0)
|
|
{
|
|
for(entry = 0; entry < 256; entry++)
|
|
{
|
|
VECTORCH v1 = ColourTable[i].Direction;
|
|
VECTORCH v2 = ColourTable[entry].Direction;
|
|
|
|
if ((v1.vx>>3 == v2.vx>>3)
|
|
&&(v1.vy>>3 == v2.vy>>3)
|
|
&&(v1.vz>>3 == v2.vz>>3)
|
|
&&(ColourTable[i].Magnitude < ColourTable[entry].Magnitude)
|
|
&&(ColourTable[brightest].Magnitude > ColourTable[entry].Magnitude ||(!brightest)))
|
|
brightest = entry;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
if (brightest==0) brightest = i;
|
|
|
|
LighterTable[i] = brightest;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
void DrawPaletteScreen(void)
|
|
{
|
|
int sortedColours[256];
|
|
{
|
|
extern unsigned char TestPalette[];
|
|
unsigned char *palPtr = TestPalette;
|
|
int i;
|
|
|
|
for(i = 0; i < 256; i++)
|
|
{
|
|
VECTORCH colour;
|
|
int mag;
|
|
|
|
colour.vx = *palPtr++;
|
|
colour.vy = *palPtr++;
|
|
colour.vz = *palPtr++;
|
|
mag = Magnitude(&colour);
|
|
|
|
if (mag!=0)
|
|
{
|
|
colour.vx = (colour.vx*7)/mag;
|
|
colour.vy = (colour.vy*7)/mag;
|
|
colour.vz = (colour.vz*7)/mag;
|
|
}
|
|
ColourTable[i].Magnitude = mag;
|
|
ColourTable[i].Direction = colour;
|
|
}
|
|
|
|
for(i = 0; i<256; i++)
|
|
{
|
|
int e;
|
|
int maxKey=-1;
|
|
int selectedEntry=0;
|
|
|
|
for (e=0; e<256; e++)
|
|
{
|
|
int key = ColourTable[e].Direction.vx + ColourTable[e].Direction.vy*64+ColourTable[e].Direction.vz*64*64;
|
|
if (key>maxKey)
|
|
{
|
|
maxKey = key;
|
|
selectedEntry = e;
|
|
}
|
|
else if (key==maxKey)
|
|
{
|
|
if (ColourTable[e].Magnitude<ColourTable[selectedEntry].Magnitude)
|
|
selectedEntry = e;
|
|
}
|
|
}
|
|
|
|
sortedColours[i] = selectedEntry;
|
|
ColourTable[selectedEntry].Direction.vx=-1;
|
|
ColourTable[selectedEntry].Direction.vy=-1;
|
|
ColourTable[selectedEntry].Direction.vz=-1;
|
|
}
|
|
|
|
}
|
|
{
|
|
char colour = 0;
|
|
int *bufferPtr = (int*)ScreenBuffer;
|
|
int i,x,y;
|
|
|
|
for (i=0; i<=12; i++)
|
|
{
|
|
for (y=0; y<=6; y++)
|
|
{
|
|
for (x=0; x<=19; x++)
|
|
{
|
|
unsigned int c=colour+x;
|
|
|
|
if (c<256)
|
|
{
|
|
c = sortedColours[c];
|
|
c = c + (c<<8) + (c<<16) +(c<<24);
|
|
*bufferPtr++=c;
|
|
*bufferPtr++=c;
|
|
*bufferPtr++=c;
|
|
*bufferPtr++=c;
|
|
}
|
|
else
|
|
{
|
|
bufferPtr++;
|
|
bufferPtr++;
|
|
bufferPtr++;
|
|
bufferPtr++;
|
|
}
|
|
}
|
|
}
|
|
colour+=20;
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
{
|
|
extern unsigned char TestPalette[];
|
|
unsigned char *palPtr = TestPalette;
|
|
int i;
|
|
|
|
for(i = 0; i < 256; i++)
|
|
{
|
|
VECTORCH colour;
|
|
int mag;
|
|
|
|
colour.vx = *palPtr++;
|
|
colour.vy = *palPtr++;
|
|
colour.vz = *palPtr++;
|
|
mag = Magnitude(&colour);
|
|
if (mag!=0)
|
|
{
|
|
colour.vx = (colour.vx*63)/mag;
|
|
colour.vy = (colour.vy*63)/mag;
|
|
colour.vz = (colour.vz*63)/mag;
|
|
}
|
|
|
|
ColourTable[i].Direction = colour;
|
|
ColourTable[i].Magnitude = mag;
|
|
}
|
|
|
|
for(i = 0; i<256; i++)
|
|
{
|
|
int e;
|
|
int maxKey=-1;
|
|
int selectedEntry=0;
|
|
|
|
for (e=0; e<256; e++)
|
|
{
|
|
int key = ColourTable[e].Magnitude;
|
|
|
|
if (key>maxKey)
|
|
{
|
|
maxKey = key;
|
|
selectedEntry = e;
|
|
}
|
|
else if (key==maxKey)
|
|
{
|
|
int key2 = ColourTable[e].Direction.vx + ColourTable[e].Direction.vy*64+ColourTable[e].Direction.vz*64*64;
|
|
int key3 = ColourTable[selectedEntry].Direction.vx
|
|
+ ColourTable[selectedEntry].Direction.vy*64
|
|
+ ColourTable[selectedEntry].Direction.vz*64*64;
|
|
|
|
if (key2<key3)
|
|
selectedEntry=e;
|
|
}
|
|
|
|
}
|
|
|
|
sortedColours[i] = selectedEntry;
|
|
ColourTable[selectedEntry].Magnitude=-1;
|
|
}
|
|
|
|
}
|
|
{
|
|
char colour = 0;
|
|
int *bufferPtr = (int*)(ScreenBuffer+32000);
|
|
int i,x,y;
|
|
|
|
for (i=0; i<=12; i++)
|
|
{
|
|
for (y=0; y<=6; y++)
|
|
{
|
|
for (x=0; x<=19; x++)
|
|
{
|
|
unsigned int c=colour+x;
|
|
|
|
if (c<256)
|
|
{
|
|
c = sortedColours[c];
|
|
c = c + (c<<8) + (c<<16) +(c<<24);
|
|
*bufferPtr++=c;
|
|
*bufferPtr++=c;
|
|
*bufferPtr++=c;
|
|
*bufferPtr++=c;
|
|
}
|
|
else
|
|
{
|
|
bufferPtr++;
|
|
bufferPtr++;
|
|
bufferPtr++;
|
|
bufferPtr++;
|
|
}
|
|
}
|
|
}
|
|
colour+=20;
|
|
}
|
|
}
|
|
#else
|
|
{
|
|
extern unsigned char TestPalette[];
|
|
char colour = 0;
|
|
int *bufferPtr = (int*)(ScreenBuffer+32000);
|
|
int i,x,y;
|
|
|
|
for (i=0; i<=12; i++)
|
|
{
|
|
for (y=0; y<=6; y++)
|
|
{
|
|
for (x=0; x<=19; x++)
|
|
{
|
|
unsigned int c=colour+x;
|
|
|
|
if (c<256)
|
|
{
|
|
c = c + (c<<8) + (c<<16) +(c<<24);
|
|
*bufferPtr++=c;
|
|
*bufferPtr++=c;
|
|
*bufferPtr++=c;
|
|
*bufferPtr++=c;
|
|
}
|
|
else
|
|
{
|
|
bufferPtr++;
|
|
bufferPtr++;
|
|
bufferPtr++;
|
|
bufferPtr++;
|
|
}
|
|
}
|
|
}
|
|
colour+=20;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void OddLineScreenCopy(unsigned int *source,unsigned int *dest)
|
|
{
|
|
int lines = 240;
|
|
|
|
do
|
|
{
|
|
int i = 640/4;
|
|
|
|
dest += 640/4;
|
|
source += 640/4;
|
|
|
|
do
|
|
{
|
|
*dest++=*source++;
|
|
}
|
|
while(--i);
|
|
}
|
|
while(--lines);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*KJL*****************************************************
|
|
* Palette fading; a value of 65536 corresponds to normal *
|
|
* palette, 0 is completely black. *
|
|
*****************************************************KJL*/
|
|
void SetPaletteFadeLevel(int fadeLevel)
|
|
{
|
|
extern int ScanDrawMode;
|
|
if(ScanDrawDirectDraw == ScanDrawMode)
|
|
{
|
|
extern unsigned char TestPalette[];
|
|
extern unsigned char TestPalette2[];
|
|
{
|
|
int x;
|
|
for (x=0; x<768; x++)
|
|
{
|
|
TestPalette2[x] = ((unsigned int)TestPalette[x]*fadeLevel)>>16;
|
|
}
|
|
}
|
|
ChangePalette(TestPalette2);
|
|
}
|
|
else
|
|
{
|
|
d3d_light_ctrl.ctrl = LCCM_CONSTCOLOUR;
|
|
d3d_light_ctrl.r = fadeLevel;
|
|
d3d_light_ctrl.g = fadeLevel;
|
|
d3d_light_ctrl.b = fadeLevel;
|
|
}
|
|
}
|
|
|
|
void FadeBetweenPalettes(unsigned char *palPtr, int fadeLevel)
|
|
{
|
|
extern unsigned char TestPalette[];
|
|
unsigned char TestPalette3[768];
|
|
{
|
|
int x;
|
|
for (x=0; x<768; x++)
|
|
{
|
|
TestPalette3[x] = ( (unsigned int)TestPalette[x]*fadeLevel + (unsigned int)(palPtr[x])*(65536-fadeLevel) )>>16;
|
|
}
|
|
}
|
|
ChangePalette(TestPalette3);
|
|
}
|
|
void FadePaletteToWhite(unsigned char *palPtr,int fadeLevel)
|
|
{
|
|
unsigned char TestPalette3[768];
|
|
{
|
|
int x;
|
|
for (x=0; x<768; x++)
|
|
{
|
|
TestPalette3[x] = ( (unsigned int)(palPtr[x])*fadeLevel + 63*(65536-fadeLevel) )>>16;
|
|
}
|
|
}
|
|
ChangePalette(TestPalette3);
|
|
}
|
|
|
|
|
|
void BlankScreen(void)
|
|
{
|
|
extern int ScanDrawMode;
|
|
|
|
if (ScanDrawDirectDraw==ScanDrawMode)
|
|
{
|
|
extern unsigned char *ScreenBuffer;
|
|
extern unsigned char TestPalette[];
|
|
unsigned int *screenPtr;
|
|
int i;
|
|
|
|
screenPtr = (unsigned int *)ScreenBuffer;
|
|
i = ScreenDescriptorBlock.SDB_Width * ScreenDescriptorBlock.SDB_Height /4;
|
|
do
|
|
{
|
|
*screenPtr++=0;
|
|
}
|
|
while(--i);
|
|
}
|
|
else
|
|
{
|
|
ColourFillBackBuffer(0);
|
|
}
|
|
|
|
// FlipBuffers();
|
|
}
|
|
|
|
|
|
|
|
|
|
void GenerateReciprocalTable(void)
|
|
{
|
|
int i=320;
|
|
|
|
do
|
|
{
|
|
ReciprocalTable[i] = 65536/i;
|
|
}
|
|
while(--i);
|
|
}
|
|
|
|
|
|
|
|
|
|
#if 0
|
|
#define NO_OF_STARS 500
|
|
typedef struct
|
|
{
|
|
VECTORCH Position;
|
|
int Colour;
|
|
|
|
} STARDESC;
|
|
static STARDESC StarArray[NO_OF_STARS];
|
|
#endif
|
|
void CreateStarArray(void)
|
|
{
|
|
#if 0
|
|
int i;
|
|
extern int sine[],cosine[];
|
|
for(i=0; i<NO_OF_STARS; i++)
|
|
{
|
|
int phi = FastRandom()&4095;
|
|
int theta = FastRandom()&4095;
|
|
|
|
StarArray[i].Position.vx = MUL_FIXED(GetCos(phi),GetSin(theta));
|
|
StarArray[i].Position.vy = MUL_FIXED(GetSin(phi),GetSin(theta));
|
|
StarArray[i].Position.vz = GetCos(theta);
|
|
StarArray[i].Colour = FastRandom()&32767;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
/* KJL 12:10:36 9/30/97 - starfield, currently implemented for 8 & 16 bit displays */
|
|
void DrawStarfilledSky(void)
|
|
{
|
|
#if 0
|
|
int i;
|
|
extern VIEWDESCRIPTORBLOCK *Global_VDB_Ptr;
|
|
extern int ScanDrawMode;
|
|
|
|
/* blank the screen */
|
|
ColourFillBackBuffer(0);
|
|
|
|
LockSurfaceAndGetBufferPointer();
|
|
|
|
if(AvP.PlayerType==I_Alien) /* wide frustrum */
|
|
{
|
|
for(i=0; i<NO_OF_STARS; i++)
|
|
{
|
|
VECTORCH rotatedPosition = StarArray[i].Position;
|
|
|
|
/* rotate star into view space */
|
|
RotateVector(&rotatedPosition,&(Global_VDB_Ptr->VDB_Mat));
|
|
|
|
/* is star within alien (wide) view frustrum ? */
|
|
if((-rotatedPosition.vx <= rotatedPosition.vz*2)
|
|
&&(rotatedPosition.vx <= rotatedPosition.vz*2)
|
|
&&(-rotatedPosition.vy*2 <= rotatedPosition.vz*3)
|
|
&&(rotatedPosition.vy*2 <= rotatedPosition.vz*3))
|
|
{
|
|
/* project into screen space */
|
|
int y = (rotatedPosition.vy*(Global_VDB_Ptr->VDB_ProjY))/rotatedPosition.vz+Global_VDB_Ptr->VDB_CentreY;
|
|
int x = (rotatedPosition.vx*(Global_VDB_Ptr->VDB_ProjX))/rotatedPosition.vz+Global_VDB_Ptr->VDB_CentreX;
|
|
|
|
/* draw pixel of required bit depth */
|
|
if (ScanDrawMode == ScanDrawDirectDraw)
|
|
{
|
|
/* 8 bit mode */
|
|
*(ScreenBuffer + x + y*BackBufferPitch) = StarArray[i].Colour&255;
|
|
}
|
|
else
|
|
{
|
|
/* 16 bit mode */
|
|
*(unsigned short*)(ScreenBuffer + (x*2 + y*BackBufferPitch)) = StarArray[i].Colour;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else /* normal frustrum */
|
|
{
|
|
for(i=0; i<NO_OF_STARS; i++)
|
|
{
|
|
VECTORCH rotatedPosition = StarArray[i].Position;
|
|
|
|
/* rotate star into view space */
|
|
RotateVector(&rotatedPosition,&(Global_VDB_Ptr->VDB_Mat));
|
|
|
|
/* is star within normal view frustrum ? */
|
|
if((-rotatedPosition.vx <= rotatedPosition.vz)
|
|
&&(rotatedPosition.vx <= rotatedPosition.vz)
|
|
&&(-rotatedPosition.vy*4 <= rotatedPosition.vz*3)
|
|
&&(rotatedPosition.vy*4 <= rotatedPosition.vz*3))
|
|
{
|
|
/* project into screen space */
|
|
int y = (rotatedPosition.vy*(Global_VDB_Ptr->VDB_ProjY))/rotatedPosition.vz+Global_VDB_Ptr->VDB_CentreY;
|
|
int x = (rotatedPosition.vx*(Global_VDB_Ptr->VDB_ProjX))/rotatedPosition.vz+Global_VDB_Ptr->VDB_CentreX;
|
|
|
|
/* draw pixel of required bit depth */
|
|
if (ScanDrawMode == ScanDrawDirectDraw)
|
|
{
|
|
/* 8 bit mode */
|
|
*(ScreenBuffer + x + y*BackBufferPitch) = StarArray[i].Colour&255;
|
|
}
|
|
else
|
|
{
|
|
/* 16 bit mode */
|
|
*(unsigned short*)(ScreenBuffer + (x*2 + y*BackBufferPitch)) = StarArray[i].Colour;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
UnlockSurface();
|
|
#endif
|
|
} |