TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-10-04 10:54:24 -04:00
Code Issues Packages Projects Releases Wiki Activity

handle ARGB or BGRA panda pixbuf fmts, note scrnsave option is still busted

Browse Source
This commit is contained in:
cxgeorge 2002-02-21 06:47:08 +00:00
parent b145370ccd
commit 7ab691bc8e
2 changed files with 229 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
panda/src/dxgsg/dxGraphicsStateGuardian.cxx
View File

@ -297,7 +297,7 @@ void DXGraphicsStateGuardian::FillFPSMeterTexture(void) {
return; return;
} }
HFONT hfnt = (HFONT) GetStockObject(ANSI_FIXED_FONT); HFONT hfnt = (HFONT) GetStockObject(ANSI_VAR_FONT);
(void) SelectObject(hDC, hfnt); (void) SelectObject(hDC, hfnt);
SetTextColor(hDC, RGB(255,255,128) ); SetTextColor(hDC, RGB(255,255,128) );
@ -6522,7 +6522,12 @@ void DXGraphicsStateGuardian::show_full_screen_frame(void) {
// Flip the front and back buffers, to make what we just rendered // Flip the front and back buffers, to make what we just rendered
// visible. // visible.
if(!_overlay_windows_supported) { if (_overlay_windows_supported) {
// If we're asking for overlay windows, we have to blt instead of
// flip, so we don't lose the window.
hr = scrn.pddsPrimary->Blt( NULL, scrn.pddsBack, NULL, DDBLT_WAIT, NULL );
} else {
// Normally, we can just do the fast flip operation. // Normally, we can just do the fast flip operation.
DWORD dwFlipFlags = DDFLIP_WAIT; DWORD dwFlipFlags = DDFLIP_WAIT;
@ -6539,11 +6544,6 @@ void DXGraphicsStateGuardian::show_full_screen_frame(void) {
// bugbug: dont we want triple buffering instead of wasting time // bugbug: dont we want triple buffering instead of wasting time
// waiting for vsync? // waiting for vsync?
hr = scrn.pddsPrimary->Flip( NULL, dwFlipFlags); hr = scrn.pddsPrimary->Flip( NULL, dwFlipFlags);
} else {
// If we're asking for overlay windows, we have to blt instead of
// flip, so we don't lose the window.
hr = scrn.pddsPrimary->Blt( NULL, scrn.pddsBack, NULL, DDBLT_WAIT, NULL );
}
if(FAILED(hr)) { if(FAILED(hr)) {
if((hr == DDERR_SURFACELOST) || (hr == DDERR_SURFACEBUSY)) { if((hr == DDERR_SURFACELOST) || (hr == DDERR_SURFACEBUSY)) {
@ -6555,6 +6555,8 @@ void DXGraphicsStateGuardian::show_full_screen_frame(void) {
} }
} }
}
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
// Function: show_windowed_frame // Function: show_windowed_frame
// Access: Public // Access: Public

347
panda/src/dxgsg/dxTextureContext.cxx
View File

@ -23,22 +23,41 @@
#include "dxGraphicsStateGuardian.h" #include "dxGraphicsStateGuardian.h"
#include "pnmImage.h" #include "pnmImage.h"
//#define FORCE_16bpp_1555
static const DWORD g_LowByteMask = 0x000000FF;
#define FORCE_16bpp_1555
//#define PANDA_ARGB_ORDER
#ifdef PANDA_ARGB_ORDER
// assume Panda uses int ARGB format in PixelBuffers natively (byte-order BGRA or BGR)
// these macros GET from PixelBuffer, (wont work from DDSurface)
#define GET_RED_BYTE(PIXEL_DWORD) ((BYTE)((PIXEL_DWORD >> 16) & g_LowByteMask))
#define GET_BLUE_BYTE(PIXEL_DWORD) ((BYTE)((PIXEL_DWORD) & g_LowByteMask))
#else
// otherwise Panda uses int ABGR (big-endian RGBA order), (byte-order RGBA or RGB)
#define GET_RED_BYTE(PIXEL_DWORD) ((BYTE)(PIXEL_DWORD & g_LowByteMask))
#define GET_BLUE_BYTE(PIXEL_DWORD) ((BYTE)((PIXEL_DWORD >> 16) & g_LowByteMask))
#endif
#define GET_GREEN_BYTE(PIXEL_DWORD) ((BYTE)((PIXEL_DWORD >> 8) & g_LowByteMask))
#define GET_ALPHA_BYTE(PIXEL_DWORD) ((BYTE)(((DWORD)PIXEL_DWORD) >> 24)) // unsigned >> shifts in 0's, so dont need to mask off upper bits
typedef enum { typedef enum {
None,Conv32to32,Conv32to32_NoAlpha,Conv32to24,Conv32to16_0555, None,Conv32to32,Conv32to32_NoAlpha,Conv32to24,Conv32to16_X555,
Conv32to16_1555,Conv32to16_0565,Conv32to16_4444,Conv24to32,Conv24to24, Conv32to16_1555,Conv32to16_0565,Conv32to16_4444,Conv24to32,Conv24to24,
Conv24to16_0555,Conv24to16_0565,ConvLum16to16_1555,ConvLum16to16_4444, Conv24to16_X555,Conv24to16_0565,ConvLum16to16_1555,ConvLum16to16_4444,
ConvLum16to32,ConvLum16to16,ConvLum8to8,ConvLum8to24,ConvLum8to32,ConvLum8to16_0555,ConvLum8to16_0565, ConvLum16to32,ConvLum16to16,ConvLum8to8,ConvLum8to24,ConvLum8to32,ConvLum8to16_X555,ConvLum8to16_0565,
ConvAlpha8to16_4444,ConvAlpha8to32,ConvAlpha8to8 ConvAlpha8to16_4444,ConvAlpha8to32,ConvAlpha8to8
} ConversionType; } ConversionType;
#ifndef NDEBUG #ifndef NDEBUG
char *ConvNameStrs[] = {"None","Conv32to32","Conv32to32_NoAlpha","Conv32to24","Conv32to16_0555", char *ConvNameStrs[] = {"None","Conv32to32","Conv32to32_NoAlpha","Conv32to24","Conv32to16_X555",
"Conv32to16_1555","Conv32to16_0565","Conv32to16_4444","Conv24to32","Conv24to24", "Conv32to16_1555","Conv32to16_0565","Conv32to16_4444","Conv24to32","Conv24to24",
"Conv24to16_0555","Conv24to16_0565","ConvLum16to16_1555","ConvLum16to16_4444", "Conv24to16_X555","Conv24to16_0565","ConvLum16to16_1555","ConvLum16to16_4444",
"ConvLum16to32","ConvLum16to16","ConvLum8to8","ConvLum8to24","ConvLum8to32", "ConvLum16to32","ConvLum16to16","ConvLum8to8","ConvLum8to24","ConvLum8to32",
"ConvLum8to16_0555","ConvLum8to16_0565","ConvAlpha8to16_4444","ConvAlpha8to32","ConvAlpha8to8" "ConvLum8to16_X555","ConvLum8to16_0565","ConvAlpha8to16_4444","ConvAlpha8to32","ConvAlpha8to8"
}; };
#endif #endif
@ -46,7 +65,6 @@ char *PandaFilterNameStrs[] = {"FT_nearest","FT_linear","FT_nearest_mipmap_neare
"FT_nearest_mipmap_linear", "FT_linear_mipmap_linear" "FT_nearest_mipmap_linear", "FT_linear_mipmap_linear"
}; };
TypeHandle DXTextureContext::_type_handle; TypeHandle DXTextureContext::_type_handle;
#define SWAPDWORDS(X,Y) { DWORD temp=X; X=Y; Y=temp; } #define SWAPDWORDS(X,Y) { DWORD temp=X; X=Y; Y=temp; }
@ -200,6 +218,7 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
dxgsg_cat.error() << "CreateTexture failed: _surface->Lock() failed on texture! hr = " << ConvD3DErrorToString(hr) << "\n"; dxgsg_cat.error() << "CreateTexture failed: _surface->Lock() failed on texture! hr = " << ConvD3DErrorToString(hr) << "\n";
return hr; return hr;
} }
//pbuf contains raw ARGB in PixelBuffer byteorder //pbuf contains raw ARGB in PixelBuffer byteorder
DWORD lPitch = ddsd.lPitch; DWORD lPitch = ddsd.lPitch;
@ -210,70 +229,72 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
case Conv32to32: case Conv32to32:
case Conv32to32_NoAlpha: { case Conv32to32_NoAlpha: {
#ifdef PANDA_ARGB_ORDER
if(ConvNeeded==Conv32to32) {
memcpy(pDDSurfBytes,(BYTE*) pbuf,dwOrigWidth*dwOrigHeight*sizeof(DWORD));
} else {
DWORD *pSrcWord = (DWORD *) pbuf; DWORD *pSrcWord = (DWORD *) pbuf;
DWORD *pDstWord; DWORD *pDstWord;
DWORD dwAlphaMaskOff = (ConvNeeded==Conv32to32_NoAlpha) ? 0x00FFFFFF : 0xFFFFFFFF;
// need to set all pixels alpha to 0xFF
for(DWORD y=0; y<dwOrigHeight; y++,pDDSurfBytes+=ddsd.lPitch) {
pDstWord = (DWORD*)pDDSurfBytes;
for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord++,pDstWord++) {
*pDstWord = *pSrcWord | 0xFF000000;
}
}
}
#else
DWORD *pDstWord,*pSrcWord = (DWORD *) pbuf;
DWORD dwAlphaMaskOn = (ConvNeeded==Conv32to32_NoAlpha) ? 0xFF000000 : 0x0;
for(DWORD y=0; y<dwOrigHeight; y++,pDDSurfBytes+=ddsd.lPitch) { for(DWORD y=0; y<dwOrigHeight; y++,pDDSurfBytes+=ddsd.lPitch) {
pDstWord = (DWORD*)pDDSurfBytes; pDstWord = (DWORD*)pDDSurfBytes;
for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord++,pDstWord++) { for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord++,pDstWord++) {
DWORD dwPixel = *pSrcWord; DWORD dwPixel = *pSrcWord;
// pixel buffer is in ABGR format(it stores big-endian RGBA) // pixel buffer is in ABGR format(it stores big-endian RGBA)
// need to change byte order to ARGB // need to change byte order to ARGB
#if 0
BYTE r,g,b,a;
a = (BYTE)((dwPixel>>24)); // unsigned >>, no need to &
b = (BYTE)((dwPixel>>16)&0x000000ff);
g = (BYTE)((dwPixel>> 8)&0x000000ff);
r = (BYTE)((dwPixel )&0x000000ff);
*pDstWord = (a << 24) | (r << 16)| (g << 8) | b;
#else
BYTE r,b; BYTE r,b;
// simpler: just swap r & b // just swap r & b
b = (BYTE)((dwPixel>>16)&0x000000ff); b = GET_BLUE_BYTE(dwPixel);
r = (BYTE)((dwPixel )&0x000000ff); r = GET_RED_BYTE(dwPixel);
*pDstWord = ((dwPixel & 0xff00ff00) | (r<<16) | b) & dwAlphaMaskOff; *pDstWord = ((dwPixel & 0xff00ff00) | (r<<16) | b) | dwAlphaMaskOn;
}
}
#endif #endif
}
}
break; break;
} }
case Conv32to16_1555: case Conv32to16_1555:
case Conv32to16_0555: { case Conv32to16_X555: {
DWORD *pSrcWord = (DWORD *) pbuf; DWORD *pSrcWord = (DWORD *) pbuf;
WORD *pDstWord; WORD *pDstWord;
DWORD dwAlphaMaskOff = (ConvNeeded==Conv32to16_0555) ? 0x7FFF : 0xFFFF;
unsigned short dwAlphaMaskOn = (ConvNeeded==Conv32to16_X555) ? 0x8000 : 0x0;
assert(ddsd.ddpfPixelFormat.dwRBitMask==0x7C00); assert(ddsd.ddpfPixelFormat.dwRBitMask==0x7C00);
// for some reason, bits are 'in-order' when converting to 16bit
// just handle 1/15 alpha/rgb
for(DWORD y=0; y<dwOrigHeight; y++,pDDSurfBytes+=ddsd.lPitch) { for(DWORD y=0; y<dwOrigHeight; y++,pDDSurfBytes+=ddsd.lPitch) {
pDstWord = (WORD*)pDDSurfBytes; pDstWord = (WORD*)pDDSurfBytes;
for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord++,pDstWord++) { for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord++,pDstWord++) {
BYTE r,g,b; BYTE r,g,b;
DWORD abit,dwPixel = *pSrcWord; DWORD dwPixel = *pSrcWord;
unsigned short abit;
// pixel buffer is in ABGR format (orig fmt designed for big-endian RGBA)
// need to change byte order to ARGB
abit = ((dwPixel>>16) & 0x00008000); // just copy high bit
// just look at most-signf-bit for alpha. (alternately, could // just look at most-signf-bit for alpha. (alternately, could
// convert any non-zero alpha to full transparent) // convert any non-zero alpha to full transparent)
b = (BYTE)((dwPixel>>16) & 0x000000ff) >> 3; abit = ((dwPixel>>16) & 0x00008000) | dwAlphaMaskOn; // just copy high bit
g = (BYTE)((dwPixel>> 8) & 0x000000ff) >> 3; g = GET_GREEN_BYTE(dwPixel) >> 3;
r = (BYTE)((dwPixel ) & 0x000000ff) >> 3; b = GET_BLUE_BYTE(dwPixel) >> 3;
r = GET_RED_BYTE(dwPixel) >> 3;
// code truncates 8 bit values to 5 bit (or 1 for alpha) // truncates 8 bit values to 5 bit (or 1 for alpha)
*pDstWord = (abit | (r << 10)| (g << 5) | b) & dwAlphaMaskOff; *pDstWord = (abit | (r << 10)| (g << 5) | b);
} }
} }
break; break;
@ -286,7 +307,6 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
assert(ddsd.ddpfPixelFormat.dwRBitMask==0xF800); assert(ddsd.ddpfPixelFormat.dwRBitMask==0xF800);
// for some reason, bits are 'in-order' when converting to 16bit // for some reason, bits are 'in-order' when converting to 16bit
// just handle 1/15 alpha/rgb
for(DWORD y=0; y<dwOrigHeight; y++,pDDSurfBytes+=ddsd.lPitch) { for(DWORD y=0; y<dwOrigHeight; y++,pDDSurfBytes+=ddsd.lPitch) {
pDstWord = (WORD*)pDDSurfBytes; pDstWord = (WORD*)pDDSurfBytes;
@ -294,52 +314,15 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
BYTE r,g,b; BYTE r,g,b;
DWORD dwPixel = *pSrcWord; DWORD dwPixel = *pSrcWord;
// pixel buffer is in ABGR format (orig fmt designed for big-endian RGBA) g = GET_GREEN_BYTE(dwPixel) >> 2;
// need to change byte order to ARGB b = GET_BLUE_BYTE(dwPixel) >> 3;
r = GET_RED_BYTE(dwPixel) >> 3;
// just look at most-signf-bit for alpha. (alternately, could
// convert any non-zero alpha to full transparent)
b = (BYTE)((dwPixel>>16) & 0x000000ff) >> 3;
g = (BYTE)((dwPixel>> 8) & 0x000000ff) >> 2;
r = (BYTE)((dwPixel ) & 0x000000ff) >> 3;
// code truncates 8 bit values to 5 bit (or 1 for alpha)
*pDstWord = ((r << 11)| (g << 5) | b); *pDstWord = ((r << 11)| (g << 5) | b);
} }
} }
break; break;
} }
case Conv32to24: {
DWORD *pSrcWord = (DWORD *) pbuf;
BYTE *pDstWord;
for(DWORD y=0; y<dwOrigHeight; y++,pDDSurfBytes+=ddsd.lPitch) {
pDstWord = (BYTE*)pDDSurfBytes;
for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord++,pDstWord+=3) {
// pixel buffer is in ABGR format(it stores big-endian RGBA)
// need to change byte order to ARGB
BYTE r,g,b;
DWORD dwPixel = *pSrcWord;
b = (BYTE)((dwPixel>>16) & 0x000000ff);
g = (BYTE)((dwPixel>> 8) & 0x000000ff);
r = (BYTE)((dwPixel ) & 0x000000ff);
*pDstWord = r;
*(pDstWord+1) = g;
*(pDstWord+2) = b;
}
}
break;
}
case Conv32to16_4444: { case Conv32to16_4444: {
DWORD *pSrcWord = (DWORD *) pbuf; DWORD *pSrcWord = (DWORD *) pbuf;
WORD *pDstWord; WORD *pDstWord;
@ -354,13 +337,10 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
BYTE r,g,b,a; BYTE r,g,b,a;
DWORD dwPixel = *pSrcWord; DWORD dwPixel = *pSrcWord;
// pixel buffer is in ABGR format (orig fmt designed for big-endian RGBA) a = GET_ALPHA_BYTE(dwPixel) >> 4;
// need to change byte order to ARGB g = GET_GREEN_BYTE(dwPixel) >> 4;
b = GET_BLUE_BYTE(dwPixel) >> 4;
a = (BYTE)((dwPixel>>24)) >> 4; r = GET_RED_BYTE(dwPixel) >> 4;
b = (BYTE)((dwPixel>>16) & 0x000000ff) >> 4;
g = (BYTE)((dwPixel>> 8) & 0x000000ff) >> 4;
r = (BYTE)((dwPixel ) & 0x000000ff) >> 4;
*pDstWord = (a << 12) | (r << 8)| (g << 4) | b; *pDstWord = (a << 12) | (r << 8)| (g << 4) | b;
} }
@ -368,9 +348,35 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
break; break;
} }
case Conv32to24: {
DWORD *pSrcWord = (DWORD *) pbuf;
BYTE *pDstWord;
for(DWORD y=0; y<dwOrigHeight; y++,pDDSurfBytes+=ddsd.lPitch) {
pDstWord = (BYTE*)pDDSurfBytes;
for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord++,pDstWord+=3) {
BYTE r,g,b;
DWORD dwPixel = *pSrcWord;
r = GET_RED_BYTE(dwPixel);
g = GET_GREEN_BYTE(dwPixel);
b = GET_BLUE_BYTE(dwPixel);
*pDstWord = r;
*(pDstWord+1) = g;
*(pDstWord+2) = b;
}
}
break;
}
case Conv24to24: { case Conv24to24: {
#ifdef PANDA_ARGB_ORDER
memcpy(pDDSurfBytes,(BYTE*)pbuf,dwOrigHeight*dwOrigWidth*3);
#else
BYTE *pSrcWord = (BYTE *) pbuf; BYTE *pSrcWord = (BYTE *) pbuf;
BYTE *pDstWord; BYTE *pDstWord;
@ -379,8 +385,6 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord+=3,pDstWord+=3) { for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord+=3,pDstWord+=3) {
BYTE r,g,b; BYTE r,g,b;
// pixel buffer is in ABGR format(it stores big-endian RGBA)
// need to change byte order to ARGB
b = *pSrcWord; b = *pSrcWord;
g = *(pSrcWord+1); g = *(pSrcWord+1);
@ -391,10 +395,11 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
*(pDstWord+2) = b; *(pDstWord+2) = b;
} }
} }
#endif
break; break;
} }
case Conv24to16_0555: { case Conv24to16_X555: {
BYTE *pSrcWord = (BYTE *) pbuf; BYTE *pSrcWord = (BYTE *) pbuf;
WORD *pDstWord; WORD *pDstWord;
@ -407,15 +412,16 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord+=3,pDstWord++) { for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord+=3,pDstWord++) {
BYTE r,g,b; BYTE r,g,b;
// pixel buffer is in ABGR format (orig fmt designed for big-endian RGBA) #ifdef PANDA_ARGB_ORDER
// need to change byte order to ARGB b = *pSrcWord >> 3;
r = *(pSrcWord+2) >> 3;
#else
r = *pSrcWord >> 3; r = *pSrcWord >> 3;
g = *(pSrcWord+1) >> 3;
b = *(pSrcWord+2) >> 3; b = *(pSrcWord+2) >> 3;
#endif
g = *(pSrcWord+1) >> 3;
// code truncates 8 bit values to 5 bit, leaves high bit as 0 *pDstWord = 0x8000 | (r << 10)| (g << 5) | b;
*pDstWord = (r << 10)| (g << 5) | b;
} }
} }
break; break;
@ -426,7 +432,6 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
WORD *pDstWord; WORD *pDstWord;
assert(ddsd.ddpfPixelFormat.dwRBitMask==0xF800); assert(ddsd.ddpfPixelFormat.dwRBitMask==0xF800);
// for some reason, bits are 'in-order' when converting to 16bit
for(DWORD y=0; y<dwOrigHeight; y++,pDDSurfBytes += ddsd.lPitch) { for(DWORD y=0; y<dwOrigHeight; y++,pDDSurfBytes += ddsd.lPitch) {
pDstWord = (WORD*)pDDSurfBytes; pDstWord = (WORD*)pDDSurfBytes;
@ -434,14 +439,16 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord+=3,pDstWord++) { for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord+=3,pDstWord++) {
BYTE r,g,b; BYTE r,g,b;
// pixel buffer is in ABGR format (orig fmt designed for big-endian RGBA) #ifdef PANDA_ARGB_ORDER
// need to change byte order to ARGB b = *pSrcWord >> 3;
g = *(pSrcWord+1) >> 2;
r = *(pSrcWord+2) >> 3;
#else
r = *pSrcWord >> 3; r = *pSrcWord >> 3;
g = *(pSrcWord+1) >> 2; g = *(pSrcWord+1) >> 2;
b = *(pSrcWord+2) >> 3; b = *(pSrcWord+2) >> 3;
#endif
// code truncates 8 bit values to 5 bit, leaves high bit as 0 // code truncates 8 bit values to 5 bit
*pDstWord = (r << 11)| (g << 5) | b; *pDstWord = (r << 11)| (g << 5) | b;
} }
} }
@ -449,7 +456,6 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
} }
case Conv24to32: { case Conv24to32: {
BYTE *pSrcWord = (BYTE *) pbuf; BYTE *pSrcWord = (BYTE *) pbuf;
DWORD *pDstWord; DWORD *pDstWord;
@ -461,13 +467,14 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
// pixel buffer is in ABGR format(it stores big-endian RGBA) // pixel buffer is in ABGR format(it stores big-endian RGBA)
// need to change byte order to ARGB // need to change byte order to ARGB
// bugbug? swapping doesnt work I dont understand why must #ifdef PANDA_ARGB_ORDER
// swap bytes for 32-bit RGBA (herc) but not here in 24bit, b = *pSrcWord;
// where they seem to be in correct order in pixelbuffer r = *(pSrcWord+2);
#else
r = *pSrcWord; r = *pSrcWord;
g = *(pSrcWord+1);
b = *(pSrcWord+2); b = *(pSrcWord+2);
#endif
g = *(pSrcWord+1);
*pDstWord = 0xFF000000 | (r << 16) | (g << 8) | b; *pDstWord = 0xFF000000 | (r << 16) | (g << 8) | b;
} }
@ -476,7 +483,6 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
} }
case ConvLum16to32: { case ConvLum16to32: {
WORD *pSrcWord = (WORD *) pbuf; WORD *pSrcWord = (WORD *) pbuf;
DWORD *pDstWord; DWORD *pDstWord;
@ -487,12 +493,11 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
// pixel buffer is in ABGR format(it stores big-endian RGBA) // pixel buffer is in ABGR format(it stores big-endian RGBA)
// need to change byte order to ARGB // need to change byte order to ARGB
DWORD dwPixel=*pSrcWord; DWORD dwPixel=*pSrcWord;
BYTE r,a; BYTE lum,a;
a = dwPixel >> 8; a = dwPixel >> 8;
r = dwPixel & 0xFF; lum = dwPixel & 0xFF;
*pDstWord = (a<<24) | lum | (lum << 8) | (lum << 16);
*pDstWord = (a<<24)| (r << 16)| (r << 8) | r;
} }
} }
break; break;
@ -509,13 +514,13 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord++,pDstWord++) { for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord++,pDstWord++) {
DWORD dwPixel=*pSrcWord; DWORD dwPixel=*pSrcWord;
BYTE r,a; BYTE lum,a;
dwPixel = *pSrcWord; dwPixel = *pSrcWord;
a = (BYTE)(dwPixel>>8) >> 4; a = (BYTE)(dwPixel>>8) >> 4;
r = (BYTE)(dwPixel & 0x000000ff) >> 4; lum = (BYTE)(dwPixel & 0x000000ff) >> 4;
*pDstWord = (a << 12) | (r << 8)| (r << 4) | r; *pDstWord = (a << 12) | lum | (lum << 4)| (lum << 8);
} }
} }
break; break;
@ -531,30 +536,30 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
pDstWord = (WORD*)pDDSurfBytes; pDstWord = (WORD*)pDDSurfBytes;
for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord++,pDstWord++) { for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord++,pDstWord++) {
DWORD dwPixel=*pSrcWord; WORD dwPixel=*pSrcWord;
BYTE r; BYTE lum;
r = (BYTE)(dwPixel & 0x000000ff) >> 3; lum = (BYTE)(dwPixel & 0x00FF) >> 3;
*pDstWord = (dwPixel & 0x8000) | (r << 10)| (r << 5) | r; *pDstWord = (dwPixel & 0x8000) | lum | (lum << 5) | (lum << 10);
} }
} }
break; break;
} }
case ConvLum16to16: { case ConvLum16to16: {
// AL bytes are in same order // All bytes are in same order?
CopyMemory(pDDSurfBytes,pbuf,dwOrigWidth*dwOrigHeight*2); CopyMemory(pDDSurfBytes,pbuf,dwOrigWidth*dwOrigHeight*2);
break; break;
} }
case ConvLum8to16_0565: case ConvLum8to16_0565:
case ConvLum8to16_0555: { case ConvLum8to16_X555: {
BYTE *pSrcWord = (BYTE *) pbuf; BYTE *pSrcWord = (BYTE *) pbuf;
WORD *pDstWord; WORD *pDstWord;
DWORD FarShift,OrVal,MiddleRoundShift; DWORD FarShift,OrVal,MiddleRoundShift;
if(ConvNeeded==ConvLum8to16_0555) { if(ConvNeeded==ConvLum8to16_X555) {
FarShift=10; OrVal=0x8000; // turn on alpha bit, just in case FarShift=10; OrVal=0x8000; // turn on alpha bit, just in case
MiddleRoundShift = 3; MiddleRoundShift = 3;
assert(ddsd.ddpfPixelFormat.dwRBitMask==0x7C00); assert(ddsd.ddpfPixelFormat.dwRBitMask==0x7C00);
@ -599,14 +604,13 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord++,pDstWord++) { for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord++,pDstWord++) {
DWORD dwPixel=*pSrcWord; DWORD dwPixel=*pSrcWord;
*pDstWord = 0xFF000000 | (dwPixel<<16) | (dwPixel<<8) | dwPixel; *pDstWord = 0xFF000000 | dwPixel | (dwPixel << 8) | (dwPixel<<16);
} }
} }
break; break;
} }
case ConvLum8to24: { case ConvLum8to24: {
// this is kind of a waste of space, but we trade it for lum resolution // this is kind of a waste of space, but we trade it for lum resolution
BYTE *pSrcWord = (BYTE *) pbuf; BYTE *pSrcWord = (BYTE *) pbuf;
BYTE *pDstWord; BYTE *pDstWord;
@ -626,8 +630,7 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
} }
case ConvAlpha8to32: { case ConvAlpha8to32: {
// huge waste of space, but this may be only fmt where we get 8bits alpha resolution
// waste of space, but this is only place we can get 8bits alpha resolution
BYTE *pSrcWord = (BYTE *) pbuf; BYTE *pSrcWord = (BYTE *) pbuf;
DWORD *pDstWord; DWORD *pDstWord;
@ -636,7 +639,7 @@ HRESULT ConvertPixBuftoDDSurf(ConversionType ConvNeeded,BYTE *pbuf,LPDIRECTDRAWS
for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord++,pDstWord++) { for(DWORD x=0; x<dwOrigWidth; x++,pSrcWord++,pDstWord++) {
// OR alpha with full white // OR alpha with full white
*pDstWord = (*pSrcWord << 24) | 0xFFFFFF; *pDstWord = (*pSrcWord << 24) | 0x00FFFFFF;
} }
} }
break; break;
@ -696,7 +699,8 @@ HRESULT ConvertDDSurftoPixBuf(PixelBuffer *pixbuf,LPDIRECTDRAWSURFACE7 pDDSurf)
DWORD dwXWindowOffset=0,dwYWindowOffset=0; DWORD dwXWindowOffset=0,dwYWindowOffset=0;
DWORD dwCopyWidth=ddsd.dwWidth,dwCopyHeight=ddsd.dwHeight; DWORD dwCopyWidth=ddsd.dwWidth,dwCopyHeight=ddsd.dwHeight;
// get window offset so we know where to start grabbing pixels // get window offset so we know where to start grabbing pixels. note for
// fullscreen primary no clipper will be attached, that 'error' should be ignored
LPDIRECTDRAWCLIPPER pDDClipper; LPDIRECTDRAWCLIPPER pDDClipper;
hr = pDDSurf->GetClipper(&pDDClipper); hr = pDDSurf->GetClipper(&pDDClipper);
@ -746,30 +750,42 @@ HRESULT ConvertDDSurftoPixBuf(PixelBuffer *pixbuf,LPDIRECTDRAWSURFACE7 pDDSurf)
DWORD lPitch = ddsd.lPitch; DWORD lPitch = ddsd.lPitch;
BYTE* pDDSurfBytes = (BYTE*)ddsd.lpSurface; BYTE* pDDSurfBytes = (BYTE*)ddsd.lpSurface;
// writes out last line in DDSurf first in PixelBuf, so Y line order precedes inversely
if(dxgsg_cat.is_debug())
dxgsg_cat.debug() << "ConvertDDSurftoPixBuf converting " << ddsd.ddpfPixelFormat.dwRGBBitCount << "bpp DDSurf to "
<< dwNumComponents << "-channel panda PixelBuffer\n";
if(dwNumComponents==4) { if(dwNumComponents==4) {
DWORD *pDstWord = (DWORD *) pbuf; DWORD *pDstWord = (DWORD *) pbuf;
switch(ddsd.ddpfPixelFormat.dwRGBBitCount) { switch(ddsd.ddpfPixelFormat.dwRGBBitCount) {
case 32: { case 32: {
DWORD *pSrcWord; DWORD *pSrcWord;
#ifdef PANDA_ARGB_ORDER
BYTE *pDstLine = (BYTE*)pDstWord;
#endif
pDDSurfBytes+=ddsd.lPitch*(dwYWindowOffset+dwCopyHeight-1); pDDSurfBytes+=ddsd.lPitch*(dwYWindowOffset+dwCopyHeight-1);
for(DWORD y=0; y<dwCopyHeight; y++,pDDSurfBytes-=ddsd.lPitch) { for(DWORD y=0; y<dwCopyHeight; y++,pDDSurfBytes-=ddsd.lPitch) {
pSrcWord = ((DWORD*)pDDSurfBytes)+dwXWindowOffset; pSrcWord = ((DWORD*)pDDSurfBytes)+dwXWindowOffset;
#ifdef PANDA_ARGB_ORDER
memcpy(pDstLine,pSrcWord,ddsd.lPitch);
pDstLine+=ddsd.lPitch;
#else
for(DWORD x=0; x<dwCopyWidth; x++,pSrcWord++,pDstWord++) { for(DWORD x=0; x<dwCopyWidth; x++,pSrcWord++,pDstWord++) {
BYTE r,g,b;
DWORD dwPixel = *pSrcWord; DWORD dwPixel = *pSrcWord;
BYTE r,b;
// pixel buffer is in ABGR format(it stores big-endian RGBA) // DDsurf is in ARGB
// need to change byte order from ARGB r= (BYTE) ((dwPixel >> 16) & g_LowByteMask);
b = (BYTE) (dwPixel & g_LowByteMask);
// simpler: just swap r & b // want to write out ABGR
r = (BYTE)((dwPixel>>16)&0x000000ff); *pDstWord = (dwPixel & 0xFF00FF00) | (b<<16) | r;
g = (BYTE)((dwPixel>> 8)&0x000000ff);
b = (BYTE)((dwPixel )&0x000000ff);
*pDstWord = (dwPixel & 0xff00ff00) | (r<<16) | b;
} }
#endif
} }
break; break;
} }
@ -783,21 +799,21 @@ HRESULT ConvertDDSurftoPixBuf(PixelBuffer *pixbuf,LPDIRECTDRAWSURFACE7 pDDSurf)
for(DWORD x=0; x<dwCopyWidth; x++,pDstWord++) { for(DWORD x=0; x<dwCopyWidth; x++,pDstWord++) {
DWORD r,g,b; DWORD r,g,b;
// pixel buffer is in ABGR format(it stores big-endian RGBA)
// need to change byte order from ARGB
b = *pSrcByte++; b = *pSrcByte++;
g = *pSrcByte++; g = *pSrcByte++;
r = *pSrcByte++; r = *pSrcByte++;
#ifdef PANDA_ARGB_ORDER
*pDstWord = 0xFF000000 | (r << 16) | (g << 8) | b; *pDstWord = 0xFF000000 | (r << 16) | (g << 8) | b;
#else
*pDstWord = 0xFF000000 | (b << 16) | (g << 8) | r;
#endif
} }
} }
break; break;
} }
case 16: { case 16: {
assert((ddsd.ddpfPixelFormat.dwRBitMask==0xF800) || // 565 assert((ddsd.ddpfPixelFormat.dwRBitMask==0xF800) || // 565
(ddsd.ddpfPixelFormat.dwRBitMask==0x0F00) || // 4444 (ddsd.ddpfPixelFormat.dwRBitMask==0x0F00) || // 4444
(ddsd.ddpfPixelFormat.dwRBitMask==0x7C00)); // 555 or 1555 (ddsd.ddpfPixelFormat.dwRBitMask==0x7C00)); // 555 or 1555
@ -842,7 +858,11 @@ HRESULT ConvertDDSurftoPixBuf(PixelBuffer *pixbuf,LPDIRECTDRAWSURFACE7 pDDSurf)
g = (dwPixel & greenmask) >> greenshift; g = (dwPixel & greenmask) >> greenshift;
r = (dwPixel & redmask) >> redshift; r = (dwPixel & redmask) >> redshift;
#ifdef PANDA_ARGB_ORDER
*pDstWord = 0xFF000000 | (r << 16) | (g << 8) | b;
#else
*pDstWord = 0xFF000000 | (b << 16) | (g << 8) | r; *pDstWord = 0xFF000000 | (b << 16) | (g << 8) | r;
#endif
} }
} }
} }
@ -863,17 +883,19 @@ HRESULT ConvertDDSurftoPixBuf(PixelBuffer *pixbuf,LPDIRECTDRAWSURFACE7 pDDSurf)
BYTE r,g,b; BYTE r,g,b;
DWORD dwPixel = *pSrcWord; DWORD dwPixel = *pSrcWord;
// pixel buffer is in ABGR format(it stores big-endian RGBA) r = (BYTE)((dwPixel>>16) & g_LowByteMask);
// need to change byte order to ARGB g = (BYTE)((dwPixel>> 8) & g_LowByteMask);
b = (BYTE)((dwPixel ) & g_LowByteMask);
// simpler: just swap r & b
r = (BYTE)((dwPixel>>16)&0x000000ff);
g = (BYTE)((dwPixel>> 8)&0x000000ff);
b = (BYTE)((dwPixel )&0x000000ff);
#ifdef PANDA_ARGB_ORDER
*pDstByte++ = b;
*pDstByte++ = g;
*pDstByte++ = r;
#else
*pDstByte++ = r; *pDstByte++ = r;
*pDstByte++ = g; *pDstByte++ = g;
*pDstByte++ = b; *pDstByte++ = b;
#endif
} }
} }
break; break;
@ -885,20 +907,25 @@ HRESULT ConvertDDSurftoPixBuf(PixelBuffer *pixbuf,LPDIRECTDRAWSURFACE7 pDDSurf)
pDDSurfBytes+=ddsd.lPitch*(dwYWindowOffset+dwCopyHeight-1); pDDSurfBytes+=ddsd.lPitch*(dwYWindowOffset+dwCopyHeight-1);
for(DWORD y=0; y<dwCopyHeight; y++,pDDSurfBytes-=ddsd.lPitch) { for(DWORD y=0; y<dwCopyHeight; y++,pDDSurfBytes-=ddsd.lPitch) {
pSrcByte = pDDSurfBytes+dwXWindowOffset*3*sizeof(BYTE); pSrcByte = pDDSurfBytes+dwXWindowOffset*3*sizeof(BYTE);
#ifdef PANDA_ARGB_ORDER
memcpy(pDstByte,pSrcByte,ddsd.lPitch);
pDstByte+=ddsd.lPitch;
#else
for(DWORD x=0; x<dwCopyWidth; x++) { for(DWORD x=0; x<dwCopyWidth; x++) {
BYTE r,g,b; BYTE r,g,b;
// pixel buffer is in ABGR format(it stores big-endian RGBA) // pixel buffer is in ABGR format(it stores big-endian RGBA)
// need to change byte order from ARGB // need to change byte order from ARGB
b = *pSrcByte++;
g = *pSrcByte++;
r = *pSrcByte++; r = *pSrcByte++;
g = *pSrcByte++;
b = *pSrcByte++;
*pDstByte++ = r;
*pDstByte++ = g;
*pDstByte++ = b; *pDstByte++ = b;
*pDstByte++ = g;
*pDstByte++ = r;
} }
#endif
} }
break; break;
} }
@ -949,9 +976,15 @@ HRESULT ConvertDDSurftoPixBuf(PixelBuffer *pixbuf,LPDIRECTDRAWSURFACE7 pDDSurf)
g = (dwPixel & greenmask) >> greenshift; g = (dwPixel & greenmask) >> greenshift;
r = (dwPixel & redmask) >> redshift; r = (dwPixel & redmask) >> redshift;
#ifdef PANDA_ARGB_ORDER
*pDstByte++ = b;
*pDstByte++ = g;
*pDstByte++ = r;
#else
*pDstByte++ = r; *pDstByte++ = r;
*pDstByte++ = g; *pDstByte++ = g;
*pDstByte++ = b; *pDstByte++ = b;
#endif
} }
} }
} }
@ -1267,7 +1300,7 @@ LPDIRECTDRAWSURFACE7 DXTextureContext::CreateTexture(LPDIRECT3DDEVICE7 pd3dDevic
ConvNeeded=((cNumColorChannels==3) ? Conv24to16_0565 : Conv32to16_0565); ConvNeeded=((cNumColorChannels==3) ? Conv24to16_0565 : Conv32to16_0565);
} else { } else {
assert((pCurPixFmt->dwRBitMask|pCurPixFmt->dwGBitMask|pCurPixFmt->dwBBitMask)==0x7FFF); assert((pCurPixFmt->dwRBitMask|pCurPixFmt->dwGBitMask|pCurPixFmt->dwBBitMask)==0x7FFF);
ConvNeeded=((cNumColorChannels==3) ? Conv24to16_0555 : Conv32to16_0555); ConvNeeded=((cNumColorChannels==3) ? Conv24to16_X555 : Conv32to16_X555);
} }
goto found_matching_format; goto found_matching_format;
} }
@ -1350,7 +1383,7 @@ LPDIRECTDRAWSURFACE7 DXTextureContext::CreateTexture(LPDIRECT3DDEVICE7 pd3dDevic
ConvNeeded=((cNumColorChannels==3) ? Conv24to16_0565 : Conv32to16_0565); ConvNeeded=((cNumColorChannels==3) ? Conv24to16_0565 : Conv32to16_0565);
} else { } else {
assert((pCurPixFmt->dwRBitMask|pCurPixFmt->dwGBitMask|pCurPixFmt->dwBBitMask)==0x7FFF); assert((pCurPixFmt->dwRBitMask|pCurPixFmt->dwGBitMask|pCurPixFmt->dwBBitMask)==0x7FFF);
ConvNeeded=((cNumColorChannels==3) ? Conv24to16_0555 : Conv32to16_0555); ConvNeeded=((cNumColorChannels==3) ? Conv24to16_X555 : Conv32to16_X555);
} }
goto found_matching_format; goto found_matching_format;
} }
@ -1409,7 +1442,7 @@ LPDIRECTDRAWSURFACE7 DXTextureContext::CreateTexture(LPDIRECT3DDEVICE7 pd3dDevic
// find compatible 16bpp fmt, just look for any 565, then 0555 // find compatible 16bpp fmt, just look for any 565, then 0555
DWORD dwMasks[2] = {0xF800, 0x7C00}; DWORD dwMasks[2] = {0xF800, 0x7C00};
ConversionType ConvType[2] = {ConvLum8to16_0565,ConvLum8to16_0555}; ConversionType ConvType[2] = {ConvLum8to16_0565,ConvLum8to16_X555};
for(DWORD modenum=0;modenum<2;modenum++) for(DWORD modenum=0;modenum<2;modenum++)
for(i=0,pCurPixFmt=&pTexPixFmts[0];i<cNumTexPixFmts;i++,pCurPixFmt++) { for(i=0,pCurPixFmt=&pTexPixFmts[0];i<cNumTexPixFmts;i++,pCurPixFmt++) {