wined3d_private.h 46.8 KB
Newer Older
1 2 3 4 5
/*
 * Direct3D wine internal private include file
 *
 * Copyright 2002-2003 The wine-d3d team
 * Copyright 2002-2003 Raphael Junqueira
Oliver Stieber's avatar
Oliver Stieber committed
6 7
 * Copyright 2004 Jason Edmeades
 * Copyright 2005 Oliver Stieber
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
 *
 * 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>
28
#include <math.h>
29 30
#define NONAMELESSUNION
#define NONAMELESSSTRUCT
31
#define COBJMACROS
32 33
#include "windef.h"
#include "winbase.h"
34
#include "winreg.h"
35 36 37
#include "wingdi.h"
#include "winuser.h"
#include "wine/debug.h"
38
#include "wine/unicode.h"
39

40 41
#include "d3d9.h"
#include "d3d9types.h"
42
#include "wine/wined3d_interface.h"
43
#include "wine/wined3d_gl.h"
44

45
/* Device caps */
46 47 48
#define MAX_PALETTES      256
#define MAX_STREAMS       16
#define MAX_TEXTURES      8
49
#define MAX_SAMPLERS      16
50 51 52
#define MAX_ACTIVE_LIGHTS 8
#define MAX_CLIPPLANES    D3DMAXUSERCLIPPLANES
#define MAX_LEVELS        256
53

54
#define MAX_VSHADER_CONSTANTS 96
55
#define MAX_PSHADER_CONSTANTS 32
56

57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
/* 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];

72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
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];

/* NOTE: Make sure these are in the correct numerical order. (see /include/d3d9types.h typedef enum _D3DDECLTYPE) */
UINT static const glTypeLookup[D3DDECLTYPE_UNUSED][5] = {
                                  {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)}};

#define WINED3D_ATR_TYPE(_attribute)          glTypeLookup[sd->u.s._attribute.dwType][0]
#define WINED3D_ATR_SIZE(_attribute)          glTypeLookup[sd->u.s._attribute.dwType][1]
#define WINED3D_ATR_GLTYPE(_attribute)        glTypeLookup[sd->u.s._attribute.dwType][2]
107
#define WINED3D_ATR_NORMALIZED(_attribute)    glTypeLookup[sd->u.s._attribute.dwType][3]
108 109
#define WINED3D_ATR_TYPESIZE(_attribute)      glTypeLookup[sd->u.s._attribute.dwType][4]

110 111 112
/**
 * Settings 
 */
113 114 115
#define VS_NONE    0
#define VS_HW      1
#define VS_SW      2
116

117 118
#define PS_NONE    0
#define PS_HW      1
119

120 121 122 123 124
#define VBO_NONE   0
#define VBO_HW     1

#define NP2_NONE   0
#define NP2_REPACK 1
125 126 127 128 129 130

typedef struct wined3d_settings_s {
/* vertex and pixel shader modes */
  int vs_mode;
  int ps_mode;
  int vbo_mode;
131 132
/* nonpower 2 function */
  int nonpower2_mode;
133 134 135 136
} wined3d_settings_t;

extern wined3d_settings_t wined3d_settings;

137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
/* 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
 */
156 157 158

/* GL related defines */
/* ------------------ */
159 160
#define GL_SUPPORT(ExtName)           (GLINFO_LOCATION.supported[ExtName] != 0)
#define GL_LIMITS(ExtName)            (GLINFO_LOCATION.max_##ExtName)
161
#define GL_EXTCALL(FuncName)          (GLINFO_LOCATION.FuncName)
162
#define GL_VEND(_VendName)            (GLINFO_LOCATION.gl_vendor == VENDOR_##_VendName ? TRUE : FALSE)
163

164 165 166 167 168
#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)

169 170 171 172 173 174 175 176 177 178 179 180 181
#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)
182 183
#define GLACTIVETEXTURE(textureNo)                          \
            glActiveTexture(GL_TEXTURE0 + textureNo);       \
184
            checkGLcall("glActiveTexture");      
185 186
#define GLCLIENTACTIVETEXTURE(textureNo)                    \
            glClientActiveTexture(GL_TEXTURE0 + textureNo);
187 188 189 190 191 192 193 194
#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);
195
#define GLTEXTURECUBEMAP GL_TEXTURE_CUBE_MAP
196
#else 
197 198
#define GLACTIVETEXTURE(textureNo)                             \
            glActiveTextureARB(GL_TEXTURE0_ARB + textureNo);   \
199
            checkGLcall("glActiveTextureARB");
200 201
#define GLCLIENTACTIVETEXTURE(textureNo)                    \
            glClientActiveTextureARB(GL_TEXTURE0_ARB + textureNo);
202
#define GLMULTITEXCOORD1F(a,b)                                 \
203
            glMultiTexCoord1fARB(GL_TEXTURE0_ARB + a, b);
204
#define GLMULTITEXCOORD2F(a,b,c)                               \
205
            glMultiTexCoord2fARB(GL_TEXTURE0_ARB + a, b, c);
