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);
|
|
|
|
|
2008-08-21 18:35:34 +02:00
|
|
|
struct hash_table_entry_t {
|
2007-02-27 20:51:48 +01:00
|
|
|
void *key;
|
|
|
|
void *value;
|
|
|
|
unsigned int hash;
|
|
|
|
struct list entry;
|
2008-08-21 18:35:34 +02:00
|
|
|
};
|
2007-02-27 20:51:48 +01:00
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
hash_function_t *hash_function;
|
|
|
|
compare_function_t *compare_function;
|
|
|
|
struct list *buckets;
|
|
|
|
unsigned int bucket_count;
|
2008-08-21 18:35:34 +02:00
|
|
|
struct hash_table_entry_t *entries;
|
2007-02-27 20:51:48 +01:00
|
|
|
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);
|
2008-07-29 17:51:52 +02:00
|
|
|
void hash_table_destroy(hash_table_t *table, void (*free_value)(void *value, void *cb), void *cb);
|
2007-02-27 20:51:48 +01:00
|
|
|
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 */
|
2008-03-26 23:23:04 +01:00
|
|
|
#define MAX_PALETTES 65536
|
2007-06-25 22:45:40 +02:00
|
|
|
#define MAX_STREAMS 16
|
|
|
|
#define MAX_TEXTURES 8
|
|
|
|
#define MAX_FRAGMENT_SAMPLERS 16
|
|
|
|
#define MAX_VERTEX_SAMPLERS 4
|
|
|
|
#define MAX_COMBINED_SAMPLERS (MAX_FRAGMENT_SAMPLERS + MAX_VERTEX_SAMPLERS)
|
|
|
|
#define MAX_ACTIVE_LIGHTS 8
|
|
|
|
#define MAX_CLIPPLANES WINED3DMAXUSERCLIPPLANES
|
|
|
|
#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
|
2007-08-19 12:50:14 +02:00
|
|
|
#define NUM_SAVEDVERTEXSTATES_R 34
|
2005-07-05 16:05:18 +02:00
|
|
|
#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,
|
2008-04-06 00:31:39 +02:00
|
|
|
MAX_LOOKUPS = 1
|
2005-08-03 13:00:28 +02:00
|
|
|
} WINELOOKUP;
|
|
|
|
|
|
|
|
extern int minLookup[MAX_LOOKUPS];
|
|
|
|
extern int maxLookup[MAX_LOOKUPS];
|
|
|
|
extern DWORD *stateLookup[MAX_LOOKUPS];
|
|
|
|
|
2008-04-06 00:31:39 +02:00
|
|
|
typedef DWORD magLookup_t[WINED3DTEXF_ANISOTROPIC + 1];
|
|
|
|
extern magLookup_t magLookup;
|
2008-04-06 00:37:51 +02:00
|
|
|
extern magLookup_t magLookup_noFilter;
|
2008-04-06 00:31:39 +02:00
|
|
|
|
2008-04-06 00:18:53 +02:00
|
|
|
typedef DWORD minMipLookup_t[WINED3DTEXF_ANISOTROPIC + 1][WINED3DTEXF_LINEAR + 1];
|
|
|
|
extern minMipLookup_t minMipLookup;
|
2008-04-06 00:22:08 +02:00
|
|
|
extern minMipLookup_t minMipLookup_noFilter;
|
2005-08-03 13:00:28 +02:00
|
|
|
|
2007-12-19 02:51:53 +01:00
|
|
|
void init_type_lookup(WineD3D_GL_Info *gl_info);
|
|
|
|
#define WINED3D_ATR_TYPE(type) GLINFO_LOCATION.glTypeLookup[type].d3dType
|
|
|
|
#define WINED3D_ATR_SIZE(type) GLINFO_LOCATION.glTypeLookup[type].size
|
|
|
|
#define WINED3D_ATR_GLTYPE(type) GLINFO_LOCATION.glTypeLookup[type].glType
|
|
|
|
#define WINED3D_ATR_NORMALIZED(type) GLINFO_LOCATION.glTypeLookup[type].normalized
|
|
|
|
#define WINED3D_ATR_TYPESIZE(type) GLINFO_LOCATION.glTypeLookup[type].typesize
|
2005-08-03 13:00:28 +02:00
|
|
|
|
2008-07-10 00:23:07 +02:00
|
|
|
/* float_16_to_32() and float_32_to_16() (see implementation in
|
|
|
|
* surface_base.c) convert 16 bit floats in the FLOAT16 data type
|
2008-02-25 11:18:03 +01:00
|
|
|
* to standard C floats and vice versa. They do not depend on the encoding
|
|
|
|
* of the C float, so they are platform independent, but slow. On x86 and
|
2008-04-22 08:18:14 +02:00
|
|
|
* other IEEE 754 compliant platforms the conversion can be accelerated by
|
|
|
|
* bit shifting the exponent and mantissa. There are also some SSE-based
|
|
|
|
* assembly routines out there.
|
2008-02-25 11:18:03 +01:00
|
|
|
*
|
|
|
|
* See GL_NV_half_float for a reference of the FLOAT16 / GL_HALF format
|
|
|
|
*/
|
2007-12-19 17:18:39 +01:00
|
|
|
static inline float float_16_to_32(const unsigned short *in) {
|
|
|
|
const unsigned short s = ((*in) & 0x8000);
|
|
|
|
const unsigned short e = ((*in) & 0x7C00) >> 10;
|
|
|
|
const unsigned short m = (*in) & 0x3FF;
|
|
|
|
const float sgn = (s ? -1.0 : 1.0);
|
|
|
|
|
|
|
|
if(e == 0) {
|
|
|
|
if(m == 0) return sgn * 0.0; /* +0.0 or -0.0 */
|
|
|
|
else return sgn * pow(2, -14.0) * ( (float) m / 1024.0);
|
|
|
|
} else if(e < 31) {
|
|
|
|
return sgn * pow(2, (float) e-15.0) * (1.0 + ((float) m / 1024.0));
|
|
|
|
} else {
|
|
|
|
if(m == 0) return sgn / 0.0; /* +INF / -INF */
|
|
|
|
else return 0.0 / 0.0; /* NAN */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
2008-03-22 14:31:52 +01:00
|
|
|
#define SHADER_ATI 3
|
|
|
|
#define SHADER_NONE 4
|
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;
|
2007-09-01 21:22:32 +02:00
|
|
|
char *logo;
|
2008-06-02 23:06:01 +02:00
|
|
|
int allow_multisampling;
|
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 */
|
2007-09-21 23:53:57 +02:00
|
|
|
struct SHADER_OPCODE_ARG;
|
2006-11-27 20:50:37 +01:00
|
|
|
|
2008-03-18 19:19:16 +01:00
|
|
|
#define SHADER_PGMSIZE 65535
|
|
|
|
typedef struct SHADER_BUFFER {
|
|
|
|
char* buffer;
|
|
|
|
unsigned int bsize;
|
|
|
|
unsigned int lineNo;
|
|
|
|
BOOL newline;
|
|
|
|
} SHADER_BUFFER;
|
|
|
|
|
2008-03-18 19:39:26 +01:00
|
|
|
struct shader_caps {
|
|
|
|
DWORD VertexShaderVersion;
|
|
|
|
DWORD MaxVertexShaderConst;
|
|
|
|
|
|
|
|
DWORD PixelShaderVersion;
|
|
|
|
float PixelShader1xMaxValue;
|
|
|
|
|
|
|
|
WINED3DVSHADERCAPS2_0 VS20Caps;
|
|
|
|
WINED3DPSHADERCAPS2_0 PS20Caps;
|
|
|
|
|
|
|
|
DWORD MaxVShaderInstructionsExecuted;
|
|
|
|
DWORD MaxPShaderInstructionsExecuted;
|
|
|
|
DWORD MaxVertexShader30InstructionSlots;
|
|
|
|
DWORD MaxPixelShader30InstructionSlots;
|
|
|
|
};
|
|
|
|
|
2006-11-27 20:50:37 +01:00
|
|
|
typedef struct {
|
|
|
|
void (*shader_select)(IWineD3DDevice *iface, BOOL usePS, BOOL useVS);
|
|
|
|
void (*shader_select_depth_blt)(IWineD3DDevice *iface);
|
2008-07-10 17:57:35 +02:00
|
|
|
void (*shader_deselect_depth_blt)(IWineD3DDevice *iface);
|
2006-11-27 20:50:37 +01:00
|
|
|
void (*shader_load_constants)(IWineD3DDevice *iface, char usePS, char useVS);
|
2007-02-08 22:31:01 +01:00
|
|
|
void (*shader_cleanup)(IWineD3DDevice *iface);
|
2007-09-21 23:53:57 +02:00
|
|
|
void (*shader_color_correction)(struct SHADER_OPCODE_ARG *arg);
|
2007-11-20 17:40:54 +01:00
|
|
|
void (*shader_destroy)(IWineD3DBaseShader *iface);
|
2008-02-24 11:23:53 +01:00
|
|
|
HRESULT (*shader_alloc_private)(IWineD3DDevice *iface);
|
|
|
|
void (*shader_free_private)(IWineD3DDevice *iface);
|
2008-03-04 02:30:23 +01:00
|
|
|
BOOL (*shader_dirtifyable_constants)(IWineD3DDevice *iface);
|
2008-03-18 19:19:16 +01:00
|
|
|
void (*shader_generate_pshader)(IWineD3DPixelShader *iface, SHADER_BUFFER *buffer);
|
|
|
|
void (*shader_generate_vshader)(IWineD3DVertexShader *iface, SHADER_BUFFER *buffer);
|
2008-03-18 19:39:26 +01:00
|
|
|
void (*shader_get_caps)(WINED3DDEVTYPE devtype, WineD3D_GL_Info *gl_info, struct shader_caps *caps);
|
2008-08-07 21:51:35 +02:00
|
|
|
BOOL (*shader_conv_supported)(WINED3DFORMAT conv);
|
2006-11-27 20:50:37 +01:00
|
|
|
} shader_backend_t;
|
|
|
|
|
2008-03-22 14:31:52 +01:00
|
|
|
extern const shader_backend_t atifs_shader_backend;
|
2006-11-27 20:50:37 +01:00
|
|
|
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;
|
|
|
|
|
2008-02-24 11:23:53 +01:00
|
|
|
/* GLSL shader private data */
|
|
|
|
struct shader_glsl_priv {
|
2008-07-08 21:44:20 +02:00
|
|
|
hash_table_t *glsl_program_lookup;
|
2008-07-07 21:02:57 +02:00
|
|
|
struct glsl_shader_prog_link *glsl_program;
|
2008-02-24 11:23:53 +01:00
|
|
|
GLhandleARB depth_blt_glsl_program_id;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* ARB_program_shader private data */
|
|
|
|
struct shader_arb_priv {
|
2008-07-10 17:57:35 +02:00
|
|
|
GLuint current_vprogram_id;
|
|
|
|
GLuint current_fprogram_id;
|
2008-02-24 11:23:53 +01:00
|
|
|
GLuint depth_blt_vprogram_id;
|
|
|
|
GLuint depth_blt_fprogram_id;
|
2008-07-28 18:41:02 +02:00
|
|
|
BOOL use_arbfp_fixed_func;
|
|
|
|
hash_table_t *fragment_shaders;
|
2008-02-24 11:23:53 +01:00
|
|
|
};
|
|
|
|
|
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
|
|
|
|
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);
|
2007-05-09 19:08:37 +02:00
|
|
|
#define TRACE_STRIDED(sd,name) TRACE( #name "=(data:%p, stride:%d, type:%d, vbo %d, stream %u)\n", \
|
|
|
|
sd->u.s.name.lpData, sd->u.s.name.dwStride, sd->u.s.name.dwType, sd->u.s.name.VBO, sd->u.s.name.streamNo);
|
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
|
|
|
|
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
|
|
|
|
2006-06-21 15:01:38 +02:00
|
|
|
void primitiveDeclarationConvertToStridedData(
|
|
|
|
IWineD3DDevice *iface,
|
|
|
|
BOOL useVertexShaderFunction,
|
|
|
|
WineDirect3DVertexStridedData *strided,
|
|
|
|
BOOL *fixup);
|
|
|
|
|
2006-05-12 22:21:31 +02:00
|
|
|
DWORD get_flexible_vertex_size(DWORD d3dvtVertexType);
|
|
|
|
|
2008-08-15 18:04:20 +02:00
|
|
|
typedef void (WINE_GLAPI *glAttribFunc)(void *data);
|
|
|
|
typedef void (WINE_GLAPI *glTexAttribFunc)(GLuint unit, void *data);
|
2007-12-19 17:10:02 +01:00
|
|
|
extern glAttribFunc position_funcs[WINED3DDECLTYPE_UNUSED];
|
|
|
|
extern glAttribFunc diffuse_funcs[WINED3DDECLTYPE_UNUSED];
|
|
|
|
extern glAttribFunc specular_funcs[WINED3DDECLTYPE_UNUSED];
|
|
|
|
extern glAttribFunc normal_funcs[WINED3DDECLTYPE_UNUSED];
|
|
|
|
|
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)
|
|
|
|
|
2008-01-27 14:11:16 +01:00
|
|
|
void depth_copy(IWineD3DDevice *iface);
|
|
|
|
|
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))
|
2007-06-25 22:45:40 +02:00
|
|
|
#define STATE_IS_SAMPLER(num) ((num) >= STATE_SAMPLER(0) && (num) <= STATE_SAMPLER(MAX_COMBINED_SAMPLERS - 1))
|
2006-12-19 23:14:07 +01:00
|
|
|
|
2007-06-25 22:45:40 +02:00
|
|
|
#define STATE_PIXELSHADER (STATE_SAMPLER(MAX_COMBINED_SAMPLERS - 1) + 1)
|
2006-12-19 23:22:19 +01:00
|
|
|
#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)
|
2007-07-15 23:46:06 +02:00
|
|
|
#define STATE_IS_ACTIVELIGHT(a) ((a) >= STATE_ACTIVELIGHT(0) && (a) < STATE_ACTIVELIGHT(MAX_ACTIVE_LIGHTS))
|
2007-02-14 17:48:52 +01:00
|
|
|
|
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))
|
|
|
|
|
2007-06-15 21:33:54 +02:00
|
|
|
#define STATE_MATERIAL (STATE_CLIPPLANE(MAX_CLIPPLANES))
|
|
|
|
|
2007-09-18 11:43:09 +02:00
|
|
|
#define STATE_FRONTFACE (STATE_MATERIAL + 1)
|
|
|
|
|
|
|
|
#define STATE_HIGHEST (STATE_FRONTFACE)
|
2006-12-19 13:00:03 +01:00
|
|
|
|
2006-12-05 23:36:10 +01:00
|
|
|
struct StateEntry
|
|
|
|
{
|
2008-07-02 02:43:52 +02:00
|
|
|
DWORD representative;
|
|
|
|
APPLYSTATEFUNC apply;
|
2006-12-05 23:36:10 +01:00
|
|
|
};
|
|
|
|
|
2008-07-02 02:43:52 +02:00
|
|
|
struct StateEntryTemplate
|
|
|
|
{
|
|
|
|
DWORD state;
|
|
|
|
struct StateEntry content;
|
2008-07-05 22:04:16 +02:00
|
|
|
GL_SupportedExt extension;
|
2008-07-02 02:43:52 +02:00
|
|
|
};
|
|
|
|
|
2008-07-03 21:36:18 +02:00
|
|
|
struct fragment_caps {
|
|
|
|
DWORD PrimitiveMiscCaps;
|
|
|
|
|
|
|
|
DWORD TextureOpCaps;
|
|
|
|
DWORD MaxTextureBlendStages;
|
|
|
|
DWORD MaxSimultaneousTextures;
|
|
|
|
};
|
|
|
|
|
2008-07-04 22:09:49 +02:00
|
|
|
struct fragment_pipeline {
|
|
|
|
void (*enable_extension)(IWineD3DDevice *iface, BOOL enable);
|
2008-07-03 21:36:18 +02:00
|
|
|
void (*get_caps)(WINED3DDEVTYPE devtype, WineD3D_GL_Info *gl_info, struct fragment_caps *caps);
|
2008-07-11 16:41:28 +02:00
|
|
|
HRESULT (*alloc_private)(IWineD3DDevice *iface);
|
|
|
|
void (*free_private)(IWineD3DDevice *iface);
|
2008-08-07 21:51:35 +02:00
|
|
|
BOOL (*conv_supported)(WINED3DFORMAT conv);
|
2008-07-04 22:09:49 +02:00
|
|
|
const struct StateEntryTemplate *states;
|
|
|
|
};
|
|
|
|
|
2008-07-02 02:43:52 +02:00
|
|
|
extern const struct StateEntryTemplate misc_state_template[];
|
2008-07-02 17:02:19 +02:00
|
|
|
extern const struct StateEntryTemplate ffp_vertexstate_template[];
|
2008-07-04 22:09:49 +02:00
|
|
|
extern const struct fragment_pipeline ffp_fragment_pipeline;
|
|
|
|
extern const struct fragment_pipeline atifs_fragment_pipeline;
|
2008-07-28 18:41:02 +02:00
|
|
|
extern const struct fragment_pipeline arbfp_fragment_pipeline;
|
2008-07-04 23:15:18 +02:00
|
|
|
extern const struct fragment_pipeline nvts_fragment_pipeline;
|
|
|
|
extern const struct fragment_pipeline nvrc_fragment_pipeline;
|
|
|
|
|
2008-03-09 19:30:08 +01:00
|
|
|
/* "Base" state table */
|
2008-07-02 02:43:52 +02:00
|
|
|
void compile_state_table(struct StateEntry *StateTable,
|
|
|
|
APPLYSTATEFUNC **dev_multistate_funcs,
|
2008-07-05 22:04:16 +02:00
|
|
|
WineD3D_GL_Info *gl_info,
|
2008-07-02 02:43:52 +02:00
|
|
|
const struct StateEntryTemplate *vertex,
|
2008-07-04 22:09:49 +02:00
|
|
|
const struct fragment_pipeline *fragment,
|
2008-07-02 21:56:38 +02:00
|
|
|
const struct StateEntryTemplate *misc);
|
2006-12-05 23:36:10 +01:00
|
|
|
|
2008-08-01 20:21:10 +02:00
|
|
|
/* Shaders for color conversions in blits */
|
|
|
|
struct blit_shader {
|
|
|
|
HRESULT (*alloc_private)(IWineD3DDevice *iface);
|
|
|
|
void (*free_private)(IWineD3DDevice *iface);
|
|
|
|
HRESULT (*set_shader)(IWineD3DDevice *iface, WINED3DFORMAT fmt, GLenum textype, UINT width, UINT height);
|
|
|
|
void (*unset_shader)(IWineD3DDevice *iface);
|
2008-08-07 21:51:35 +02:00
|
|
|
BOOL (*conv_supported)(WINED3DFORMAT conv);
|
2008-08-01 20:21:10 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
extern const struct blit_shader ffp_blit;
|
2008-08-19 18:09:45 +02:00
|
|
|
extern const struct blit_shader arbfp_blit;
|
2008-08-01 20:21:10 +02:00
|
|
|
|
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
|
|
|
|
2008-01-09 20:37:05 +01:00
|
|
|
/* Stores some information about the context state for optimization */
|
2008-08-03 21:17:51 +02:00
|
|
|
BOOL draw_buffer_dirty;
|
2007-02-12 19:18:31 +01:00
|
|
|
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-06-20 14:36:32 +02:00
|
|
|
unsigned char num_untracked_materials;
|
|
|
|
GLenum untracked_materials[2];
|
2007-02-15 03:04:18 +01:00
|
|
|
BOOL last_was_blit, last_was_ckey;
|
2008-06-17 01:41:49 +02:00
|
|
|
UINT blit_w, blit_h;
|
2007-05-07 21:08:14 +02:00
|
|
|
char texShaderBumpMap;
|
2007-08-14 02:31:10 +02:00
|
|
|
BOOL fog_coord;
|
2007-02-12 19:21:10 +01:00
|
|
|
|
2008-03-04 02:30:23 +01:00
|
|
|
char *vshader_const_dirty, *pshader_const_dirty;
|
|
|
|
|
2007-02-12 19:21:10 +01:00
|
|
|
/* The actual opengl context */
|
2007-08-08 03:09:38 +02:00
|
|
|
HGLRC glCtx;
|
|
|
|
HWND win_handle;
|
|
|
|
HDC hdc;
|
|
|
|
HPBUFFERARB pbuffer;
|
2007-02-12 19:22:41 +01:00
|
|
|
BOOL isPBuffer;
|
2008-04-08 14:20:27 +02:00
|
|
|
GLint aux_buffers;
|
2008-08-21 18:34:55 +02:00
|
|
|
|
|
|
|
/* FBOs */
|
|
|
|
IWineD3DSurface **fbo_color_attachments;
|
|
|
|
IWineD3DSurface *fbo_depth_attachment;
|
|
|
|
GLuint fbo;
|
|
|
|
GLuint src_fbo;
|
|
|
|
GLuint dst_fbo;
|
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 */
|
2008-01-09 20:37:05 +01:00
|
|
|
CTXUSAGE_DRAWPRIM = 2, /* OpenGL states are set up for blitting DirectDraw surfaces */
|
2007-02-12 19:18:36 +01:00
|
|
|
CTXUSAGE_BLIT = 3, /* OpenGL states are set up 3D drawing */
|
2007-07-09 16:57:58 +02:00
|
|
|
CTXUSAGE_CLEAR = 4, /* Drawable and states are set up for clearing */
|
2007-02-12 19:18:36 +01:00
|
|
|
} ContextUsage;
|
|
|
|
|
|
|
|
void ActivateContext(IWineD3DDeviceImpl *device, IWineD3DSurface *target, ContextUsage usage);
|
2007-08-11 12:17:56 +02:00
|
|
|
WineD3DContext *CreateContext(IWineD3DDeviceImpl *This, IWineD3DSurfaceImpl *target, HWND win, BOOL create_pbuffer, const WINED3DPRESENT_PARAMETERS *pPresentParms);
|
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
|
|
|
|
2008-07-29 19:09:34 +02:00
|
|
|
void delete_opengl_contexts(IWineD3DDevice *iface, IWineD3DSwapChain *swapchain);
|
|
|
|
HRESULT create_primary_opengl_context(IWineD3DDevice *iface, IWineD3DSwapChain *swapchain);
|
|
|
|
|
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;
|
2007-11-29 13:22:47 +01:00
|
|
|
BOOL enabled;
|
2004-11-29 18:53:42 +01:00
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
2007-08-11 16:25:58 +02:00
|
|
|
typedef struct WineD3D_PixelFormat
|
|
|
|
{
|
|
|
|
int iPixelFormat; /* WGL pixel format */
|
2008-03-21 14:52:15 +01:00
|
|
|
int iPixelType; /* WGL pixel type e.g. WGL_TYPE_RGBA_ARB, WGL_TYPE_RGBA_FLOAT_ARB or WGL_TYPE_COLORINDEX_ARB */
|
2007-08-11 16:25:58 +02:00
|
|
|
int redSize, greenSize, blueSize, alphaSize;
|
|
|
|
int depthSize, stencilSize;
|
2008-03-16 17:37:38 +01:00
|
|
|
BOOL windowDrawable;
|
|
|
|
BOOL pbufferDrawable;
|
2008-04-27 19:36:34 +02:00
|
|
|
BOOL doubleBuffer;
|
|
|
|
int auxBuffers;
|
2008-04-28 23:44:21 +02:00
|
|
|
int numSamples;
|
2007-08-11 16:25:58 +02:00
|
|
|
} WineD3D_PixelFormat;
|
|
|
|
|
2007-06-09 14:27:41 +02:00
|
|
|
/* The adapter structure */
|
2007-07-27 13:22:54 +02:00
|
|
|
typedef struct GLPixelFormatDesc GLPixelFormatDesc;
|
2007-06-09 14:27:41 +02:00
|
|
|
struct WineD3DAdapter
|
|
|
|
{
|
2007-12-06 23:43:25 +01:00
|
|
|
UINT num;
|
2008-03-28 23:04:17 +01:00
|
|
|
BOOL opengl;
|
2007-06-09 14:27:41 +02:00
|
|
|
POINT monitorPoint;
|
|
|
|
WineD3D_GL_Info gl_info;
|
2007-06-08 15:23:04 +02:00
|
|
|
const char *driver;
|
|
|
|
const char *description;
|
2007-08-13 16:47:17 +02:00
|
|
|
WCHAR DeviceName[CCHDEVICENAME]; /* DeviceName for use with e.g. ChangeDisplaySettings */
|
2007-06-08 14:16:37 +02:00
|
|
|
int nCfgs;
|
2007-08-11 16:25:58 +02:00
|
|
|
WineD3D_PixelFormat *cfgs;
|
2008-05-03 16:37:09 +02:00
|
|
|
BOOL brokenStencil; /* Set on cards which only offer mixed depth+stencil */
|
2007-09-23 00:46:21 +02:00
|
|
|
unsigned int TextureRam; /* Amount of texture memory both video ram + AGP/TurboCache/HyperMemory/.. */
|
|
|
|
unsigned int UsedTextureRam;
|
2007-06-09 14:27:41 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
extern BOOL InitAdapters(void);
|
2007-07-27 13:22:54 +02:00
|
|
|
extern BOOL initPixelFormats(WineD3D_GL_Info *gl_info);
|
2007-09-23 00:46:21 +02:00
|
|
|
extern long WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl *D3DDevice, long glram);
|
2007-06-09 14:27:41 +02:00
|
|
|
|
2007-07-04 17:57:45 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
* High order patch management
|
|
|
|
*/
|
|
|
|
struct WineD3DRectPatch
|
|
|
|
{
|
|
|
|
UINT Handle;
|
|
|
|
float *mem;
|
|
|
|
WineDirect3DVertexStridedData strided;
|
|
|
|
WINED3DRECTPATCH_INFO RectPatchInfo;
|
|
|
|
float numSegs[4];
|
|
|
|
char has_normals, has_texcoords;
|
|
|
|
struct list entry;
|
|
|
|
};
|
|
|
|
|
|
|
|
HRESULT tesselate_rectpatch(IWineD3DDeviceImpl *This, struct WineD3DRectPatch *patch);
|
|
|
|
|
2008-03-22 14:31:52 +01:00
|
|
|
enum projection_types
|
|
|
|
{
|
2008-07-30 17:57:32 +02:00
|
|
|
proj_none = 0,
|
|
|
|
proj_count3 = 1,
|
|
|
|
proj_count4 = 2
|
|
|
|
};
|
|
|
|
|
|
|
|
enum tex_types
|
|
|
|
{
|
|
|
|
tex_1d = 0,
|
|
|
|
tex_2d = 1,
|
|
|
|
tex_3d = 2,
|
|
|
|
tex_cube = 3,
|
|
|
|
tex_rect = 4
|
|
|
|
};
|
|
|
|
|
|
|
|
enum dst_arg
|
|
|
|
{
|
|
|
|
resultreg = 0,
|
|
|
|
tempreg = 1
|
2008-03-22 14:31:52 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* Fixed function pipeline replacements
|
|
|
|
*/
|
|
|
|
struct texture_stage_op
|
|
|
|
{
|
2008-07-30 17:57:32 +02:00
|
|
|
unsigned cop : 5, aop : 5;
|
2008-08-05 21:50:56 +02:00
|
|
|
#define ARG_UNUSED 0x3f
|
2008-07-30 17:57:32 +02:00
|
|
|
unsigned carg1 : 6, carg2 : 6, carg0 : 6;
|
|
|
|
unsigned tex_type : 3;
|
2008-08-01 18:47:24 +02:00
|
|
|
unsigned dst : 1; /* Total of 32 bits */
|
2008-07-30 17:57:32 +02:00
|
|
|
unsigned aarg1 : 6, aarg2 : 6, aarg0 : 6;
|
|
|
|
unsigned projected : 2;
|
2008-08-01 18:47:24 +02:00
|
|
|
unsigned padding : 12; /* Total of 64 bits */
|
2008-03-22 14:31:52 +01:00
|
|
|
WINED3DFORMAT color_correction;
|
|
|
|
};
|
|
|
|
|
2008-07-12 04:18:06 +02:00
|
|
|
struct ffp_settings {
|
|
|
|
struct texture_stage_op op[MAX_TEXTURES];
|
|
|
|
enum {
|
|
|
|
FOG_OFF,
|
|
|
|
FOG_LINEAR,
|
|
|
|
FOG_EXP,
|
|
|
|
FOG_EXP2
|
|
|
|
} fog;
|
2008-08-20 17:15:31 +02:00
|
|
|
unsigned char sRGB_write;
|
2008-07-12 04:18:06 +02:00
|
|
|
};
|
|
|
|
|
2008-03-22 14:31:52 +01:00
|
|
|
struct ffp_desc
|
|
|
|
{
|
2008-07-12 04:18:06 +02:00
|
|
|
struct ffp_settings settings;
|
2008-03-22 14:31:52 +01:00
|
|
|
};
|
|
|
|
|
2008-07-12 04:18:06 +02:00
|
|
|
void gen_ffp_op(IWineD3DStateBlockImpl *stateblock, struct ffp_settings *settings, BOOL ignore_textype);
|
2008-07-29 17:51:52 +02:00
|
|
|
struct ffp_desc *find_ffp_shader(hash_table_t *fragment_shaders, struct ffp_settings *settings);
|
|
|
|
void add_ffp_shader(hash_table_t *shaders, struct ffp_desc *desc);
|
|
|
|
BOOL ffp_program_key_compare(void *keya, void *keyb);
|
|
|
|
unsigned int ffp_program_key_hash(void *key);
|
2008-03-22 14:31:52 +01:00
|
|
|
|
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;
|
|
|
|
} 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;
|
|
|
|
|
2006-04-10 19:39:53 +02:00
|
|
|
/* A helper function that dumps a resource list */
|
2007-11-16 20:28:45 +01:00
|
|
|
void dumpResources(struct list *list);
|
2006-04-10 19:39:53 +02:00
|
|
|
|
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;
|
2007-06-09 14:27:41 +02:00
|
|
|
struct WineD3DAdapter *adapter;
|
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;
|
2008-02-24 11:23:53 +01:00
|
|
|
void *shader_priv;
|
2008-07-11 16:41:28 +02:00
|
|
|
void *fragment_priv;
|
2008-08-01 20:21:10 +02:00
|
|
|
void *blit_priv;
|
2008-07-02 01:23:44 +02:00
|
|
|
struct StateEntry StateTable[STATE_HIGHEST + 1];
|
2008-07-02 02:43:52 +02:00
|
|
|
/* Array of functions for states which are handled by more than one pipeline part */
|
|
|
|
APPLYSTATEFUNC *multistate_funcs[STATE_HIGHEST + 1];
|
2008-07-04 22:09:49 +02:00
|
|
|
const struct fragment_pipeline *frag_pipe;
|
2008-08-01 20:21:10 +02:00
|
|
|
const struct blit_shader *blitter;
|
2006-10-08 05:25:01 +02:00
|
|
|
|
2008-08-21 20:23:38 +02:00
|
|
|
unsigned int max_ffp_textures, max_ffp_texture_stages;
|
2008-08-17 23:46:47 +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 */
|
2008-08-03 01:06:01 +02:00
|
|
|
#define DDRAW_PITCH_ALIGNMENT 8
|
|
|
|
#define D3D8_PITCH_ALIGNMENT 4
|
2007-06-08 22:28:04 +02:00
|
|
|
unsigned char surface_alignment; /* Line Alignment of surfaces */
|
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;
|
2007-08-06 16:38:00 +02:00
|
|
|
UINT NumberOfSwapChains;
|
2005-06-23 13:05:24 +02:00
|
|
|
|
2007-11-16 20:28:45 +01:00
|
|
|
struct list resources; /* a linked list to track resources created by the device */
|
2008-01-08 20:45:59 +01:00
|
|
|
struct list shaders; /* a linked list to track shaders (pixel and vertex) */
|
2008-03-04 02:30:23 +01:00
|
|
|
unsigned int highest_dirty_ps_const, highest_dirty_vs_const;
|
2005-07-26 12:34:15 +02:00
|
|
|
|
2005-01-09 18:37:02 +01:00
|
|
|
/* Render Target Support */
|
2006-12-19 19:25:22 +01:00
|
|
|
IWineD3DSurface **render_targets;
|
2007-11-10 00:19:19 +01:00
|
|
|
IWineD3DSurface *auto_depth_stencil_buffer;
|
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 */
|
2008-03-26 23:23:04 +01:00
|
|
|
UINT NumberOfPalettes;
|
|
|
|
PALETTEENTRY **palettes;
|
2005-03-14 11:12:52 +01:00
|
|
|
UINT currentPalette;
|
2007-10-11 23:11:37 +02:00
|
|
|
UINT paletteConversionShader;
|
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-12-19 19:25:35 +01:00
|
|
|
GLenum *draw_buffers;
|
2008-01-27 14:32:40 +01:00
|
|
|
GLuint depth_blt_texture;
|
2008-07-02 23:00:11 +02:00
|
|
|
GLuint depth_blt_rb;
|
|
|
|
UINT depth_blt_rb_w;
|
|
|
|
UINT depth_blt_rb_h;
|
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;
|
2007-05-15 00:37:53 +02:00
|
|
|
BOOL haveHardwareCursor;
|
|
|
|
HCURSOR hardwareCursor;
|
2005-03-02 13:16:10 +01:00
|
|
|
|
2007-09-01 21:22:32 +02:00
|
|
|
/* The Wine logo surface */
|
|
|
|
IWineD3DSurface *logo_surface;
|
|
|
|
|
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 */
|
2006-05-18 22:42:22 +02:00
|
|
|
DWORD ddraw_width, ddraw_height;
|
|
|
|
WINED3DFORMAT ddraw_format;
|
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 */
|
2007-06-25 22:45:40 +02:00
|
|
|
DWORD texUnitMap[MAX_COMBINED_SAMPLERS];
|
|
|
|
DWORD rev_tex_unit_map[MAX_COMBINED_SAMPLERS];
|
2007-06-22 20:43:24 +02:00
|
|
|
BOOL fixed_function_usage_map[MAX_TEXTURES];
|
2006-12-19 23:33:34 +01:00
|
|
|
|
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 */
|
2007-06-02 22:20:17 +02:00
|
|
|
WineD3DContext *activeContext;
|
|
|
|
DWORD lastThread;
|
|
|
|
UINT numContexts;
|
2007-02-12 19:21:10 +01:00
|
|
|
WineD3DContext *pbufferContext; /* The context that has a pbuffer as drawable */
|
|
|
|
DWORD pbufferWidth, pbufferHeight; /* Size of the buffer drawable */
|
2007-07-04 17:57:45 +02:00
|
|
|
|
|
|
|
/* High level patch management */
|
|
|
|
#define PATCHMAP_SIZE 43
|
|
|
|
#define PATCHMAP_HASHFUNC(x) ((x) % PATCHMAP_SIZE) /* Primitive and simple function */
|
|
|
|
struct list patches[PATCHMAP_SIZE];
|
|
|
|
struct WineD3DRectPatch *currentPatch;
|
2007-02-12 19:18:36 +01:00
|
|
|
};
|
2004-10-07 06:22:21 +02:00
|
|
|
|
2008-03-04 02:30:23 +01:00
|
|
|
extern const IWineD3DDeviceVtbl IWineD3DDevice_Vtbl, IWineD3DDevice_DirtyConst_Vtbl;
|
2004-10-07 06:22:21 +02:00
|
|
|
|
2007-12-20 08:32:11 +01:00
|
|
|
HRESULT IWineD3DDeviceImpl_ClearSurface(IWineD3DDeviceImpl *This, IWineD3DSurfaceImpl *target, DWORD Count,
|
|
|
|
CONST WINED3DRECT* pRects, DWORD Flags, WINED3DCOLOR Color,
|
|
|
|
float Z, DWORD Stencil);
|
2007-06-12 23:08:22 +02:00
|
|
|
void IWineD3DDeviceImpl_FindTexUnitMap(IWineD3DDeviceImpl *This);
|
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
|
|
|
}
|
|
|
|
|
2007-05-07 20:46:24 +02:00
|
|
|
/* Support for IWineD3DResource ::Set/Get/FreePrivateData. */
|
2005-07-15 11:54:57 +02:00
|
|
|
typedef struct PrivateData
|
|
|
|
{
|
2007-05-07 20:46:24 +02:00
|
|
|
struct list entry;
|
2005-07-15 11:54:57 +02:00
|
|
|
|
|
|
|
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;
|
2007-10-22 13:02:03 +02:00
|
|
|
BYTE *allocatedMemory; /* Pointer to the real data location */
|
|
|
|
BYTE *heapMemory; /* Pointer to the HeapAlloced block of memory */
|
2007-05-07 20:46:24 +02:00
|
|
|
struct list privateData;
|
2007-11-16 20:28:45 +01:00
|
|
|
struct list resource_list_entry;
|
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;
|
|
|
|
|
2007-10-22 13:30:14 +02:00
|
|
|
/* Tests show that the start address of resources is 32 byte aligned */
|
|
|
|
#define RESOURCE_ALIGNMENT 32
|
2004-10-14 02:32:04 +02:00
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* IWineD3DVertexBuffer implementation structure (extends IWineD3DResourceImpl)
|
|
|
|
*/
|
2007-12-21 03:55:31 +01:00
|
|
|
enum vbo_conversion_type {
|
|
|
|
CONV_NONE = 0,
|
|
|
|
CONV_D3DCOLOR = 1,
|
|
|
|
CONV_POSITIONT = 2,
|
|
|
|
CONV_FLOAT16_2 = 3 /* Also handles FLOAT16_4 */
|
|
|
|
|
|
|
|
/* TODO: Add tests and support for FLOAT16_4 POSITIONT, D3DCOLOR position, other
|
|
|
|
* fixed function semantics as D3DCOLOR or FLOAT16
|
|
|
|
*/
|
|
|
|
};
|
|
|
|
|
2004-10-14 02:32:04 +02:00
|
|
|
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;
|
2007-12-19 17:18:39 +01:00
|
|
|
LONG vbo_size;
|
|
|
|
GLenum vbo_usage;
|
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 */
|
2007-12-21 03:55:31 +01:00
|
|
|
DWORD stride; /* 0 if no conversion */
|
|
|
|
enum vbo_conversion_type *conv_map; /* NULL if no conversion */
|
2007-12-19 17:18:39 +01:00
|
|
|
|
|
|
|
/* Extra load offsets, for FLOAT16 conversion */
|
2007-12-21 03:55:31 +01:00
|
|
|
DWORD *conv_shift; /* NULL if no shifted conversion */
|
|
|
|
DWORD conv_stride; /* 0 if no shifted conversion */
|
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
|
|
|
|
2008-02-15 20:02:07 +01:00
|
|
|
#define VBFLAG_OPTIMIZED 0x01 /* Optimize has been called for the VB */
|
|
|
|
#define VBFLAG_DIRTY 0x02 /* Buffer data has been modified */
|
|
|
|
#define VBFLAG_HASDESC 0x04 /* A vertex description has been found */
|
|
|
|
#define VBFLAG_CREATEVBO 0x08 /* Attempt to create a VBO next PreLoad */
|
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;
|
|
|
|
|
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;
|
2007-06-07 01:13:16 +02:00
|
|
|
BOOL is_srgb;
|
|
|
|
UINT srgb_mode_change_count;
|
2007-09-21 23:47:40 +02:00
|
|
|
WINED3DFORMAT shader_conversion_group;
|
2007-11-13 22:08:13 +01:00
|
|
|
float pow2Matrix[16];
|
2008-04-06 00:18:53 +02:00
|
|
|
minMipLookup_t *minMipLookup;
|
2008-04-06 00:37:51 +02:00
|
|
|
magLookup_t *magLookup;
|
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;
|
2007-11-28 20:35:04 +01:00
|
|
|
UINT target;
|
2008-07-09 01:59:10 +02:00
|
|
|
BOOL cond_np2;
|
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;
|
|
|
|
} 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;
|
2007-09-11 10:31:54 +02:00
|
|
|
UINT bitmap_size;
|
2006-05-06 18:08:33 +02:00
|
|
|
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;
|
|
|
|
|
2007-04-28 17:59:37 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
* IWineD3DClipp implementation structure
|
|
|
|
*/
|
|
|
|
typedef struct IWineD3DClipperImpl
|
|
|
|
{
|
|
|
|
const IWineD3DClipperVtbl *lpVtbl;
|
|
|
|
LONG ref;
|
|
|
|
|
|
|
|
IUnknown *Parent;
|
|
|
|
HWND hWnd;
|
|
|
|
} IWineD3DClipperImpl;
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2007-11-30 20:22:33 +01:00
|
|
|
/* A method to retrieve the drawable size. Not in the Vtable to make it changeable */
|
|
|
|
void (*get_drawable_size)(IWineD3DSurfaceImpl *This, UINT *width, UINT *height);
|
|
|
|
|
2006-05-19 00:13:29 +02:00
|
|
|
/* Oversized texture */
|
|
|
|
RECT glRect;
|
|
|
|
|
2007-09-11 10:31:54 +02:00
|
|
|
/* PBO */
|
|
|
|
GLuint pbo;
|
|
|
|
|
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;
|
2007-10-13 12:54:10 +02:00
|
|
|
BOOL srgb;
|
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;
|
2007-04-28 17:59:37 +02:00
|
|
|
|
|
|
|
/* DirectDraw clippers */
|
|
|
|
IWineD3DClipper *clipper;
|
2008-08-05 12:19:43 +02:00
|
|
|
|
|
|
|
/* DirectDraw Overlay handling */
|
|
|
|
RECT overlay_srcrect;
|
|
|
|
RECT overlay_destrect;
|
|
|
|
IWineD3DSurfaceImpl *overlay_dest;
|
2008-07-30 22:28:25 +02:00
|
|
|
struct list overlays;
|
|
|
|
struct list overlay_entry;
|
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 */
|
2007-09-16 13:29:44 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_QueryInterface(IWineD3DSurface *iface, REFIID riid, LPVOID *ppobj);
|
2007-09-16 13:42:18 +02:00
|
|
|
ULONG WINAPI IWineD3DBaseSurfaceImpl_AddRef(IWineD3DSurface *iface);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetParent(IWineD3DSurface *iface, IUnknown **pParent);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetDevice(IWineD3DSurface *iface, IWineD3DDevice** ppDevice);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetPrivateData(IWineD3DSurface *iface, REFGUID refguid, CONST void* pData, DWORD SizeOfData, DWORD Flags);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetPrivateData(IWineD3DSurface *iface, REFGUID refguid, void* pData, DWORD* pSizeOfData);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_FreePrivateData(IWineD3DSurface *iface, REFGUID refguid);
|
|
|
|
DWORD WINAPI IWineD3DBaseSurfaceImpl_SetPriority(IWineD3DSurface *iface, DWORD PriorityNew);
|
|
|
|
DWORD WINAPI IWineD3DBaseSurfaceImpl_GetPriority(IWineD3DSurface *iface);
|
|
|
|
WINED3DRESOURCETYPE WINAPI IWineD3DBaseSurfaceImpl_GetType(IWineD3DSurface *iface);
|
2007-09-16 14:03:39 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetContainer(IWineD3DSurface* iface, REFIID riid, void** ppContainer);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetDesc(IWineD3DSurface *iface, WINED3DSURFACE_DESC *pDesc);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetBltStatus(IWineD3DSurface *iface, DWORD Flags);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetFlipStatus(IWineD3DSurface *iface, DWORD Flags);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_IsLost(IWineD3DSurface *iface);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_Restore(IWineD3DSurface *iface);
|
2007-09-16 16:27:58 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetPalette(IWineD3DSurface *iface, IWineD3DPalette **Pal);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetPalette(IWineD3DSurface *iface, IWineD3DPalette *Pal);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetColorKey(IWineD3DSurface *iface, DWORD Flags, WINEDDCOLORKEY *CKey);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetContainer(IWineD3DSurface *iface, IWineD3DBase *container);
|
|
|
|
DWORD WINAPI IWineD3DBaseSurfaceImpl_GetPitch(IWineD3DSurface *iface);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_RealizePalette(IWineD3DSurface *iface);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetOverlayPosition(IWineD3DSurface *iface, LONG X, LONG Y);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetOverlayPosition(IWineD3DSurface *iface, LONG *X, LONG *Y);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder(IWineD3DSurface *iface, DWORD Flags, IWineD3DSurface *Ref);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_UpdateOverlay(IWineD3DSurface *iface, RECT *SrcRect, IWineD3DSurface *DstSurface, RECT *DstRect, DWORD Flags, WINEDDOVERLAYFX *FX);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetClipper(IWineD3DSurface *iface, IWineD3DClipper *clipper);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetClipper(IWineD3DSurface *iface, IWineD3DClipper **clipper);
|
2007-09-16 16:49:02 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetFormat(IWineD3DSurface *iface, WINED3DFORMAT format);
|
2007-09-17 13:48:11 +02:00
|
|
|
HRESULT IWineD3DBaseSurfaceImpl_CreateDIBSection(IWineD3DSurface *iface);
|
2007-09-17 16:03:21 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_Blt(IWineD3DSurface *iface, RECT *DestRect, IWineD3DSurface *SrcSurface, RECT *SrcRect, DWORD Flags, WINEDDBLTFX *DDBltFx, WINED3DTEXTUREFILTERTYPE Filter);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dstx, DWORD dsty, IWineD3DSurface *Source, RECT *rsrc, DWORD trans);
|
2007-10-09 22:19:39 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_LockRect(IWineD3DSurface *iface, WINED3DLOCKED_RECT* pLockedRect, CONST RECT* pRect, DWORD Flags);
|
2007-11-15 14:38:34 +01:00
|
|
|
void WINAPI IWineD3DBaseSurfaceImpl_BindTexture(IWineD3DSurface *iface);
|
2005-01-09 18:37:02 +01:00
|
|
|
|
2007-09-16 16:33:23 +02:00
|
|
|
const void *WINAPI IWineD3DSurfaceImpl_GetData(IWineD3DSurface *iface);
|
|
|
|
|
2007-11-30 20:22:33 +01:00
|
|
|
void get_drawable_size_swapchain(IWineD3DSurfaceImpl *This, UINT *width, UINT *height);
|
|
|
|
void get_drawable_size_backbuffer(IWineD3DSurfaceImpl *This, UINT *width, UINT *height);
|
|
|
|
void get_drawable_size_pbuffer(IWineD3DSurfaceImpl *This, UINT *width, UINT *height);
|
|
|
|
void get_drawable_size_fbo(IWineD3DSurfaceImpl *This, UINT *width, UINT *height);
|
|
|
|
|
2008-07-24 18:38:51 +02:00
|
|
|
void flip_surface(IWineD3DSurfaceImpl *front, IWineD3DSurfaceImpl *back);
|
|
|
|
|
2006-05-06 16:15:37 +02:00
|
|
|
/* Surface flags: */
|
2008-07-02 23:00:41 +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 */
|
|
|
|
#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 */
|
|
|
|
#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 */
|
|
|
|
#define SFLAG_LOST 0x00002000 /* Surface lost flag for DDraw */
|
|
|
|
#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 */
|
|
|
|
#define SFLAG_CLIENT 0x00010000 /* GL_APPLE_client_storage is used on that texture */
|
|
|
|
#define SFLAG_ALLOCATED 0x00020000 /* A gl texture is allocated for this surface */
|
|
|
|
#define SFLAG_PBO 0x00040000 /* Has a PBO attached for speeding up data transfers for dynamically locked surfaces */
|
|
|
|
#define SFLAG_NORMCOORD 0x00080000 /* Set if the GL texture coords are normalized(non-texture rectangle) */
|
|
|
|
#define SFLAG_DS_ONSCREEN 0x00100000 /* Is a depth stencil, last modified onscreen */
|
|
|
|
#define SFLAG_DS_OFFSCREEN 0x00200000 /* Is a depth stencil, last modified offscreen */
|
2008-08-20 17:48:14 +02:00
|
|
|
#define SFLAG_INOVERLAYDRAW 0x00400000 /* Overlay drawing is in progress. Recursion prevention */
|
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-09-11 10:31:54 +02:00
|
|
|
* SFLAG_PBO: PBOs don't use 'normal' memory. It is either allocated by the driver or must be NULL.
|
2007-03-31 23:02:37 +02:00
|
|
|
* SFLAG_CLIENT: OpenGL uses our memory as backup
|
2006-05-06 16:15:37 +02:00
|
|
|
*/
|
2008-07-02 23:00:41 +02:00
|
|
|
#define SFLAG_DONOTFREE (SFLAG_OVERSIZE | \
|
|
|
|
SFLAG_CONVERTED | \
|
|
|
|
SFLAG_DIBSECTION | \
|
|
|
|
SFLAG_LOCKED | \
|
|
|
|
SFLAG_DYNLOCK | \
|
|
|
|
SFLAG_DYNCHANGE | \
|
|
|
|
SFLAG_USERPTR | \
|
|
|
|
SFLAG_PBO | \
|
|
|
|
SFLAG_CLIENT)
|
|
|
|
|
|
|
|
#define SFLAG_LOCATIONS (SFLAG_INSYSMEM | \
|
|
|
|
SFLAG_INTEXTURE | \
|
|
|
|
SFLAG_INDRAWABLE)
|
|
|
|
|
|
|
|
#define SFLAG_DS_LOCATIONS (SFLAG_DS_ONSCREEN | \
|
|
|
|
SFLAG_DS_OFFSCREEN)
|
|
|
|
|
2006-05-23 00:48:54 +02:00
|
|
|
BOOL CalculateTexRect(IWineD3DSurfaceImpl *This, RECT *Rect, float glTexCoord[4]);
|
|
|
|
|
2007-08-11 20:02:01 +02:00
|
|
|
typedef enum {
|
|
|
|
NO_CONVERSION,
|
|
|
|
CONVERT_PALETTED,
|
|
|
|
CONVERT_PALETTED_CK,
|
|
|
|
CONVERT_CK_565,
|
|
|
|
CONVERT_CK_5551,
|
|
|
|
CONVERT_CK_4444,
|
|
|
|
CONVERT_CK_4444_ARGB,
|
|
|
|
CONVERT_CK_1555,
|
|
|
|
CONVERT_555,
|
|
|
|
CONVERT_CK_RGB24,
|
|
|
|
CONVERT_CK_8888,
|
|
|
|
CONVERT_CK_8888_ARGB,
|
|
|
|
CONVERT_RGB32_888,
|
|
|
|
CONVERT_V8U8,
|
2007-08-31 20:41:03 +02:00
|
|
|
CONVERT_L6V5U5,
|
2007-08-11 20:02:01 +02:00
|
|
|
CONVERT_X8L8V8U8,
|
|
|
|
CONVERT_Q8W8V8U8,
|
|
|
|
CONVERT_V16U16,
|
2007-08-12 16:24:29 +02:00
|
|
|
CONVERT_A4L4,
|
|
|
|
CONVERT_R32F,
|
2007-12-15 23:47:10 +01:00
|
|
|
CONVERT_R16F,
|
|
|
|
CONVERT_G16R16,
|
2007-08-11 20:02:01 +02:00
|
|
|
} CONVERT_TYPES;
|
|
|
|
|
|
|
|
HRESULT d3dfmt_get_conv(IWineD3DSurfaceImpl *This, BOOL need_alpha_ck, BOOL use_texturing, GLenum *format, GLenum *internal, GLenum *type, CONVERT_TYPES *convert, int *target_bpp, BOOL srgb_mode);
|
|
|
|
|
2008-04-02 23:12:16 +02:00
|
|
|
BOOL palette9_changed(IWineD3DSurfaceImpl *This);
|
|
|
|
|
2005-01-19 20:34:49 +01:00
|
|
|
/*****************************************************************************
|
|
|
|
* IWineD3DVertexDeclaration implementation structure
|
|
|
|
*/
|
2007-11-20 21:14:10 +01:00
|
|
|
typedef struct attrib_declaration {
|
|
|
|
DWORD usage;
|
|
|
|
DWORD idx;
|
|
|
|
} attrib_declaration;
|
|
|
|
|
|
|
|
#define MAX_ATTRIBS 16
|
|
|
|
|
2005-01-19 20:34:49 +01:00
|
|
|
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;
|
2007-08-03 19:53:25 +02:00
|
|
|
|
|
|
|
DWORD streams[MAX_STREAMS];
|
|
|
|
UINT num_streams;
|
2007-07-30 12:35:33 +02:00
|
|
|
BOOL position_transformed;
|
2007-12-20 01:34:22 +01:00
|
|
|
BOOL half_float_conv_needed;
|
2007-11-20 21:14:10 +01:00
|
|
|
|
|
|
|
/* Ordered array of declaration types that need swizzling in a vshader */
|
|
|
|
attrib_declaration swizzled_attribs[MAX_ATTRIBS];
|
|
|
|
UINT num_swizzled_attribs;
|
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];
|
2007-06-25 22:45:40 +02:00
|
|
|
BOOL textures[MAX_COMBINED_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];
|
2007-06-25 22:45:40 +02:00
|
|
|
BOOL samplerState[MAX_COMBINED_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
|
|
|
|
2007-08-09 17:45:29 +02:00
|
|
|
struct StageState {
|
|
|
|
DWORD stage;
|
|
|
|
DWORD state;
|
|
|
|
};
|
|
|
|
|
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;
|
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];
|
2007-07-04 17:57:45 +02:00
|
|
|
UINT streamOffset[MAX_STREAMS + 1 /* tesselated pseudo-stream */ ];
|
2005-07-05 16:05:18 +02:00
|
|
|
IWineD3DVertexBuffer *streamSource[MAX_STREAMS];
|
2007-07-04 17:57:45 +02:00
|
|
|
UINT streamFreq[MAX_STREAMS + 1];
|
|
|
|
UINT streamFlags[MAX_STREAMS + 1]; /*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-08-25 00:09:33 +02:00
|
|
|
INT baseVertexIndex;
|
|
|
|
INT 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 */
|
2007-06-25 22:45:40 +02:00
|
|
|
IWineD3DBaseTexture *textures[MAX_COMBINED_SAMPLERS];
|
|
|
|
int textureDimensions[MAX_COMBINED_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 */
|
2007-06-25 22:45:40 +02:00
|
|
|
DWORD samplerState[MAX_COMBINED_SAMPLERS][WINED3D_HIGHEST_SAMPLER_STATE + 1];
|
2005-06-24 13:53:07 +02:00
|
|
|
|
2007-01-10 11:28:42 +01:00
|
|
|
/* Scissor test rectangle */
|
|
|
|
RECT scissorRect;
|
2007-07-31 15:04:56 +02:00
|
|
|
|
|
|
|
/* Contained state management */
|
|
|
|
DWORD contained_render_states[WINEHIGHEST_RENDER_STATE + 1];
|
|
|
|
unsigned int num_contained_render_states;
|
2007-08-14 23:44:25 +02:00
|
|
|
DWORD contained_transform_states[HIGHEST_TRANSFORMSTATE + 1];
|
2007-07-31 15:44:13 +02:00
|
|
|
unsigned int num_contained_transform_states;
|
2007-08-03 20:07:30 +02:00
|
|
|
DWORD contained_vs_consts_i[MAX_CONST_I];
|
|
|
|
unsigned int num_contained_vs_consts_i;
|
|
|
|
DWORD contained_vs_consts_b[MAX_CONST_B];
|
|
|
|
unsigned int num_contained_vs_consts_b;
|
2007-08-03 20:26:29 +02:00
|
|
|
DWORD *contained_vs_consts_f;
|
|
|
|
unsigned int num_contained_vs_consts_f;
|
2007-08-03 20:12:54 +02:00
|
|
|
DWORD contained_ps_consts_i[MAX_CONST_I];
|
|
|
|
unsigned int num_contained_ps_consts_i;
|
|
|
|
DWORD contained_ps_consts_b[MAX_CONST_B];
|
|
|
|
unsigned int num_contained_ps_consts_b;
|
2007-08-03 20:26:29 +02:00
|
|
|
DWORD *contained_ps_consts_f;
|
|
|
|
unsigned int num_contained_ps_consts_f;
|
2007-08-09 17:45:29 +02:00
|
|
|
struct StageState contained_tss_states[MAX_TEXTURES * (WINED3D_HIGHEST_TEXTURE_STATE)];
|
|
|
|
unsigned int num_contained_tss_states;
|
2007-08-03 20:23:52 +02:00
|
|
|
struct StageState contained_sampler_states[MAX_COMBINED_SAMPLERS * WINED3D_HIGHEST_SAMPLER_STATE];
|
|
|
|
unsigned int num_contained_sampler_states;
|
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
|
|
|
|
2007-12-04 01:43:24 +01:00
|
|
|
/* Direct3D terminology with little modifications. We do not have an issued state
|
|
|
|
* because only the driver knows about it, but we have a created state because d3d
|
|
|
|
* allows GetData on a created issue, but opengl doesn't
|
|
|
|
*/
|
|
|
|
enum query_state {
|
|
|
|
QUERY_CREATED,
|
|
|
|
QUERY_SIGNALLED,
|
|
|
|
QUERY_BUILDING
|
|
|
|
};
|
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 */
|
2007-12-04 01:43:24 +01:00
|
|
|
enum query_state state;
|
2006-10-11 03:53:30 +02:00
|
|
|
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;
|
2008-02-28 21:02:58 +01:00
|
|
|
extern const IWineD3DQueryVtbl IWineD3DEventQuery_Vtbl;
|
2008-02-28 21:03:41 +01:00
|
|
|
extern const IWineD3DQueryVtbl IWineD3DOcclusionQuery_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;
|
2007-08-14 15:42:34 +02:00
|
|
|
WineD3DContext *ctx;
|
2005-09-21 11:43:13 +02:00
|
|
|
} WineQueryOcclusionData;
|
|
|
|
|
2007-03-01 00:34:33 +01:00
|
|
|
typedef struct WineQueryEventData {
|
|
|
|
GLuint fenceId;
|
2007-08-14 15:26:02 +02:00
|
|
|
WineD3DContext *ctx;
|
2007-03-01 00:34:33 +01:00
|
|
|
} 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;
|
2008-07-01 18:17:38 +02:00
|
|
|
WINED3DGAMMARAMP orig_gamma;
|
2005-06-23 13:05:24 +02:00
|
|
|
|
2007-01-10 11:27:26 +01:00
|
|
|
long prev_time, frames; /* Performance tracking */
|
2007-06-03 13:20:27 +02:00
|
|
|
unsigned int vSyncCounter;
|
2007-01-10 11:27:26 +01:00
|
|
|
|
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;
|
|
|
|
} IWineD3DSwapChainImpl;
|
|
|
|
|
2006-12-14 15:47:59 +01:00
|
|
|
extern const IWineD3DSwapChainVtbl IWineD3DSwapChain_Vtbl;
|
2008-08-05 21:23:00 +02:00
|
|
|
const IWineD3DSwapChainVtbl IWineGDISwapChain_Vtbl;
|
|
|
|
void x11_copy_to_screen(IWineD3DSwapChainImpl *This, LPRECT rc);
|
2005-06-23 13:05:24 +02:00
|
|
|
|
2008-07-28 01:04:16 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_QueryInterface(IWineD3DSwapChain *iface, REFIID riid, LPVOID *ppobj);
|
|
|
|
ULONG WINAPI IWineD3DBaseSwapChainImpl_AddRef(IWineD3DSwapChain *iface);
|
|
|
|
ULONG WINAPI IWineD3DBaseSwapChainImpl_Release(IWineD3DSwapChain *iface);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_GetParent(IWineD3DSwapChain *iface, IUnknown ** ppParent);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_GetFrontBufferData(IWineD3DSwapChain *iface, IWineD3DSurface *pDestSurface);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_GetBackBuffer(IWineD3DSwapChain *iface, UINT iBackBuffer, WINED3DBACKBUFFER_TYPE Type, IWineD3DSurface **ppBackBuffer);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_GetRasterStatus(IWineD3DSwapChain *iface, WINED3DRASTER_STATUS *pRasterStatus);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_GetDisplayMode(IWineD3DSwapChain *iface, WINED3DDISPLAYMODE*pMode);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_GetDevice(IWineD3DSwapChain *iface, IWineD3DDevice**ppDevice);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_GetPresentParameters(IWineD3DSwapChain *iface, WINED3DPRESENT_PARAMETERS *pPresentationParameters);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_SetGammaRamp(IWineD3DSwapChain *iface, DWORD Flags, CONST WINED3DGAMMARAMP *pRamp);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_GetGammaRamp(IWineD3DSwapChain *iface, WINED3DGAMMARAMP *pRamp);
|
|
|
|
|
2007-06-02 22:21:57 +02:00
|
|
|
WineD3DContext *IWineD3DSwapChainImpl_CreateContextForThread(IWineD3DSwapChain *iface);
|
|
|
|
|
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);
|
2007-07-04 17:57:45 +02:00
|
|
|
const char *debug_d3dbasis(WINED3DBASISTYPE basis);
|
|
|
|
const char *debug_d3ddegree(WINED3DDEGREETYPE order);
|
2008-07-12 18:45:33 +02:00
|
|
|
const char* debug_d3dtop(WINED3DTEXTUREOP d3dtop);
|
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);
|
2008-07-12 18:45:33 +02:00
|
|
|
BOOL is_invalid_op(IWineD3DDeviceImpl *This, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3);
|
2008-03-29 13:55:59 +01:00
|
|
|
void set_tex_op_nvrc(IWineD3DDevice *iface, BOOL is_alpha, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3, INT texture_idx, DWORD dst);
|
2007-08-27 14:33:46 +02:00
|
|
|
void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords, BOOL transformed, DWORD coordtype);
|
2008-04-23 22:23:57 +02:00
|
|
|
void texture_activate_dimensions(DWORD stage, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context);
|
2008-07-04 19:06:58 +02:00
|
|
|
void sampler_texdim(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context);
|
2008-07-06 01:31:34 +02:00
|
|
|
void tex_alphaop(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context);
|
|
|
|
void apply_pixelshader(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context);
|
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);
|
2008-07-02 23:00:41 +02:00
|
|
|
void surface_modify_ds_location(IWineD3DSurface *iface, DWORD location);
|
|
|
|
void surface_load_ds_location(IWineD3DSurface *iface, DWORD location);
|
2007-04-09 01:53:32 +02:00
|
|
|
|
2007-08-09 01:04:30 +02:00
|
|
|
BOOL getColorBits(WINED3DFORMAT fmt, short *redSize, short *greenSize, short *blueSize, short *alphaSize, short *totalSize);
|
|
|
|
BOOL getDepthStencilBits(WINED3DFORMAT fmt, short *depthSize, short *stencilSize);
|
|
|
|
|
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);
|
2007-09-13 12:25:29 +02:00
|
|
|
unsigned int count_bits(unsigned int mask);
|
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);
|
2008-01-12 22:56:30 +01:00
|
|
|
extern void WINAPI IWineD3DResourceImpl_UnLoad(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);
|
2008-01-25 18:18:06 +01:00
|
|
|
extern void WINAPI IWineD3DBaseTextureImpl_UnLoad(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);
|
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
|
|
|
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-11-06 23:36:10 +01:00
|
|
|
GLhandleARB vuniformI_locations[MAX_CONST_I];
|
|
|
|
GLhandleARB puniformI_locations[MAX_CONST_I];
|
2007-11-06 23:05:38 +01:00
|
|
|
GLhandleARB posFixup_location;
|
2008-03-05 03:18:55 +01:00
|
|
|
GLhandleARB bumpenvmat_location[MAX_TEXTURES];
|
|
|
|
GLhandleARB luminancescale_location[MAX_TEXTURES];
|
|
|
|
GLhandleARB luminanceoffset_location[MAX_TEXTURES];
|
2007-11-06 23:05:38 +01:00
|
|
|
GLhandleARB srgb_comparison_location;
|
|
|
|
GLhandleARB srgb_mul_low_location;
|
|
|
|
GLhandleARB ycorrection_location;
|
2008-06-19 00:36:35 +02:00
|
|
|
GLenum vertex_color_clamp;
|
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-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 */
|
2007-12-06 22:10:11 +01:00
|
|
|
DWORD texcoord_mask[MAX_REG_TEXCRD]; /* vertex < 3.0 */
|
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) */
|
2007-06-25 22:45:40 +02:00
|
|
|
DWORD samplers[max(MAX_FRAGMENT_SAMPLERS, MAX_VERTEX_SAMPLERS)];
|
2008-03-05 03:18:55 +01:00
|
|
|
BOOL bumpmat[MAX_TEXTURES], luminanceparams[MAX_TEXTURES];
|
2007-10-13 13:03:56 +02:00
|
|
|
char usesnrm, vpos, usesdsy;
|
2007-11-09 14:48:47 +01:00
|
|
|
char usesrelconstF;
|
2006-06-12 08:59:16 +02:00
|
|
|
|
2007-09-14 13:21:52 +02:00
|
|
|
/* Whether or not loops are used in this shader, and nesting depth */
|
|
|
|
unsigned loop_depth;
|
2006-06-14 04:32:14 +02:00
|
|
|
|
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;
|
|
|
|
|
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;
|
|
|
|
|
2007-11-28 12:55:11 +01:00
|
|
|
#ifdef __GNUC__
|
|
|
|
#define PRINTF_ATTR(fmt,args) __attribute__((format (printf,fmt,args)))
|
|
|
|
#else
|
|
|
|
#define PRINTF_ATTR(fmt,args)
|
|
|
|
#endif
|
|
|
|
|
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,
|
2007-11-28 12:55:11 +01:00
|
|
|
const char* fmt, ...) PRINTF_ATTR(2,3);
|
2006-05-08 21:44:25 +02:00
|
|
|
|
2006-05-09 13:57:36 +02:00
|
|
|
extern const SHADER_OPCODE* shader_get_opcode(
|
|
|
|
IWineD3DBaseShader *iface,
|
|
|
|
const DWORD code);
|
|
|
|
|
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);
|
2007-08-31 17:00:16 +02:00
|
|
|
extern void pshader_hw_texdepth(SHADER_OPCODE_ARG* arg);
|
2007-08-30 23:35:50 +02:00
|
|
|
extern void pshader_hw_texkill(SHADER_OPCODE_ARG* arg);
|
2007-09-25 01:00:27 +02:00
|
|
|
extern void pshader_hw_texdp3tex(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_hw_texdp3(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_hw_texm3x3(SHADER_OPCODE_ARG* arg);
|
|
|
|
extern void pshader_hw_texm3x2depth(SHADER_OPCODE_ARG* arg);
|
2007-09-05 16:46:12 +02:00
|
|
|
extern void pshader_hw_dp2add(SHADER_OPCODE_ARG* arg);
|
2007-09-05 17:05:58 +02:00
|
|
|
extern void pshader_hw_texreg2rgb(SHADER_OPCODE_ARG* arg);
|
2006-07-03 03:27:15 +02:00
|
|
|
|
2007-09-05 20:09:06 +02:00
|
|
|
/* ARB vertex / pixel shader common prototypes */
|
|
|
|
extern void shader_hw_nrm(SHADER_OPCODE_ARG* arg);
|
2007-09-26 22:09:59 +02:00
|
|
|
extern void shader_hw_sincos(SHADER_OPCODE_ARG* arg);
|
2007-09-05 20:01:53 +02:00
|
|
|
extern void shader_hw_mnxn(SHADER_OPCODE_ARG* arg);
|
2007-09-05 20:09:06 +02:00
|
|
|
|
2006-07-03 03:27:15 +02:00
|
|
|
/* ARB vertex shader prototypes */
|
|
|
|
extern void vshader_hw_map2gl(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);
|
2007-07-02 22:40:06 +02:00
|
|
|
extern void shader_glsl_rsq(SHADER_OPCODE_ARG* arg);
|
2006-06-09 09:35:15 +02:00
|
|
|
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);
|
2007-05-11 12:12:40 +02:00
|
|
|
extern void shader_glsl_pow(SHADER_OPCODE_ARG* arg);
|
2007-09-09 21:24:53 +02:00
|
|
|
extern void shader_glsl_log(SHADER_OPCODE_ARG* arg);
|
2007-06-27 23:46:53 +02:00
|
|
|
extern void shader_glsl_texldl(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,
|
2007-10-26 02:11:00 +02:00
|
|
|
semantic* semantics_out,
|
|
|
|
IWineD3DPixelShader *iface);
|
2006-06-09 09:35:15 +02:00
|
|
|
|
2006-03-30 19:14:31 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
* IDirect3DBaseShader implementation structure
|
|
|
|
*/
|
|
|
|
typedef struct IWineD3DBaseShaderClass
|
|
|
|
{
|
2007-11-16 21:01:33 +01:00
|
|
|
LONG ref;
|
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;
|
2007-11-16 21:02:29 +01:00
|
|
|
DWORD *function;
|
2006-03-30 19:14:31 +02:00
|
|
|
UINT functionLength;
|
|
|
|
GLuint prgId;
|
2006-08-05 18:15:35 +02:00
|
|
|
BOOL is_compiled;
|
2007-09-14 13:21:52 +02:00
|
|
|
UINT cur_loop_depth, cur_loop_regno;
|
2007-11-09 14:48:47 +01:00
|
|
|
BOOL load_local_constsF;
|
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
|
|
|
|
2007-09-21 23:47:40 +02:00
|
|
|
/* Pixel formats of sampled textures, for format conversion. This
|
|
|
|
* represents the formats found during compilation, it is not initialized
|
|
|
|
* on the first parser pass. It is needed to check if the shader
|
|
|
|
* needs recompilation to adjust the format conversion
|
|
|
|
*/
|
|
|
|
WINED3DFORMAT sampled_format[MAX_COMBINED_SAMPLERS];
|
|
|
|
UINT sampled_samplers[MAX_COMBINED_SAMPLERS];
|
|
|
|
UINT num_sampled_samplers;
|
|
|
|
|
|
|
|
UINT recompile_count;
|
|
|
|
|
2006-09-27 13:14:46 +02:00
|
|
|
/* Pointer to the parent device */
|
|
|
|
IWineD3DDevice *device;
|
2008-01-08 20:45:59 +01:00
|
|
|
struct list shader_list_entry;
|
2006-09-27 13:14:46 +02:00
|
|
|
|
2006-03-30 19:14:31 +02:00
|
|
|
} IWineD3DBaseShaderClass;
|
|
|
|
|
|
|
|
typedef struct IWineD3DBaseShaderImpl {
|
|
|
|
/* IUnknown */
|
|
|
|
const IWineD3DBaseShaderVtbl *lpVtbl;
|
|
|
|
|
|
|
|
/* IWineD3DBaseShader */
|
|
|
|
IWineD3DBaseShaderClass baseShader;
|
|
|
|
} IWineD3DBaseShaderImpl;
|
|
|
|
|
2007-11-16 21:01:33 +01:00
|
|
|
HRESULT WINAPI IWineD3DBaseShaderImpl_QueryInterface(IWineD3DBaseShader *iface, REFIID riid, LPVOID *ppobj);
|
|
|
|
ULONG WINAPI IWineD3DBaseShaderImpl_AddRef(IWineD3DBaseShader *iface);
|
|
|
|
ULONG WINAPI IWineD3DBaseShaderImpl_Release(IWineD3DBaseShader *iface);
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2007-12-06 22:10:11 +01:00
|
|
|
static inline int shader_get_writemask(const DWORD param) {
|
|
|
|
return param & WINED3DSP_WRITEMASK_ALL;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
static inline BOOL shader_is_scalar(DWORD param) {
|
|
|
|
DWORD reg_type = shader_get_regtype(param);
|
2008-02-11 12:04:57 +01:00
|
|
|
DWORD reg_num;
|
2007-04-12 23:55:31 +02:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2008-02-11 12:04:57 +01:00
|
|
|
case WINED3DSPR_MISCTYPE:
|
|
|
|
reg_num = param & WINED3DSP_REGNUM_MASK;
|
|
|
|
switch(reg_num) {
|
|
|
|
case 0: /* vPos */
|
|
|
|
return FALSE;
|
|
|
|
case 1: /* vFace */
|
|
|
|
return TRUE;
|
|
|
|
default:
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2007-04-12 23:55:31 +02:00
|
|
|
default:
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-14 14:15:49 +01:00
|
|
|
static inline BOOL shader_constant_is_local(IWineD3DBaseShaderImpl* This, DWORD reg) {
|
|
|
|
local_constant* lconst;
|
|
|
|
|
|
|
|
if(This->baseShader.load_local_constsF) return FALSE;
|
|
|
|
LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
|
|
|
|
if(lconst->idx == reg) return TRUE;
|
|
|
|
}
|
|
|
|
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-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
|
|
|
|
2007-11-20 21:14:10 +01:00
|
|
|
/* Ordered array of attributes that are swizzled */
|
|
|
|
attrib_declaration swizzled_attribs [MAX_ATTRIBS];
|
|
|
|
UINT num_swizzled_attribs;
|
|
|
|
|
2008-05-06 15:54:52 +02:00
|
|
|
/* run time data... */
|
2005-12-09 11:23:52 +01:00
|
|
|
VSHADERDATA *data;
|
2007-11-07 19:57:49 +01:00
|
|
|
UINT min_rel_offset, max_rel_offset;
|
|
|
|
UINT rel_offset;
|
|
|
|
|
2007-11-20 21:14:10 +01:00
|
|
|
UINT recompile_count;
|
2005-03-02 13:16:10 +01:00
|
|
|
#if 0 /* needs reworking */
|
2008-05-06 15:54:52 +02:00
|
|
|
/* run time data */
|
2005-03-02 13:16:10 +01:00
|
|
|
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
|
|
|
|
*/
|
2007-10-26 02:11:00 +02:00
|
|
|
|
|
|
|
enum vertexprocessing_mode {
|
|
|
|
fixedfunction,
|
|
|
|
vertexshader,
|
|
|
|
pretransformed
|
|
|
|
};
|
|
|
|
|
2008-03-05 03:18:55 +01:00
|
|
|
struct stb_const_desc {
|
|
|
|
char texunit;
|
|
|
|
UINT const_num;
|
|
|
|
};
|
|
|
|
|
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-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];
|
2007-10-28 00:12:37 +02:00
|
|
|
DWORD input_reg_map[MAX_REG_INPUT];
|
2007-11-06 12:34:22 +01:00
|
|
|
BOOL input_reg_used[MAX_REG_INPUT];
|
2008-06-19 00:36:35 +02:00
|
|
|
int declared_in_count;
|
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 */
|
2008-03-05 03:18:55 +01:00
|
|
|
struct stb_const_desc bumpenvmatconst[MAX_TEXTURES];
|
|
|
|
char numbumpenvmatconsts;
|
|
|
|
struct stb_const_desc luminanceconst[MAX_TEXTURES];
|
2007-09-14 13:02:59 +02:00
|
|
|
char srgb_enabled;
|
|
|
|
char srgb_mode_hardcoded;
|
|
|
|
UINT srgb_low_const;
|
|
|
|
UINT srgb_cmp_const;
|
2007-09-14 13:11:00 +02:00
|
|
|
char vpos_uniform;
|
|
|
|
BOOL render_offscreen;
|
|
|
|
UINT height;
|
2007-10-26 02:11:00 +02:00
|
|
|
enum vertexprocessing_mode vertexprocessing;
|
2007-02-15 03:05:17 +01:00
|
|
|
|
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
|
|
|
|
2007-09-14 13:02:59 +02:00
|
|
|
/* sRGB correction constants */
|
|
|
|
static const float srgb_cmp = 0.0031308;
|
|
|
|
static const float srgb_mul_low = 12.92;
|
|
|
|
static const float srgb_pow = 0.41666;
|
|
|
|
static const float srgb_mul_high = 1.055;
|
|
|
|
static const float srgb_sub_high = 0.055;
|
|
|
|
|
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;
|
2007-08-09 01:04:30 +02:00
|
|
|
short depthSize, stencilSize;
|
2006-06-21 10:36:14 +02:00
|
|
|
BOOL isFourcc;
|
2007-07-23 11:13:37 +02:00
|
|
|
} StaticPixelFormatDesc;
|
|
|
|
|
|
|
|
const StaticPixelFormatDesc *getFormatDescEntry(WINED3DFORMAT fmt,
|
2007-07-27 13:22:54 +02:00
|
|
|
WineD3D_GL_Info *gl_info,
|
2007-07-23 11:13:37 +02:00
|
|
|
const GlPixelFormatDesc **glDesc);
|
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,
|
2007-07-24 23:38:40 +02:00
|
|
|
IWineD3DSurface *dst_surface, WINED3DRECT *dst_rect, const WINED3DTEXTUREFILTERTYPE filter, BOOL flip);
|
2008-07-02 23:00:11 +02:00
|
|
|
void bind_fbo(IWineD3DDevice *iface, GLenum target, GLuint *fbo);
|
|
|
|
void attach_depth_stencil_fbo(IWineD3DDeviceImpl *This, GLenum fbo_target, IWineD3DSurface *depth_stencil, BOOL use_render_buffer);
|
2008-08-04 19:28:42 +02:00
|
|
|
void attach_surface_fbo(IWineD3DDeviceImpl *This, GLenum fbo_target, DWORD idx, IWineD3DSurface *surface);
|
2008-07-02 23:00:41 +02:00
|
|
|
void depth_blt(IWineD3DDevice *iface, GLuint texture);
|
2008-07-02 23:00:11 +02:00
|
|
|
|
2003-11-14 04:50:35 +01:00
|
|
|
#endif
|