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
|
2006-05-18 14:49:52 +02:00
|
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
2003-11-14 04:50:35 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
#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
|
|
|
|
2006-10-10 01:45:12 +02:00
|
|
|
#include "wined3d_private_types.h"
|
2003-11-14 04:50:35 +01:00
|
|
|
#include "wine/wined3d_interface.h"
|
2007-02-14 23:30:46 +01:00
|
|
|
#include "wine/wined3d_caps.h"
|
2004-09-29 23:26:47 +02:00
|
|
|
#include "wine/wined3d_gl.h"
|
2006-06-09 09:33:01 +02:00
|
|
|
#include "wine/list.h"
|
2003-11-14 04:50:35 +01:00
|
|
|
|
2007-02-27 20:51:48 +01:00
|
|
|
/* Hash table functions */
|
|
|
|
typedef unsigned int (hash_function_t)(void *key);
|
|
|
|
typedef BOOL (compare_function_t)(void *keya, void *keyb);
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
void *key;
|
|
|
|
void *value;
|
|
|
|
unsigned int hash;
|
|
|
|
struct list entry;
|
|
|
|
} hash_table_entry_t;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
hash_function_t *hash_function;
|
|
|
|
compare_function_t *compare_function;
|
|
|
|
struct list *buckets;
|
|
|
|
unsigned int bucket_count;
|
|
|
|
hash_table_entry_t *entries;
|
|
|
|
unsigned int entry_count;
|
|
|
|
struct list free_entries;
|
|
|
|
unsigned int count;
|
|
|
|
unsigned int grow_size;
|
|
|
|
unsigned int shrink_size;
|
|
|
|
} hash_table_t;
|
|
|
|
|
|
|
|
hash_table_t *hash_table_create(hash_function_t *hash_function, compare_function_t *compare_function);
|
|
|
|
void hash_table_destroy(hash_table_t *table);
|
|
|
|
void *hash_table_get(hash_table_t *table, void *key);
|
|
|
|
void hash_table_put(hash_table_t *table, void *key, void *value);
|
|
|
|
void hash_table_remove(hash_table_t *table, void *key);
|
|
|
|
|
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
|
2006-10-13 05:35:35 +02:00
|
|
|
#define MAX_CLIPPLANES WINED3DMAXUSERCLIPPLANES
|
2005-07-05 16:05:18 +02:00
|
|
|
#define MAX_LEVELS 256
|
2005-06-24 13:53:07 +02:00
|
|
|
|
2006-07-19 06:06:07 +02:00
|
|
|
#define MAX_CONST_I 16
|
|
|
|
#define MAX_CONST_B 16
|
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];
|
|
|
|
|
2006-10-11 03:55:05 +02:00
|
|
|
extern DWORD minMipLookup[WINED3DTEXF_ANISOTROPIC + 1][WINED3DTEXF_LINEAR + 1];
|
2005-08-03 13:00:28 +02:00
|
|
|
|
2006-03-22 20:46:59 +01:00
|
|
|
typedef struct _WINED3DGLTYPE {
|
|
|
|
int d3dType;
|
|
|
|
GLint size;
|
|
|
|
GLenum glType;
|
|
|
|
GLboolean normalized;
|
|
|
|
int typesize;
|
|
|
|
} WINED3DGLTYPE;
|
|
|
|
|
2006-10-11 03:54:22 +02:00
|
|
|
/* NOTE: Make sure these are in the correct numerical order. (see /include/wined3d_types.h) */
|
|
|
|
static WINED3DGLTYPE const glTypeLookup[WINED3DDECLTYPE_UNUSED] = {
|
|
|
|
{WINED3DDECLTYPE_FLOAT1, 1, GL_FLOAT , GL_FALSE ,sizeof(float)},
|
|
|
|
{WINED3DDECLTYPE_FLOAT2, 2, GL_FLOAT , GL_FALSE ,sizeof(float)},
|
|
|
|
{WINED3DDECLTYPE_FLOAT3, 3, GL_FLOAT , GL_FALSE ,sizeof(float)},
|
|
|
|
{WINED3DDECLTYPE_FLOAT4, 4, GL_FLOAT , GL_FALSE ,sizeof(float)},
|
|
|
|
{WINED3DDECLTYPE_D3DCOLOR, 4, GL_UNSIGNED_BYTE , GL_TRUE ,sizeof(BYTE)},
|
|
|
|
{WINED3DDECLTYPE_UBYTE4, 4, GL_UNSIGNED_BYTE , GL_FALSE ,sizeof(BYTE)},
|
|
|
|
{WINED3DDECLTYPE_SHORT2, 2, GL_SHORT , GL_FALSE ,sizeof(short int)},
|
|
|
|
{WINED3DDECLTYPE_SHORT4, 4, GL_SHORT , GL_FALSE ,sizeof(short int)},
|
|
|
|
{WINED3DDECLTYPE_UBYTE4N, 4, GL_UNSIGNED_BYTE , GL_FALSE ,sizeof(BYTE)},
|
|
|
|
{WINED3DDECLTYPE_SHORT2N, 2, GL_SHORT , GL_FALSE ,sizeof(short int)},
|
|
|
|
{WINED3DDECLTYPE_SHORT4N, 4, GL_SHORT , GL_FALSE ,sizeof(short int)},
|
|
|
|
{WINED3DDECLTYPE_USHORT2N, 2, GL_UNSIGNED_SHORT , GL_FALSE ,sizeof(short int)},
|
|
|
|
{WINED3DDECLTYPE_USHORT4N, 4, GL_UNSIGNED_SHORT , GL_FALSE ,sizeof(short int)},
|
|
|
|
{WINED3DDECLTYPE_UDEC3, 3, GL_UNSIGNED_SHORT , GL_FALSE ,sizeof(short int)},
|
|
|
|
{WINED3DDECLTYPE_DEC3N, 3, GL_SHORT , GL_FALSE ,sizeof(short int)},
|
|
|
|
{WINED3DDECLTYPE_FLOAT16_2, 2, GL_FLOAT , GL_FALSE ,sizeof(short int)},
|
|
|
|
{WINED3DDECLTYPE_FLOAT16_4, 4, GL_FLOAT , GL_FALSE ,sizeof(short int)}};
|
2005-08-03 13:00:28 +02:00
|
|
|
|
2006-07-07 08:25:14 +02:00
|
|
|
#define WINED3D_ATR_TYPE(type) glTypeLookup[type].d3dType
|
|
|
|
#define WINED3D_ATR_SIZE(type) glTypeLookup[type].size
|
|
|
|
#define WINED3D_ATR_GLTYPE(type) glTypeLookup[type].glType
|
|
|
|
#define WINED3D_ATR_NORMALIZED(type) glTypeLookup[type].normalized
|
|
|
|
#define WINED3D_ATR_TYPESIZE(type) glTypeLookup[type].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
|
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
|
2006-09-26 20:31:48 +02:00
|
|
|
#define NP2_NATIVE 2
|
2005-07-24 19:11:33 +02:00
|
|
|
|
2006-11-17 13:23:53 +01:00
|
|
|
#define ORM_BACKBUFFER 0
|
|
|
|
#define ORM_PBUFFER 1
|
2006-11-17 13:24:00 +01:00
|
|
|
#define ORM_FBO 2
|
2006-11-17 13:23:53 +01:00
|
|
|
|
2006-05-24 00:22:59 +02:00
|
|
|
#define SHADER_ARB 1
|
|
|
|
#define SHADER_GLSL 2
|
wined3d: Rework shader mode selection.
- currently half the shader selection code (GLSL vs ARB) is in
fillGLcaps. The parts that check for software shaders are in
GetDeviceCaps. That placement, will work, but is definitely not optimal.
FillGLcaps should detect support - it should not make decision as to
what's used, because that's not what the purpose of the function is.
GetDeviceCaps should report support as it has already been selected.
Instead, select shader mode in its own function, called in the
appropriate places.
- unifying pixel and vertex shaders into a single selection is a
mistake. A software vertex shader can be coupled with a hardware arb or
glsl pixel shader, or no shader at all. Split them back into two and add
a SHADER_NONE variant.
- drawprim is doing support checks for ARB_PROGRAM, and making shader
decisions based on that - that's wrong, support has already been
checked, and decided upon, and shaders can be implemented via software,
ARB_PROGRAm or GLSL, so that support check isn't valid.
- Store the shader selected mode into the shader itself. Different types
of shaders can be combined, so this is an improvement. In fact, storing
the mode into the settings globally is a mistake as well - it should be
done per device, since different cards have different capabilities.
2006-07-04 09:21:53 +02:00
|
|
|
#define SHADER_NONE 3
|
2006-05-24 00:22:59 +02:00
|
|
|
|
2006-07-17 20:14:25 +02:00
|
|
|
#define RTL_DISABLE -1
|
|
|
|
#define RTL_AUTO 0
|
|
|
|
#define RTL_READDRAW 1
|
|
|
|
#define RTL_READTEX 2
|
|
|
|
#define RTL_TEXDRAW 3
|
|
|
|
#define RTL_TEXTEX 4
|
|
|
|
|
2006-09-26 20:31:41 +02:00
|
|
|
/* NOTE: When adding fields to this structure, make sure to update the default
|
|
|
|
* values in wined3d_main.c as well. */
|
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;
|
2006-05-24 00:22:59 +02:00
|
|
|
/* Ideally, we don't want the user to have to request GLSL. If the hardware supports GLSL,
|
|
|
|
we should use it. However, until it's fully implemented, we'll leave it as a registry
|
|
|
|
setting for developers. */
|
2006-05-18 03:24:08 +02:00
|
|
|
BOOL glslRequested;
|
2006-11-17 13:23:53 +01:00
|
|
|
int offscreen_rendering_mode;
|
2006-07-17 20:14:25 +02:00
|
|
|
int rendertargetlock_mode;
|
2006-08-08 00:03:06 +02:00
|
|
|
/* Memory tracking and object counting */
|
|
|
|
unsigned int emulated_textureram;
|
2005-07-24 19:11:33 +02:00
|
|
|
} wined3d_settings_t;
|
|
|
|
|
|
|
|
extern wined3d_settings_t wined3d_settings;
|
|
|
|
|
2006-11-27 20:50:37 +01:00
|
|
|
/* Shader backends */
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
void (*shader_select)(IWineD3DDevice *iface, BOOL usePS, BOOL useVS);
|
|
|
|
void (*shader_select_depth_blt)(IWineD3DDevice *iface);
|
|
|
|
void (*shader_load_constants)(IWineD3DDevice *iface, char usePS, char useVS);
|
2007-02-08 22:31:01 +01:00
|
|
|
void (*shader_cleanup)(IWineD3DDevice *iface);
|
2006-11-27 20:50:37 +01:00
|
|
|
} shader_backend_t;
|
|
|
|
|
|
|
|
extern const shader_backend_t glsl_shader_backend;
|
|
|
|
extern const shader_backend_t arb_program_shader_backend;
|
|
|
|
extern const shader_backend_t none_shader_backend;
|
|
|
|
|
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);
|
2006-05-25 13:54:03 +02:00
|
|
|
|
2004-12-13 14:35:38 +01:00
|
|
|
/* 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
|
2006-10-12 08:21:00 +02:00
|
|
|
/* Highest value in WINED3DTRANSFORMSTATETYPE */
|
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 { \
|
2007-04-23 22:02:50 +02:00
|
|
|
FIXME(">>>>>>>>>>>>>>>>> %s (%#x) from %s @ %s / %d\n", \
|
|
|
|
debug_glerror(err), err, A, __FILE__, __LINE__); \
|
2006-04-10 06:39:07 +02:00
|
|
|
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);
|
2006-10-01 05:20:10 +02:00
|
|
|
#define TRACE_STRIDED(sd,name) TRACE( #name "=(data:%p, stride:%d, type:%d)\n", sd->u.s.name.lpData, sd->u.s.name.dwStride, sd->u.s.name.dwType);
|
2004-12-09 12:42:34 +01:00
|
|
|
|
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;
|
2007-02-12 19:18:36 +01:00
|
|
|
typedef struct IWineD3DDeviceImpl IWineD3DDeviceImpl;
|
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 { \
|
2007-04-23 22:02:50 +02:00
|
|
|
FIXME(">>>>>>>>>>>>>>>>> %s (%#x) from %s @ %s / %d\n", \
|
|
|
|
debug_glerror(err), err, A, __FILE__, __LINE__); \
|
2006-04-10 06:39:07 +02:00
|
|
|
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
|
2006-10-15 17:05:01 +02:00
|
|
|
of each frame, a check is made for the existence of C:\D3DTRACE, and if it exists d3d trace
|
|
|
|
is enabled, and if it doesn't exist it is disabled. */
|
2004-12-14 12:54:27 +01:00
|
|
|
# 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,
|
2007-01-02 21:13:28 +01:00
|
|
|
int minIndex);
|
2004-12-09 12:42:34 +01:00
|
|
|
|
2007-01-02 21:07:39 +01:00
|
|
|
void primitiveConvertToStridedData(IWineD3DDevice *iface, WineDirect3DVertexStridedData *strided, BOOL *fixup);
|
2006-06-21 15:01:38 +02:00
|
|
|
|
|
|
|
void primitiveDeclarationConvertToStridedData(
|
|
|
|
IWineD3DDevice *iface,
|
|
|
|
BOOL useVertexShaderFunction,
|
|
|
|
WineDirect3DVertexStridedData *strided,
|
|
|
|
BOOL *fixup);
|
|
|
|
|
|
|
|
void primitiveConvertFVFtoOffset(DWORD thisFVF,
|
|
|
|
DWORD stride,
|
|
|
|
BYTE *data,
|
|
|
|
WineDirect3DVertexStridedData *strided,
|
2007-01-16 23:58:29 +01:00
|
|
|
GLint streamVBO,
|
|
|
|
UINT streamNo);
|
2006-05-12 22:21:31 +02:00
|
|
|
|
|
|
|
DWORD get_flexible_vertex_size(DWORD d3dvtVertexType);
|
|
|
|
|
2007-03-10 00:55:08 +01:00
|
|
|
void blt_to_drawable(IWineD3DDeviceImpl *This, IWineD3DSurfaceImpl *surface);
|
|
|
|
|
2006-05-09 18:16:13 +02:00
|
|
|
#define eps 1e-8
|
|
|
|
|
2006-05-12 22:21:31 +02:00
|
|
|
#define GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, tex_num) \
|
|
|
|
(((((d3dvtVertexType) >> (16 + (2 * (tex_num)))) + 1) & 0x03) + 1)
|
|
|
|
|
2006-12-05 23:36:10 +01:00
|
|
|
/* Routines and structures related to state management */
|
2007-02-12 19:18:31 +01:00
|
|
|
typedef struct WineD3DContext WineD3DContext;
|
2007-02-12 19:18:22 +01:00
|
|
|
typedef void (*APPLYSTATEFUNC)(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *ctx);
|
2006-12-05 23:36:10 +01:00
|
|
|
|
2006-12-06 13:22:12 +01:00
|
|
|
#define STATE_RENDER(a) (a)
|
|
|
|
#define STATE_IS_RENDER(a) ((a) >= STATE_RENDER(1) && (a) <= STATE_RENDER(WINEHIGHEST_RENDER_STATE))
|
|
|
|
|
2006-12-19 22:43:49 +01:00
|
|
|
#define STATE_TEXTURESTAGE(stage, num) (STATE_RENDER(WINEHIGHEST_RENDER_STATE) + (stage) * WINED3D_HIGHEST_TEXTURE_STATE + (num))
|
|
|
|
#define STATE_IS_TEXTURESTAGE(a) ((a) >= STATE_TEXTURESTAGE(0, 1) && (a) <= STATE_TEXTURESTAGE(MAX_TEXTURES - 1, WINED3D_HIGHEST_TEXTURE_STATE))
|
|
|
|
|
2006-12-19 23:14:07 +01:00
|
|
|
/* + 1 because samplers start with 0 */
|
|
|
|
#define STATE_SAMPLER(num) (STATE_TEXTURESTAGE(MAX_TEXTURES - 1, WINED3D_HIGHEST_TEXTURE_STATE) + 1 + (num))
|
|
|
|
#define STATE_IS_SAMPLER(num) ((num) >= STATE_SAMPLER(0) && (num) <= STATE_SAMPLER(MAX_SAMPLERS - 1))
|
|
|
|
|
2006-12-19 23:22:19 +01:00
|
|
|
#define STATE_PIXELSHADER (STATE_SAMPLER(MAX_SAMPLERS - 1) + 1)
|
|
|
|
#define STATE_IS_PIXELSHADER(a) ((a) == STATE_PIXELSHADER)
|
|
|
|
|
2006-12-28 18:57:16 +01:00
|
|
|
#define STATE_TRANSFORM(a) (STATE_PIXELSHADER + (a))
|
|
|
|
#define STATE_IS_TRANSFORM(a) ((a) >= STATE_TRANSFORM(1) && (a) <= STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)))
|
|
|
|
|
2007-01-02 00:35:07 +01:00
|
|
|
#define STATE_STREAMSRC (STATE_TRANSFORM(WINED3DTS_WORLDMATRIX(255)) + 1)
|
|
|
|
#define STATE_IS_STREAMSRC(a) ((a) == STATE_STREAMSRC)
|
2007-02-19 15:25:32 +01:00
|
|
|
#define STATE_INDEXBUFFER (STATE_STREAMSRC + 1)
|
|
|
|
#define STATE_IS_INDEXBUFFER(a) ((a) == STATE_INDEXBUFFER)
|
2007-01-02 00:35:07 +01:00
|
|
|
|
2007-02-19 15:25:32 +01:00
|
|
|
#define STATE_VDECL (STATE_INDEXBUFFER + 1)
|
2007-01-02 00:35:07 +01:00
|
|
|
#define STATE_IS_VDECL(a) ((a) == STATE_VDECL)
|
|
|
|
|
|
|
|
#define STATE_VSHADER (STATE_VDECL + 1)
|
|
|
|
#define STATE_IS_VSHADER(a) ((a) == STATE_VSHADER)
|
|
|
|
|
2007-01-02 21:40:59 +01:00
|
|
|
#define STATE_VIEWPORT (STATE_VSHADER + 1)
|
|
|
|
#define STATE_IS_VIEWPORT(a) ((a) == STATE_VIEWPORT)
|
|
|
|
|
2007-01-06 18:17:27 +01:00
|
|
|
#define STATE_VERTEXSHADERCONSTANT (STATE_VIEWPORT + 1)
|
|
|
|
#define STATE_PIXELSHADERCONSTANT (STATE_VERTEXSHADERCONSTANT + 1)
|
|
|
|
#define STATE_IS_VERTEXSHADERCONSTANT(a) ((a) == STATE_VERTEXSHADERCONSTANT)
|
|
|
|
#define STATE_IS_PIXELSHADERCONSTANT(a) ((a) == STATE_PIXELSHADERCONSTANT)
|
|
|
|
|
2007-02-14 17:48:52 +01:00
|
|
|
#define STATE_ACTIVELIGHT(a) (STATE_PIXELSHADERCONSTANT + (a) + 1)
|
|
|
|
#define STATE_IS_ACTIVELIGHT(a) ((a) >= STATE_ACTIVELIGHT(0) && (a) < STATE_PIXELSHADERCONSTANT(MAX_ACTIVE_LIGHTS))
|
|
|
|
|
2007-02-19 15:25:16 +01:00
|
|
|
#define STATE_SCISSORRECT (STATE_ACTIVELIGHT(MAX_ACTIVE_LIGHTS - 1) + 1)
|
|
|
|
#define STATE_IS_SCISSORRECT(a) ((a) == STATE_SCISSORRECT)
|
|
|
|
|
2007-02-28 14:36:36 +01:00
|
|
|
#define STATE_CLIPPLANE(a) (STATE_SCISSORRECT + 1 + (a))
|
|
|
|
#define STATE_IS_CLIPPLANE(a) ((a) >= STATE_CLIPPLANE(0) && (a) <= STATE_CLIPPLANE(MAX_CLIPPLANES - 1))
|
|
|
|
|
|
|
|
#define STATE_HIGHEST (STATE_CLIPPLANE(MAX_CLIPPLANES - 1))
|
2006-12-19 13:00:03 +01:00
|
|
|
|
2006-12-05 23:36:10 +01:00
|
|
|
struct StateEntry
|
|
|
|
{
|
|
|
|
DWORD representative;
|
|
|
|
APPLYSTATEFUNC apply;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Global state table */
|
|
|
|
extern const struct StateEntry StateTable[];
|
|
|
|
|
2007-02-12 19:18:31 +01:00
|
|
|
/* The new context manager that should deal with onscreen and offscreen rendering */
|
|
|
|
struct WineD3DContext {
|
|
|
|
/* State dirtification
|
|
|
|
* dirtyArray is an array that contains markers for dirty states. numDirtyEntries states are dirty, their numbers are in indices
|
|
|
|
* 0...numDirtyEntries - 1. isStateDirty is a redundant copy of the dirtyArray. Technically only one of them would be needed,
|
|
|
|
* but with the help of both it is easy to find out if a state is dirty(just check the array index), and for applying dirty states
|
|
|
|
* only numDirtyEntries array elements have to be checked, not STATE_HIGHEST states.
|
|
|
|
*/
|
|
|
|
DWORD dirtyArray[STATE_HIGHEST + 1]; /* Won't get bigger than that, a state is never marked dirty 2 times */
|
|
|
|
DWORD numDirtyEntries;
|
|
|
|
DWORD isStateDirty[STATE_HIGHEST/32 + 1]; /* Bitmap to find out quickly if a state is dirty */
|
|
|
|
|
2007-02-12 19:21:10 +01:00
|
|
|
IWineD3DSurface *surface;
|
2007-03-04 17:31:06 +01:00
|
|
|
DWORD tid; /* Thread ID which owns this context at the moment */
|
2007-02-12 19:18:31 +01:00
|
|
|
|
|
|
|
/* Stores some inforation about the context state for optimization */
|
|
|
|
BOOL last_was_rhw; /* true iff last draw_primitive was in xyzrhw mode */
|
|
|
|
BOOL last_was_pshader;
|
|
|
|
BOOL last_was_vshader;
|
|
|
|
BOOL last_was_foggy_shader;
|
|
|
|
BOOL namedArraysLoaded, numberedArraysLoaded;
|
|
|
|
BOOL lastWasPow2Texture[MAX_TEXTURES];
|
|
|
|
GLenum tracking_parm; /* Which source is tracking current colour */
|
2007-02-15 03:04:18 +01:00
|
|
|
BOOL last_was_blit, last_was_ckey;
|
2007-02-12 19:21:10 +01:00
|
|
|
|
|
|
|
/* The actual opengl context */
|
|
|
|
GLXContext glCtx;
|
|
|
|
Drawable drawable;
|
2007-02-12 19:22:41 +01:00
|
|
|
Display *display;
|
|
|
|
BOOL isPBuffer;
|
2007-02-12 19:18:31 +01:00
|
|
|
};
|
|
|
|
|
2007-02-12 19:18:36 +01:00
|
|
|
typedef enum ContextUsage {
|
|
|
|
CTXUSAGE_RESOURCELOAD = 1, /* Only loads textures: No State is applied */
|
|
|
|
CTXUSAGE_DRAWPRIM = 2, /* OpenGL states are set up for blitting DirectDraw surfacs */
|
|
|
|
CTXUSAGE_BLIT = 3, /* OpenGL states are set up 3D drawing */
|
|
|
|
} ContextUsage;
|
|
|
|
|
|
|
|
void ActivateContext(IWineD3DDeviceImpl *device, IWineD3DSurface *target, ContextUsage usage);
|
2007-02-12 19:22:41 +01:00
|
|
|
WineD3DContext *CreateContext(IWineD3DDeviceImpl *This, IWineD3DSurfaceImpl *target, Display *display, Window win);
|
2007-02-12 19:21:10 +01:00
|
|
|
void DestroyContext(IWineD3DDeviceImpl *This, WineD3DContext *context);
|
2007-04-09 01:53:27 +02:00
|
|
|
void apply_fbo_state(IWineD3DDevice *iface);
|
2007-02-12 19:18:36 +01:00
|
|
|
|
2006-04-18 22:38:30 +02:00
|
|
|
/* Routine to fill gl caps for swapchains and IWineD3D */
|
2006-07-19 23:49:37 +02:00
|
|
|
BOOL IWineD3DImpl_FillGLCaps(IWineD3D *iface, Display* display);
|
2006-04-18 22:38:30 +02:00
|
|
|
|
2006-08-19 11:58:23 +02:00
|
|
|
/* Macros for doing basic GPU detection based on opengl capabilities */
|
|
|
|
#define WINE_D3D6_CAPABLE(gl_info) (gl_info->supported[ARB_MULTITEXTURE])
|
|
|
|
#define WINE_D3D7_CAPABLE(gl_info) (gl_info->supported[ARB_TEXTURE_COMPRESSION] && gl_info->supported[ARB_TEXTURE_CUBE_MAP] && gl_info->supported[ARB_TEXTURE_ENV_DOT3])
|
|
|
|
#define WINE_D3D8_CAPABLE(gl_info) WINE_D3D7_CAPABLE(gl_info) && (gl_info->supported[ARB_MULTISAMPLE] && gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
|
|
|
|
#define WINE_D3D9_CAPABLE(gl_info) WINE_D3D8_CAPABLE(gl_info) && (gl_info->supported[ARB_FRAGMENT_PROGRAM] && gl_info->supported[ARB_VERTEX_SHADER])
|
|
|
|
|
2006-12-05 00:28:58 +01:00
|
|
|
/* Default callbacks for implicit object destruction */
|
|
|
|
extern ULONG WINAPI D3DCB_DefaultDestroySurface(IWineD3DSurface *pSurface);
|
|
|
|
|
2006-12-05 00:29:21 +01:00
|
|
|
extern ULONG WINAPI D3DCB_DefaultDestroyVolume(IWineD3DVolume *pSurface);
|
|
|
|
|
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 changed;
|
|
|
|
BOOL enabledChanged;
|
|
|
|
|
|
|
|
/* Converted parms to speed up swapping lights */
|
|
|
|
float lightPosn[4];
|
|
|
|
float lightDirn[4];
|
|
|
|
float exponent;
|
|
|
|
float cutoff;
|
|
|
|
|
2007-02-14 17:46:54 +01:00
|
|
|
struct list entry;
|
2004-11-29 18:53:42 +01:00
|
|
|
};
|
|
|
|
|
2006-06-07 05:37:05 +02:00
|
|
|
/* The default light parameters */
|
|
|
|
extern const WINED3DLIGHT WINED3D_default_light;
|
|
|
|
|
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
|
|
|
|
2007-02-20 15:57:10 +01:00
|
|
|
/* TODO: setup some flags in the registry to enable, disable pbuffer support
|
2005-07-19 13:39:24 +02:00
|
|
|
(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;
|
|
|
|
|
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
|
|
|
|
*/
|
2007-02-12 19:18:36 +01:00
|
|
|
struct IWineD3DDeviceImpl
|
2004-10-07 06:22:21 +02:00
|
|
|
{
|
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
|
|
|
|
2007-01-18 23:41:36 +01:00
|
|
|
/* Window styles to restore when switching fullscreen mode */
|
|
|
|
LONG style;
|
|
|
|
LONG exStyle;
|
|
|
|
|
2004-10-08 22:52:33 +02:00
|
|
|
/* X and GL Information */
|
|
|
|
GLint maxConcurrentLights;
|
2007-02-27 21:32:15 +01:00
|
|
|
GLenum offscreenBuffer;
|
2004-10-08 22:52:33 +02:00
|
|
|
|
2006-10-08 05:25:01 +02:00
|
|
|
/* Selected capabilities */
|
|
|
|
int vs_selected_mode;
|
|
|
|
int ps_selected_mode;
|
2006-11-27 20:50:43 +01:00
|
|
|
const shader_backend_t *shader_backend;
|
2007-02-27 20:51:53 +01:00
|
|
|
hash_table_t *glsl_program_lookup;
|
2006-10-08 05:25:01 +02:00
|
|
|
|
2007-02-12 19:18:27 +01:00
|
|
|
/* To store */
|
2004-10-08 22:52:33 +02:00
|
|
|
BOOL view_ident; /* true iff view matrix is identity */
|
2006-08-21 18:28:05 +02:00
|
|
|
BOOL untransformed;
|
2007-04-27 00:43:15 +02:00
|
|
|
BOOL vertexBlendUsed; /* To avoid needless setting of the blend matrices */
|
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;
|
2007-01-06 18:41:43 +01:00
|
|
|
BOOL isInDraw;
|
2004-10-21 22:59:12 +02:00
|
|
|
|
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;
|
2006-10-11 03:52:00 +02:00
|
|
|
WINED3DDEVTYPE devType;
|
2004-10-08 22:52:33 +02:00
|
|
|
|
2006-05-24 11:34:30 +02:00
|
|
|
IWineD3DSwapChain **swapchains;
|
|
|
|
uint NumberOfSwapChains;
|
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 */
|
2006-12-19 19:25:22 +01:00
|
|
|
IWineD3DSurface **render_targets;
|
2005-03-14 11:12:52 +01:00
|
|
|
IWineD3DSurface *depthStencilBuffer;
|
2007-04-09 01:53:27 +02:00
|
|
|
IWineD3DSurface **fbo_color_attachments;
|
|
|
|
IWineD3DSurface *fbo_depth_attachment;
|
2005-01-09 18:37:02 +01:00
|
|
|
|
2005-03-14 11:12:52 +01:00
|
|
|
IWineD3DSurface *stencilBufferTarget;
|
2005-01-09 18:37:02 +01:00
|
|
|
|
2007-02-12 19:21:10 +01:00
|
|
|
/* Caches to avoid unneeded context changes */
|
|
|
|
IWineD3DSurface *lastActiveRenderTarget;
|
|
|
|
IWineD3DSwapChain *lastActiveSwapChain;
|
|
|
|
|
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 */
|
2006-11-17 13:23:41 +01:00
|
|
|
BOOL render_offscreen;
|
2006-11-17 13:24:04 +01:00
|
|
|
WINED3D_DEPTHCOPYSTATE depth_copy_state;
|
2006-11-17 13:24:00 +01:00
|
|
|
GLuint fbo;
|
2007-04-09 01:54:07 +02:00
|
|
|
GLuint src_fbo;
|
|
|
|
GLuint dst_fbo;
|
2006-12-19 19:25:35 +01:00
|
|
|
GLenum *draw_buffers;
|
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;
|
2006-07-27 17:39:03 +02:00
|
|
|
UINT cursorWidth, cursorHeight;
|
|
|
|
GLuint cursorTexture;
|
2005-03-02 13:16:10 +01:00
|
|
|
|
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
|
|
|
|
2007-02-09 16:35:45 +01:00
|
|
|
/* A flag to check for proper BeginScene / EndScene call pairs */
|
|
|
|
BOOL inScene;
|
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;
|
2006-05-13 22:22:16 +02:00
|
|
|
IWineD3DSurface *ddraw_primary;
|
2006-05-18 22:42:22 +02:00
|
|
|
DWORD ddraw_width, ddraw_height;
|
|
|
|
WINED3DFORMAT ddraw_format;
|
2006-09-09 13:33:17 +02:00
|
|
|
BOOL ddraw_fullscreen;
|
2006-04-18 23:39:52 +02:00
|
|
|
|
2006-09-23 19:09:06 +02:00
|
|
|
/* Final position fixup constant */
|
|
|
|
float posFixup[4];
|
2006-12-19 13:00:03 +01:00
|
|
|
|
2006-12-19 23:33:34 +01:00
|
|
|
/* With register combiners we can skip junk texture stages */
|
|
|
|
DWORD texUnitMap[MAX_SAMPLERS];
|
|
|
|
BOOL oneToOneTexUnitMap;
|
|
|
|
|
2007-01-02 00:21:26 +01:00
|
|
|
/* Stream source management */
|
|
|
|
WineDirect3DVertexStridedData strided_streams;
|
2007-01-02 21:13:28 +01:00
|
|
|
WineDirect3DVertexStridedData *up_strided;
|
2007-01-06 18:11:21 +01:00
|
|
|
BOOL useDrawStridedSlow;
|
2007-02-14 17:56:29 +01:00
|
|
|
BOOL instancedDraw;
|
2007-01-02 00:21:26 +01:00
|
|
|
|
2007-02-12 19:18:22 +01:00
|
|
|
/* Context management */
|
2007-02-12 19:21:10 +01:00
|
|
|
WineD3DContext **contexts; /* Dynamic array containing pointers to context structures */
|
|
|
|
WineD3DContext *activeContext; /* Only 0 for now */
|
|
|
|
UINT numContexts; /* Always 1 for now */
|
|
|
|
WineD3DContext *pbufferContext; /* The context that has a pbuffer as drawable */
|
|
|
|
DWORD pbufferWidth, pbufferHeight; /* Size of the buffer drawable */
|
2007-02-12 19:18:36 +01:00
|
|
|
};
|
2004-10-07 06:22:21 +02:00
|
|
|
|
2005-06-06 21:50:35 +02:00
|
|
|
extern const IWineD3DDeviceVtbl IWineD3DDevice_Vtbl;
|
2004-10-07 06:22:21 +02:00
|
|
|
|
2006-12-19 13:00:03 +01:00
|
|
|
void IWineD3DDeviceImpl_MarkStateDirty(IWineD3DDeviceImpl *This, DWORD state);
|
2007-02-12 19:18:31 +01:00
|
|
|
static inline BOOL isStateDirty(WineD3DContext *context, DWORD state) {
|
2006-12-19 13:00:03 +01:00
|
|
|
DWORD idx = state >> 5;
|
|
|
|
BYTE shift = state & 0x1f;
|
2007-02-12 19:18:31 +01:00
|
|
|
return context->isStateDirty[idx] & (1 << shift);
|
2006-12-19 13:00:03 +01: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
|
|
|
|
2006-06-21 15:01:38 +02:00
|
|
|
/* Vertex buffer object support */
|
|
|
|
GLuint vbo;
|
|
|
|
BYTE Flags;
|
2007-01-12 19:01:59 +01:00
|
|
|
LONG bindCount;
|
2006-06-21 15:01:38 +02:00
|
|
|
|
|
|
|
UINT dirtystart, dirtyend;
|
2006-06-27 13:11:13 +02:00
|
|
|
LONG lockcount;
|
2006-06-21 15:01:38 +02:00
|
|
|
|
2006-09-23 18:02:22 +02:00
|
|
|
LONG declChanges, draws;
|
2006-06-21 15:01:38 +02:00
|
|
|
/* Last description of the buffer */
|
|
|
|
WineDirect3DVertexStridedData strided;
|
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
|
|
|
|
2006-06-21 15:01:38 +02:00
|
|
|
#define VBFLAG_LOAD 0x01 /* Data is written from allocatedMemory to the VBO */
|
|
|
|
#define VBFLAG_OPTIMIZED 0x02 /* Optimize has been called for the VB */
|
|
|
|
#define VBFLAG_DIRTY 0x04 /* Buffer data has been modified */
|
2007-01-12 19:01:59 +01:00
|
|
|
#define VBFLAG_HASDESC 0x08 /* A vertex description has been found */
|
|
|
|
#define VBFLAG_VBOCREATEFAIL 0x10 /* An attempt to create a vbo has failed */
|
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;
|
|
|
|
|
2007-02-19 15:25:32 +01:00
|
|
|
GLuint vbo;
|
|
|
|
UINT dirtystart, dirtyend;
|
|
|
|
LONG lockcount;
|
|
|
|
|
2004-11-24 19:13:41 +01:00
|
|
|
/* 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-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];
|
2006-12-19 23:26:39 +01:00
|
|
|
LONG bindCount;
|
|
|
|
DWORD sampler;
|
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;
|
|
|
|
|
2007-04-09 01:53:32 +02:00
|
|
|
typedef struct {
|
|
|
|
struct list entry;
|
|
|
|
GLuint id;
|
|
|
|
UINT width;
|
|
|
|
UINT height;
|
|
|
|
} renderbuffer_entry_t;
|
|
|
|
|
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;
|
2007-02-19 15:23:36 +01:00
|
|
|
IWineD3DPaletteImpl *palette; /* D3D7 style palette handling */
|
|
|
|
PALETTEENTRY *palette9; /* D3D8/9 style palette handling */
|
2005-01-09 18:37:02 +01:00
|
|
|
|
|
|
|
UINT bytesPerPixel;
|
2005-07-11 16:25:54 +02:00
|
|
|
|
|
|
|
/* TODO: move this off into a management class(maybe!) */
|
2006-07-23 00:03:33 +02:00
|
|
|
DWORD Flags;
|
2005-07-11 16:25:54 +02:00
|
|
|
|
|
|
|
UINT pow2Width;
|
|
|
|
UINT pow2Height;
|
|
|
|
|
2006-05-19 00:13:29 +02:00
|
|
|
/* Oversized texture */
|
|
|
|
RECT glRect;
|
|
|
|
|
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;
|
2007-01-12 18:57:26 +01:00
|
|
|
int lockCount;
|
|
|
|
#define MAXLOCKCOUNT 50 /* After this amount of locks do not free the sysmem copy */
|
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 */
|
2007-04-14 22:44:55 +02:00
|
|
|
WINEDDCOLORKEY DestBltCKey;
|
|
|
|
WINEDDCOLORKEY DestOverlayCKey;
|
|
|
|
WINEDDCOLORKEY SrcOverlayCKey;
|
|
|
|
WINEDDCOLORKEY SrcBltCKey;
|
2006-05-09 19:37:38 +02:00
|
|
|
DWORD CKeyFlags;
|
|
|
|
|
2007-04-14 22:44:55 +02:00
|
|
|
WINEDDCOLORKEY glCKey;
|
2007-04-09 01:53:32 +02:00
|
|
|
|
|
|
|
struct list renderbuffers;
|
|
|
|
renderbuffer_entry_t *current_renderbuffer;
|
2005-01-09 18:37:02 +01:00
|
|
|
};
|
|
|
|
|
2005-06-06 21:50:35 +02:00
|
|
|
extern const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl;
|
2006-05-13 22:22:16 +02:00
|
|
|
extern const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl;
|
|
|
|
|
|
|
|
/* Predeclare the shared Surface functions */
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_QueryInterface(IWineD3DSurface *iface, REFIID riid, LPVOID *ppobj);
|
|
|
|
ULONG WINAPI IWineD3DSurfaceImpl_AddRef(IWineD3DSurface *iface);
|
|
|
|
ULONG WINAPI IWineD3DSurfaceImpl_Release(IWineD3DSurface *iface);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_GetParent(IWineD3DSurface *iface, IUnknown **pParent);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_GetDevice(IWineD3DSurface *iface, IWineD3DDevice** ppDevice);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_SetPrivateData(IWineD3DSurface *iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_GetPrivateData(IWineD3DSurface *iface, REFGUID refguid, void* pData, DWORD* pSizeOfData);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_FreePrivateData(IWineD3DSurface *iface, REFGUID refguid);
|
|
|
|
DWORD WINAPI IWineD3DSurfaceImpl_SetPriority(IWineD3DSurface *iface, DWORD PriorityNew);
|
|
|
|
DWORD WINAPI IWineD3DSurfaceImpl_GetPriority(IWineD3DSurface *iface);
|
|
|
|
void WINAPI IWineD3DSurfaceImpl_PreLoad(IWineD3DSurface *iface);
|
|
|
|
WINED3DRESOURCETYPE WINAPI IWineD3DSurfaceImpl_GetType(IWineD3DSurface *iface);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_GetContainer(IWineD3DSurface* iface, REFIID riid, void** ppContainer);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_GetDesc(IWineD3DSurface *iface, WINED3DSURFACE_DESC *pDesc);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_GetBltStatus(IWineD3DSurface *iface, DWORD Flags);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_GetFlipStatus(IWineD3DSurface *iface, DWORD Flags);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_IsLost(IWineD3DSurface *iface);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_Restore(IWineD3DSurface *iface);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_SetPixelFormat(IWineD3DSurface *iface, WINED3DFORMAT Format, BYTE *Surface, DWORD Size);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_GetPalette(IWineD3DSurface *iface, IWineD3DPalette **Pal);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_SetPalette(IWineD3DSurface *iface, IWineD3DPalette *Pal);
|
2007-04-14 22:44:55 +02:00
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_SetColorKey(IWineD3DSurface *iface, DWORD Flags, WINEDDCOLORKEY *CKey);
|
2006-05-13 22:22:16 +02:00
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_CleanDirtyRect(IWineD3DSurface *iface);
|
|
|
|
extern HRESULT WINAPI IWineD3DSurfaceImpl_AddDirtyRect(IWineD3DSurface *iface, CONST RECT* pDirtyRect);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_SetContainer(IWineD3DSurface *iface, IWineD3DBase *container);
|
|
|
|
void WINAPI IWineD3DSurfaceImpl_SetGlTextureDesc(IWineD3DSurface *iface, UINT textureName, int target);
|
|
|
|
void WINAPI IWineD3DSurfaceImpl_GetGlDesc(IWineD3DSurface *iface, glDescriptor **glDescription);
|
|
|
|
const void *WINAPI IWineD3DSurfaceImpl_GetData(IWineD3DSurface *iface);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_SetFormat(IWineD3DSurface *iface, WINED3DFORMAT format);
|
2007-04-14 22:44:55 +02:00
|
|
|
HRESULT WINAPI IWineGDISurfaceImpl_Blt(IWineD3DSurface *iface, RECT *DestRect, IWineD3DSurface *SrcSurface, RECT *SrcRect, DWORD Flags, WINEDDBLTFX *DDBltFx, WINED3DTEXTUREFILTERTYPE Filter);
|
2006-05-13 22:22:16 +02:00
|
|
|
HRESULT WINAPI IWineGDISurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dstx, DWORD dsty, IWineD3DSurface *Source, RECT *rsrc, DWORD trans);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_SetPalette(IWineD3DSurface *iface, IWineD3DPalette *Pal);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_GetDC(IWineD3DSurface *iface, HDC *pHDC);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_ReleaseDC(IWineD3DSurface *iface, HDC hDC);
|
|
|
|
DWORD WINAPI IWineD3DSurfaceImpl_GetPitch(IWineD3DSurface *iface);
|
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_RealizePalette(IWineD3DSurface *iface);
|
2006-07-25 16:38:02 +02:00
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_SetMem(IWineD3DSurface *iface, void *Mem);
|
2006-10-05 16:37:42 +02:00
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_SetOverlayPosition(IWineD3DSurface *iface, LONG X, LONG Y);
|
2006-10-05 16:40:56 +02:00
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_GetOverlayPosition(IWineD3DSurface *iface, LONG *X, LONG *Y);
|
2006-10-05 16:41:19 +02:00
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_UpdateOverlayZOrder(IWineD3DSurface *iface, DWORD Flags, IWineD3DSurface *Ref);
|
2006-10-05 16:43:26 +02:00
|
|
|
HRESULT WINAPI IWineD3DSurfaceImpl_UpdateOverlay(IWineD3DSurface *iface, RECT *SrcRect, IWineD3DSurface *DstSurface, RECT *DstRect, DWORD Flags, WINEDDOVERLAYFX *FX);
|
2005-01-09 18:37:02 +01:00
|
|
|
|
2006-05-06 16:15:37 +02:00
|
|
|
/* Surface flags: */
|
2006-07-23 00:03:33 +02:00
|
|
|
#define SFLAG_OVERSIZE 0x00000001 /* Surface is bigger than gl size, blts only */
|
|
|
|
#define SFLAG_CONVERTED 0x00000002 /* Converted for color keying or Palettized */
|
|
|
|
#define SFLAG_DIBSECTION 0x00000004 /* Has a DIB section attached for getdc */
|
2007-03-06 21:47:45 +01:00
|
|
|
#define SFLAG_LOCKABLE 0x00000008 /* Surface can be locked */
|
|
|
|
#define SFLAG_DISCARD 0x00000010 /* ??? */
|
|
|
|
#define SFLAG_LOCKED 0x00000020 /* Surface is locked atm */
|
|
|
|
#define SFLAG_INTEXTURE 0x00000040 /* The GL texture contains the newest surface content */
|
|
|
|
#define SFLAG_INDRAWABLE 0x00000080 /* The gl drawable contains the most up to date data */
|
|
|
|
#define SFLAG_INSYSMEM 0x00000100 /* The system memory copy is most up to date */
|
2007-02-13 20:21:41 +01:00
|
|
|
#define SFLAG_NONPOW2 0x00000200 /* Surface sizes are not a power of 2 */
|
|
|
|
#define SFLAG_DYNLOCK 0x00000400 /* Surface is often locked by the app */
|
|
|
|
#define SFLAG_DYNCHANGE 0x00000C00 /* Surface contents are changed very often, implies DYNLOCK */
|
|
|
|
#define SFLAG_DCINUSE 0x00001000 /* Set between GetDC and ReleaseDC calls */
|
2007-03-06 21:47:45 +01:00
|
|
|
#define SFLAG_LOST 0x00002000 /* Surface lost flag for DDraw */
|
2007-03-13 03:44:22 +01:00
|
|
|
#define SFLAG_USERPTR 0x00004000 /* The application allocated the memory for this surface */
|
|
|
|
#define SFLAG_GLCKEY 0x00008000 /* The gl texture was created with a color key */
|
2007-03-31 23:02:37 +02:00
|
|
|
#define SFLAG_CLIENT 0x00010000 /* GL_APPLE_client_storage is used on that texture */
|
2007-04-22 02:02:29 +02:00
|
|
|
#define SFLAG_ALLOCATED 0x00020000 /* A gl texture is allocated for this surface */
|
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_LOCKED: The app requires access to the surface data
|
|
|
|
* SFLAG_DYNLOCK: Avoid freeing the data for performance
|
|
|
|
* SFLAG_DYNCHANGE: Same reason as DYNLOCK
|
2007-03-31 23:02:37 +02:00
|
|
|
* SFLAG_CLIENT: OpenGL uses our memory as backup
|
2006-05-06 16:15:37 +02:00
|
|
|
*/
|
|
|
|
#define SFLAG_DONOTFREE (SFLAG_OVERSIZE | \
|
|
|
|
SFLAG_CONVERTED | \
|
|
|
|
SFLAG_DIBSECTION | \
|
|
|
|
SFLAG_LOCKED | \
|
|
|
|
SFLAG_DYNLOCK | \
|
2006-07-25 16:38:02 +02:00
|
|
|
SFLAG_DYNCHANGE | \
|
2007-03-31 23:02:37 +02:00
|
|
|
SFLAG_USERPTR | \
|
|
|
|
SFLAG_CLIENT)
|
2006-05-06 16:15:37 +02:00
|
|
|
|
2006-05-23 00:48:54 +02:00
|
|
|
BOOL CalculateTexRect(IWineD3DSurfaceImpl *This, RECT *Rect, float glTexCoord[4]);
|
|
|
|
|
2006-10-05 21:36:19 +02:00
|
|
|
/* Alignment of the pitch */
|
|
|
|
#define SURFACE_ALIGNMENT 4
|
|
|
|
|
2005-01-19 20:34:49 +01:00
|
|
|
/*****************************************************************************
|
|
|
|
* IWineD3DVertexDeclaration implementation structure
|
|
|
|
*/
|
|
|
|
typedef struct IWineD3DVertexDeclarationImpl {
|
2007-03-12 23:21:54 +01:00
|
|
|
/* IUnknown Information */
|
|
|
|
const IWineD3DVertexDeclarationVtbl *lpVtbl;
|
|
|
|
LONG ref;
|
|
|
|
|
|
|
|
IUnknown *parent;
|
|
|
|
IWineD3DDeviceImpl *wineD3DDevice;
|
|
|
|
|
|
|
|
WINED3DVERTEXELEMENT *pDeclarationWine;
|
|
|
|
UINT declarationWNumElements;
|
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];
|
2006-06-27 23:40:42 +02:00
|
|
|
BOOL textures[MAX_SAMPLERS];
|
2005-07-05 16:05:18 +02:00
|
|
|
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;
|
2006-07-19 06:06:07 +02:00
|
|
|
BOOL pixelShaderConstantsB[MAX_CONST_B];
|
|
|
|
BOOL pixelShaderConstantsI[MAX_CONST_I];
|
|
|
|
BOOL *pixelShaderConstantsF;
|
2005-07-05 16:05:18 +02:00
|
|
|
BOOL vertexShader;
|
2006-07-19 06:06:07 +02:00
|
|
|
BOOL vertexShaderConstantsB[MAX_CONST_B];
|
|
|
|
BOOL vertexShaderConstantsI[MAX_CONST_I];
|
|
|
|
BOOL *vertexShaderConstantsF;
|
2007-01-10 11:28:42 +01:00
|
|
|
BOOL scissorRect;
|
2004-10-21 22:59:12 +02:00
|
|
|
} SAVEDSTATES;
|
|
|
|
|
2006-08-19 17:24:02 +02:00
|
|
|
typedef struct {
|
2007-02-27 20:51:58 +01:00
|
|
|
struct list entry;
|
|
|
|
DWORD count;
|
|
|
|
DWORD idx[13];
|
|
|
|
} constants_entry;
|
2006-08-19 17:24:02 +02:00
|
|
|
|
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;
|
2006-08-19 17:24:02 +02:00
|
|
|
struct list set_vconstantsF;
|
|
|
|
struct list set_pconstantsF;
|
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 */
|
2006-07-19 06:06:07 +02:00
|
|
|
BOOL vertexShaderConstantB[MAX_CONST_B];
|
|
|
|
INT vertexShaderConstantI[MAX_CONST_I * 4];
|
|
|
|
float *vertexShaderConstantF;
|
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];
|
2006-10-31 09:19:13 +01:00
|
|
|
UINT streamFlags[MAX_STREAMS]; /*0 | WINED3DSTREAMSOURCE_INSTANCEDATA | WINED3DSTREAMSOURCE_INDEXEDDATA */
|
2004-11-28 16:04:41 +01:00
|
|
|
|
2004-12-09 12:42:34 +01:00
|
|
|
/* Indices */
|
|
|
|
IWineD3DIndexBuffer* pIndexData;
|
2007-01-06 18:19:55 +01:00
|
|
|
UINT baseVertexIndex;
|
|
|
|
UINT loadBaseVertexIndex; /* non-indexed drawing needs 0 here, indexed baseVertexIndex */
|
2004-12-09 12:42:34 +01:00
|
|
|
|
2004-11-28 16:04:41 +01:00
|
|
|
/* Transform */
|
2006-10-12 08:21:39 +02:00
|
|
|
WINED3DMATRIX transforms[HIGHEST_TRANSFORMSTATE + 1];
|
2004-11-28 16:04:41 +01:00
|
|
|
|
2007-02-14 17:46:54 +01:00
|
|
|
/* Light hashmap . Collisions are handled using standard wine double linked lists */
|
|
|
|
#define LIGHTMAP_SIZE 43 /* Use of a prime number recommended. Set to 1 for a linked list! */
|
|
|
|
#define LIGHTMAP_HASHFUNC(x) ((x) % LIGHTMAP_SIZE) /* Primitive and simple function */
|
|
|
|
struct list lightMap[LIGHTMAP_SIZE]; /* Mashmap containing the lights */
|
|
|
|
PLIGHTINFOEL *activeLights[MAX_ACTIVE_LIGHTS]; /* Map of opengl lights to d3d lights */
|
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 */
|
2006-07-19 06:06:07 +02:00
|
|
|
BOOL pixelShaderConstantB[MAX_CONST_B];
|
|
|
|
INT pixelShaderConstantI[MAX_CONST_I * 4];
|
|
|
|
float *pixelShaderConstantF;
|
2005-07-05 16:05:18 +02:00
|
|
|
|
2004-12-13 14:35:38 +01:00
|
|
|
/* 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 */
|
2006-06-27 23:40:42 +02:00
|
|
|
IWineD3DBaseTexture *textures[MAX_SAMPLERS];
|
2005-07-05 16:05:18 +02:00
|
|
|
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];
|
2006-12-19 23:00:58 +01:00
|
|
|
DWORD lowest_disabled_stage;
|
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
|
|
|
|
2006-06-08 10:00:23 +02:00
|
|
|
/* Current GLSL Shader Program */
|
2006-08-19 17:23:20 +02:00
|
|
|
struct glsl_shader_prog_link *glsl_program;
|
2007-01-10 11:28:42 +01:00
|
|
|
|
|
|
|
/* Scissor test rectangle */
|
|
|
|
RECT scissorRect;
|
2004-10-21 22:59:12 +02:00
|
|
|
};
|
|
|
|
|
2006-07-23 21:08:27 +02:00
|
|
|
extern void stateblock_savedstates_set(
|
|
|
|
IWineD3DStateBlock* iface,
|
|
|
|
SAVEDSTATES* states,
|
|
|
|
BOOL value);
|
|
|
|
|
|
|
|
extern void stateblock_savedstates_copy(
|
|
|
|
IWineD3DStateBlock* iface,
|
|
|
|
SAVEDSTATES* dest,
|
|
|
|
SAVEDSTATES* source);
|
|
|
|
|
|
|
|
extern void stateblock_copy(
|
|
|
|
IWineD3DStateBlock* destination,
|
|
|
|
IWineD3DStateBlock* source);
|
|
|
|
|
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
|
|
|
|
|
2006-10-11 03:53:30 +02:00
|
|
|
/* IWineD3DQuery fields */
|
|
|
|
WINED3DQUERYTYPE 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 {
|
2006-07-25 00:51:33 +02:00
|
|
|
GLuint queryId;
|
2005-09-21 11:43:13 +02:00
|
|
|
} WineQueryOcclusionData;
|
|
|
|
|
2007-03-01 00:34:33 +01:00
|
|
|
typedef struct WineQueryEventData {
|
|
|
|
GLuint fenceId;
|
|
|
|
} WineQueryEventData;
|
2005-09-21 11:43:13 +02:00
|
|
|
|
2005-06-23 13:05:24 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
* IWineD3DSwapChainImpl implementation structure (extends IUnknown)
|
|
|
|
*/
|
|
|
|
|
|
|
|
typedef struct IWineD3DSwapChainImpl
|
|
|
|
{
|
|
|
|
/*IUnknown part*/
|
2006-12-14 15:47:59 +01:00
|
|
|
const 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 */
|
2006-06-15 12:54:19 +02:00
|
|
|
IWineD3DSurface **backBuffer;
|
2005-06-23 13:05:24 +02:00
|
|
|
IWineD3DSurface *frontBuffer;
|
|
|
|
BOOL wantsDepthStencilBuffer;
|
2007-02-15 22:36:50 +01:00
|
|
|
WINED3DPRESENT_PARAMETERS presentParms;
|
2006-12-08 16:13:15 +01:00
|
|
|
DWORD orig_width, orig_height;
|
2007-02-15 13:53:33 +01:00
|
|
|
WINED3DFORMAT orig_fmt;
|
2005-06-23 13:05:24 +02:00
|
|
|
|
2007-01-10 11:27:26 +01:00
|
|
|
long prev_time, frames; /* Performance tracking */
|
|
|
|
|
2007-03-04 17:31:06 +01:00
|
|
|
WineD3DContext **context; /* Later a array for multithreading */
|
|
|
|
unsigned int num_contexts;
|
2005-06-23 13:05:24 +02:00
|
|
|
|
|
|
|
HWND win_handle;
|
|
|
|
Window win;
|
|
|
|
} IWineD3DSwapChainImpl;
|
|
|
|
|
2006-12-14 15:47:59 +01:00
|
|
|
extern const IWineD3DSwapChainVtbl IWineD3DSwapChain_Vtbl;
|
2005-06-23 13:05:24 +02:00
|
|
|
|
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);
|
2006-10-11 03:52:00 +02:00
|
|
|
const char* debug_d3ddevicetype(WINED3DDEVTYPE 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);
|
2006-07-28 21:33:20 +02:00
|
|
|
const char* debug_d3dusagequery(DWORD usagequery);
|
2006-08-07 19:21:54 +02:00
|
|
|
const char* debug_d3ddeclmethod(WINED3DDECLMETHOD method);
|
|
|
|
const char* debug_d3ddecltype(WINED3DDECLTYPE type);
|
2006-07-03 08:11:15 +02:00
|
|
|
const char* debug_d3ddeclusage(BYTE usage);
|
2006-10-12 08:23:55 +02:00
|
|
|
const char* debug_d3dprimitivetype(WINED3DPRIMITIVETYPE PrimitiveType);
|
2004-12-13 14:35:38 +01:00
|
|
|
const char* debug_d3drenderstate(DWORD state);
|
2006-06-09 23:47:16 +02:00
|
|
|
const char* debug_d3dsamplerstate(DWORD state);
|
2007-04-09 01:53:38 +02:00
|
|
|
const char* debug_d3dtexturefiltertype(WINED3DTEXTUREFILTERTYPE filter_type);
|
2004-12-13 14:35:38 +01:00
|
|
|
const char* debug_d3dtexturestate(DWORD state);
|
2006-07-24 04:54:30 +02:00
|
|
|
const char* debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype);
|
2006-03-28 14:20:47 +02:00
|
|
|
const char* debug_d3dpool(WINED3DPOOL pool);
|
2007-04-16 21:19:12 +02:00
|
|
|
const char *debug_fbostatus(GLenum status);
|
2007-04-23 22:02:50 +02:00
|
|
|
const char *debug_glerror(GLenum error);
|
2004-12-13 14:35:38 +01:00
|
|
|
|
|
|
|
/* Routines for GL <-> D3D values */
|
|
|
|
GLenum StencilOp(DWORD op);
|
2006-08-25 16:28:34 +02:00
|
|
|
GLenum CompareFunc(DWORD func);
|
2006-10-13 05:33:03 +02:00
|
|
|
void set_tex_op(IWineD3DDevice *iface, BOOL isAlpha, int Stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3);
|
|
|
|
void set_tex_op_nvrc(IWineD3DDevice *iface, BOOL is_alpha, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3, INT texture_idx);
|
2005-07-26 22:01:29 +02:00
|
|
|
void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords);
|
2004-09-28 04:12:12 +02:00
|
|
|
|
2007-04-09 01:53:32 +02:00
|
|
|
void surface_set_compatible_renderbuffer(IWineD3DSurface *iface, unsigned int width, unsigned int height);
|
2007-04-16 21:20:25 +02:00
|
|
|
GLenum surface_get_gl_buffer(IWineD3DSurface *iface, IWineD3DSwapChain *swapchain);
|
2007-04-09 01:53:32 +02:00
|
|
|
|
2006-10-11 03:51:13 +02:00
|
|
|
int D3DFmtMakeGlCfg(WINED3DFORMAT BackBufferFormat, WINED3DFORMAT StencilBufferFormat, int *attribs, int* nAttribs, BOOL alternate);
|
2005-07-07 22:35:05 +02:00
|
|
|
|
2006-05-12 22:21:31 +02:00
|
|
|
/* Math utils */
|
2006-11-24 15:15:06 +01:00
|
|
|
void multiply_matrix(WINED3DMATRIX *dest, const WINED3DMATRIX *src1, const WINED3DMATRIX *src2);
|
2005-07-07 22:35:05 +02:00
|
|
|
|
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
|
|
|
|
2006-06-21 15:01:38 +02:00
|
|
|
extern BYTE* WINAPI IWineD3DVertexBufferImpl_GetMemory(IWineD3DVertexBuffer* iface, DWORD iOffset, GLint *vbo);
|
2005-07-24 19:11:33 +02:00
|
|
|
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
|
|
|
|
2006-05-10 00:05:26 +02:00
|
|
|
struct SHADER_OPCODE_ARG;
|
|
|
|
typedef void (*SHADER_HANDLER) (struct SHADER_OPCODE_ARG*);
|
|
|
|
|
2006-06-09 09:33:01 +02:00
|
|
|
/* Struct to maintain a list of GLSL shader programs and their associated pixel and
|
|
|
|
* vertex shaders. A list of this type is maintained on the DeviceImpl, and is only
|
|
|
|
* used if the user is using GLSL shaders. */
|
|
|
|
struct glsl_shader_prog_link {
|
2007-02-27 20:51:53 +01:00
|
|
|
struct list vshader_entry;
|
|
|
|
struct list pshader_entry;
|
2006-06-09 09:33:01 +02:00
|
|
|
GLhandleARB programId;
|
2006-08-19 17:23:20 +02:00
|
|
|
GLhandleARB *vuniformF_locations;
|
|
|
|
GLhandleARB *puniformF_locations;
|
2007-02-27 20:51:53 +01:00
|
|
|
GLhandleARB vshader;
|
|
|
|
GLhandleARB pshader;
|
2006-06-09 09:33:01 +02:00
|
|
|
};
|
|
|
|
|
2007-02-27 20:51:53 +01:00
|
|
|
typedef struct {
|
|
|
|
GLhandleARB vshader;
|
|
|
|
GLhandleARB pshader;
|
|
|
|
} glsl_program_key_t;
|
|
|
|
|
2006-06-12 08:55:30 +02:00
|
|
|
/* TODO: Make this dynamic, based on shader limits ? */
|
|
|
|
#define MAX_REG_ADDR 1
|
|
|
|
#define MAX_REG_TEMP 32
|
|
|
|
#define MAX_REG_TEXCRD 8
|
2006-06-12 08:57:07 +02:00
|
|
|
#define MAX_REG_INPUT 12
|
|
|
|
#define MAX_REG_OUTPUT 12
|
2006-06-12 08:55:30 +02:00
|
|
|
#define MAX_ATTRIBS 16
|
2006-06-16 22:07:31 +02:00
|
|
|
#define MAX_CONST_I 16
|
|
|
|
#define MAX_CONST_B 16
|
2006-06-12 08:55:30 +02:00
|
|
|
|
2006-07-10 12:35:15 +02:00
|
|
|
/* FIXME: This needs to go up to 2048 for
|
|
|
|
* Shader model 3 according to msdn (and for software shaders) */
|
|
|
|
#define MAX_LABELS 16
|
|
|
|
|
2006-07-07 08:27:38 +02:00
|
|
|
typedef struct semantic {
|
|
|
|
DWORD usage;
|
|
|
|
DWORD reg;
|
|
|
|
} semantic;
|
|
|
|
|
2006-07-10 06:51:03 +02:00
|
|
|
typedef struct local_constant {
|
|
|
|
struct list entry;
|
|
|
|
unsigned int idx;
|
|
|
|
DWORD value[4];
|
|
|
|
} local_constant;
|
|
|
|
|
2006-06-09 09:33:01 +02:00
|
|
|
typedef struct shader_reg_maps {
|
2006-06-12 08:53:32 +02:00
|
|
|
|
2006-06-12 08:55:30 +02:00
|
|
|
char texcoord[MAX_REG_TEXCRD]; /* pixel < 3.0 */
|
|
|
|
char temporary[MAX_REG_TEMP]; /* pixel, vertex */
|
|
|
|
char address[MAX_REG_ADDR]; /* vertex */
|
2006-06-12 08:57:07 +02:00
|
|
|
char packed_input[MAX_REG_INPUT]; /* pshader >= 3.0 */
|
|
|
|
char packed_output[MAX_REG_OUTPUT]; /* vertex >= 3.0 */
|
2006-06-12 08:55:30 +02:00
|
|
|
char attributes[MAX_ATTRIBS]; /* vertex */
|
2006-07-10 12:35:15 +02:00
|
|
|
char labels[MAX_LABELS]; /* pixel, vertex */
|
2006-06-12 08:55:30 +02:00
|
|
|
|
2006-06-12 08:59:16 +02:00
|
|
|
/* Sampler usage tokens
|
|
|
|
* Use 0 as default (bit 31 is always 1 on a valid token) */
|
|
|
|
DWORD samplers[MAX_SAMPLERS];
|
2007-02-15 03:05:17 +01:00
|
|
|
char bumpmat;
|
2006-06-12 08:59:16 +02:00
|
|
|
|
2006-06-14 04:32:14 +02:00
|
|
|
/* Whether or not a loop is used in this shader */
|
|
|
|
char loop;
|
|
|
|
|
2006-07-17 07:41:53 +02:00
|
|
|
/* Whether or not this shader uses fog */
|
|
|
|
char fog;
|
|
|
|
|
2006-06-09 09:33:01 +02:00
|
|
|
} shader_reg_maps;
|
|
|
|
|
2006-05-10 00:05:26 +02:00
|
|
|
#define SHADER_PGMSIZE 65535
|
|
|
|
typedef struct SHADER_BUFFER {
|
|
|
|
char* buffer;
|
2006-06-13 14:14:20 +02:00
|
|
|
unsigned int bsize;
|
2006-05-10 00:05:26 +02:00
|
|
|
unsigned int lineNo;
|
2007-01-15 19:30:41 +01:00
|
|
|
BOOL newline;
|
2006-05-10 00:05:26 +02:00
|
|
|
} SHADER_BUFFER;
|
2006-03-28 21:10:32 +02:00
|
|
|
|
wined3d: More flow control instructions
- Implement if, else, endif, rep, endrep, break
- Implement ifc, breakc, using undocumented comparison bits in the instruction token
- Fix bug in main loop processing of codes with no dst token
- Fix bug in GLSL output modifier processing of codes with no dst token
- Fix bug in loop implementation (src1 contains the integer data, src0 is aL)
- Add versioning for all the instructions above, and remove
GLSL_REQUIRED thing, which is useless and should be removed from all
opcodes in general.
2006-07-10 11:11:35 +02:00
|
|
|
/* Undocumented opcode controls */
|
|
|
|
#define INST_CONTROLS_SHIFT 16
|
|
|
|
#define INST_CONTROLS_MASK 0x00ff0000
|
|
|
|
|
|
|
|
typedef enum COMPARISON_TYPE {
|
|
|
|
COMPARISON_GT = 1,
|
|
|
|
COMPARISON_EQ = 2,
|
|
|
|
COMPARISON_GE = 3,
|
|
|
|
COMPARISON_LT = 4,
|
|
|
|
COMPARISON_NE = 5,
|
|
|
|
COMPARISON_LE = 6
|
|
|
|
} COMPARISON_TYPE;
|
|
|
|
|
2006-03-28 21:10:32 +02:00
|
|
|
typedef struct SHADER_OPCODE {
|
|
|
|
unsigned int opcode;
|
|
|
|
const char* name;
|
|
|
|
const char* glname;
|
2006-06-12 12:57:04 +02:00
|
|
|
char dst_token;
|
2006-03-28 21:10:32 +02:00
|
|
|
CONST UINT num_params;
|
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;
|
2006-06-09 09:33:01 +02:00
|
|
|
shader_reg_maps* reg_maps;
|
2006-05-10 00:05:26 +02:00
|
|
|
CONST SHADER_OPCODE* opcode;
|
wined3d: More flow control instructions
- Implement if, else, endif, rep, endrep, break
- Implement ifc, breakc, using undocumented comparison bits in the instruction token
- Fix bug in main loop processing of codes with no dst token
- Fix bug in GLSL output modifier processing of codes with no dst token
- Fix bug in loop implementation (src1 contains the integer data, src0 is aL)
- Add versioning for all the instructions above, and remove
GLSL_REQUIRED thing, which is useless and should be removed from all
opcodes in general.
2006-07-10 11:11:35 +02:00
|
|
|
DWORD opcode_token;
|
2006-05-10 00:05:26 +02:00
|
|
|
DWORD dst;
|
2006-05-17 08:04:30 +02:00
|
|
|
DWORD dst_addr;
|
2006-05-18 03:09:56 +02:00
|
|
|
DWORD predicate;
|
2006-05-10 00:05:26 +02:00
|
|
|
DWORD src[4];
|
2006-05-17 08:04:30 +02:00
|
|
|
DWORD src_addr[4];
|
2006-05-10 00:05:26 +02:00
|
|
|
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;
|
2006-06-12 08:59:16 +02:00
|
|
|
unsigned int texcoord;
|
|
|
|
unsigned int sampler;
|
2006-05-08 23:09:21 +02:00
|
|
|
unsigned int constant_int;
|
|
|
|
unsigned int constant_float;
|
|
|
|
unsigned int constant_bool;
|
|
|
|
unsigned int address;
|
2006-06-12 08:57:07 +02:00
|
|
|
unsigned int packed_output;
|
|
|
|
unsigned int packed_input;
|
2006-05-26 17:52:33 +02:00
|
|
|
unsigned int attributes;
|
2006-07-10 12:35:15 +02:00
|
|
|
unsigned int label;
|
2006-05-08 23:09:21 +02:00
|
|
|
} 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-07-10 06:51:03 +02:00
|
|
|
extern void shader_delete_constant_list(
|
|
|
|
struct list* clist);
|
|
|
|
|
2007-02-27 20:51:53 +01:00
|
|
|
void delete_glsl_program_entry(IWineD3DDevice *iface, struct glsl_shader_prog_link *entry);
|
|
|
|
|
2006-07-07 08:27:38 +02:00
|
|
|
/* Vertex shader utility functions */
|
|
|
|
extern BOOL vshader_get_input(
|
|
|
|
IWineD3DVertexShader* iface,
|
|
|
|
BYTE usage_req, BYTE usage_idx_req,
|
|
|
|
unsigned int* regnum);
|
|
|
|
|
|
|
|
extern BOOL vshader_input_is_color(
|
|
|
|
IWineD3DVertexShader* iface,
|
|
|
|
unsigned int regnum);
|
|
|
|
|
2006-07-19 06:06:07 +02:00
|
|
|
extern HRESULT allocate_shader_constants(IWineD3DStateBlockImpl* object);
|
|
|
|
|
2006-06-16 22:07:00 +02:00
|
|
|
/* ARB_[vertex/fragment]_program helper functions */
|
|
|
|
extern void shader_arb_load_constants(
|
2006-09-27 13:15:58 +02:00
|
|
|
IWineD3DDevice* device,
|
2006-06-16 22:07:00 +02:00
|
|
|
char usePixelShader,
|
|
|
|
char useVertexShader);
|
|
|
|
|
2006-06-09 09:33:33 +02:00
|
|
|
/* ARB shader program Prototypes */
|
|
|
|
extern void shader_hw_def(SHADER_OPCODE_ARG *arg);
|
|
|
|
|
2006-07-03 03:27:15 +02:00
|
|
|
/* ARB pixel shader prototypes */
|
2007-03-26 23:34:32 +02:00
|
|
|
extern void pshader_hw_bem(SHADER_OPCODE_ARG* arg);
|
2006-07-03 03:27:15 +02:00
|
|
|
extern void pshader_hw_cnd(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_hw_cmp(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_hw_map2gl(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_hw_tex(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_hw_texcoord(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_hw_texreg2ar(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_hw_texreg2gb(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_hw_texbem(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_hw_texm3x2pad(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_hw_texm3x2tex(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_hw_texm3x3pad(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_hw_texm3x3tex(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_hw_texm3x3spec(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_hw_texm3x3vspec(SHADER_OPCODE_ARG* arg);
|
|
|
|
|
|
|
|
/* ARB vertex shader prototypes */
|
|
|
|
extern void vshader_hw_map2gl(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void vshader_hw_mnxn(SHADER_OPCODE_ARG* arg);
|
2007-02-15 13:50:59 +01:00
|
|
|
extern void vshader_hw_rsq_rcp(SHADER_OPCODE_ARG* arg);
|
2006-07-03 03:27:15 +02:00
|
|
|
|
2006-06-14 04:32:14 +02:00
|
|
|
/* GLSL helper functions */
|
|
|
|
extern void shader_glsl_add_instruction_modifiers(SHADER_OPCODE_ARG *arg);
|
2006-06-16 22:07:00 +02:00
|
|
|
extern void shader_glsl_load_constants(
|
2006-09-27 13:15:58 +02:00
|
|
|
IWineD3DDevice* device,
|
2006-06-16 22:07:00 +02:00
|
|
|
char usePixelShader,
|
|
|
|
char useVertexShader);
|
2006-06-09 09:37:45 +02:00
|
|
|
|
2006-06-09 09:35:15 +02:00
|
|
|
/** The following translate DirectX pixel/vertex shader opcodes to GLSL lines */
|
2007-01-15 19:31:56 +01:00
|
|
|
extern void shader_glsl_cross(SHADER_OPCODE_ARG* arg);
|
2006-06-09 09:35:15 +02:00
|
|
|
extern void shader_glsl_map2gl(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_arith(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_mov(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_mad(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_mnxn(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_lrp(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_dot(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_rcp(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_cnd(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_compare(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_def(SHADER_OPCODE_ARG* arg);
|
2006-06-16 22:08:00 +02:00
|
|
|
extern void shader_glsl_defi(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_defb(SHADER_OPCODE_ARG* arg);
|
2006-07-28 10:14:14 +02:00
|
|
|
extern void shader_glsl_expp(SHADER_OPCODE_ARG* arg);
|
2006-06-09 09:35:15 +02:00
|
|
|
extern void shader_glsl_cmp(SHADER_OPCODE_ARG* arg);
|
2006-06-14 04:32:14 +02:00
|
|
|
extern void shader_glsl_lit(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_dst(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_sincos(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_loop(SHADER_OPCODE_ARG* arg);
|
wined3d: More flow control instructions
- Implement if, else, endif, rep, endrep, break
- Implement ifc, breakc, using undocumented comparison bits in the instruction token
- Fix bug in main loop processing of codes with no dst token
- Fix bug in GLSL output modifier processing of codes with no dst token
- Fix bug in loop implementation (src1 contains the integer data, src0 is aL)
- Add versioning for all the instructions above, and remove
GLSL_REQUIRED thing, which is useless and should be removed from all
opcodes in general.
2006-07-10 11:11:35 +02:00
|
|
|
extern void shader_glsl_end(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_if(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_ifc(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_else(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_break(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_breakc(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_rep(SHADER_OPCODE_ARG* arg);
|
2006-07-10 12:35:15 +02:00
|
|
|
extern void shader_glsl_call(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_callnz(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void shader_glsl_label(SHADER_OPCODE_ARG* arg);
|
2006-06-12 08:57:07 +02:00
|
|
|
|
2006-06-09 09:35:15 +02:00
|
|
|
/** GLSL Pixel Shader Prototypes */
|
|
|
|
extern void pshader_glsl_tex(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_glsl_texcoord(SHADER_OPCODE_ARG* arg);
|
2006-07-28 10:14:14 +02:00
|
|
|
extern void pshader_glsl_texdp3tex(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_glsl_texdp3(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_glsl_texdepth(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_glsl_texm3x2depth(SHADER_OPCODE_ARG* arg);
|
2006-06-09 09:35:15 +02:00
|
|
|
extern void pshader_glsl_texm3x2pad(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_glsl_texm3x2tex(SHADER_OPCODE_ARG* arg);
|
2006-07-28 10:14:14 +02:00
|
|
|
extern void pshader_glsl_texm3x3(SHADER_OPCODE_ARG* arg);
|
2006-06-27 08:00:02 +02:00
|
|
|
extern void pshader_glsl_texm3x3pad(SHADER_OPCODE_ARG* arg);
|
2006-07-25 04:52:38 +02:00
|
|
|
extern void pshader_glsl_texm3x3tex(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_glsl_texm3x3spec(SHADER_OPCODE_ARG* arg);
|
2006-06-27 08:00:02 +02:00
|
|
|
extern void pshader_glsl_texm3x3vspec(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_glsl_texkill(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_glsl_texbem(SHADER_OPCODE_ARG* arg);
|
2007-03-26 23:34:32 +02:00
|
|
|
extern void pshader_glsl_bem(SHADER_OPCODE_ARG* arg);
|
2006-07-25 04:52:38 +02:00
|
|
|
extern void pshader_glsl_texreg2ar(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_glsl_texreg2gb(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_glsl_texreg2rgb(SHADER_OPCODE_ARG* arg);
|
2006-06-27 08:00:02 +02:00
|
|
|
extern void pshader_glsl_dp2add(SHADER_OPCODE_ARG* arg);
|
2006-06-12 08:57:07 +02:00
|
|
|
extern void pshader_glsl_input_pack(
|
|
|
|
SHADER_BUFFER* buffer,
|
2006-07-07 08:27:38 +02:00
|
|
|
semantic* semantics_out);
|
2006-06-12 08:57:07 +02:00
|
|
|
|
|
|
|
/** GLSL Vertex Shader Prototypes */
|
|
|
|
extern void vshader_glsl_output_unpack(
|
|
|
|
SHADER_BUFFER* buffer,
|
2006-07-07 08:27:38 +02:00
|
|
|
semantic* semantics_out);
|
2006-06-09 09:35:15 +02:00
|
|
|
|
2006-03-30 19:14:31 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
* IDirect3DBaseShader implementation structure
|
|
|
|
*/
|
|
|
|
typedef struct IWineD3DBaseShaderClass
|
|
|
|
{
|
2006-05-08 23:09:21 +02:00
|
|
|
DWORD hex_version;
|
|
|
|
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;
|
2006-08-05 18:15:35 +02:00
|
|
|
BOOL is_compiled;
|
wined3d: Rework shader mode selection.
- currently half the shader selection code (GLSL vs ARB) is in
fillGLcaps. The parts that check for software shaders are in
GetDeviceCaps. That placement, will work, but is definitely not optimal.
FillGLcaps should detect support - it should not make decision as to
what's used, because that's not what the purpose of the function is.
GetDeviceCaps should report support as it has already been selected.
Instead, select shader mode in its own function, called in the
appropriate places.
- unifying pixel and vertex shaders into a single selection is a
mistake. A software vertex shader can be coupled with a hardware arb or
glsl pixel shader, or no shader at all. Split them back into two and add
a SHADER_NONE variant.
- drawprim is doing support checks for ARB_PROGRAM, and making shader
decisions based on that - that's wrong, support has already been
checked, and decided upon, and shaders can be implemented via software,
ARB_PROGRAm or GLSL, so that support check isn't valid.
- Store the shader selected mode into the shader itself. Different types
of shaders can be combined, so this is an improvement. In fact, storing
the mode into the settings globally is a mistake as well - it should be
done per device, since different cards have different capabilities.
2006-07-04 09:21:53 +02:00
|
|
|
|
|
|
|
/* Type of shader backend */
|
|
|
|
int shader_mode;
|
|
|
|
|
2007-02-27 20:51:53 +01:00
|
|
|
/* Programs this shader is linked with */
|
|
|
|
struct list linked_programs;
|
|
|
|
|
2006-07-10 06:51:03 +02:00
|
|
|
/* Immediate constants (override global ones) */
|
|
|
|
struct list constantsB;
|
|
|
|
struct list constantsF;
|
|
|
|
struct list constantsI;
|
2006-08-05 18:15:35 +02:00
|
|
|
shader_reg_maps reg_maps;
|
2006-07-10 06:51:03 +02:00
|
|
|
|
2006-09-27 13:14:46 +02:00
|
|
|
/* Pointer to the parent device */
|
|
|
|
IWineD3DDevice *device;
|
|
|
|
|
2006-03-30 19:14:31 +02:00
|
|
|
} IWineD3DBaseShaderClass;
|
|
|
|
|
|
|
|
typedef struct IWineD3DBaseShaderImpl {
|
|
|
|
/* IUnknown */
|
|
|
|
const IWineD3DBaseShaderVtbl *lpVtbl;
|
|
|
|
LONG ref;
|
|
|
|
|
|
|
|
/* IWineD3DBaseShader */
|
|
|
|
IWineD3DBaseShaderClass baseShader;
|
|
|
|
} IWineD3DBaseShaderImpl;
|
|
|
|
|
2006-07-10 06:51:03 +02:00
|
|
|
extern HRESULT shader_get_registers_used(
|
2006-06-12 08:53:32 +02:00
|
|
|
IWineD3DBaseShader *iface,
|
|
|
|
shader_reg_maps* reg_maps,
|
2006-07-07 08:27:38 +02:00
|
|
|
semantic* semantics_in,
|
|
|
|
semantic* semantics_out,
|
2006-08-27 19:16:01 +02:00
|
|
|
CONST DWORD* pToken,
|
|
|
|
IWineD3DStateBlockImpl *stateBlock);
|
2006-06-12 08:53:32 +02:00
|
|
|
|
2006-06-12 08:55:30 +02:00
|
|
|
extern void shader_generate_glsl_declarations(
|
|
|
|
IWineD3DBaseShader *iface,
|
|
|
|
shader_reg_maps* reg_maps,
|
2006-07-19 06:06:07 +02:00
|
|
|
SHADER_BUFFER* buffer,
|
|
|
|
WineD3D_GL_Info* gl_info);
|
2006-06-12 08:55:30 +02:00
|
|
|
|
|
|
|
extern void shader_generate_arb_declarations(
|
|
|
|
IWineD3DBaseShader *iface,
|
|
|
|
shader_reg_maps* reg_maps,
|
2006-07-19 06:06:07 +02:00
|
|
|
SHADER_BUFFER* buffer,
|
|
|
|
WineD3D_GL_Info* gl_info);
|
2006-06-12 08:55:30 +02:00
|
|
|
|
2006-06-12 08:53:32 +02:00
|
|
|
extern void shader_generate_main(
|
2006-05-10 04:33:24 +02:00
|
|
|
IWineD3DBaseShader *iface,
|
|
|
|
SHADER_BUFFER* buffer,
|
2006-06-12 08:53:32 +02:00
|
|
|
shader_reg_maps* reg_maps,
|
2006-05-10 04:33:24 +02:00
|
|
|
CONST DWORD* pFunction);
|
|
|
|
|
2006-05-10 19:53:07 +02:00
|
|
|
extern void shader_dump_ins_modifiers(
|
|
|
|
const DWORD output);
|
|
|
|
|
2006-05-14 15:43:31 +02:00
|
|
|
extern void shader_dump_param(
|
|
|
|
IWineD3DBaseShader *iface,
|
|
|
|
const DWORD param,
|
2006-05-17 08:05:49 +02:00
|
|
|
const DWORD addr_token,
|
2006-05-14 15:43:31 +02:00
|
|
|
int input);
|
|
|
|
|
2006-06-12 08:54:30 +02:00
|
|
|
extern void shader_trace_init(
|
|
|
|
IWineD3DBaseShader *iface,
|
|
|
|
const DWORD* pFunction);
|
|
|
|
|
2006-05-17 08:02:36 +02:00
|
|
|
extern int shader_get_param(
|
|
|
|
IWineD3DBaseShader* iface,
|
|
|
|
const DWORD* pToken,
|
|
|
|
DWORD* param,
|
|
|
|
DWORD* addr_token);
|
|
|
|
|
|
|
|
extern int shader_skip_unrecognized(
|
|
|
|
IWineD3DBaseShader* iface,
|
|
|
|
const DWORD* pToken);
|
|
|
|
|
2006-05-24 00:22:13 +02:00
|
|
|
extern void print_glsl_info_log(
|
|
|
|
WineD3D_GL_Info *gl_info,
|
|
|
|
GLhandleARB obj);
|
|
|
|
|
2007-03-17 11:39:40 +01:00
|
|
|
static inline int shader_get_regtype(const DWORD param) {
|
2006-10-10 01:47:12 +02:00
|
|
|
return (((param & WINED3DSP_REGTYPE_MASK) >> WINED3DSP_REGTYPE_SHIFT) |
|
|
|
|
((param & WINED3DSP_REGTYPE_MASK2) >> WINED3DSP_REGTYPE_SHIFT2));
|
2006-04-28 11:20:48 +02:00
|
|
|
}
|
|
|
|
|
2006-06-06 08:40:08 +02:00
|
|
|
extern unsigned int shader_get_float_offset(const DWORD reg);
|
|
|
|
|
2007-03-17 11:39:40 +01:00
|
|
|
static inline BOOL shader_is_pshader_version(DWORD token) {
|
2006-05-14 15:43:31 +02:00
|
|
|
return 0xFFFF0000 == (token & 0xFFFF0000);
|
|
|
|
}
|
|
|
|
|
2007-03-17 11:39:40 +01:00
|
|
|
static inline BOOL shader_is_vshader_version(DWORD token) {
|
2006-05-14 15:43:31 +02:00
|
|
|
return 0xFFFE0000 == (token & 0xFFFF0000);
|
|
|
|
}
|
|
|
|
|
2007-03-17 11:39:40 +01:00
|
|
|
static inline BOOL shader_is_comment(DWORD token) {
|
2006-10-13 05:34:13 +02:00
|
|
|
return WINED3DSIO_COMMENT == (token & WINED3DSI_OPCODE_MASK);
|
2006-05-14 15:43:31 +02:00
|
|
|
}
|
|
|
|
|
2007-04-12 23:55:31 +02:00
|
|
|
/* TODO: vFace (ps_3_0) */
|
|
|
|
static inline BOOL shader_is_scalar(DWORD param) {
|
|
|
|
DWORD reg_type = shader_get_regtype(param);
|
|
|
|
|
|
|
|
switch (reg_type) {
|
|
|
|
case WINED3DSPR_RASTOUT:
|
|
|
|
if ((param & WINED3DSP_REGNUM_MASK) != 0) {
|
|
|
|
/* oFog & oPts */
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
/* oPos */
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
case WINED3DSPR_DEPTHOUT: /* oDepth */
|
|
|
|
case WINED3DSPR_CONSTBOOL: /* b# */
|
|
|
|
case WINED3DSPR_LOOP: /* aL */
|
|
|
|
case WINED3DSPR_PREDICATE: /* p0 */
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-09-23 19:09:06 +02:00
|
|
|
/* Internally used shader constants. Applications can use constants 0 to GL_LIMITS(vshader_constantsF) - 1,
|
|
|
|
* so upload them above that
|
|
|
|
*/
|
|
|
|
#define ARB_SHADER_PRIVCONST_BASE GL_LIMITS(vshader_constantsF)
|
|
|
|
#define ARB_SHADER_PRIVCONST_POS ARB_SHADER_PRIVCONST_BASE + 0
|
|
|
|
|
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;
|
2005-03-02 13:16:10 +01:00
|
|
|
|
2006-07-17 07:41:53 +02:00
|
|
|
DWORD usage;
|
2005-08-17 13:34:03 +02:00
|
|
|
|
2006-07-04 10:01:46 +02:00
|
|
|
/* Vertex shader input and output semantics */
|
2006-07-07 08:27:38 +02:00
|
|
|
semantic semantics_in [MAX_ATTRIBS];
|
|
|
|
semantic semantics_out [MAX_REG_OUTPUT];
|
2006-07-04 10:01:46 +02:00
|
|
|
|
2005-08-17 11:54:54 +02:00
|
|
|
/* run time datas... */
|
2005-12-09 11:23:52 +01:00
|
|
|
VSHADERDATA *data;
|
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;
|
|
|
|
|
2006-07-04 10:01:46 +02:00
|
|
|
/* Pixel shader input semantics */
|
2006-07-07 08:27:38 +02:00
|
|
|
semantic semantics_in [MAX_REG_INPUT];
|
2006-07-04 10:01:46 +02:00
|
|
|
|
2005-09-28 12:13:00 +02:00
|
|
|
/* run time data */
|
|
|
|
PSHADERDATA *data;
|
|
|
|
|
2007-02-15 03:05:17 +01:00
|
|
|
/* Some information about the shader behavior */
|
|
|
|
char needsbumpmat;
|
|
|
|
UINT bumpenvmatconst;
|
|
|
|
|
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-06-21 10:36:14 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
* Pixel format management
|
|
|
|
*/
|
|
|
|
typedef struct {
|
|
|
|
WINED3DFORMAT format;
|
|
|
|
DWORD alphaMask, redMask, greenMask, blueMask;
|
|
|
|
UINT bpp;
|
|
|
|
BOOL isFourcc;
|
|
|
|
GLint glInternal, glFormat, glType;
|
|
|
|
} PixelFormatDesc;
|
|
|
|
|
|
|
|
const PixelFormatDesc *getFormatDescEntry(WINED3DFORMAT fmt);
|
2007-03-12 23:22:00 +01:00
|
|
|
|
2007-03-17 11:39:40 +01:00
|
|
|
static inline BOOL use_vs(IWineD3DDeviceImpl *device) {
|
2007-03-12 23:22:00 +01:00
|
|
|
return (device->vs_selected_mode != SHADER_NONE
|
|
|
|
&& device->stateBlock->vertexShader
|
|
|
|
&& ((IWineD3DVertexShaderImpl *)device->stateBlock->vertexShader)->baseShader.function
|
|
|
|
&& !device->strided_streams.u.s.position_transformed);
|
|
|
|
}
|
|
|
|
|
2007-03-17 11:39:40 +01:00
|
|
|
static inline BOOL use_ps(IWineD3DDeviceImpl *device) {
|
2007-03-12 23:22:00 +01:00
|
|
|
return (device->ps_selected_mode != SHADER_NONE
|
|
|
|
&& device->stateBlock->pixelShader
|
|
|
|
&& ((IWineD3DPixelShaderImpl *)device->stateBlock->pixelShader)->baseShader.function);
|
|
|
|
}
|
|
|
|
|
2007-05-03 20:57:09 +02:00
|
|
|
void stretch_rect_fbo(IWineD3DDevice *iface, IWineD3DSurface *src_surface, WINED3DRECT *src_rect,
|
|
|
|
IWineD3DSurface *dst_surface, WINED3DRECT *dst_rect, WINED3DTEXTUREFILTERTYPE filter, BOOL flip);
|
2007-04-09 01:54:07 +02:00
|
|
|
|
2003-11-14 04:50:35 +01:00
|
|
|
#endif
|