206
#define GLMULTITEXCOORD3F(a,b,c,d)                             \
207
            glMultiTexCoord3fARB(GL_TEXTURE0_ARB + a, b, c, d);
208
#define GLMULTITEXCOORD4F(a,b,c,d,e)                           \
209
            glMultiTexCoord4fARB(GL_TEXTURE0_ARB + a, b, c, d, e);
210
#define GLTEXTURECUBEMAP GL_TEXTURE_CUBE_MAP_ARB
211 212 213 214
#endif

/* DirectX Device Limits */
/* --------------------- */
215 216
#define MAX_LEVELS  256  /* Maximum number of mipmap levels. Guessed at 256 */

217 218
#define MAX_STREAMS  16  /* Maximum possible streams - used for fixed size arrays
                            See MaxStreams in MSDN under GetDeviceCaps */
219
                         /* Maximum number of constants provided to the shaders */
220 221
#define HIGHEST_TRANSFORMSTATE 512 
                         /* Highest value in D3DTRANSFORMSTATETYPE */
222
#define MAX_CLIPPLANES  D3DMAXUSERCLIPPLANES
223

224 225
#define MAX_PALETTES      256

226 227
/* Checking of API calls */
/* --------------------- */
228 229 230 231 232 233 234 235 236 237
#define checkGLcall(A) \
{ \
    GLint err = glGetError();   \
    if (err != GL_NO_ERROR) { \
       FIXME(">>>>>>>>>>>>>>>>> %x from %s @ %s / %d\n", err, A, __FILE__, __LINE__); \
    } else { \
       TRACE("%s call ok %s / %d\n", A, __FILE__, __LINE__); \
    } \
}

238 239 240 241
/* Trace routines / diagnostics */
/* ---------------------------- */

/* Dump out a matrix and copy it */
242 243 244 245 246 247 248 249 250
#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)

251 252 253 254 255 256 257 258 259 260
/* 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;                            \
  }                                           \
}

261
/* Trace vector and strided data information */
262 263 264
#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);

265 266 267 268 269 270 271
/* Defines used for optimizations */

/*    Only reapply what is necessary */
#define REAPPLY_ALPHAOP  0x0001
#define REAPPLY_ALL      0xFFFF

/* Advance declaration of structures to satisfy compiler */
272
typedef struct IWineD3DStateBlockImpl IWineD3DStateBlockImpl;
273
typedef struct IWineD3DSurfaceImpl    IWineD3DSurfaceImpl;
274

275 276 277 278 279 280 281 282
/* 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
283 284
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
285 286 287 288 289 290 291
*/
typedef struct WineD3DGlobalStatistics {
    int glsurfaceram; /* The aproximate amount of glTexture memory allocated for textures */
} WineD3DGlobalStatistics;

extern WineD3DGlobalStatistics* wineD3DGlobalStatistics;

292
/* Global variables */
293 294
extern const float identity[16];

295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
/*****************************************************************************
 * 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 */
#define vcheckGLcall(A) \
{ \
    GLint err = glGetError();   \
    if (err != GL_NO_ERROR) { \
       FIXME(">>>>>>>>>>>>>>>>> %x from %s @ %s / %d\n", err, A, __FILE__, __LINE__); \
    } else { \
       VTRACE(("%s call ok %s / %d\n", A, __FILE__, __LINE__)); \
    } \
}

317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
/* 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

347 348 349 350 351 352 353 354 355 356
/*****************************************************************************
 * Prototypes
 */

/* Routine common to the draw primitive and draw indexed primitive routines */
void drawPrimitive(IWineD3DDevice *iface,
                    int PrimitiveType,
                    long NumPrimitives,
                    /* for Indexed: */
                    long  StartVertexIndex,
357
                    UINT  numberOfVertices,
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
                    long  StartIdx,
                    short idxBytes,
                    const void *idxData,
                    int   minIndex);

/*****************************************************************************
 * Structures required to draw primitives 
 */

typedef struct Direct3DStridedData {
    BYTE     *lpData;        /* Pointer to start of data               */
    DWORD     dwStride;      /* Stride between occurances of this data */
    DWORD     dwType;        /* Type (as in D3DVSDT_TYPE)              */
} Direct3DStridedData;

typedef struct Direct3DVertexStridedData {
    union {
        struct {
             Direct3DStridedData  position;
             Direct3DStridedData  blendWeights;
             Direct3DStridedData  blendMatrixIndices;
             Direct3DStridedData  normal;
             Direct3DStridedData  pSize;
             Direct3DStridedData  diffuse;
             Direct3DStridedData  specular;
383
             Direct3DStridedData  texCoords[MAX_TEXTURES];
384 385 386 387 388 389 390 391
             Direct3DStridedData  position2; /* tween data */
             Direct3DStridedData  normal2;   /* tween data */
             Direct3DStridedData  tangent;
             Direct3DStridedData  binormal;
             Direct3DStridedData  tessFactor;
             Direct3DStridedData  fog;
             Direct3DStridedData  depth;
             Direct3DStridedData  sample;
392 393 394 395 396
        } s;
        Direct3DStridedData input[16];  /* Indexed by constants in D3DVSDE_REGISTER */
    } u;
} Direct3DVertexStridedData;

