-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
Hi again,
now the real things:
Changelog:
- declare a new debug chanel for vertex shaders
- some usefull debug functions for textures format (maybe i'll move this
utils into an util.c file later)
- use of this functions ;)
- correct DrawPrimitive (RHW correctness and vshader RHW)
- more copyrects fixes (only two unimplemented behavior remains)
- fix GetFrontBuffer to get screenshots samples working (ugly but i'll try
better later)
- add D3DCOLORTOGLFLOAT4 and use it
- first try of D3DRS_FOGTABLEMODE support
TODO:
- beautify the code to remove all my stupid emacs tabs
- bind cube maps in draw
- more readable and usefull debugging traces
- d3dcore ?
- fix sw vshaders and merge hw vshader prototypes
Raphael
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.1 (GNU/Linux)
iD8DBQE+wgBHp7NA3AmQTU4RApONAJwPJXujh5iQhZYDTMoauzOr9KLrSgCgiFH6
NxffH2DagJT0SJNmNSFY4pw=
=BErd
-----END PGP SIGNATURE-----
Index: device.c
===================================================================
RCS file: /home/wine/wine/dlls/d3d8/device.c,v
retrieving revision 1.52
diff -u -r1.52 device.c
--- device.c 14 May 2003 00:00:12 -0000 1.52
+++ device.c 14 May 2003 08:26:35 -0000
@@ -38,6 +38,7 @@
#undef GL_VERSION_1_4
WINE_DEFAULT_DEBUG_CHANNEL(d3d);
+WINE_DECLARE_DEBUG_CHANNEL(d3d_shader);
/* Some #defines for additional diagnostics */
@@ -78,6 +79,79 @@
#define TRACE_VECTOR(name) TRACE( #name "=(%f, %f, %f, %f)\n", name.x, name.y, name.z, name.w);
+const char* debug_d3dformat(D3DFORMAT fmt) {
+ switch (fmt) {
+#define FMT_TO_STR(fmt) case fmt: return #fmt
+ FMT_TO_STR(D3DFMT_UNKNOWN);
+
+ FMT_TO_STR(D3DFMT_R8G8B8);
+ FMT_TO_STR(D3DFMT_A8R8G8B8);
+ FMT_TO_STR(D3DFMT_X8R8G8B8);
+ FMT_TO_STR(D3DFMT_R5G6B5);
+ FMT_TO_STR(D3DFMT_X1R5G5B5);
+ FMT_TO_STR(D3DFMT_A1R5G5B5);
+ FMT_TO_STR(D3DFMT_A4R4G4B4);
+ FMT_TO_STR(D3DFMT_R3G3B2);
+ FMT_TO_STR(D3DFMT_A8);
+ FMT_TO_STR(D3DFMT_A8R3G3B2);
+ FMT_TO_STR(D3DFMT_X4R4G4B4);
+
+ FMT_TO_STR(D3DFMT_A8P8);
+ FMT_TO_STR(D3DFMT_P8);
+
+ FMT_TO_STR(D3DFMT_L8);
+ FMT_TO_STR(D3DFMT_A8L8);
+ FMT_TO_STR(D3DFMT_A4L4);
+
+ FMT_TO_STR(D3DFMT_V8U8);
+ FMT_TO_STR(D3DFMT_L6V5U5);
+ FMT_TO_STR(D3DFMT_X8L8V8U8);
+ FMT_TO_STR(D3DFMT_Q8W8V8U8);
+ FMT_TO_STR(D3DFMT_V16U16);
+ FMT_TO_STR(D3DFMT_W11V11U10);
+
+ FMT_TO_STR(D3DFMT_UYVY);
+ FMT_TO_STR(D3DFMT_YUY2);
+ FMT_TO_STR(D3DFMT_DXT1);
+ FMT_TO_STR(D3DFMT_DXT2);
+ FMT_TO_STR(D3DFMT_DXT3);
+ FMT_TO_STR(D3DFMT_DXT4);
+ FMT_TO_STR(D3DFMT_DXT5);
+
+ FMT_TO_STR(D3DFMT_D16_LOCKABLE);
+ FMT_TO_STR(D3DFMT_D32);
+ FMT_TO_STR(D3DFMT_D15S1);
+ FMT_TO_STR(D3DFMT_D24S8);
+ FMT_TO_STR(D3DFMT_D16);
+ FMT_TO_STR(D3DFMT_D24X8);
+ FMT_TO_STR(D3DFMT_D24X4S4);
+
+ FMT_TO_STR(D3DFMT_VERTEXDATA);
+ FMT_TO_STR(D3DFMT_INDEX16);
+ FMT_TO_STR(D3DFMT_INDEX32);
+#undef FMT_TO_STR
+ default:
+ FIXME("Unrecognized %u D3DFORMAT!\n", fmt);
+ return "unrecognized";
+ }
+}
+
+const char* debug_d3dressourcetype(D3DRESOURCETYPE res) {
+ switch (res) {
+#define RES_TO_STR(res) case res: return #res;
+ RES_TO_STR(D3DRTYPE_SURFACE);
+ RES_TO_STR(D3DRTYPE_VOLUME);
+ RES_TO_STR(D3DRTYPE_TEXTURE);
+ RES_TO_STR(D3DRTYPE_VOLUMETEXTURE);
+ RES_TO_STR(D3DRTYPE_CUBETEXTURE);
+ RES_TO_STR(D3DRTYPE_VERTEXBUFFER);
+ RES_TO_STR(D3DRTYPE_INDEXBUFFER);
+#undef RES_TO_STR
+ default:
+ FIXME("Unrecognized %u D3DRESOURCETYPE!\n", res);
+ return "unrecognized";
+ }
+}
/* Routine common to the draw primitive and draw indexed primitive routines */
void DrawPrimitiveI(LPDIRECT3DDEVICE8 iface,
@@ -197,38 +271,51 @@
}
if (isRHW) {
- double height, width, minZ, maxZ;
+ double X, Y, height, width, minZ, maxZ;
/*
* Already transformed vertex do not need transform
* matrices. Reset all matrices to identity.
* Leave the default matrix in world mode.
*/
- glMatrixMode(GL_PROJECTION);
+ glMatrixMode(GL_MODELVIEW);
checkGLcall("glMatrixMode");
glLoadIdentity();
checkGLcall("glLoadIdentity");
- glMatrixMode(GL_MODELVIEW);
+ /**
+ * As seen in d3d7 code:
+ * See the OpenGL Red Book for an explanation of the following translation (in the OpenGL
+ * Correctness Tips section).
+ */
+ glTranslatef(0.375f, 0.375f, 0.0f);
+ /**
+ *
+ */
+ glMatrixMode(GL_PROJECTION);
checkGLcall("glMatrixMode");
glLoadIdentity();
checkGLcall("glLoadIdentity");
+ X = This->StateBlock->viewport.X;
+ Y = This->StateBlock->viewport.Y;
height = This->StateBlock->viewport.Height;
width = This->StateBlock->viewport.Width;
minZ = This->StateBlock->viewport.MinZ;
maxZ = This->StateBlock->viewport.MaxZ;
TRACE("Calling glOrtho with %f, %f, %f, %f\n", width, height, -minZ, -maxZ);
- glOrtho(0.0, width, height, 0.0, -minZ, -maxZ);
+ /*glOrtho(0.0, width, height, 0.0, -minZ, -maxZ);*/
+ glOrtho(X, X + width, Y + height, Y, -minZ, -maxZ);
checkGLcall("glOrtho");
} else {
- glMatrixMode(GL_PROJECTION);
- checkGLcall("glMatrixMode");
- glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_PROJECTION].u.m[0][0]);
- checkGLcall("glLoadMatrixf");
glMatrixMode(GL_MODELVIEW);
checkGLcall("glMatrixMode");
glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_VIEW].u.m[0][0]);
checkGLcall("glLoadMatrixf");
glMultMatrixf((float *) &This->StateBlock->transforms[D3DTS_WORLDMATRIX(0)].u.m[0][0]);
checkGLcall("glMultMatrixf");
+
+ glMatrixMode(GL_PROJECTION);
+ checkGLcall("glMatrixMode");
+ glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_PROJECTION].u.m[0][0]);
+ checkGLcall("glLoadMatrixf");
}
/* Set OpenGL to the appropriate Primitive Type */
@@ -279,7 +366,7 @@
vertex arrays, we need to drop down to the slow mechanism for
certain functions */
- if (isPtSize || isDiffuse || useVertexShaderFunction==TRUE || (numBlends > 0)) {
+ if (isPtSize || isDiffuse || useVertexShaderFunction == TRUE || (numBlends > 0)) {
TRACE("Using slow per-vertex code\n");
/* Enable this one to be able to debug what is going on, but it is slower
@@ -524,7 +611,7 @@
}
/*diffuseColor = D3DCOLOR_COLORVALUE(vertex_shader->output.oD[0]);*/
glColor4fv((float*) &vertex_shader->output.oD[0]);
-
+
/* Requires secondary color extensions to compile... */
#if defined(GL_VERSION_1_4)
glSecondaryColor3fv((float*) &vertex_shader->output.oD[1]);
@@ -601,12 +688,15 @@
}
if (1.0f == rhw || rhw < 0.01f) {
- VTRACE(("Vertex: glVertex:x,y,z=%f,%f,%f\n", x,y,z));
+ TRACE_(d3d_shader)("Vertex: glVertex:x,y,z=%f,%f,%f\n", x, y, z);
glVertex3f(x, y, z);
/*checkGLcall("glVertex3f");*/
} else {
- VTRACE(("Vertex: glVertex:x,y,z=%f,%f,%f / rhw=%f\n", x,y,z,rhw));
- glVertex4f(x / rhw, y / rhw, z / rhw, 1.0f / rhw);
+ GLfloat w = 1.0f / rhw;
+ TRACE_(d3d_shader)("Vertex: glVertex:x,y,z=%f,%f,%f / rhw=%f\n", x,y,z,rhw);
+
+ /*glVertex4f(x / rhw, y / rhw, z / rhw, 1.0f / rhw);*/
+ glVertex4f(x * w, y * w, z * w, 1.0f);
/*checkGLcall("glVertex4f");*/
}
} else {
@@ -891,7 +981,7 @@
}
/*
- Simple utility routines used for dx -> gl mapping of byte formats
+ * Simple utility routines used for dx -> gl mapping of byte formats
*/
SHORT bytesPerPixel(D3DFORMAT fmt) {
SHORT retVal;
@@ -914,15 +1004,16 @@
case D3DFMT_D24X4S4: retVal = 4; break;
/* unknown */
case D3DFMT_UNKNOWN:
- /* Guess at the highest value of the above */
- TRACE("D3DFMT_UNKNOWN - Guessing at 4 bytes/pixel %d\n", fmt);
- retVal = 4;
- break;
+ /* Guess at the highest value of the above */
+ TRACE("D3DFMT_UNKNOWN - Guessing at 4 bytes/pixel %d\n", fmt);
+ retVal = 4;
+ break;
+
default:
- FIXME("Unhandled fmt %d\n", fmt);
- retVal = 4;
+ FIXME("Unhandled fmt(%u,%s)\n", fmt, debug_d3dformat(fmt));
+ retVal = 4;
}
- TRACE("bytes/Pxl for fmt %d = %d\n", fmt, retVal);
+ TRACE("bytes/Pxl for fmt(%u,%s) = %d\n", fmt, debug_d3dformat(fmt), retVal);
return retVal;
}
@@ -937,10 +1028,10 @@
case D3DFMT_R5G6B5: retVal = GL_RGB5; break; /* fixme: internal format 6 for g? */
case D3DFMT_A1R5G5B5: retVal = GL_RGB5_A1; break;
default:
- FIXME("Unhandled fmt %d\n", fmt);
+ FIXME("Unhandled fmt(%u,%s)\n", fmt, debug_d3dformat(fmt));
retVal = 4;
}
- TRACE("fmt2glintFmt for fmt %d = %x\n", fmt, retVal);
+ TRACE("fmt2glintFmt for fmt(%u,%s) = %x\n", fmt, debug_d3dformat(fmt), retVal);
return retVal;
}
GLenum fmt2glFmt(D3DFORMAT fmt) {
@@ -954,10 +1045,10 @@
case D3DFMT_R5G6B5: retVal = GL_RGB; break;
case D3DFMT_A1R5G5B5: retVal = GL_BGRA; break;
default:
- FIXME("Unhandled fmt %d\n", fmt);
+ FIXME("Unhandled fmt(%u,%s)\n", fmt, debug_d3dformat(fmt));
retVal = 4;
}
- TRACE("fmt2glFmt for fmt %d = %x\n", fmt, retVal);
+ TRACE("fmt2glFmt for fmt(%u,%s) = %x\n", fmt, debug_d3dformat(fmt), retVal);
return retVal;
}
DWORD fmt2glType(D3DFORMAT fmt) {
@@ -967,14 +1058,14 @@
case D3DFMT_A4R4G4B4: retVal = GL_UNSIGNED_SHORT_4_4_4_4_REV; break;
case D3DFMT_A8R8G8B8: retVal = GL_UNSIGNED_BYTE; break;
case D3DFMT_X8R8G8B8: retVal = GL_UNSIGNED_BYTE; break;
- case D3DFMT_R5G6B5: retVal = GL_UNSIGNED_SHORT_5_6_5_REV; break;
+ case D3DFMT_R5G6B5: retVal = GL_UNSIGNED_SHORT_5_6_5; break;
case D3DFMT_R8G8B8: retVal = GL_UNSIGNED_BYTE; break;
case D3DFMT_A1R5G5B5: retVal = GL_UNSIGNED_SHORT_1_5_5_5_REV; break;
default:
- FIXME("Unhandled fmt %d\n", fmt);
+ FIXME("Unhandled fmt(%u,%s)\n", fmt, debug_d3dformat(fmt));
retVal = 4;
}
- TRACE("fmt2glType for fmt %d = %x\n", fmt, retVal);
+ TRACE("fmt2glType for fmt(%u,%s) = %x\n", fmt, debug_d3dformat(fmt), retVal);
return retVal;
}
@@ -1117,7 +1208,7 @@
/* Apply the current values to the specified texture stage */
void setupTextureStates(LPDIRECT3DDEVICE8 iface, DWORD Stage) {
ICOM_THIS(IDirect3DDevice8Impl,iface);
- int i=0;
+ int i = 0;
float col[4];
/* Make appropriate texture active */
@@ -1133,16 +1224,19 @@
}
TRACE("-----------------------> Updating the texture at stage %ld to have new texture state information\n", Stage);
- for (i=1; i<HIGHEST_TEXTURE_STATE; i++) {
+ for (i = 1; i < HIGHEST_TEXTURE_STATE; i++) {
IDirect3DDevice8Impl_SetTextureStageState(iface, Stage, i, This->StateBlock->texture_state[Stage][i]);
}
/* Note the D3DRS value applies to all textures, but GL has one
per texture, so apply it now ready to be used! */
+#if 0
col[0] = ((This->StateBlock->renderstate[D3DRS_TEXTUREFACTOR]>> 16) & 0xFF) / 255.0;
col[1] = ((This->StateBlock->renderstate[D3DRS_TEXTUREFACTOR] >> 8 ) & 0xFF) / 255.0;
col[2] = ((This->StateBlock->renderstate[D3DRS_TEXTUREFACTOR] >> 0 ) & 0xFF) / 255.0;
col[3] = ((This->StateBlock->renderstate[D3DRS_TEXTUREFACTOR] >> 24 ) & 0xFF) / 255.0;
+#endif
+ D3DCOLORTOGLFLOAT4(This->StateBlock->renderstate[D3DRS_TEXTUREFACTOR], col);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &col[0]);
checkGLcall("glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);");
@@ -1487,8 +1581,7 @@
/* Generate all the surfaces */
tmpW = EdgeLength;
- for (i = 0; i < object->levels; i++)
- {
+ for (i = 0; i < object->levels; i++) {
/* Create the 6 faces */
for (j = 0; j < 6; j++) {
IDirect3DDevice8Impl_CreateImageSurface(iface, tmpW, tmpW, Format, (LPDIRECT3DSURFACE8*) &object->surfaces[j][i]);
@@ -1496,6 +1589,7 @@
/*IUnknown_AddRef(object->surfaces[j][i]->Container);*/
object->surfaces[j][i]->myDesc.Usage = Usage;
object->surfaces[j][i]->myDesc.Pool = Pool;
+ /*object->surfaces[j][i]->myDesc.Format = Format;*/
TRACE("Created surface level %d @ %p, memory at %p\n", i, object->surfaces[j][i], object->surfaces[j][i]->allocatedMemory);
tmpW = max(1, tmpW / 2);
@@ -1665,8 +1759,8 @@
IDirect3DBaseTexture8* texture = NULL;
- IDirect3DSurface8Impl *src = (IDirect3DSurface8Impl*) pSourceSurface;
- IDirect3DSurface8Impl *dst = (IDirect3DSurface8Impl*) pDestinationSurface;
+ IDirect3DSurface8Impl* src = (IDirect3DSurface8Impl*) pSourceSurface;
+ IDirect3DSurface8Impl* dst = (IDirect3DSurface8Impl*) pDestinationSurface;
ICOM_THIS(IDirect3DDevice8Impl,iface);
TRACE("(%p) srcsur=%p, pSourceRects=%p, cRects=%d, pDstSur=%p, pDestPtsArr=%p\n", This,
@@ -1706,65 +1800,90 @@
}
/* Quick if complete copy ... */
- if (rc == D3D_OK && (cRects == 0 && pSourceRectsArray==NULL && pDestPointsArray==NULL &&
- src->myDesc.Width == dst->myDesc.Width &&
- src->myDesc.Height == dst->myDesc.Height)) {
- D3DLOCKED_RECT lr;
+ if (rc == D3D_OK && cRects == 0 && pSourceRectsArray == NULL && pDestPointsArray == NULL) {
- IDirect3DSurface8Impl_LockRect((LPDIRECT3DSURFACE8)src, &lr, NULL, D3DLOCK_READONLY);
- IDirect3DSurface8Impl_LockRect((LPDIRECT3DSURFACE8)dst, &lr, NULL, D3DLOCK_DISCARD);
- TRACE("Locked src and dst, Direct copy as surfaces are equal, w=%d, h=%d\n", dst->myDesc.Width, dst->myDesc.Height);
+ if (src->myDesc.Width == dst->myDesc.Width && src->myDesc.Height == dst->myDesc.Height) {
- memcpy(dst->allocatedMemory, src->allocatedMemory, src->myDesc.Size);
+ D3DLOCKED_RECT lrSrc;
+ D3DLOCKED_RECT lrDst;
+ IDirect3DSurface8Impl_LockRect((LPDIRECT3DSURFACE8) src, &lrSrc, NULL, D3DLOCK_READONLY);
+ IDirect3DSurface8Impl_LockRect((LPDIRECT3DSURFACE8) dst, &lrDst, NULL, 0L);
+ TRACE("Locked src and dst, Direct copy as surfaces are equal, w=%d, h=%d\n", dst->myDesc.Width, dst->myDesc.Height);
- IDirect3DSurface8Impl_UnlockRect((LPDIRECT3DSURFACE8)src);
- IDirect3DSurface8Impl_UnlockRect((LPDIRECT3DSURFACE8)dst);
+ /*memcpy(dst->allocatedMemory, src->allocatedMemory, src->myDesc.Size);*/
+ memcpy(lrDst.pBits, lrSrc.pBits, src->myDesc.Size);
+
+ IDirect3DSurface8Impl_UnlockRect((LPDIRECT3DSURFACE8) src);
+ IDirect3DSurface8Impl_UnlockRect((LPDIRECT3DSURFACE8) dst);
TRACE("Unlocked src and dst\n");
+ } else {
+
+ FIXME("Wanted to copy all surfaces but size not compatible\n");
+ rc = D3DERR_INVALIDCALL;
+
+ }
+
} else {
- int i;
+
+ if (NULL != pSourceRectsArray && NULL != pDestPointsArray) {
+
int bytesPerPixel = ((IDirect3DSurface8Impl *)pSourceSurface)->bytesPerPixel;
- int pitchFrom = ((IDirect3DSurface8Impl *)pSourceSurface)->myDesc.Width * bytesPerPixel;
+#if 0
+ int pitchFrom = ((IDirect3DSurface8Impl *)pSourceSurface)->myDesc.Width * bytesPerPixel;
int pitchTo = ((IDirect3DSurface8Impl *)pDestinationSurface)->myDesc.Width * bytesPerPixel;
-
char *copyfrom = ((IDirect3DSurface8Impl *)pSourceSurface)->allocatedMemory;
char *copyto = ((IDirect3DSurface8Impl *)pDestinationSurface)->allocatedMemory;
-
+ char *from;
+ char *to;
+#endif
+ int i;
/* Copy rect by rect */
- for (i=0; i<cRects; i++) {
- CONST RECT *r = &pSourceRectsArray[i];
- CONST POINT *p = &pDestPointsArray[i];
- char *from;
- char *to;
- int copyperline = (r->right - r->left) * bytesPerPixel;
+ for (i = 0; i < cRects; i++) {
+ CONST RECT* r = &pSourceRectsArray[i];
+ CONST POINT* p = &pDestPointsArray[i];
+ int copyperline = (r->right - r->left) * bytesPerPixel;
int j;
- D3DLOCKED_RECT lr;
- RECT dest_rect;
+ D3DLOCKED_RECT lrSrc;
+ D3DLOCKED_RECT lrDst;
+ RECT dest_rect;
+
- TRACE("Copying rect %d (%ld,%ld),(%ld,%ld) -> (%ld,%ld)\n", i, r->left, r->top,
- r->right, r->bottom, p->x, p->y);
+ TRACE("Copying rect %d (%ld,%ld),(%ld,%ld) -> (%ld,%ld)\n", i, r->left, r->top, r->right, r->bottom, p->x, p->y);
- IDirect3DSurface8Impl_LockRect((LPDIRECT3DSURFACE8)src, &lr, r, D3DLOCK_READONLY);
- dest_rect.left = p->x;
- dest_rect.top = p->y;
+ IDirect3DSurface8Impl_LockRect((LPDIRECT3DSURFACE8) src, &lrSrc, r, D3DLOCK_READONLY);
+ dest_rect.left = p->x;
+ dest_rect.top = p->y;
dest_rect.right = p->x + (r->right - r->left);
- dest_rect.left = p->y + (r->bottom - r->top);
- IDirect3DSurface8Impl_LockRect((LPDIRECT3DSURFACE8)dst, &lr, &dest_rect, 0L);
+ dest_rect.left = p->y + (r->bottom - r->top);
+ IDirect3DSurface8Impl_LockRect((LPDIRECT3DSURFACE8) dst, &lrDst, &dest_rect, 0L);
TRACE("Locked src and dst\n");
/* Find where to start */
+#if 0
from = copyfrom + (r->top * pitchFrom) + (r->left * bytesPerPixel);
to = copyto + (p->y * pitchTo) + (p->x * bytesPerPixel);
-
/* Copy line by line */
- for (j=0; j<(r->bottom - r->top); j++) {
- memcpy(to + (j*pitchTo), from + (j*pitchFrom), copyperline);
+ for (j = 0; j < (r->bottom - r->top); j++) {
+ memcpy(to + (j * pitchTo), from + (j * pitchFrom), copyperline);
}
+#endif
- IDirect3DSurface8Impl_UnlockRect((LPDIRECT3DSURFACE8)src);
- IDirect3DSurface8Impl_UnlockRect((LPDIRECT3DSURFACE8)dst);
+ for (j = 0; j < (r->bottom - r->top); j++) {
+ memcpy((char*) lrDst.pBits + (j * lrDst.Pitch), (char*) lrSrc.pBits + (j * lrSrc.Pitch), copyperline);
+ }
+
+ IDirect3DSurface8Impl_UnlockRect((LPDIRECT3DSURFACE8) src);
+ IDirect3DSurface8Impl_UnlockRect((LPDIRECT3DSURFACE8) dst);
TRACE("Unlocked src and dst\n");
}
+
+ } else {
+
+ FIXME("Wanted to copy partial surfaces not implemented\n");
+ rc = D3DERR_INVALIDCALL;
+
+ }
}
/* Set dirty */
@@ -1810,24 +1929,43 @@
HRESULT WINAPI IDirect3DDevice8Impl_GetFrontBuffer(LPDIRECT3DDEVICE8 iface, IDirect3DSurface8* pDestSurface) {
HRESULT hr;
D3DLOCKED_RECT lockedRect;
+ RECT wantedRect;
GLint prev_store;
GLenum prev_read;
ICOM_THIS(IDirect3DDevice8Impl,iface);
- FIXME("(%p) : stub\n", This);
+ FIXME("(%p) : see if behavior correct\n", This);
if (D3DFMT_A8R8G8B8 != ((IDirect3DSurface8Impl*) pDestSurface)->myDesc.Format) {
+ ERR("(%p) : surface(%p) have a invalid format\n", This, pDestSurface);
return D3DERR_INVALIDCALL;
}
-
- hr = IDirect3DSurface8Impl_LockRect(pDestSurface, &lockedRect, NULL, 0);
+
+ wantedRect.left = 0;
+ wantedRect.top = 0;
+ wantedRect.right = This->PresentParms.BackBufferWidth;
+ wantedRect.bottom = This->PresentParms.BackBufferHeight;
+
+ hr = IDirect3DSurface8Impl_LockRect(pDestSurface, &lockedRect, &wantedRect, 0);
if (FAILED(hr)) {
+ ERR("(%p) : cannot lock surface\n", This);
return D3DERR_INVALIDCALL;
}
ENTER_GL();
+ /*
+ {
+ IDirect3DSurface8Impl* tmp = ((IDirect3DSurface8Impl*) pDestSurface);
+ FIXME("dest:%u,%u,bpp:%u\n", tmp->myDesc.Width, tmp->myDesc.Height, tmp->bytesPerPixel);
+ FIXME("dest2:pitch%u\n", lockedRect.Pitch);
+ FIXME("src:%u,%u\n", This->PresentParms.BackBufferWidth, This->PresentParms.BackBufferHeight);
+ tmp = This->frontBuffer;
+ FIXME("src2:%u,%u,bpp:%u\n", tmp->myDesc.Width, tmp->myDesc.Height, tmp->bytesPerPixel);
+ }
+ */
+
glFlush();
vcheckGLcall("glFlush");
glGetIntegerv(GL_READ_BUFFER, &prev_read);
@@ -1839,13 +1977,25 @@
vcheckGLcall("glReadBuffer");
glPixelStorei(GL_PACK_SWAP_BYTES, TRUE);
vcheckGLcall("glPixelStorei");
+ /* stupid copy */
+ {
+ long j;
+ for (j = 0; j < This->PresentParms.BackBufferHeight; ++j) {
+ /*memcpy(lockedRect.pBits + (j * lockedRect.Pitch), This->frontBuffer->allocatedMemory + (j * i), i);*/
+ glReadPixels(0, This->PresentParms.BackBufferHeight - j - 1, This->PresentParms.BackBufferWidth, 1,
+ GL_BGRA, GL_UNSIGNED_BYTE, ((char*) lockedRect.pBits) + (j * lockedRect.Pitch));
+ vcheckGLcall("glReadPixels");
+ }
+ }
+ /*
glReadPixels(0, 0, This->PresentParms.BackBufferWidth, This->PresentParms.BackBufferHeight,
GL_BGRA, GL_UNSIGNED_BYTE, lockedRect.pBits);
- vcheckGLcall("glReadPixels");
+ */
glPixelStorei(GL_PACK_SWAP_BYTES, prev_store);
vcheckGLcall("glPixelStorei");
glReadBuffer(prev_read);
vcheckGLcall("glReadBuffer");
+
LEAVE_GL();
hr = IDirect3DSurface8Impl_UnlockRect(pDestSurface);
@@ -1906,7 +2056,7 @@
LEAVE_GL();
return D3D_OK;
}
-HRESULT WINAPI IDirect3DDevice8Impl_Clear(LPDIRECT3DDEVICE8 iface, DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil) {
+HRESULT WINAPI IDirect3DDevice8Impl_Clear(LPDIRECT3DDEVICE8 iface, DWORD Count, CONST D3DRECT* pRects, DWORD Flags, D3DCOLOR Color, float Z, DWORD Stencil) {
ICOM_THIS(IDirect3DDevice8Impl,iface);
/* TODO: From MSDN This method fails if you specify the D3DCLEAR_ZBUFFER or D3DCLEAR_STENCIL flags when the
@@ -1917,9 +2067,8 @@
GLfloat old_z_clear_value;
GLint old_stencil_clear_value;
GLfloat old_color_clear_value[4];
-
int i;
- CONST D3DRECT *curRect;
+ CONST D3DRECT* curRect;
TRACE("(%p) Count (%ld), pRects (%p), Flags (%lx), Z (%f), Stencil (%ld)\n", This,
Count, pRects, Flags, Z, Stencil);
@@ -2000,7 +2149,7 @@
return D3D_OK;
}
-HRESULT WINAPI IDirect3DDevice8Impl_SetTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE d3dts,CONST D3DMATRIX* lpmatrix) {
+HRESULT WINAPI IDirect3DDevice8Impl_SetTransform(LPDIRECT3DDEVICE8 iface, D3DTRANSFORMSTATETYPE d3dts, CONST D3DMATRIX* lpmatrix) {
ICOM_THIS(IDirect3DDevice8Impl,iface);
D3DMATRIX m;
int k;
@@ -2045,11 +2194,13 @@
to the other so that if I ever find out that I need to transpose them, I
will able to do it quickly, only by changing the macro conv_mat. */
- if (d3dts <= 256) { /* WORLDMATRIX(0) == 256! */
+ if (d3dts < 256) {
switch (d3dts) {
- case D3DTS_WORLDMATRIX(0):
+#if 0
+ case D3DTS_WORLDMATRIX(0): /* WORLDMATRIX(0) == 256! so not here */
conv_mat(lpmatrix, &This->StateBlock->transforms[D3DTS_WORLDMATRIX(0)]);
break;
+#endif
case D3DTS_VIEW:
conv_mat(lpmatrix, &This->StateBlock->transforms[D3DTS_VIEW]);
@@ -2156,10 +2307,10 @@
}
} else if (d3dts >= D3DTS_TEXTURE0 && d3dts <= D3DTS_TEXTURE7) {
/* Now apply texture transforms if not applying to the dummy textures */
- Stage = d3dts-D3DTS_TEXTURE0;
+ Stage = d3dts - D3DTS_TEXTURE0;
- if (memcmp(&This->lastTexTrans[Stage], &This->StateBlock->transforms[D3DTS_TEXTURE0+Stage].u.m[0][0], sizeof(D3DMATRIX))) {
- memcpy(&This->lastTexTrans[Stage], &This->StateBlock->transforms[D3DTS_TEXTURE0+Stage].u.m[0][0], sizeof(D3DMATRIX));
+ if (memcmp(&This->lastTexTrans[Stage], &This->StateBlock->transforms[D3DTS_TEXTURE0 + Stage].u.m[0][0], sizeof(D3DMATRIX))) {
+ memcpy(&This->lastTexTrans[Stage], &This->StateBlock->transforms[D3DTS_TEXTURE0 + Stage].u.m[0][0], sizeof(D3DMATRIX));
#if defined(GL_VERSION_1_3)
glActiveTexture(GL_TEXTURE0 + Stage);
@@ -2196,7 +2347,7 @@
if (viewChanged == TRUE ||
(memcmp(&This->lastWorld0, &This->StateBlock->transforms[D3DTS_WORLDMATRIX(0)].u.m[0][0], sizeof(D3DMATRIX)))) {
memcpy(&This->lastWorld0, &This->StateBlock->transforms[D3DTS_WORLDMATRIX(0)].u.m[0][0], sizeof(D3DMATRIX));
- if (viewChanged==FALSE) {
+ if (viewChanged == FALSE) {
glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_VIEW].u.m[0][0]);
checkGLcall("glLoadMatrixf");
}
@@ -2230,7 +2381,7 @@
m.u.s._21 = f; m.u.s._22 = f; m.u.s._23 = f; m.u.s._24 = f;
m.u.s._31 = f; m.u.s._32 = f; m.u.s._33 = f; m.u.s._34 = f;
m.u.s._41 = f; m.u.s._42 = f; m.u.s._43 = f; m.u.s._44 = f;
- if (viewChanged==FALSE) {
+ if (viewChanged == FALSE) {
glLoadMatrixf((float *) &This->StateBlock->transforms[D3DTS_VIEW].u.m[0][0]);
checkGLcall("glLoadMatrixf");
}
@@ -2367,14 +2518,14 @@
TRACE("(%p) : Emissive (%f,%f,%f,%f)\n", This, pMaterial->Emissive.r, pMaterial->Emissive.g, pMaterial->Emissive.b, pMaterial->Emissive.a);
TRACE("(%p) : Power (%f)\n", This, pMaterial->Power);
- glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float *)&This->UpdateStateBlock->material.Ambient);
+ glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, (float*) &This->UpdateStateBlock->material.Ambient);
checkGLcall("glMaterialfv");
- glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float *)&This->UpdateStateBlock->material.Diffuse);
+ glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, (float*) &This->UpdateStateBlock->material.Diffuse);
checkGLcall("glMaterialfv");
- glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float *)&This->UpdateStateBlock->material.Specular);
+ glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, (float*) &This->UpdateStateBlock->material.Specular);
checkGLcall("glMaterialfv");
- glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float *)&This->UpdateStateBlock->material.Emissive);
+ glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, (float*) &This->UpdateStateBlock->material.Emissive);
checkGLcall("glMaterialfv");
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, This->UpdateStateBlock->material.Power);
checkGLcall("glMaterialf");
@@ -2393,7 +2544,7 @@
return D3D_OK;
}
-HRESULT WINAPI IDirect3DDevice8Impl_SetLight(LPDIRECT3DDEVICE8 iface, DWORD Index,CONST D3DLIGHT8* pLight) {
+HRESULT WINAPI IDirect3DDevice8Impl_SetLight(LPDIRECT3DDEVICE8 iface, DWORD Index, CONST D3DLIGHT8* pLight) {
float colRGBA[] = {0.0, 0.0, 0.0, 0.0};
float rho;
float quad_att;
@@ -2570,10 +2721,10 @@
}
if (Enable) {
- glEnable(GL_LIGHT0+Index);
+ glEnable(GL_LIGHT0 + Index);
checkGLcall("glEnable GL_LIGHT0+Index");
} else {
- glDisable(GL_LIGHT0+Index);
+ glDisable(GL_LIGHT0 + Index);
checkGLcall("glDisable GL_LIGHT0+Index");
}
return D3D_OK;
@@ -2622,7 +2773,7 @@
TRACE("Clipplane [%f,%f,%f,%f]\n", This->UpdateStateBlock->clipplane[Index][0], This->UpdateStateBlock->clipplane[Index][1],
This->UpdateStateBlock->clipplane[Index][2], This->UpdateStateBlock->clipplane[Index][3]);
- glClipPlane(GL_CLIP_PLANE0+Index, This->UpdateStateBlock->clipplane[Index]);
+ glClipPlane(GL_CLIP_PLANE0 + Index, This->UpdateStateBlock->clipplane[Index]);
glPopMatrix();
checkGLcall("glClipPlane");
@@ -2789,13 +2940,15 @@
case D3DRS_AMBIENT :
{
-
float col[4];
+#if 0
col[0] = ((Value >> 16) & 0xFF) / 255.0;
- col[1] = ((Value >> 8 ) & 0xFF) / 255.0;
- col[2] = ((Value >> 0 ) & 0xFF) / 255.0;
- col[3] = ((Value >> 24 ) & 0xFF) / 255.0;
- TRACE("Setting ambient to (%f,%f,%f,%f)\n", col[0],col[1],col[2],col[3]);
+ col[1] = ((Value >> 8) & 0xFF) / 255.0;
+ col[2] = ((Value >> 0) & 0xFF) / 255.0;
+ col[3] = ((Value >> 24) & 0xFF) / 255.0;
+#endif
+ D3DCOLORTOGLFLOAT4(Value, col);
+ TRACE("Setting ambient to (%f,%f,%f,%f)\n", col[0], col[1], col[2], col[3]);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, col);
checkGLcall("glLightModel for MODEL_AMBIENT");
@@ -2890,12 +3043,12 @@
case D3DRS_ALPHAREF :
{
int glParm = GL_LESS;
- float ref = 1.0;
+ float ref = 1.0f;
glGetIntegerv(GL_ALPHA_TEST_FUNC, &glParm);
checkGLcall("glGetFloatv(GL_ALPHA_TEST_FUNC, &glParm);");
- ref = ((float) Value) / 255.0;
+ ref = ((float) Value) / 255.0f;
TRACE("glAlphaFunc with Parm=%x, ref=%f\n", glParm, ref);
glAlphaFunc(glParm, ref);
checkGLcall("glAlphaFunc");
@@ -2965,11 +3118,13 @@
/* Note the texture color applies to all textures whereas
GL_TEXTURE_ENV_COLOR applies to active only */
float col[4];
- col[0] = ((Value >> 16) & 0xFF) / 255.0;
- col[1] = ((Value >> 8 ) & 0xFF) / 255.0;
- col[2] = ((Value >> 0 ) & 0xFF) / 255.0;
- col[3] = ((Value >> 24 ) & 0xFF) / 255.0;
-
+#if 0
+ col[0] = ((Value >> 16) & 0xFF) / 255.0f;
+ col[1] = ((Value >> 8) & 0xFF) / 255.0f;
+ col[2] = ((Value >> 0) & 0xFF) / 255.0f;
+ col[3] = ((Value >> 24) & 0xFF) / 255.0f;
+#endif
+ D3DCOLORTOGLFLOAT4(Value, col);
/* Set the default alpha blend color */
glBlendColor(col[0], col[1], col[2], col[3]);
checkGLcall("glBlendColor");
@@ -3157,20 +3312,35 @@
case D3DRS_FOGCOLOR :
{
float col[4];
- col[0] = ((Value >> 16) & 0xFF) / 255.0;
- col[1] = ((Value >> 8 ) & 0xFF) / 255.0;
- col[2] = ((Value >> 0 ) & 0xFF) / 255.0;
- col[3] = ((Value >> 24 ) & 0xFF) / 255.0;
-
+#if 0
+ col[0] = ((Value >> 16) & 0xFF) / 255.0f;
+ col[1] = ((Value >> 8) & 0xFF) / 255.0f;
+ col[2] = ((Value >> 0) & 0xFF) / 255.0f;
+ col[3] = ((Value >> 24) & 0xFF) / 255.0f;
+#endif
+ D3DCOLORTOGLFLOAT4(Value, col);
/* Set the default alpha blend color */
glFogfv(GL_FOG_COLOR, &col[0]);
checkGLcall("glFog GL_FOG_COLOR");
}
break;
+ case D3DRS_FOGTABLEMODE :
+ {
+ switch (Value) {
+ case D3DFOG_NONE: /* I don't know what to do here */ break;
+ case D3DFOG_EXP: glFogi(GL_FOG_MODE, GL_EXP); checkGLcall("glFogi(GL_FOG_MODE, GL_EXP"); break;
+ case D3DFOG_EXP2: glFogi(GL_FOG_MODE, GL_EXP2); checkGLcall("glFogi(GL_FOG_MODE, GL_EXP2"); break;
+ case D3DFOG_LINEAR: glFogi(GL_FOG_MODE, GL_LINEAR); checkGLcall("glFogi(GL_FOG_MODE, GL_LINEAR"); break;
+ default:
+ FIXME("Unsupported Value(%lu) for D3DRS_FOGTABLEMODE!\n", Value);
+ }
+ }
+ break;
+
case D3DRS_FOGSTART :
{
- float *f = (float *)&Value;
+ float *f = (float*) &Value;
glFogfv(GL_FOG_START, f);
checkGLcall("glFogf(GL_FOG_START, (float) Value)");
TRACE("Fog Start == %f\n", *f);
@@ -3179,7 +3349,7 @@
case D3DRS_FOGEND :
{
- float *f = (float *)&Value;
+ float *f = (float*) &Value;
glFogfv(GL_FOG_END, f);
checkGLcall("glFogf(GL_FOG_END, (float) Value)");
TRACE("Fog End == %f\n", *f);
@@ -3268,7 +3438,6 @@
case D3DRS_LINEPATTERN :
case D3DRS_LASTPIXEL :
case D3DRS_ZVISIBLE :
- case D3DRS_FOGTABLEMODE :
case D3DRS_EDGEANTIALIAS :
case D3DRS_ZBIAS :
case D3DRS_RANGEFOGENABLE :
@@ -3383,7 +3552,7 @@
HRESULT WINAPI IDirect3DDevice8Impl_GetTexture(LPDIRECT3DDEVICE8 iface, DWORD Stage,IDirect3DBaseTexture8** ppTexture) {
ICOM_THIS(IDirect3DDevice8Impl,iface);
TRACE("(%p) : returning %p for stage %ld\n", This, This->UpdateStateBlock->textures[Stage], Stage);
- *ppTexture = (LPDIRECT3DBASETEXTURE8)This->UpdateStateBlock->textures[Stage];
+ *ppTexture = (LPDIRECT3DBASETEXTURE8) This->UpdateStateBlock->textures[Stage];
IDirect3DBaseTexture8Impl_AddRef(*ppTexture);
return D3D_OK;
}
@@ -3438,9 +3607,9 @@
textureType = IDirect3DBaseTexture8Impl_GetType(pTexture);
if (textureType == D3DRTYPE_TEXTURE) {
- IDirect3DTexture8Impl *pTexture2 = (IDirect3DTexture8Impl *) pTexture;
+ IDirect3DTexture8Impl *pTexture2 = (IDirect3DTexture8Impl*) pTexture;
- if ((void *)oldTxt == (void *)pTexture2 && pTexture2->Dirty == FALSE) {
+ if ((void*) oldTxt == (void*) pTexture2 && pTexture2->Dirty == FALSE) {
TRACE("Skipping setting texture as old == new\n");
reapplyStates = FALSE;
} else {
@@ -3450,16 +3619,22 @@
This->UpdateStateBlock->textureDimensions[Stage] = GL_TEXTURE_2D;
/* Load up the texture now */
- IDirect3DTexture8Impl_PreLoad((LPDIRECT3DTEXTURE8)pTexture);
+ IDirect3DTexture8Impl_PreLoad((LPDIRECT3DTEXTURE8) pTexture);
}
} else if (textureType == D3DRTYPE_VOLUMETEXTURE) {
+#if 0
IDirect3DVolumeTexture8Impl *pTexture2 = (IDirect3DVolumeTexture8Impl *) pTexture;
int i;
+#endif
/* Standard 3D (volume) texture */
TRACE("Standard 3d texture\n");
This->UpdateStateBlock->textureDimensions[Stage] = GL_TEXTURE_3D;
+ /* Load up the texture now */
+ IDirect3DVolumeTexture8Impl_PreLoad((LPDIRECT3DVOLUMETEXTURE8) pTexture);
+
+#if 0
for (i=0; i<pTexture2->levels; i++)
{
@@ -3507,9 +3682,17 @@
pTexture2->Dirty = FALSE;
}
}
+#endif
- } else {
- FIXME("(%p) : Incorrect type for a texture : %d\n", This, textureType);
+ } else if (textureType == D3DRTYPE_CUBETEXTURE) {
+ /* Standard Cube texture */
+ FIXME("Standard Cube texture\n");
+ /*This->UpdateStateBlock->textureDimensions[Stage] = GL_TEXTURE_4D;*/
+
+ /* Load up the texture now */
+ IDirect3DCubeTexture8Impl_PreLoad((LPDIRECT3DCUBETEXTURE8) pTexture);
+ } else {
+ FIXME("(%p) : Incorrect type for a texture : (%d,%s)\n", This, textureType, debug_d3dressourcetype(textureType));
}
} else {
TRACE("Setting to no texture (ie default texture)\n");
@@ -3535,12 +3718,12 @@
return D3D_OK;
}
-HRESULT WINAPI IDirect3DDevice8Impl_SetTextureStageState(LPDIRECT3DDEVICE8 iface, DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value) {
+HRESULT WINAPI IDirect3DDevice8Impl_SetTextureStageState(LPDIRECT3DDEVICE8 iface, DWORD Stage, D3DTEXTURESTAGESTATETYPE Type, DWORD Value) {
ICOM_THIS(IDirect3DDevice8Impl,iface);
/* FIXME: Handle 3d textures? What if TSS value set before set texture? Need to reapply all values? */
- TRACE("(%p) : stub, Stage=%ld, Type=%d, Value =%ld\n", This, Stage, Type, Value);
+ TRACE("(%p) : stub, Stage=%ld, Type=%d, Value=%ld\n", This, Stage, Type, Value);
/* Reject invalid texture units */
if (Stage >= This->TextureUnits) {
@@ -3724,44 +3907,48 @@
case D3DTOP_SELECTARG1 :
{
+ /*FIXME("see if D3DTOP_SELECTARG1 behavior is correct now!\n");*/
glTexEnvi(GL_TEXTURE_ENV, Parm, GL_REPLACE);
checkGLcall("glTexEnvi(GL_TEXTURE_ENV, Parm, GL_REPLACE)");
-#if 0 /* don't seem to do anything */
- BOOL isAlphaOp = (Type == D3DTSS_ALPHAOP);
- DWORD dwValue = 0;
- GLenum source;
- GLenum operand;
- dwValue = This->StateBlock->texture_state[Stage][(isAlphaOp) ? D3DTSS_ALPHAARG1 : D3DTSS_COLORARG1];
- GetSrcAndOpFromValue(dwValue, isAlphaOp, &source, &operand);
- if (isAlphaOp) {
- TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE0_ALPHA_EXT, source, GL_OPERAND0_ALPHA_EXT, operand);
- glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, source);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, 'source')");
- glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, operand);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, 'operand')");
- } else {
- TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE0_RGB_EXT, source, GL_OPERAND0_RGB_EXT, operand);
- glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, source);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, 'source')");
- glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, operand);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, 'operand')");
- }
- dwValue = This->StateBlock->texture_state[Stage][(isAlphaOp) ? D3DTSS_ALPHAARG2 : D3DTSS_COLORARG2];
- GetSrcAndOpFromValue(dwValue, isAlphaOp, &source, &operand);
- if (isAlphaOp) {
- TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE1_ALPHA_EXT, source, GL_OPERAND1_ALPHA_EXT, operand);
- glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, source);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, 'source')");
- glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, operand);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, 'operand')");
- } else {
- TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE1_RGB_EXT, source, GL_OPERAND1_RGB_EXT, operand);
- glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, source);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, 'source')");
- glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, operand);
- checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, 'operand')");
+#if 0 /* don't seem to do anything */
+ {
+ BOOL isAlphaOp = (Type == D3DTSS_ALPHAOP);
+ DWORD dwValue = 0;
+ GLenum source;
+ GLenum operand;
+
+ dwValue = This->StateBlock->texture_state[Stage][(isAlphaOp) ? D3DTSS_ALPHAARG1 : D3DTSS_COLORARG1];
+ GetSrcAndOpFromValue(dwValue, isAlphaOp, &source, &operand);
+ if (isAlphaOp) {
+ TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE0_ALPHA_EXT, source, GL_OPERAND0_ALPHA_EXT, operand);
+ glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, source);
+ checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_EXT, 'source')");
+ glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, operand);
+ checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_EXT, 'operand')");
+ } else {
+ TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE0_RGB_EXT, source, GL_OPERAND0_RGB_EXT, operand);
+ glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, source);
+ checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_EXT, 'source')");
+ glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, operand);
+ checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_EXT, 'operand')");
+ }
+ dwValue = This->StateBlock->texture_state[Stage][(isAlphaOp) ? D3DTSS_ALPHAARG2 : D3DTSS_COLORARG2];
+ GetSrcAndOpFromValue(dwValue, isAlphaOp, &source, &operand);
+ if (isAlphaOp) {
+ TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE1_ALPHA_EXT, source, GL_OPERAND1_ALPHA_EXT, operand);
+ glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, source);
+ checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_EXT, 'source')");
+ glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, operand);
+ checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_EXT, 'operand')");
+ } else {
+ TRACE("Source %x = %x, Operand %x = %x\n", GL_SOURCE1_RGB_EXT, source, GL_OPERAND1_RGB_EXT, operand);
+ glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, source);
+ checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_EXT, 'source')");
+ glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, operand);
+ checkGLcall("glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_EXT, 'operand')");
+ }
}
-#endif
+#endif
}
break;
@@ -3771,6 +3958,7 @@
DWORD dwValue = 0;
GLenum source;
GLenum operand;
+ /*FIXME("see if D3DTOP_SELECTARG2 behavior is correct now!\n");*/
glTexEnvi(GL_TEXTURE_ENV, Parm, GL_REPLACE);
checkGLcall("glTexEnvi(GL_TEXTURE_ENV, Parm, GL_REPLACE)");
/* GL_REPLACE, swap args 0 and 1? */
@@ -3926,11 +4114,13 @@
case D3DTSS_BORDERCOLOR :
{
float col[4];
+#if 0
col[0] = ((Value >> 16) & 0xFF) / 255.0;
col[1] = ((Value >> 8) & 0xFF) / 255.0;
col[2] = ((Value >> 0) & 0xFF) / 255.0;
col[3] = ((Value >> 24) & 0xFF) / 255.0;
-
+#endif
+ D3DCOLORTOGLFLOAT4(Value, col);
TRACE("Setting border color for %x to %lx\n", This->StateBlock->textureDimensions[Stage], Value);
glTexParameterfv(This->StateBlock->textureDimensions[Stage], GL_TEXTURE_BORDER_COLOR, &col[0]);
checkGLcall("glTexParameteri(..., GL_TEXTURE_BORDER_COLOR, ...)");
@@ -4137,7 +4327,7 @@
HRESULT res;
UINT i;
- TRACE("(%p) : VertexShader not fully supported yet : Decl=%p, Func=%p\n", This, pDeclaration, pFunction);
+ TRACE_(d3d_shader)("(%p) : VertexShader not fully supported yet : Decl=%p, Func=%p\n", This, pDeclaration, pFunction);
if (NULL == pDeclaration || NULL == pHandle) { /* pFunction can be NULL see MSDN */
return D3DERR_INVALIDCALL;
}
@@ -4168,7 +4358,7 @@
This->UpdateStateBlock->Set.vertexShader = TRUE;
if (Handle > VS_HIGHESTFIXEDFXF) { /* only valid with non FVF shaders */
- FIXME("(%p) : Created shader, Handle=%lx\n", This, Handle);
+ TRACE_(d3d_shader)("(%p) : Created shader, Handle=%lx\n", This, Handle);
This->UpdateStateBlock->vertexShaderDecl = VERTEX_SHADER_DECL(Handle);
This->UpdateStateBlock->Changed.vertexShaderDecl = TRUE;
This->UpdateStateBlock->Set.vertexShaderDecl = TRUE;
@@ -4190,7 +4380,7 @@
}
HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShader(LPDIRECT3DDEVICE8 iface, DWORD* pHandle) {
ICOM_THIS(IDirect3DDevice8Impl,iface);
- TRACE("(%p) : GetVertexShader returning %ld\n", This, This->StateBlock->VertexShader);
+ TRACE_(d3d_shader)("(%p) : GetVertexShader returning %ld\n", This, This->StateBlock->VertexShader);
*pHandle = This->StateBlock->VertexShader;
return D3D_OK;
}
@@ -4211,7 +4401,7 @@
if (NULL == object) {
return D3DERR_INVALIDCALL;
}
- FIXME("(%p) : freing VertexShader %p\n", This, object);
+ TRACE_(d3d_shader)("(%p) : freing VertexShader %p\n", This, object);
/* TODO: check validity of object */
if (NULL != object->function) HeapFree(GetProcessHeap(), 0, (void *)object->function);
HeapFree(GetProcessHeap(), 0, (void *)object->data);
@@ -4225,7 +4415,7 @@
if (NULL == attached_decl) {
return D3DERR_INVALIDCALL;
}
- FIXME("(%p) : freing VertexShaderDeclaration %p\n", This, attached_decl);
+ TRACE_(d3d_shader)("(%p) : freing VertexShaderDeclaration %p\n", This, attached_decl);
/* TODO: check validity of object */
HeapFree(GetProcessHeap(), 0, (void *)attached_decl->pDeclaration8);
HeapFree(GetProcessHeap(), 0, (void *)attached_decl);
@@ -4238,7 +4428,7 @@
ICOM_THIS(IDirect3DDevice8Impl,iface);
if (Register + ConstantCount > D3D8_VSHADER_MAX_CONSTANTS) {
- ERR("(%p) : SetVertexShaderConstant C[%lu] invalid\n", This, Register);
+ ERR_(d3d_shader)("(%p) : SetVertexShaderConstant C[%lu] invalid\n", This, Register);
return D3DERR_INVALIDCALL;
}
if (NULL == pConstantData) {
@@ -4247,14 +4437,14 @@
if (ConstantCount > 1) {
FLOAT* f = (FLOAT*)pConstantData;
UINT i;
- TRACE("(%p) : SetVertexShaderConstant C[%lu..%lu]=\n", This, Register, Register + ConstantCount - 1);
+ TRACE_(d3d_shader)("(%p) : SetVertexShaderConstant C[%lu..%lu]=\n", This, Register, Register + ConstantCount - 1);
for (i = 0; i < ConstantCount; ++i) {
- TRACE("{%f, %f, %f, %f}\n", f[0], f[1], f[2], f[3]);
+ TRACE_(d3d_shader)("{%f, %f, %f, %f}\n", f[0], f[1], f[2], f[3]);
f += 4;
}
} else {
- FLOAT* f = (FLOAT*)pConstantData;
- TRACE("(%p) : SetVertexShaderConstant, C[%lu]={%f, %f, %f, %f}\n", This, Register, f[0], f[1], f[2], f[3]);
+ FLOAT* f = (FLOAT*) pConstantData;
+ TRACE_(d3d_shader)("(%p) : SetVertexShaderConstant, C[%lu]={%f, %f, %f, %f}\n", This, Register, f[0], f[1], f[2], f[3]);
}
This->UpdateStateBlock->Changed.vertexShaderConstant = TRUE;
memcpy(&This->UpdateStateBlock->vertexShaderConstant[Register], pConstantData, ConstantCount * 4 * sizeof(FLOAT));
@@ -4263,7 +4453,7 @@
HRESULT WINAPI IDirect3DDevice8Impl_GetVertexShaderConstant(LPDIRECT3DDEVICE8 iface, DWORD Register, void* pConstantData, DWORD ConstantCount) {
ICOM_THIS(IDirect3DDevice8Impl,iface);
- TRACE("(%p) : C[%lu] count=%ld\n", This, Register, ConstantCount);
+ TRACE_(d3d_shader)("(%p) : C[%lu] count=%ld\n", This, Register, ConstantCount);
if (Register + ConstantCount > D3D8_VSHADER_MAX_CONSTANTS) {
return D3DERR_INVALIDCALL;
}
Index: d3d8_private.h
===================================================================
RCS file: /home/wine/wine/dlls/d3d8/d3d8_private.h,v
retrieving revision 1.25
diff -u -r1.25 d3d8_private.h
--- d3d8_private.h 12 May 2003 03:10:27 -0000 1.25
+++ d3d8_private.h 14 May 2003 08:26:38 -0000
@@ -173,7 +173,11 @@
(vec).z = D3DCOLOR_B(dw); \
(vec).w = D3DCOLOR_A(dw);
-
+#define D3DCOLORTOGLFLOAT4(dw, vec) \
+ (vec)[0] = D3DCOLOR_R(dw); \
+ (vec)[1] = D3DCOLOR_G(dw); \
+ (vec)[2] = D3DCOLOR_B(dw); \
+ (vec)[3] = D3DCOLOR_A(dw);
/* ===========================================================================
The interfactes themselves
@@ -1124,5 +1128,11 @@
GLint fmt2glintFmt(D3DFORMAT fmt);
GLenum fmt2glFmt(D3DFORMAT fmt);
DWORD fmt2glType(D3DFORMAT fmt);
+
+/**
+ * Internals debug functions
+ */
+const char* debug_d3dformat(D3DFORMAT fmt);
+const char* debug_d3dressourcetype(D3DRESOURCETYPE res);
#endif /* __WINE_D3DX8_PRIVATE_H */
