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
|
2009-05-01 09:13:54 +02:00
|
|
|
* Copyright 2002-2003, 2004 Jason Edmeades
|
2005-06-23 13:05:24 +02:00
|
|
|
* 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
|
|
|
|
2008-11-25 11:57:39 +01:00
|
|
|
#include "objbase.h"
|
|
|
|
#include "wine/wined3d.h"
|
2008-11-20 13:32:00 +01:00
|
|
|
#include "wined3d_gl.h"
|
2006-06-09 09:33:01 +02:00
|
|
|
#include "wine/list.h"
|
2009-06-03 10:47:26 +02:00
|
|
|
#include "wine/rbtree.h"
|
2003-11-14 04:50:35 +01:00
|
|
|
|
2008-12-03 14:53:43 +01:00
|
|
|
/* Texture format fixups */
|
|
|
|
|
|
|
|
enum fixup_channel_source
|
|
|
|
{
|
|
|
|
CHANNEL_SOURCE_ZERO = 0,
|
|
|
|
CHANNEL_SOURCE_ONE = 1,
|
|
|
|
CHANNEL_SOURCE_X = 2,
|
|
|
|
CHANNEL_SOURCE_Y = 3,
|
|
|
|
CHANNEL_SOURCE_Z = 4,
|
|
|
|
CHANNEL_SOURCE_W = 5,
|
|
|
|
CHANNEL_SOURCE_YUV0 = 6,
|
|
|
|
CHANNEL_SOURCE_YUV1 = 7,
|
|
|
|
};
|
|
|
|
|
|
|
|
enum yuv_fixup
|
|
|
|
{
|
|
|
|
YUV_FIXUP_YUY2 = 0,
|
|
|
|
YUV_FIXUP_UYVY = 1,
|
|
|
|
YUV_FIXUP_YV12 = 2,
|
|
|
|
};
|
|
|
|
|
|
|
|
#include <pshpack2.h>
|
|
|
|
struct color_fixup_desc
|
|
|
|
{
|
|
|
|
unsigned x_sign_fixup : 1;
|
|
|
|
unsigned x_source : 3;
|
|
|
|
unsigned y_sign_fixup : 1;
|
|
|
|
unsigned y_source : 3;
|
|
|
|
unsigned z_sign_fixup : 1;
|
|
|
|
unsigned z_source : 3;
|
|
|
|
unsigned w_sign_fixup : 1;
|
|
|
|
unsigned w_source : 3;
|
|
|
|
};
|
|
|
|
#include <poppack.h>
|
|
|
|
|
|
|
|
static const struct color_fixup_desc COLOR_FIXUP_IDENTITY =
|
|
|
|
{0, CHANNEL_SOURCE_X, 0, CHANNEL_SOURCE_Y, 0, CHANNEL_SOURCE_Z, 0, CHANNEL_SOURCE_W};
|
|
|
|
|
|
|
|
static inline struct color_fixup_desc create_color_fixup_desc(
|
|
|
|
int sign0, enum fixup_channel_source src0, int sign1, enum fixup_channel_source src1,
|
|
|
|
int sign2, enum fixup_channel_source src2, int sign3, enum fixup_channel_source src3)
|
|
|
|
{
|
|
|
|
struct color_fixup_desc fixup =
|
|
|
|
{
|
|
|
|
sign0, src0,
|
|
|
|
sign1, src1,
|
|
|
|
sign2, src2,
|
|
|
|
sign3, src3,
|
|
|
|
};
|
|
|
|
return fixup;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct color_fixup_desc create_yuv_fixup_desc(enum yuv_fixup yuv_fixup)
|
|
|
|
{
|
|
|
|
struct color_fixup_desc fixup =
|
|
|
|
{
|
|
|
|
0, yuv_fixup & (1 << 0) ? CHANNEL_SOURCE_YUV1 : CHANNEL_SOURCE_YUV0,
|
|
|
|
0, yuv_fixup & (1 << 1) ? CHANNEL_SOURCE_YUV1 : CHANNEL_SOURCE_YUV0,
|
|
|
|
0, yuv_fixup & (1 << 2) ? CHANNEL_SOURCE_YUV1 : CHANNEL_SOURCE_YUV0,
|
|
|
|
0, yuv_fixup & (1 << 3) ? CHANNEL_SOURCE_YUV1 : CHANNEL_SOURCE_YUV0,
|
|
|
|
};
|
|
|
|
return fixup;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline BOOL is_identity_fixup(struct color_fixup_desc fixup)
|
|
|
|
{
|
|
|
|
return !memcmp(&fixup, &COLOR_FIXUP_IDENTITY, sizeof(fixup));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline BOOL is_yuv_fixup(struct color_fixup_desc fixup)
|
|
|
|
{
|
|
|
|
return fixup.x_source == CHANNEL_SOURCE_YUV0 || fixup.x_source == CHANNEL_SOURCE_YUV1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline enum yuv_fixup get_yuv_fixup(struct color_fixup_desc fixup)
|
|
|
|
{
|
|
|
|
enum yuv_fixup yuv_fixup = 0;
|
|
|
|
if (fixup.x_source == CHANNEL_SOURCE_YUV1) yuv_fixup |= (1 << 0);
|
|
|
|
if (fixup.y_source == CHANNEL_SOURCE_YUV1) yuv_fixup |= (1 << 1);
|
|
|
|
if (fixup.z_source == CHANNEL_SOURCE_YUV1) yuv_fixup |= (1 << 2);
|
|
|
|
if (fixup.w_source == CHANNEL_SOURCE_YUV1) yuv_fixup |= (1 << 3);
|
|
|
|
return yuv_fixup;
|
|
|
|
}
|
|
|
|
|
2009-06-03 10:47:26 +02:00
|
|
|
void *wined3d_rb_alloc(size_t size);
|
|
|
|
void *wined3d_rb_realloc(void *ptr, size_t size);
|
|
|
|
void wined3d_rb_free(void *ptr);
|
2007-02-27 20:51:48 +01:00
|
|
|
|
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
|
2005-06-24 13:53:07 +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;
|
|
|
|
|
2008-11-28 15:30:11 +01:00
|
|
|
extern const int minLookup[MAX_LOOKUPS];
|
|
|
|
extern const int maxLookup[MAX_LOOKUPS];
|
2005-08-03 13:00:28 +02:00
|
|
|
extern DWORD *stateLookup[MAX_LOOKUPS];
|
|
|
|
|
2008-11-26 16:14:40 +01:00
|
|
|
struct min_lookup
|
|
|
|
{
|
|
|
|
GLenum mip[WINED3DTEXF_LINEAR + 1];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct min_lookup minMipLookup[WINED3DTEXF_ANISOTROPIC + 1];
|
|
|
|
const struct min_lookup minMipLookup_noFilter[WINED3DTEXF_ANISOTROPIC + 1];
|
|
|
|
GLenum magLookup[WINED3DTEXF_ANISOTROPIC + 1];
|
|
|
|
const GLenum magLookup_noFilter[WINED3DTEXF_ANISOTROPIC + 1];
|
2008-04-06 00:31:39 +02:00
|
|
|
|
2008-11-26 16:14:40 +01:00
|
|
|
extern const struct filter_lookup filter_lookup_nofilter;
|
|
|
|
extern struct filter_lookup filter_lookup;
|
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 */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-16 09:38:25 +02:00
|
|
|
static inline float float_24_to_32(DWORD in)
|
|
|
|
{
|
|
|
|
const float sgn = in & 0x800000 ? -1.0f : 1.0f;
|
|
|
|
const unsigned short e = (in & 0x780000) >> 19;
|
|
|
|
const unsigned short m = in & 0x7ffff;
|
|
|
|
|
|
|
|
if (e == 0)
|
|
|
|
{
|
|
|
|
if (m == 0) return sgn * 0.0f; /* +0.0 or -0.0 */
|
|
|
|
else return sgn * pow(2, -6.0f) * ((float)m / 524288.0f);
|
|
|
|
}
|
|
|
|
else if (e < 15)
|
|
|
|
{
|
|
|
|
return sgn * pow(2, (float)e - 7.0f) * (1.0f + ((float)m / 524288.0f));
|
|
|
|
}
|
|
|
|
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
|
|
|
|
|
2008-11-23 22:51:03 +01:00
|
|
|
#define PCI_VENDOR_NONE 0xffff /* e.g. 0x8086 for Intel and 0x10de for Nvidia */
|
2008-11-23 22:33:29 +01:00
|
|
|
#define PCI_DEVICE_NONE 0xffff /* e.g. 0x14f for a Geforce6200 */
|
|
|
|
|
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;
|
2008-11-23 22:51:03 +01:00
|
|
|
unsigned short pci_vendor_id;
|
2008-11-23 22:33:29 +01:00
|
|
|
unsigned short pci_device_id;
|
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;
|
|
|
|
|
2009-05-01 09:13:54 +02:00
|
|
|
typedef enum _WINED3DSAMPLER_TEXTURE_TYPE
|
|
|
|
{
|
|
|
|
WINED3DSTT_UNKNOWN = 0,
|
|
|
|
WINED3DSTT_1D = 1,
|
|
|
|
WINED3DSTT_2D = 2,
|
|
|
|
WINED3DSTT_CUBE = 3,
|
|
|
|
WINED3DSTT_VOLUME = 4,
|
|
|
|
} WINED3DSAMPLER_TEXTURE_TYPE;
|
|
|
|
|
|
|
|
typedef enum _WINED3DSHADER_PARAM_REGISTER_TYPE
|
|
|
|
{
|
|
|
|
WINED3DSPR_TEMP = 0,
|
|
|
|
WINED3DSPR_INPUT = 1,
|
|
|
|
WINED3DSPR_CONST = 2,
|
|
|
|
WINED3DSPR_ADDR = 3,
|
|
|
|
WINED3DSPR_TEXTURE = 3,
|
|
|
|
WINED3DSPR_RASTOUT = 4,
|
|
|
|
WINED3DSPR_ATTROUT = 5,
|
|
|
|
WINED3DSPR_TEXCRDOUT = 6,
|
|
|
|
WINED3DSPR_OUTPUT = 6,
|
|
|
|
WINED3DSPR_CONSTINT = 7,
|
|
|
|
WINED3DSPR_COLOROUT = 8,
|
|
|
|
WINED3DSPR_DEPTHOUT = 9,
|
|
|
|
WINED3DSPR_SAMPLER = 10,
|
|
|
|
WINED3DSPR_CONST2 = 11,
|
|
|
|
WINED3DSPR_CONST3 = 12,
|
|
|
|
WINED3DSPR_CONST4 = 13,
|
|
|
|
WINED3DSPR_CONSTBOOL = 14,
|
|
|
|
WINED3DSPR_LOOP = 15,
|
|
|
|
WINED3DSPR_TEMPFLOAT16 = 16,
|
|
|
|
WINED3DSPR_MISCTYPE = 17,
|
|
|
|
WINED3DSPR_LABEL = 18,
|
|
|
|
WINED3DSPR_PREDICATE = 19,
|
2009-05-06 10:05:46 +02:00
|
|
|
WINED3DSPR_IMMCONST,
|
2009-05-01 09:13:54 +02:00
|
|
|
} WINED3DSHADER_PARAM_REGISTER_TYPE;
|
|
|
|
|
2009-05-06 10:05:46 +02:00
|
|
|
enum wined3d_immconst_type
|
|
|
|
{
|
|
|
|
WINED3D_IMMCONST_FLOAT,
|
|
|
|
WINED3D_IMMCONST_FLOAT4,
|
|
|
|
};
|
|
|
|
|
2009-05-01 09:13:54 +02:00
|
|
|
typedef enum _WINED3DVS_RASTOUT_OFFSETS
|
|
|
|
{
|
|
|
|
WINED3DSRO_POSITION = 0,
|
|
|
|
WINED3DSRO_FOG = 1,
|
|
|
|
WINED3DSRO_POINT_SIZE = 2,
|
|
|
|
} WINED3DVS_RASTOUT_OFFSETS;
|
|
|
|
|
|
|
|
#define WINED3DSP_NOSWIZZLE (0 | (1 << 2) | (2 << 4) | (3 << 6))
|
|
|
|
|
|
|
|
typedef enum _WINED3DSHADER_PARAM_SRCMOD_TYPE
|
|
|
|
{
|
|
|
|
WINED3DSPSM_NONE = 0,
|
|
|
|
WINED3DSPSM_NEG = 1,
|
|
|
|
WINED3DSPSM_BIAS = 2,
|
|
|
|
WINED3DSPSM_BIASNEG = 3,
|
|
|
|
WINED3DSPSM_SIGN = 4,
|
|
|
|
WINED3DSPSM_SIGNNEG = 5,
|
|
|
|
WINED3DSPSM_COMP = 6,
|
|
|
|
WINED3DSPSM_X2 = 7,
|
|
|
|
WINED3DSPSM_X2NEG = 8,
|
|
|
|
WINED3DSPSM_DZ = 9,
|
|
|
|
WINED3DSPSM_DW = 10,
|
|
|
|
WINED3DSPSM_ABS = 11,
|
|
|
|
WINED3DSPSM_ABSNEG = 12,
|
|
|
|
WINED3DSPSM_NOT = 13,
|
|
|
|
} WINED3DSHADER_PARAM_SRCMOD_TYPE;
|
|
|
|
|
2009-05-06 10:05:45 +02:00
|
|
|
#define WINED3DSP_WRITEMASK_0 0x1 /* .x r */
|
|
|
|
#define WINED3DSP_WRITEMASK_1 0x2 /* .y g */
|
|
|
|
#define WINED3DSP_WRITEMASK_2 0x4 /* .z b */
|
|
|
|
#define WINED3DSP_WRITEMASK_3 0x8 /* .w a */
|
|
|
|
#define WINED3DSP_WRITEMASK_ALL 0xf /* all */
|
2009-05-01 09:13:54 +02:00
|
|
|
|
|
|
|
typedef enum _WINED3DSHADER_PARAM_DSTMOD_TYPE
|
|
|
|
{
|
|
|
|
WINED3DSPDM_NONE = 0,
|
|
|
|
WINED3DSPDM_SATURATE = 1,
|
|
|
|
WINED3DSPDM_PARTIALPRECISION = 2,
|
|
|
|
WINED3DSPDM_MSAMPCENTROID = 4,
|
|
|
|
} WINED3DSHADER_PARAM_DSTMOD_TYPE;
|
|
|
|
|
|
|
|
typedef enum _WINED3DSHADER_INSTRUCTION_OPCODE_TYPE
|
|
|
|
{
|
|
|
|
WINED3DSIO_NOP = 0,
|
|
|
|
WINED3DSIO_MOV = 1,
|
|
|
|
WINED3DSIO_ADD = 2,
|
|
|
|
WINED3DSIO_SUB = 3,
|
|
|
|
WINED3DSIO_MAD = 4,
|
|
|
|
WINED3DSIO_MUL = 5,
|
|
|
|
WINED3DSIO_RCP = 6,
|
|
|
|
WINED3DSIO_RSQ = 7,
|
|
|
|
WINED3DSIO_DP3 = 8,
|
|
|
|
WINED3DSIO_DP4 = 9,
|
|
|
|
WINED3DSIO_MIN = 10,
|
|
|
|
WINED3DSIO_MAX = 11,
|
|
|
|
WINED3DSIO_SLT = 12,
|
|
|
|
WINED3DSIO_SGE = 13,
|
|
|
|
WINED3DSIO_EXP = 14,
|
|
|
|
WINED3DSIO_LOG = 15,
|
|
|
|
WINED3DSIO_LIT = 16,
|
|
|
|
WINED3DSIO_DST = 17,
|
|
|
|
WINED3DSIO_LRP = 18,
|
|
|
|
WINED3DSIO_FRC = 19,
|
|
|
|
WINED3DSIO_M4x4 = 20,
|
|
|
|
WINED3DSIO_M4x3 = 21,
|
|
|
|
WINED3DSIO_M3x4 = 22,
|
|
|
|
WINED3DSIO_M3x3 = 23,
|
|
|
|
WINED3DSIO_M3x2 = 24,
|
|
|
|
WINED3DSIO_CALL = 25,
|
|
|
|
WINED3DSIO_CALLNZ = 26,
|
|
|
|
WINED3DSIO_LOOP = 27,
|
|
|
|
WINED3DSIO_RET = 28,
|
|
|
|
WINED3DSIO_ENDLOOP = 29,
|
|
|
|
WINED3DSIO_LABEL = 30,
|
|
|
|
WINED3DSIO_DCL = 31,
|
|
|
|
WINED3DSIO_POW = 32,
|
|
|
|
WINED3DSIO_CRS = 33,
|
|
|
|
WINED3DSIO_SGN = 34,
|
|
|
|
WINED3DSIO_ABS = 35,
|
|
|
|
WINED3DSIO_NRM = 36,
|
|
|
|
WINED3DSIO_SINCOS = 37,
|
|
|
|
WINED3DSIO_REP = 38,
|
|
|
|
WINED3DSIO_ENDREP = 39,
|
|
|
|
WINED3DSIO_IF = 40,
|
|
|
|
WINED3DSIO_IFC = 41,
|
|
|
|
WINED3DSIO_ELSE = 42,
|
|
|
|
WINED3DSIO_ENDIF = 43,
|
|
|
|
WINED3DSIO_BREAK = 44,
|
|
|
|
WINED3DSIO_BREAKC = 45,
|
|
|
|
WINED3DSIO_MOVA = 46,
|
|
|
|
WINED3DSIO_DEFB = 47,
|
|
|
|
WINED3DSIO_DEFI = 48,
|
|
|
|
|
|
|
|
WINED3DSIO_TEXCOORD = 64,
|
|
|
|
WINED3DSIO_TEXKILL = 65,
|
|
|
|
WINED3DSIO_TEX = 66,
|
|
|
|
WINED3DSIO_TEXBEM = 67,
|
|
|
|
WINED3DSIO_TEXBEML = 68,
|
|
|
|
WINED3DSIO_TEXREG2AR = 69,
|
|
|
|
WINED3DSIO_TEXREG2GB = 70,
|
|
|
|
WINED3DSIO_TEXM3x2PAD = 71,
|
|
|
|
WINED3DSIO_TEXM3x2TEX = 72,
|
|
|
|
WINED3DSIO_TEXM3x3PAD = 73,
|
|
|
|
WINED3DSIO_TEXM3x3TEX = 74,
|
|
|
|
WINED3DSIO_TEXM3x3DIFF = 75,
|
|
|
|
WINED3DSIO_TEXM3x3SPEC = 76,
|
|
|
|
WINED3DSIO_TEXM3x3VSPEC = 77,
|
|
|
|
WINED3DSIO_EXPP = 78,
|
|
|
|
WINED3DSIO_LOGP = 79,
|
|
|
|
WINED3DSIO_CND = 80,
|
|
|
|
WINED3DSIO_DEF = 81,
|
|
|
|
WINED3DSIO_TEXREG2RGB = 82,
|
|
|
|
WINED3DSIO_TEXDP3TEX = 83,
|
|
|
|
WINED3DSIO_TEXM3x2DEPTH = 84,
|
|
|
|
WINED3DSIO_TEXDP3 = 85,
|
|
|
|
WINED3DSIO_TEXM3x3 = 86,
|
|
|
|
WINED3DSIO_TEXDEPTH = 87,
|
|
|
|
WINED3DSIO_CMP = 88,
|
|
|
|
WINED3DSIO_BEM = 89,
|
|
|
|
WINED3DSIO_DP2ADD = 90,
|
|
|
|
WINED3DSIO_DSX = 91,
|
|
|
|
WINED3DSIO_DSY = 92,
|
|
|
|
WINED3DSIO_TEXLDD = 93,
|
|
|
|
WINED3DSIO_SETP = 94,
|
|
|
|
WINED3DSIO_TEXLDL = 95,
|
|
|
|
WINED3DSIO_BREAKP = 96,
|
|
|
|
|
|
|
|
WINED3DSIO_PHASE = 0xfffd,
|
|
|
|
WINED3DSIO_COMMENT = 0xfffe,
|
|
|
|
WINED3DSIO_END = 0Xffff,
|
|
|
|
} WINED3DSHADER_INSTRUCTION_OPCODE_TYPE;
|
|
|
|
|
|
|
|
/* Undocumented opcode control to identify projective texture lookups in ps 2.0 and later */
|
|
|
|
#define WINED3DSI_TEXLD_PROJECT 1
|
|
|
|
#define WINED3DSI_TEXLD_BIAS 2
|
|
|
|
|
|
|
|
typedef enum COMPARISON_TYPE
|
|
|
|
{
|
|
|
|
COMPARISON_GT = 1,
|
|
|
|
COMPARISON_EQ = 2,
|
|
|
|
COMPARISON_GE = 3,
|
|
|
|
COMPARISON_LT = 4,
|
|
|
|
COMPARISON_NE = 5,
|
|
|
|
COMPARISON_LE = 6,
|
|
|
|
} COMPARISON_TYPE;
|
|
|
|
|
2009-05-05 09:38:03 +02:00
|
|
|
#define WINED3D_SM1_VS 0xfffe
|
|
|
|
#define WINED3D_SM1_PS 0xffff
|
|
|
|
#define WINED3D_SM4_PS 0x0000
|
|
|
|
#define WINED3D_SM4_VS 0x0001
|
|
|
|
#define WINED3D_SM4_GS 0x0002
|
|
|
|
|
2009-05-01 09:13:54 +02:00
|
|
|
/* Shader version tokens, and shader end tokens */
|
2009-05-05 09:38:03 +02:00
|
|
|
#define WINED3DPS_VERSION(major, minor) ((WINED3D_SM1_PS << 16) | ((major) << 8) | (minor))
|
|
|
|
#define WINED3DVS_VERSION(major, minor) ((WINED3D_SM1_VS << 16) | ((major) << 8) | (minor))
|
2009-05-01 09:13:54 +02:00
|
|
|
|
2006-11-27 20:50:37 +01:00
|
|
|
/* Shader backends */
|
2009-04-01 12:23:01 +02:00
|
|
|
|
|
|
|
/* TODO: Make this dynamic, based on shader limits ? */
|
|
|
|
#define MAX_ATTRIBS 16
|
|
|
|
#define MAX_REG_ADDR 1
|
|
|
|
#define MAX_REG_TEMP 32
|
|
|
|
#define MAX_REG_TEXCRD 8
|
|
|
|
#define MAX_REG_INPUT 12
|
|
|
|
#define MAX_REG_OUTPUT 12
|
|
|
|
#define MAX_CONST_I 16
|
|
|
|
#define MAX_CONST_B 16
|
|
|
|
|
|
|
|
/* FIXME: This needs to go up to 2048 for
|
|
|
|
* Shader model 3 according to msdn (and for software shaders) */
|
|
|
|
#define MAX_LABELS 16
|
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-09-23 17:39:34 +02:00
|
|
|
enum WINED3D_SHADER_INSTRUCTION_HANDLER
|
|
|
|
{
|
|
|
|
WINED3DSIH_ABS,
|
|
|
|
WINED3DSIH_ADD,
|
|
|
|
WINED3DSIH_BEM,
|
|
|
|
WINED3DSIH_BREAK,
|
|
|
|
WINED3DSIH_BREAKC,
|
|
|
|
WINED3DSIH_BREAKP,
|
|
|
|
WINED3DSIH_CALL,
|
|
|
|
WINED3DSIH_CALLNZ,
|
|
|
|
WINED3DSIH_CMP,
|
|
|
|
WINED3DSIH_CND,
|
|
|
|
WINED3DSIH_CRS,
|
|
|
|
WINED3DSIH_DCL,
|
|
|
|
WINED3DSIH_DEF,
|
|
|
|
WINED3DSIH_DEFB,
|
|
|
|
WINED3DSIH_DEFI,
|
|
|
|
WINED3DSIH_DP2ADD,
|
|
|
|
WINED3DSIH_DP3,
|
|
|
|
WINED3DSIH_DP4,
|
|
|
|
WINED3DSIH_DST,
|
|
|
|
WINED3DSIH_DSX,
|
|
|
|
WINED3DSIH_DSY,
|
|
|
|
WINED3DSIH_ELSE,
|
|
|
|
WINED3DSIH_ENDIF,
|
|
|
|
WINED3DSIH_ENDLOOP,
|
|
|
|
WINED3DSIH_ENDREP,
|
|
|
|
WINED3DSIH_EXP,
|
|
|
|
WINED3DSIH_EXPP,
|
|
|
|
WINED3DSIH_FRC,
|
|
|
|
WINED3DSIH_IF,
|
|
|
|
WINED3DSIH_IFC,
|
|
|
|
WINED3DSIH_LABEL,
|
|
|
|
WINED3DSIH_LIT,
|
|
|
|
WINED3DSIH_LOG,
|
|
|
|
WINED3DSIH_LOGP,
|
|
|
|
WINED3DSIH_LOOP,
|
|
|
|
WINED3DSIH_LRP,
|
|
|
|
WINED3DSIH_M3x2,
|
|
|
|
WINED3DSIH_M3x3,
|
|
|
|
WINED3DSIH_M3x4,
|
|
|
|
WINED3DSIH_M4x3,
|
|
|
|
WINED3DSIH_M4x4,
|
|
|
|
WINED3DSIH_MAD,
|
|
|
|
WINED3DSIH_MAX,
|
|
|
|
WINED3DSIH_MIN,
|
|
|
|
WINED3DSIH_MOV,
|
|
|
|
WINED3DSIH_MOVA,
|
|
|
|
WINED3DSIH_MUL,
|
|
|
|
WINED3DSIH_NOP,
|
|
|
|
WINED3DSIH_NRM,
|
|
|
|
WINED3DSIH_PHASE,
|
|
|
|
WINED3DSIH_POW,
|
|
|
|
WINED3DSIH_RCP,
|
|
|
|
WINED3DSIH_REP,
|
|
|
|
WINED3DSIH_RET,
|
|
|
|
WINED3DSIH_RSQ,
|
|
|
|
WINED3DSIH_SETP,
|
|
|
|
WINED3DSIH_SGE,
|
|
|
|
WINED3DSIH_SGN,
|
|
|
|
WINED3DSIH_SINCOS,
|
|
|
|
WINED3DSIH_SLT,
|
|
|
|
WINED3DSIH_SUB,
|
|
|
|
WINED3DSIH_TEX,
|
|
|
|
WINED3DSIH_TEXBEM,
|
|
|
|
WINED3DSIH_TEXBEML,
|
|
|
|
WINED3DSIH_TEXCOORD,
|
|
|
|
WINED3DSIH_TEXDEPTH,
|
|
|
|
WINED3DSIH_TEXDP3,
|
|
|
|
WINED3DSIH_TEXDP3TEX,
|
|
|
|
WINED3DSIH_TEXKILL,
|
|
|
|
WINED3DSIH_TEXLDD,
|
|
|
|
WINED3DSIH_TEXLDL,
|
|
|
|
WINED3DSIH_TEXM3x2DEPTH,
|
|
|
|
WINED3DSIH_TEXM3x2PAD,
|
|
|
|
WINED3DSIH_TEXM3x2TEX,
|
|
|
|
WINED3DSIH_TEXM3x3,
|
|
|
|
WINED3DSIH_TEXM3x3DIFF,
|
|
|
|
WINED3DSIH_TEXM3x3PAD,
|
|
|
|
WINED3DSIH_TEXM3x3SPEC,
|
|
|
|
WINED3DSIH_TEXM3x3TEX,
|
|
|
|
WINED3DSIH_TEXM3x3VSPEC,
|
|
|
|
WINED3DSIH_TEXREG2AR,
|
|
|
|
WINED3DSIH_TEXREG2GB,
|
|
|
|
WINED3DSIH_TEXREG2RGB,
|
|
|
|
WINED3DSIH_TABLE_SIZE
|
|
|
|
};
|
|
|
|
|
2009-05-06 17:59:21 +02:00
|
|
|
enum wined3d_shader_type
|
|
|
|
{
|
|
|
|
WINED3D_SHADER_TYPE_PIXEL,
|
|
|
|
WINED3D_SHADER_TYPE_VERTEX,
|
|
|
|
WINED3D_SHADER_TYPE_GEOMETRY,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct wined3d_shader_version
|
|
|
|
{
|
|
|
|
enum wined3d_shader_type type;
|
|
|
|
BYTE major;
|
|
|
|
BYTE minor;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define WINED3D_SHADER_VERSION(major, minor) (((major) << 8) | (minor))
|
|
|
|
|
2009-04-01 12:23:01 +02:00
|
|
|
typedef struct shader_reg_maps
|
|
|
|
{
|
2009-05-06 17:59:21 +02:00
|
|
|
struct wined3d_shader_version shader_version;
|
2009-04-01 12:23:01 +02:00
|
|
|
char texcoord[MAX_REG_TEXCRD]; /* pixel < 3.0 */
|
|
|
|
char temporary[MAX_REG_TEMP]; /* pixel, vertex */
|
|
|
|
char address[MAX_REG_ADDR]; /* vertex */
|
|
|
|
char labels[MAX_LABELS]; /* pixel, vertex */
|
2009-05-07 17:31:20 +02:00
|
|
|
DWORD *constf; /* pixel, vertex */
|
2009-04-01 12:23:01 +02:00
|
|
|
DWORD texcoord_mask[MAX_REG_TEXCRD]; /* vertex < 3.0 */
|
2009-05-27 10:24:49 +02:00
|
|
|
WORD input_registers; /* max(MAX_REG_INPUT, MAX_ATTRIBS), 16 */
|
2009-05-27 10:24:50 +02:00
|
|
|
WORD output_registers; /* MAX_REG_OUTPUT, 12 */
|
2009-04-28 09:53:28 +02:00
|
|
|
WORD integer_constants; /* MAX_CONST_I, 16 */
|
|
|
|
WORD boolean_constants; /* MAX_CONST_B, 16 */
|
2009-06-16 07:36:59 +02:00
|
|
|
WORD local_int_consts; /* MAX_CONST_I, 16 */
|
2009-05-27 18:23:59 +02:00
|
|
|
WORD local_bool_consts; /* MAX_CONST_B, 16 */
|
2009-04-01 12:23:01 +02:00
|
|
|
|
2009-04-29 09:55:06 +02:00
|
|
|
WINED3DSAMPLER_TEXTURE_TYPE sampler_type[max(MAX_FRAGMENT_SAMPLERS, MAX_VERTEX_SAMPLERS)];
|
2009-04-01 12:23:01 +02:00
|
|
|
BOOL bumpmat[MAX_TEXTURES], luminanceparams[MAX_TEXTURES];
|
2009-05-29 17:29:57 +02:00
|
|
|
|
|
|
|
unsigned usesnrm : 1;
|
|
|
|
unsigned vpos : 1;
|
|
|
|
unsigned usesdsx : 1;
|
|
|
|
unsigned usesdsy : 1;
|
|
|
|
unsigned usestexldd : 1;
|
|
|
|
unsigned usesmova : 1;
|
|
|
|
unsigned usesfacing : 1;
|
|
|
|
unsigned usesrelconstF : 1;
|
|
|
|
unsigned fog : 1;
|
|
|
|
unsigned usestexldl : 1;
|
2009-06-25 14:44:00 +02:00
|
|
|
unsigned usesifc : 1;
|
2009-06-25 18:54:28 +02:00
|
|
|
unsigned usescall : 1;
|
|
|
|
unsigned padding : 4;
|
2009-04-01 12:23:01 +02:00
|
|
|
|
|
|
|
/* Whether or not loops are used in this shader, and nesting depth */
|
|
|
|
unsigned loop_depth;
|
2009-06-18 18:10:15 +02:00
|
|
|
unsigned highest_render_target;
|
2009-04-01 12:23:01 +02:00
|
|
|
|
|
|
|
} shader_reg_maps;
|
|
|
|
|
2009-04-15 10:06:28 +02:00
|
|
|
struct wined3d_shader_context
|
|
|
|
{
|
|
|
|
IWineD3DBaseShader *shader;
|
|
|
|
const struct shader_reg_maps *reg_maps;
|
|
|
|
SHADER_BUFFER *buffer;
|
2009-05-15 13:56:40 +02:00
|
|
|
void *backend_data;
|
2009-04-15 10:06:28 +02:00
|
|
|
};
|
|
|
|
|
2009-05-07 16:36:07 +02:00
|
|
|
struct wined3d_shader_register
|
|
|
|
{
|
|
|
|
WINED3DSHADER_PARAM_REGISTER_TYPE type;
|
|
|
|
UINT idx;
|
|
|
|
const struct wined3d_shader_src_param *rel_addr;
|
|
|
|
enum wined3d_immconst_type immconst_type;
|
|
|
|
DWORD immconst_data[4];
|
|
|
|
};
|
|
|
|
|
2009-04-03 10:36:38 +02:00
|
|
|
struct wined3d_shader_dst_param
|
|
|
|
{
|
2009-05-07 16:36:07 +02:00
|
|
|
struct wined3d_shader_register reg;
|
2009-04-07 11:09:11 +02:00
|
|
|
DWORD write_mask;
|
2009-04-06 10:10:08 +02:00
|
|
|
DWORD modifiers;
|
2009-04-10 09:15:06 +02:00
|
|
|
DWORD shift;
|
2009-04-03 10:36:38 +02:00
|
|
|
};
|
|
|
|
|
2009-04-15 10:06:28 +02:00
|
|
|
struct wined3d_shader_src_param
|
|
|
|
{
|
2009-05-07 16:36:07 +02:00
|
|
|
struct wined3d_shader_register reg;
|
2009-04-21 09:35:05 +02:00
|
|
|
DWORD swizzle;
|
2009-04-15 10:06:28 +02:00
|
|
|
DWORD modifiers;
|
2009-04-15 10:06:28 +02:00
|
|
|
};
|
|
|
|
|
2009-04-01 12:23:01 +02:00
|
|
|
struct wined3d_shader_instruction
|
2009-04-01 12:23:01 +02:00
|
|
|
{
|
2009-04-15 10:06:28 +02:00
|
|
|
const struct wined3d_shader_context *ctx;
|
2009-04-02 10:41:00 +02:00
|
|
|
enum WINED3D_SHADER_INSTRUCTION_HANDLER handler_idx;
|
2009-04-01 12:23:01 +02:00
|
|
|
DWORD flags;
|
|
|
|
BOOL coissue;
|
|
|
|
DWORD predicate;
|
2009-04-02 10:41:00 +02:00
|
|
|
UINT dst_count;
|
2009-04-03 10:36:38 +02:00
|
|
|
const struct wined3d_shader_dst_param *dst;
|
2009-04-02 10:41:00 +02:00
|
|
|
UINT src_count;
|
2009-04-15 10:06:28 +02:00
|
|
|
const struct wined3d_shader_src_param *src;
|
2009-04-01 12:23:01 +02:00
|
|
|
};
|
2009-04-01 12:23:01 +02:00
|
|
|
|
2009-04-08 08:35:06 +02:00
|
|
|
struct wined3d_shader_semantic
|
|
|
|
{
|
2009-04-08 08:35:07 +02:00
|
|
|
WINED3DDECLUSAGE usage;
|
|
|
|
UINT usage_idx;
|
2009-04-29 09:55:07 +02:00
|
|
|
WINED3DSAMPLER_TEXTURE_TYPE sampler_type;
|
2009-04-08 08:35:06 +02:00
|
|
|
struct wined3d_shader_dst_param reg;
|
|
|
|
};
|
|
|
|
|
2009-05-27 10:24:50 +02:00
|
|
|
struct wined3d_shader_attribute
|
|
|
|
{
|
|
|
|
WINED3DDECLUSAGE usage;
|
|
|
|
UINT usage_idx;
|
|
|
|
};
|
|
|
|
|
2009-05-04 09:49:27 +02:00
|
|
|
struct wined3d_shader_frontend
|
|
|
|
{
|
2009-05-08 17:44:25 +02:00
|
|
|
void *(*shader_init)(const DWORD *ptr, const struct wined3d_shader_signature *output_signature);
|
2009-05-05 09:38:03 +02:00
|
|
|
void (*shader_free)(void *data);
|
2009-05-06 17:59:21 +02:00
|
|
|
void (*shader_read_header)(void *data, const DWORD **ptr, struct wined3d_shader_version *shader_version);
|
2009-05-06 17:59:21 +02:00
|
|
|
void (*shader_read_opcode)(void *data, const DWORD **ptr, struct wined3d_shader_instruction *ins, UINT *param_size);
|
|
|
|
void (*shader_read_src_param)(void *data, const DWORD **ptr, struct wined3d_shader_src_param *src_param,
|
|
|
|
struct wined3d_shader_src_param *src_rel_addr);
|
|
|
|
void (*shader_read_dst_param)(void *data, const DWORD **ptr, struct wined3d_shader_dst_param *dst_param,
|
|
|
|
struct wined3d_shader_src_param *dst_rel_addr);
|
2009-05-04 09:49:27 +02:00
|
|
|
void (*shader_read_semantic)(const DWORD **ptr, struct wined3d_shader_semantic *semantic);
|
|
|
|
void (*shader_read_comment)(const DWORD **ptr, const char **comment);
|
2009-05-05 09:38:03 +02:00
|
|
|
BOOL (*shader_is_end)(void *data, const DWORD **ptr);
|
2009-05-04 09:49:27 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
extern const struct wined3d_shader_frontend sm1_shader_frontend;
|
2009-05-05 09:38:03 +02:00
|
|
|
extern const struct wined3d_shader_frontend sm4_shader_frontend;
|
2009-05-04 09:49:27 +02:00
|
|
|
|
2009-04-01 12:23:01 +02:00
|
|
|
typedef void (*SHADER_HANDLER)(const struct wined3d_shader_instruction *);
|
2008-09-23 17:39:34 +02:00
|
|
|
|
2008-03-18 19:39:26 +01:00
|
|
|
struct shader_caps {
|
|
|
|
DWORD VertexShaderVersion;
|
|
|
|
DWORD MaxVertexShaderConst;
|
|
|
|
|
|
|
|
DWORD PixelShaderVersion;
|
|
|
|
float PixelShader1xMaxValue;
|
2009-03-22 12:24:28 +01:00
|
|
|
DWORD MaxPixelShaderConst;
|
2008-03-18 19:39:26 +01:00
|
|
|
|
|
|
|
WINED3DVSHADERCAPS2_0 VS20Caps;
|
|
|
|
WINED3DPSHADERCAPS2_0 PS20Caps;
|
|
|
|
|
|
|
|
DWORD MaxVShaderInstructionsExecuted;
|
|
|
|
DWORD MaxPShaderInstructionsExecuted;
|
|
|
|
DWORD MaxVertexShader30InstructionSlots;
|
|
|
|
DWORD MaxPixelShader30InstructionSlots;
|
2009-05-08 17:24:01 +02:00
|
|
|
|
|
|
|
BOOL VSClipping;
|
2008-03-18 19:39:26 +01:00
|
|
|
};
|
|
|
|
|
2008-10-27 18:31:31 +01:00
|
|
|
enum tex_types
|
|
|
|
{
|
|
|
|
tex_1d = 0,
|
|
|
|
tex_2d = 1,
|
|
|
|
tex_3d = 2,
|
|
|
|
tex_cube = 3,
|
|
|
|
tex_rect = 4,
|
|
|
|
tex_type_count = 5,
|
|
|
|
};
|
|
|
|
|
2008-12-14 15:40:07 +01:00
|
|
|
enum vertexprocessing_mode {
|
|
|
|
fixedfunction,
|
|
|
|
vertexshader,
|
|
|
|
pretransformed
|
|
|
|
};
|
|
|
|
|
2009-03-09 14:31:28 +01:00
|
|
|
#define WINED3D_CONST_NUM_UNUSED ~0U
|
|
|
|
|
2008-12-15 19:35:40 +01:00
|
|
|
enum fogmode {
|
|
|
|
FOG_OFF,
|
|
|
|
FOG_LINEAR,
|
|
|
|
FOG_EXP,
|
|
|
|
FOG_EXP2
|
|
|
|
};
|
|
|
|
|
2008-12-14 15:40:07 +01:00
|
|
|
/* Stateblock dependent parameters which have to be hardcoded
|
|
|
|
* into the shader code
|
|
|
|
*/
|
|
|
|
struct ps_compile_args {
|
|
|
|
struct color_fixup_desc color_fixup[MAX_FRAGMENT_SAMPLERS];
|
|
|
|
enum vertexprocessing_mode vp_mode;
|
2008-12-15 19:35:40 +01:00
|
|
|
enum fogmode fog;
|
2008-12-14 15:40:07 +01:00
|
|
|
/* Projected textures(ps 1.0-1.3) */
|
|
|
|
/* Texture types(2D, Cube, 3D) in ps 1.x */
|
2009-03-26 03:15:21 +01:00
|
|
|
BOOL srgb_correction;
|
2009-04-09 19:14:03 +02:00
|
|
|
WORD np2_fixup;
|
|
|
|
/* Bitmap for NP2 texcoord fixups (16 samplers max currently).
|
2009-03-26 03:15:21 +01:00
|
|
|
D3D9 has a limit of 16 samplers and the fixup is superfluous
|
|
|
|
in D3D10 (unconditional NP2 support mandatory). */
|
2008-12-14 15:40:07 +01:00
|
|
|
};
|
|
|
|
|
2009-02-05 19:44:32 +01:00
|
|
|
enum fog_src_type {
|
|
|
|
VS_FOG_Z = 0,
|
|
|
|
VS_FOG_COORD = 1
|
|
|
|
};
|
|
|
|
|
|
|
|
struct vs_compile_args {
|
|
|
|
WORD fog_src;
|
|
|
|
WORD swizzle_map; /* MAX_ATTRIBS, 16 */
|
|
|
|
};
|
|
|
|
|
2006-11-27 20:50:37 +01:00
|
|
|
typedef struct {
|
2009-05-27 18:23:16 +02:00
|
|
|
void (*shader_handle_instruction)(const struct wined3d_shader_instruction *);
|
2006-11-27 20:50:37 +01:00
|
|
|
void (*shader_select)(IWineD3DDevice *iface, BOOL usePS, BOOL useVS);
|
2008-10-27 18:31:31 +01:00
|
|
|
void (*shader_select_depth_blt)(IWineD3DDevice *iface, enum tex_types tex_type);
|
2008-07-10 17:57:35 +02:00
|
|
|
void (*shader_deselect_depth_blt)(IWineD3DDevice *iface);
|
2008-12-17 17:07:25 +01:00
|
|
|
void (*shader_update_float_vertex_constants)(IWineD3DDevice *iface, UINT start, UINT count);
|
|
|
|
void (*shader_update_float_pixel_constants)(IWineD3DDevice *iface, UINT start, UINT count);
|
2006-11-27 20:50:37 +01:00
|
|
|
void (*shader_load_constants)(IWineD3DDevice *iface, char usePS, char useVS);
|
2009-04-09 00:55:38 +02:00
|
|
|
void (*shader_load_np2fixup_constants)(IWineD3DDevice *iface, char usePS, char useVS);
|
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-11-25 14:36:09 +01:00
|
|
|
void (*shader_get_caps)(WINED3DDEVTYPE devtype, const WineD3D_GL_Info *gl_info, struct shader_caps *caps);
|
2008-12-03 14:53:43 +01:00
|
|
|
BOOL (*shader_color_fixup_supported)(struct color_fixup_desc fixup);
|
2009-05-03 18:17:07 +02:00
|
|
|
void (*shader_add_instruction_modifiers)(const struct wined3d_shader_instruction *ins);
|
2006-11-27 20:50:37 +01:00
|
|
|
} shader_backend_t;
|
|
|
|
|
|
|
|
extern const shader_backend_t glsl_shader_backend;
|
|
|
|
extern const shader_backend_t arb_program_shader_backend;
|
|
|
|
extern const shader_backend_t none_shader_backend;
|
|
|
|
|
2004-09-29 23:26:47 +02:00
|
|
|
/* X11 locking */
|
|
|
|
|
2008-12-18 21:12:36 +01:00
|
|
|
extern void (* CDECL wine_tsx11_lock_ptr)(void);
|
|
|
|
extern void (* CDECL wine_tsx11_unlock_ptr)(void);
|
2004-09-29 23:26:47 +02:00
|
|
|
|
|
|
|
/* 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)
|
|
|
|
|
2008-12-03 10:03:26 +01:00
|
|
|
#define D3DCOLORTOGLFLOAT4(dw, vec) do { \
|
2004-12-13 14:35:38 +01:00
|
|
|
(vec)[0] = D3DCOLOR_R(dw); \
|
|
|
|
(vec)[1] = D3DCOLOR_G(dw); \
|
|
|
|
(vec)[2] = D3DCOLOR_B(dw); \
|
2008-12-03 10:03:26 +01:00
|
|
|
(vec)[3] = D3DCOLOR_A(dw); \
|
|
|
|
} while(0)
|
2006-05-25 13:54:03 +02:00
|
|
|
|
2004-12-13 14:35:38 +01:00
|
|
|
/* DirectX Device Limits */
|
|
|
|
/* --------------------- */
|
2009-04-24 09:17:58 +02:00
|
|
|
#define MAX_MIP_LEVELS 32 /* Maximum number of mipmap levels. */
|
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 */
|
2008-12-31 16:57:10 +01:00
|
|
|
#define HIGHEST_TRANSFORMSTATE WINED3DTS_WORLDMATRIX(255) /* Highest value in WINED3DTRANSFORMSTATETYPE */
|
2005-01-09 18:37:02 +01:00
|
|
|
|
2004-12-13 14:35:38 +01:00
|
|
|
/* Checking of API calls */
|
|
|
|
/* --------------------- */
|
2008-12-02 18:41:33 +01:00
|
|
|
#ifndef WINE_NO_DEBUG_MSGS
|
2006-04-10 06:39:07 +02:00
|
|
|
#define checkGLcall(A) \
|
2008-12-03 10:03:26 +01:00
|
|
|
do { \
|
2006-04-10 06:39:07 +02:00
|
|
|
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); \
|
2008-12-03 10:03:26 +01:00
|
|
|
} while(0)
|
2008-12-02 18:41:33 +01:00
|
|
|
#else
|
2008-12-03 10:03:26 +01:00
|
|
|
#define checkGLcall(A) do {} while(0)
|
2008-12-02 18:41:33 +01:00
|
|
|
#endif
|
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() \
|
2008-12-03 10:03:26 +01:00
|
|
|
do { \
|
2004-11-29 18:53:42 +01:00
|
|
|
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; \
|
|
|
|
} \
|
2008-12-03 10:03:26 +01:00
|
|
|
} while(0)
|
2004-11-29 18:53:42 +01:00
|
|
|
|
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);
|
2009-03-27 10:25:56 +01:00
|
|
|
#define TRACE_STRIDED(si, name) TRACE( #name "=(data:%p, stride:%d, format:%#x, vbo %d, stream %u)\n", \
|
2009-03-30 11:24:54 +02:00
|
|
|
si->elements[name].data, si->elements[name].stride, si->elements[name].format_desc->format, \
|
2009-03-27 10:25:55 +01:00
|
|
|
si->elements[name].buffer_object, si->elements[name].stream_idx);
|
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
|
|
|
|
|
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
|
|
|
|
|
2009-03-27 10:25:55 +01:00
|
|
|
enum wined3d_ffp_idx
|
|
|
|
{
|
|
|
|
WINED3D_FFP_POSITION = 0,
|
|
|
|
WINED3D_FFP_BLENDWEIGHT = 1,
|
|
|
|
WINED3D_FFP_BLENDINDICES = 2,
|
|
|
|
WINED3D_FFP_NORMAL = 3,
|
|
|
|
WINED3D_FFP_PSIZE = 4,
|
|
|
|
WINED3D_FFP_DIFFUSE = 5,
|
|
|
|
WINED3D_FFP_SPECULAR = 6,
|
|
|
|
WINED3D_FFP_TEXCOORD0 = 7,
|
|
|
|
WINED3D_FFP_TEXCOORD1 = 8,
|
|
|
|
WINED3D_FFP_TEXCOORD2 = 9,
|
|
|
|
WINED3D_FFP_TEXCOORD3 = 10,
|
|
|
|
WINED3D_FFP_TEXCOORD4 = 11,
|
|
|
|
WINED3D_FFP_TEXCOORD5 = 12,
|
|
|
|
WINED3D_FFP_TEXCOORD6 = 13,
|
|
|
|
WINED3D_FFP_TEXCOORD7 = 14,
|
|
|
|
};
|
|
|
|
|
2009-03-27 10:25:56 +01:00
|
|
|
enum wined3d_ffp_emit_idx
|
|
|
|
{
|
|
|
|
WINED3D_FFP_EMIT_FLOAT1 = 0,
|
|
|
|
WINED3D_FFP_EMIT_FLOAT2 = 1,
|
|
|
|
WINED3D_FFP_EMIT_FLOAT3 = 2,
|
|
|
|
WINED3D_FFP_EMIT_FLOAT4 = 3,
|
|
|
|
WINED3D_FFP_EMIT_D3DCOLOR = 4,
|
|
|
|
WINED3D_FFP_EMIT_UBYTE4 = 5,
|
|
|
|
WINED3D_FFP_EMIT_SHORT2 = 6,
|
|
|
|
WINED3D_FFP_EMIT_SHORT4 = 7,
|
|
|
|
WINED3D_FFP_EMIT_UBYTE4N = 8,
|
|
|
|
WINED3D_FFP_EMIT_SHORT2N = 9,
|
|
|
|
WINED3D_FFP_EMIT_SHORT4N = 10,
|
|
|
|
WINED3D_FFP_EMIT_USHORT2N = 11,
|
|
|
|
WINED3D_FFP_EMIT_USHORT4N = 12,
|
|
|
|
WINED3D_FFP_EMIT_UDEC3 = 13,
|
|
|
|
WINED3D_FFP_EMIT_DEC3N = 14,
|
|
|
|
WINED3D_FFP_EMIT_FLOAT16_2 = 15,
|
|
|
|
WINED3D_FFP_EMIT_FLOAT16_4 = 16,
|
|
|
|
WINED3D_FFP_EMIT_COUNT = 17
|
|
|
|
};
|
|
|
|
|
2009-03-27 10:25:55 +01:00
|
|
|
struct wined3d_stream_info_element
|
|
|
|
{
|
2009-03-30 11:24:54 +02:00
|
|
|
const struct GlPixelFormatDesc *format_desc;
|
2009-03-27 10:25:55 +01:00
|
|
|
GLsizei stride;
|
|
|
|
const BYTE *data;
|
|
|
|
UINT stream_idx;
|
|
|
|
GLuint buffer_object;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct wined3d_stream_info
|
|
|
|
{
|
|
|
|
struct wined3d_stream_info_element elements[MAX_ATTRIBS];
|
|
|
|
BOOL position_transformed;
|
|
|
|
WORD swizzle_map; /* MAX_ATTRIBS, 16 */
|
|
|
|
WORD use_map; /* MAX_ATTRIBS, 16 */
|
|
|
|
};
|
|
|
|
|
2004-12-09 12:42:34 +01:00
|
|
|
/*****************************************************************************
|
|
|
|
* Prototypes
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Routine common to the draw primitive and draw indexed primitive routines */
|
2009-03-05 12:30:43 +01:00
|
|
|
void drawPrimitive(IWineD3DDevice *iface, UINT index_count, UINT numberOfVertices,
|
|
|
|
UINT start_idx, UINT idxBytes, const void *idxData, UINT minIndex);
|
2006-05-12 22:21:31 +02:00
|
|
|
DWORD get_flexible_vertex_size(DWORD d3dvtVertexType);
|
|
|
|
|
2008-11-28 15:30:11 +01:00
|
|
|
typedef void (WINE_GLAPI *glAttribFunc)(const void *data);
|
|
|
|
typedef void (WINE_GLAPI *glMultiTexCoordFunc)(GLenum unit, const void *data);
|
2009-03-27 10:25:56 +01:00
|
|
|
extern glAttribFunc position_funcs[WINED3D_FFP_EMIT_COUNT];
|
|
|
|
extern glAttribFunc diffuse_funcs[WINED3D_FFP_EMIT_COUNT];
|
2009-03-11 10:15:09 +01:00
|
|
|
extern glAttribFunc specular_func_3ubv;
|
2009-03-27 10:25:56 +01:00
|
|
|
extern glAttribFunc specular_funcs[WINED3D_FFP_EMIT_COUNT];
|
|
|
|
extern glAttribFunc normal_funcs[WINED3D_FFP_EMIT_COUNT];
|
|
|
|
extern glMultiTexCoordFunc multi_texcoord_funcs[WINED3D_FFP_EMIT_COUNT];
|
2007-12-19 17:10:02 +01:00
|
|
|
|
2006-05-09 18:16:13 +02:00
|
|
|
#define eps 1e-8
|
|
|
|
|
2006-05-12 22:21:31 +02:00
|
|
|
#define GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, tex_num) \
|
|
|
|
(((((d3dvtVertexType) >> (16 + (2 * (tex_num)))) + 1) & 0x03) + 1)
|
|
|
|
|
2006-12-05 23:36:10 +01:00
|
|
|
/* Routines and structures related to state management */
|
2007-02-12 19:18:31 +01:00
|
|
|
typedef struct WineD3DContext WineD3DContext;
|
2007-02-12 19:18:22 +01:00
|
|
|
typedef void (*APPLYSTATEFUNC)(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *ctx);
|
2006-12-05 23:36:10 +01:00
|
|
|
|
2006-12-06 13:22:12 +01:00
|
|
|
#define STATE_RENDER(a) (a)
|
|
|
|
#define STATE_IS_RENDER(a) ((a) >= STATE_RENDER(1) && (a) <= STATE_RENDER(WINEHIGHEST_RENDER_STATE))
|
|
|
|
|
2009-01-06 11:43:45 +01:00
|
|
|
#define STATE_TEXTURESTAGE(stage, num) (STATE_RENDER(WINEHIGHEST_RENDER_STATE) + 1 + (stage) * (WINED3D_HIGHEST_TEXTURE_STATE + 1) + (num))
|
2006-12-19 22:43:49 +01:00
|
|
|
#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-11-25 14:36:09 +01:00
|
|
|
void (*get_caps)(WINED3DDEVTYPE devtype, const 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-12-03 14:53:43 +01:00
|
|
|
BOOL (*color_fixup_supported)(struct color_fixup_desc fixup);
|
2008-07-04 22:09:49 +02:00
|
|
|
const struct StateEntryTemplate *states;
|
2008-08-23 22:41:51 +02:00
|
|
|
BOOL ffp_proj_control;
|
2008-07-04 22:09:49 +02:00
|
|
|
};
|
|
|
|
|
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 */
|
2009-01-07 02:20:08 +01:00
|
|
|
HRESULT compile_state_table(struct StateEntry *StateTable, APPLYSTATEFUNC **dev_multistate_funcs,
|
2008-12-01 15:32:14 +01:00
|
|
|
const WineD3D_GL_Info *gl_info, const struct StateEntryTemplate *vertex,
|
|
|
|
const struct fragment_pipeline *fragment, 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);
|
2009-03-24 10:09:24 +01:00
|
|
|
HRESULT (*set_shader)(IWineD3DDevice *iface, const struct GlPixelFormatDesc *format_desc,
|
|
|
|
GLenum textype, UINT width, UINT height);
|
2008-08-01 20:21:10 +02:00
|
|
|
void (*unset_shader)(IWineD3DDevice *iface);
|
2008-12-03 14:53:43 +01:00
|
|
|
BOOL (*color_fixup_supported)(struct color_fixup_desc fixup);
|
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
|
|
|
|
2008-12-15 19:37:36 +01:00
|
|
|
enum fogsource {
|
|
|
|
FOGSOURCE_FFP,
|
|
|
|
FOGSOURCE_VS,
|
|
|
|
FOGSOURCE_COORD,
|
|
|
|
};
|
|
|
|
|
2009-05-11 16:43:49 +02:00
|
|
|
#define WINED3D_MAX_FBO_ENTRIES 64
|
|
|
|
|
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-12-30 14:56:49 +01:00
|
|
|
WORD draw_buffer_dirty : 1;
|
|
|
|
WORD last_was_rhw : 1; /* true iff last draw_primitive was in xyzrhw mode */
|
|
|
|
WORD last_was_pshader : 1;
|
|
|
|
WORD last_was_vshader : 1;
|
|
|
|
WORD namedArraysLoaded : 1;
|
|
|
|
WORD numberedArraysLoaded : 1;
|
|
|
|
WORD last_was_blit : 1;
|
|
|
|
WORD last_was_ckey : 1;
|
|
|
|
WORD fog_coord : 1;
|
|
|
|
WORD isPBuffer : 1;
|
|
|
|
WORD fog_enabled : 1;
|
|
|
|
WORD num_untracked_materials : 2; /* Max value 2 */
|
wined3d: Get rid of last_was_foggy_shader & friends.
The fog settings do not depend on wether the shader writes to oFog or not,
instead they depend on the FOGVERTEXMODE and FOGTABLEMODE settings, and if a
vertex shader is bound at all.
It works the same way as with the fixed function, and having a vertex shader
is the same as using pretransformed vertices, just that the fog coord comes
from the shader instead of the specular color:
FOGTABLEMODE != NONE: The Z coord is used, oFog is ignored
FOGTABLEMODE == NONE, with VS: oFog is used
FOGTABLEMODE == NONE, no VS, XYZ: Z is used
FOGTABLEMODE == NONE, no VS, XYZRHW: diffuse color is used
2009-01-16 15:09:18 +01:00
|
|
|
WORD padding : 3;
|
2008-12-30 14:56:49 +01:00
|
|
|
BYTE texShaderBumpMap; /* MAX_TEXTURES, 8 */
|
|
|
|
BYTE lastWasPow2Texture; /* MAX_TEXTURES, 8 */
|
2008-12-08 10:30:02 +01:00
|
|
|
DWORD numbered_array_mask;
|
2007-02-12 19:18:31 +01:00
|
|
|
GLenum tracking_parm; /* Which source is tracking current colour */
|
2007-06-20 14:36:32 +02:00
|
|
|
GLenum untracked_materials[2];
|
2008-06-17 01:41:49 +02:00
|
|
|
UINT blit_w, blit_h;
|
2008-12-15 19:37:36 +01:00
|
|
|
enum fogsource fog_source;
|
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;
|
2008-04-08 14:20:27 +02:00
|
|
|
GLint aux_buffers;
|
2008-08-21 18:34:55 +02:00
|
|
|
|
|
|
|
/* FBOs */
|
2009-05-11 16:43:49 +02:00
|
|
|
UINT fbo_entry_count;
|
2008-09-18 14:57:53 +02:00
|
|
|
struct list fbo_list;
|
|
|
|
struct fbo_entry *current_fbo;
|
2008-08-21 18:34:55 +02:00
|
|
|
GLuint src_fbo;
|
|
|
|
GLuint dst_fbo;
|
2008-12-15 19:21:37 +01:00
|
|
|
|
|
|
|
/* Extension emulation */
|
|
|
|
GLint gl_fog_source;
|
|
|
|
GLfloat fog_coord_value;
|
|
|
|
GLfloat color[4], fogstart, fogend, fogcolor[4];
|
2009-05-07 11:40:44 +02:00
|
|
|
GLuint dummy_arbfp_prog;
|
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);
|
2008-12-15 19:21:37 +01:00
|
|
|
WineD3DContext *getActiveContext(void);
|
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);
|
2008-09-18 14:57:53 +02:00
|
|
|
void context_resource_released(IWineD3DDevice *iface, IWineD3DResource *resource, WINED3DRESOURCETYPE type);
|
2008-09-18 14:57:53 +02:00
|
|
|
void context_bind_fbo(IWineD3DDevice *iface, GLenum target, GLuint *fbo);
|
|
|
|
void context_attach_depth_stencil_fbo(IWineD3DDeviceImpl *This, GLenum fbo_target, IWineD3DSurface *depth_stencil, BOOL use_render_buffer);
|
|
|
|
void context_attach_surface_fbo(IWineD3DDeviceImpl *This, GLenum fbo_target, DWORD idx, IWineD3DSurface *surface);
|
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 */
|
|
|
|
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
|
|
|
};
|
|
|
|
|
2007-07-27 13:22:54 +02:00
|
|
|
extern BOOL initPixelFormats(WineD3D_GL_Info *gl_info);
|
2009-03-13 10:44:17 +01:00
|
|
|
BOOL initPixelFormatsNoGL(WineD3D_GL_Info *gl_info);
|
2007-09-23 00:46:21 +02:00
|
|
|
extern long WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl *D3DDevice, long glram);
|
2008-12-16 13:18:49 +01:00
|
|
|
extern void add_gl_compat_wrappers(WineD3D_GL_Info *gl_info);
|
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 dst_arg
|
|
|
|
{
|
|
|
|
resultreg = 0,
|
|
|
|
tempreg = 1
|
2008-03-22 14:31:52 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* Fixed function pipeline replacements
|
|
|
|
*/
|
2008-12-09 20:02:18 +01:00
|
|
|
#define ARG_UNUSED 0xff
|
2008-03-22 14:31:52 +01:00
|
|
|
struct texture_stage_op
|
|
|
|
{
|
2008-12-03 14:53:43 +01:00
|
|
|
unsigned cop : 8;
|
|
|
|
unsigned carg1 : 8;
|
|
|
|
unsigned carg2 : 8;
|
|
|
|
unsigned carg0 : 8;
|
|
|
|
|
|
|
|
unsigned aop : 8;
|
|
|
|
unsigned aarg1 : 8;
|
|
|
|
unsigned aarg2 : 8;
|
|
|
|
unsigned aarg0 : 8;
|
|
|
|
|
2008-12-10 10:04:40 +01:00
|
|
|
struct color_fixup_desc color_fixup;
|
2008-07-30 17:57:32 +02:00
|
|
|
unsigned tex_type : 3;
|
2008-12-03 14:53:43 +01:00
|
|
|
unsigned dst : 1;
|
2008-07-30 17:57:32 +02:00
|
|
|
unsigned projected : 2;
|
2008-12-03 14:53:43 +01:00
|
|
|
unsigned padding : 10;
|
2008-03-22 14:31:52 +01:00
|
|
|
};
|
|
|
|
|
2008-11-07 17:15:29 +01:00
|
|
|
struct ffp_frag_settings {
|
2008-07-12 04:18:06 +02:00
|
|
|
struct texture_stage_op op[MAX_TEXTURES];
|
2008-12-15 19:35:40 +01:00
|
|
|
enum fogmode fog;
|
2009-06-22 16:25:37 +02:00
|
|
|
/* Use shorts instead of chars to get dword alignment */
|
|
|
|
unsigned short sRGB_write;
|
|
|
|
unsigned short emul_clipplanes;
|
2008-07-12 04:18:06 +02:00
|
|
|
};
|
|
|
|
|
2008-11-07 17:15:29 +01:00
|
|
|
struct ffp_frag_desc
|
2008-03-22 14:31:52 +01:00
|
|
|
{
|
2009-06-03 10:47:26 +02:00
|
|
|
struct wine_rb_entry entry;
|
2008-11-07 17:15:29 +01:00
|
|
|
struct ffp_frag_settings settings;
|
2008-03-22 14:31:52 +01:00
|
|
|
};
|
|
|
|
|
2009-06-03 10:47:26 +02:00
|
|
|
extern const struct wine_rb_functions wined3d_ffp_frag_program_rb_functions;
|
|
|
|
|
2008-11-07 17:15:29 +01:00
|
|
|
void gen_ffp_frag_op(IWineD3DStateBlockImpl *stateblock, struct ffp_frag_settings *settings, BOOL ignore_textype);
|
2009-06-03 10:47:26 +02:00
|
|
|
const struct ffp_frag_desc *find_ffp_frag_shader(const struct wine_rb_tree *fragment_shaders,
|
2008-11-25 14:36:08 +01:00
|
|
|
const struct ffp_frag_settings *settings);
|
2009-06-03 10:47:26 +02:00
|
|
|
void add_ffp_frag_shader(struct wine_rb_tree *shaders, struct ffp_frag_desc *desc);
|
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;
|
2009-03-11 10:15:09 +01:00
|
|
|
|
|
|
|
UINT adapter_count;
|
|
|
|
struct WineD3DAdapter adapters[1];
|
2004-09-23 06:34:27 +02:00
|
|
|
} IWineD3DImpl;
|
|
|
|
|
2005-06-06 21:50:35 +02:00
|
|
|
extern const IWineD3DVtbl IWineD3D_Vtbl;
|
2004-09-23 06:34:27 +02:00
|
|
|
|
2009-03-11 10:15:09 +01:00
|
|
|
BOOL InitAdapters(IWineD3DImpl *This);
|
|
|
|
|
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
|
|
|
|
*/
|
2009-03-09 14:31:28 +01:00
|
|
|
#define WINED3D_UNMAPPED_STAGE ~0U
|
|
|
|
|
2009-05-01 09:13:54 +02:00
|
|
|
/* Multithreaded flag. Removed from the public header to signal that IWineD3D::CreateDevice ignores it */
|
|
|
|
#define WINED3DCREATE_MULTITHREADED 0x00000004
|
|
|
|
|
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;
|
2009-01-16 10:14:24 +01:00
|
|
|
IWineD3DDeviceParent *device_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;
|
2009-03-22 12:24:28 +01:00
|
|
|
DWORD d3d_vshader_constantF, d3d_pshader_constantF; /* Advertised d3d caps, not GL ones */
|
2009-05-08 17:24:01 +02:00
|
|
|
DWORD vs_clipping;
|
2008-08-17 23:46:47 +02:00
|
|
|
|
2008-12-30 14:56:49 +01:00
|
|
|
WORD view_ident : 1; /* true iff view matrix is identity */
|
|
|
|
WORD untransformed : 1;
|
|
|
|
WORD vertexBlendUsed : 1; /* To avoid needless setting of the blend matrices */
|
|
|
|
WORD isRecordingState : 1;
|
|
|
|
WORD isInDraw : 1;
|
|
|
|
WORD render_offscreen : 1;
|
|
|
|
WORD bCursorVisible : 1;
|
|
|
|
WORD haveHardwareCursor : 1;
|
|
|
|
WORD d3d_initialized : 1;
|
|
|
|
WORD inScene : 1; /* A flag to check for proper BeginScene / EndScene call pairs */
|
|
|
|
WORD softwareVertexProcessing : 1; /* process vertex shaders using software or hardware */
|
|
|
|
WORD useDrawStridedSlow : 1;
|
|
|
|
WORD instancedDraw : 1;
|
|
|
|
WORD padding : 3;
|
|
|
|
|
|
|
|
BYTE fixed_function_usage_map; /* MAX_TEXTURES, 8 */
|
|
|
|
|
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 */
|
|
|
|
IWineD3DStateBlockImpl *stateBlock;
|
|
|
|
IWineD3DStateBlockImpl *updateStateBlock;
|
|
|
|
|
2004-10-08 22:52:33 +02:00
|
|
|
/* Internal use fields */
|
2006-04-03 14:54:16 +02:00
|
|
|
WINED3DDEVICE_CREATION_PARAMETERS createParms;
|
2004-10-08 22:52:33 +02:00
|
|
|
UINT adapterNo;
|
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-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 */
|
|
|
|
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
|
|
|
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-09-21 12:55:03 +02:00
|
|
|
/* Device state management */
|
|
|
|
HRESULT state;
|
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];
|
2006-12-19 23:33:34 +01:00
|
|
|
|
2007-01-02 00:21:26 +01:00
|
|
|
/* Stream source management */
|
2009-03-27 10:25:55 +01:00
|
|
|
struct wined3d_stream_info strided_streams;
|
2008-12-01 15:32:15 +01:00
|
|
|
const WineDirect3DVertexStridedData *up_strided;
|
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-12-17 17:07:25 +01:00
|
|
|
extern const IWineD3DDeviceVtbl IWineD3DDevice_Vtbl;
|
2004-10-07 06:22:21 +02:00
|
|
|
|
2009-05-29 09:13:21 +02:00
|
|
|
void device_resource_add(IWineD3DDeviceImpl *This, IWineD3DResource *resource);
|
2009-05-29 09:13:21 +02:00
|
|
|
void device_resource_released(IWineD3DDeviceImpl *This, IWineD3DResource *resource);
|
2009-03-27 10:25:55 +01:00
|
|
|
void device_stream_info_from_declaration(IWineD3DDeviceImpl *This,
|
|
|
|
BOOL use_vshader, struct wined3d_stream_info *stream_info, BOOL *fixup);
|
|
|
|
void device_stream_info_from_strided(IWineD3DDeviceImpl *This,
|
|
|
|
const struct WineDirect3DVertexStridedData *strided, struct wined3d_stream_info *stream_info);
|
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_* */
|
|
|
|
|
|
|
|
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;
|
2009-03-12 09:53:14 +01:00
|
|
|
const struct GlPixelFormatDesc *format_desc;
|
2008-09-29 19:52:18 +02:00
|
|
|
DWORD priority;
|
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;
|
|
|
|
|
2008-12-02 18:41:33 +01:00
|
|
|
void resource_cleanup(IWineD3DResource *iface);
|
|
|
|
HRESULT resource_free_private_data(IWineD3DResource *iface, REFGUID guid);
|
|
|
|
HRESULT resource_get_device(IWineD3DResource *iface, IWineD3DDevice **device);
|
|
|
|
HRESULT resource_get_parent(IWineD3DResource *iface, IUnknown **parent);
|
|
|
|
DWORD resource_get_priority(IWineD3DResource *iface);
|
|
|
|
HRESULT resource_get_private_data(IWineD3DResource *iface, REFGUID guid,
|
|
|
|
void *data, DWORD *data_size);
|
2009-05-29 09:13:21 +02:00
|
|
|
HRESULT resource_init(IWineD3DResource *iface, WINED3DRESOURCETYPE resource_type,
|
2009-03-13 10:44:18 +01:00
|
|
|
IWineD3DDeviceImpl *device, UINT size, DWORD usage, const struct GlPixelFormatDesc *format_desc,
|
|
|
|
WINED3DPOOL pool, IUnknown *parent);
|
2008-12-02 18:41:33 +01:00
|
|
|
WINED3DRESOURCETYPE resource_get_type(IWineD3DResource *iface);
|
|
|
|
DWORD resource_set_priority(IWineD3DResource *iface, DWORD new_priority);
|
|
|
|
HRESULT resource_set_private_data(IWineD3DResource *iface, REFGUID guid,
|
|
|
|
const void *data, DWORD data_size, DWORD flags);
|
|
|
|
|
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
|
|
|
|
2005-08-03 13:00:28 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
* IWineD3DBaseTexture D3D- > openGL state map lookups
|
|
|
|
*/
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2009-02-17 00:25:51 +01:00
|
|
|
enum WINED3DSRGB
|
|
|
|
{
|
|
|
|
SRGB_ANY = 0, /* Uses the cached value(e.g. external calls) */
|
|
|
|
SRGB_RGB = 1, /* Loads the rgb texture */
|
|
|
|
SRGB_SRGB = 2, /* Loads the srgb texture */
|
|
|
|
SRGB_BOTH = 3, /* Loads both textures */
|
|
|
|
};
|
|
|
|
|
2004-12-07 15:29:12 +01:00
|
|
|
/*****************************************************************************
|
|
|
|
* IWineD3DBaseTexture implementation structure (extends IWineD3DResourceImpl)
|
|
|
|
*/
|
|
|
|
typedef struct IWineD3DBaseTextureClass
|
|
|
|
{
|
2008-12-03 14:53:43 +01:00
|
|
|
DWORD states[MAX_WINETEXTURESTATES];
|
2009-01-16 16:22:09 +01:00
|
|
|
DWORD srgbstates[MAX_WINETEXTURESTATES];
|
2004-12-07 15:29:12 +01:00
|
|
|
UINT levels;
|
2009-01-16 16:22:09 +01:00
|
|
|
BOOL dirty, srgbDirty;
|
|
|
|
UINT textureName, srgbTextureName;
|
2008-12-03 14:53:43 +01:00
|
|
|
float pow2Matrix[16];
|
2005-03-14 11:12:52 +01:00
|
|
|
UINT LOD;
|
2006-04-06 19:02:16 +02:00
|
|
|
WINED3DTEXTUREFILTERTYPE filterType;
|
2006-12-19 23:26:39 +01:00
|
|
|
LONG bindCount;
|
|
|
|
DWORD sampler;
|
2007-06-07 01:13:16 +02:00
|
|
|
BOOL is_srgb;
|
2009-03-26 03:12:50 +01:00
|
|
|
BOOL pow2Matrix_identity;
|
2008-11-26 16:14:40 +01:00
|
|
|
const struct min_lookup *minMipLookup;
|
|
|
|
const GLenum *magLookup;
|
2009-02-17 00:25:51 +01:00
|
|
|
void (*internal_preload)(IWineD3DBaseTexture *iface, enum WINED3DSRGB srgb);
|
2004-12-07 15:29:12 +01:00
|
|
|
} IWineD3DBaseTextureClass;
|
|
|
|
|
2009-02-17 00:25:51 +01:00
|
|
|
void surface_internal_preload(IWineD3DSurface *iface, enum WINED3DSRGB srgb);
|
|
|
|
|
2004-12-07 15:29:12 +01:00
|
|
|
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;
|
|
|
|
|
2008-12-02 18:41:32 +01:00
|
|
|
void basetexture_apply_state_changes(IWineD3DBaseTexture *iface,
|
|
|
|
const DWORD texture_states[WINED3D_HIGHEST_TEXTURE_STATE + 1],
|
|
|
|
const DWORD sampler_states[WINED3D_HIGHEST_SAMPLER_STATE + 1]);
|
2009-01-16 16:22:09 +01:00
|
|
|
HRESULT basetexture_bind(IWineD3DBaseTexture *iface, BOOL srgb, BOOL *set_surface_desc);
|
2008-12-02 18:41:32 +01:00
|
|
|
void basetexture_cleanup(IWineD3DBaseTexture *iface);
|
|
|
|
void basetexture_generate_mipmaps(IWineD3DBaseTexture *iface);
|
|
|
|
WINED3DTEXTUREFILTERTYPE basetexture_get_autogen_filter_type(IWineD3DBaseTexture *iface);
|
|
|
|
BOOL basetexture_get_dirty(IWineD3DBaseTexture *iface);
|
|
|
|
DWORD basetexture_get_level_count(IWineD3DBaseTexture *iface);
|
|
|
|
DWORD basetexture_get_lod(IWineD3DBaseTexture *iface);
|
2009-06-02 09:01:17 +02:00
|
|
|
HRESULT basetexture_init(IWineD3DBaseTextureImpl *texture, UINT levels, WINED3DRESOURCETYPE resource_type,
|
|
|
|
IWineD3DDeviceImpl *device, UINT size, DWORD usage, const struct GlPixelFormatDesc *format_desc,
|
|
|
|
WINED3DPOOL pool, IUnknown *parent);
|
2008-12-02 18:41:32 +01:00
|
|
|
HRESULT basetexture_set_autogen_filter_type(IWineD3DBaseTexture *iface, WINED3DTEXTUREFILTERTYPE filter_type);
|
|
|
|
BOOL basetexture_set_dirty(IWineD3DBaseTexture *iface, BOOL dirty);
|
|
|
|
DWORD basetexture_set_lod(IWineD3DBaseTexture *iface, DWORD new_lod);
|
|
|
|
void basetexture_unload(IWineD3DBaseTexture *iface);
|
2009-01-16 16:22:09 +01:00
|
|
|
static inline void basetexture_setsrgbcache(IWineD3DBaseTexture *iface, BOOL srgb) {
|
|
|
|
IWineD3DBaseTextureImpl *This = (IWineD3DBaseTextureImpl *)iface;
|
|
|
|
This->baseTexture.is_srgb = srgb;
|
|
|
|
}
|
2008-12-02 18:41:32 +01:00
|
|
|
|
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 */
|
2009-04-24 09:17:58 +02:00
|
|
|
IWineD3DSurface *surfaces[MAX_MIP_LEVELS];
|
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
|
|
|
|
2009-06-03 10:47:25 +02:00
|
|
|
HRESULT texture_init(IWineD3DTextureImpl *texture, UINT width, UINT height, UINT levels,
|
|
|
|
IWineD3DDeviceImpl *device, DWORD usage, WINED3DFORMAT format, WINED3DPOOL pool, IUnknown *parent);
|
|
|
|
|
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 */
|
2009-04-24 09:17:58 +02:00
|
|
|
IWineD3DSurface *surfaces[6][MAX_MIP_LEVELS];
|
2005-01-17 14:44:57 +01:00
|
|
|
} IWineD3DCubeTextureImpl;
|
|
|
|
|
2005-06-06 21:50:35 +02:00
|
|
|
extern const IWineD3DCubeTextureVtbl IWineD3DCubeTexture_Vtbl;
|
2005-01-17 14:44:57 +01:00
|
|
|
|
2009-06-03 10:47:26 +02:00
|
|
|
HRESULT cubetexture_init(IWineD3DCubeTextureImpl *texture, UINT edge_length, UINT levels,
|
|
|
|
IWineD3DDeviceImpl *device, DWORD usage, WINED3DFORMAT format, WINED3DPOOL pool, IUnknown *parent);
|
|
|
|
|
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
|
|
|
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
|
|
|
|
2009-01-14 10:01:10 +01:00
|
|
|
void volume_add_dirty_box(IWineD3DVolume *iface, const WINED3DBOX *dirty_box);
|
|
|
|
|
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 */
|
2009-04-24 09:17:58 +02:00
|
|
|
IWineD3DVolume *volumes[MAX_MIP_LEVELS];
|
2005-01-17 14:44:57 +01:00
|
|
|
} IWineD3DVolumeTextureImpl;
|
|
|
|
|
2005-06-06 21:50:35 +02:00
|
|
|
extern const IWineD3DVolumeTextureVtbl IWineD3DVolumeTexture_Vtbl;
|
2005-01-17 14:44:57 +01:00
|
|
|
|
2009-06-03 10:47:26 +02:00
|
|
|
HRESULT volumetexture_init(IWineD3DVolumeTextureImpl *texture, UINT width, UINT height, UINT depth, UINT levels,
|
|
|
|
IWineD3DDeviceImpl *device, DWORD usage, WINED3DFORMAT format, WINED3DPOOL pool, IUnknown *parent);
|
|
|
|
|
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;
|
|
|
|
|
2008-09-18 14:57:53 +02:00
|
|
|
struct fbo_entry
|
|
|
|
{
|
|
|
|
struct list entry;
|
|
|
|
IWineD3DSurface **render_targets;
|
|
|
|
IWineD3DSurface *depth_stencil;
|
|
|
|
BOOL attached;
|
|
|
|
GLuint id;
|
|
|
|
};
|
|
|
|
|
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
|
|
|
|
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;
|
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;
|
|
|
|
|
2009-06-15 09:06:49 +02:00
|
|
|
UINT surface_calculate_size(const struct GlPixelFormatDesc *format_desc, UINT alignment, UINT width, UINT height);
|
2009-06-15 09:06:49 +02:00
|
|
|
void surface_gdi_cleanup(IWineD3DSurfaceImpl *This);
|
|
|
|
HRESULT surface_init(IWineD3DSurfaceImpl *surface, WINED3DSURFTYPE surface_type, UINT alignment,
|
|
|
|
UINT width, UINT height, UINT level, BOOL lockable, BOOL discard, WINED3DMULTISAMPLE_TYPE multisample_type,
|
|
|
|
UINT multisample_quality, IWineD3DDeviceImpl *device, DWORD usage, WINED3DFORMAT format,
|
|
|
|
WINED3DPOOL pool, IUnknown *parent);
|
|
|
|
|
2006-05-13 22:22:16 +02:00
|
|
|
/* 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);
|
2008-11-25 11:57:39 +01:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetColorKey(IWineD3DSurface *iface, DWORD Flags, const WINEDDCOLORKEY *CKey);
|
2007-09-16 16:27:58 +02:00
|
|
|
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);
|
2008-11-25 11:57:39 +01:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_UpdateOverlay(IWineD3DSurface *iface, const RECT *SrcRect,
|
|
|
|
IWineD3DSurface *DstSurface, const RECT *DstRect, DWORD Flags, const WINEDDOVERLAYFX *FX);
|
2007-09-16 16:27:58 +02:00
|
|
|
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);
|
2008-11-25 11:57:39 +01:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_Blt(IWineD3DSurface *iface, const RECT *DestRect, IWineD3DSurface *SrcSurface,
|
|
|
|
const RECT *SrcRect, DWORD Flags, const WINEDDBLTFX *DDBltFx, WINED3DTEXTUREFILTERTYPE Filter);
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dstx, DWORD dsty,
|
|
|
|
IWineD3DSurface *Source, const 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);
|
2009-01-16 16:22:09 +01:00
|
|
|
void WINAPI IWineD3DBaseSurfaceImpl_BindTexture(IWineD3DSurface *iface, BOOL srgb);
|
2008-11-25 11:57:39 +01:00
|
|
|
const void *WINAPI IWineD3DBaseSurfaceImpl_GetData(IWineD3DSurface *iface);
|
2007-09-16 16:33:23 +02:00
|
|
|
|
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 */
|
2009-01-16 16:22:09 +01:00
|
|
|
#define SFLAG_INSRGBTEX 0x00000080 /* The GL srgb texture contains the newest surface content */
|
|
|
|
#define SFLAG_INDRAWABLE 0x00000100 /* The gl drawable contains the most up to date data */
|
|
|
|
#define SFLAG_INSYSMEM 0x00000200 /* The system memory copy is most up to date */
|
|
|
|
#define SFLAG_NONPOW2 0x00000400 /* Surface sizes are not a power of 2 */
|
|
|
|
#define SFLAG_DYNLOCK 0x00000800 /* Surface is often locked by the app */
|
2008-07-02 23:00:41 +02:00
|
|
|
#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 */
|
2009-01-16 16:22:09 +01:00
|
|
|
#define SFLAG_SRGBALLOCATED 0x00040000 /* A srgb gl texture is allocated for this surface */
|
|
|
|
#define SFLAG_PBO 0x00080000 /* Has a PBO attached for speeding up data transfers for dynamically locked surfaces */
|
|
|
|
#define SFLAG_NORMCOORD 0x00100000 /* Set if the GL texture coords are normalized(non-texture rectangle) */
|
|
|
|
#define SFLAG_DS_ONSCREEN 0x00200000 /* Is a depth stencil, last modified onscreen */
|
|
|
|
#define SFLAG_DS_OFFSCREEN 0x00400000 /* Is a depth stencil, last modified offscreen */
|
|
|
|
#define SFLAG_INOVERLAYDRAW 0x00800000 /* Overlay drawing is in progress. Recursion prevention */
|
2009-03-25 10:12:27 +01:00
|
|
|
#define SFLAG_SWAPCHAIN 0x01000000 /* The surface is part of a swapchain */
|
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
|
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_USERPTR | \
|
|
|
|
SFLAG_PBO | \
|
|
|
|
SFLAG_CLIENT)
|
|
|
|
|
|
|
|
#define SFLAG_LOCATIONS (SFLAG_INSYSMEM | \
|
|
|
|
SFLAG_INTEXTURE | \
|
2009-01-16 16:22:09 +01:00
|
|
|
SFLAG_INDRAWABLE | \
|
|
|
|
SFLAG_INSRGBTEX)
|
2008-07-02 23:00:41 +02:00
|
|
|
|
|
|
|
#define SFLAG_DS_LOCATIONS (SFLAG_DS_ONSCREEN | \
|
|
|
|
SFLAG_DS_OFFSCREEN)
|
2008-09-22 14:52:52 +02:00
|
|
|
#define SFLAG_DS_DISCARDED SFLAG_DS_LOCATIONS
|
2008-07-02 23:00:41 +02:00
|
|
|
|
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,
|
2008-12-15 19:14:15 +01:00
|
|
|
CONVERT_G16R16,
|
2009-04-06 15:05:27 +02:00
|
|
|
CONVERT_R16G16F,
|
|
|
|
CONVERT_R32G32F,
|
2009-06-16 09:38:25 +02:00
|
|
|
CONVERT_D15S1,
|
|
|
|
CONVERT_D24X4S4,
|
|
|
|
CONVERT_D24FS8,
|
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
|
|
|
#define MAX_ATTRIBS 16
|
|
|
|
|
2009-03-27 10:25:56 +01:00
|
|
|
struct wined3d_vertex_declaration_element
|
|
|
|
{
|
2009-03-27 10:25:56 +01:00
|
|
|
const struct GlPixelFormatDesc *format_desc;
|
2009-03-27 10:25:56 +01:00
|
|
|
BOOL ffp_valid;
|
|
|
|
WORD input_slot;
|
|
|
|
WORD offset;
|
|
|
|
UINT output_slot;
|
|
|
|
BYTE method;
|
|
|
|
BYTE usage;
|
|
|
|
BYTE usage_idx;
|
|
|
|
};
|
|
|
|
|
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;
|
|
|
|
|
2009-03-27 10:25:56 +01:00
|
|
|
struct wined3d_vertex_declaration_element *elements;
|
|
|
|
UINT element_count;
|
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;
|
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
|
|
|
|
2009-03-27 10:25:55 +01:00
|
|
|
HRESULT vertexdeclaration_init(IWineD3DVertexDeclarationImpl *This,
|
|
|
|
const WINED3DVERTEXELEMENT *elements, UINT element_count);
|
|
|
|
|
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 {
|
2009-01-05 10:10:16 +01:00
|
|
|
DWORD transform[(HIGHEST_TRANSFORMSTATE >> 5) + 1];
|
2009-01-05 10:10:16 +01:00
|
|
|
WORD streamSource; /* MAX_STREAMS, 16 */
|
|
|
|
WORD streamFreq; /* MAX_STREAMS, 16 */
|
2009-01-05 10:10:16 +01:00
|
|
|
DWORD renderState[(WINEHIGHEST_RENDER_STATE >> 5) + 1];
|
2009-01-06 11:43:45 +01:00
|
|
|
DWORD textureState[MAX_TEXTURES]; /* WINED3D_HIGHEST_TEXTURE_STATE + 1, 18 */
|
|
|
|
WORD samplerState[MAX_COMBINED_SAMPLERS]; /* WINED3D_HIGHEST_SAMPLER_STATE + 1, 14 */
|
|
|
|
DWORD textures; /* MAX_COMBINED_SAMPLERS, 20 */
|
2009-01-05 10:10:16 +01:00
|
|
|
DWORD clipplane; /* WINED3DMAXUSERCLIPPLANES, 32 */
|
|
|
|
WORD pixelShaderConstantsB; /* MAX_CONST_B, 16 */
|
|
|
|
WORD pixelShaderConstantsI; /* MAX_CONST_I, 16 */
|
2008-12-30 14:56:49 +01:00
|
|
|
BOOL *pixelShaderConstantsF;
|
2009-01-05 10:10:16 +01:00
|
|
|
WORD vertexShaderConstantsB; /* MAX_CONST_B, 16 */
|
|
|
|
WORD vertexShaderConstantsI; /* MAX_CONST_I, 16 */
|
2008-12-30 14:56:49 +01:00
|
|
|
BOOL *vertexShaderConstantsF;
|
2009-03-05 12:30:43 +01:00
|
|
|
WORD primitive_type : 1;
|
|
|
|
WORD indices : 1;
|
|
|
|
WORD material : 1;
|
|
|
|
WORD viewport : 1;
|
|
|
|
WORD vertexDecl : 1;
|
|
|
|
WORD pixelShader : 1;
|
|
|
|
WORD vertexShader : 1;
|
|
|
|
WORD scissorRect : 1;
|
|
|
|
WORD padding : 1;
|
2004-10-21 22:59:12 +02:00
|
|
|
} SAVEDSTATES;
|
|
|
|
|
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;
|
2005-07-05 16:05:18 +02:00
|
|
|
|
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
|
|
|
|
2009-03-05 12:30:43 +01:00
|
|
|
/* primitive type */
|
|
|
|
GLenum gl_primitive_type;
|
|
|
|
|
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 */ ];
|
2009-03-06 14:56:23 +01:00
|
|
|
IWineD3DBuffer *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 */
|
2009-04-06 16:46:12 +02:00
|
|
|
IWineD3DBuffer* pIndexData;
|
2009-04-09 10:50:31 +02:00
|
|
|
WINED3DFORMAT IndexFmt;
|
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];
|
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;
|
2009-01-06 11:43:45 +01:00
|
|
|
struct StageState contained_tss_states[MAX_TEXTURES * (WINED3D_HIGHEST_TEXTURE_STATE + 1)];
|
2007-08-09 17:45:29 +02:00
|
|
|
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_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
|
|
|
|
2009-02-23 09:16:02 +01:00
|
|
|
/* IWineD3DBuffer */
|
2009-03-06 14:56:23 +01:00
|
|
|
|
|
|
|
/* TODO: Add tests and support for FLOAT16_4 POSITIONT, D3DCOLOR position, other
|
|
|
|
* fixed function semantics as D3DCOLOR or FLOAT16 */
|
|
|
|
enum wined3d_buffer_conversion_type
|
|
|
|
{
|
|
|
|
CONV_NONE,
|
|
|
|
CONV_D3DCOLOR,
|
|
|
|
CONV_POSITIONT,
|
|
|
|
CONV_FLOAT16_2, /* Also handles FLOAT16_4 */
|
|
|
|
};
|
|
|
|
|
|
|
|
#define WINED3D_BUFFER_OPTIMIZED 0x01 /* Optimize has been called for the buffer */
|
|
|
|
#define WINED3D_BUFFER_DIRTY 0x02 /* Buffer data has been modified */
|
|
|
|
#define WINED3D_BUFFER_HASDESC 0x04 /* A vertex description has been found */
|
|
|
|
#define WINED3D_BUFFER_CREATEBO 0x08 /* Attempt to create a buffer object next PreLoad */
|
2009-04-09 18:40:57 +02:00
|
|
|
#define WINED3D_BUFFER_DOUBLEBUFFER 0x10 /* Use a vbo and local allocated memory */
|
2009-03-06 14:56:23 +01:00
|
|
|
|
2009-02-23 09:16:02 +01:00
|
|
|
struct wined3d_buffer
|
|
|
|
{
|
|
|
|
const struct IWineD3DBufferVtbl *vtbl;
|
|
|
|
IWineD3DResourceClass resource;
|
|
|
|
|
|
|
|
struct wined3d_buffer_desc desc;
|
2009-03-06 14:56:23 +01:00
|
|
|
|
|
|
|
GLuint buffer_object;
|
|
|
|
GLenum buffer_object_usage;
|
2009-04-06 13:38:56 +02:00
|
|
|
GLenum buffer_type_hint;
|
2009-03-06 14:56:23 +01:00
|
|
|
UINT buffer_object_size;
|
|
|
|
LONG bind_count;
|
|
|
|
DWORD flags;
|
|
|
|
|
|
|
|
UINT dirty_start;
|
|
|
|
UINT dirty_end;
|
|
|
|
LONG lock_count;
|
|
|
|
|
|
|
|
/* conversion stuff */
|
|
|
|
UINT conversion_count;
|
|
|
|
UINT draw_count;
|
|
|
|
UINT stride; /* 0 if no conversion */
|
|
|
|
UINT conversion_stride; /* 0 if no shifted conversion */
|
|
|
|
enum wined3d_buffer_conversion_type *conversion_map; /* NULL if no conversion */
|
|
|
|
/* Extra load offsets, for FLOAT16 conversion */
|
|
|
|
UINT *conversion_shift; /* NULL if no shifted conversion */
|
2009-02-23 09:16:02 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
extern const IWineD3DBufferVtbl wined3d_buffer_vtbl;
|
2009-03-06 14:56:23 +01:00
|
|
|
const BYTE *buffer_get_memory(IWineD3DBuffer *iface, UINT offset, GLuint *buffer_object);
|
2009-04-09 18:40:57 +02:00
|
|
|
const BYTE *buffer_get_sysmem(struct wined3d_buffer *This);
|
2009-02-23 09:16:02 +01:00
|
|
|
|
2009-02-24 07:43:02 +01:00
|
|
|
/* IWineD3DRendertargetView */
|
|
|
|
struct wined3d_rendertarget_view
|
|
|
|
{
|
|
|
|
const struct IWineD3DRendertargetViewVtbl *vtbl;
|
|
|
|
LONG refcount;
|
|
|
|
|
|
|
|
IWineD3DResource *resource;
|
|
|
|
IUnknown *parent;
|
|
|
|
};
|
|
|
|
|
|
|
|
extern const IWineD3DRendertargetViewVtbl wined3d_rendertarget_view_vtbl;
|
|
|
|
|
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;
|
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;
|
2008-12-01 15:32:15 +01:00
|
|
|
void x11_copy_to_screen(IWineD3DSwapChainImpl *This, const RECT *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);
|
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);
|
2008-12-03 14:53:43 +01:00
|
|
|
void dump_color_fixup_desc(struct color_fixup_desc fixup);
|
2009-02-16 23:30:36 +01:00
|
|
|
const char *debug_surflocation(DWORD flag);
|
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);
|
2008-08-23 22:41:51 +02:00
|
|
|
void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords, BOOL transformed, DWORD coordtype, BOOL ffp_can_disable_proj);
|
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);
|
2008-12-14 17:16:36 +01:00
|
|
|
void state_fogcolor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context);
|
|
|
|
void state_fogdensity(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context);
|
2008-12-15 19:37:36 +01:00
|
|
|
void state_fogstartend(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context);
|
|
|
|
void state_fog_fragpart(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context);
|
2004-09-28 04:12:12 +02:00
|
|
|
|
2009-01-14 10:01:11 +01:00
|
|
|
void surface_add_dirty_rect(IWineD3DSurface *iface, const RECT *dirty_rect);
|
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_load_ds_location(IWineD3DSurface *iface, DWORD location);
|
2008-09-24 15:56:47 +02:00
|
|
|
void surface_modify_ds_location(IWineD3DSurface *iface, DWORD location);
|
|
|
|
void surface_set_compatible_renderbuffer(IWineD3DSurface *iface, unsigned int width, unsigned int height);
|
2009-01-16 16:22:09 +01:00
|
|
|
void surface_set_texture_name(IWineD3DSurface *iface, GLuint name, BOOL srgb_name);
|
2008-09-24 15:56:47 +02:00
|
|
|
void surface_set_texture_target(IWineD3DSurface *iface, GLenum target);
|
2007-04-09 01:53:32 +02:00
|
|
|
|
2009-03-24 10:09:24 +01:00
|
|
|
BOOL getColorBits(const struct GlPixelFormatDesc *format_desc,
|
2009-03-13 10:44:18 +01:00
|
|
|
short *redSize, short *greenSize, short *blueSize, short *alphaSize, short *totalSize);
|
2009-03-24 10:09:24 +01:00
|
|
|
BOOL getDepthStencilBits(const struct GlPixelFormatDesc *format_desc, short *depthSize, short *stencilSize);
|
2007-08-09 01:04:30 +02:00
|
|
|
|
2006-05-12 22:21:31 +02:00
|
|
|
/* Math utils */
|
2006-11-24 15:15:06 +01:00
|
|
|
void multiply_matrix(WINED3DMATRIX *dest, const WINED3DMATRIX *src1, const WINED3DMATRIX *src2);
|
2008-12-12 09:33:52 +01:00
|
|
|
UINT wined3d_log2i(UINT32 x);
|
2009-04-22 21:39:14 +02:00
|
|
|
unsigned int count_bits(unsigned int mask);
|
2005-07-07 22:35:05 +02:00
|
|
|
|
2006-07-10 06:51:03 +02:00
|
|
|
typedef struct local_constant {
|
|
|
|
struct list entry;
|
|
|
|
unsigned int idx;
|
|
|
|
DWORD value[4];
|
|
|
|
} local_constant;
|
|
|
|
|
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);
|
2009-03-10 09:19:04 +01:00
|
|
|
int shader_vaddline(SHADER_BUFFER *buffer, const char *fmt, va_list args);
|
2006-05-08 21:44:25 +02:00
|
|
|
|
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);
|
|
|
|
|
2006-07-19 06:06:07 +02:00
|
|
|
extern HRESULT allocate_shader_constants(IWineD3DStateBlockImpl* object);
|
|
|
|
|
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
|
|
|
SHADER_LIMITS limits;
|
2006-05-10 04:30:11 +02:00
|
|
|
SHADER_PARSE_STATE parse_state;
|
2007-11-16 21:02:29 +01:00
|
|
|
DWORD *function;
|
2006-03-30 19:14:31 +02:00
|
|
|
UINT functionLength;
|
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;
|
2009-05-05 09:38:03 +02:00
|
|
|
const struct wined3d_shader_frontend *frontend;
|
|
|
|
void *frontend_data;
|
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
|
|
|
|
2007-02-27 20:51:53 +01:00
|
|
|
/* Programs this shader is linked with */
|
|
|
|
struct list linked_programs;
|
|
|
|
|
2006-07-10 06:51:03 +02:00
|
|
|
/* Immediate constants (override global ones) */
|
|
|
|
struct list constantsB;
|
|
|
|
struct list constantsF;
|
|
|
|
struct list constantsI;
|
2006-08-05 18:15:35 +02:00
|
|
|
shader_reg_maps reg_maps;
|
2006-07-10 06:51:03 +02:00
|
|
|
|
2006-09-27 13:14:46 +02:00
|
|
|
/* Pointer to the parent device */
|
|
|
|
IWineD3DDevice *device;
|
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;
|
|
|
|
|
2008-12-09 09:52:38 +01:00
|
|
|
void shader_buffer_init(struct SHADER_BUFFER *buffer);
|
|
|
|
void shader_buffer_free(struct SHADER_BUFFER *buffer);
|
2008-12-09 09:52:39 +01:00
|
|
|
void shader_cleanup(IWineD3DBaseShader *iface);
|
2009-05-06 17:59:21 +02:00
|
|
|
void shader_dump_src_param(const struct wined3d_shader_src_param *param,
|
|
|
|
const struct wined3d_shader_version *shader_version);
|
|
|
|
void shader_dump_dst_param(const struct wined3d_shader_dst_param *param,
|
|
|
|
const struct wined3d_shader_version *shader_version);
|
2009-05-04 09:49:27 +02:00
|
|
|
void shader_generate_main(IWineD3DBaseShader *iface, SHADER_BUFFER *buffer,
|
2009-05-15 13:56:40 +02:00
|
|
|
const shader_reg_maps *reg_maps, const DWORD *pFunction, void *backend_ctx);
|
2009-05-04 09:49:27 +02:00
|
|
|
HRESULT shader_get_registers_used(IWineD3DBaseShader *iface, const struct wined3d_shader_frontend *fe,
|
2009-05-27 10:24:50 +02:00
|
|
|
struct shader_reg_maps *reg_maps, struct wined3d_shader_attribute *attributes,
|
2009-05-27 10:24:50 +02:00
|
|
|
struct wined3d_shader_signature_element *input_signature,
|
|
|
|
struct wined3d_shader_signature_element *output_signature, const DWORD *byte_code, DWORD constf_size);
|
2009-05-05 09:38:03 +02:00
|
|
|
void shader_init(struct IWineD3DBaseShaderClass *shader, IWineD3DDevice *device);
|
2009-05-27 10:24:50 +02:00
|
|
|
BOOL shader_match_semantic(const char *semantic_name, WINED3DDECLUSAGE usage);
|
2009-05-04 09:49:27 +02:00
|
|
|
const struct wined3d_shader_frontend *shader_select_frontend(DWORD version_token);
|
2009-05-05 09:38:03 +02:00
|
|
|
void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data, const DWORD *pFunction);
|
2006-05-10 04:33:24 +02:00
|
|
|
|
2009-05-06 17:59:21 +02:00
|
|
|
static inline BOOL shader_is_pshader_version(enum wined3d_shader_type type)
|
|
|
|
{
|
|
|
|
return type == WINED3D_SHADER_TYPE_PIXEL;
|
2006-05-14 15:43:31 +02:00
|
|
|
}
|
|
|
|
|
2009-05-06 17:59:21 +02:00
|
|
|
static inline BOOL shader_is_vshader_version(enum wined3d_shader_type type)
|
|
|
|
{
|
|
|
|
return type == WINED3D_SHADER_TYPE_VERTEX;
|
2006-05-14 15:43:31 +02:00
|
|
|
}
|
|
|
|
|
2009-05-07 16:36:08 +02:00
|
|
|
static inline BOOL shader_is_scalar(const struct wined3d_shader_register *reg)
|
2009-04-07 11:09:11 +02:00
|
|
|
{
|
2009-05-07 16:36:08 +02:00
|
|
|
switch (reg->type)
|
2009-04-07 11:09:11 +02:00
|
|
|
{
|
2007-04-12 23:55:31 +02:00
|
|
|
case WINED3DSPR_RASTOUT:
|
2009-04-07 11:09:11 +02:00
|
|
|
/* oFog & oPts */
|
2009-05-07 16:36:08 +02:00
|
|
|
if (reg->idx != 0) return TRUE;
|
2007-04-12 23:55:31 +02:00
|
|
|
/* 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:
|
2009-05-07 16:36:08 +02:00
|
|
|
switch(reg->idx)
|
2009-04-07 11:09:11 +02:00
|
|
|
{
|
2008-02-11 12:04:57 +01:00
|
|
|
case 0: /* vPos */
|
|
|
|
return FALSE;
|
|
|
|
case 1: /* vFace */
|
|
|
|
return TRUE;
|
|
|
|
default:
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2009-05-07 16:36:08 +02:00
|
|
|
case WINED3DSPR_IMMCONST:
|
|
|
|
switch(reg->immconst_type)
|
|
|
|
{
|
|
|
|
case WINED3D_IMMCONST_FLOAT:
|
|
|
|
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;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2003-11-14 04:50:35 +01:00
|
|
|
/*****************************************************************************
|
2009-02-05 19:44:32 +01:00
|
|
|
* IDirect3DVertexShader implementation structures
|
2003-11-14 04:50:35 +01:00
|
|
|
*/
|
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
|
|
|
|
2008-11-20 13:27:42 +01:00
|
|
|
/* The GL shader */
|
2009-05-26 21:06:37 +02:00
|
|
|
void *backend_priv;
|
2008-11-20 13:27:42 +01:00
|
|
|
|
2006-07-04 10:01:46 +02:00
|
|
|
/* Vertex shader input and output semantics */
|
2009-05-27 10:24:50 +02:00
|
|
|
struct wined3d_shader_attribute attributes[MAX_ATTRIBS];
|
2009-05-27 10:24:50 +02:00
|
|
|
struct wined3d_shader_signature_element output_signature[MAX_REG_OUTPUT];
|
2006-07-04 10:01:46 +02:00
|
|
|
|
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
|
|
|
} IWineD3DVertexShaderImpl;
|
2005-06-06 21:50:35 +02:00
|
|
|
extern const IWineD3DVertexShaderVtbl IWineD3DVertexShader_Vtbl;
|
2009-02-05 19:44:32 +01:00
|
|
|
|
|
|
|
void find_vs_compile_args(IWineD3DVertexShaderImpl *shader, IWineD3DStateBlockImpl *stateblock, struct vs_compile_args *args);
|
2003-11-14 04:50:35 +01:00
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* IDirect3DPixelShader implementation structure
|
|
|
|
*/
|
2009-06-17 23:24:25 +02:00
|
|
|
|
|
|
|
/* Using additional shader constants (uniforms in GLSL / program environment
|
|
|
|
* or local parameters in ARB) is costly:
|
|
|
|
* ARB only knows float4 parameters and GLSL compiler are not really smart
|
|
|
|
* when it comes to efficiently pack float2 uniforms, so no space is wasted
|
|
|
|
* (in fact most compilers map a float2 to a full float4 uniform).
|
|
|
|
*
|
|
|
|
* For NP2 texcoord fixup we only need 2 floats (width and height) for each
|
|
|
|
* 2D texture used in the shader. We therefore pack fixup info for 2 textures
|
|
|
|
* into a single shader constant (uniform / program parameter).
|
|
|
|
*
|
|
|
|
* This structure is shared between the GLSL and the ARB backend.*/
|
|
|
|
struct ps_np2fixup_info {
|
|
|
|
unsigned char idx[MAX_FRAGMENT_SAMPLERS]; /* indices to the real constant */
|
|
|
|
WORD active; /* bitfield indicating if we can apply the fixup */
|
|
|
|
WORD num_consts;
|
|
|
|
};
|
|
|
|
|
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 */
|
2009-05-27 10:24:50 +02:00
|
|
|
struct wined3d_shader_signature_element input_signature[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
|
|
|
|
2008-11-20 13:27:42 +01:00
|
|
|
/* The GL shader */
|
2009-05-26 21:05:59 +02:00
|
|
|
void *backend_priv;
|
2008-11-20 13:27:42 +01:00
|
|
|
|
2007-02-15 03:05:17 +01:00
|
|
|
/* Some information about the shader behavior */
|
2007-09-14 13:11:00 +02:00
|
|
|
char vpos_uniform;
|
2009-05-26 15:53:52 +02:00
|
|
|
|
|
|
|
BOOL color0_mov;
|
|
|
|
DWORD color0_reg;
|
|
|
|
|
2005-03-02 13:16:10 +01:00
|
|
|
} IWineD3DPixelShaderImpl;
|
2003-11-14 04:50:35 +01:00
|
|
|
|
2005-06-06 21:50:35 +02:00
|
|
|
extern const IWineD3DPixelShaderVtbl IWineD3DPixelShader_Vtbl;
|
2009-05-26 13:43:43 +02:00
|
|
|
void pixelshader_update_samplers(struct shader_reg_maps *reg_maps, IWineD3DBaseTexture * const *textures);
|
2008-11-20 02:55:17 +01:00
|
|
|
void find_ps_compile_args(IWineD3DPixelShaderImpl *shader, IWineD3DStateBlockImpl *stateblock, struct ps_compile_args *args);
|
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
|
|
|
|
*/
|
2008-12-03 14:53:42 +01:00
|
|
|
|
2009-05-01 09:13:54 +02:00
|
|
|
/* WineD3D pixel format flags */
|
|
|
|
#define WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING 0x1
|
|
|
|
#define WINED3DFMT_FLAG_FILTERING 0x2
|
|
|
|
#define WINED3DFMT_FLAG_DEPTH 0x4
|
|
|
|
#define WINED3DFMT_FLAG_STENCIL 0x8
|
|
|
|
#define WINED3DFMT_FLAG_RENDERTARGET 0x10
|
|
|
|
#define WINED3DFMT_FLAG_FOURCC 0x20
|
2009-06-05 14:39:20 +02:00
|
|
|
#define WINED3DFMT_FLAG_FBO_ATTACHABLE 0x40
|
2009-06-10 09:44:04 +02:00
|
|
|
#define WINED3DFMT_FLAG_COMPRESSED 0x80
|
2009-05-01 09:13:54 +02:00
|
|
|
|
2008-12-03 14:53:42 +01:00
|
|
|
struct GlPixelFormatDesc
|
|
|
|
{
|
2009-03-13 10:44:17 +01:00
|
|
|
WINED3DFORMAT format;
|
|
|
|
DWORD red_mask;
|
|
|
|
DWORD green_mask;
|
|
|
|
DWORD blue_mask;
|
|
|
|
DWORD alpha_mask;
|
|
|
|
UINT byte_count;
|
|
|
|
WORD depth_size;
|
|
|
|
WORD stencil_size;
|
|
|
|
|
2009-06-10 09:44:04 +02:00
|
|
|
UINT block_width;
|
|
|
|
UINT block_height;
|
|
|
|
UINT block_byte_count;
|
|
|
|
|
2009-03-27 10:25:56 +01:00
|
|
|
enum wined3d_ffp_emit_idx emit_idx;
|
|
|
|
GLint component_count;
|
|
|
|
GLenum gl_vtx_type;
|
|
|
|
GLint gl_vtx_format;
|
|
|
|
GLboolean gl_normalized;
|
|
|
|
unsigned int component_size;
|
|
|
|
|
2008-12-03 14:53:42 +01:00
|
|
|
GLint glInternal;
|
|
|
|
GLint glGammaInternal;
|
|
|
|
GLint rtInternal;
|
|
|
|
GLint glFormat;
|
|
|
|
GLint glType;
|
|
|
|
unsigned int Flags;
|
|
|
|
float heightscale;
|
2008-12-03 14:53:43 +01:00
|
|
|
struct color_fixup_desc color_fixup;
|
2008-12-03 14:53:42 +01:00
|
|
|
};
|
|
|
|
|
2009-03-13 10:44:18 +01:00
|
|
|
const struct GlPixelFormatDesc *getFormatDescEntry(WINED3DFORMAT fmt, const WineD3D_GL_Info *gl_info);
|
2007-03-12 23:22:00 +01:00
|
|
|
|
2008-12-30 14:56:49 +01:00
|
|
|
static inline BOOL use_vs(IWineD3DStateBlockImpl *stateblock)
|
|
|
|
{
|
|
|
|
return (stateblock->vertexShader
|
2009-01-08 10:19:16 +01:00
|
|
|
&& !stateblock->wineD3DDevice->strided_streams.position_transformed
|
2008-12-30 14:56:49 +01:00
|
|
|
&& stateblock->wineD3DDevice->vs_selected_mode != SHADER_NONE);
|
2007-03-12 23:22:00 +01:00
|
|
|
}
|
|
|
|
|
2008-12-30 14:56:49 +01:00
|
|
|
static inline BOOL use_ps(IWineD3DStateBlockImpl *stateblock)
|
|
|
|
{
|
|
|
|
return (stateblock->pixelShader
|
|
|
|
&& stateblock->wineD3DDevice->ps_selected_mode != SHADER_NONE);
|
2007-03-12 23:22:00 +01:00
|
|
|
}
|
|
|
|
|
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);
|
2009-05-11 21:43:54 +02:00
|
|
|
|
|
|
|
/* The WNDCLASS-Name for the fake window which we use to retrieve the GL capabilities */
|
|
|
|
#define WINED3D_OPENGL_WINDOW_CLASS_NAME "WineD3D_OpenGL"
|
|
|
|
|
2003-11-14 04:50:35 +01:00
|
|
|
#endif
|