397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418
/*****************************************************************************
 * 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;
};

419 420 421 422 423 424
/*****************************************************************************
 * IWineD3D implementation structure
 */
typedef struct IWineD3DImpl
{
    /* IUnknown fields */
425
    const IWineD3DVtbl     *lpVtbl;
426
    LONG                    ref;     /* Note: Ref counting not required */
427 428

    /* WineD3D Information */
429
    IUnknown               *parent;
430
    UINT                    dxVersion;
431 432 433 434

    /* GL Information */
    BOOL                    isGLInfoValid;
    WineD3D_GL_Info         gl_info;
435 436
} IWineD3DImpl;

437
extern const IWineD3DVtbl IWineD3D_Vtbl;
438

439 440 441 442
typedef struct SwapChainList {
    IWineD3DSwapChain         *swapchain;
    struct SwapChainList      *next;
} SwapChainList;
443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470

/** 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

471 472 473 474
typedef struct ResourceList {
    IWineD3DResource         *resource;
    struct ResourceList      *next;
} ResourceList;
475

476 477 478 479 480
/*****************************************************************************
 * IWineD3DDevice implementation structure
 */
typedef struct IWineD3DDeviceImpl
{
481
    /* IUnknown fields      */
482
    const IWineD3DDeviceVtbl *lpVtbl;
483
    LONG                    ref;     /* Note: Ref counting not required */
484

485
    /* WineD3D Information  */
486
    IUnknown               *parent;
487
    IWineD3D               *wineD3D;
488

489 490 491 492 493 494 495 496
    /* 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 */
497 498
    GLenum                  tracking_parm;     /* Which source is tracking current colour         */
    LONG                    tracking_color;    /* used iff GL_COLOR_MATERIAL was enabled          */
499 500 501 502
#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*/
503 504 505 506 507
    UINT                    srcBlend;
    UINT                    dstBlend;
    UINT                    alphafunc;
    UINT                    stencilfunc;
    BOOL                    texture_shader_active;  /* TODO: Confirm use is correct */
508

509 510 511 512 513
    /* State block related */
    BOOL                    isRecordingState;
    IWineD3DStateBlockImpl *stateBlock;
    IWineD3DStateBlockImpl *updateStateBlock;

514 515 516 517 518
    /* Internal use fields  */
    D3DDEVICE_CREATION_PARAMETERS   createParms;
    UINT                            adapterNo;
    D3DDEVTYPE                      devType;

519
    SwapChainList          *swapchains;
Oliver Stieber's avatar
Oliver Stieber committed
520

521 522
    ResourceList           *resources; /* a linked list to track resources created by the device */

523
    /* Render Target Support */
524
    IWineD3DSurface        *depthStencilBuffer;
525

526 527
    IWineD3DSurface        *renderTarget;
    IWineD3DSurface        *stencilBufferTarget;
528 529

    /* palettes texture management */
530 531
    PALETTEENTRY            palettes[MAX_PALETTES][256];
    UINT                    currentPalette;
532

533
    /* For rendering to a texture using glCopyTexImage */
534
    BOOL                    renderUpsideDown;
535

536 537 538 539 540 541 542
    /* Cursor management */
    BOOL                    bCursorVisible;
    UINT                    xHotSpot;
    UINT                    yHotSpot;
    UINT                    xScreenSpace;
    UINT                    yScreenSpace;

543
    /* Textures for when no other textures are mapped */
544
    UINT                          dummyTextureName[MAX_TEXTURES];
545

546 547 548
    /* Debug stream management */
    BOOL                     debug;

549 550 551
    /* Device state management */
    HRESULT                 state;

552 553 554 555 556
    /* Screen buffer resources */
    glContext contextCache[CONTEXT_CACHE];

    /* A flag to check if endscene has been called before changing the render tartet */
    BOOL sceneEnded;
557 558 559 560

    /* process vertex shaders using software or hardware */
    BOOL softwareVertexProcessing;
    
561 562
} IWineD3DDeviceImpl;

563
extern const IWineD3DDeviceVtbl IWineD3DDevice_Vtbl;
564

565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583
/* 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;

584 585 586 587 588 589
/*****************************************************************************
 * IWineD3DResource implementation structure
 */
typedef struct IWineD3DResourceClass
{
    /* IUnknown fields */
590
    LONG                    ref;     /* Note: Ref counting not required */
591 592

    /* WineD3DResource Information */
593
    IUnknown               *parent;
594
    D3DRESOURCETYPE         resourceType;
595
    IWineD3DDeviceImpl     *wineD3DDevice;
596 597 598 599 600
    D3DPOOL                 pool;
    UINT                    size;
    DWORD                   usage;
    WINED3DFORMAT           format;
    BYTE                   *allocatedMemory;
601
    PrivateData            *privateData;
602 603 604 605 606 607

} IWineD3DResourceClass;

