blitz-research
/
blitz3d
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
blitz3d/gxruntime/ddutil.cpp

526 lines
14 KiB
C++
Raw Permalink Blame History

#include "std.h"
#include "ddutil.h"
#include "asmcoder.h"
#include "gxcanvas.h"
#include "gxruntime.h"
extern gxRuntime *gx_runtime;
#include "..\..\freeimage241\source\freeimage.h"
static AsmCoder asm_coder;
static void calcShifts( unsigned mask,unsigned char *shr,unsigned char *shl ){
if( mask ){
for( *shl=0;!(mask&1);++*shl,mask>>=1 ){}
for( *shr=8;mask&1;--*shr,mask>>=1 ){}
}else *shr=*shl=0;
}
PixelFormat::~PixelFormat(){
if( plot_code ){
VirtualFree( plot_code,0,MEM_RELEASE );
}
}
void PixelFormat::setFormat( const DDPIXELFORMAT &pf ){
if( plot_code ){
VirtualFree( plot_code,0,MEM_RELEASE );
}
if( !(pf.dwFlags & DDPF_RGB) ){
memset( this,0,sizeof(*this) );
return;
}
plot_code=(char*)VirtualAlloc( 0,128,MEM_COMMIT|MEM_RESERVE,PAGE_EXECUTE_READWRITE );
point_code=plot_code+64;
depth=pf.dwRGBBitCount;
amask=pf.dwRGBAlphaBitMask;
rmask=pf.dwRBitMask;
gmask=pf.dwGBitMask;
bmask=pf.dwBBitMask;
pitch=depth/8;argbfill=0;
if( !amask ) argbfill|=0xff000000;
if( !rmask ) argbfill|=0x00ff0000;
if( !gmask ) argbfill|=0x0000ff00;
if( !bmask ) argbfill|=0x000000ff;
calcShifts( amask,&ashr,&ashl );ashr+=24;
calcShifts( rmask,&rshr,&rshl );rshr+=16;
calcShifts( gmask,&gshr,&gshl );gshr+=8;
calcShifts( bmask,&bshr,&bshl );
plot=(Plot)(void*)plot_code;
point=(Point)(void*)point_code;
asm_coder.CodePlot( plot_code,depth,amask,rmask,gmask,bmask );
asm_coder.CodePoint( point_code,depth,amask,rmask,gmask,bmask );
}
static void adjustTexSize( int *width,int *height,IDirect3DDevice7 *dir3dDev ){
D3DDEVICEDESC7 ddDesc={0};
if( dir3dDev->GetCaps( &ddDesc )<0 ){
*width=*height=256;
return;
}
int w=*width,h=*height,min,max;
//make power of 2
//Try *always* making POW2 size to fix GF6800 non-pow2 tex issue
// if( ddDesc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_POW2 ){
for( w=1;w<*width;w<<=1 ){}
for( h=1;h<*height;h<<=1 ){}
// }
//make square
if( ddDesc.dpcTriCaps.dwTextureCaps & D3DPTEXTURECAPS_SQUAREONLY ){
if( w>h ) h=w;
else w=h;
}
//check aspect ratio
if( max=ddDesc.dwMaxTextureAspectRatio ){
int asp=w>h ? w/h : h/w;
if( asp>max ){
if( w>h ) h=w/max;
else w=h/max;
}
}
//clamp size
if( (min=ddDesc.dwMinTextureWidth) && w<min ) w=min;
if( (min=ddDesc.dwMinTextureHeight) && h<min ) h=min;
if( (max=ddDesc.dwMaxTextureWidth) && w>max ) w=max;
if( (max=ddDesc.dwMaxTextureHeight) && h>max ) h=max;
*width=w;*height=h;
}
static ddSurf *createSurface( int width,int height,int pitch,void *bits,IDirectDraw7 *dirDraw ){
DDSURFACEDESC2 desc={sizeof(desc)};
desc.dwFlags=DDSD_WIDTH|DDSD_HEIGHT|DDSD_LPSURFACE|DDSD_PITCH|DDSD_PIXELFORMAT|DDSD_CAPS;
desc.ddsCaps.dwCaps=DDSCAPS_OFFSCREENPLAIN|DDSCAPS_SYSTEMMEMORY;
desc.dwWidth=width;desc.dwHeight=height;
desc.lPitch=pitch;desc.lpSurface=bits;
desc.ddpfPixelFormat.dwSize=sizeof(DDPIXELFORMAT);
desc.ddpfPixelFormat.dwFlags=DDPF_RGB|DDPF_ALPHAPIXELS;
desc.ddpfPixelFormat.dwRGBBitCount=32;
desc.ddpfPixelFormat.dwRBitMask=0xff0000;
desc.ddpfPixelFormat.dwGBitMask=0x00ff00;
desc.ddpfPixelFormat.dwBBitMask=0x0000ff;
desc.ddpfPixelFormat.dwRGBAlphaBitMask=0xff000000;
ddSurf *surf;
if( dirDraw->CreateSurface( &desc,&surf,0 )>=0 ) return surf;
return 0;
}
static void buildMask( ddSurf *surf ){
DDSURFACEDESC2 desc={sizeof(desc)};
surf->Lock( 0,&desc,DDLOCK_WAIT,0 );
unsigned char *surf_p=(unsigned char*)desc.lpSurface;
PixelFormat fmt( desc.ddpfPixelFormat );
for( int y=0;y<desc.dwHeight;++y ){
unsigned char *p=surf_p;
for( int x=0;x<desc.dwWidth;++x ){
unsigned argb=fmt.getPixel( p );
unsigned rgb=argb&0xffffff;
unsigned a=rgb ? 0xff000000 : 0;
fmt.setPixel( p,a|rgb );
p+=fmt.getPitch();
}
surf_p+=desc.lPitch;
}
surf->Unlock( 0 );
}
static void buildAlpha( ddSurf *surf,bool whiten ){
DDSURFACEDESC2 desc={sizeof(desc)};
surf->Lock( 0,&desc,DDLOCK_WAIT,0 );
unsigned char *surf_p=(unsigned char*)desc.lpSurface;
PixelFormat fmt( desc.ddpfPixelFormat );
for( int y=0;y<desc.dwHeight;++y ){
unsigned char *p=surf_p;
for( int x=0;x<desc.dwWidth;++x ){
unsigned argb=fmt.getPixel( p );
unsigned alpha=(((argb>>16)&0xff)+((argb>>8)&0xff)+(argb&0xff))/3;
argb=(alpha<<24) | (argb & 0xffffff);
if( whiten ) argb|=0xffffff;
fmt.setPixel( p,argb );
p+=fmt.getPitch();
}
surf_p+=desc.lPitch;
}
surf->Unlock( 0 );
}
void ddUtil::buildMipMaps( ddSurf *surf ){
DDSURFACEDESC2 desc={sizeof(desc)};
surf->GetSurfaceDesc( &desc );
if( !(desc.ddsCaps.dwCaps & DDSCAPS_TEXTURE) ) return;
if( !(desc.ddpfPixelFormat.dwFlags & DDPF_RGB) ) return;
DDSCAPS2 caps={0};
caps.dwCaps=DDSCAPS_TEXTURE;
caps.dwCaps2=DDSCAPS2_MIPMAPSUBLEVEL;
IDirectDrawSurface7 *src=surf,*dest;
while( src->GetAttachedSurface( &caps,&dest )>=0 ){
DDSURFACEDESC2 src_desc={sizeof(src_desc)};
if( src->Lock( 0,&src_desc,DDLOCK_WAIT,0 )<0 ) abort();
unsigned char *src_p=(unsigned char*)src_desc.lpSurface;
PixelFormat src_fmt( src_desc.ddpfPixelFormat );
DDSURFACEDESC2 dest_desc={sizeof(dest_desc)};
if( dest->Lock( 0,&dest_desc,DDLOCK_WAIT,0 )<0 ) abort();
unsigned char *dest_p=(unsigned char *)dest_desc.lpSurface;
PixelFormat dest_fmt( dest_desc.ddpfPixelFormat );
if( src_desc.dwWidth==1 ){
for( int y=0;y<dest_desc.dwHeight;++y ){
unsigned p1=src_fmt.getPixel( src_p );
unsigned p2=src_fmt.getPixel( src_p+src_desc.lPitch );
unsigned argb=
((p1&0xfefefefe)>>1)+((p2&0xfefefefe)>>1);
argb+=( (
(p1&0x01010101)+(p2&0x01010101) )>>1 ) & 0x01010101;
dest_fmt.setPixel( dest_p,argb );
src_p+=src_desc.lPitch*2;
dest_p+=dest_desc.lPitch;
}
}else if( src_desc.dwHeight==1 ){
for( int x=0;x<dest_desc.dwWidth;++x ){
unsigned p1=src_fmt.getPixel( src_p );
unsigned p2=src_fmt.getPixel( src_p+src_fmt.getPitch() );
unsigned argb=
((p1&0xfefefefe)>>1)+((p2&0xfefefefe)>>1);
argb+=( (
(p1&0x01010101)+(p2&0x01010101) )>>1 ) & 0x01010101;
dest_fmt.setPixel( dest_p,argb );
src_p+=src_fmt.getPitch()*2;
dest_p+=dest_fmt.getPitch();
}
}else{
for( int y=0;y<dest_desc.dwHeight;++y ){
unsigned char *src_t=src_p;
unsigned char *dest_t=dest_p;
for( int x=0;x<dest_desc.dwWidth;++x ){
unsigned p1=src_fmt.getPixel( src_t );
unsigned p2=src_fmt.getPixel( src_t+src_fmt.getPitch() );
unsigned p3=src_fmt.getPixel( src_t+src_desc.lPitch+src_fmt.getPitch() );
unsigned p4=src_fmt.getPixel( src_t+src_desc.lPitch );
unsigned argb=
((p1&0xfcfcfcfc)>>2)+((p2&0xfcfcfcfc)>>2)+
((p3&0xfcfcfcfc)>>2)+((p4&0xfcfcfcfc)>>2);
argb+=( (
(p1&0x03030303)+(p2&0x03030303)+
(p3&0x03030303)+(p4&0x03030303) )>>2 ) & 0x03030303;
dest_fmt.setPixel( dest_t,argb );
src_t+=src_fmt.getPitch()*2;
dest_t+=dest_fmt.getPitch();
}
src_p+=src_desc.lPitch*2;
dest_p+=dest_desc.lPitch;
}
}
src->Unlock( 0 );
dest->Unlock( 0 );
dest->Release();
src=dest;
}
}
void ddUtil::copy( ddSurf *dest,int dx,int dy,int dw,int dh,ddSurf *src,int sx,int sy,int sw,int sh ){
DDSURFACEDESC2 src_desc={sizeof(src_desc)};
src->Lock( 0,&src_desc,DDLOCK_WAIT,0 );
PixelFormat src_fmt( src_desc.ddpfPixelFormat );
unsigned char *src_p=(unsigned char*)src_desc.lpSurface;
src_p+=src_desc.lPitch*sy+src_fmt.getPitch()*sx;
DDSURFACEDESC2 dest_desc={sizeof(dest_desc)};
dest->Lock( 0,&dest_desc,DDLOCK_WAIT,0 );
PixelFormat dest_fmt( dest_desc.ddpfPixelFormat );
unsigned char *dest_p=(unsigned char *)dest_desc.lpSurface;
dest_p+=dest_desc.lPitch*dy+dest_fmt.getPitch()*dx;
for( int y=0;y<dh;++y ){
unsigned char *dest=dest_p;
unsigned char *src=src_p+src_desc.lPitch*(y*sh/dh);
for( int x=0;x<dw;++x ){
dest_fmt.setPixel( dest,src_fmt.getPixel( src+src_fmt.getPitch()*(x*sw/dw) ) );
dest+=dest_fmt.getPitch();
}
dest_p+=dest_desc.lPitch;
}
src->Unlock( 0 );
dest->Unlock( 0 );
}
ddSurf *ddUtil::createSurface( int w,int h,int flags,gxGraphics *gfx ){
DDSURFACEDESC2 desc={sizeof(desc)};
desc.dwFlags=DDSD_CAPS;
int hi=flags & gxCanvas::CANVAS_TEX_HICOLOR?1:0;
if( w ){ desc.dwWidth=w;desc.dwFlags|=DDSD_WIDTH; }
if( h ){ desc.dwHeight=h;desc.dwFlags|=DDSD_HEIGHT; }
if( flags & gxCanvas::CANVAS_TEX_MASK ){
desc.dwFlags|=DDSD_PIXELFORMAT;
desc.ddpfPixelFormat=gfx->texRGBMaskFmt[hi];
}else if( flags & gxCanvas::CANVAS_TEX_RGB ){
desc.dwFlags|=DDSD_PIXELFORMAT;
desc.ddpfPixelFormat=(flags&gxCanvas::CANVAS_TEX_ALPHA)?gfx->texRGBAlphaFmt[hi]:gfx->texRGBFmt[hi];
}else if( flags & gxCanvas::CANVAS_TEX_ALPHA ){
desc.dwFlags|=DDSD_PIXELFORMAT;
desc.ddpfPixelFormat=gfx->texAlphaFmt[hi];
}else if( flags & gxCanvas::CANVAS_TEXTURE ){
desc.dwFlags|=DDSD_PIXELFORMAT;
desc.ddpfPixelFormat=gfx->primFmt;
}
if( flags & gxCanvas::CANVAS_TEXTURE ){
desc.ddsCaps.dwCaps|=DDSCAPS_TEXTURE;
if( !(flags & gxCanvas::CANVAS_TEX_VIDMEM) ){
desc.ddsCaps.dwCaps2|=DDSCAPS2_TEXTUREMANAGE;
if( flags & gxCanvas::CANVAS_TEX_MIPMAP ){
desc.ddsCaps.dwCaps|=DDSCAPS_MIPMAP|DDSCAPS_COMPLEX;
}
}
if( flags & (gxCanvas::CANVAS_TEX_CUBE) ){
desc.ddsCaps.dwCaps|=DDSCAPS_COMPLEX;
desc.ddsCaps.dwCaps2|=DDSCAPS2_CUBEMAP|DDSCAPS2_CUBEMAP_ALLFACES;
}
adjustTexSize( (int*)&desc.dwWidth,(int*)&desc.dwHeight,gfx->dir3dDev );
}else{
desc.ddsCaps.dwCaps=DDSCAPS_OFFSCREENPLAIN;
if( flags & gxCanvas::CANVAS_HIGHCOLOR ){
desc.dwFlags|=DDSD_PIXELFORMAT;
desc.ddsCaps.dwCaps|=DDSCAPS_SYSTEMMEMORY;
desc.ddpfPixelFormat.dwSize=sizeof(DDPIXELFORMAT);
desc.ddpfPixelFormat.dwFlags=DDPF_RGB|DDPF_ALPHAPIXELS;
desc.ddpfPixelFormat.dwRGBBitCount=32;
desc.ddpfPixelFormat.dwRBitMask=0xff0000;
desc.ddpfPixelFormat.dwGBitMask=0x00ff00;
desc.ddpfPixelFormat.dwBBitMask=0x0000ff;
desc.ddpfPixelFormat.dwRGBAlphaBitMask=0xff000000;
}else if( flags & gxCanvas::CANVAS_NONDISPLAY ){
desc.ddsCaps.dwCaps|=DDSCAPS_SYSTEMMEMORY;
}
}
ddSurf *surf;
if( gfx->dirDraw->CreateSurface( &desc,&surf,0 )>=0 ) return surf;
if( desc.ddsCaps.dwCaps & DDSCAPS_OFFSCREENPLAIN ){
if( !(desc.ddsCaps.dwCaps & DDSCAPS_SYSTEMMEMORY) ){
//try again in system memory!
desc.ddsCaps.dwCaps|=DDSCAPS_SYSTEMMEMORY;
if( gfx->dirDraw->CreateSurface( &desc,&surf,0 )>=0 ) return surf;
}
}
return 0;
}
//Tom Speed's DXTC loader
//
IDirectDrawSurface7 *loadDXTC(const char* filename,gxGraphics *gfx)
{
HRESULT hr;
DDSURFACEDESC2 ddsd;
DDSURFACEDESC2 fileddsd;
char magicID[4];
FILE *fp;
/* try to open the file */
fp = fopen(filename, "rb");
if(!fp) return NULL;
/* valid DDS? */
fread(magicID, 1, 4, fp);
if (strncmp(magicID, "DDS ", 4) != 0)
{
fclose(fp);
return NULL;
}
/* get the DXTC file surface description */
fread(&fileddsd, sizeof(DDSURFACEDESC2), 1, fp);
if (fileddsd.dwSize != sizeof(DDSURFACEDESC2))
{
fclose(fp);
return NULL;
}
/* copy the fileddsd before we manipulate it so you
can get neccessary info you want about it later */
memcpy(&ddsd, &fileddsd,sizeof(DDSURFACEDESC2));
/* remove unwanted flags if they exist */
//not sure if this is needed, works without it though
//ddsd.dwFlags &= ~DDSD_LINEARSIZE;
int blockSize = 0;
int chunkSize = 0;
if(ddsd.ddpfPixelFormat.dwFourCC == FOURCC_DXT1)
blockSize = 8; // DXT1
if(ddsd.ddpfPixelFormat.dwFourCC == FOURCC_DXT3)
blockSize = 16; // DXT3
if(ddsd.ddpfPixelFormat.dwFourCC == FOURCC_DXT5)
blockSize = 16; // DXT5
/* if it isn't a format we support, exit */
if (blockSize == 0)
{
fclose(fp);
return NULL;
}
/* add texture manage flag */
ddsd.ddsCaps.dwCaps2|=DDSCAPS2_TEXTUREMANAGE;
/* Create the new DXTC surface using the DDSURFACEDESC2
we read in from the file */
IDirectDrawSurface7 * newSurf = NULL;
hr = gfx->dirDraw->CreateSurface(&ddsd, &newSurf, NULL);
if(FAILED(hr))
{
fclose(fp);
return NULL;
}
/* Define what type of child surfaces we may wish
to access, in this case MipMaps */
DDSCAPS2 mipmapddsd;
ZeroMemory(&mipmapddsd,sizeof(DDSCAPS2));
mipmapddsd.dwCaps = DDSCAPS_TEXTURE|DDSCAPS_MIPMAP|DDSCAPS_COMPLEX;
/* pointers used when iterating through mipmaps */
IDirectDrawSurface7 *topDDS = NULL;
IDirectDrawSurface7 *nextDDS = NULL;
topDDS = newSurf;
topDDS->AddRef();
while(TRUE)
{
/* get a description of this surface */
hr = topDDS->Lock(NULL,&ddsd,DDLOCK_WAIT,NULL);
if(FAILED(hr))
{
fclose(fp);
topDDS->Release();
newSurf->Release();
nextDDS->Release();
return NULL;
}
/* how big the raw data is for this surface */
chunkSize = ((ddsd.dwWidth+3)/4) * ((ddsd.dwHeight+3)/4) * blockSize;
/* read in the raw DXTC surface data */
if(!fread(ddsd.lpSurface, chunkSize, 1, fp))
{
fclose(fp);
topDDS->Release();
newSurf->Release();
nextDDS->Release();
return NULL;
}
topDDS->Unlock(NULL);
/* Get next mipmap in chain, or exit the loop if there's no more */
hr = topDDS->GetAttachedSurface(&mipmapddsd,&nextDDS);
if(FAILED(hr))
{
fclose(fp);
topDDS->Release();
break;
}
topDDS->Release();
topDDS = nextDDS;
nextDDS->Release();
}
return newSurf;
}
ddSurf *ddUtil::loadSurface( const std::string &f,int flags,gxGraphics *gfx ){
int i=f.find( ".dds" );
if( i!=string::npos && i+4==f.size() ){
//dds file!
ddSurf *surf=loadDXTC( f.c_str(),gfx );
return surf;
}
FreeImage_Initialise();
FREE_IMAGE_FORMAT fmt=FreeImage_GetFileType( f.c_str(),f.size() );
if( fmt==FIF_UNKNOWN ){
int n=f.find( "." );if( n==string::npos ) return 0;
fmt=FreeImage_GetFileTypeFromExt( f.substr(n+1).c_str() );
if( fmt==FIF_UNKNOWN ) return 0;
}
FIBITMAP *t_dib=FreeImage_Load( fmt,f.c_str(),0 );
if( !t_dib ) return 0;
bool trans=FreeImage_GetBPP( t_dib )==32 || FreeImage_IsTransparent( t_dib );
FIBITMAP *dib=FreeImage_ConvertTo32Bits( t_dib );
if( dib ) FreeImage_Unload( t_dib );
else dib=t_dib;
int width=FreeImage_GetWidth(dib);
int height=FreeImage_GetHeight(dib);
int pitch=FreeImage_GetPitch(dib);
void *bits=FreeImage_GetBits(dib);
ddSurf *src=::createSurface( width,height,pitch,bits,gfx->dirDraw );
if( !src ){
FreeImage_Unload( dib );
return 0;
}
if( flags & gxCanvas::CANVAS_TEX_ALPHA ){
if( flags & gxCanvas::CANVAS_TEX_MASK ){
buildMask( src );
}else if( !trans ){
buildAlpha( src,(flags & gxCanvas::CANVAS_TEX_RGB)?false:true );
}
}else{
unsigned char *p=(unsigned char *)bits;
for( int k=0;k<height;++k ){
unsigned char *t=p+3;
for( int j=0;j<width;++j ){
*t=0xff;t+=4;
}
p+=pitch;
}
}
ddSurf *dest=createSurface( width,height,flags,gfx );
if( !dest ){
src->Release();
FreeImage_Unload( dib );
return 0;
}
int t_w=width,t_h=height;
if( flags & gxCanvas::CANVAS_TEXTURE ) adjustTexSize( &t_w,&t_h,gfx->dir3dDev );
copy( dest,0,0,t_w,t_h,src,0,height-1,width,-height );
src->Release();
FreeImage_Unload( dib );
return dest;
}
Reference in New Issue View Git Blame Copy Permalink