Use the DUMMYUNIONNAME macros so that the headers can be used in
Winelib.
diff --git a/dlls/ddraw/d3ddevice/mesa.c b/dlls/ddraw/d3ddevice/mesa.c
index 49cb32f..ad3dc29 100644
--- a/dlls/ddraw/d3ddevice/mesa.c
+++ b/dlls/ddraw/d3ddevice/mesa.c
@@ -429,7 +429,7 @@
I am currently working on a set of patches for Mesa to have OSMesa support
16 bpp surfaces => we will able to render directly onto the surface, no
need to do a bpp conversion */
- dest = (unsigned short *) sdesc.y.lpSurface;
+ dest = (unsigned short *) sdesc.u2.lpSurface;
src = ((unsigned char *) odev->buffer) + 4 * (sdesc.dwWidth * (sdesc.dwHeight - 1));
for (y = 0; y < sdesc.dwHeight; y++) {
unsigned char *lsrc = src;
@@ -448,7 +448,7 @@
}
/* Unlock the surface */
- IDirectDrawSurface3_Unlock(surf,sdesc.y.lpSurface);
+ IDirectDrawSurface3_Unlock(surf,sdesc.u2.lpSurface);
#else
/* No need to do anything here... */
#endif
@@ -698,45 +698,45 @@
case D3DVT_VERTEX: { \
D3DVERTEX *vx = ((D3DVERTEX *) lpvertex) + INDEX; \
\
- glNormal3f(vx->nx.nx, vx->ny.ny, vx->nz.nz); \
- glVertex3f(vx->x.x, vx->y.y, vx->z.z); \
- TRACE(" V: %f %f %f\n", vx->x.x, vx->y.y, vx->z.z); \
+ glNormal3f(vx->u4.nx, vx->u5.ny, vx->u6.nz); \
+ glVertex3f(vx->u1.x, vx->u2.y, vx->u3.z); \
+ TRACE(" V: %f %f %f\n", vx->u1.x, vx->u2.y, vx->u3.z); \
} break; \
\
case D3DVT_LVERTEX: { \
D3DLVERTEX *vx = ((D3DLVERTEX *) lpvertex) + INDEX; \
- DWORD col = vx->c.color; \
+ DWORD col = vx->u4.color; \
\
glColor3f(((col >> 16) & 0xFF) / 255.0, \
((col >> 8) & 0xFF) / 255.0, \
((col >> 0) & 0xFF) / 255.0); \
- glVertex3f(vx->x.x, vx->y.y, vx->z.z); \
+ glVertex3f(vx->u1.x, vx->u2.y, vx->u3.z); \
TRACE(" LV: %f %f %f (%02lx %02lx %02lx)\n", \
- vx->x.x, vx->y.y, vx->z.z, \
+ vx->u1.x, vx->u2.y, vx->u3.z, \
((col >> 16) & 0xFF), ((col >> 8) & 0xFF), ((col >> 0) & 0xFF));\
} break; \
\
case D3DVT_TLVERTEX: { \
D3DTLVERTEX *vx = ((D3DTLVERTEX *) lpvertex) + INDEX; \
- DWORD col = vx->c.color; \
+ DWORD col = vx->u5.color; \
\
glColor3f(((col >> 16) & 0xFF) / 255.0, \
((col >> 8) & 0xFF) / 255.0, \
((col >> 0) & 0xFF) / 255.0); \
- glTexCoord2f(vx->u.tu, vx->v.tv); \
- if (vx->r.rhw < 0.01) \
- glVertex3f(vx->x.sx, \
- vx->y.sy, \
- vx->z.sz); \
+ glTexCoord2f(vx->u7.tu, vx->u8.tv); \
+ if (vx->u4.rhw < 0.01) \
+ glVertex3f(vx->u1.sx, \
+ vx->u2.sy, \
+ vx->u3.sz); \
else \
- glVertex4f(vx->x.sx / vx->r.rhw, \
- vx->y.sy / vx->r.rhw, \
- vx->z.sz / vx->r.rhw, \
- 1.0 / vx->r.rhw); \
+ glVertex4f(vx->u1.sx / vx->u4.rhw, \
+ vx->u2.sy / vx->u4.rhw, \
+ vx->u3.sz / vx->u4.rhw, \
+ 1.0 / vx->u4.rhw); \
TRACE(" TLV: %f %f %f (%02lx %02lx %02lx) (%f %f) (%f)\n", \
- vx->x.sx, vx->y.sy, vx->z.sz, \
+ vx->u1.sx, vx->u2.sy, vx->u3.sz, \
((col >> 16) & 0xFF), ((col >> 8) & 0xFF), ((col >> 0) & 0xFF),\
- vx->u.tu, vx->v.tv, vx->r.rhw); \
+ vx->u7.tu, vx->u8.tv, vx->u4.rhw); \
} break; \
\
default: \
@@ -985,7 +985,7 @@
FIXME("(%p)->(): stub\n", This);
/* We get the pointer to the surface (should be done on flip) */
- /* odev->zb->pbuf = This->surface->s.surface_desc.y.lpSurface; */
+ /* odev->zb->pbuf = This->surface->s.surface_desc.u2.lpSurface; */
return DD_OK;
}
@@ -1018,7 +1018,7 @@
I am currently working on a set of patches for Mesa to have OSMesa support
16 bpp surfaces => we will able to render directly onto the surface, no
need to do a bpp conversion */
- dest = (unsigned short *) sdesc.y.lpSurface;
+ dest = (unsigned short *) sdesc.u2.lpSurface;
src = ((unsigned char *) odev->buffer) + 4 * (sdesc.dwWidth * (sdesc.dwHeight - 1));
for (y = 0; y < sdesc.dwHeight; y++) {
unsigned char *lsrc = src;
@@ -1038,7 +1038,7 @@
}
/* Unlock the surface */
- IDirectDrawSurface3_Unlock(surf,sdesc.y.lpSurface);
+ IDirectDrawSurface3_Unlock(surf,sdesc.u2.lpSurface);
#else
/* No need to do anything here... */
#endif
diff --git a/dlls/ddraw/d3dexecutebuffer.c b/dlls/ddraw/d3dexecutebuffer.c
index 8b261c1..9cb33ce 100644
--- a/dlls/ddraw/d3dexecutebuffer.c
+++ b/dlls/ddraw/d3dexecutebuffer.c
@@ -106,25 +106,25 @@
#define DO_TLVERTEX(index) \
{ \
D3DTLVERTEX *vx = &(tl_vx[index]); \
- DWORD col = vx->c.color; \
+ DWORD col = vx->u5.color; \
\
glColor3f(((col >> 16) & 0xFF) / 255.0, \
((col >> 8) & 0xFF) / 255.0, \
((col >> 0) & 0xFF) / 255.0); \
- glTexCoord2f(vx->u.tu, vx->v.tv); \
- if (vx->r.rhw < 0.01) \
- glVertex3f(vx->x.sx, \
- vx->y.sy, \
- vx->z.sz); \
+ glTexCoord2f(vx->u7.tu, vx->u8.tv); \
+ if (vx->u4.rhw < 0.01) \
+ glVertex3f(vx->u1.sx, \
+ vx->u2.sy, \
+ vx->u3.sz); \
else \
- glVertex4f(vx->x.sx / vx->r.rhw, \
- vx->y.sy / vx->r.rhw, \
- vx->z.sz / vx->r.rhw, \
- 1.0 / vx->r.rhw); \
+ glVertex4f(vx->u1.sx / vx->u4.rhw, \
+ vx->u2.sy / vx->u4.rhw, \
+ vx->u3.sz / vx->u4.rhw, \
+ 1.0 / vx->u4.rhw); \
TRACE(" TLV: %f %f %f (%02lx %02lx %02lx) (%f %f) (%f)\n", \
- vx->x.sx, vx->y.sy, vx->z.sz, \
+ vx->u1.sx, vx->u2.sy, vx->u3.sz, \
((col >> 16) & 0xFF), ((col >> 8) & 0xFF), ((col >> 0) & 0xFF), \
- vx->u.tu, vx->v.tv, vx->r.rhw); \
+ vx->u7.tu, vx->u8.tv, vx->u4.rhw); \
}
#define TRIANGLE_LOOP(macro) \
@@ -134,7 +134,7 @@
LPD3DTRIANGLE ci = (LPD3DTRIANGLE) instr; \
\
TRACE(" v1: %d v2: %d v3: %d\n", \
- ci->v1.v1, ci->v2.v2, ci->v3.v3); \
+ ci->u1.v1, ci->u2.v2, ci->u3.v3); \
TRACE(" Flags : "); \
if (TRACE_ON(ddraw)) { \
/* Wireframe */ \
@@ -158,9 +158,9 @@
} \
\
/* Draw the triangle */ \
- macro(ci->v1.v1); \
- macro(ci->v2.v2); \
- macro(ci->v3.v3); \
+ macro(ci->u1.v1); \
+ macro(ci->u2.v2); \
+ macro(ci->u3.v3); \
\
instr += size; \
} \
@@ -367,24 +367,24 @@
LPD3DSTATE ci = (LPD3DSTATE) instr;
/* Handle the state transform */
- switch (ci->t.dtstTransformStateType) {
+ switch (ci->u1.dtstTransformStateType) {
case D3DTRANSFORMSTATE_WORLD: {
- TRACE(" WORLD (%p)\n", (D3DMATRIX*) ci->v.dwArg[0]);
- odev->world_mat = (D3DMATRIX*) ci->v.dwArg[0];
+ TRACE(" WORLD (%p)\n", (D3DMATRIX*) ci->u2.dwArg[0]);
+ odev->world_mat = (D3DMATRIX*) ci->u2.dwArg[0];
} break;
case D3DTRANSFORMSTATE_VIEW: {
- TRACE(" VIEW (%p)\n", (D3DMATRIX*) ci->v.dwArg[0]);
- odev->view_mat = (D3DMATRIX*) ci->v.dwArg[0];
+ TRACE(" VIEW (%p)\n", (D3DMATRIX*) ci->u2.dwArg[0]);
+ odev->view_mat = (D3DMATRIX*) ci->u2.dwArg[0];
} break;
case D3DTRANSFORMSTATE_PROJECTION: {
- TRACE(" PROJECTION (%p)\n", (D3DMATRIX*) ci->v.dwArg[0]);
- odev->proj_mat = (D3DMATRIX*) ci->v.dwArg[0];
+ TRACE(" PROJECTION (%p)\n", (D3DMATRIX*) ci->u2.dwArg[0]);
+ odev->proj_mat = (D3DMATRIX*) ci->u2.dwArg[0];
} break;
default:
- ERR(" Unhandled state transformation !! (%d)\n", (int) ci->t.dtstTransformStateType);
+ ERR(" Unhandled state transformation !! (%d)\n", (int) ci->u1.dtstTransformStateType);
break;
}
@@ -401,9 +401,9 @@
LPD3DSTATE ci = (LPD3DSTATE) instr;
/* Handle the state transform */
- switch (ci->t.dlstLightStateType) {
+ switch (ci->u1.dlstLightStateType) {
case D3DLIGHTSTATE_MATERIAL: {
- IDirect3DMaterial2Impl* mat = (IDirect3DMaterial2Impl*) ci->v.dwArg[0];
+ IDirect3DMaterial2Impl* mat = (IDirect3DMaterial2Impl*) ci->u2.dwArg[0];
TRACE(" MATERIAL\n");
if (mat != NULL) {
@@ -415,7 +415,7 @@
case D3DLIGHTSTATE_AMBIENT: {
float light[4];
- DWORD dwLightState = ci->v.dwArg[0];
+ DWORD dwLightState = ci->u2.dwArg[0];
TRACE(" AMBIENT\n");
light[0] = ((dwLightState >> 16) & 0xFF) / 255.0;
@@ -452,7 +452,7 @@
} break ;
default:
- ERR(" Unhandled light state !! (%d)\n", (int) ci->t.dlstLightStateType);
+ ERR(" Unhandled light state !! (%d)\n", (int) ci->u1.dlstLightStateType);
break;
}
instr += size;
@@ -467,7 +467,7 @@
LPD3DSTATE ci = (LPD3DSTATE) instr;
/* Handle the state transform */
- set_render_state(ci->t.drstRenderStateType, ci->v.dwArg[0], &(odev->rs));
+ set_render_state(ci->u1.drstRenderStateType, ci->u2.dwArg[0], &(odev->rs));
instr += size;
}
@@ -539,18 +539,18 @@
for (nb = 0; nb < ci->dwCount; nb++) {
/* For the moment, no normal transformation... */
- dst->nx = src->nx.nx;
- dst->ny = src->ny.ny;
- dst->nz = src->nz.nz;
+ dst->nx = src->u4.nx;
+ dst->ny = src->u5.ny;
+ dst->nz = src->u6.nz;
- dst->u = src->u.tu;
- dst->v = src->v.tv;
+ dst->u = src->u7.tu;
+ dst->v = src->u8.tv;
/* Now, the matrix multiplication */
- dst->x = (src->x.x * mat->_11) + (src->y.y * mat->_21) + (src->z.z * mat->_31) + (1.0 * mat->_41);
- dst->y = (src->x.x * mat->_12) + (src->y.y * mat->_22) + (src->z.z * mat->_32) + (1.0 * mat->_42);
- dst->z = (src->x.x * mat->_13) + (src->y.y * mat->_23) + (src->z.z * mat->_33) + (1.0 * mat->_43);
- dst->w = (src->x.x * mat->_14) + (src->y.y * mat->_24) + (src->z.z * mat->_34) + (1.0 * mat->_44);
+ dst->x = (src->u1.x * mat->_11) + (src->u2.y * mat->_21) + (src->u3.z * mat->_31) + (1.0 * mat->_41);
+ dst->y = (src->u1.x * mat->_12) + (src->u2.y * mat->_22) + (src->u3.z * mat->_32) + (1.0 * mat->_42);
+ dst->z = (src->u1.x * mat->_13) + (src->u2.y * mat->_23) + (src->u3.z * mat->_33) + (1.0 * mat->_43);
+ dst->w = (src->u1.x * mat->_14) + (src->u2.y * mat->_24) + (src->u3.z * mat->_34) + (1.0 * mat->_44);
src++;
dst++;
@@ -567,16 +567,16 @@
ilpBuff->vertex_type = D3DVT_LVERTEX;
for (nb = 0; nb < ci->dwCount; nb++) {
- dst->c = src->c.color;
- dst->sc = src->s.specular;
- dst->u = src->u.tu;
- dst->v = src->v.tv;
+ dst->c = src->u4.color;
+ dst->sc = src->u5.specular;
+ dst->u = src->u6.tu;
+ dst->v = src->u7.tv;
/* Now, the matrix multiplication */
- dst->x = (src->x.x * mat->_11) + (src->y.y * mat->_21) + (src->z.z * mat->_31) + (1.0 * mat->_41);
- dst->y = (src->x.x * mat->_12) + (src->y.y * mat->_22) + (src->z.z * mat->_32) + (1.0 * mat->_42);
- dst->z = (src->x.x * mat->_13) + (src->y.y * mat->_23) + (src->z.z * mat->_33) + (1.0 * mat->_43);
- dst->w = (src->x.x * mat->_14) + (src->y.y * mat->_24) + (src->z.z * mat->_34) + (1.0 * mat->_44);
+ dst->x = (src->u1.x * mat->_11) + (src->u2.y * mat->_21) + (src->u3.z * mat->_31) + (1.0 * mat->_41);
+ dst->y = (src->u1.x * mat->_12) + (src->u2.y * mat->_22) + (src->u3.z * mat->_32) + (1.0 * mat->_42);
+ dst->z = (src->u1.x * mat->_13) + (src->u2.y * mat->_23) + (src->u3.z * mat->_33) + (1.0 * mat->_43);
+ dst->w = (src->u1.x * mat->_14) + (src->u2.y * mat->_24) + (src->u3.z * mat->_34) + (1.0 * mat->_44);
src++;
dst++;
diff --git a/dlls/ddraw/d3dmaterial.c b/dlls/ddraw/d3dmaterial.c
index 87104f8..bb702fe 100644
--- a/dlls/ddraw/d3dmaterial.c
+++ b/dlls/ddraw/d3dmaterial.c
@@ -33,25 +33,25 @@
This->device.active_device1->set_context(This->device.active_device1);
/* Set the current Material */
- _dump_colorvalue("Diffuse", This->mat.a.diffuse);
+ _dump_colorvalue("Diffuse", This->mat.u.diffuse);
glMaterialfv(GL_FRONT,
GL_DIFFUSE,
- (float *) &(This->mat.a.diffuse));
- _dump_colorvalue("Ambient", This->mat.b.ambient);
+ (float *) &(This->mat.u.diffuse));
+ _dump_colorvalue("Ambient", This->mat.u1.ambient);
glMaterialfv(GL_FRONT,
GL_AMBIENT,
- (float *) &(This->mat.b.ambient));
- _dump_colorvalue("Specular", This->mat.c.specular);
+ (float *) &(This->mat.u1.ambient));
+ _dump_colorvalue("Specular", This->mat.u2.specular);
glMaterialfv(GL_FRONT,
GL_SPECULAR,
- (float *) &(This->mat.c.specular));
- _dump_colorvalue("Emissive", This->mat.d.emissive);
+ (float *) &(This->mat.u2.specular));
+ _dump_colorvalue("Emissive", This->mat.u3.emissive);
glMaterialfv(GL_FRONT,
GL_EMISSION,
- (float *) &(This->mat.d.emissive));
+ (float *) &(This->mat.u3.emissive));
TRACE("Size : %ld\n", This->mat.dwSize);
- TRACE("Power : %f\n", This->mat.e.power);
+ TRACE("Power : %f\n", This->mat.u4.power);
TRACE("Texture handle : %08lx\n", (DWORD)This->mat.hTexture);
LEAVE_GL();
diff --git a/dlls/dplayx/dplay.c b/dlls/dplayx/dplay.c
index 0bcd852..df443c5 100644
--- a/dlls/dplayx/dplay.c
+++ b/dlls/dplayx/dplay.c
@@ -1144,8 +1144,8 @@
static void
DP_DeleteDPNameStruct( LPDPNAME lpDPName )
{
- HeapFree( GetProcessHeap(), HEAP_ZERO_MEMORY, lpDPName->psn.lpszShortNameA );
- HeapFree( GetProcessHeap(), HEAP_ZERO_MEMORY, lpDPName->pln.lpszLongNameA );
+ HeapFree( GetProcessHeap(), HEAP_ZERO_MEMORY, lpDPName->u1.lpszShortNameA );
+ HeapFree( GetProcessHeap(), HEAP_ZERO_MEMORY, lpDPName->u2.lpszLongNameA );
}
/* This method assumes that all links to it are already deleted */
@@ -1208,14 +1208,14 @@
}
/* Delete any existing pointers */
- if( lpDst->psn.lpszShortNameA )
+ if( lpDst->u1.lpszShortNameA )
{
- HeapFree( GetProcessHeap(), 0, lpDst->psn.lpszShortNameA );
+ HeapFree( GetProcessHeap(), 0, lpDst->u1.lpszShortNameA );
}
- if( lpDst->pln.lpszLongNameA )
+ if( lpDst->u2.lpszLongNameA )
{
- HeapFree( GetProcessHeap(), 0, lpDst->psn.lpszShortNameA );
+ HeapFree( GetProcessHeap(), 0, lpDst->u1.lpszShortNameA );
}
/* Copy as required */
@@ -1223,32 +1223,32 @@
if( bAnsi )
{
- if( lpSrc->psn.lpszShortNameA )
+ if( lpSrc->u1.lpszShortNameA )
{
- lpDst->psn.lpszShortNameA = HeapAlloc( GetProcessHeap(), 0,
- strlen(lpSrc->psn.lpszShortNameA)+1 );
- strcpy( lpDst->psn.lpszShortNameA, lpSrc->psn.lpszShortNameA );
+ lpDst->u1.lpszShortNameA = HeapAlloc( GetProcessHeap(), 0,
+ strlen(lpSrc->u1.lpszShortNameA)+1 );
+ strcpy( lpDst->u1.lpszShortNameA, lpSrc->u1.lpszShortNameA );
}
- if( lpSrc->pln.lpszLongNameA )
+ if( lpSrc->u2.lpszLongNameA )
{
- lpDst->pln.lpszLongNameA = HeapAlloc( GetProcessHeap(), 0,
- strlen(lpSrc->pln.lpszLongNameA)+1 );
- strcpy( lpDst->pln.lpszLongNameA, lpSrc->pln.lpszLongNameA );
+ lpDst->u2.lpszLongNameA = HeapAlloc( GetProcessHeap(), 0,
+ strlen(lpSrc->u2.lpszLongNameA)+1 );
+ strcpy( lpDst->u2.lpszLongNameA, lpSrc->u2.lpszLongNameA );
}
}
else
{
- if( lpSrc->psn.lpszShortNameA )
+ if( lpSrc->u1.lpszShortNameA )
{
- lpDst->psn.lpszShortName = HeapAlloc( GetProcessHeap(), 0,
- (strlenW(lpSrc->psn.lpszShortName)+1)*sizeof(WCHAR) );
- strcpyW( lpDst->psn.lpszShortName, lpSrc->psn.lpszShortName );
+ lpDst->u1.lpszShortName = HeapAlloc( GetProcessHeap(), 0,
+ (strlenW(lpSrc->u1.lpszShortName)+1)*sizeof(WCHAR) );
+ strcpyW( lpDst->u1.lpszShortName, lpSrc->u1.lpszShortName );
}
- if( lpSrc->pln.lpszLongNameA )
+ if( lpSrc->u2.lpszLongNameA )
{
- lpDst->pln.lpszLongName = HeapAlloc( GetProcessHeap(), 0,
- (strlenW(lpSrc->pln.lpszLongName)+1)*sizeof(WCHAR) );
- strcpyW( lpDst->pln.lpszLongName, lpSrc->pln.lpszLongName );
+ lpDst->u2.lpszLongName = HeapAlloc( GetProcessHeap(), 0,
+ (strlenW(lpSrc->u2.lpszLongName)+1)*sizeof(WCHAR) );
+ strcpyW( lpDst->u2.lpszLongName, lpSrc->u2.lpszLongName );
}
}
@@ -2345,14 +2345,14 @@
dwRequiredDataSize = lpGData->name.dwSize;
- if( lpGData->name.psn.lpszShortNameA )
+ if( lpGData->name.u1.lpszShortNameA )
{
- dwRequiredDataSize += strlen( lpGData->name.psn.lpszShortNameA ) + 1;
+ dwRequiredDataSize += strlen( lpGData->name.u1.lpszShortNameA ) + 1;
}
- if( lpGData->name.pln.lpszLongNameA )
+ if( lpGData->name.u2.lpszLongNameA )
{
- dwRequiredDataSize += strlen( lpGData->name.pln.lpszLongNameA ) + 1;
+ dwRequiredDataSize += strlen( lpGData->name.u2.lpszLongNameA ) + 1;
}
if( ( lpData == NULL ) ||
@@ -2366,24 +2366,24 @@
/* Copy the structure */
CopyMemory( lpName, &lpGData->name, lpGData->name.dwSize );
- if( lpGData->name.psn.lpszShortNameA )
+ if( lpGData->name.u1.lpszShortNameA )
{
strcpy( ((BYTE*)lpName)+lpGData->name.dwSize,
- lpGData->name.psn.lpszShortNameA );
+ lpGData->name.u1.lpszShortNameA );
}
else
{
- lpName->psn.lpszShortNameA = NULL;
+ lpName->u1.lpszShortNameA = NULL;
}
- if( lpGData->name.psn.lpszShortNameA )
+ if( lpGData->name.u1.lpszShortNameA )
{
strcpy( ((BYTE*)lpName)+lpGData->name.dwSize,
- lpGData->name.pln.lpszLongNameA );
+ lpGData->name.u2.lpszLongNameA );
}
else
{
- lpName->pln.lpszLongNameA = NULL;
+ lpName->u2.lpszLongNameA = NULL;
}
return DP_OK;
@@ -2545,14 +2545,14 @@
dwRequiredDataSize = lpPList->lpPData->name.dwSize;
- if( lpPList->lpPData->name.psn.lpszShortNameA )
+ if( lpPList->lpPData->name.u1.lpszShortNameA )
{
- dwRequiredDataSize += strlen( lpPList->lpPData->name.psn.lpszShortNameA ) + 1;
+ dwRequiredDataSize += strlen( lpPList->lpPData->name.u1.lpszShortNameA ) + 1;
}
- if( lpPList->lpPData->name.pln.lpszLongNameA )
+ if( lpPList->lpPData->name.u2.lpszLongNameA )
{
- dwRequiredDataSize += strlen( lpPList->lpPData->name.pln.lpszLongNameA ) + 1;
+ dwRequiredDataSize += strlen( lpPList->lpPData->name.u2.lpszLongNameA ) + 1;
}
if( ( lpData == NULL ) ||
@@ -2566,24 +2566,24 @@
/* Copy the structure */
CopyMemory( lpName, &lpPList->lpPData->name, lpPList->lpPData->name.dwSize );
- if( lpPList->lpPData->name.psn.lpszShortNameA )
+ if( lpPList->lpPData->name.u1.lpszShortNameA )
{
strcpy( ((BYTE*)lpName)+lpPList->lpPData->name.dwSize,
- lpPList->lpPData->name.psn.lpszShortNameA );
+ lpPList->lpPData->name.u1.lpszShortNameA );
}
else
{
- lpName->psn.lpszShortNameA = NULL;
+ lpName->u1.lpszShortNameA = NULL;
}
- if( lpPList->lpPData->name.psn.lpszShortNameA )
+ if( lpPList->lpPData->name.u1.lpszShortNameA )
{
strcpy( ((BYTE*)lpName)+lpPList->lpPData->name.dwSize,
- lpPList->lpPData->name.pln.lpszLongNameA );
+ lpPList->lpPData->name.u2.lpszLongNameA );
}
else
{
- lpName->pln.lpszLongNameA = NULL;
+ lpName->u2.lpszLongNameA = NULL;
}
return DP_OK;
@@ -3148,28 +3148,28 @@
if( bAnsi )
{
- if( lpSessDesc->sess.lpszSessionNameA )
+ if( lpSessDesc->u1.lpszSessionNameA )
{
- dwSize += lstrlenA( lpSessDesc->sess.lpszSessionNameA ) + 1;
+ dwSize += lstrlenA( lpSessDesc->u1.lpszSessionNameA ) + 1;
}
- if( lpSessDesc->pass.lpszPasswordA )
+ if( lpSessDesc->u2.lpszPasswordA )
{
- dwSize += lstrlenA( lpSessDesc->pass.lpszPasswordA ) + 1;
+ dwSize += lstrlenA( lpSessDesc->u2.lpszPasswordA ) + 1;
}
}
else /* UNICODE */
{
- if( lpSessDesc->sess.lpszSessionName )
+ if( lpSessDesc->u1.lpszSessionName )
{
dwSize += sizeof( WCHAR ) *
- ( lstrlenW( lpSessDesc->sess.lpszSessionName ) + 1 );
+ ( lstrlenW( lpSessDesc->u1.lpszSessionName ) + 1 );
}
- if( lpSessDesc->pass.lpszPassword )
+ if( lpSessDesc->u2.lpszPassword )
{
dwSize += sizeof( WCHAR ) *
- ( lstrlenW( lpSessDesc->pass.lpszPassword ) + 1 );
+ ( lstrlenW( lpSessDesc->u2.lpszPassword ) + 1 );
}
}
@@ -3194,42 +3194,42 @@
if( bAnsi )
{
- if( lpSessionSrc->sess.lpszSessionNameA )
+ if( lpSessionSrc->u1.lpszSessionNameA )
{
lstrcpyA( (LPSTR)lpStartOfFreeSpace,
- lpSessionDest->sess.lpszSessionNameA );
- lpSessionDest->sess.lpszSessionNameA = (LPSTR)lpStartOfFreeSpace;
+ lpSessionDest->u1.lpszSessionNameA );
+ lpSessionDest->u1.lpszSessionNameA = (LPSTR)lpStartOfFreeSpace;
lpStartOfFreeSpace +=
- lstrlenA( (LPSTR)lpSessionDest->sess.lpszSessionNameA ) + 1;
+ lstrlenA( (LPSTR)lpSessionDest->u1.lpszSessionNameA ) + 1;
}
- if( lpSessionSrc->pass.lpszPasswordA )
+ if( lpSessionSrc->u2.lpszPasswordA )
{
lstrcpyA( (LPSTR)lpStartOfFreeSpace,
- lpSessionDest->pass.lpszPasswordA );
- lpSessionDest->pass.lpszPasswordA = (LPSTR)lpStartOfFreeSpace;
+ lpSessionDest->u2.lpszPasswordA );
+ lpSessionDest->u2.lpszPasswordA = (LPSTR)lpStartOfFreeSpace;
lpStartOfFreeSpace +=
- lstrlenA( (LPSTR)lpSessionDest->pass.lpszPasswordA ) + 1;
+ lstrlenA( (LPSTR)lpSessionDest->u2.lpszPasswordA ) + 1;
}
}
else /* UNICODE */
{
- if( lpSessionSrc->sess.lpszSessionName )
+ if( lpSessionSrc->u1.lpszSessionName )
{
lstrcpyW( (LPWSTR)lpStartOfFreeSpace,
- lpSessionDest->sess.lpszSessionName );
- lpSessionDest->sess.lpszSessionName = (LPWSTR)lpStartOfFreeSpace;
+ lpSessionDest->u1.lpszSessionName );
+ lpSessionDest->u1.lpszSessionName = (LPWSTR)lpStartOfFreeSpace;
lpStartOfFreeSpace += sizeof(WCHAR) *
- ( lstrlenW( (LPWSTR)lpSessionDest->sess.lpszSessionName ) + 1 );
+ ( lstrlenW( (LPWSTR)lpSessionDest->u1.lpszSessionName ) + 1 );
}
- if( lpSessionSrc->pass.lpszPassword )
+ if( lpSessionSrc->u2.lpszPassword )
{
lstrcpyW( (LPWSTR)lpStartOfFreeSpace,
- lpSessionDest->pass.lpszPassword );
- lpSessionDest->pass.lpszPassword = (LPWSTR)lpStartOfFreeSpace;
+ lpSessionDest->u2.lpszPassword );
+ lpSessionDest->u2.lpszPassword = (LPWSTR)lpStartOfFreeSpace;
lpStartOfFreeSpace += sizeof(WCHAR) *
- ( lstrlenW( (LPWSTR)lpSessionDest->pass.lpszPassword ) + 1 );
+ ( lstrlenW( (LPWSTR)lpSessionDest->u2.lpszPassword ) + 1 );
}
}
}
@@ -3544,8 +3544,8 @@
/* Fill in the DPNAME struct for the service provider */
dpName.dwSize = sizeof( dpName );
dpName.dwFlags = 0;
- dpName.psn.lpszShortNameA = subKeyName;
- dpName.pln.lpszLongNameA = NULL;
+ dpName.u1.lpszShortNameA = subKeyName;
+ dpName.u2.lpszLongNameA = NULL;
/* Create the compound address for the service provider.
NOTE: This is a gruesome architectural scar right now. DP uses DPL and DPL uses DP
@@ -3649,8 +3649,8 @@
/* Fill in the DPNAME struct for the service provider */
dpName.dwSize = sizeof( dpName );
dpName.dwFlags = 0;
- dpName.psn.lpszShortNameA = subKeyName;
- dpName.pln.lpszLongNameA = NULL;
+ dpName.u1.lpszShortNameA = subKeyName;
+ dpName.u2.lpszLongNameA = NULL;
/* Create the compound address for the service provider.
NOTE: This is a gruesome architectural scar right now. DP uses DPL and DPL uses DP
diff --git a/dlls/dplayx/dplayx_global.c b/dlls/dplayx/dplayx_global.c
index 6661d43..8113287 100644
--- a/dlls/dplayx/dplayx_global.c
+++ b/dlls/dplayx/dplayx_global.c
@@ -647,20 +647,20 @@
CopyMemory( dest->lpSessionDesc, src->lpSessionDesc, sizeof( DPSESSIONDESC2 ) );
/* Session names may or may not exist */
- if( src->lpSessionDesc->sess.lpszSessionNameA )
+ if( src->lpSessionDesc->u1.lpszSessionNameA )
{
- strcpy( (LPSTR)lpStartOfFreeSpace, src->lpSessionDesc->sess.lpszSessionNameA );
- dest->lpSessionDesc->sess.lpszSessionNameA = (LPSTR)lpStartOfFreeSpace;
+ strcpy( (LPSTR)lpStartOfFreeSpace, src->lpSessionDesc->u1.lpszSessionNameA );
+ dest->lpSessionDesc->u1.lpszSessionNameA = (LPSTR)lpStartOfFreeSpace;
lpStartOfFreeSpace +=
- strlen( (LPSTR)dest->lpSessionDesc->sess.lpszSessionNameA ) + 1;
+ strlen( (LPSTR)dest->lpSessionDesc->u1.lpszSessionNameA ) + 1;
}
- if( src->lpSessionDesc->pass.lpszPasswordA )
+ if( src->lpSessionDesc->u2.lpszPasswordA )
{
- strcpy( (LPSTR)lpStartOfFreeSpace, src->lpSessionDesc->pass.lpszPasswordA );
- dest->lpSessionDesc->pass.lpszPasswordA = (LPSTR)lpStartOfFreeSpace;
+ strcpy( (LPSTR)lpStartOfFreeSpace, src->lpSessionDesc->u2.lpszPasswordA );
+ dest->lpSessionDesc->u2.lpszPasswordA = (LPSTR)lpStartOfFreeSpace;
lpStartOfFreeSpace +=
- strlen( (LPSTR)dest->lpSessionDesc->pass.lpszPasswordA ) + 1;
+ strlen( (LPSTR)dest->lpSessionDesc->u2.lpszPasswordA ) + 1;
}
}
@@ -671,20 +671,20 @@
lpStartOfFreeSpace += sizeof( DPNAME );
CopyMemory( dest->lpPlayerName, src->lpPlayerName, sizeof( DPNAME ) );
- if( src->lpPlayerName->psn.lpszShortNameA )
+ if( src->lpPlayerName->u1.lpszShortNameA )
{
- strcpy( (LPSTR)lpStartOfFreeSpace, src->lpPlayerName->psn.lpszShortNameA );
- dest->lpPlayerName->psn.lpszShortNameA = (LPSTR)lpStartOfFreeSpace;
+ strcpy( (LPSTR)lpStartOfFreeSpace, src->lpPlayerName->u1.lpszShortNameA );
+ dest->lpPlayerName->u1.lpszShortNameA = (LPSTR)lpStartOfFreeSpace;
lpStartOfFreeSpace +=
- strlen( (LPSTR)dest->lpPlayerName->psn.lpszShortNameA ) + 1;
+ strlen( (LPSTR)dest->lpPlayerName->u1.lpszShortNameA ) + 1;
}
- if( src->lpPlayerName->pln.lpszLongNameA )
+ if( src->lpPlayerName->u2.lpszLongNameA )
{
- strcpy( (LPSTR)lpStartOfFreeSpace, src->lpPlayerName->pln.lpszLongNameA );
- dest->lpPlayerName->pln.lpszLongNameA = (LPSTR)lpStartOfFreeSpace;
+ strcpy( (LPSTR)lpStartOfFreeSpace, src->lpPlayerName->u2.lpszLongNameA );
+ dest->lpPlayerName->u2.lpszLongNameA = (LPSTR)lpStartOfFreeSpace;
lpStartOfFreeSpace +=
- strlen( (LPSTR)dest->lpPlayerName->pln.lpszLongName ) + 1 ;
+ strlen( (LPSTR)dest->lpPlayerName->u2.lpszLongName ) + 1 ;
}
}
@@ -769,20 +769,20 @@
CopyMemory( dest->lpSessionDesc, src->lpSessionDesc, sizeof( DPSESSIONDESC2 ) );
/* Session names may or may not exist */
- if( src->lpSessionDesc->sess.lpszSessionName )
+ if( src->lpSessionDesc->u1.lpszSessionName )
{
- strcpyW( (LPWSTR)lpStartOfFreeSpace, dest->lpSessionDesc->sess.lpszSessionName );
- src->lpSessionDesc->sess.lpszSessionName = (LPWSTR)lpStartOfFreeSpace;
+ strcpyW( (LPWSTR)lpStartOfFreeSpace, dest->lpSessionDesc->u1.lpszSessionName );
+ src->lpSessionDesc->u1.lpszSessionName = (LPWSTR)lpStartOfFreeSpace;
lpStartOfFreeSpace += sizeof(WCHAR) *
- ( strlenW( (LPWSTR)dest->lpSessionDesc->sess.lpszSessionName ) + 1 );
+ ( strlenW( (LPWSTR)dest->lpSessionDesc->u1.lpszSessionName ) + 1 );
}
- if( src->lpSessionDesc->pass.lpszPassword )
+ if( src->lpSessionDesc->u2.lpszPassword )
{
- strcpyW( (LPWSTR)lpStartOfFreeSpace, src->lpSessionDesc->pass.lpszPassword );
- dest->lpSessionDesc->pass.lpszPassword = (LPWSTR)lpStartOfFreeSpace;
+ strcpyW( (LPWSTR)lpStartOfFreeSpace, src->lpSessionDesc->u2.lpszPassword );
+ dest->lpSessionDesc->u2.lpszPassword = (LPWSTR)lpStartOfFreeSpace;
lpStartOfFreeSpace += sizeof(WCHAR) *
- ( strlenW( (LPWSTR)dest->lpSessionDesc->pass.lpszPassword ) + 1 );
+ ( strlenW( (LPWSTR)dest->lpSessionDesc->u2.lpszPassword ) + 1 );
}
}
@@ -793,20 +793,20 @@
lpStartOfFreeSpace += sizeof( DPNAME );
CopyMemory( dest->lpPlayerName, src->lpPlayerName, sizeof( DPNAME ) );
- if( src->lpPlayerName->psn.lpszShortName )
+ if( src->lpPlayerName->u1.lpszShortName )
{
- strcpyW( (LPWSTR)lpStartOfFreeSpace, src->lpPlayerName->psn.lpszShortName );
- dest->lpPlayerName->psn.lpszShortName = (LPWSTR)lpStartOfFreeSpace;
+ strcpyW( (LPWSTR)lpStartOfFreeSpace, src->lpPlayerName->u1.lpszShortName );
+ dest->lpPlayerName->u1.lpszShortName = (LPWSTR)lpStartOfFreeSpace;
lpStartOfFreeSpace += sizeof(WCHAR) *
- ( strlenW( (LPWSTR)dest->lpPlayerName->psn.lpszShortName ) + 1 );
+ ( strlenW( (LPWSTR)dest->lpPlayerName->u1.lpszShortName ) + 1 );
}
- if( src->lpPlayerName->pln.lpszLongName )
+ if( src->lpPlayerName->u2.lpszLongName )
{
- strcpyW( (LPWSTR)lpStartOfFreeSpace, src->lpPlayerName->pln.lpszLongName );
- dest->lpPlayerName->pln.lpszLongName = (LPWSTR)lpStartOfFreeSpace;
+ strcpyW( (LPWSTR)lpStartOfFreeSpace, src->lpPlayerName->u2.lpszLongName );
+ dest->lpPlayerName->u2.lpszLongName = (LPWSTR)lpStartOfFreeSpace;
lpStartOfFreeSpace += sizeof(WCHAR) *
- ( strlenW( (LPWSTR)dest->lpPlayerName->pln.lpszLongName ) + 1 );
+ ( strlenW( (LPWSTR)dest->lpPlayerName->u2.lpszLongName ) + 1 );
}
}
@@ -952,14 +952,14 @@
{
dwTotalSize += sizeof( DPSESSIONDESC2 );
- if( lpConn->lpSessionDesc->sess.lpszSessionNameA )
+ if( lpConn->lpSessionDesc->u1.lpszSessionNameA )
{
- dwTotalSize += strlen( lpConn->lpSessionDesc->sess.lpszSessionNameA ) + 1;
+ dwTotalSize += strlen( lpConn->lpSessionDesc->u1.lpszSessionNameA ) + 1;
}
- if( lpConn->lpSessionDesc->pass.lpszPasswordA )
+ if( lpConn->lpSessionDesc->u2.lpszPasswordA )
{
- dwTotalSize += strlen( lpConn->lpSessionDesc->pass.lpszPasswordA ) + 1;
+ dwTotalSize += strlen( lpConn->lpSessionDesc->u2.lpszPasswordA ) + 1;
}
}
@@ -967,14 +967,14 @@
{
dwTotalSize += sizeof( DPNAME );
- if( lpConn->lpPlayerName->psn.lpszShortNameA )
+ if( lpConn->lpPlayerName->u1.lpszShortNameA )
{
- dwTotalSize += strlen( lpConn->lpPlayerName->psn.lpszShortNameA ) + 1;
+ dwTotalSize += strlen( lpConn->lpPlayerName->u1.lpszShortNameA ) + 1;
}
- if( lpConn->lpPlayerName->pln.lpszLongNameA )
+ if( lpConn->lpPlayerName->u2.lpszLongNameA )
{
- dwTotalSize += strlen( lpConn->lpPlayerName->pln.lpszLongNameA ) + 1;
+ dwTotalSize += strlen( lpConn->lpPlayerName->u2.lpszLongNameA ) + 1;
}
}
@@ -999,16 +999,16 @@
{
dwTotalSize += sizeof( DPSESSIONDESC2 );
- if( lpConn->lpSessionDesc->sess.lpszSessionName )
+ if( lpConn->lpSessionDesc->u1.lpszSessionName )
{
dwTotalSize += sizeof( WCHAR ) *
- ( strlenW( lpConn->lpSessionDesc->sess.lpszSessionName ) + 1 );
+ ( strlenW( lpConn->lpSessionDesc->u1.lpszSessionName ) + 1 );
}
- if( lpConn->lpSessionDesc->pass.lpszPassword )
+ if( lpConn->lpSessionDesc->u2.lpszPassword )
{
dwTotalSize += sizeof( WCHAR ) *
- ( strlenW( lpConn->lpSessionDesc->pass.lpszPassword ) + 1 );
+ ( strlenW( lpConn->lpSessionDesc->u2.lpszPassword ) + 1 );
}
}
@@ -1016,16 +1016,16 @@
{
dwTotalSize += sizeof( DPNAME );
- if( lpConn->lpPlayerName->psn.lpszShortName )
+ if( lpConn->lpPlayerName->u1.lpszShortName )
{
dwTotalSize += sizeof( WCHAR ) *
- ( strlenW( lpConn->lpPlayerName->psn.lpszShortName ) + 1 );
+ ( strlenW( lpConn->lpPlayerName->u1.lpszShortName ) + 1 );
}
- if( lpConn->lpPlayerName->pln.lpszLongName )
+ if( lpConn->lpPlayerName->u2.lpszLongName )
{
dwTotalSize += sizeof( WCHAR ) *
- ( strlenW( lpConn->lpPlayerName->pln.lpszLongName ) + 1 );
+ ( strlenW( lpConn->lpPlayerName->u2.lpszLongName ) + 1 );
}
}
@@ -1053,17 +1053,17 @@
{
CopyMemory( lpSessionDest, lpSessionSrc, sizeof( *lpSessionSrc ) );
- if( lpSessionSrc->sess.lpszSessionNameA )
+ if( lpSessionSrc->u1.lpszSessionNameA )
{
- if ((lpSessionDest->sess.lpszSessionNameA = HeapAlloc( GetProcessHeap(), 0,
- strlen(lpSessionSrc->sess.lpszSessionNameA)+1 )))
- strcpy( lpSessionDest->sess.lpszSessionNameA, lpSessionSrc->sess.lpszSessionNameA );
+ if ((lpSessionDest->u1.lpszSessionNameA = HeapAlloc( GetProcessHeap(), 0,
+ strlen(lpSessionSrc->u1.lpszSessionNameA)+1 )))
+ strcpy( lpSessionDest->u1.lpszSessionNameA, lpSessionSrc->u1.lpszSessionNameA );
}
- if( lpSessionSrc->pass.lpszPasswordA )
+ if( lpSessionSrc->u2.lpszPasswordA )
{
- if ((lpSessionDest->pass.lpszPasswordA = HeapAlloc( GetProcessHeap(), 0,
- strlen(lpSessionSrc->pass.lpszPasswordA)+1 )))
- strcpy( lpSessionDest->pass.lpszPasswordA, lpSessionSrc->pass.lpszPasswordA );
+ if ((lpSessionDest->u2.lpszPasswordA = HeapAlloc( GetProcessHeap(), 0,
+ strlen(lpSessionSrc->u2.lpszPasswordA)+1 )))
+ strcpy( lpSessionDest->u2.lpszPasswordA, lpSessionSrc->u2.lpszPasswordA );
}
return TRUE;
diff --git a/dlls/dplayx/dplobby.c b/dlls/dplayx/dplobby.c
index 4dbdc70..5c44e69 100644
--- a/dlls/dplayx/dplobby.c
+++ b/dlls/dplayx/dplobby.c
@@ -932,7 +932,7 @@
dplAppInfo.dwSize = sizeof( dplAppInfo );
dplAppInfo.guidApplication = serviceProviderGUID;
- dplAppInfo.appName.lpszAppNameA = subKeyName;
+ dplAppInfo.u.lpszAppNameA = subKeyName;
EnterCriticalSection( &This->unk->DPL_lock );
diff --git a/dlls/dplayx/name_server.c b/dlls/dplayx/name_server.c
index 3d90b5e..68174a3 100644
--- a/dlls/dplayx/name_server.c
+++ b/dlls/dplayx/name_server.c
@@ -118,9 +118,9 @@
CopyMemory( lpCacheNode->data, &lpMsg->sd, sizeof( *lpCacheNode->data ) );
len = WideCharToMultiByte( CP_ACP, 0, (LPWSTR)(lpMsg+1), -1, NULL, 0, NULL, NULL );
- if ((lpCacheNode->data->sess.lpszSessionNameA = HeapAlloc( GetProcessHeap(), 0, len )))
+ if ((lpCacheNode->data->u1.lpszSessionNameA = HeapAlloc( GetProcessHeap(), 0, len )))
WideCharToMultiByte( CP_ACP, 0, (LPWSTR)(lpMsg+1), -1,
- lpCacheNode->data->sess.lpszSessionNameA, len, NULL, NULL );
+ lpCacheNode->data->u1.lpszSessionNameA, len, NULL, NULL );
lpCacheNode->dwTime = timeGetTime();
@@ -341,10 +341,10 @@
if (bAnsi)
dwVariableLen = MultiByteToWideChar( CP_ACP, 0,
- lpDP->dp2->lpSessionDesc->sess.lpszSessionNameA,
+ lpDP->dp2->lpSessionDesc->u1.lpszSessionNameA,
-1, NULL, 0 );
else
- dwVariableLen = strlenW( lpDP->dp2->lpSessionDesc->sess.lpszSessionName ) + 1;
+ dwVariableLen = strlenW( lpDP->dp2->lpSessionDesc->u1.lpszSessionName ) + 1;
dwVariableSize = dwVariableLen * sizeof( WCHAR );
@@ -364,8 +364,8 @@
sizeof( lpDP->dp2->lpSessionDesc->dwSize ) );
rmsg->dwUnknown = 0x0000005c;
if( bAnsi )
- MultiByteToWideChar( CP_ACP, 0, lpDP->dp2->lpSessionDesc->sess.lpszSessionNameA, -1,
+ MultiByteToWideChar( CP_ACP, 0, lpDP->dp2->lpSessionDesc->u1.lpszSessionNameA, -1,
(LPWSTR)(rmsg+1), dwVariableLen );
else
- strcpyW( (LPWSTR)(rmsg+1), lpDP->dp2->lpSessionDesc->sess.lpszSessionName );
+ strcpyW( (LPWSTR)(rmsg+1), lpDP->dp2->lpSessionDesc->u1.lpszSessionName );
}
diff --git a/include/d3dtypes.h b/include/d3dtypes.h
index cbfd914..955a590 100644
--- a/include/d3dtypes.h
+++ b/include/d3dtypes.h
@@ -156,15 +156,15 @@
union {
D3DVALUE hx;
D3DVALUE dvHX;
- } x;
+ } DUMMYUNIONNAME1;
union {
D3DVALUE hy;
D3DVALUE dvHY;
- } y;
+ } DUMMYUNIONNAME2;
union {
D3DVALUE hz;
D3DVALUE dvHZ;
- } z;
+ } DUMMYUNIONNAME3;
} D3DHVERTEX, *LPD3DHVERTEX;
/*
@@ -174,35 +174,35 @@
union {
D3DVALUE sx;
D3DVALUE dvSX;
- } x;
+ } DUMMYUNIONNAME1;
union {
D3DVALUE sy;
D3DVALUE dvSY;
- } y;
+ } DUMMYUNIONNAME2;
union {
D3DVALUE sz;
D3DVALUE dvSZ;
- } z;
+ } DUMMYUNIONNAME3;
union {
D3DVALUE rhw;
D3DVALUE dvRHW;
- } r;
+ } DUMMYUNIONNAME4;
union {
D3DCOLOR color;
D3DCOLOR dcColor;
- } c;
+ } DUMMYUNIONNAME5;
union {
D3DCOLOR specular;
D3DCOLOR dcSpecular;
- } s;
+ } DUMMYUNIONNAME6;
union {
D3DVALUE tu;
D3DVALUE dvTU;
- } u;
+ } DUMMYUNIONNAME7;
union {
D3DVALUE tv;
D3DVALUE dvTV;
- } v;
+ } DUMMYUNIONNAME8;
/* There are C++ members associated with this class */
} D3DTLVERTEX, *LPD3DTLVERTEX;
@@ -210,67 +210,67 @@
union {
D3DVALUE x;
D3DVALUE dvX;
- } x;
+ } DUMMYUNIONNAME1;
union {
D3DVALUE y;
D3DVALUE dvY;
- } y;
+ } DUMMYUNIONNAME2;
union {
D3DVALUE z;
D3DVALUE dvZ;
- } z;
+ } DUMMYUNIONNAME3;
DWORD dwReserved;
union {
D3DCOLOR color;
D3DCOLOR dcColor;
- } c;
+ } DUMMYUNIONNAME4;
union {
D3DCOLOR specular;
D3DCOLOR dcSpecular;
- } s;
+ } DUMMYUNIONNAME5;
union {
D3DVALUE tu;
D3DVALUE dvTU;
- } u;
+ } DUMMYUNIONNAME6;
union {
D3DVALUE tv;
D3DVALUE dvTV;
- } v;
+ } DUMMYUNIONNAME7;
} D3DLVERTEX, *LPD3DLVERTEX;
typedef struct _D3DVERTEX {
union {
D3DVALUE x;
D3DVALUE dvX;
- } x;
+ } DUMMYUNIONNAME1;
union {
D3DVALUE y;
D3DVALUE dvY;
- } y;
+ } DUMMYUNIONNAME2;
union {
D3DVALUE z;
D3DVALUE dvZ;
- } z;
+ } DUMMYUNIONNAME3;
union {
D3DVALUE nx;
D3DVALUE dvNX;
- } nx;
+ } DUMMYUNIONNAME4;
union {
D3DVALUE ny;
D3DVALUE dvNY;
- } ny;
+ } DUMMYUNIONNAME5;
union {
D3DVALUE nz;
D3DVALUE dvNZ;
- } nz;
+ } DUMMYUNIONNAME6;
union {
D3DVALUE tu;
D3DVALUE dvTU;
- } u;
+ } DUMMYUNIONNAME7;
union {
D3DVALUE tv;
D3DVALUE dvTV;
- } v;
+ } DUMMYUNIONNAME8;
/* FIXME: Some C++ stuff to go here */
} D3DVERTEX, *LPD3DVERTEX;
@@ -432,23 +432,23 @@
union {
D3DCOLORVALUE diffuse;
D3DCOLORVALUE dcvDiffuse;
- } a;
+ } DUMMYUNIONNAME;
union {
D3DCOLORVALUE ambient;
D3DCOLORVALUE dcvAmbient;
- } b;
+ } DUMMYUNIONNAME1;
union {
D3DCOLORVALUE specular;
D3DCOLORVALUE dcvSpecular;
- } c;
+ } DUMMYUNIONNAME2;
union {
D3DCOLORVALUE emissive;
D3DCOLORVALUE dcvEmissive;
- } d;
+ } DUMMYUNIONNAME3;
union {
D3DVALUE power;
D3DVALUE dvPower;
- } e;
+ } DUMMYUNIONNAME4;
D3DTEXTUREHANDLE hTexture;
DWORD dwRampSize;
} D3DMATERIAL, *LPD3DMATERIAL;
@@ -911,11 +911,11 @@
D3DTRANSFORMSTATETYPE dtstTransformStateType;
D3DLIGHTSTATETYPE dlstLightStateType;
D3DRENDERSTATETYPE drstRenderStateType;
- } t;
+ } DUMMYUNIONNAME1;
union {
DWORD dwArg[1];
D3DVALUE dvArg[1];
- } v;
+ } DUMMYUNIONNAME2;
} D3DSTATE, *LPD3DSTATE;
typedef struct _D3DMATRIXLOAD {
@@ -1064,15 +1064,15 @@
union {
WORD v1;
WORD wV1;
- } v1;
+ } DUMMYUNIONNAME1;
union {
WORD v2;
WORD wV2;
- } v2;
+ } DUMMYUNIONNAME2;
union {
WORD v3;
WORD wV3;
- } v3;
+ } DUMMYUNIONNAME3;
WORD wFlags;
} D3DTRIANGLE, *LPD3DTRIANGLE;
@@ -1080,11 +1080,11 @@
union {
WORD v1;
WORD wV1;
- } v1;
+ } DUMMYUNIONNAME1;
union {
WORD v2;
WORD wV2;
- } v2;
+ } DUMMYUNIONNAME2;
} D3DLINE, *LPD3DLINE;
typedef struct _D3DSPAN {
diff --git a/include/dplay.h b/include/dplay.h
index 86b98da..1d409aa 100644
--- a/include/dplay.h
+++ b/include/dplay.h
@@ -1,12 +1,6 @@
#ifndef __WINE_DPLAY_H
#define __WINE_DPLAY_H
-/* FIXME: GCC doesn't yet support annon structures so some of the structures
- * defined here don't match the sdk exactly. I've tried to come up with
- * suitably terse names, but this file won't cut it for inclusion into a
- * Winelib app.
- */
-
#include "wine/obj_base.h"
#ifdef __cplusplus
@@ -182,13 +176,13 @@
{
LPWSTR lpszShortName;
LPSTR lpszShortNameA;
- }psn;
+ } DUMMYUNIONNAME1;
union /*playerLongName */ /* Player's formal/real name */
{
LPWSTR lpszLongName;
LPSTR lpszLongNameA;
- }pln;
+ } DUMMYUNIONNAME2;
} DPNAME, *LPDPNAME;
@@ -232,13 +226,13 @@
{
LPWSTR lpszSessionName;
LPSTR lpszSessionNameA;
- }sess;
+ } DUMMYUNIONNAME1;
union /* Optional password */
{
LPWSTR lpszPassword;
LPSTR lpszPasswordA;
- }pass;
+ } DUMMYUNIONNAME2;
DWORD dwReserved1;
DWORD dwReserved2;
@@ -289,7 +283,7 @@
{ /* Message string */
LPWSTR lpszMessage; /* Unicode */
LPSTR lpszMessageA; /* ANSI */
- }msgstr;
+ } DUMMYUNIONNAME;
} DPCHAT, *LPDPCHAT;
typedef struct
@@ -307,12 +301,12 @@
{ /* SSPI provider name */
LPWSTR lpszSSPIProvider; /* Unicode */
LPSTR lpszSSPIProviderA; /* ANSI */
- }sspi;
+ } DUMMYUNIONNAME1;
union
{ /* CAPI provider name */
LPWSTR lpszCAPIProvider; /* Unicode */
LPSTR lpszCAPIProviderA; /* ANSI */
- }capi;
+ } DUMMYUNIONNAME2;
DWORD dwCAPIProviderType; /* Crypto Service Provider type */
DWORD dwEncryptionAlgorithm; /* Encryption Algorithm type */
} DPSECURITYDESC, *LPDPSECURITYDESC;
@@ -327,17 +321,17 @@
{ /* User name of the account */
LPWSTR lpszUsername; /* Unicode */
LPSTR lpszUsernameA; /* ANSI */
- }name;
+ } DUMMYUNIONNAME1;
union
{ /* Password of the account */
LPWSTR lpszPassword; /* Unicode */
LPSTR lpszPasswordA; /* ANSI */
- }pass;
+ } DUMMYUNIONNAME2;
union
{ /* Domain name of the account */
LPWSTR lpszDomain; /* Unicode */
LPSTR lpszDomainA; /* ANSI */
- }domain;
+ } DUMMYUNIONNAME3;
} DPCREDENTIALS, *LPDPCREDENTIALS;
typedef const DPCREDENTIALS *LPCDPCREDENTIALS;
diff --git a/include/dplobby.h b/include/dplobby.h
index 85615b7..83384c7 100644
--- a/include/dplobby.h
+++ b/include/dplobby.h
@@ -1,12 +1,6 @@
#ifndef __WINE_DPLOBBY_H
#define __WINE_DPLOBBY_H
-/* FIXME: GCC doesn't yet support annon structures so some of the structures
- * defined here don't match the sdk exactly. I've tried to come up with
- * suitably terse names, but this file won't cut it for inclusion into a
- * Winelib app.
- */
-
#include "dplay.h"
#ifdef __cplusplus
@@ -276,7 +270,7 @@
{
LPSTR lpszAppNameA;
LPWSTR lpszAppName;
- } appName;
+ } DUMMYUNIONNAME;
} DPLAPPINFO, *LPDPLAPPINFO;
typedef const DPLAPPINFO *LPCDPLAPPINFO;
@@ -298,7 +292,7 @@
{
LPSTR lpszApplicationNameA;
LPWSTR lpszApplicationName;
- } appName;
+ } DUMMYUNIONNAME1;
GUID guidApplication;
@@ -306,25 +300,25 @@
{
LPSTR lpszFilenameA;
LPWSTR lpszFilename;
- } fileName;
+ } DUMMYUNIONNAME2;
union
{
LPSTR lpszCommandLineA;
LPWSTR lpszCommandLine;
- } cmdLine;
+ } DUMMYUNIONNAME3;
union
{
LPSTR lpszPathA;
LPWSTR lpszPath;
- } path;
+ } DUMMYUNIONNAME4;
union
{
LPSTR lpszCurrentDirectoryA;
LPWSTR lpszCurrentDirectory;
- } curDir;
+ } DUMMYUNIONNAME5;
LPSTR lpszDescriptionA;
LPWSTR lpszDescriptionW;