typedef struct IWineD3DResourceImpl
{
    /* IUnknown & WineD3DResource Information     */
608
    const IWineD3DResourceVtbl *lpVtbl;
609 610 611 612 613 614 615 616 617 618
    IWineD3DResourceClass   resource;
} IWineD3DResourceImpl;


/*****************************************************************************
 * IWineD3DVertexBuffer implementation structure (extends IWineD3DResourceImpl)
 */
typedef struct IWineD3DVertexBufferImpl
{
    /* IUnknown & WineD3DResource Information     */
619
    const IWineD3DVertexBufferVtbl *lpVtbl;
620 621 622
    IWineD3DResourceClass     resource;

    /* WineD3DVertexBuffer specifics */
623
    DWORD                     fvf;
624 625 626

} IWineD3DVertexBufferImpl;

627
extern const IWineD3DVertexBufferVtbl IWineD3DVertexBuffer_Vtbl;
628

629

630 631 632 633 634 635
/*****************************************************************************
 * IWineD3DIndexBuffer implementation structure (extends IWineD3DResourceImpl)
 */
typedef struct IWineD3DIndexBufferImpl
{
    /* IUnknown & WineD3DResource Information     */
636
    const IWineD3DIndexBufferVtbl *lpVtbl;
637 638 639 640 641
    IWineD3DResourceClass     resource;

    /* WineD3DVertexBuffer specifics */
} IWineD3DIndexBufferImpl;

642
extern const IWineD3DIndexBufferVtbl IWineD3DIndexBuffer_Vtbl;
643

644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671
/*****************************************************************************
 * 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;

672 673 674 675 676 677
/*****************************************************************************
 * IWineD3DBaseTexture implementation structure (extends IWineD3DResourceImpl)
 */
typedef struct IWineD3DBaseTextureClass
{
    UINT                    levels;
678
    BOOL                    dirty;
679
    D3DFORMAT               format;
680
    DWORD                   usage;
681
    UINT                    textureName;
682 683
    UINT                    LOD;
    D3DTEXTUREFILTERTYPE    filterType;
684
    DWORD                   states[MAX_WINETEXTURESTATES];
685 686 687 688 689 690

} IWineD3DBaseTextureClass;

typedef struct IWineD3DBaseTextureImpl
{
    /* IUnknown & WineD3DResource Information     */
691
    const IWineD3DBaseTextureVtbl *lpVtbl;
692 693 694 695 696
    IWineD3DResourceClass     resource;
    IWineD3DBaseTextureClass  baseTexture;

} IWineD3DBaseTextureImpl;

697 698 699 700 701 702
/*****************************************************************************
 * IWineD3DTexture implementation structure (extends IWineD3DBaseTextureImpl)
 */
typedef struct IWineD3DTextureImpl
{
    /* IUnknown & WineD3DResource/WineD3DBaseTexture Information     */
703
    const IWineD3DTextureVtbl *lpVtbl;
704 705 706 707
    IWineD3DResourceClass     resource;
    IWineD3DBaseTextureClass  baseTexture;

    /* IWineD3DTexture */
708
    IWineD3DSurface          *surfaces[MAX_LEVELS];
709 710 711
    
    UINT                      width;
    UINT                      height;
712 713
    float                     pow2scalingFactorX;
    float                     pow2scalingFactorY;
714 715 716

} IWineD3DTextureImpl;

717
extern const IWineD3DTextureVtbl IWineD3DTexture_Vtbl;
718 719 720 721 722 723 724

/*****************************************************************************
 * IWineD3DCubeTexture implementation structure (extends IWineD3DBaseTextureImpl)
 */
typedef struct IWineD3DCubeTextureImpl
{
    /* IUnknown & WineD3DResource/WineD3DBaseTexture Information     */
725
    const IWineD3DCubeTextureVtbl *lpVtbl;
726 727 728 729
    IWineD3DResourceClass     resource;
    IWineD3DBaseTextureClass  baseTexture;

    /* IWineD3DCubeTexture */
730
    IWineD3DSurface          *surfaces[6][MAX_LEVELS];
731 732

    UINT                      edgeLength;
733
    float                     pow2scalingFactor;
734

735 736
} IWineD3DCubeTextureImpl;

737
extern const IWineD3DCubeTextureVtbl IWineD3DCubeTexture_Vtbl;
738 739 740 741 742 743

/*****************************************************************************
 * IWineD3DVolume implementation structure (extends IUnknown)
 */
