xTr1m/bluflame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

port from perforce

Browse Source
This commit is contained in:
Frank Tovar
2026-04-18 22:31:51 +02:00
commit 8d0ab5b7cc
8409 changed files with 3972376 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

343
evoke-64k/bp10/picstuff.h Normal file
View File

@@ -0,0 +1,343 @@
#pragma once
/*
D3DLOCKED_RECT g_d3dlr;
const int iTexSize= 256;
int Pre[ iTexSize * iTexSize ];
int PixelStack[ iTexSize * iTexSize ];
int PixelStackPointer= 0;
DWORD dwColor[ 12 ]=
{
0,
0xff000000,
0xffffffff,
0xc0000000,
0xa0000000,
0x80000000,
0x60000000,
0x40000000,
0x20000000,
0x10000000,
0x00000000,
0x00000000,
};
int GetPre( int x, int y )
{
if( x < 0 || x >= iTexSize || y < 0 || y >= iTexSize )
{
return -1;
}
return Pre[ y * iTexSize + x ];
}
void FillAndAdd( int x, int y )
{
if( Pre[ y * iTexSize + x ] == 1 || Pre[ y * iTexSize + x ] == 0 )
{
return;
}
int iOffset= y * iTexSize + x;
Pre[ iOffset ]= 0;
PixelStack[ PixelStackPointer ]= iOffset;
PixelStackPointer++;
}
void ClearAlpha( int x, int y )
{
FillAndAdd( x, y );
while( PixelStackPointer > 0 )
{
PixelStackPointer--;
x= PixelStack[ PixelStackPointer ] % iTexSize;
y= PixelStack[ PixelStackPointer ] / iTexSize;
if( x > 0 )
{
FillAndAdd( x - 1, y );
}
if( x < iTexSize - 1 )
{
FillAndAdd( x + 1, y );
}
if( y > 0 )
{
FillAndAdd( x, y - 1 );
}
if( y < iTexSize - 1 )
{
FillAndAdd( x, y + 1 );
}
}
}
void FindAndExpandBorder()
{
PixelStackPointer= 0;
for( int y= 1; y < iTexSize - 1; y++ )
{
for( int x= 1; x < iTexSize - 1; x++ )
{
bool bBorder= false;
bool bCenter= false;
for( int dy= -1; dy <= 1; dy++ )
{
for( int dx= -1; dx <= 1; dx++ )
{
int Val= Pre[ ( y + dy ) * iTexSize + x + dx ];
if( dx ==0 && dy == 0 )
{
bCenter= Val > 0;
}
else if( !bBorder )
{
bBorder= Val < 1;
}
}
}
if( bBorder && bCenter )
{
int iOffset= y * iTexSize + x;
PixelStack[ PixelStackPointer ]= iOffset;
PixelStackPointer++;
}
}
}
while( PixelStackPointer > 0 )
{
PixelStackPointer--;
int x= PixelStack[ PixelStackPointer ] % iTexSize;
int y= PixelStack[ PixelStackPointer ] / iTexSize;
for( int dy= -16; dy <= 16; dy++ )
{
for( int dx= -16; dx <= 16; dx++ )
{
if( dx * dx + dy * dy <= 16 * 16 + 16 )
{
int Offset= ( y + dy ) * iTexSize + x + dx;
if( Pre[ Offset ] < 1 )
{
Pre[ Offset ]= 2;
}
}
}
}
}
}
void DropShadow( int dx, int dy )
{
for( int y= 0; y < iTexSize; y++ )
{
for( int x= 0; x < iTexSize; x++ )
{
int iOffset= y * iTexSize + x;
if( GetPre( x + dx, y + dy ) == 2 && Pre[ iOffset ] < 1 )
{
Pre[ iOffset ]= 2 + abs( dx );
}
}
}
}
void CreatePicTexture( int iPic, const unsigned char* ucData )
{
for( int i= 0; i < iTexSize * iTexSize; ++i )
{
Pre[ i ]= -1;
}
int iPos= 0;
int iWidth= ucData[ iPos++ ];
int iHeight= ucData[ iPos++ ];
int iStartX= ( iTexSize - iWidth ) / 2;
int iStartY= iTexSize - iHeight - 22;
int iMask= 128;
for( int y= 0; y < iHeight; y++ )
{
for( int x=0; x < iWidth; x++ )
{
Pre[ ( y + iStartY ) * iTexSize + x + iStartX ]=
( iMask & ucData[ iPos ] ) ? 1 : 2;
iMask/= 2;
if( iMask == 0 )
{
iMask= 128;
iPos++;
}
}
}
ClearAlpha( iTexSize / 2, 0 );
FindAndExpandBorder();
DropShadow( 1, 2 );
DropShadow( -2, -2 );
DropShadow( 2, -2 );
DropShadow( 2, 4 );
DropShadow( -3, 4 );
DropShadow( 3, 6 );
DropShadow( 4, 8 );
DropShadow( 5, 10 );
g_d3d_device->CreateTexture(
iTexSize,
iTexSize,
1,
0,
D3DFMT_A8R8G8B8,
D3DPOOL_MANAGED,
&g_pPictures[ iPic ],
NULL );
g_pPictures[ iPic ]->LockRect( 0, &g_d3dlr, 0, 0 );
DWORD* pDst = (DWORD*)g_d3dlr.pBits;
for( int i= 0; i < iTexSize * iTexSize; ++i )
{
pDst[ i ]= dwColor[ Pre[ i ] ];
}
g_pPictures[ iPic ]->UnlockRect( 0 );
}
void RenderLoading( int iPercent );
void CreatePictures()
{
int iAdd= 2;
int i= 0;
CreatePicTexture( 0, g_puetz);
RenderLoading( i ); i+= iAdd;
CreatePicTexture( 1, g_marcel );
RenderLoading( i ); i+= iAdd;
CreatePicTexture( 2, g_tggc );
RenderLoading( i ); i+= iAdd;
CreatePicTexture( 3, g_timba);
RenderLoading( i ); i+= iAdd;
CreatePicTexture( 4, g_spock);
RenderLoading( i ); i+= iAdd;
CreatePicTexture( 5, g_seekuh);
RenderLoading( i ); i+= iAdd;
CreatePicTexture( 6, g_seagull);
RenderLoading( i ); i+= iAdd;
CreatePicTexture( 7, g_oldgyver);
RenderLoading( i ); i+= iAdd;
CreatePicTexture( 8, g_data);
RenderLoading( i ); i+= iAdd;
CreatePicTexture( 9, g_bruce);
RenderLoading( i ); i+= iAdd;
CreatePicTexture( 10, g_hannibal );
RenderLoading( i ); i+= iAdd;
CreatePicTexture( 11, g_garfield );
RenderLoading( i ); i+= iAdd;
CreatePicTexture( 12, g_dm );
RenderLoading( i ); i+= iAdd;
CreatePicTexture( 13, g_wolverine );
RenderLoading( i ); i+= iAdd;
CreatePicTexture( 14, g_norris );
RenderLoading( i ); i+= iAdd;
CreatePicTexture( 15, g_sau );
RenderLoading( i ); i+= iAdd;
}
struct SVertexPic
{
FLOAT x, y, z;
FLOAT tx, ty;
};
const DWORD c_dwFVFPic= D3DFVF_XYZ|D3DFVF_TEX1;
SVertexPic g_VertPic[]=
{
{ -1.0f, -1.0f, 5.0f, 0.01f, 0.01f },
{ -1.0f, 1.0f, 5.0f, 0.01f, 0.99f },
{ 1.0f, -1.0f, 5.0f, 0.99f, 0.01f },
{ 1.0f, 1.0f,5.0f, 0.99f, 0.99f },
};
void RenderPic( int iIndex, float fMidX, float fMidY, float fSize )
{
g_d3d_device->SetRenderState( D3DRS_LIGHTING, FALSE );
g_d3d_device->SetRenderState( D3DRS_ZENABLE, FALSE );
g_d3d_device->SetRenderState( D3DRS_ALPHATESTENABLE, TRUE );
g_d3d_device->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
g_d3d_device->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
g_d3d_device->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
g_d3d_device->SetRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATER );
g_d3d_device->SetRenderState( D3DRS_ALPHAREF, 0x20 );
g_d3d_device->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
g_d3d_device->SetSamplerState(0,D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
g_d3d_device->SetSamplerState(0,D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
g_d3d_device->SetSamplerState(0,D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
g_d3d_device->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
g_d3d_device->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 );
g_d3d_device->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TEXTURE );
g_d3d_device->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1 );
g_d3d_device->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
D3DXMATRIX mat;
D3DXMatrixOrthoLH(
&mat,
1024.0f,
-576.0f * (float)c_iScreenSizeY / (float)c_iRealScreenY,
1.0f,
8.0f );
g_d3d_device->SetTransform( D3DTS_PROJECTION, &mat );
D3DXMatrixIdentity( &mat );
g_d3d_device->SetTransform( D3DTS_VIEW, &mat );
g_d3d_device->SetTransform( D3DTS_WORLD, &mat );
{
g_VertPic[ 0 ].x= fMidX - fSize;
g_VertPic[ 0 ].y= fMidY - fSize;
g_VertPic[ 1 ].x= fMidX - fSize;
g_VertPic[ 1 ].y= fMidY + fSize;
g_VertPic[ 2 ].x= fMidX + fSize;
g_VertPic[ 2 ].y= fMidY - fSize;
g_VertPic[ 3 ].x= fMidX + fSize;
g_VertPic[ 3 ].y= fMidY + fSize;
g_d3d_device->SetTexture( 0, g_pPictures[ iIndex ] );
g_d3d_device->SetFVF( c_dwFVFPic );
g_d3d_device->DrawPrimitiveUP(
D3DPT_TRIANGLESTRIP,
2,
g_VertPic,
sizeof( SVertexPic )
);
}
}
*/