2003-11-14 04:50:35 +01:00
/*
* Direct3D wine internal private include file
*
* Copyright 2002 - 2003 The wine - d3d team
* Copyright 2002 - 2003 Raphael Junqueira
2005-06-23 13:05:24 +02:00
* Copyright 2004 Jason Edmeades
* Copyright 2005 Oliver Stieber
2003-11-14 04:50:35 +01:00
*
* This library is free software ; you can redistribute it and / or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
* version 2.1 of the License , or ( at your option ) any later version .
*
* This library is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library ; if not , write to the Free Software
* Foundation , Inc . , 59 Temple Place , Suite 330 , Boston , MA 02111 - 1307 USA
*/
# ifndef __WINE_WINED3D_PRIVATE_H
# define __WINE_WINED3D_PRIVATE_H
# include <stdarg.h>
2004-11-29 18:53:42 +01:00
# include <math.h>
2004-09-23 06:34:27 +02:00
# define NONAMELESSUNION
# define NONAMELESSSTRUCT
2004-11-23 14:52:46 +01:00
# define COBJMACROS
2003-11-14 04:50:35 +01:00
# include "windef.h"
# include "winbase.h"
2004-09-23 06:34:27 +02:00
# include "winreg.h"
2003-11-14 04:50:35 +01:00
# include "wingdi.h"
# include "winuser.h"
# include "wine/debug.h"
2004-10-08 22:52:33 +02:00
# include "wine/unicode.h"
2003-11-14 04:50:35 +01:00
2004-09-23 06:34:27 +02:00
# include "d3d9.h"
# include "d3d9types.h"
2006-04-14 19:15:46 +02:00
# include "ddraw.h"
2003-11-14 04:50:35 +01:00
# include "wine/wined3d_interface.h"
2004-09-29 23:26:47 +02:00
# include "wine/wined3d_gl.h"
2003-11-14 04:50:35 +01:00
2005-06-24 13:53:07 +02:00
/* Device caps */
2005-07-05 16:05:18 +02:00
# define MAX_PALETTES 256
# define MAX_STREAMS 16
# define MAX_TEXTURES 8
2005-06-24 13:53:07 +02:00
# define MAX_SAMPLERS 16
2005-07-05 16:05:18 +02:00
# define MAX_ACTIVE_LIGHTS 8
# define MAX_CLIPPLANES D3DMAXUSERCLIPPLANES
# define MAX_LEVELS 256
2005-06-24 13:53:07 +02:00
2005-08-17 12:27:01 +02:00
# define MAX_VSHADER_CONSTANTS 96
2005-08-25 21:24:21 +02:00
# define MAX_PSHADER_CONSTANTS 32
2005-08-17 12:27:01 +02:00
2005-07-05 16:05:18 +02:00
/* Used for CreateStateBlock */
# define NUM_SAVEDPIXELSTATES_R 35
# define NUM_SAVEDPIXELSTATES_T 18
# define NUM_SAVEDPIXELSTATES_S 12
# define NUM_SAVEDVERTEXSTATES_R 31
# define NUM_SAVEDVERTEXSTATES_T 2
# define NUM_SAVEDVERTEXSTATES_S 1
extern const DWORD SavedPixelStates_R [ NUM_SAVEDPIXELSTATES_R ] ;
extern const DWORD SavedPixelStates_T [ NUM_SAVEDPIXELSTATES_T ] ;
extern const DWORD SavedPixelStates_S [ NUM_SAVEDPIXELSTATES_S ] ;
extern const DWORD SavedVertexStates_R [ NUM_SAVEDVERTEXSTATES_R ] ;
extern const DWORD SavedVertexStates_T [ NUM_SAVEDVERTEXSTATES_T ] ;
extern const DWORD SavedVertexStates_S [ NUM_SAVEDVERTEXSTATES_S ] ;
2005-08-03 13:00:28 +02:00
typedef enum _WINELOOKUP {
WINELOOKUP_WARPPARAM = 0 ,
WINELOOKUP_MAGFILTER = 1 ,
MAX_LOOKUPS = 2
} WINELOOKUP ;
extern int minLookup [ MAX_LOOKUPS ] ;
extern int maxLookup [ MAX_LOOKUPS ] ;
extern DWORD * stateLookup [ MAX_LOOKUPS ] ;
extern DWORD minMipLookup [ D3DTEXF_ANISOTROPIC + 1 ] [ D3DTEXF_LINEAR + 1 ] ;
2006-03-22 20:46:59 +01:00
typedef struct _WINED3DGLTYPE {
int d3dType ;
GLint size ;
GLenum glType ;
GLboolean normalized ;
int typesize ;
} WINED3DGLTYPE ;
2005-08-03 13:00:28 +02:00
/* NOTE: Make sure these are in the correct numerical order. (see /include/d3d9types.h typedef enum _D3DDECLTYPE) */
2006-03-22 20:46:59 +01:00
WINED3DGLTYPE static const glTypeLookup [ D3DDECLTYPE_UNUSED ] = {
2005-08-03 13:00:28 +02:00
{ D3DDECLTYPE_FLOAT1 , 1 , GL_FLOAT , GL_FALSE , sizeof ( float ) } ,
{ D3DDECLTYPE_FLOAT2 , 2 , GL_FLOAT , GL_FALSE , sizeof ( float ) } ,
{ D3DDECLTYPE_FLOAT3 , 3 , GL_FLOAT , GL_FALSE , sizeof ( float ) } ,
{ D3DDECLTYPE_FLOAT4 , 4 , GL_FLOAT , GL_FALSE , sizeof ( float ) } ,
{ D3DDECLTYPE_D3DCOLOR , 4 , GL_UNSIGNED_BYTE , GL_TRUE , sizeof ( BYTE ) } ,
{ D3DDECLTYPE_UBYTE4 , 4 , GL_UNSIGNED_BYTE , GL_FALSE , sizeof ( BYTE ) } ,
{ D3DDECLTYPE_SHORT2 , 2 , GL_SHORT , GL_FALSE , sizeof ( short int ) } ,
{ D3DDECLTYPE_SHORT4 , 4 , GL_SHORT , GL_FALSE , sizeof ( short int ) } ,
{ D3DDECLTYPE_UBYTE4N , 4 , GL_UNSIGNED_BYTE , GL_FALSE , sizeof ( BYTE ) } ,
{ D3DDECLTYPE_SHORT2N , 2 , GL_SHORT , GL_FALSE , sizeof ( short int ) } ,
{ D3DDECLTYPE_SHORT4N , 4 , GL_SHORT , GL_FALSE , sizeof ( short int ) } ,
{ D3DDECLTYPE_USHORT2N , 2 , GL_UNSIGNED_SHORT , GL_FALSE , sizeof ( short int ) } ,
{ D3DDECLTYPE_USHORT4N , 4 , GL_UNSIGNED_SHORT , GL_FALSE , sizeof ( short int ) } ,
{ D3DDECLTYPE_UDEC3 , 3 , GL_UNSIGNED_SHORT , GL_FALSE , sizeof ( short int ) } ,
{ D3DDECLTYPE_DEC3N , 3 , GL_SHORT , GL_FALSE , sizeof ( short int ) } ,
{ D3DDECLTYPE_FLOAT16_2 , 2 , GL_FLOAT , GL_FALSE , sizeof ( short int ) } ,
{ D3DDECLTYPE_FLOAT16_4 , 4 , GL_FLOAT , GL_FALSE , sizeof ( short int ) } } ;
2006-03-22 20:46:59 +01:00
# define WINED3D_ATR_TYPE(_attribute) glTypeLookup[sd->u.s._attribute.dwType].d3dType
# define WINED3D_ATR_SIZE(_attribute) glTypeLookup[sd->u.s._attribute.dwType].size
# define WINED3D_ATR_GLTYPE(_attribute) glTypeLookup[sd->u.s._attribute.dwType].glType
# define WINED3D_ATR_NORMALIZED(_attribute) glTypeLookup[sd->u.s._attribute.dwType].normalized
# define WINED3D_ATR_TYPESIZE(_attribute) glTypeLookup[sd->u.s._attribute.dwType].typesize
2005-08-03 13:00:28 +02:00
2005-07-24 19:11:33 +02:00
/**
* Settings
*/
2005-09-23 13:08:03 +02:00
# define VS_NONE 0
# define VS_HW 1
# define VS_SW 2
2004-09-23 06:34:27 +02:00
2005-09-23 13:08:03 +02:00
# define PS_NONE 0
# define PS_HW 1
2004-09-23 06:34:27 +02:00
2005-09-23 13:08:03 +02:00
# define VBO_NONE 0
# define VBO_HW 1
# define NP2_NONE 0
# define NP2_REPACK 1
2005-07-24 19:11:33 +02:00
typedef struct wined3d_settings_s {
/* vertex and pixel shader modes */
int vs_mode ;
int ps_mode ;
int vbo_mode ;
2005-09-23 13:08:03 +02:00
/* nonpower 2 function */
int nonpower2_mode ;
2005-07-24 19:11:33 +02:00
} wined3d_settings_t ;
extern wined3d_settings_t wined3d_settings ;
2004-09-29 23:26:47 +02:00
/* X11 locking */
extern void ( * wine_tsx11_lock_ptr ) ( void ) ;
extern void ( * wine_tsx11_unlock_ptr ) ( void ) ;
/* As GLX relies on X, this is needed */
extern int num_lock ;
#if 0
# define ENTER_GL() ++num_lock; if (num_lock > 1) FIXME("Recursive use of GL lock to: %d\n", num_lock); wine_tsx11_lock_ptr()
# define LEAVE_GL() if (num_lock != 1) FIXME("Recursive use of GL lock: %d\n", num_lock); --num_lock; wine_tsx11_unlock_ptr()
# else
# define ENTER_GL() wine_tsx11_lock_ptr()
# define LEAVE_GL() wine_tsx11_unlock_ptr()
# endif
/*****************************************************************************
* Defines
*/
2004-12-13 14:35:38 +01:00
/* GL related defines */
/* ------------------ */
2004-11-28 16:04:41 +01:00
# define GL_SUPPORT(ExtName) (GLINFO_LOCATION.supported[ExtName] != 0)
# define GL_LIMITS(ExtName) (GLINFO_LOCATION.max_##ExtName)
2004-12-09 12:42:34 +01:00
# define GL_EXTCALL(FuncName) (GLINFO_LOCATION.FuncName)
2005-08-17 13:34:03 +02:00
# define GL_VEND(_VendName) (GLINFO_LOCATION.gl_vendor == VENDOR_##_VendName ? TRUE : FALSE)
2004-10-06 02:05:29 +02:00
2005-11-15 13:03:13 +01:00
# define D3DCOLOR_B_R(dw) (((dw) >> 16) & 0xFF)
# define D3DCOLOR_B_G(dw) (((dw) >> 8) & 0xFF)
# define D3DCOLOR_B_B(dw) (((dw) >> 0) & 0xFF)
# define D3DCOLOR_B_A(dw) (((dw) >> 24) & 0xFF)
2004-12-13 14:35:38 +01:00
# define D3DCOLOR_R(dw) (((float) (((dw) >> 16) & 0xFF)) / 255.0f)
# define D3DCOLOR_G(dw) (((float) (((dw) >> 8) & 0xFF)) / 255.0f)
# define D3DCOLOR_B(dw) (((float) (((dw) >> 0) & 0xFF)) / 255.0f)
# define D3DCOLOR_A(dw) (((float) (((dw) >> 24) & 0xFF)) / 255.0f)
# define D3DCOLORTOGLFLOAT4(dw, vec) \
( vec ) [ 0 ] = D3DCOLOR_R ( dw ) ; \
( vec ) [ 1 ] = D3DCOLOR_G ( dw ) ; \
( vec ) [ 2 ] = D3DCOLOR_B ( dw ) ; \
( vec ) [ 3 ] = D3DCOLOR_A ( dw ) ;
/* Note: The following is purely to keep the source code as clear from #ifdefs as possible */
# if defined(GL_VERSION_1_3)
2004-12-14 12:54:27 +01:00
# define GLACTIVETEXTURE(textureNo) \
glActiveTexture ( GL_TEXTURE0 + textureNo ) ; \
2004-12-13 14:35:38 +01:00
checkGLcall ( " glActiveTexture " ) ;
2005-01-17 14:44:57 +01:00
# define GLCLIENTACTIVETEXTURE(textureNo) \
glClientActiveTexture ( GL_TEXTURE0 + textureNo ) ;
2004-12-14 12:54:27 +01:00
# define GLMULTITEXCOORD1F(a,b) \
glMultiTexCoord1f ( GL_TEXTURE0 + a , b ) ;
# define GLMULTITEXCOORD2F(a,b,c) \
glMultiTexCoord2f ( GL_TEXTURE0 + a , b , c ) ;
# define GLMULTITEXCOORD3F(a,b,c,d) \
glMultiTexCoord3f ( GL_TEXTURE0 + a , b , c , d ) ;
# define GLMULTITEXCOORD4F(a,b,c,d,e) \
glMultiTexCoord4f ( GL_TEXTURE0 + a , b , c , d , e ) ;
2005-01-17 14:44:57 +01:00
# define GLTEXTURECUBEMAP GL_TEXTURE_CUBE_MAP
2004-12-13 14:35:38 +01:00
# else
2004-12-14 12:54:27 +01:00
# define GLACTIVETEXTURE(textureNo) \
glActiveTextureARB ( GL_TEXTURE0_ARB + textureNo ) ; \
2004-12-13 14:35:38 +01:00
checkGLcall ( " glActiveTextureARB " ) ;
2005-01-17 14:44:57 +01:00
# define GLCLIENTACTIVETEXTURE(textureNo) \
glClientActiveTextureARB ( GL_TEXTURE0_ARB + textureNo ) ;
2004-12-14 12:54:27 +01:00
# define GLMULTITEXCOORD1F(a,b) \
2004-12-17 20:07:44 +01:00
glMultiTexCoord1fARB ( GL_TEXTURE0_ARB + a , b ) ;
2004-12-14 12:54:27 +01:00
# define GLMULTITEXCOORD2F(a,b,c) \
2004-12-17 20:07:44 +01:00
glMultiTexCoord2fARB ( GL_TEXTURE0_ARB + a , b , c ) ;
2004-12-14 12:54:27 +01:00
# define GLMULTITEXCOORD3F(a,b,c,d) \
2004-12-17 20:07:44 +01:00
glMultiTexCoord3fARB ( GL_TEXTURE0_ARB + a , b , c , d ) ;
2004-12-14 12:54:27 +01:00
# define GLMULTITEXCOORD4F(a,b,c,d,e) \
2004-12-17 20:07:44 +01:00
glMultiTexCoord4fARB ( GL_TEXTURE0_ARB + a , b , c , d , e ) ;
2005-01-17 14:44:57 +01:00
# define GLTEXTURECUBEMAP GL_TEXTURE_CUBE_MAP_ARB
2004-12-13 14:35:38 +01:00
# endif
/* DirectX Device Limits */
/* --------------------- */
2005-01-17 14:44:57 +01:00
# define MAX_LEVELS 256 /* Maximum number of mipmap levels. Guessed at 256 */
2004-10-06 02:05:29 +02:00
# define MAX_STREAMS 16 / * Maximum possible streams - used for fixed size arrays
See MaxStreams in MSDN under GetDeviceCaps */
2005-03-03 14:57:15 +01:00
/* Maximum number of constants provided to the shaders */
2004-11-28 16:04:41 +01:00
# define HIGHEST_TRANSFORMSTATE 512
/* Highest value in D3DTRANSFORMSTATETYPE */
2004-11-29 18:53:42 +01:00
# define MAX_CLIPPLANES D3DMAXUSERCLIPPLANES
2004-10-06 02:05:29 +02:00
2005-01-09 18:37:02 +01:00
# define MAX_PALETTES 256
2004-12-13 14:35:38 +01:00
/* Checking of API calls */
/* --------------------- */
2006-04-10 06:39:07 +02:00
# define checkGLcall(A) \
{ \
GLint err = glGetError ( ) ; \
if ( err = = GL_NO_ERROR ) { \
TRACE ( " %s call ok %s / %d \n " , A , __FILE__ , __LINE__ ) ; \
\
} else do { \
FIXME ( " >>>>>>>>>>>>>>>>> %x from %s @ %s / %d \n " , \
err , A , __FILE__ , __LINE__ ) ; \
err = glGetError ( ) ; \
} while ( err ! = GL_NO_ERROR ) ; \
}
2004-10-08 22:52:33 +02:00
2004-12-13 14:35:38 +01:00
/* Trace routines / diagnostics */
/* ---------------------------- */
/* Dump out a matrix and copy it */
2004-11-28 16:04:41 +01:00
# define conv_mat(mat,gl_mat) \
do { \
TRACE ( " %f %f %f %f \n " , ( mat ) - > u . s . _11 , ( mat ) - > u . s . _12 , ( mat ) - > u . s . _13 , ( mat ) - > u . s . _14 ) ; \
TRACE ( " %f %f %f %f \n " , ( mat ) - > u . s . _21 , ( mat ) - > u . s . _22 , ( mat ) - > u . s . _23 , ( mat ) - > u . s . _24 ) ; \
TRACE ( " %f %f %f %f \n " , ( mat ) - > u . s . _31 , ( mat ) - > u . s . _32 , ( mat ) - > u . s . _33 , ( mat ) - > u . s . _34 ) ; \
TRACE ( " %f %f %f %f \n " , ( mat ) - > u . s . _41 , ( mat ) - > u . s . _42 , ( mat ) - > u . s . _43 , ( mat ) - > u . s . _44 ) ; \
memcpy ( gl_mat , ( mat ) , 16 * sizeof ( float ) ) ; \
} while ( 0 )
2004-11-29 18:53:42 +01:00
/* Macro to dump out the current state of the light chain */
# define DUMP_LIGHT_CHAIN() \
{ \
PLIGHTINFOEL * el = This - > stateBlock - > lights ; \
while ( el ) { \
TRACE ( " Light %p (glIndex %ld, d3dIndex %ld, enabled %d) \n " , el , el - > glIndex , el - > OriginalIndex , el - > lightEnabled ) ; \
el = el - > next ; \
} \
}
2004-12-13 14:35:38 +01:00
/* Trace vector and strided data information */
2004-12-09 12:42:34 +01:00
# define TRACE_VECTOR(name) TRACE( #name "=(%f, %f, %f, %f)\n", name.x, name.y, name.z, name.w);
# define TRACE_STRIDED(sd,name) TRACE( #name "=(data:%p, stride:%ld, type:%ld)\n", sd->u.s.name.lpData, sd->u.s.name.dwStride, sd->u.s.name.dwType);
2004-12-13 14:35:38 +01:00
/* Defines used for optimizations */
/* Only reapply what is necessary */
# define REAPPLY_ALPHAOP 0x0001
# define REAPPLY_ALL 0xFFFF
/* Advance declaration of structures to satisfy compiler */
2004-10-21 22:59:12 +02:00
typedef struct IWineD3DStateBlockImpl IWineD3DStateBlockImpl ;
2005-01-09 18:37:02 +01:00
typedef struct IWineD3DSurfaceImpl IWineD3DSurfaceImpl ;
2006-04-17 17:04:59 +02:00
typedef struct IWineD3DPaletteImpl IWineD3DPaletteImpl ;
2004-10-21 22:59:12 +02:00
2005-07-13 13:34:55 +02:00
/* Tracking */
/* TODO: Move some of this to the device */
long globalChangeGlRam ( long glram ) ;
/* Memory and object tracking */
/*Structure for holding information on all direct3d objects
2005-07-22 11:06:03 +02:00
useful for making sure tracking is ok and when release is called on a device !
and probably quite handy for debugging and dumping states out
2005-07-13 13:34:55 +02:00
*/
typedef struct WineD3DGlobalStatistics {
int glsurfaceram ; /* The aproximate amount of glTexture memory allocated for textures */
} WineD3DGlobalStatistics ;
extern WineD3DGlobalStatistics * wineD3DGlobalStatistics ;
2004-12-13 14:35:38 +01:00
/* Global variables */
2004-11-28 16:04:41 +01:00
extern const float identity [ 16 ] ;
2004-12-09 12:42:34 +01:00
/*****************************************************************************
* Compilable extra diagnostics
*/
/* Trace information per-vertex: (extremely high amount of trace) */
#if 0 /* NOTE: Must be 0 in cvs */
# define VTRACE(A) TRACE A
# else
# define VTRACE(A)
# endif
/* Checking of per-vertex related GL calls */
2006-04-10 06:39:07 +02:00
/* --------------------- */
# define vcheckGLcall(A) \
{ \
GLint err = glGetError ( ) ; \
if ( err = = GL_NO_ERROR ) { \
2004-12-09 12:42:34 +01:00
VTRACE ( ( " %s call ok %s / %d \n " , A , __FILE__ , __LINE__ ) ) ; \
2006-04-10 06:39:07 +02:00
\
} else do { \
FIXME ( " >>>>>>>>>>>>>>>>> %x from %s @ %s / %d \n " , \
err , A , __FILE__ , __LINE__ ) ; \
err = glGetError ( ) ; \
} while ( err ! = GL_NO_ERROR ) ; \
2004-12-09 12:42:34 +01:00
}
2004-12-14 12:54:27 +01:00
/* TODO: Confirm each of these works when wined3d move completed */
#if 0 /* NOTE: Must be 0 in cvs */
/* To avoid having to get gigabytes of trace, the following can be compiled in, and at the start
of each frame , a check is made for the existence of C : \ D3DTRACE , and if if exists d3d trace
is enabled , and if it doesn ' t exists it is disabled . */
# define FRAME_DEBUGGING
/* Adding in the SINGLE_FRAME_DEBUGGING gives a trace of just what makes up a single frame, before
the file is deleted */
# if 1 /* NOTE: Must be 1 in cvs, as this is mostly more useful than a trace from program start */
# define SINGLE_FRAME_DEBUGGING
# endif
/* The following, when enabled, lets you see the makeup of the frame, by drawprimitive calls.
It can only be enabled when FRAME_DEBUGGING is also enabled
The contents of the back buffer are written into / tmp / backbuffer_ * after each primitive
array is drawn . */
# if 0 /* NOTE: Must be 0 in cvs, as this give a lot of ppm files when compiled in */
# define SHOW_FRAME_MAKEUP 1
# endif
/* The following, when enabled, lets you see the makeup of the all the textures used during each
of the drawprimitive calls . It can only be enabled when SHOW_FRAME_MAKEUP is also enabled .
The contents of the textures assigned to each stage are written into
/ tmp / texture_ * _ < Stage > . ppm after each primitive array is drawn . */
# if 0 /* NOTE: Must be 0 in cvs, as this give a lot of ppm files when compiled in */
# define SHOW_TEXTURE_MAKEUP 0
# endif
extern BOOL isOn ;
extern BOOL isDumpingFrames ;
extern LONG primCounter ;
# endif
2004-12-09 12:42:34 +01:00
/*****************************************************************************
* Prototypes
*/
/* Routine common to the draw primitive and draw indexed primitive routines */
void drawPrimitive ( IWineD3DDevice * iface ,
int PrimitiveType ,
long NumPrimitives ,
/* for Indexed: */
long StartVertexIndex ,
2005-08-19 12:05:00 +02:00
UINT numberOfVertices ,
2004-12-09 12:42:34 +01:00
long StartIdx ,
short idxBytes ,
const void * idxData ,
2006-05-06 16:58:57 +02:00
int minIndex ,
WineDirect3DVertexStridedData * DrawPrimStrideData ) ;
2004-12-09 12:42:34 +01:00
2006-05-09 18:16:13 +02:00
# define eps 1e-8
2006-04-18 22:38:30 +02:00
/* Routine to fill gl caps for swapchains and IWineD3D */
BOOL IWineD3DImpl_FillGLCaps ( WineD3D_GL_Info * gl_info ,
Display * display ) ;
2004-11-29 18:53:42 +01:00
/*****************************************************************************
* Internal representation of a light
*/
typedef struct PLIGHTINFOEL PLIGHTINFOEL ;
struct PLIGHTINFOEL {
WINED3DLIGHT OriginalParms ; /* Note D3D8LIGHT == D3D9LIGHT */
DWORD OriginalIndex ;
LONG glIndex ;
BOOL lightEnabled ;
BOOL changed ;
BOOL enabledChanged ;
/* Converted parms to speed up swapping lights */
float lightPosn [ 4 ] ;
float lightDirn [ 4 ] ;
float exponent ;
float cutoff ;
PLIGHTINFOEL * next ;
PLIGHTINFOEL * prev ;
} ;
2004-09-23 06:34:27 +02:00
/*****************************************************************************
* IWineD3D implementation structure
*/
typedef struct IWineD3DImpl
{
/* IUnknown fields */
2005-06-06 21:50:35 +02:00
const IWineD3DVtbl * lpVtbl ;
2005-07-28 12:16:21 +02:00
LONG ref ; /* Note: Ref counting not required */
2004-09-23 06:34:27 +02:00
/* WineD3D Information */
2004-11-23 14:52:46 +01:00
IUnknown * parent ;
2004-09-23 06:34:27 +02:00
UINT dxVersion ;
2004-09-29 23:26:47 +02:00
/* GL Information */
BOOL isGLInfoValid ;
WineD3D_GL_Info gl_info ;
2004-09-23 06:34:27 +02:00
} IWineD3DImpl ;
2005-06-06 21:50:35 +02:00
extern const IWineD3DVtbl IWineD3D_Vtbl ;
2004-09-23 06:34:27 +02:00
2005-07-27 17:33:17 +02:00
typedef struct SwapChainList {
IWineD3DSwapChain * swapchain ;
struct SwapChainList * next ;
} SwapChainList ;
2005-07-19 13:39:24 +02:00
/** Hacked out start of a context manager!! **/
typedef struct glContext {
int Width ;
int Height ;
int usedcount ;
GLXContext context ;
Drawable drawable ;
IWineD3DSurface * pSurface ;
#if 0 /* TODO: someway to represent the state of the context */
IWineD3DStateBlock * pStateBlock ;
# endif
/* a few other things like format */
} glContext ;
/* TODO: setup some flags in the regestry to enable, disable pbuffer support
( since it will break quite a few things until contexts are managed properly ! ) */
extern BOOL pbuffer_support ;
/* allocate one pbuffer per surface */
extern BOOL pbuffer_per_surface ;
/* Maximum number of contexts/pbuffers to keep in cache,
set to 100 because ATI ' s drivers don ' t support deleting pBuffers properly
this needs to be migrated to a list and some option availalbe for controle the cache size .
*/
# define CONTEXT_CACHE 100
2005-07-26 12:34:15 +02:00
typedef struct ResourceList {
IWineD3DResource * resource ;
struct ResourceList * next ;
} ResourceList ;
2005-07-19 13:39:24 +02:00
2006-04-10 19:39:53 +02:00
/* A helper function that dumps a resource list */
void dumpResources ( ResourceList * resources ) ;
2004-10-07 06:22:21 +02:00
/*****************************************************************************
* IWineD3DDevice implementation structure
*/
typedef struct IWineD3DDeviceImpl
{
2004-10-08 22:52:33 +02:00
/* IUnknown fields */
2005-06-06 21:50:35 +02:00
const IWineD3DDeviceVtbl * lpVtbl ;
2005-07-28 12:16:21 +02:00
LONG ref ; /* Note: Ref counting not required */
2004-10-07 06:22:21 +02:00
2004-10-08 22:52:33 +02:00
/* WineD3D Information */
2005-01-17 14:44:57 +01:00
IUnknown * parent ;
2004-11-28 16:04:41 +01:00
IWineD3D * wineD3D ;
2004-10-07 06:22:21 +02:00
2004-10-08 22:52:33 +02:00
/* X and GL Information */
GLint maxConcurrentLights ;
/* Optimization */
BOOL modelview_valid ;
BOOL proj_valid ;
BOOL view_ident ; /* true iff view matrix is identity */
BOOL last_was_rhw ; /* true iff last draw_primitive was in xyzrhw mode */
2006-02-13 13:25:21 +01:00
BOOL viewport_changed ; /* Was the viewport changed since the last draw? */
2004-12-09 12:42:34 +01:00
GLenum tracking_parm ; /* Which source is tracking current colour */
LONG tracking_color ; /* used iff GL_COLOR_MATERIAL was enabled */
2005-03-02 13:16:10 +01:00
# define DISABLED_TRACKING 0 /* Disabled */
# define IS_TRACKING 1 /* tracking_parm is tracking diffuse color */
# define NEEDS_TRACKING 2 /* Tracking needs to be enabled when needed */
# define NEEDS_DISABLE 3 /* Tracking needs to be disabled when needed*/
2004-12-13 14:35:38 +01:00
UINT srcBlend ;
UINT dstBlend ;
UINT alphafunc ;
UINT stencilfunc ;
BOOL texture_shader_active ; /* TODO: Confirm use is correct */
2004-10-08 22:52:33 +02:00
2004-10-21 22:59:12 +02:00
/* State block related */
BOOL isRecordingState ;
IWineD3DStateBlockImpl * stateBlock ;
IWineD3DStateBlockImpl * updateStateBlock ;
2004-10-08 22:52:33 +02:00
/* Internal use fields */
2006-04-03 14:54:16 +02:00
WINED3DDEVICE_CREATION_PARAMETERS createParms ;
2004-10-08 22:52:33 +02:00
UINT adapterNo ;
D3DDEVTYPE devType ;
2005-07-27 17:33:17 +02:00
SwapChainList * swapchains ;
2005-06-23 13:05:24 +02:00
2005-07-26 12:34:15 +02:00
ResourceList * resources ; /* a linked list to track resources created by the device */
2005-01-09 18:37:02 +01:00
/* Render Target Support */
2005-03-14 11:12:52 +01:00
IWineD3DSurface * depthStencilBuffer ;
2005-01-09 18:37:02 +01:00
2005-03-14 11:12:52 +01:00
IWineD3DSurface * renderTarget ;
IWineD3DSurface * stencilBufferTarget ;
2005-01-09 18:37:02 +01:00
/* palettes texture management */
2005-03-14 11:12:52 +01:00
PALETTEENTRY palettes [ MAX_PALETTES ] [ 256 ] ;
UINT currentPalette ;
2005-01-09 18:37:02 +01:00
2004-12-09 12:42:34 +01:00
/* For rendering to a texture using glCopyTexImage */
2005-03-14 11:12:52 +01:00
BOOL renderUpsideDown ;
2004-12-09 12:42:34 +01:00
2005-03-02 13:16:10 +01:00
/* Cursor management */
BOOL bCursorVisible ;
UINT xHotSpot ;
UINT yHotSpot ;
UINT xScreenSpace ;
UINT yScreenSpace ;
2004-12-13 14:35:38 +01:00
/* Textures for when no other textures are mapped */
2005-07-05 16:05:18 +02:00
UINT dummyTextureName [ MAX_TEXTURES ] ;
2004-12-13 14:35:38 +01:00
2005-03-02 13:16:10 +01:00
/* Debug stream management */
BOOL debug ;
2005-09-21 12:55:03 +02:00
/* Device state management */
HRESULT state ;
2006-04-18 22:38:30 +02:00
BOOL d3d_initialized ;
2005-09-21 12:55:03 +02:00
2005-07-19 13:39:24 +02:00
/* Screen buffer resources */
glContext contextCache [ CONTEXT_CACHE ] ;
/* A flag to check if endscene has been called before changing the render tartet */
BOOL sceneEnded ;
2005-10-29 12:30:36 +02:00
/* process vertex shaders using software or hardware */
BOOL softwareVertexProcessing ;
2006-04-18 23:39:52 +02:00
/* DirectDraw stuff */
HWND ddraw_window ;
2004-10-07 06:22:21 +02:00
} IWineD3DDeviceImpl ;
2005-06-06 21:50:35 +02:00
extern const IWineD3DDeviceVtbl IWineD3DDevice_Vtbl ;
2004-10-07 06:22:21 +02:00
2005-07-15 11:54:57 +02:00
/* Support for IWineD3DResource ::Set/Get/FreePrivateData. I don't think
* anybody uses it for much so a good implementation is optional . */
typedef struct PrivateData
{
struct PrivateData * next ;
GUID tag ;
DWORD flags ; /* DDSPD_* */
DWORD uniqueness_value ;
union
{
LPVOID data ;
LPUNKNOWN object ;
} ptr ;
DWORD size ;
} PrivateData ;
2004-10-14 02:32:04 +02:00
/*****************************************************************************
* IWineD3DResource implementation structure
*/
typedef struct IWineD3DResourceClass
{
/* IUnknown fields */
2005-07-28 12:16:21 +02:00
LONG ref ; /* Note: Ref counting not required */
2004-10-14 02:32:04 +02:00
/* WineD3DResource Information */
2004-11-23 14:52:46 +01:00
IUnknown * parent ;
2006-03-09 23:21:16 +01:00
WINED3DRESOURCETYPE resourceType ;
2005-01-09 18:37:02 +01:00
IWineD3DDeviceImpl * wineD3DDevice ;
2006-03-28 14:20:47 +02:00
WINED3DPOOL pool ;
2005-03-29 21:01:00 +02:00
UINT size ;
DWORD usage ;
WINED3DFORMAT format ;
BYTE * allocatedMemory ;
2005-07-15 11:54:57 +02:00
PrivateData * privateData ;
2004-10-14 02:32:04 +02:00
} IWineD3DResourceClass ;
typedef struct IWineD3DResourceImpl
{
/* IUnknown & WineD3DResource Information */
2005-06-06 21:50:35 +02:00
const IWineD3DResourceVtbl * lpVtbl ;
2004-10-14 02:32:04 +02:00
IWineD3DResourceClass resource ;
} IWineD3DResourceImpl ;
/*****************************************************************************
* IWineD3DVertexBuffer implementation structure ( extends IWineD3DResourceImpl )
*/
typedef struct IWineD3DVertexBufferImpl
{
/* IUnknown & WineD3DResource Information */
2005-06-06 21:50:35 +02:00
const IWineD3DVertexBufferVtbl * lpVtbl ;
2004-10-14 02:32:04 +02:00
IWineD3DResourceClass resource ;
/* WineD3DVertexBuffer specifics */
2005-07-13 13:34:55 +02:00
DWORD fvf ;
2004-10-14 02:32:04 +02:00
} IWineD3DVertexBufferImpl ;
2005-06-06 21:50:35 +02:00
extern const IWineD3DVertexBufferVtbl IWineD3DVertexBuffer_Vtbl ;
2004-10-14 02:32:04 +02:00
2005-03-29 21:01:00 +02:00
2004-11-24 19:13:41 +01:00
/*****************************************************************************
* IWineD3DIndexBuffer implementation structure ( extends IWineD3DResourceImpl )
*/
typedef struct IWineD3DIndexBufferImpl
{
/* IUnknown & WineD3DResource Information */
2005-06-06 21:50:35 +02:00
const IWineD3DIndexBufferVtbl * lpVtbl ;
2004-11-24 19:13:41 +01:00
IWineD3DResourceClass resource ;
/* WineD3DVertexBuffer specifics */
} IWineD3DIndexBufferImpl ;
2005-06-06 21:50:35 +02:00
extern const IWineD3DIndexBufferVtbl IWineD3DIndexBuffer_Vtbl ;
2004-11-24 19:13:41 +01:00
2005-08-03 13:00:28 +02:00
/*****************************************************************************
* IWineD3DBaseTexture D3D - > openGL state map lookups
*/
# define WINED3DFUNC_NOTSUPPORTED -2
# define WINED3DFUNC_UNIMPLEMENTED -1
typedef enum winetexturestates {
WINED3DTEXSTA_ADDRESSU = 0 ,
WINED3DTEXSTA_ADDRESSV = 1 ,
WINED3DTEXSTA_ADDRESSW = 2 ,
WINED3DTEXSTA_BORDERCOLOR = 3 ,
WINED3DTEXSTA_MAGFILTER = 4 ,
WINED3DTEXSTA_MINFILTER = 5 ,
WINED3DTEXSTA_MIPFILTER = 6 ,
WINED3DTEXSTA_MAXMIPLEVEL = 7 ,
WINED3DTEXSTA_MAXANISOTROPY = 8 ,
WINED3DTEXSTA_SRGBTEXTURE = 9 ,
WINED3DTEXSTA_ELEMENTINDEX = 10 ,
WINED3DTEXSTA_DMAPOFFSET = 11 ,
WINED3DTEXSTA_TSSADDRESSW = 12 ,
MAX_WINETEXTURESTATES = 13 ,
} winetexturestates ;
typedef struct Wined3dTextureStateMap {
CONST int state ;
int function ;
} Wined3dTextureStateMap ;
2004-12-07 15:29:12 +01:00
/*****************************************************************************
* IWineD3DBaseTexture implementation structure ( extends IWineD3DResourceImpl )
*/
typedef struct IWineD3DBaseTextureClass
{
UINT levels ;
2005-01-09 18:37:02 +01:00
BOOL dirty ;
2005-01-17 14:44:57 +01:00
D3DFORMAT format ;
2005-03-14 11:12:52 +01:00
DWORD usage ;
2005-08-03 13:00:28 +02:00
UINT textureName ;
2005-03-14 11:12:52 +01:00
UINT LOD ;
2006-04-06 19:02:16 +02:00
WINED3DTEXTUREFILTERTYPE filterType ;
2005-08-03 13:00:28 +02:00
DWORD states [ MAX_WINETEXTURESTATES ] ;
2004-12-07 15:29:12 +01:00
} IWineD3DBaseTextureClass ;
typedef struct IWineD3DBaseTextureImpl
{
/* IUnknown & WineD3DResource Information */
2005-06-06 21:50:35 +02:00
const IWineD3DBaseTextureVtbl * lpVtbl ;
2004-12-07 15:29:12 +01:00
IWineD3DResourceClass resource ;
IWineD3DBaseTextureClass baseTexture ;
} IWineD3DBaseTextureImpl ;
2005-01-17 14:44:57 +01:00
/*****************************************************************************
* IWineD3DTexture implementation structure ( extends IWineD3DBaseTextureImpl )
*/
typedef struct IWineD3DTextureImpl
{
/* IUnknown & WineD3DResource/WineD3DBaseTexture Information */
2005-06-06 21:50:35 +02:00
const IWineD3DTextureVtbl * lpVtbl ;
2005-01-17 14:44:57 +01:00
IWineD3DResourceClass resource ;
IWineD3DBaseTextureClass baseTexture ;
/* IWineD3DTexture */
2005-03-14 11:12:52 +01:00
IWineD3DSurface * surfaces [ MAX_LEVELS ] ;
2005-01-17 14:44:57 +01:00
UINT width ;
UINT height ;
2005-08-03 21:49:05 +02:00
float pow2scalingFactorX ;
float pow2scalingFactorY ;
2005-01-17 14:44:57 +01:00
} IWineD3DTextureImpl ;
2005-06-06 21:50:35 +02:00
extern const IWineD3DTextureVtbl IWineD3DTexture_Vtbl ;
2005-01-17 14:44:57 +01:00
/*****************************************************************************
* IWineD3DCubeTexture implementation structure ( extends IWineD3DBaseTextureImpl )
*/
typedef struct IWineD3DCubeTextureImpl
{
/* IUnknown & WineD3DResource/WineD3DBaseTexture Information */
2005-06-06 21:50:35 +02:00
const IWineD3DCubeTextureVtbl * lpVtbl ;
2005-01-17 14:44:57 +01:00
IWineD3DResourceClass resource ;
IWineD3DBaseTextureClass baseTexture ;
/* IWineD3DCubeTexture */
2005-03-14 11:12:52 +01:00
IWineD3DSurface * surfaces [ 6 ] [ MAX_LEVELS ] ;
2005-01-17 14:44:57 +01:00
UINT edgeLength ;
2005-08-03 21:49:05 +02:00
float pow2scalingFactor ;
2005-03-14 11:12:52 +01:00
2005-01-17 14:44:57 +01:00
} IWineD3DCubeTextureImpl ;
2005-06-06 21:50:35 +02:00
extern const IWineD3DCubeTextureVtbl IWineD3DCubeTexture_Vtbl ;
2005-01-17 14:44:57 +01:00
2006-05-10 19:55:02 +02:00
typedef struct _WINED3DVOLUMET_DESC
{
UINT Width ;
UINT Height ;
UINT Depth ;
} WINED3DVOLUMET_DESC ;
2005-01-17 14:44:57 +01:00
/*****************************************************************************
* IWineD3DVolume implementation structure ( extends IUnknown )
*/
typedef struct IWineD3DVolumeImpl
{
2005-03-29 21:01:00 +02:00
/* IUnknown & WineD3DResource fields */
2005-06-06 21:50:35 +02:00
const IWineD3DVolumeVtbl * lpVtbl ;
2005-03-29 21:01:00 +02:00
IWineD3DResourceClass resource ;
2005-01-17 14:44:57 +01:00
/* WineD3DVolume Information */
2006-05-10 19:55:02 +02:00
WINED3DVOLUMET_DESC currentDesc ;
2006-02-06 11:30:48 +01:00
IWineD3DBase * container ;
2005-01-17 14:44:57 +01:00
UINT bytesPerPixel ;
BOOL lockable ;
BOOL locked ;
2006-04-07 13:12:22 +02:00
WINED3DBOX lockedBox ;
WINED3DBOX dirtyBox ;
2005-01-17 14:44:57 +01:00
BOOL dirty ;
} IWineD3DVolumeImpl ;
2005-06-06 21:50:35 +02:00
extern const IWineD3DVolumeVtbl IWineD3DVolume_Vtbl ;
2005-01-17 14:44:57 +01:00
/*****************************************************************************
* IWineD3DVolumeTexture implementation structure ( extends IWineD3DBaseTextureImpl )
*/
typedef struct IWineD3DVolumeTextureImpl
{
/* IUnknown & WineD3DResource/WineD3DBaseTexture Information */
2005-06-06 21:50:35 +02:00
const IWineD3DVolumeTextureVtbl * lpVtbl ;
2005-01-17 14:44:57 +01:00
IWineD3DResourceClass resource ;
IWineD3DBaseTextureClass baseTexture ;
/* IWineD3DVolumeTexture */
2005-03-14 11:12:52 +01:00
IWineD3DVolume * volumes [ MAX_LEVELS ] ;
2005-01-17 14:44:57 +01:00
UINT width ;
UINT height ;
UINT depth ;
} IWineD3DVolumeTextureImpl ;
2005-06-06 21:50:35 +02:00
extern const IWineD3DVolumeTextureVtbl IWineD3DVolumeTexture_Vtbl ;
2005-01-17 14:44:57 +01:00
2005-03-02 13:16:10 +01:00
typedef struct _WINED3DSURFACET_DESC
{
2006-03-24 17:34:26 +01:00
WINED3DMULTISAMPLE_TYPE MultiSampleType ;
DWORD MultiSampleQuality ;
UINT Width ;
UINT Height ;
2005-03-02 13:16:10 +01:00
} WINED3DSURFACET_DESC ;
2006-05-06 18:08:33 +02:00
/*****************************************************************************
* Structure for DIB Surfaces ( GetDC and GDI surfaces )
*/
typedef struct wineD3DSurface_DIB {
HBITMAP DIBsection ;
void * bitmap_data ;
HGDIOBJ holdbitmap ;
BOOL client_memory ;
} wineD3DSurface_DIB ;
2005-01-09 18:37:02 +01:00
/*****************************************************************************
* IWineD3DSurface implementation structure
*/
struct IWineD3DSurfaceImpl
{
/* IUnknown & IWineD3DResource Information */
2005-06-06 21:50:35 +02:00
const IWineD3DSurfaceVtbl * lpVtbl ;
2005-01-09 18:37:02 +01:00
IWineD3DResourceClass resource ;
/* IWineD3DSurface fields */
2006-02-06 11:30:48 +01:00
IWineD3DBase * container ;
2005-03-02 13:16:10 +01:00
WINED3DSURFACET_DESC currentDesc ;
2006-04-21 00:00:30 +02:00
IWineD3DPaletteImpl * palette ;
2005-01-09 18:37:02 +01:00
UINT textureName ;
UINT bytesPerPixel ;
2005-07-11 16:25:54 +02:00
/* TODO: move this off into a management class(maybe!) */
2006-05-06 16:15:37 +02:00
WORD Flags ;
2005-07-11 16:25:54 +02:00
UINT pow2Width ;
UINT pow2Height ;
UINT pow2Size ;
2005-08-03 21:49:05 +02:00
#if 0
2005-07-11 16:25:54 +02:00
/* precalculated x and y scalings for texture coords */
float pow2scalingFactorX ; /* = (Width / pow2Width ) */
float pow2scalingFactorY ; /* = (Height / pow2Height) */
2005-08-03 21:49:05 +02:00
# endif
2005-07-11 16:25:54 +02:00
2005-01-09 18:37:02 +01:00
RECT lockedRect ;
RECT dirtyRect ;
2005-07-11 22:38:27 +02:00
glDescriptor glDescription ;
2006-05-06 18:08:33 +02:00
/* For GetDC */
wineD3DSurface_DIB dib ;
HDC hDC ;
2006-05-09 19:37:38 +02:00
/* Color keys for DDraw */
DDCOLORKEY DestBltCKey ;
DDCOLORKEY DestOverlayCKey ;
DDCOLORKEY SrcOverlayCKey ;
DDCOLORKEY SrcBltCKey ;
DWORD CKeyFlags ;
2005-01-09 18:37:02 +01:00
} ;
2005-06-06 21:50:35 +02:00
extern const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl ;
2005-01-09 18:37:02 +01:00
2006-05-06 16:15:37 +02:00
/* Surface flags: */
# define SFLAG_OVERSIZE 0x0001 /* Surface is bigger than gl size, blts only */
# define SFLAG_CONVERTED 0x0002 /* Converted for color keying or Palettized */
# define SFLAG_DIBSECTION 0x0004 /* Has a DIB section attached for getdc */
# define SFLAG_DIRTY 0x0008 /* Surface was locked by the app */
# define SFLAG_LOCKABLE 0x0010 /* Surface can be locked */
# define SFLAG_DISCARD 0x0020 /* ??? */
# define SFLAG_LOCKED 0x0040 /* Surface is locked atm */
# define SFLAG_ACTIVELOCK 0x0080 /* Not locked, but surface memory is needed */
# define SFLAG_INTEXTURE 0x0100 /* ??? */
# define SFLAG_INPBUFFER 0x0200 /* ??? */
# define SFLAG_NONPOW2 0x0400 /* Surface sizes are not a power of 2 */
# define SFLAG_DYNLOCK 0x0800 /* Surface is often locked by the app */
# define SFLAG_DYNCHANGE 0x1800 /* Surface contents are changed very often, implies DYNLOCK */
2006-05-06 18:08:33 +02:00
# define SFLAG_DCINUSE 0x2000 /* Set between GetDC and ReleaseDC calls */
# define SFLAG_NEWDC 0x4000 /* To inform LockRect about a new dc */
2006-05-09 18:47:28 +02:00
# define SFLAG_LOST 0x8000 /* Surface lost flag for DDraw */
2006-05-06 16:15:37 +02:00
/* In some conditions the surface memory must not be freed:
* SFLAG_OVERSIZE : Not all data can be kept in GL
* SFLAG_CONVERTED : Converting the data back would take too long
* SFLAG_DIBSECTION : The dib code manages the memory
* SFLAG_DIRTY : GL surface isn ' t up to date
* SFLAG_LOCKED : The app requires access to the surface data
* SFLAG_ACTIVELOCK : Some wined3d code needs the memory
* SFLAG_DYNLOCK : Avoid freeing the data for performance
* SFLAG_DYNCHANGE : Same reason as DYNLOCK
*/
# define SFLAG_DONOTFREE (SFLAG_OVERSIZE | \
SFLAG_CONVERTED | \
SFLAG_DIBSECTION | \
SFLAG_DIRTY | \
SFLAG_LOCKED | \
SFLAG_ACTIVELOCK | \
SFLAG_DYNLOCK | \
SFLAG_DYNCHANGE )
2005-01-19 20:34:49 +01:00
/*****************************************************************************
* IWineD3DVertexDeclaration implementation structure
*/
typedef struct IWineD3DVertexDeclarationImpl {
/* IUnknown Information */
2005-06-06 21:50:35 +02:00
const IWineD3DVertexDeclarationVtbl * lpVtbl ;
2005-07-28 12:16:21 +02:00
LONG ref ; /* Note: Ref counting not required */
2005-01-19 20:34:49 +01:00
2005-03-02 13:16:10 +01:00
IUnknown * parent ;
2005-01-19 20:34:49 +01:00
/** precomputed fvf if simple declaration */
IWineD3DDeviceImpl * wineD3DDevice ;
DWORD fvf [ MAX_STREAMS ] ;
DWORD allFVF ;
/** dx8 compatible Declaration fields */
DWORD * pDeclaration8 ;
DWORD declaration8Length ;
/** dx9+ */
2005-12-09 11:23:52 +01:00
D3DVERTEXELEMENT9 * pDeclaration9 ;
2005-01-19 20:34:49 +01:00
UINT declaration9NumElements ;
2005-12-09 11:23:52 +01:00
WINED3DVERTEXELEMENT * pDeclarationWine ;
UINT declarationWNumElements ;
float * constants ;
2005-01-19 20:34:49 +01:00
} IWineD3DVertexDeclarationImpl ;
2005-06-06 21:50:35 +02:00
extern const IWineD3DVertexDeclarationVtbl IWineD3DVertexDeclaration_Vtbl ;
2005-01-19 20:34:49 +01:00
2004-10-21 22:59:12 +02:00
/*****************************************************************************
* IWineD3DStateBlock implementation structure
*/
/* Internal state Block for Begin/End/Capture/Create/Apply info */
/* Note: Very long winded but gl Lists are not flexible enough */
/* to resolve everything we need, so doing it manually for now */
typedef struct SAVEDSTATES {
2004-12-09 12:42:34 +01:00
BOOL indices ;
2004-11-29 18:53:42 +01:00
BOOL material ;
2004-10-21 22:59:12 +02:00
BOOL fvf ;
2005-07-05 16:05:18 +02:00
BOOL streamSource [ MAX_STREAMS ] ;
BOOL streamFreq [ MAX_STREAMS ] ;
BOOL textures [ MAX_TEXTURES ] ;
BOOL transform [ HIGHEST_TRANSFORMSTATE + 1 ] ;
2004-12-09 12:42:34 +01:00
BOOL viewport ;
2005-07-05 16:05:18 +02:00
BOOL renderState [ WINEHIGHEST_RENDER_STATE + 1 ] ;
2005-07-26 20:49:30 +02:00
BOOL textureState [ MAX_TEXTURES ] [ WINED3D_HIGHEST_TEXTURE_STATE + 1 ] ;
BOOL samplerState [ MAX_SAMPLERS ] [ WINED3D_HIGHEST_SAMPLER_STATE + 1 ] ;
2005-08-01 12:58:31 +02:00
BOOL clipplane [ MAX_CLIPPLANES ] ;
2005-01-26 21:54:00 +01:00
BOOL vertexDecl ;
2005-03-02 13:16:10 +01:00
BOOL pixelShader ;
2005-09-28 12:13:00 +02:00
BOOL pixelShaderConstants [ MAX_PSHADER_CONSTANTS ] ;
2005-07-05 16:05:18 +02:00
BOOL vertexShader ;
2005-09-21 12:19:29 +02:00
BOOL vertexShaderConstants [ MAX_VSHADER_CONSTANTS ] ;
2004-10-21 22:59:12 +02:00
} SAVEDSTATES ;
2005-09-21 12:19:29 +02:00
typedef enum {
2005-11-29 17:05:54 +01:00
WINESHADERCNST_NONE = 0 ,
WINESHADERCNST_FLOAT = 1 ,
WINESHADERCNST_INTEGER = 2 ,
WINESHADERCNST_BOOL = 3
2005-09-21 12:19:29 +02:00
} WINESHADERCNST ;
2004-10-21 22:59:12 +02:00
struct IWineD3DStateBlockImpl
{
/* IUnknown fields */
2005-06-06 21:50:35 +02:00
const IWineD3DStateBlockVtbl * lpVtbl ;
2005-07-28 12:16:21 +02:00
LONG ref ; /* Note: Ref counting not required */
2005-07-05 16:05:18 +02:00
2004-10-21 22:59:12 +02:00
/* IWineD3DStateBlock information */
2004-11-23 14:52:46 +01:00
IUnknown * parent ;
2005-01-09 18:37:02 +01:00
IWineD3DDeviceImpl * wineD3DDevice ;
2005-07-26 20:49:30 +02:00
WINED3DSTATEBLOCKTYPE blockType ;
2004-10-21 22:59:12 +02:00
/* Array indicating whether things have been set or changed */
SAVEDSTATES changed ;
SAVEDSTATES set ;
2005-07-05 16:05:18 +02:00
2004-10-21 22:59:12 +02:00
/* Drawing - Vertex Shader or FVF related */
DWORD fvf ;
2005-01-19 20:34:49 +01:00
/* Vertex Shader Declaration */
2005-08-17 13:34:03 +02:00
IWineD3DVertexDeclaration * vertexDecl ;
2005-01-19 20:34:49 +01:00
2005-09-28 12:13:00 +02:00
IWineD3DVertexShader * vertexShader ;
2004-10-21 22:59:12 +02:00
2005-08-17 12:27:01 +02:00
/* Vertex Shader Constants */
BOOL vertexShaderConstantB [ MAX_VSHADER_CONSTANTS ] ;
2005-08-26 10:53:31 +02:00
INT vertexShaderConstantI [ MAX_VSHADER_CONSTANTS * 4 ] ;
2005-08-17 12:27:01 +02:00
float vertexShaderConstantF [ MAX_VSHADER_CONSTANTS * 4 ] ;
2005-09-21 12:19:29 +02:00
WINESHADERCNST vertexShaderConstantT [ MAX_VSHADER_CONSTANTS ] ; /* TODO: Think about changing this to a char to possibly save a little memory */
2005-08-17 12:27:01 +02:00
2004-11-23 14:52:46 +01:00
/* Stream Source */
2005-01-19 20:34:49 +01:00
BOOL streamIsUP ;
2005-07-05 16:05:18 +02:00
UINT streamStride [ MAX_STREAMS ] ;
UINT streamOffset [ MAX_STREAMS ] ;
IWineD3DVertexBuffer * streamSource [ MAX_STREAMS ] ;
UINT streamFreq [ MAX_STREAMS ] ;
UINT streamFlags [ MAX_STREAMS ] ; /*0 | D3DSTREAMSOURCE_INSTANCEDATA | D3DSTREAMSOURCE_INDEXEDDATA */
2004-11-28 16:04:41 +01:00
2004-12-09 12:42:34 +01:00
/* Indices */
IWineD3DIndexBuffer * pIndexData ;
UINT baseVertexIndex ; /* Note: only used for d3d8 */
2004-11-28 16:04:41 +01:00
/* Transform */
2005-07-05 16:05:18 +02:00
D3DMATRIX transforms [ HIGHEST_TRANSFORMSTATE + 1 ] ;
2004-11-28 16:04:41 +01:00
2004-11-29 18:53:42 +01:00
/* Lights */
PLIGHTINFOEL * lights ; /* NOTE: active GL lights must be front of the chain */
2005-07-05 16:05:18 +02:00
2004-11-29 18:53:42 +01:00
/* Clipping */
double clipplane [ MAX_CLIPPLANES ] [ 4 ] ;
WINED3DCLIPSTATUS clip_status ;
2004-12-09 12:42:34 +01:00
/* ViewPort */
WINED3DVIEWPORT viewport ;
2004-11-29 18:53:42 +01:00
/* Material */
WINED3DMATERIAL material ;
2005-07-05 16:05:18 +02:00
/* Pixel Shader */
2005-09-28 12:13:00 +02:00
IWineD3DPixelShader * pixelShader ;
2005-08-25 21:24:21 +02:00
/* Pixel Shader Constants */
BOOL pixelShaderConstantB [ MAX_PSHADER_CONSTANTS ] ;
2005-09-28 12:13:00 +02:00
INT pixelShaderConstantI [ MAX_PSHADER_CONSTANTS * 4 ] ;
2005-08-25 21:24:21 +02:00
float pixelShaderConstantF [ MAX_PSHADER_CONSTANTS * 4 ] ;
2005-09-28 12:13:00 +02:00
WINESHADERCNST pixelShaderConstantT [ MAX_PSHADER_CONSTANTS ] ; /* TODO: Think about changing this to a char to possibly save a little memory */
2005-07-05 16:05:18 +02:00
2004-12-13 14:35:38 +01:00
/* Indexed Vertex Blending */
D3DVERTEXBLENDFLAGS vertex_blend ;
FLOAT tween_factor ;
/* RenderState */
2005-07-05 16:05:18 +02:00
DWORD renderState [ WINEHIGHEST_RENDER_STATE + 1 ] ;
2004-12-13 14:35:38 +01:00
2004-12-09 12:42:34 +01:00
/* Texture */
2005-07-05 16:05:18 +02:00
IWineD3DBaseTexture * textures [ MAX_TEXTURES ] ;
int textureDimensions [ MAX_SAMPLERS ] ;
2004-12-13 14:35:38 +01:00
/* Texture State Stage */
2005-07-26 20:49:30 +02:00
DWORD textureState [ MAX_TEXTURES ] [ WINED3D_HIGHEST_TEXTURE_STATE + 1 ] ;
2005-06-24 13:53:07 +02:00
/* Sampler States */
2005-07-26 20:49:30 +02:00
DWORD samplerState [ MAX_SAMPLERS ] [ WINED3D_HIGHEST_SAMPLER_STATE + 1 ] ;
2005-06-24 13:53:07 +02:00
2004-10-21 22:59:12 +02:00
} ;
2005-06-06 21:50:35 +02:00
extern const IWineD3DStateBlockVtbl IWineD3DStateBlock_Vtbl ;
2004-10-21 22:59:12 +02:00
2005-03-03 14:57:15 +01:00
/*****************************************************************************
* IWineD3DQueryImpl implementation structure ( extends IUnknown )
*/
typedef struct IWineD3DQueryImpl
{
2005-06-06 21:50:35 +02:00
const IWineD3DQueryVtbl * lpVtbl ;
2005-07-28 12:16:21 +02:00
LONG ref ; /* Note: Ref counting not required */
2005-03-03 14:57:15 +01:00
IUnknown * parent ;
/*TODO: replace with iface usage */
#if 0
IWineD3DDevice * wineD3DDevice ;
# else
IWineD3DDeviceImpl * wineD3DDevice ;
# endif
/* IWineD3DQuery fields */
D3DQUERYTYPE type ;
2005-09-21 11:43:13 +02:00
/* TODO: Think about using a IUnknown instead of a void* */
2005-03-03 14:57:15 +01:00
void * extendedData ;
} IWineD3DQueryImpl ;
2005-06-06 21:50:35 +02:00
extern const IWineD3DQueryVtbl IWineD3DQuery_Vtbl ;
2005-03-03 14:57:15 +01:00
2005-09-21 11:43:13 +02:00
/* Datastructures for IWineD3DQueryImpl.extendedData */
typedef struct WineQueryOcclusionData {
unsigned int queryId ;
} WineQueryOcclusionData ;
2005-06-23 13:05:24 +02:00
/*****************************************************************************
* IWineD3DSwapChainImpl implementation structure ( extends IUnknown )
*/
typedef struct IWineD3DSwapChainImpl
{
/*IUnknown part*/
IWineD3DSwapChainVtbl * lpVtbl ;
2005-07-28 12:16:21 +02:00
LONG ref ; /* Note: Ref counting not required */
2005-06-23 13:05:24 +02:00
IUnknown * parent ;
IWineD3DDeviceImpl * wineD3DDevice ;
/* IWineD3DSwapChain fields */
IWineD3DSurface * backBuffer ;
IWineD3DSurface * frontBuffer ;
BOOL wantsDepthStencilBuffer ;
D3DPRESENT_PARAMETERS presentParms ;
2005-11-23 20:14:43 +01:00
/* TODO: move everything up to drawable off into a context manager
2005-06-23 13:05:24 +02:00
and store the ' data ' in the contextManagerData interface .
IUnknown * contextManagerData ;
*/
HWND win_handle ;
Window win ;
Display * display ;
GLXContext glCtx ;
XVisualInfo * visInfo ;
GLXContext render_ctx ;
2005-06-30 20:19:33 +02:00
/* This has been left in device for now, but needs moving off into a rendertarget management class and separated out from swapchains and devices. */
2005-06-23 13:05:24 +02:00
Drawable drawable ;
} IWineD3DSwapChainImpl ;
extern IWineD3DSwapChainVtbl IWineD3DSwapChain_Vtbl ;
2004-10-21 22:59:12 +02:00
/*****************************************************************************
* Utility function prototypes
*/
2004-12-13 14:35:38 +01:00
/* Trace routines */
2005-07-13 21:38:39 +02:00
const char * debug_d3dformat ( WINED3DFORMAT fmt ) ;
2004-10-05 04:14:06 +02:00
const char * debug_d3ddevicetype ( D3DDEVTYPE devtype ) ;
2006-03-09 23:21:16 +01:00
const char * debug_d3dresourcetype ( WINED3DRESOURCETYPE res ) ;
2004-10-05 04:14:06 +02:00
const char * debug_d3dusage ( DWORD usage ) ;
2004-12-09 12:42:34 +01:00
const char * debug_d3dprimitivetype ( D3DPRIMITIVETYPE PrimitiveType ) ;
2004-12-13 14:35:38 +01:00
const char * debug_d3drenderstate ( DWORD state ) ;
const char * debug_d3dtexturestate ( DWORD state ) ;
2006-03-28 14:20:47 +02:00
const char * debug_d3dpool ( WINED3DPOOL pool ) ;
2004-12-13 14:35:38 +01:00
/* Routines for GL <-> D3D values */
GLenum StencilOp ( DWORD op ) ;
void set_tex_op ( IWineD3DDevice * iface , BOOL isAlpha , int Stage , D3DTEXTUREOP op , DWORD arg1 , DWORD arg2 , DWORD arg3 ) ;
2005-07-26 22:01:29 +02:00
void set_texture_matrix ( const float * smat , DWORD flags , BOOL calculatedCoords ) ;
2004-12-13 14:35:38 +01:00
void GetSrcAndOpFromValue ( DWORD iValue , BOOL isAlphaArg , GLenum * source , GLenum * operand ) ;
2004-09-28 04:12:12 +02:00
2005-01-09 18:37:02 +01:00
SHORT D3DFmtGetBpp ( IWineD3DDeviceImpl * This , D3DFORMAT fmt ) ;
GLenum D3DFmt2GLFmt ( IWineD3DDeviceImpl * This , D3DFORMAT fmt ) ;
GLenum D3DFmt2GLType ( IWineD3DDeviceImpl * This , D3DFORMAT fmt ) ;
GLint D3DFmt2GLIntFmt ( IWineD3DDeviceImpl * This , D3DFORMAT fmt ) ;
2005-07-07 22:35:05 +02:00
int D3DFmtMakeGlCfg ( D3DFORMAT BackBufferFormat , D3DFORMAT StencilBufferFormat , int * attribs , int * nAttribs , BOOL alternate ) ;
2005-01-17 14:44:57 +01:00
/*****************************************************************************
* To enable calling of inherited functions , requires prototypes
2005-01-18 12:42:29 +01:00
*
* Note : Only require classes which are subclassed , ie resource , basetexture ,
2005-01-17 14:44:57 +01:00
*/
/*** IUnknown methods ***/
extern HRESULT WINAPI IWineD3DResourceImpl_QueryInterface ( IWineD3DResource * iface , REFIID riid , void * * ppvObject ) ;
extern ULONG WINAPI IWineD3DResourceImpl_AddRef ( IWineD3DResource * iface ) ;
extern ULONG WINAPI IWineD3DResourceImpl_Release ( IWineD3DResource * iface ) ;
/*** IWineD3DResource methods ***/
extern HRESULT WINAPI IWineD3DResourceImpl_GetParent ( IWineD3DResource * iface , IUnknown * * pParent ) ;
extern HRESULT WINAPI IWineD3DResourceImpl_GetDevice ( IWineD3DResource * iface , IWineD3DDevice * * ppDevice ) ;
extern HRESULT WINAPI IWineD3DResourceImpl_SetPrivateData ( IWineD3DResource * iface , REFGUID refguid , CONST void * pData , DWORD SizeOfData , DWORD Flags ) ;
extern HRESULT WINAPI IWineD3DResourceImpl_GetPrivateData ( IWineD3DResource * iface , REFGUID refguid , void * pData , DWORD * pSizeOfData ) ;
extern HRESULT WINAPI IWineD3DResourceImpl_FreePrivateData ( IWineD3DResource * iface , REFGUID refguid ) ;
extern DWORD WINAPI IWineD3DResourceImpl_SetPriority ( IWineD3DResource * iface , DWORD PriorityNew ) ;
extern DWORD WINAPI IWineD3DResourceImpl_GetPriority ( IWineD3DResource * iface ) ;
extern void WINAPI IWineD3DResourceImpl_PreLoad ( IWineD3DResource * iface ) ;
2006-03-09 23:21:16 +01:00
extern WINED3DRESOURCETYPE WINAPI IWineD3DResourceImpl_GetType ( IWineD3DResource * iface ) ;
2005-03-29 21:01:00 +02:00
/*** class static members ***/
void IWineD3DResourceImpl_CleanUp ( IWineD3DResource * iface ) ;
2005-01-17 14:44:57 +01:00
/*** IUnknown methods ***/
extern HRESULT WINAPI IWineD3DBaseTextureImpl_QueryInterface ( IWineD3DBaseTexture * iface , REFIID riid , void * * ppvObject ) ;
extern ULONG WINAPI IWineD3DBaseTextureImpl_AddRef ( IWineD3DBaseTexture * iface ) ;
extern ULONG WINAPI IWineD3DBaseTextureImpl_Release ( IWineD3DBaseTexture * iface ) ;
/*** IWineD3DResource methods ***/
extern HRESULT WINAPI IWineD3DBaseTextureImpl_GetParent ( IWineD3DBaseTexture * iface , IUnknown * * pParent ) ;
extern HRESULT WINAPI IWineD3DBaseTextureImpl_GetDevice ( IWineD3DBaseTexture * iface , IWineD3DDevice * * ppDevice ) ;
extern HRESULT WINAPI IWineD3DBaseTextureImpl_SetPrivateData ( IWineD3DBaseTexture * iface , REFGUID refguid , CONST void * pData , DWORD SizeOfData , DWORD Flags ) ;
extern HRESULT WINAPI IWineD3DBaseTextureImpl_GetPrivateData ( IWineD3DBaseTexture * iface , REFGUID refguid , void * pData , DWORD * pSizeOfData ) ;
extern HRESULT WINAPI IWineD3DBaseTextureImpl_FreePrivateData ( IWineD3DBaseTexture * iface , REFGUID refguid ) ;
extern DWORD WINAPI IWineD3DBaseTextureImpl_SetPriority ( IWineD3DBaseTexture * iface , DWORD PriorityNew ) ;
extern DWORD WINAPI IWineD3DBaseTextureImpl_GetPriority ( IWineD3DBaseTexture * iface ) ;
extern void WINAPI IWineD3DBaseTextureImpl_PreLoad ( IWineD3DBaseTexture * iface ) ;
2006-03-09 23:21:16 +01:00
extern WINED3DRESOURCETYPE WINAPI IWineD3DBaseTextureImpl_GetType ( IWineD3DBaseTexture * iface ) ;
2005-01-17 14:44:57 +01:00
/*** IWineD3DBaseTexture methods ***/
extern DWORD WINAPI IWineD3DBaseTextureImpl_SetLOD ( IWineD3DBaseTexture * iface , DWORD LODNew ) ;
extern DWORD WINAPI IWineD3DBaseTextureImpl_GetLOD ( IWineD3DBaseTexture * iface ) ;
extern DWORD WINAPI IWineD3DBaseTextureImpl_GetLevelCount ( IWineD3DBaseTexture * iface ) ;
2006-04-06 19:02:16 +02:00
extern HRESULT WINAPI IWineD3DBaseTextureImpl_SetAutoGenFilterType ( IWineD3DBaseTexture * iface , WINED3DTEXTUREFILTERTYPE FilterType ) ;
extern WINED3DTEXTUREFILTERTYPE WINAPI IWineD3DBaseTextureImpl_GetAutoGenFilterType ( IWineD3DBaseTexture * iface ) ;
2005-01-17 14:44:57 +01:00
extern void WINAPI IWineD3DBaseTextureImpl_GenerateMipSubLevels ( IWineD3DBaseTexture * iface ) ;
extern BOOL WINAPI IWineD3DBaseTextureImpl_SetDirty ( IWineD3DBaseTexture * iface , BOOL ) ;
extern BOOL WINAPI IWineD3DBaseTextureImpl_GetDirty ( IWineD3DBaseTexture * iface ) ;
2005-07-24 19:11:33 +02:00
extern BYTE * WINAPI IWineD3DVertexBufferImpl_GetMemory ( IWineD3DVertexBuffer * iface , DWORD iOffset ) ;
extern HRESULT WINAPI IWineD3DVertexBufferImpl_ReleaseMemory ( IWineD3DVertexBuffer * iface ) ;
2005-03-29 21:01:00 +02:00
extern HRESULT WINAPI IWineD3DBaseTextureImpl_BindTexture ( IWineD3DBaseTexture * iface ) ;
extern HRESULT WINAPI IWineD3DBaseTextureImpl_UnBindTexture ( IWineD3DBaseTexture * iface ) ;
2005-08-03 13:00:28 +02:00
extern void WINAPI IWineD3DBaseTextureImpl_ApplyStateChanges ( IWineD3DBaseTexture * iface , const DWORD textureStates [ WINED3D_HIGHEST_TEXTURE_STATE + 1 ] , const DWORD samplerStates [ WINED3D_HIGHEST_SAMPLER_STATE + 1 ] ) ;
2005-03-29 21:01:00 +02:00
/*** class static members ***/
void IWineD3DBaseTextureImpl_CleanUp ( IWineD3DBaseTexture * iface ) ;
2005-01-09 18:37:02 +01:00
2005-09-26 12:58:41 +02:00
/* An enum for the type of constants that are used... addressing causes
* problems with being able to work out what ' s used and what ' s not . . so
* maybe we ' ll have to rely on the server vertex shader const functions ?
*/
2005-08-17 13:34:03 +02:00
enum vsConstantsEnum {
VS_CONSTANT_NOT_USED = 0 ,
VS_CONSTANT_CONSTANT ,
VS_CONSTANT_INTEGER ,
VS_CONSTANT_BOOLEAN ,
VS_CONSTANT_FLOAT
} ;
2006-05-10 00:05:26 +02:00
struct SHADER_OPCODE_ARG ;
2006-03-28 21:10:32 +02:00
typedef void ( * shader_fct_t ) ( ) ;
2006-05-10 00:05:26 +02:00
typedef void ( * SHADER_HANDLER ) ( struct SHADER_OPCODE_ARG * ) ;
2006-05-10 04:47:35 +02:00
/* This must be 0 in the main branch until GLSL is at least mostly implemented.
Also , think about making it a winecfg option to use GLSL ( if the card supports it )
or ARB_vertex_program . Ideally , we want to use GLSL if it ' s available , but until
everything is implemented , we ' ll probably have better luck with the ARB generation */
# define USING_GLSL 0
2006-05-10 00:05:26 +02:00
# define SHADER_PGMSIZE 65535
typedef struct SHADER_BUFFER {
char * buffer ;
size_t bsize ;
unsigned int lineNo ;
} SHADER_BUFFER ;
2006-03-28 21:10:32 +02:00
typedef struct SHADER_OPCODE {
unsigned int opcode ;
const char * name ;
const char * glname ;
CONST UINT num_params ;
shader_fct_t soft_fct ;
2006-05-10 00:05:26 +02:00
SHADER_HANDLER hw_fct ;
2006-05-10 04:43:34 +02:00
SHADER_HANDLER hw_glsl_fct ;
2006-03-28 21:10:32 +02:00
DWORD min_version ;
DWORD max_version ;
} SHADER_OPCODE ;
2006-05-10 00:05:26 +02:00
typedef struct SHADER_OPCODE_ARG {
IWineD3DBaseShader * shader ;
CONST SHADER_OPCODE * opcode ;
DWORD dst ;
DWORD src [ 4 ] ;
SHADER_BUFFER * buffer ;
} SHADER_OPCODE_ARG ;
2006-05-08 21:44:25 +02:00
2006-05-08 23:09:21 +02:00
typedef struct SHADER_LIMITS {
unsigned int temporary ;
unsigned int texture ;
unsigned int constant_int ;
unsigned int constant_float ;
unsigned int constant_bool ;
unsigned int address ;
} SHADER_LIMITS ;
2006-05-10 04:30:11 +02:00
/** Keeps track of details for TEX_M#x# shader opcodes which need to
maintain state information between multiple codes */
typedef struct SHADER_PARSE_STATE {
unsigned int current_row ;
DWORD texcoord_w [ 2 ] ;
} SHADER_PARSE_STATE ;
2006-05-08 21:44:25 +02:00
/* Base Shader utility functions.
* ( may move callers into the same file in the future ) */
extern int shader_addline (
SHADER_BUFFER * buffer ,
const char * fmt , . . . ) ;
2006-05-09 13:57:36 +02:00
extern const SHADER_OPCODE * shader_get_opcode (
IWineD3DBaseShader * iface ,
const DWORD code ) ;
2006-03-30 19:14:31 +02:00
/*****************************************************************************
* IDirect3DBaseShader implementation structure
*/
typedef struct IWineD3DBaseShaderClass
{
DWORD version ;
2006-05-08 23:09:21 +02:00
DWORD hex_version ;
2006-05-10 04:31:09 +02:00
DWORD temps_used ;
DWORD textures_used ;
2006-05-08 23:09:21 +02:00
SHADER_LIMITS limits ;
2006-05-10 04:30:11 +02:00
SHADER_PARSE_STATE parse_state ;
2006-03-30 19:14:31 +02:00
CONST SHADER_OPCODE * shader_ins ;
CONST DWORD * function ;
UINT functionLength ;
GLuint prgId ;
} IWineD3DBaseShaderClass ;
typedef struct IWineD3DBaseShaderImpl {
/* IUnknown */
const IWineD3DBaseShaderVtbl * lpVtbl ;
LONG ref ;
/* IWineD3DBaseShader */
IWineD3DBaseShaderClass baseShader ;
} IWineD3DBaseShaderImpl ;
2006-05-10 00:03:09 +02:00
extern void shader_get_registers_used (
IWineD3DBaseShader * iface ,
2006-05-10 04:31:09 +02:00
CONST DWORD * pToken ) ;
2006-05-10 00:03:09 +02:00
2006-05-10 04:26:05 +02:00
extern void shader_program_dump_decl_usage (
DWORD dcl ,
DWORD param ) ;
2006-05-10 04:33:24 +02:00
extern void generate_base_shader (
IWineD3DBaseShader * iface ,
SHADER_BUFFER * buffer ,
CONST DWORD * pFunction ) ;
2006-05-10 19:53:07 +02:00
extern void shader_dump_ins_modifiers (
const DWORD output ) ;
2006-04-28 11:20:48 +02:00
inline static int shader_get_regtype ( const DWORD param ) {
return ( ( ( param & D3DSP_REGTYPE_MASK ) > > D3DSP_REGTYPE_SHIFT ) |
( ( param & D3DSP_REGTYPE_MASK2 ) > > D3DSP_REGTYPE_SHIFT2 ) ) ;
}
2003-11-14 04:50:35 +01:00
/*****************************************************************************
* IDirect3DVertexShader implementation structure
*/
2005-03-02 13:16:10 +01:00
typedef struct IWineD3DVertexShaderImpl {
/* IUnknown parts*/
2005-06-06 21:50:35 +02:00
const IWineD3DVertexShaderVtbl * lpVtbl ;
2005-07-28 12:16:21 +02:00
LONG ref ; /* Note: Ref counting not required */
2005-03-02 13:16:10 +01:00
2006-03-30 19:14:31 +02:00
/* IWineD3DBaseShader */
IWineD3DBaseShaderClass baseShader ;
2005-03-02 13:16:10 +01:00
2005-08-17 13:34:03 +02:00
/* IWineD3DVertexShaderImpl */
2006-03-30 19:14:31 +02:00
IUnknown * parent ;
IWineD3DDeviceImpl * wineD3DDevice ;
2005-03-02 13:16:10 +01:00
2005-08-17 11:54:54 +02:00
DWORD usage ;
2005-08-17 13:34:03 +02:00
/* vertex declaration array mapping */
BOOL namedArrays ; /* don't map use named functions */
BOOL declaredArrays ; /* mapping requires */
INT arrayUsageMap [ WINED3DSHADERDECLUSAGE_MAX_USAGE ] ; /* lookup table for the maps */
INT highestConstant ;
CHAR constantsUsedBitmap [ 256 ] ;
/* FIXME: This needs to be populated with some flags of VS_CONSTANT_NOT_USED, VS_CONSTANT_CONSTANT, VS_CONSTANT_INTEGER, VS_CONSTANT_BOOLEAN, VS_CONSTANT_FLOAT, a half byte bitmap will be the best option, but I'll keep it as chards for siplicity */
2005-08-17 11:54:54 +02:00
/* run time datas... */
2005-12-09 11:23:52 +01:00
VSHADERDATA * data ;
IWineD3DVertexDeclaration * vertexDeclaration ;
2005-03-02 13:16:10 +01:00
#if 0 /* needs reworking */
/* run time datas */
VSHADERINPUTDATA input ;
VSHADEROUTPUTDATA output ;
# endif
} IWineD3DVertexShaderImpl ;
2006-03-28 21:10:44 +02:00
extern const SHADER_OPCODE IWineD3DVertexShaderImpl_shader_ins [ ] ;
2005-06-06 21:50:35 +02:00
extern const IWineD3DVertexShaderVtbl IWineD3DVertexShader_Vtbl ;
2003-11-14 04:50:35 +01:00
/*****************************************************************************
* IDirect3DPixelShader implementation structure
*/
2005-03-02 13:16:10 +01:00
typedef struct IWineD3DPixelShaderImpl {
2005-09-28 12:13:00 +02:00
/* IUnknown parts */
2005-06-06 21:50:35 +02:00
const IWineD3DPixelShaderVtbl * lpVtbl ;
2005-07-28 12:16:21 +02:00
LONG ref ; /* Note: Ref counting not required */
2005-09-28 12:13:00 +02:00
2006-03-30 19:14:31 +02:00
/* IWineD3DBaseShader */
IWineD3DBaseShaderClass baseShader ;
/* IWineD3DPixelShaderImpl */
2005-03-02 13:16:10 +01:00
IUnknown * parent ;
IWineD3DDeviceImpl * wineD3DDevice ;
2005-11-21 17:27:55 +01:00
CHAR constants [ WINED3D_PSHADER_MAX_CONSTANTS ] ;
2005-09-28 12:13:00 +02:00
/* run time data */
PSHADERDATA * data ;
2005-03-02 13:16:10 +01:00
#if 0 /* needs reworking */
PSHADERINPUTDATA input ;
PSHADEROUTPUTDATA output ;
# endif
} IWineD3DPixelShaderImpl ;
2003-11-14 04:50:35 +01:00
2006-03-28 21:10:44 +02:00
extern const SHADER_OPCODE IWineD3DPixelShaderImpl_shader_ins [ ] ;
2005-06-06 21:50:35 +02:00
extern const IWineD3DPixelShaderVtbl IWineD3DPixelShader_Vtbl ;
2006-04-17 17:04:59 +02:00
/*****************************************************************************
* IWineD3DPalette implementation structure
*/
struct IWineD3DPaletteImpl {
/* IUnknown parts */
const IWineD3DPaletteVtbl * lpVtbl ;
LONG ref ;
2006-04-21 00:00:30 +02:00
IUnknown * parent ;
IWineD3DDeviceImpl * wineD3DDevice ;
/* IWineD3DPalette */
HPALETTE hpal ;
WORD palVersion ; /*| */
WORD palNumEntries ; /*| LOGPALETTE */
PALETTEENTRY palents [ 256 ] ; /*| */
/* This is to store the palette in 'screen format' */
int screen_palents [ 256 ] ;
DWORD Flags ;
2006-04-17 17:04:59 +02:00
} ;
extern const IWineD3DPaletteVtbl IWineD3DPalette_Vtbl ;
2006-04-21 00:00:30 +02:00
DWORD IWineD3DPaletteImpl_Size ( DWORD dwFlags ) ;
2006-04-17 17:04:59 +02:00
2006-04-18 23:04:51 +02:00
/* DirectDraw utility functions */
extern WINED3DFORMAT pixelformat_for_depth ( DWORD depth ) ;
2006-05-06 18:08:33 +02:00
LONG get_bitmask_red ( WINED3DFORMAT fmt ) ;
LONG get_bitmask_green ( WINED3DFORMAT fmt ) ;
LONG get_bitmask_blue ( WINED3DFORMAT fmt ) ;
LONG get_bitmask_alpha ( WINED3DFORMAT fmt ) ;
2006-04-18 23:04:51 +02:00
2003-11-14 04:50:35 +01:00
# endif