typedef struct IWineD3DVolumeImpl
{
744
    /* IUnknown & WineD3DResource fields */
745
    const IWineD3DVolumeVtbl  *lpVtbl;
746
    IWineD3DResourceClass      resource;
747 748 749

    /* WineD3DVolume Information */
    D3DVOLUME_DESC          currentDesc;
H. Verbeet's avatar
H. Verbeet committed
750
    IWineD3DBase            *container;
751 752 753 754 755 756 757 758 759 760 761
    UINT                    bytesPerPixel;

    BOOL                    lockable;
    BOOL                    locked;
    D3DBOX                  lockedBox;
    D3DBOX                  dirtyBox;
    BOOL                    dirty;


} IWineD3DVolumeImpl;

762
extern const IWineD3DVolumeVtbl IWineD3DVolume_Vtbl;
763 764 765 766 767 768 769

/*****************************************************************************
 * IWineD3DVolumeTexture implementation structure (extends IWineD3DBaseTextureImpl)
 */
typedef struct IWineD3DVolumeTextureImpl
{
    /* IUnknown & WineD3DResource/WineD3DBaseTexture Information     */
770
    const IWineD3DVolumeTextureVtbl *lpVtbl;
771 772 773 774
    IWineD3DResourceClass     resource;
    IWineD3DBaseTextureClass  baseTexture;

    /* IWineD3DVolumeTexture */
775
    IWineD3DVolume           *volumes[MAX_LEVELS];
776 777 778 779 780 781

    UINT                      width;
    UINT                      height;
    UINT                      depth;
} IWineD3DVolumeTextureImpl;

782
extern const IWineD3DVolumeTextureVtbl IWineD3DVolumeTexture_Vtbl;
783

784 785 786 787 788 789 790 791
typedef struct _WINED3DSURFACET_DESC
{
    D3DMULTISAMPLE_TYPE MultiSampleType;
    DWORD               MultiSampleQuality;
    UINT                Width;
    UINT                Height;
} WINED3DSURFACET_DESC;

792 793 794 795 796 797
/*****************************************************************************
 * IWineD3DSurface implementation structure
 */
struct IWineD3DSurfaceImpl
{
    /* IUnknown & IWineD3DResource Information     */
798
    const IWineD3DSurfaceVtbl *lpVtbl;
799 800 801
    IWineD3DResourceClass     resource;

    /* IWineD3DSurface fields */
H. Verbeet's avatar
H. Verbeet committed
802
    IWineD3DBase              *container;
803
    WINED3DSURFACET_DESC      currentDesc;
804 805 806

    UINT                      textureName;
    UINT                      bytesPerPixel;
807 808 809 810 811 812 813 814

    /* TODO: move this off into a management class(maybe!) */
    BOOL                      nonpow2;

    UINT                      pow2Width;
    UINT                      pow2Height;
    UINT                      pow2Size;

815
#if 0
816 817 818
    /* precalculated x and y scalings for texture coords */
    float                     pow2scalingFactorX; /* =  (Width  / pow2Width ) */
    float                     pow2scalingFactorY; /* =  (Height / pow2Height) */
819
#endif
820

821
    BOOL                      lockable;
822
    BOOL                      discard;
823
    BOOL                      locked;
824
    BOOL                      activeLock;
825
    
826 827 828
    RECT                      lockedRect;
    RECT                      dirtyRect;
    BOOL                      Dirty;
829
    
830 831
    BOOL                      inTexture;
    BOOL                      inPBuffer;
832 833

    glDescriptor              glDescription;
834 835
};

836
extern const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl;
837

838 839 840 841 842
/*****************************************************************************
 * IWineD3DVertexDeclaration implementation structure
 */
typedef struct IWineD3DVertexDeclarationImpl {
 /* IUnknown  Information     */
843
  const IWineD3DVertexDeclarationVtbl *lpVtbl;
844
  LONG                    ref;     /* Note: Ref counting not required */
845

846
  IUnknown               *parent;
847 848 849 850 851 852 853 854 855 856
  /** precomputed fvf if simple declaration */
  IWineD3DDeviceImpl     *wineD3DDevice;
  DWORD   fvf[MAX_STREAMS];
  DWORD   allFVF;

  /** dx8 compatible Declaration fields */
  DWORD*  pDeclaration8;
  DWORD   declaration8Length;

  /** dx9+ */
857
  D3DVERTEXELEMENT9 *pDeclaration9;
858
  UINT               declaration9NumElements;
859 860 861 862 863 864

  WINED3DVERTEXELEMENT  *pDeclarationWine;
  UINT                   declarationWNumElements;
  
  float                 *constants;
  
865 866
} IWineD3DVertexDeclarationImpl;

867
extern const IWineD3DVertexDeclarationVtbl IWineD3DVertexDeclaration_Vtbl;
868

869 870 871 872 873 874 875 876
/*****************************************************************************
 * 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 {
877
        BOOL                      indices;
878
        BOOL                      material;
879
        BOOL                      fvf;
880 881 882 883
        BOOL                      streamSource[MAX_STREAMS];
        BOOL                      streamFreq[MAX_STREAMS];
        BOOL                      textures[MAX_TEXTURES];
        BOOL                      transform[HIGHEST_TRANSFORMSTATE + 1];
884
        BOOL                      viewport;
885
        BOOL                      renderState[WINEHIGHEST_RENDER_STATE + 1];
886 887
        BOOL                      textureState[MAX_TEXTURES][WINED3D_HIGHEST_TEXTURE_STATE + 1];
        BOOL                      samplerState[MAX_SAMPLERS][WINED3D_HIGHEST_SAMPLER_STATE + 1];
888
        BOOL                      clipplane[MAX_CLIPPLANES];
889
        BOOL                      vertexDecl;
890
        BOOL                      pixelShader;
891
        BOOL                      pixelShaderConstants[MAX_PSHADER_CONSTANTS];
892
        BOOL                      vertexShader;
893
        BOOL                      vertexShaderConstants[MAX_VSHADER_CONSTANTS];
894 895
} SAVEDSTATES;

896
typedef enum {
897 898 899 900
    WINESHADERCNST_NONE     = 0,
    WINESHADERCNST_FLOAT    = 1,
    WINESHADERCNST_INTEGER  = 2,
    WINESHADERCNST_BOOL     = 3
901 902
} WINESHADERCNST;

903 904 905
struct IWineD3DStateBlockImpl
{
    /* IUnknown fields */
906
    const IWineD3DStateBlockVtbl *lpVtbl;
907
    LONG                      ref;     /* Note: Ref counting not required */
908

909
    /* IWineD3DStateBlock information */
910
    IUnknown                 *parent;
911
    IWineD3DDeviceImpl       *wineD3DDevice;
912
    WINED3DSTATEBLOCKTYPE     blockType;
913 914 915 916

    /* Array indicating whether things have been set or changed */
    SAVEDSTATES               changed;
    SAVEDSTATES               set;
917

918 919
    /* Drawing - Vertex Shader or FVF related */
    DWORD                     fvf;
920
    /* Vertex Shader Declaration */
921
    IWineD3DVertexDeclaration *vertexDecl;
922

923
    IWineD3DVertexShader      *vertexShader;
924

925 926
    /* Vertex Shader Constants */
    BOOL                       vertexShaderConstantB[MAX_VSHADER_CONSTANTS];
Mike McCormack's avatar
Mike McCormack committed
927
    INT                        vertexShaderConstantI[MAX_VSHADER_CONSTANTS * 4];
928
    float                      vertexShaderConstantF[MAX_VSHADER_CONSTANTS * 4];
929
    WINESHADERCNST             vertexShaderConstantT[MAX_VSHADER_CONSTANTS]; /* TODO: Think about changing this to a char to possibly save a little memory */
930

931
    /* Stream Source */
932
    BOOL                      streamIsUP;
933 934 935 936 937
    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  */
938

939 940 941 942
    /* Indices */
    IWineD3DIndexBuffer*      pIndexData;
    UINT                      baseVertexIndex; /* Note: only used for d3d8 */

943
    /* Transform */
944
    D3DMATRIX                 transforms[HIGHEST_TRANSFORMSTATE + 1];
945

946 947
    /* Lights */
    PLIGHTINFOEL             *lights; /* NOTE: active GL lights must be front of the chain */
948

949 950 951 952
    /* Clipping */
    double                    clipplane[MAX_CLIPPLANES][4];
    WINED3DCLIPSTATUS         clip_status;

953 954 955
    /* ViewPort */
    WINED3DVIEWPORT           viewport;

956 957 958
    /* Material */
    WINED3DMATERIAL           material;

959
    /* Pixel Shader */
960
    IWineD3DPixelShader      *pixelShader;
961 962 963

    /* Pixel Shader Constants */
    BOOL                       pixelShaderConstantB[MAX_PSHADER_CONSTANTS];
964
    INT                        pixelShaderConstantI[MAX_PSHADER_CONSTANTS * 4];
965
    float                      pixelShaderConstantF[MAX_PSHADER_CONSTANTS * 4];
966
    WINESHADERCNST             pixelShaderConstantT[MAX_PSHADER_CONSTANTS]; /* TODO: Think about changing this to a char to possibly save a little memory */
967

968 969 970 971 972
    /* Indexed Vertex Blending */
    D3DVERTEXBLENDFLAGS       vertex_blend;
    FLOAT                     tween_factor;

    /* RenderState */
973
    DWORD                     renderState[WINEHIGHEST_RENDER_STATE + 1];
974

975
    /* Texture */
976 977
    IWineD3DBaseTexture      *textures[MAX_TEXTURES];
    int                       textureDimensions[MAX_SAMPLERS];
978 979

    /* Texture State Stage */
980
    DWORD                     textureState[MAX_TEXTURES][WINED3D_HIGHEST_TEXTURE_STATE + 1];
981
    /* Sampler States */
982
    DWORD                     samplerState[MAX_SAMPLERS][WINED3D_HIGHEST_SAMPLER_STATE + 1];
983

984 985
};

986
extern const IWineD3DStateBlockVtbl IWineD3DStateBlock_Vtbl;
987

988 989 990 991 992
/*****************************************************************************
 * IWineD3DQueryImpl implementation structure (extends IUnknown)
 */
typedef struct IWineD3DQueryImpl
{
993
    const IWineD3DQueryVtbl  *lpVtbl;
994
    LONG                      ref;     /* Note: Ref counting not required */
995 996 997 998 999 1000 1001 1002 1003 1004 1005
    
    IUnknown                 *parent;
    /*TODO: replace with iface usage */
#if 0
    IWineD3DDevice         *wineD3DDevice;
#else
    IWineD3DDeviceImpl       *wineD3DDevice;
#endif
    /* IWineD3DQuery fields */

    D3DQUERYTYPE              type;
1006
    /* TODO: Think about using a IUnknown instead of a void* */
1007 1008 1009 1010 1011
    void                     *extendedData;
    
  
} IWineD3DQueryImpl;

1012
extern const IWineD3DQueryVtbl IWineD3DQuery_Vtbl;
1013

1014 1015 1016 1017 1018 1019
/* Datastructures for IWineD3DQueryImpl.extendedData */
typedef struct  WineQueryOcclusionData {
       unsigned int queryId;
} WineQueryOcclusionData;


Oliver Stieber's avatar
Oliver Stieber committed
1020 1021 1022 1023 1024 1025 1026 1027
/*****************************************************************************
 * IWineD3DSwapChainImpl implementation structure (extends IUnknown)
 */

typedef struct IWineD3DSwapChainImpl
{
    /*IUnknown part*/
    IWineD3DSwapChainVtbl    *lpVtbl;
1028
    LONG                      ref;     /* Note: Ref counting not required */
Oliver Stieber's avatar
Oliver Stieber committed
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038

    IUnknown                 *parent;
    IWineD3DDeviceImpl       *wineD3DDevice;

    /* IWineD3DSwapChain fields */
    IWineD3DSurface          *backBuffer;
    IWineD3DSurface          *frontBuffer;
    BOOL                      wantsDepthStencilBuffer;
    D3DPRESENT_PARAMETERS     presentParms;

1039
    /* TODO: move everything up to drawable off into a context manager
Oliver Stieber's avatar
Oliver Stieber committed
1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
      and store the 'data' in the contextManagerData interface.
    IUnknown                  *contextManagerData;
    */

    HWND                    win_handle;
    Window                  win;
    Display                *display;

    GLXContext              glCtx;
    XVisualInfo            *visInfo;
    GLXContext              render_ctx;
1051
    /* This has been left in device for now, but needs moving off into a rendertarget management class and separated out from swapchains and devices. */
Oliver Stieber's avatar
Oliver Stieber committed
1052 1053 1054 1055 1056
    Drawable                drawable;
} IWineD3DSwapChainImpl;

extern IWineD3DSwapChainVtbl IWineD3DSwapChain_Vtbl;

1057 1058 1059
/*****************************************************************************
 * Utility function prototypes 
 */
1060 1061

/* Trace routines */
1062
const char* debug_d3dformat(WINED3DFORMAT fmt);
1063 1064 1065
const char* debug_d3ddevicetype(D3DDEVTYPE devtype);
const char* debug_d3dresourcetype(D3DRESOURCETYPE res);
const char* debug_d3dusage(DWORD usage);
1066
const char* debug_d3dprimitivetype(D3DPRIMITIVETYPE PrimitiveType);
1067 1068
const char* debug_d3drenderstate(DWORD state);
const char* debug_d3dtexturestate(DWORD state);
1069
const char* debug_d3dpool(D3DPOOL pool);
1070 1071 1072 1073

/* 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);
1074
void   set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords);
1075
void   GetSrcAndOpFromValue(DWORD iValue, BOOL isAlphaArg, GLenum* source, GLenum* operand);
1076

1077 1078 1079 1080 1081
SHORT  D3DFmtGetBpp(IWineD3DDeviceImpl* This, D3DFORMAT fmt);
GLenum D3DFmt2GLFmt(IWineD3DDeviceImpl* This, D3DFORMAT fmt);
GLenum D3DFmt2GLType(IWineD3DDeviceImpl *This, D3DFORMAT fmt);
GLint  D3DFmt2GLIntFmt(IWineD3DDeviceImpl* This, D3DFORMAT fmt);

1082 1083 1084
int D3DFmtMakeGlCfg(D3DFORMAT BackBufferFormat, D3DFORMAT StencilBufferFormat, int *attribs, int* nAttribs, BOOL alternate);


1085 1086
/*****************************************************************************
 * To enable calling of inherited functions, requires prototypes 
1087 1088
 *
 * Note: Only require classes which are subclassed, ie resource, basetexture, 
1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
 */
    /*** 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);
    extern D3DRESOURCETYPE WINAPI IWineD3DResourceImpl_GetType(IWineD3DResource *iface);
1104 1105
    /*** class static members ***/
    void IWineD3DResourceImpl_CleanUp(IWineD3DResource *iface);
1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129

    /*** 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);
    extern D3DRESOURCETYPE WINAPI IWineD3DBaseTextureImpl_GetType(IWineD3DBaseTexture *iface);
    /*** 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);
    extern HRESULT WINAPI IWineD3DBaseTextureImpl_SetAutoGenFilterType(IWineD3DBaseTexture *iface, D3DTEXTUREFILTERTYPE FilterType);
    extern D3DTEXTUREFILTERTYPE WINAPI IWineD3DBaseTextureImpl_GetAutoGenFilterType(IWineD3DBaseTexture *iface);
    extern void WINAPI IWineD3DBaseTextureImpl_GenerateMipSubLevels(IWineD3DBaseTexture *iface);
    extern BOOL WINAPI IWineD3DBaseTextureImpl_SetDirty(IWineD3DBaseTexture *iface, BOOL);
    extern BOOL WINAPI IWineD3DBaseTextureImpl_GetDirty(IWineD3DBaseTexture *iface);
1130 1131 1132

    extern BYTE* WINAPI IWineD3DVertexBufferImpl_GetMemory(IWineD3DVertexBuffer* iface, DWORD iOffset);
    extern HRESULT WINAPI IWineD3DVertexBufferImpl_ReleaseMemory(IWineD3DVertexBuffer* iface);
1133 1134
    extern HRESULT WINAPI IWineD3DBaseTextureImpl_BindTexture(IWineD3DBaseTexture *iface);
    extern HRESULT WINAPI IWineD3DBaseTextureImpl_UnBindTexture(IWineD3DBaseTexture *iface);
1135
    extern void WINAPI IWineD3DBaseTextureImpl_ApplyStateChanges(IWineD3DBaseTexture *iface, const DWORD textureStates[WINED3D_HIGHEST_TEXTURE_STATE + 1], const DWORD samplerStates[WINED3D_HIGHEST_SAMPLER_STATE + 1]);
1136 1137
    /*** class static members ***/
    void IWineD3DBaseTextureImpl_CleanUp(IWineD3DBaseTexture *iface);
1138

1139 1140 1141 1142
/* 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?
 */
1143 1144 1145 1146 1147 1148 1149 1150
enum vsConstantsEnum {
    VS_CONSTANT_NOT_USED = 0,
    VS_CONSTANT_CONSTANT,
    VS_CONSTANT_INTEGER,
    VS_CONSTANT_BOOLEAN,
    VS_CONSTANT_FLOAT
};

1151 1152 1153
/*****************************************************************************
 * IDirect3DVertexShader implementation structure
 */
1154 1155
typedef struct IWineD3DVertexShaderImpl {
    /* IUnknown parts*/   
1156
    const IWineD3DVertexShaderVtbl *lpVtbl;
1157
    LONG                        ref;     /* Note: Ref counting not required */
1158 1159 1160 1161

    IUnknown                    *parent;
    IWineD3DDeviceImpl          *wineD3DDevice;

1162
    /* IWineD3DVertexShaderImpl */
1163 1164 1165
    CONST DWORD                 *function;
    UINT                         functionLength;

1166 1167
    DWORD usage;
    DWORD version;
1168 1169 1170 1171 1172 1173 1174 1175

    /* 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 */
1176
    /* run time datas...  */
1177
    VSHADERDATA                *data;
Mike McCormack's avatar
Mike McCormack committed
1178
    GLuint                      prgId;
1179
    IWineD3DVertexDeclaration  *vertexDeclaration;
1180 1181 1182 1183 1184 1185
#if 0 /* needs reworking */
    /* run time datas */
    VSHADERINPUTDATA input;
    VSHADEROUTPUTDATA output;
#endif
} IWineD3DVertexShaderImpl;
1186
extern const IWineD3DVertexShaderVtbl IWineD3DVertexShader_Vtbl;
1187 1188 1189 1190

/*****************************************************************************
 * IDirect3DPixelShader implementation structure
 */
1191
typedef struct IWineD3DPixelShaderImpl {
1192
    /* IUnknown parts */
1193
    const IWineD3DPixelShaderVtbl *lpVtbl;
1194
    LONG                        ref;     /* Note: Ref counting not required */
1195

1196 1197 1198
    IUnknown                   *parent;
    IWineD3DDeviceImpl         *wineD3DDevice;

1199
    /* IWineD3DPixelShaderImpl */
1200 1201
    CONST DWORD                *function;
    UINT                        functionLength;
1202
    DWORD                       version;
1203
    CHAR                        constants[WINED3D_PSHADER_MAX_CONSTANTS];
1204 1205 1206

    /* run time data */
    PSHADERDATA                *data;
1207
    GLuint                      prgId;
1208

1209 1210 1211 1212 1213
#if 0 /* needs reworking */
    PSHADERINPUTDATA input;
    PSHADEROUTPUTDATA output;
#endif
} IWineD3DPixelShaderImpl;
1214

1215
extern const IWineD3DPixelShaderVtbl IWineD3DPixelShader_Vtbl;
1216
#endif