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>
|
2009-12-09 20:32:09 +01:00
|
|
|
#include <limits.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
|
|
|
|
2009-07-01 09:46:19 +02:00
|
|
|
/* Driver quirks */
|
|
|
|
#define WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT 0x00000001
|
|
|
|
#define WINED3D_QUIRK_SET_TEXCOORD_W 0x00000002
|
|
|
|
#define WINED3D_QUIRK_GLSL_CLIP_VARYING 0x00000004
|
2009-07-10 11:28:49 +02:00
|
|
|
#define WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA 0x00000008
|
2009-09-28 12:30:48 +02:00
|
|
|
#define WINED3D_QUIRK_NV_CLIP_BROKEN 0x00000010
|
2010-03-17 21:59:51 +01:00
|
|
|
#define WINED3D_QUIRK_FBO_TEX_UPDATE 0x00000020
|
2009-07-01 09:46:19 +02:00
|
|
|
|
2010-11-30 18:39:37 +01:00
|
|
|
typedef struct IWineD3DSurfaceImpl IWineD3DSurfaceImpl;
|
|
|
|
typedef struct IWineD3DDeviceImpl IWineD3DDeviceImpl;
|
|
|
|
typedef struct IWineD3DSwapChainImpl IWineD3DSwapChainImpl;
|
2010-12-13 13:40:32 +01:00
|
|
|
struct IWineD3DBaseShaderImpl;
|
2011-01-03 18:51:41 +01:00
|
|
|
struct IWineD3DBaseTextureImpl;
|
2011-01-16 23:36:45 +01:00
|
|
|
struct IWineD3DResourceImpl;
|
2010-11-30 18:39:37 +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,
|
2010-03-02 16:21:45 +01:00
|
|
|
CHANNEL_SOURCE_COMPLEX0 = 6,
|
|
|
|
CHANNEL_SOURCE_COMPLEX1 = 7,
|
2008-12-03 14:53:43 +01:00
|
|
|
};
|
|
|
|
|
2010-03-02 16:21:45 +01:00
|
|
|
enum complex_fixup
|
2008-12-03 14:53:43 +01:00
|
|
|
{
|
2010-03-19 13:19:53 +01:00
|
|
|
COMPLEX_FIXUP_NONE = 0,
|
|
|
|
COMPLEX_FIXUP_YUY2 = 1,
|
|
|
|
COMPLEX_FIXUP_UYVY = 2,
|
|
|
|
COMPLEX_FIXUP_YV12 = 3,
|
|
|
|
COMPLEX_FIXUP_P8 = 4,
|
2008-12-03 14:53:43 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
#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;
|
|
|
|
}
|
|
|
|
|
2010-03-02 16:21:45 +01:00
|
|
|
static inline struct color_fixup_desc create_complex_fixup_desc(enum complex_fixup complex_fixup)
|
2008-12-03 14:53:43 +01:00
|
|
|
{
|
|
|
|
struct color_fixup_desc fixup =
|
|
|
|
{
|
2010-03-02 16:21:45 +01:00
|
|
|
0, complex_fixup & (1 << 0) ? CHANNEL_SOURCE_COMPLEX1 : CHANNEL_SOURCE_COMPLEX0,
|
|
|
|
0, complex_fixup & (1 << 1) ? CHANNEL_SOURCE_COMPLEX1 : CHANNEL_SOURCE_COMPLEX0,
|
|
|
|
0, complex_fixup & (1 << 2) ? CHANNEL_SOURCE_COMPLEX1 : CHANNEL_SOURCE_COMPLEX0,
|
|
|
|
0, complex_fixup & (1 << 3) ? CHANNEL_SOURCE_COMPLEX1 : CHANNEL_SOURCE_COMPLEX0,
|
2008-12-03 14:53:43 +01:00
|
|
|
};
|
|
|
|
return fixup;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline BOOL is_identity_fixup(struct color_fixup_desc fixup)
|
|
|
|
{
|
|
|
|
return !memcmp(&fixup, &COLOR_FIXUP_IDENTITY, sizeof(fixup));
|
|
|
|
}
|
|
|
|
|
2010-03-02 16:21:45 +01:00
|
|
|
static inline BOOL is_complex_fixup(struct color_fixup_desc fixup)
|
2008-12-03 14:53:43 +01:00
|
|
|
{
|
2010-03-02 16:21:45 +01:00
|
|
|
return fixup.x_source == CHANNEL_SOURCE_COMPLEX0 || fixup.x_source == CHANNEL_SOURCE_COMPLEX1;
|
2008-12-03 14:53:43 +01:00
|
|
|
}
|
|
|
|
|
2010-03-02 16:21:45 +01:00
|
|
|
static inline enum complex_fixup get_complex_fixup(struct color_fixup_desc fixup)
|
2008-12-03 14:53:43 +01:00
|
|
|
{
|
2010-03-02 16:21:45 +01:00
|
|
|
enum complex_fixup complex_fixup = 0;
|
|
|
|
if (fixup.x_source == CHANNEL_SOURCE_COMPLEX1) complex_fixup |= (1 << 0);
|
|
|
|
if (fixup.y_source == CHANNEL_SOURCE_COMPLEX1) complex_fixup |= (1 << 1);
|
|
|
|
if (fixup.z_source == CHANNEL_SOURCE_COMPLEX1) complex_fixup |= (1 << 2);
|
|
|
|
if (fixup.w_source == CHANNEL_SOURCE_COMPLEX1) complex_fixup |= (1 << 3);
|
|
|
|
return complex_fixup;
|
2008-12-03 14:53:43 +01:00
|
|
|
}
|
|
|
|
|
2009-09-11 19:01:19 +02:00
|
|
|
void *wined3d_rb_alloc(size_t size) DECLSPEC_HIDDEN;
|
|
|
|
void *wined3d_rb_realloc(void *ptr, size_t size) DECLSPEC_HIDDEN;
|
|
|
|
void wined3d_rb_free(void *ptr) DECLSPEC_HIDDEN;
|
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
|
|
|
|
2008-11-26 16:14:40 +01:00
|
|
|
struct min_lookup
|
|
|
|
{
|
|
|
|
GLenum mip[WINED3DTEXF_LINEAR + 1];
|
|
|
|
};
|
|
|
|
|
2010-10-01 13:42:22 +02:00
|
|
|
extern const struct min_lookup minMipLookup[WINED3DTEXF_LINEAR + 1] DECLSPEC_HIDDEN;
|
|
|
|
extern const struct min_lookup minMipLookup_noFilter[WINED3DTEXF_LINEAR + 1] DECLSPEC_HIDDEN;
|
|
|
|
extern const struct min_lookup minMipLookup_noMip[WINED3DTEXF_LINEAR + 1] DECLSPEC_HIDDEN;
|
|
|
|
extern const GLenum magLookup[WINED3DTEXF_LINEAR + 1] DECLSPEC_HIDDEN;
|
|
|
|
extern const GLenum magLookup_noFilter[WINED3DTEXF_LINEAR + 1] DECLSPEC_HIDDEN;
|
2008-04-06 00:31:39 +02:00
|
|
|
|
2009-08-05 09:00:59 +02:00
|
|
|
static inline GLenum wined3d_gl_mag_filter(const GLenum mag_lookup[], WINED3DTEXTUREFILTERTYPE mag_filter)
|
|
|
|
{
|
|
|
|
return mag_lookup[mag_filter];
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline GLenum wined3d_gl_min_mip_filter(const struct min_lookup min_mip_lookup[],
|
|
|
|
WINED3DTEXTUREFILTERTYPE min_filter, WINED3DTEXTUREFILTERTYPE mip_filter)
|
|
|
|
{
|
|
|
|
return min_mip_lookup[min_filter].mip[mip_filter];
|
|
|
|
}
|
|
|
|
|
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;
|
2009-07-07 11:08:01 +02:00
|
|
|
const float sgn = (s ? -1.0f : 1.0f);
|
2007-12-19 17:18:39 +01:00
|
|
|
|
|
|
|
if(e == 0) {
|
2009-07-07 11:08:01 +02:00
|
|
|
if(m == 0) return sgn * 0.0f; /* +0.0 or -0.0 */
|
2010-07-28 15:05:37 +02:00
|
|
|
else return sgn * powf(2, -14.0f) * ((float)m / 1024.0f);
|
2007-12-19 17:18:39 +01:00
|
|
|
} else if(e < 31) {
|
2010-07-28 15:05:37 +02:00
|
|
|
return sgn * powf(2, (float)e - 15.0f) * (1.0f + ((float)m / 1024.0f));
|
2007-12-19 17:18:39 +01:00
|
|
|
} else {
|
2009-07-07 11:08:01 +02:00
|
|
|
if(m == 0) return sgn / 0.0f; /* +INF / -INF */
|
|
|
|
else return 0.0f / 0.0f; /* NAN */
|
2007-12-19 17:18:39 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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;
|
2010-07-28 15:06:38 +02:00
|
|
|
const unsigned int m = in & 0x7ffff;
|
2009-06-16 09:38:25 +02:00
|
|
|
|
|
|
|
if (e == 0)
|
|
|
|
{
|
|
|
|
if (m == 0) return sgn * 0.0f; /* +0.0 or -0.0 */
|
2010-07-28 15:05:37 +02:00
|
|
|
else return sgn * powf(2, -6.0f) * ((float)m / 524288.0f);
|
2009-06-16 09:38:25 +02:00
|
|
|
}
|
|
|
|
else if (e < 15)
|
|
|
|
{
|
2010-07-28 15:05:37 +02:00
|
|
|
return sgn * powf(2, (float)e - 7.0f) * (1.0f + ((float)m / 524288.0f));
|
2009-06-16 09:38:25 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2009-07-07 11:08:01 +02:00
|
|
|
if (m == 0) return sgn / 0.0f; /* +INF / -INF */
|
|
|
|
else return 0.0f / 0.0f; /* NAN */
|
2009-06-16 09:38:25 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-07-24 19:11:33 +02:00
|
|
|
/**
|
2009-08-27 10:04:56 +02:00
|
|
|
* Settings
|
2005-07-24 19:11:33 +02:00
|
|
|
*/
|
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
|
|
|
|
|
2006-11-17 13:23:53 +01:00
|
|
|
#define ORM_BACKBUFFER 0
|
2010-03-14 21:53:23 +01:00
|
|
|
#define ORM_FBO 1
|
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_READDRAW 1
|
|
|
|
#define RTL_READTEX 2
|
|
|
|
|
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;
|
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;
|
2010-04-13 20:46:26 +02:00
|
|
|
BOOL strict_draw_ordering;
|
2005-07-24 19:11:33 +02:00
|
|
|
} wined3d_settings_t;
|
|
|
|
|
2009-09-11 19:01:19 +02:00
|
|
|
extern wined3d_settings_t wined3d_settings DECLSPEC_HIDDEN;
|
2005-07-24 19:11:33 +02:00
|
|
|
|
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-07-16 13:08:22 +02:00
|
|
|
WINED3DSPR_CONSTBUFFER,
|
2010-10-08 13:12:15 +02:00
|
|
|
WINED3DSPR_NULL,
|
2010-10-12 13:40:03 +02:00
|
|
|
WINED3DSPR_RESOURCE,
|
2009-05-01 09:13:54 +02:00
|
|
|
} WINED3DSHADER_PARAM_REGISTER_TYPE;
|
|
|
|
|
2009-05-06 10:05:46 +02:00
|
|
|
enum wined3d_immconst_type
|
|
|
|
{
|
2010-10-08 13:12:18 +02:00
|
|
|
WINED3D_IMMCONST_SCALAR,
|
|
|
|
WINED3D_IMMCONST_VEC4,
|
2009-05-06 10:05:46 +02:00
|
|
|
};
|
|
|
|
|
2009-05-01 09:13:54 +02:00
|
|
|
#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;
|
|
|
|
|
|
|
|
/* 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
|
2009-07-09 09:56:08 +02:00
|
|
|
|
|
|
|
struct wined3d_shader_buffer
|
|
|
|
{
|
|
|
|
char *buffer;
|
2008-03-18 19:19:16 +01:00
|
|
|
unsigned int bsize;
|
|
|
|
unsigned int lineNo;
|
|
|
|
BOOL newline;
|
2009-07-09 09:56:08 +02:00
|
|
|
};
|
2008-03-18 19:19:16 +01:00
|
|
|
|
2008-09-23 17:39:34 +02:00
|
|
|
enum WINED3D_SHADER_INSTRUCTION_HANDLER
|
|
|
|
{
|
|
|
|
WINED3DSIH_ABS,
|
|
|
|
WINED3DSIH_ADD,
|
2010-10-07 12:17:57 +02:00
|
|
|
WINED3DSIH_AND,
|
2008-09-23 17:39:34 +02:00
|
|
|
WINED3DSIH_BEM,
|
|
|
|
WINED3DSIH_BREAK,
|
|
|
|
WINED3DSIH_BREAKC,
|
|
|
|
WINED3DSIH_BREAKP,
|
|
|
|
WINED3DSIH_CALL,
|
|
|
|
WINED3DSIH_CALLNZ,
|
|
|
|
WINED3DSIH_CMP,
|
|
|
|
WINED3DSIH_CND,
|
|
|
|
WINED3DSIH_CRS,
|
2010-01-06 23:22:17 +01:00
|
|
|
WINED3DSIH_CUT,
|
2008-09-23 17:39:34 +02:00
|
|
|
WINED3DSIH_DCL,
|
|
|
|
WINED3DSIH_DEF,
|
|
|
|
WINED3DSIH_DEFB,
|
|
|
|
WINED3DSIH_DEFI,
|
2010-10-13 12:26:29 +02:00
|
|
|
WINED3DSIH_DIV,
|
2008-09-23 17:39:34 +02:00
|
|
|
WINED3DSIH_DP2ADD,
|
|
|
|
WINED3DSIH_DP3,
|
|
|
|
WINED3DSIH_DP4,
|
|
|
|
WINED3DSIH_DST,
|
|
|
|
WINED3DSIH_DSX,
|
|
|
|
WINED3DSIH_DSY,
|
|
|
|
WINED3DSIH_ELSE,
|
2010-01-06 23:22:10 +01:00
|
|
|
WINED3DSIH_EMIT,
|
2008-09-23 17:39:34 +02:00
|
|
|
WINED3DSIH_ENDIF,
|
|
|
|
WINED3DSIH_ENDLOOP,
|
|
|
|
WINED3DSIH_ENDREP,
|
|
|
|
WINED3DSIH_EXP,
|
|
|
|
WINED3DSIH_EXPP,
|
|
|
|
WINED3DSIH_FRC,
|
2010-10-13 12:26:30 +02:00
|
|
|
WINED3DSIH_FTOI,
|
2010-01-06 23:22:11 +01:00
|
|
|
WINED3DSIH_IADD,
|
2010-10-13 12:26:31 +02:00
|
|
|
WINED3DSIH_IEQ,
|
2008-09-23 17:39:34 +02:00
|
|
|
WINED3DSIH_IF,
|
|
|
|
WINED3DSIH_IFC,
|
2010-01-06 23:22:08 +01:00
|
|
|
WINED3DSIH_IGE,
|
2010-10-08 13:12:16 +02:00
|
|
|
WINED3DSIH_IMUL,
|
2010-10-11 13:06:16 +02:00
|
|
|
WINED3DSIH_ITOF,
|
2008-09-23 17:39:34 +02:00
|
|
|
WINED3DSIH_LABEL,
|
2010-10-13 12:26:32 +02:00
|
|
|
WINED3DSIH_LD,
|
2008-09-23 17:39:34 +02:00
|
|
|
WINED3DSIH_LIT,
|
|
|
|
WINED3DSIH_LOG,
|
|
|
|
WINED3DSIH_LOGP,
|
|
|
|
WINED3DSIH_LOOP,
|
|
|
|
WINED3DSIH_LRP,
|
2010-01-06 23:22:12 +01:00
|
|
|
WINED3DSIH_LT,
|
2008-09-23 17:39:34 +02:00
|
|
|
WINED3DSIH_M3x2,
|
|
|
|
WINED3DSIH_M3x3,
|
|
|
|
WINED3DSIH_M3x4,
|
|
|
|
WINED3DSIH_M4x3,
|
|
|
|
WINED3DSIH_M4x4,
|
|
|
|
WINED3DSIH_MAD,
|
|
|
|
WINED3DSIH_MAX,
|
|
|
|
WINED3DSIH_MIN,
|
|
|
|
WINED3DSIH_MOV,
|
|
|
|
WINED3DSIH_MOVA,
|
2010-10-07 12:18:00 +02:00
|
|
|
WINED3DSIH_MOVC,
|
2008-09-23 17:39:34 +02:00
|
|
|
WINED3DSIH_MUL,
|
|
|
|
WINED3DSIH_NOP,
|
|
|
|
WINED3DSIH_NRM,
|
|
|
|
WINED3DSIH_PHASE,
|
|
|
|
WINED3DSIH_POW,
|
|
|
|
WINED3DSIH_RCP,
|
|
|
|
WINED3DSIH_REP,
|
|
|
|
WINED3DSIH_RET,
|
|
|
|
WINED3DSIH_RSQ,
|
2010-10-11 13:06:17 +02:00
|
|
|
WINED3DSIH_SAMPLE,
|
2010-10-14 13:03:58 +02:00
|
|
|
WINED3DSIH_SAMPLE_GRAD,
|
2010-10-11 13:06:18 +02:00
|
|
|
WINED3DSIH_SAMPLE_LOD,
|
2008-09-23 17:39:34 +02:00
|
|
|
WINED3DSIH_SETP,
|
|
|
|
WINED3DSIH_SGE,
|
|
|
|
WINED3DSIH_SGN,
|
|
|
|
WINED3DSIH_SINCOS,
|
|
|
|
WINED3DSIH_SLT,
|
2010-10-20 12:12:27 +02:00
|
|
|
WINED3DSIH_SQRT,
|
2008-09-23 17:39:34 +02:00
|
|
|
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,
|
2010-10-11 13:06:19 +02:00
|
|
|
WINED3DSIH_UTOF,
|
2008-09-23 17:39:34 +02:00
|
|
|
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))
|
|
|
|
|
2010-12-06 20:33:02 +01:00
|
|
|
struct wined3d_shader_reg_maps
|
2009-04-01 12:23:01 +02:00
|
|
|
{
|
2009-05-06 17:59:21 +02:00
|
|
|
struct wined3d_shader_version shader_version;
|
2009-08-11 09:42:15 +02:00
|
|
|
BYTE texcoord; /* MAX_REG_TEXCRD, 8 */
|
2009-08-12 09:44:23 +02:00
|
|
|
BYTE address; /* MAX_REG_ADDR, 1 */
|
2009-08-12 09:44:24 +02:00
|
|
|
WORD labels; /* MAX_LABELS, 16 */
|
2009-08-11 09:42:16 +02:00
|
|
|
DWORD temporary; /* MAX_REG_TEMP, 32 */
|
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-08-12 09:44:25 +02:00
|
|
|
BYTE bumpmat; /* MAX_TEXTURES, 8 */
|
2009-08-12 09:44:26 +02:00
|
|
|
BYTE luminanceparams; /* MAX_TEXTURES, 8 */
|
2009-05-29 17:29:57 +02:00
|
|
|
|
2009-08-11 09:42:14 +02:00
|
|
|
WORD usesnrm : 1;
|
|
|
|
WORD vpos : 1;
|
|
|
|
WORD usesdsx : 1;
|
|
|
|
WORD usesdsy : 1;
|
|
|
|
WORD usestexldd : 1;
|
|
|
|
WORD usesmova : 1;
|
|
|
|
WORD usesfacing : 1;
|
|
|
|
WORD usesrelconstF : 1;
|
|
|
|
WORD fog : 1;
|
|
|
|
WORD usestexldl : 1;
|
|
|
|
WORD usesifc : 1;
|
|
|
|
WORD usescall : 1;
|
2010-05-21 14:05:46 +02:00
|
|
|
WORD usesrcp : 1;
|
|
|
|
WORD padding : 3;
|
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;
|
2010-12-01 20:50:48 +01:00
|
|
|
UINT min_rel_offset, max_rel_offset;
|
2010-12-06 20:33:02 +01:00
|
|
|
};
|
2009-04-01 12:23:01 +02:00
|
|
|
|
2010-10-29 12:25:15 +02:00
|
|
|
/* Keeps track of details for TEX_M#x# instructions which need to maintain
|
|
|
|
* state information between multiple instructions. */
|
|
|
|
struct wined3d_shader_tex_mx
|
|
|
|
{
|
|
|
|
unsigned int current_row;
|
|
|
|
DWORD texcoord_w[2];
|
|
|
|
};
|
|
|
|
|
2010-10-29 12:25:16 +02:00
|
|
|
struct wined3d_shader_loop_state
|
|
|
|
{
|
|
|
|
UINT current_depth;
|
|
|
|
UINT current_reg;
|
|
|
|
};
|
|
|
|
|
2009-04-15 10:06:28 +02:00
|
|
|
struct wined3d_shader_context
|
|
|
|
{
|
2010-12-14 18:31:01 +01:00
|
|
|
struct IWineD3DBaseShaderImpl *shader;
|
2010-01-24 21:16:13 +01:00
|
|
|
const struct wined3d_gl_info *gl_info;
|
2010-12-06 20:33:02 +01:00
|
|
|
const struct wined3d_shader_reg_maps *reg_maps;
|
2009-07-09 09:56:08 +02:00
|
|
|
struct wined3d_shader_buffer *buffer;
|
2010-10-29 12:25:15 +02:00
|
|
|
struct wined3d_shader_tex_mx *tex_mx;
|
2010-10-29 12:25:16 +02:00
|
|
|
struct wined3d_shader_loop_state *loop_state;
|
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;
|
2009-07-16 13:08:21 +02:00
|
|
|
UINT array_idx;
|
2009-05-07 16:36:07 +02:00
|
|
|
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-08-10 09:30:48 +02:00
|
|
|
struct wined3d_shader_loop_control
|
|
|
|
{
|
|
|
|
unsigned int count;
|
|
|
|
unsigned int start;
|
|
|
|
int step;
|
|
|
|
};
|
|
|
|
|
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);
|
2010-02-22 21:37:19 +01:00
|
|
|
void (*shader_read_comment)(const DWORD **ptr, const char **comment, UINT *comment_size);
|
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
|
|
|
};
|
|
|
|
|
2009-09-11 19:01:19 +02:00
|
|
|
extern const struct wined3d_shader_frontend sm1_shader_frontend DECLSPEC_HIDDEN;
|
|
|
|
extern const struct wined3d_shader_frontend sm4_shader_frontend DECLSPEC_HIDDEN;
|
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
|
|
|
|
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
|
|
|
|
*/
|
2010-09-30 12:16:16 +02:00
|
|
|
|
|
|
|
#define WINED3D_PSARGS_PROJECTED (1 << 3)
|
|
|
|
#define WINED3D_PSARGS_TEXTRANSFORM_SHIFT 4
|
|
|
|
#define WINED3D_PSARGS_TEXTRANSFORM_MASK 0xf
|
|
|
|
|
2008-12-14 15:40:07 +01:00
|
|
|
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;
|
2010-09-30 12:16:16 +02:00
|
|
|
WORD tex_transform; /* ps 1.0-1.3, 4 textures */
|
2008-12-14 15:40:07 +01:00
|
|
|
/* Texture types(2D, Cube, 3D) in ps 1.x */
|
2010-09-30 12:16:16 +02:00
|
|
|
WORD 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). */
|
2010-05-17 11:14:48 +02:00
|
|
|
WORD shadow; /* MAX_FRAGMENT_SAMPLERS, 16 */
|
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 {
|
2009-11-01 17:03:39 +01:00
|
|
|
BYTE fog_src;
|
|
|
|
BYTE clip_enabled;
|
2009-02-05 19:44:32 +01:00
|
|
|
WORD swizzle_map; /* MAX_ATTRIBS, 16 */
|
|
|
|
};
|
|
|
|
|
2009-08-06 08:12:20 +02:00
|
|
|
struct wined3d_context;
|
2010-10-25 12:33:40 +02:00
|
|
|
struct wined3d_state;
|
2009-08-06 08:12:20 +02:00
|
|
|
|
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 *);
|
2009-08-07 08:51:18 +02:00
|
|
|
void (*shader_select)(const struct wined3d_context *context, BOOL usePS, BOOL useVS);
|
2010-11-29 23:08:39 +01:00
|
|
|
void (*shader_select_depth_blt)(void *shader_priv, const struct wined3d_gl_info *gl_info,
|
|
|
|
enum tex_types tex_type, const SIZE *ds_mask_size);
|
2010-11-29 23:08:40 +01:00
|
|
|
void (*shader_deselect_depth_blt)(void *shader_priv, const struct wined3d_gl_info *gl_info);
|
2010-11-30 18:39:37 +01:00
|
|
|
void (*shader_update_float_vertex_constants)(IWineD3DDeviceImpl *device, UINT start, UINT count);
|
2010-11-30 18:39:38 +01:00
|
|
|
void (*shader_update_float_pixel_constants)(IWineD3DDeviceImpl *device, UINT start, UINT count);
|
2009-08-06 08:12:20 +02:00
|
|
|
void (*shader_load_constants)(const struct wined3d_context *context, char usePS, char useVS);
|
2010-10-25 12:33:40 +02:00
|
|
|
void (*shader_load_np2fixup_constants)(void *shader_priv, const struct wined3d_gl_info *gl_info,
|
|
|
|
const struct wined3d_state *state);
|
2010-12-13 13:40:32 +01:00
|
|
|
void (*shader_destroy)(struct IWineD3DBaseShaderImpl *shader);
|
2010-11-30 18:39:39 +01:00
|
|
|
HRESULT (*shader_alloc_private)(IWineD3DDeviceImpl *device);
|
2010-11-30 18:39:40 +01:00
|
|
|
void (*shader_free_private)(IWineD3DDeviceImpl *device);
|
2010-12-01 20:50:44 +01:00
|
|
|
BOOL (*shader_dirtifyable_constants)(void);
|
2010-02-03 18:18:00 +01:00
|
|
|
void (*shader_get_caps)(const struct 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;
|
|
|
|
|
2009-09-11 19:01:19 +02:00
|
|
|
extern const shader_backend_t glsl_shader_backend DECLSPEC_HIDDEN;
|
|
|
|
extern const shader_backend_t arb_program_shader_backend DECLSPEC_HIDDEN;
|
|
|
|
extern const shader_backend_t none_shader_backend DECLSPEC_HIDDEN;
|
2006-11-27 20:50:37 +01:00
|
|
|
|
2004-09-29 23:26:47 +02:00
|
|
|
/* X11 locking */
|
|
|
|
|
2010-07-28 15:29:15 +02:00
|
|
|
extern void (CDECL *wine_tsx11_lock_ptr)(void) DECLSPEC_HIDDEN;
|
|
|
|
extern void (CDECL *wine_tsx11_unlock_ptr)(void) DECLSPEC_HIDDEN;
|
2004-09-29 23:26:47 +02:00
|
|
|
|
|
|
|
/* As GLX relies on X, this is needed */
|
2009-09-11 19:01:19 +02:00
|
|
|
extern int num_lock DECLSPEC_HIDDEN;
|
2004-09-29 23:26:47 +02:00
|
|
|
|
|
|
|
#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 */
|
|
|
|
/* ------------------ */
|
2010-05-25 12:02:04 +02:00
|
|
|
#define GL_EXTCALL(f) (gl_info->f)
|
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
|
|
|
|
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
|
2009-07-15 18:45:03 +02:00
|
|
|
#define checkGLcall(A) \
|
|
|
|
do { \
|
|
|
|
GLint err; \
|
|
|
|
if(!__WINE_IS_DEBUG_ON(_FIXME, __wine_dbch___default)) break; \
|
|
|
|
err = glGetError(); \
|
|
|
|
if (err == GL_NO_ERROR) { \
|
|
|
|
TRACE("%s call ok %s / %d\n", A, __FILE__, __LINE__); \
|
|
|
|
\
|
|
|
|
} else do { \
|
2010-03-29 13:31:11 +02:00
|
|
|
ERR(">>>>>>>>>>>>>>>>> %s (%#x) from %s @ %s / %d\n", \
|
2009-07-15 18:45:03 +02:00
|
|
|
debug_glerror(err), err, A, __FILE__, __LINE__); \
|
|
|
|
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-12-13 14:35:38 +01:00
|
|
|
/* Trace vector and strided data information */
|
2009-08-21 09:12:30 +02:00
|
|
|
#define TRACE_STRIDED(si, name) do { if (si->use_map & (1 << name)) \
|
|
|
|
TRACE( #name "=(data:%p, stride:%d, format:%#x, vbo %d, stream %u)\n", \
|
2010-08-30 20:29:49 +02:00
|
|
|
si->elements[name].data, si->elements[name].stride, si->elements[name].format->id, \
|
2009-08-21 09:12:30 +02:00
|
|
|
si->elements[name].buffer_object, si->elements[name].stream_idx); } while(0)
|
2004-12-09 12:42:34 +01:00
|
|
|
|
2004-12-13 14:35:38 +01:00
|
|
|
/* Global variables */
|
2009-09-11 19:01:19 +02:00
|
|
|
extern const float identity[16] DECLSPEC_HIDDEN;
|
2004-11-28 16:04:41 +01:00
|
|
|
|
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
|
|
|
|
{
|
2010-08-30 20:29:49 +02:00
|
|
|
const struct wined3d_format *format;
|
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 */
|
2010-11-29 23:08:38 +01:00
|
|
|
void drawPrimitive(IWineD3DDeviceImpl *device, UINT index_count,
|
2009-09-11 19:01:19 +02:00
|
|
|
UINT start_idx, UINT idxBytes, const void *idxData) DECLSPEC_HIDDEN;
|
|
|
|
DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) DECLSPEC_HIDDEN;
|
2006-05-12 22:21:31 +02:00
|
|
|
|
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-09-11 19:01:19 +02:00
|
|
|
extern glAttribFunc position_funcs[WINED3D_FFP_EMIT_COUNT] DECLSPEC_HIDDEN;
|
|
|
|
extern glAttribFunc diffuse_funcs[WINED3D_FFP_EMIT_COUNT] DECLSPEC_HIDDEN;
|
|
|
|
extern glAttribFunc specular_func_3ubv DECLSPEC_HIDDEN;
|
|
|
|
extern glAttribFunc specular_funcs[WINED3D_FFP_EMIT_COUNT] DECLSPEC_HIDDEN;
|
|
|
|
extern glAttribFunc normal_funcs[WINED3D_FFP_EMIT_COUNT] DECLSPEC_HIDDEN;
|
|
|
|
extern glMultiTexCoordFunc multi_texcoord_funcs[WINED3D_FFP_EMIT_COUNT] DECLSPEC_HIDDEN;
|
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 */
|
|
|
|
|
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))
|
2010-01-28 23:40:23 +01:00
|
|
|
#define STATE_IS_MATERIAL(a) ((a) == STATE_MATERIAL)
|
2007-06-15 21:33:54 +02:00
|
|
|
|
2007-09-18 11:43:09 +02:00
|
|
|
#define STATE_FRONTFACE (STATE_MATERIAL + 1)
|
2010-01-28 23:40:23 +01:00
|
|
|
#define STATE_IS_FRONTFACE(a) ((a) == STATE_FRONTFACE)
|
2007-09-18 11:43:09 +02:00
|
|
|
|
2011-01-07 01:16:18 +01:00
|
|
|
#define STATE_POINTSPRITECOORDORIGIN (STATE_FRONTFACE + 1)
|
|
|
|
#define STATE_IS_POINTSPRITECOORDORIGIN(a) ((a) == STATE_POINTSPRITECOORDORIGIN)
|
|
|
|
|
|
|
|
#define STATE_HIGHEST (STATE_POINTSPRITECOORDORIGIN)
|
2006-12-19 13:00:03 +01: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
|
|
|
|
|
2009-07-24 10:44:13 +02:00
|
|
|
struct wined3d_occlusion_query
|
|
|
|
{
|
|
|
|
struct list entry;
|
|
|
|
GLuint id;
|
2009-08-03 08:06:51 +02:00
|
|
|
struct wined3d_context *context;
|
2009-07-24 10:44:13 +02:00
|
|
|
};
|
|
|
|
|
2010-01-25 19:51:30 +01:00
|
|
|
union wined3d_gl_query_object
|
|
|
|
{
|
|
|
|
GLuint id;
|
|
|
|
GLsync sync;
|
|
|
|
};
|
|
|
|
|
2009-07-24 10:44:14 +02:00
|
|
|
struct wined3d_event_query
|
|
|
|
{
|
|
|
|
struct list entry;
|
2010-01-25 19:51:30 +01:00
|
|
|
union wined3d_gl_query_object object;
|
2009-08-03 08:06:51 +02:00
|
|
|
struct wined3d_context *context;
|
2009-07-24 10:44:14 +02:00
|
|
|
};
|
|
|
|
|
2010-03-03 22:45:34 +01:00
|
|
|
enum wined3d_event_query_result
|
|
|
|
{
|
|
|
|
WINED3D_EVENT_QUERY_OK,
|
|
|
|
WINED3D_EVENT_QUERY_WAITING,
|
|
|
|
WINED3D_EVENT_QUERY_NOT_STARTED,
|
|
|
|
WINED3D_EVENT_QUERY_WRONG_THREAD,
|
2010-03-03 23:48:50 +01:00
|
|
|
WINED3D_EVENT_QUERY_ERROR
|
2010-03-03 22:45:34 +01:00
|
|
|
};
|
|
|
|
|
2010-03-21 13:26:36 +01:00
|
|
|
void wined3d_event_query_destroy(struct wined3d_event_query *query) DECLSPEC_HIDDEN;
|
|
|
|
enum wined3d_event_query_result wined3d_event_query_test(struct wined3d_event_query *query, IWineD3DDeviceImpl *device) DECLSPEC_HIDDEN;
|
|
|
|
enum wined3d_event_query_result wined3d_event_query_finish(struct wined3d_event_query *query, IWineD3DDeviceImpl *device) DECLSPEC_HIDDEN;
|
|
|
|
void wined3d_event_query_issue(struct wined3d_event_query *query, IWineD3DDeviceImpl *device) DECLSPEC_HIDDEN;
|
2010-07-29 17:13:01 +02:00
|
|
|
BOOL wined3d_event_query_supported(const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
|
2010-03-21 13:26:36 +01:00
|
|
|
|
2009-08-03 08:06:51 +02:00
|
|
|
struct wined3d_context
|
2009-07-17 10:34:02 +02:00
|
|
|
{
|
|
|
|
const struct wined3d_gl_info *gl_info;
|
2007-02-12 19:18:31 +01:00
|
|
|
/* 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;
|
2009-12-29 17:10:22 +01:00
|
|
|
DWORD isStateDirty[STATE_HIGHEST / (sizeof(DWORD) * CHAR_BIT) + 1]; /* Bitmap to find out quickly if a state is dirty */
|
2007-02-12 19:18:31 +01:00
|
|
|
|
2010-03-15 21:07:25 +01:00
|
|
|
IWineD3DSwapChainImpl *swapchain;
|
2010-04-21 22:02:31 +02:00
|
|
|
IWineD3DSurfaceImpl *current_rt;
|
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 */
|
2009-08-06 08:12:19 +02:00
|
|
|
WORD render_offscreen : 1;
|
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 fog_enabled : 1;
|
|
|
|
WORD num_untracked_materials : 2; /* Max value 2 */
|
2009-07-22 10:41:06 +02:00
|
|
|
WORD current : 1;
|
|
|
|
WORD destroyed : 1;
|
2009-10-20 11:05:04 +02:00
|
|
|
WORD valid : 1;
|
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 */
|
2009-10-28 11:00:11 +01:00
|
|
|
UINT level;
|
2009-10-28 11:00:13 +01:00
|
|
|
HGLRC restore_ctx;
|
|
|
|
HDC restore_dc;
|
2007-08-08 03:09:38 +02:00
|
|
|
HGLRC glCtx;
|
|
|
|
HWND win_handle;
|
|
|
|
HDC hdc;
|
2010-03-15 21:07:31 +01:00
|
|
|
int pixel_format;
|
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;
|
2009-10-20 11:05:06 +02:00
|
|
|
struct list fbo_destroy_list;
|
2008-09-18 14:57:53 +02:00
|
|
|
struct fbo_entry *current_fbo;
|
2008-08-21 18:34:55 +02:00
|
|
|
GLuint dst_fbo;
|
2009-07-17 10:34:05 +02:00
|
|
|
GLuint fbo_read_binding;
|
|
|
|
GLuint fbo_draw_binding;
|
2010-03-17 21:59:51 +01:00
|
|
|
BOOL rebind_fbo;
|
2010-05-04 20:39:52 +02:00
|
|
|
IWineD3DSurfaceImpl **blit_targets;
|
2010-07-30 10:15:26 +02:00
|
|
|
GLenum *draw_buffers;
|
2008-12-15 19:21:37 +01:00
|
|
|
|
2009-07-24 10:44:13 +02:00
|
|
|
/* Queries */
|
|
|
|
GLuint *free_occlusion_queries;
|
|
|
|
UINT free_occlusion_query_size;
|
|
|
|
UINT free_occlusion_query_count;
|
|
|
|
struct list occlusion_queries;
|
|
|
|
|
2010-01-25 19:51:30 +01:00
|
|
|
union wined3d_gl_query_object *free_event_queries;
|
2009-07-24 10:44:14 +02:00
|
|
|
UINT free_event_query_size;
|
|
|
|
UINT free_event_query_count;
|
|
|
|
struct list event_queries;
|
|
|
|
|
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
|
|
|
};
|
|
|
|
|
2011-01-28 20:05:43 +01:00
|
|
|
typedef void (*APPLYSTATEFUNC)(DWORD state, struct wined3d_stateblock *stateblock, struct wined3d_context *ctx);
|
2009-08-03 08:06:51 +02:00
|
|
|
|
|
|
|
struct StateEntry
|
|
|
|
{
|
|
|
|
DWORD representative;
|
|
|
|
APPLYSTATEFUNC apply;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct StateEntryTemplate
|
|
|
|
{
|
|
|
|
DWORD state;
|
|
|
|
struct StateEntry content;
|
|
|
|
GL_SupportedExt extension;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct fragment_caps
|
|
|
|
{
|
|
|
|
DWORD PrimitiveMiscCaps;
|
|
|
|
DWORD TextureOpCaps;
|
|
|
|
DWORD MaxTextureBlendStages;
|
|
|
|
DWORD MaxSimultaneousTextures;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct fragment_pipeline
|
|
|
|
{
|
2010-12-01 20:50:45 +01:00
|
|
|
void (*enable_extension)(BOOL enable);
|
2010-02-03 18:17:59 +01:00
|
|
|
void (*get_caps)(const struct wined3d_gl_info *gl_info, struct fragment_caps *caps);
|
2010-12-01 20:50:46 +01:00
|
|
|
HRESULT (*alloc_private)(IWineD3DDeviceImpl *device);
|
2010-12-01 20:50:47 +01:00
|
|
|
void (*free_private)(IWineD3DDeviceImpl *device);
|
2009-08-03 08:06:51 +02:00
|
|
|
BOOL (*color_fixup_supported)(struct color_fixup_desc fixup);
|
|
|
|
const struct StateEntryTemplate *states;
|
|
|
|
BOOL ffp_proj_control;
|
|
|
|
};
|
|
|
|
|
2009-09-11 19:01:19 +02:00
|
|
|
extern const struct StateEntryTemplate misc_state_template[] DECLSPEC_HIDDEN;
|
|
|
|
extern const struct StateEntryTemplate ffp_vertexstate_template[] DECLSPEC_HIDDEN;
|
|
|
|
extern const struct fragment_pipeline ffp_fragment_pipeline DECLSPEC_HIDDEN;
|
|
|
|
extern const struct fragment_pipeline atifs_fragment_pipeline DECLSPEC_HIDDEN;
|
|
|
|
extern const struct fragment_pipeline arbfp_fragment_pipeline DECLSPEC_HIDDEN;
|
|
|
|
extern const struct fragment_pipeline nvts_fragment_pipeline DECLSPEC_HIDDEN;
|
|
|
|
extern const struct fragment_pipeline nvrc_fragment_pipeline DECLSPEC_HIDDEN;
|
2009-08-03 08:06:51 +02:00
|
|
|
|
|
|
|
/* "Base" state table */
|
|
|
|
HRESULT compile_state_table(struct StateEntry *StateTable, APPLYSTATEFUNC **dev_multistate_funcs,
|
|
|
|
const struct wined3d_gl_info *gl_info, const struct StateEntryTemplate *vertex,
|
2009-09-11 19:01:19 +02:00
|
|
|
const struct fragment_pipeline *fragment, const struct StateEntryTemplate *misc) DECLSPEC_HIDDEN;
|
2009-08-03 08:06:51 +02:00
|
|
|
|
2010-04-06 22:20:42 +02:00
|
|
|
enum blit_operation
|
|
|
|
{
|
2010-04-12 12:17:09 +02:00
|
|
|
BLIT_OP_BLIT,
|
|
|
|
BLIT_OP_COLOR_FILL
|
2010-04-06 22:20:42 +02:00
|
|
|
};
|
|
|
|
|
2010-09-05 23:38:48 +02:00
|
|
|
/* Shaders for color conversions in blits. Do not do blit operations while
|
|
|
|
* already under the GL lock. */
|
2009-08-03 08:06:51 +02:00
|
|
|
struct blit_shader
|
|
|
|
{
|
2010-12-08 18:28:10 +01:00
|
|
|
HRESULT (*alloc_private)(IWineD3DDeviceImpl *device);
|
2010-12-08 18:28:11 +01:00
|
|
|
void (*free_private)(IWineD3DDeviceImpl *device);
|
2010-12-09 23:41:18 +01:00
|
|
|
HRESULT (*set_shader)(void *blit_priv, const struct wined3d_gl_info *gl_info, IWineD3DSurfaceImpl *surface);
|
2010-12-09 23:41:19 +01:00
|
|
|
void (*unset_shader)(const struct wined3d_gl_info *gl_info);
|
2010-04-06 22:20:42 +02:00
|
|
|
BOOL (*blit_supported)(const struct wined3d_gl_info *gl_info, enum blit_operation blit_op,
|
2010-08-30 20:29:49 +02:00
|
|
|
const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool, const struct wined3d_format *src_format,
|
|
|
|
const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool, const struct wined3d_format *dst_format);
|
2010-08-23 18:28:08 +02:00
|
|
|
HRESULT (*color_fill)(IWineD3DDeviceImpl *device, IWineD3DSurfaceImpl *dst_surface,
|
|
|
|
const RECT *dst_rect, const WINED3DCOLORVALUE *color);
|
2009-08-03 08:06:51 +02:00
|
|
|
};
|
|
|
|
|
2009-09-11 19:01:19 +02:00
|
|
|
extern const struct blit_shader ffp_blit DECLSPEC_HIDDEN;
|
|
|
|
extern const struct blit_shader arbfp_blit DECLSPEC_HIDDEN;
|
2010-03-25 17:01:33 +01:00
|
|
|
extern const struct blit_shader cpu_blit DECLSPEC_HIDDEN;
|
2009-08-03 08:06:51 +02:00
|
|
|
|
2010-08-29 21:57:42 +02:00
|
|
|
const struct blit_shader *wined3d_select_blitter(const struct wined3d_gl_info *gl_info, enum blit_operation blit_op,
|
2010-08-30 20:29:49 +02:00
|
|
|
const RECT *src_rect, DWORD src_usage, WINED3DPOOL src_pool, const struct wined3d_format *src_format,
|
|
|
|
const RECT *dst_rect, DWORD dst_usage, WINED3DPOOL dst_pool, const struct wined3d_format *dst_format)
|
2010-08-29 21:57:42 +02:00
|
|
|
DECLSPEC_HIDDEN;
|
|
|
|
|
2010-04-08 22:49:51 +02:00
|
|
|
/* Temporary blit_shader helper functions */
|
|
|
|
HRESULT arbfp_blit_surface(IWineD3DDeviceImpl *device, IWineD3DSurfaceImpl *src_surface, const RECT *src_rect,
|
|
|
|
IWineD3DSurfaceImpl *dst_surface, const RECT *dst_rect_in, enum blit_operation blit_op,
|
|
|
|
DWORD Filter) DECLSPEC_HIDDEN;
|
|
|
|
|
2010-05-03 22:03:28 +02:00
|
|
|
struct wined3d_context *context_acquire(IWineD3DDeviceImpl *This, IWineD3DSurfaceImpl *target) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
void context_alloc_event_query(struct wined3d_context *context,
|
|
|
|
struct wined3d_event_query *query) DECLSPEC_HIDDEN;
|
|
|
|
void context_alloc_occlusion_query(struct wined3d_context *context,
|
|
|
|
struct wined3d_occlusion_query *query) DECLSPEC_HIDDEN;
|
2010-05-03 22:03:28 +02:00
|
|
|
void context_apply_blit_state(struct wined3d_context *context, IWineD3DDeviceImpl *device) DECLSPEC_HIDDEN;
|
2011-01-26 19:45:02 +01:00
|
|
|
BOOL context_apply_clear_state(struct wined3d_context *context, IWineD3DDeviceImpl *device,
|
2010-07-23 11:31:03 +02:00
|
|
|
UINT rt_count, IWineD3DSurfaceImpl **rts, IWineD3DSurfaceImpl *depth_stencil) DECLSPEC_HIDDEN;
|
2011-01-26 19:45:02 +01:00
|
|
|
BOOL context_apply_draw_state(struct wined3d_context *context, IWineD3DDeviceImpl *device) DECLSPEC_HIDDEN;
|
2010-05-05 18:22:35 +02:00
|
|
|
void context_apply_fbo_state_blit(struct wined3d_context *context, GLenum target,
|
2010-07-26 12:06:32 +02:00
|
|
|
IWineD3DSurfaceImpl *render_target, IWineD3DSurfaceImpl *depth_stencil, DWORD location) DECLSPEC_HIDDEN;
|
2009-08-03 08:06:51 +02:00
|
|
|
void context_attach_depth_stencil_fbo(struct wined3d_context *context,
|
2010-04-15 19:21:26 +02:00
|
|
|
GLenum fbo_target, IWineD3DSurfaceImpl *depth_stencil, BOOL use_render_buffer) DECLSPEC_HIDDEN;
|
2010-05-03 22:03:28 +02:00
|
|
|
void context_bind_fbo(struct wined3d_context *context, GLenum target, GLuint *fbo) DECLSPEC_HIDDEN;
|
2010-03-28 16:25:04 +02:00
|
|
|
struct wined3d_context *context_create(IWineD3DSwapChainImpl *swapchain, IWineD3DSurfaceImpl *target,
|
2010-08-30 20:29:49 +02:00
|
|
|
const struct wined3d_format *ds_format) DECLSPEC_HIDDEN;
|
2009-10-28 11:00:14 +01:00
|
|
|
void context_destroy(IWineD3DDeviceImpl *This, struct wined3d_context *context) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
void context_free_event_query(struct wined3d_event_query *query) DECLSPEC_HIDDEN;
|
|
|
|
void context_free_occlusion_query(struct wined3d_occlusion_query *query) DECLSPEC_HIDDEN;
|
|
|
|
struct wined3d_context *context_get_current(void) DECLSPEC_HIDDEN;
|
|
|
|
DWORD context_get_tls_idx(void) DECLSPEC_HIDDEN;
|
2009-10-28 11:00:11 +01:00
|
|
|
void context_release(struct wined3d_context *context) DECLSPEC_HIDDEN;
|
2011-01-16 23:36:47 +01:00
|
|
|
void context_resource_released(struct IWineD3DDeviceImpl *device,
|
|
|
|
struct IWineD3DResourceImpl *resource, WINED3DRESOURCETYPE type) DECLSPEC_HIDDEN;
|
2011-01-17 18:49:28 +01:00
|
|
|
void context_resource_unloaded(struct IWineD3DDeviceImpl *device,
|
|
|
|
struct IWineD3DResourceImpl *resource, WINED3DRESOURCETYPE type) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
BOOL context_set_current(struct wined3d_context *ctx) DECLSPEC_HIDDEN;
|
2009-12-10 21:41:52 +01:00
|
|
|
void context_set_draw_buffer(struct wined3d_context *context, GLenum buffer) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
void context_set_tls_idx(DWORD idx) DECLSPEC_HIDDEN;
|
2010-03-17 21:59:51 +01:00
|
|
|
void context_surface_update(struct wined3d_context *context, IWineD3DSurfaceImpl *surface) DECLSPEC_HIDDEN;
|
2007-02-12 19:18:36 +01:00
|
|
|
|
2006-08-19 11:58:23 +02:00
|
|
|
/* Macros for doing basic GPU detection based on opengl capabilities */
|
|
|
|
#define WINE_D3D6_CAPABLE(gl_info) (gl_info->supported[ARB_MULTITEXTURE])
|
|
|
|
#define WINE_D3D7_CAPABLE(gl_info) (gl_info->supported[ARB_TEXTURE_COMPRESSION] && gl_info->supported[ARB_TEXTURE_CUBE_MAP] && gl_info->supported[ARB_TEXTURE_ENV_DOT3])
|
|
|
|
#define WINE_D3D8_CAPABLE(gl_info) WINE_D3D7_CAPABLE(gl_info) && (gl_info->supported[ARB_MULTISAMPLE] && gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
|
|
|
|
#define WINE_D3D9_CAPABLE(gl_info) WINE_D3D8_CAPABLE(gl_info) && (gl_info->supported[ARB_FRAGMENT_PROGRAM] && gl_info->supported[ARB_VERTEX_SHADER])
|
2010-04-14 14:19:19 +02:00
|
|
|
#define WINE_D3D10_CAPABLE(gl_info) WINE_D3D9_CAPABLE(gl_info) && (gl_info->supported[EXT_GPU_SHADER4])
|
2006-08-19 11:58:23 +02:00
|
|
|
|
2004-11-29 18:53:42 +01:00
|
|
|
/*****************************************************************************
|
|
|
|
* Internal representation of a light
|
|
|
|
*/
|
2009-10-14 10:55:16 +02:00
|
|
|
struct wined3d_light_info
|
|
|
|
{
|
2004-11-29 18:53:42 +01:00
|
|
|
WINED3DLIGHT OriginalParms; /* Note D3D8LIGHT == D3D9LIGHT */
|
|
|
|
DWORD OriginalIndex;
|
|
|
|
LONG glIndex;
|
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 */
|
2009-09-11 19:01:19 +02:00
|
|
|
extern const WINED3DLIGHT WINED3D_default_light DECLSPEC_HIDDEN;
|
2006-06-07 05:37:05 +02:00
|
|
|
|
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 */
|
2010-03-01 17:32:53 +01:00
|
|
|
int redSize, greenSize, blueSize, alphaSize, colorSize;
|
2007-08-11 16:25:58 +02:00
|
|
|
int depthSize, stencilSize;
|
2008-03-16 17:37:38 +01:00
|
|
|
BOOL windowDrawable;
|
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;
|
|
|
|
|
2010-07-31 03:02:01 +02:00
|
|
|
/* The driver names reflect the lowest GPU supported
|
|
|
|
* by a certain driver, so DRIVER_ATI_R300 supports
|
|
|
|
* R3xx, R4xx and R5xx GPUs. */
|
|
|
|
enum wined3d_display_driver
|
|
|
|
{
|
2010-09-11 03:59:46 +02:00
|
|
|
DRIVER_ATI_RAGE_128PRO,
|
|
|
|
DRIVER_ATI_R100,
|
2010-07-31 03:02:01 +02:00
|
|
|
DRIVER_ATI_R300,
|
|
|
|
DRIVER_ATI_R600,
|
2010-09-09 04:26:22 +02:00
|
|
|
DRIVER_INTEL_GMA800,
|
|
|
|
DRIVER_INTEL_GMA900,
|
|
|
|
DRIVER_INTEL_GMA950,
|
|
|
|
DRIVER_INTEL_GMA3000,
|
2010-07-31 03:02:01 +02:00
|
|
|
DRIVER_NVIDIA_TNT,
|
|
|
|
DRIVER_NVIDIA_GEFORCE2MX,
|
|
|
|
DRIVER_NVIDIA_GEFORCEFX,
|
2010-09-08 00:20:11 +02:00
|
|
|
DRIVER_NVIDIA_GEFORCE6,
|
|
|
|
DRIVER_UNKNOWN
|
2010-07-31 03:02:01 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
enum wined3d_driver_model
|
|
|
|
{
|
|
|
|
DRIVER_MODEL_WIN9X,
|
|
|
|
DRIVER_MODEL_NT40,
|
|
|
|
DRIVER_MODEL_NT5X,
|
|
|
|
DRIVER_MODEL_NT6X
|
|
|
|
};
|
|
|
|
|
2010-03-03 08:16:26 +01:00
|
|
|
enum wined3d_gl_vendor
|
|
|
|
{
|
2010-04-04 19:51:41 +02:00
|
|
|
GL_VENDOR_UNKNOWN,
|
2010-03-03 08:16:26 +01:00
|
|
|
GL_VENDOR_APPLE,
|
2010-04-04 19:51:41 +02:00
|
|
|
GL_VENDOR_FGLRX,
|
2010-03-03 08:16:26 +01:00
|
|
|
GL_VENDOR_INTEL,
|
|
|
|
GL_VENDOR_MESA,
|
|
|
|
GL_VENDOR_NVIDIA,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2009-10-27 10:10:39 +01:00
|
|
|
enum wined3d_pci_vendor
|
|
|
|
{
|
2010-04-04 19:51:40 +02:00
|
|
|
HW_VENDOR_SOFTWARE = 0x0000,
|
2010-03-03 08:16:26 +01:00
|
|
|
HW_VENDOR_ATI = 0x1002,
|
|
|
|
HW_VENDOR_NVIDIA = 0x10de,
|
|
|
|
HW_VENDOR_INTEL = 0x8086,
|
2009-10-27 10:10:39 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
enum wined3d_pci_device
|
|
|
|
{
|
|
|
|
CARD_WINE = 0x0000,
|
|
|
|
|
|
|
|
CARD_ATI_RAGE_128PRO = 0x5246,
|
|
|
|
CARD_ATI_RADEON_7200 = 0x5144,
|
|
|
|
CARD_ATI_RADEON_8500 = 0x514c,
|
|
|
|
CARD_ATI_RADEON_9500 = 0x4144,
|
|
|
|
CARD_ATI_RADEON_XPRESS_200M = 0x5955,
|
|
|
|
CARD_ATI_RADEON_X700 = 0x5e4c,
|
|
|
|
CARD_ATI_RADEON_X1600 = 0x71c2,
|
2010-04-16 08:49:40 +02:00
|
|
|
CARD_ATI_RADEON_HD2350 = 0x94c7,
|
2009-10-27 10:10:39 +01:00
|
|
|
CARD_ATI_RADEON_HD2600 = 0x9581,
|
|
|
|
CARD_ATI_RADEON_HD2900 = 0x9400,
|
|
|
|
CARD_ATI_RADEON_HD3200 = 0x9620,
|
|
|
|
CARD_ATI_RADEON_HD4350 = 0x954f,
|
|
|
|
CARD_ATI_RADEON_HD4550 = 0x9540,
|
|
|
|
CARD_ATI_RADEON_HD4600 = 0x9495,
|
|
|
|
CARD_ATI_RADEON_HD4650 = 0x9498,
|
|
|
|
CARD_ATI_RADEON_HD4670 = 0x9490,
|
|
|
|
CARD_ATI_RADEON_HD4700 = 0x944e,
|
|
|
|
CARD_ATI_RADEON_HD4770 = 0x94b3,
|
|
|
|
CARD_ATI_RADEON_HD4800 = 0x944c, /* Picked one value between 9440, 944c, 9442, 9460 */
|
|
|
|
CARD_ATI_RADEON_HD4830 = 0x944c,
|
|
|
|
CARD_ATI_RADEON_HD4850 = 0x9442,
|
|
|
|
CARD_ATI_RADEON_HD4870 = 0x9440,
|
|
|
|
CARD_ATI_RADEON_HD4890 = 0x9460,
|
2010-11-09 11:38:42 +01:00
|
|
|
CARD_ATI_RADEON_HD5400 = 0x68f9,
|
|
|
|
CARD_ATI_RADEON_HD5600 = 0x68d8,
|
2009-12-28 13:00:48 +01:00
|
|
|
CARD_ATI_RADEON_HD5700 = 0x68BE, /* Picked HD5750 */
|
|
|
|
CARD_ATI_RADEON_HD5750 = 0x68BE,
|
|
|
|
CARD_ATI_RADEON_HD5770 = 0x68B8,
|
|
|
|
CARD_ATI_RADEON_HD5800 = 0x6898, /* Picked HD5850 */
|
|
|
|
CARD_ATI_RADEON_HD5850 = 0x6898,
|
|
|
|
CARD_ATI_RADEON_HD5870 = 0x6899,
|
2010-11-09 11:38:42 +01:00
|
|
|
CARD_ATI_RADEON_HD5900 = 0x689c,
|
2009-10-27 10:10:39 +01:00
|
|
|
|
|
|
|
CARD_NVIDIA_RIVA_128 = 0x0018,
|
|
|
|
CARD_NVIDIA_RIVA_TNT = 0x0020,
|
|
|
|
CARD_NVIDIA_RIVA_TNT2 = 0x0028,
|
|
|
|
CARD_NVIDIA_GEFORCE = 0x0100,
|
|
|
|
CARD_NVIDIA_GEFORCE2_MX = 0x0110,
|
|
|
|
CARD_NVIDIA_GEFORCE2 = 0x0150,
|
|
|
|
CARD_NVIDIA_GEFORCE3 = 0x0200,
|
|
|
|
CARD_NVIDIA_GEFORCE4_MX = 0x0170,
|
|
|
|
CARD_NVIDIA_GEFORCE4_TI4200 = 0x0253,
|
|
|
|
CARD_NVIDIA_GEFORCEFX_5200 = 0x0320,
|
|
|
|
CARD_NVIDIA_GEFORCEFX_5600 = 0x0312,
|
|
|
|
CARD_NVIDIA_GEFORCEFX_5800 = 0x0302,
|
|
|
|
CARD_NVIDIA_GEFORCE_6200 = 0x014f,
|
|
|
|
CARD_NVIDIA_GEFORCE_6600GT = 0x0140,
|
|
|
|
CARD_NVIDIA_GEFORCE_6800 = 0x0041,
|
|
|
|
CARD_NVIDIA_GEFORCE_7400 = 0x01d8,
|
|
|
|
CARD_NVIDIA_GEFORCE_7300 = 0x01d7, /* GeForce Go 7300 */
|
|
|
|
CARD_NVIDIA_GEFORCE_7600 = 0x0391,
|
|
|
|
CARD_NVIDIA_GEFORCE_7800GT = 0x0092,
|
2009-12-30 14:10:25 +01:00
|
|
|
CARD_NVIDIA_GEFORCE_8100 = 0x084F,
|
|
|
|
CARD_NVIDIA_GEFORCE_8200 = 0x0849, /* Other PCI ID 0x084B */
|
2009-10-27 10:10:39 +01:00
|
|
|
CARD_NVIDIA_GEFORCE_8300GS = 0x0423,
|
2009-12-30 14:10:25 +01:00
|
|
|
CARD_NVIDIA_GEFORCE_8400GS = 0x0404,
|
|
|
|
CARD_NVIDIA_GEFORCE_8500GT = 0x0421,
|
2009-10-27 10:10:39 +01:00
|
|
|
CARD_NVIDIA_GEFORCE_8600GT = 0x0402,
|
|
|
|
CARD_NVIDIA_GEFORCE_8600MGT = 0x0407,
|
|
|
|
CARD_NVIDIA_GEFORCE_8800GTS = 0x0193,
|
2010-07-20 19:02:17 +02:00
|
|
|
CARD_NVIDIA_GEFORCE_8800GTX = 0x0191,
|
2009-10-27 10:10:39 +01:00
|
|
|
CARD_NVIDIA_GEFORCE_9200 = 0x086d,
|
|
|
|
CARD_NVIDIA_GEFORCE_9400GT = 0x042c,
|
|
|
|
CARD_NVIDIA_GEFORCE_9500GT = 0x0640,
|
|
|
|
CARD_NVIDIA_GEFORCE_9600GT = 0x0622,
|
|
|
|
CARD_NVIDIA_GEFORCE_9800GT = 0x0614,
|
2010-05-26 21:51:34 +02:00
|
|
|
CARD_NVIDIA_GEFORCE_210 = 0x0a23,
|
|
|
|
CARD_NVIDIA_GEFORCE_GT220 = 0x0a20,
|
|
|
|
CARD_NVIDIA_GEFORCE_GT240 = 0x0ca3,
|
2009-10-27 10:10:39 +01:00
|
|
|
CARD_NVIDIA_GEFORCE_GTX260 = 0x05e2,
|
|
|
|
CARD_NVIDIA_GEFORCE_GTX275 = 0x05e6,
|
|
|
|
CARD_NVIDIA_GEFORCE_GTX280 = 0x05e1,
|
2010-11-24 00:43:45 +01:00
|
|
|
CARD_NVIDIA_GEFORCE_GT320M = 0x0a2d,
|
2010-05-26 21:51:36 +02:00
|
|
|
CARD_NVIDIA_GEFORCE_GT325M = 0x0a35,
|
2010-11-23 00:21:37 +01:00
|
|
|
CARD_NVIDIA_GEFORCE_GT330 = 0x0ca0,
|
2010-05-26 21:51:36 +02:00
|
|
|
CARD_NVIDIA_GEFORCE_GTS350M = 0x0cb0,
|
2010-09-07 17:42:51 +02:00
|
|
|
CARD_NVIDIA_GEFORCE_GTX460 = 0x0e22,
|
2010-09-14 04:42:12 +02:00
|
|
|
CARD_NVIDIA_GEFORCE_GTX465 = 0x06c4,
|
2010-05-26 21:51:33 +02:00
|
|
|
CARD_NVIDIA_GEFORCE_GTX470 = 0x06cd,
|
|
|
|
CARD_NVIDIA_GEFORCE_GTX480 = 0x06c0,
|
2009-10-27 10:10:39 +01:00
|
|
|
|
|
|
|
CARD_INTEL_845G = 0x2562,
|
|
|
|
CARD_INTEL_I830G = 0x3577,
|
|
|
|
CARD_INTEL_I855G = 0x3582,
|
|
|
|
CARD_INTEL_I865G = 0x2572,
|
|
|
|
CARD_INTEL_I915G = 0x2582,
|
|
|
|
CARD_INTEL_I915GM = 0x2592,
|
|
|
|
CARD_INTEL_I945GM = 0x27a2, /* Same as GMA 950? */
|
2010-05-31 16:26:19 +02:00
|
|
|
CARD_INTEL_X3100 = 0x2a02, /* Found in Macs. Same as GM965/GL960 */
|
2010-11-10 06:32:33 +01:00
|
|
|
CARD_INTEL_GM45 = 0x2a42,
|
2009-10-27 10:10:39 +01:00
|
|
|
};
|
|
|
|
|
2010-02-16 09:50:38 +01:00
|
|
|
struct wined3d_fbo_ops
|
|
|
|
{
|
|
|
|
PGLFNGLISRENDERBUFFERPROC glIsRenderbuffer;
|
|
|
|
PGLFNGLBINDRENDERBUFFERPROC glBindRenderbuffer;
|
|
|
|
PGLFNGLDELETERENDERBUFFERSPROC glDeleteRenderbuffers;
|
|
|
|
PGLFNGLGENRENDERBUFFERSPROC glGenRenderbuffers;
|
|
|
|
PGLFNGLRENDERBUFFERSTORAGEPROC glRenderbufferStorage;
|
|
|
|
PGLFNRENDERBUFFERSTORAGEMULTISAMPLEPROC glRenderbufferStorageMultisample;
|
|
|
|
PGLFNGLGETRENDERBUFFERPARAMETERIVPROC glGetRenderbufferParameteriv;
|
|
|
|
PGLFNGLISFRAMEBUFFERPROC glIsFramebuffer;
|
|
|
|
PGLFNGLBINDFRAMEBUFFERPROC glBindFramebuffer;
|
|
|
|
PGLFNGLDELETEFRAMEBUFFERSPROC glDeleteFramebuffers;
|
|
|
|
PGLFNGLGENFRAMEBUFFERSPROC glGenFramebuffers;
|
|
|
|
PGLFNGLCHECKFRAMEBUFFERSTATUSPROC glCheckFramebufferStatus;
|
|
|
|
PGLFNGLFRAMEBUFFERTEXTURE1DPROC glFramebufferTexture1D;
|
|
|
|
PGLFNGLFRAMEBUFFERTEXTURE2DPROC glFramebufferTexture2D;
|
|
|
|
PGLFNGLFRAMEBUFFERTEXTURE3DPROC glFramebufferTexture3D;
|
|
|
|
PGLFNGLFRAMEBUFFERRENDERBUFFERPROC glFramebufferRenderbuffer;
|
|
|
|
PGLFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glGetFramebufferAttachmentParameteriv;
|
|
|
|
PGLFNGLBLITFRAMEBUFFERPROC glBlitFramebuffer;
|
|
|
|
PGLFNGLGENERATEMIPMAPPROC glGenerateMipmap;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct wined3d_gl_limits
|
|
|
|
{
|
|
|
|
UINT buffers;
|
|
|
|
UINT lights;
|
|
|
|
UINT textures;
|
|
|
|
UINT texture_stages;
|
|
|
|
UINT fragment_samplers;
|
|
|
|
UINT vertex_samplers;
|
|
|
|
UINT combined_samplers;
|
|
|
|
UINT general_combiners;
|
|
|
|
UINT sampler_stages;
|
|
|
|
UINT clipplanes;
|
|
|
|
UINT texture_size;
|
|
|
|
UINT texture3d_size;
|
|
|
|
float pointsize_max;
|
|
|
|
float pointsize_min;
|
|
|
|
UINT point_sprite_units;
|
|
|
|
UINT blends;
|
|
|
|
UINT anisotropy;
|
|
|
|
float shininess;
|
|
|
|
|
|
|
|
UINT glsl_varyings;
|
|
|
|
UINT glsl_vs_float_constants;
|
|
|
|
UINT glsl_ps_float_constants;
|
|
|
|
|
|
|
|
UINT arb_vs_float_constants;
|
|
|
|
UINT arb_vs_native_constants;
|
|
|
|
UINT arb_vs_instructions;
|
|
|
|
UINT arb_vs_temps;
|
|
|
|
UINT arb_ps_float_constants;
|
|
|
|
UINT arb_ps_local_constants;
|
|
|
|
UINT arb_ps_native_constants;
|
|
|
|
UINT arb_ps_instructions;
|
|
|
|
UINT arb_ps_temps;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct wined3d_gl_info
|
|
|
|
{
|
2010-04-05 21:10:15 +02:00
|
|
|
DWORD glsl_version;
|
2010-02-16 09:50:38 +01:00
|
|
|
struct wined3d_gl_limits limits;
|
|
|
|
DWORD reserved_glsl_constants;
|
|
|
|
DWORD quirks;
|
|
|
|
BOOL supported[WINED3D_GL_EXT_COUNT];
|
|
|
|
GLint wrap_lookup[WINED3DTADDRESS_MIRRORONCE - WINED3DTADDRESS_WRAP + 1];
|
|
|
|
|
|
|
|
struct wined3d_fbo_ops fbo_ops;
|
|
|
|
#define USE_GL_FUNC(type, pfn, ext, replace) type pfn;
|
|
|
|
/* GL function pointers */
|
|
|
|
GL_EXT_FUNCS_GEN
|
|
|
|
/* WGL function pointers */
|
|
|
|
WGL_EXT_FUNCS_GEN
|
|
|
|
#undef USE_GL_FUNC
|
|
|
|
|
2010-08-30 20:29:49 +02:00
|
|
|
struct wined3d_format *formats;
|
2010-02-16 09:50:38 +01:00
|
|
|
};
|
|
|
|
|
2009-10-26 10:12:16 +01:00
|
|
|
struct wined3d_driver_info
|
|
|
|
{
|
2009-10-27 10:10:39 +01:00
|
|
|
enum wined3d_pci_vendor vendor;
|
|
|
|
enum wined3d_pci_device device;
|
2009-10-26 10:12:16 +01:00
|
|
|
const char *name;
|
|
|
|
const char *description;
|
2010-09-11 03:59:47 +02:00
|
|
|
unsigned int vidmem;
|
2009-10-26 10:12:16 +01:00
|
|
|
DWORD version_high;
|
|
|
|
DWORD version_low;
|
|
|
|
};
|
|
|
|
|
2007-06-09 14:27:41 +02:00
|
|
|
/* The adapter structure */
|
2009-10-21 10:33:58 +02:00
|
|
|
struct wined3d_adapter
|
2007-06-09 14:27:41 +02:00
|
|
|
{
|
2009-12-07 20:20:00 +01:00
|
|
|
UINT ordinal;
|
2008-03-28 23:04:17 +01:00
|
|
|
BOOL opengl;
|
2007-06-09 14:27:41 +02:00
|
|
|
POINT monitorPoint;
|
2009-07-17 10:34:01 +02:00
|
|
|
struct wined3d_gl_info gl_info;
|
2009-10-26 10:12:16 +01:00
|
|
|
struct wined3d_driver_info driver_info;
|
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;
|
2009-12-02 10:41:23 +01:00
|
|
|
LUID luid;
|
2010-02-02 12:06:56 +01:00
|
|
|
|
|
|
|
const struct fragment_pipeline *fragment_pipe;
|
2010-02-02 12:06:57 +01:00
|
|
|
const shader_backend_t *shader_backend;
|
2010-02-03 11:02:20 +01:00
|
|
|
const struct blit_shader *blitter;
|
2007-06-09 14:27:41 +02:00
|
|
|
};
|
|
|
|
|
2009-10-27 10:10:39 +01:00
|
|
|
BOOL initPixelFormats(struct wined3d_gl_info *gl_info, enum wined3d_pci_vendor vendor) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
BOOL initPixelFormatsNoGL(struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
|
2010-05-21 12:45:40 +02:00
|
|
|
extern unsigned int WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl *D3DDevice, unsigned int glram) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
extern void add_gl_compat_wrappers(struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
|
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;
|
|
|
|
};
|
|
|
|
|
2009-09-11 19:01:19 +02:00
|
|
|
HRESULT tesselate_rectpatch(IWineD3DDeviceImpl *This, struct WineD3DRectPatch *patch) DECLSPEC_HIDDEN;
|
2007-07-04 17:57:45 +02:00
|
|
|
|
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-09-11 19:01:19 +02:00
|
|
|
extern const struct wine_rb_functions wined3d_ffp_frag_program_rb_functions DECLSPEC_HIDDEN;
|
2009-09-16 08:37:15 +02:00
|
|
|
extern const struct wined3d_parent_ops wined3d_null_parent_ops DECLSPEC_HIDDEN;
|
2009-06-03 10:47:26 +02:00
|
|
|
|
2011-01-28 20:05:43 +01:00
|
|
|
void gen_ffp_frag_op(struct wined3d_stateblock *stateblock, struct ffp_frag_settings *settings,
|
2009-09-11 19:01:19 +02:00
|
|
|
BOOL ignore_textype) DECLSPEC_HIDDEN;
|
2009-06-03 10:47:26 +02:00
|
|
|
const struct ffp_frag_desc *find_ffp_frag_shader(const struct wine_rb_tree *fragment_shaders,
|
2009-09-11 19:01:19 +02:00
|
|
|
const struct ffp_frag_settings *settings) DECLSPEC_HIDDEN;
|
|
|
|
void add_ffp_frag_shader(struct wine_rb_tree *shaders, struct ffp_frag_desc *desc) DECLSPEC_HIDDEN;
|
2008-03-22 14:31:52 +01:00
|
|
|
|
2011-02-01 19:39:53 +01:00
|
|
|
struct wined3d
|
2004-09-23 06:34:27 +02:00
|
|
|
{
|
2011-02-01 19:39:53 +01:00
|
|
|
LONG ref;
|
2010-08-31 18:41:40 +02:00
|
|
|
void *parent;
|
2011-02-01 19:39:53 +01:00
|
|
|
UINT dxVersion;
|
2009-03-11 10:15:09 +01:00
|
|
|
UINT adapter_count;
|
2009-10-21 10:33:58 +02:00
|
|
|
struct wined3d_adapter adapters[1];
|
2011-02-01 19:39:53 +01:00
|
|
|
};
|
2004-09-23 06:34:27 +02:00
|
|
|
|
2011-02-01 19:39:54 +01:00
|
|
|
HRESULT wined3d_init(struct wined3d *wined3d, UINT version, void *parent) DECLSPEC_HIDDEN;
|
2009-12-22 18:32:13 +01:00
|
|
|
BOOL wined3d_register_window(HWND window, struct IWineD3DDeviceImpl *device) DECLSPEC_HIDDEN;
|
2009-12-14 20:49:52 +01:00
|
|
|
void wined3d_unregister_window(HWND window) DECLSPEC_HIDDEN;
|
2009-03-11 10:15:09 +01: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 */
|
2009-01-16 10:14:24 +01:00
|
|
|
IWineD3DDeviceParent *device_parent;
|
2011-02-01 19:39:54 +01:00
|
|
|
struct wined3d *wined3d;
|
2009-10-21 10:33:58 +02:00
|
|
|
struct wined3d_adapter *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
|
|
|
|
2010-02-04 18:30:06 +01:00
|
|
|
unsigned int max_ffp_textures;
|
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 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;
|
2009-12-22 18:32:13 +01:00
|
|
|
WORD filter_messages : 1;
|
|
|
|
WORD padding : 3;
|
2008-12-30 14:56:49 +01:00
|
|
|
|
|
|
|
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 */
|
2011-01-28 20:05:43 +01:00
|
|
|
struct wined3d_stateblock *stateBlock;
|
|
|
|
struct wined3d_stateblock *updateStateBlock;
|
2004-10-21 22:59:12 +02:00
|
|
|
|
2004-10-08 22:52:33 +02:00
|
|
|
/* Internal use fields */
|
2006-04-03 14:54:16 +02:00
|
|
|
WINED3DDEVICE_CREATION_PARAMETERS createParms;
|
2006-10-11 03:52:00 +02:00
|
|
|
WINED3DDEVTYPE devType;
|
2009-12-22 18:32:13 +01:00
|
|
|
HWND focus_window;
|
2004-10-08 22:52:33 +02:00
|
|
|
|
2011-01-19 19:20:12 +01:00
|
|
|
IWineD3DSwapChainImpl **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 */
|
2010-04-19 20:46:59 +02:00
|
|
|
IWineD3DSurfaceImpl **render_targets;
|
2010-04-19 20:47:00 +02:00
|
|
|
IWineD3DSurfaceImpl *auto_depth_stencil;
|
2010-04-20 22:38:41 +02:00
|
|
|
IWineD3DSurfaceImpl *onscreen_depth_stencil;
|
2010-04-19 20:47:01 +02:00
|
|
|
IWineD3DSurfaceImpl *depth_stencil;
|
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;
|
2005-01-09 18:37:02 +01:00
|
|
|
|
2004-12-09 12:42:34 +01:00
|
|
|
/* For rendering to a texture using glCopyTexImage */
|
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
|
|
|
|
2006-04-18 23:39:52 +02:00
|
|
|
/* DirectDraw stuff */
|
2006-05-18 22:42:22 +02:00
|
|
|
DWORD ddraw_width, ddraw_height;
|
2010-08-23 18:28:10 +02:00
|
|
|
enum wined3d_format_id ddraw_format;
|
2006-04-18 23:39:52 +02: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;
|
2010-03-21 13:26:36 +01:00
|
|
|
struct wined3d_event_query *buffer_queries[MAX_ATTRIBS];
|
|
|
|
unsigned int num_buffer_queries;
|
2007-01-02 00:21:26 +01:00
|
|
|
|
2007-02-12 19:18:22 +01:00
|
|
|
/* Context management */
|
2009-08-03 08:06:51 +02:00
|
|
|
struct wined3d_context **contexts;
|
2007-06-02 22:20:17 +02:00
|
|
|
UINT numContexts;
|
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
|
|
|
|
2010-08-23 18:28:06 +02:00
|
|
|
HRESULT device_clear_render_targets(IWineD3DDeviceImpl *device, UINT rt_count, IWineD3DSurfaceImpl **rts,
|
|
|
|
UINT rect_count, const RECT *rects, const RECT *draw_rect, DWORD flags,
|
|
|
|
const WINED3DCOLORVALUE *color, float depth, DWORD stencil) DECLSPEC_HIDDEN;
|
2010-03-14 21:53:25 +01:00
|
|
|
BOOL device_context_add(IWineD3DDeviceImpl *device, struct wined3d_context *context) DECLSPEC_HIDDEN;
|
|
|
|
void device_context_remove(IWineD3DDeviceImpl *device, struct wined3d_context *context) DECLSPEC_HIDDEN;
|
2010-04-29 00:08:59 +02:00
|
|
|
void device_get_draw_rect(IWineD3DDeviceImpl *device, RECT *rect) DECLSPEC_HIDDEN;
|
2011-02-01 19:39:54 +01:00
|
|
|
HRESULT device_init(IWineD3DDeviceImpl *device, struct wined3d *wined3d,
|
2009-11-18 10:45:53 +01:00
|
|
|
UINT adapter_idx, WINED3DDEVTYPE device_type, HWND focus_window, DWORD flags,
|
2010-08-31 18:41:37 +02:00
|
|
|
IWineD3DDeviceParent *device_parent) DECLSPEC_HIDDEN;
|
2010-02-03 11:02:21 +01:00
|
|
|
void device_preload_textures(IWineD3DDeviceImpl *device) DECLSPEC_HIDDEN;
|
2010-11-02 12:02:47 +01:00
|
|
|
LRESULT device_process_message(IWineD3DDeviceImpl *device, HWND window, BOOL unicode,
|
2009-12-22 18:32:13 +01:00
|
|
|
UINT message, WPARAM wparam, LPARAM lparam, WNDPROC proc) DECLSPEC_HIDDEN;
|
2011-01-16 23:36:45 +01:00
|
|
|
void device_resource_add(struct IWineD3DDeviceImpl *device, struct IWineD3DResourceImpl *resource) DECLSPEC_HIDDEN;
|
2011-01-16 23:36:46 +01:00
|
|
|
void device_resource_released(struct IWineD3DDeviceImpl *device, struct IWineD3DResourceImpl *resource) DECLSPEC_HIDDEN;
|
2009-03-27 10:25:55 +01:00
|
|
|
void device_stream_info_from_declaration(IWineD3DDeviceImpl *This,
|
2009-09-11 19:01:19 +02:00
|
|
|
BOOL use_vshader, struct wined3d_stream_info *stream_info, BOOL *fixup) DECLSPEC_HIDDEN;
|
2010-04-20 22:38:41 +02:00
|
|
|
void device_switch_onscreen_ds(IWineD3DDeviceImpl *device, struct wined3d_context *context,
|
|
|
|
IWineD3DSurfaceImpl *depth_stencil) DECLSPEC_HIDDEN;
|
2010-02-03 11:02:22 +01:00
|
|
|
void device_update_stream_info(IWineD3DDeviceImpl *device, const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
void IWineD3DDeviceImpl_FindTexUnitMap(IWineD3DDeviceImpl *This) DECLSPEC_HIDDEN;
|
|
|
|
void IWineD3DDeviceImpl_MarkStateDirty(IWineD3DDeviceImpl *This, DWORD state) DECLSPEC_HIDDEN;
|
2009-12-10 21:41:54 +01:00
|
|
|
|
2009-08-03 08:06:51 +02:00
|
|
|
static inline BOOL isStateDirty(struct wined3d_context *context, DWORD state)
|
|
|
|
{
|
2009-12-29 17:10:22 +01:00
|
|
|
DWORD idx = state / (sizeof(*context->isStateDirty) * CHAR_BIT);
|
|
|
|
BYTE shift = state & ((sizeof(*context->isStateDirty) * CHAR_BIT) - 1);
|
2007-02-12 19:18:31 +01:00
|
|
|
return context->isStateDirty[idx] & (1 << shift);
|
2006-12-19 13:00:03 +01:00
|
|
|
}
|
|
|
|
|
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 */
|
2006-03-09 23:21:16 +01:00
|
|
|
WINED3DRESOURCETYPE resourceType;
|
2009-12-09 20:32:08 +01:00
|
|
|
IWineD3DDeviceImpl *device;
|
2006-03-28 14:20:47 +02:00
|
|
|
WINED3DPOOL pool;
|
2005-03-29 21:01:00 +02:00
|
|
|
UINT size;
|
|
|
|
DWORD usage;
|
2010-08-30 20:29:49 +02:00
|
|
|
const struct wined3d_format *format;
|
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;
|
2010-08-31 18:41:40 +02:00
|
|
|
|
|
|
|
void *parent;
|
2009-09-17 23:03:33 +02:00
|
|
|
const struct wined3d_parent_ops *parent_ops;
|
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;
|
|
|
|
|
2011-01-06 09:39:00 +01:00
|
|
|
void resource_cleanup(struct IWineD3DResourceImpl *resource) DECLSPEC_HIDDEN;
|
2011-01-06 09:39:01 +01:00
|
|
|
HRESULT resource_free_private_data(struct IWineD3DResourceImpl *resource, REFGUID guid) DECLSPEC_HIDDEN;
|
2011-01-07 10:16:39 +01:00
|
|
|
DWORD resource_get_priority(struct IWineD3DResourceImpl *resource) DECLSPEC_HIDDEN;
|
2011-01-06 09:39:02 +01:00
|
|
|
HRESULT resource_get_private_data(struct IWineD3DResourceImpl *resource, REFGUID guid,
|
2009-09-11 19:01:19 +02:00
|
|
|
void *data, DWORD *data_size) DECLSPEC_HIDDEN;
|
2011-01-06 09:38:59 +01:00
|
|
|
HRESULT resource_init(struct IWineD3DResourceImpl *resource, WINED3DRESOURCETYPE resource_type,
|
2010-08-30 20:29:49 +02:00
|
|
|
IWineD3DDeviceImpl *device, UINT size, DWORD usage, const struct wined3d_format *format,
|
2010-08-31 18:41:40 +02:00
|
|
|
WINED3DPOOL pool, void *parent, const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
|
2011-01-07 10:16:41 +01:00
|
|
|
WINED3DRESOURCETYPE resource_get_type(struct IWineD3DResourceImpl *resource) DECLSPEC_HIDDEN;
|
2011-01-07 10:16:40 +01:00
|
|
|
DWORD resource_set_priority(struct IWineD3DResourceImpl *resource, DWORD priority) DECLSPEC_HIDDEN;
|
2011-01-07 10:16:38 +01:00
|
|
|
HRESULT resource_set_private_data(struct IWineD3DResourceImpl *resource, REFGUID guid,
|
2009-09-11 19:01:19 +02:00
|
|
|
const void *data, DWORD data_size, DWORD flags) DECLSPEC_HIDDEN;
|
2010-08-15 23:21:42 +02:00
|
|
|
void resource_unload(IWineD3DResourceImpl *resource) DECLSPEC_HIDDEN;
|
2008-12-02 18:41:33 +01:00
|
|
|
|
2007-10-22 13:30:14 +02:00
|
|
|
/* Tests show that the start address of resources is 32 byte aligned */
|
2010-03-11 15:41:31 +01:00
|
|
|
#define RESOURCE_ALIGNMENT 16
|
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,
|
2010-05-17 11:14:48 +02:00
|
|
|
WINED3DTEXSTA_SHADOW = 10,
|
|
|
|
MAX_WINETEXTURESTATES = 11,
|
2005-08-03 13:00:28 +02:00
|
|
|
} 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 */
|
|
|
|
};
|
|
|
|
|
2009-09-19 14:59:27 +02:00
|
|
|
struct gl_texture
|
|
|
|
{
|
|
|
|
DWORD states[MAX_WINETEXTURESTATES];
|
|
|
|
BOOL dirty;
|
|
|
|
GLuint name;
|
|
|
|
};
|
|
|
|
|
2011-01-04 17:42:03 +01:00
|
|
|
struct wined3d_texture_ops
|
|
|
|
{
|
|
|
|
HRESULT (*texture_bind)(struct IWineD3DBaseTextureImpl *texture, BOOL srgb);
|
|
|
|
void (*texture_preload)(struct IWineD3DBaseTextureImpl *texture, enum WINED3DSRGB srgb);
|
|
|
|
};
|
|
|
|
|
2004-12-07 15:29:12 +01:00
|
|
|
/*****************************************************************************
|
|
|
|
* IWineD3DBaseTexture implementation structure (extends IWineD3DResourceImpl)
|
|
|
|
*/
|
|
|
|
typedef struct IWineD3DBaseTextureClass
|
|
|
|
{
|
2011-01-04 17:42:03 +01:00
|
|
|
const struct wined3d_texture_ops *texture_ops;
|
2009-09-19 14:59:27 +02:00
|
|
|
struct gl_texture texture_rgb, texture_srgb;
|
2010-04-22 18:55:57 +02:00
|
|
|
IWineD3DResourceImpl **sub_resources;
|
|
|
|
UINT layer_count;
|
|
|
|
UINT level_count;
|
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;
|
2010-09-17 11:59:38 +02:00
|
|
|
GLenum target;
|
2004-12-07 15:29:12 +01:00
|
|
|
} IWineD3DBaseTextureClass;
|
|
|
|
|
|
|
|
typedef struct IWineD3DBaseTextureImpl
|
|
|
|
{
|
|
|
|
/* IUnknown & WineD3DResource Information */
|
2005-06-06 21:50:35 +02:00
|
|
|
const IWineD3DBaseTextureVtbl *lpVtbl;
|
2004-12-07 15:29:12 +01:00
|
|
|
IWineD3DResourceClass resource;
|
|
|
|
IWineD3DBaseTextureClass baseTexture;
|
|
|
|
|
|
|
|
} IWineD3DBaseTextureImpl;
|
|
|
|
|
2011-01-03 18:51:40 +01:00
|
|
|
void basetexture_apply_state_changes(IWineD3DBaseTextureImpl *texture,
|
2010-01-03 21:18:22 +01:00
|
|
|
const DWORD samplerStates[WINED3D_HIGHEST_SAMPLER_STATE + 1],
|
|
|
|
const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
|
2011-01-03 18:51:39 +01:00
|
|
|
HRESULT basetexture_bind(IWineD3DBaseTextureImpl *texture, BOOL srgb, BOOL *set_surface_desc) DECLSPEC_HIDDEN;
|
2010-12-15 21:06:25 +01:00
|
|
|
void basetexture_cleanup(IWineD3DBaseTextureImpl *texture) DECLSPEC_HIDDEN;
|
2011-01-03 18:51:38 +01:00
|
|
|
void basetexture_generate_mipmaps(IWineD3DBaseTextureImpl *texture) DECLSPEC_HIDDEN;
|
2011-01-02 12:26:38 +01:00
|
|
|
WINED3DTEXTUREFILTERTYPE basetexture_get_autogen_filter_type(IWineD3DBaseTextureImpl *texture) DECLSPEC_HIDDEN;
|
2010-12-15 21:06:26 +01:00
|
|
|
DWORD basetexture_get_level_count(IWineD3DBaseTextureImpl *texture) DECLSPEC_HIDDEN;
|
2011-01-02 12:26:36 +01:00
|
|
|
DWORD basetexture_get_lod(IWineD3DBaseTextureImpl *texture) DECLSPEC_HIDDEN;
|
2010-04-22 18:55:59 +02:00
|
|
|
IWineD3DResourceImpl *basetexture_get_sub_resource(IWineD3DBaseTextureImpl *texture,
|
2010-10-25 12:33:39 +02:00
|
|
|
UINT sub_resource_idx) DECLSPEC_HIDDEN;
|
2011-01-04 17:42:03 +01:00
|
|
|
HRESULT basetexture_init(IWineD3DBaseTextureImpl *texture, const struct wined3d_texture_ops *texture_ops,
|
|
|
|
UINT layer_count, UINT level_count, WINED3DRESOURCETYPE resource_type, IWineD3DDeviceImpl *device,
|
|
|
|
DWORD usage, const struct wined3d_format *format, WINED3DPOOL pool, void *parent,
|
2010-04-22 18:55:57 +02:00
|
|
|
const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
|
2011-01-02 12:26:37 +01:00
|
|
|
HRESULT basetexture_set_autogen_filter_type(IWineD3DBaseTextureImpl *texture,
|
2009-09-11 19:01:19 +02:00
|
|
|
WINED3DTEXTUREFILTERTYPE filter_type) DECLSPEC_HIDDEN;
|
2010-12-08 18:28:09 +01:00
|
|
|
BOOL basetexture_set_dirty(IWineD3DBaseTextureImpl *texture, BOOL dirty) DECLSPEC_HIDDEN;
|
2011-01-02 12:26:35 +01:00
|
|
|
DWORD basetexture_set_lod(IWineD3DBaseTextureImpl *texture, DWORD lod) DECLSPEC_HIDDEN;
|
2010-12-15 21:06:24 +01:00
|
|
|
void basetexture_unload(IWineD3DBaseTextureImpl *texture) DECLSPEC_HIDDEN;
|
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 */
|
2008-07-09 01:59:10 +02:00
|
|
|
BOOL cond_np2;
|
2005-01-17 14:44:57 +01:00
|
|
|
|
|
|
|
} IWineD3DTextureImpl;
|
|
|
|
|
2009-09-17 23:03:25 +02:00
|
|
|
HRESULT texture_init(IWineD3DTextureImpl *texture, UINT width, UINT height, UINT levels,
|
2010-08-23 18:28:10 +02:00
|
|
|
IWineD3DDeviceImpl *device, DWORD usage, enum wined3d_format_id format_id, WINED3DPOOL pool,
|
2010-08-31 18:41:40 +02:00
|
|
|
void *parent, const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
|
2009-06-03 10:47:25 +02:00
|
|
|
|
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;
|
|
|
|
} IWineD3DCubeTextureImpl;
|
|
|
|
|
2009-09-17 12:35:25 +02:00
|
|
|
HRESULT cubetexture_init(IWineD3DCubeTextureImpl *texture, UINT edge_length, UINT levels,
|
2010-08-23 18:28:10 +02:00
|
|
|
IWineD3DDeviceImpl *device, DWORD usage, enum wined3d_format_id format_id, WINED3DPOOL pool,
|
2010-08-31 18:41:40 +02:00
|
|
|
void *parent, const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
|
2009-06-03 10:47:26 +02:00
|
|
|
|
2006-05-10 19:55:02 +02:00
|
|
|
typedef struct _WINED3DVOLUMET_DESC
|
|
|
|
{
|
|
|
|
UINT Width;
|
|
|
|
UINT Height;
|
|
|
|
UINT Depth;
|
|
|
|
} WINED3DVOLUMET_DESC;
|
|
|
|
|
2005-01-17 14:44:57 +01:00
|
|
|
/*****************************************************************************
|
|
|
|
* IWineD3DVolume implementation structure (extends IUnknown)
|
|
|
|
*/
|
|
|
|
typedef struct IWineD3DVolumeImpl
|
|
|
|
{
|
2005-03-29 21:01:00 +02:00
|
|
|
/* IUnknown & WineD3DResource fields */
|
2005-06-06 21:50:35 +02:00
|
|
|
const IWineD3DVolumeVtbl *lpVtbl;
|
2005-03-29 21:01:00 +02:00
|
|
|
IWineD3DResourceClass resource;
|
2005-01-17 14:44:57 +01:00
|
|
|
|
|
|
|
/* WineD3DVolume Information */
|
2006-05-10 19:55:02 +02:00
|
|
|
WINED3DVOLUMET_DESC currentDesc;
|
2010-08-16 20:00:24 +02:00
|
|
|
struct IWineD3DVolumeTextureImpl *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;
|
|
|
|
|
2011-01-18 17:55:19 +01:00
|
|
|
void volume_add_dirty_box(struct IWineD3DVolumeImpl *volume, const WINED3DBOX *dirty_box) DECLSPEC_HIDDEN;
|
2009-09-16 08:37:19 +02:00
|
|
|
HRESULT volume_init(IWineD3DVolumeImpl *volume, IWineD3DDeviceImpl *device, UINT width,
|
2010-08-23 18:28:10 +02:00
|
|
|
UINT height, UINT depth, DWORD usage, enum wined3d_format_id format_id, WINED3DPOOL pool,
|
2010-08-31 18:41:40 +02:00
|
|
|
void *parent, const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
|
2011-01-20 19:52:01 +01:00
|
|
|
void volume_load(IWineD3DVolumeImpl *volume, UINT level, BOOL srgb_mode) DECLSPEC_HIDDEN;
|
2010-08-16 20:00:24 +02:00
|
|
|
void volume_set_container(IWineD3DVolumeImpl *volume, struct IWineD3DVolumeTextureImpl *container) DECLSPEC_HIDDEN;
|
2009-01-14 10:01:10 +01:00
|
|
|
|
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;
|
|
|
|
} IWineD3DVolumeTextureImpl;
|
|
|
|
|
2009-09-11 19:01:19 +02:00
|
|
|
HRESULT volumetexture_init(IWineD3DVolumeTextureImpl *texture, UINT width, UINT height,
|
2010-08-23 18:28:10 +02:00
|
|
|
UINT depth, UINT levels, IWineD3DDeviceImpl *device, DWORD usage, enum wined3d_format_id format_id,
|
2010-08-31 18:41:40 +02:00
|
|
|
WINED3DPOOL pool, void *parent, const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
|
2009-06-03 10:47:26 +02:00
|
|
|
|
2005-03-02 13:16:10 +01:00
|
|
|
typedef struct _WINED3DSURFACET_DESC
|
|
|
|
{
|
2006-03-24 17:34:26 +01:00
|
|
|
WINED3DMULTISAMPLE_TYPE MultiSampleType;
|
|
|
|
DWORD MultiSampleQuality;
|
|
|
|
UINT Width;
|
|
|
|
UINT Height;
|
2005-03-02 13:16:10 +01:00
|
|
|
} WINED3DSURFACET_DESC;
|
|
|
|
|
2006-05-06 18:08:33 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
* Structure for DIB Surfaces (GetDC and GDI surfaces)
|
|
|
|
*/
|
|
|
|
typedef struct wineD3DSurface_DIB {
|
|
|
|
HBITMAP DIBsection;
|
|
|
|
void* bitmap_data;
|
2007-09-11 10:31:54 +02:00
|
|
|
UINT bitmap_size;
|
2006-05-06 18:08:33 +02:00
|
|
|
HGDIOBJ holdbitmap;
|
|
|
|
BOOL client_memory;
|
|
|
|
} wineD3DSurface_DIB;
|
|
|
|
|
2007-04-09 01:53:32 +02:00
|
|
|
typedef struct {
|
|
|
|
struct list entry;
|
|
|
|
GLuint id;
|
|
|
|
UINT width;
|
|
|
|
UINT height;
|
|
|
|
} renderbuffer_entry_t;
|
|
|
|
|
2008-09-18 14:57:53 +02:00
|
|
|
struct fbo_entry
|
|
|
|
{
|
|
|
|
struct list entry;
|
2010-04-15 19:21:27 +02:00
|
|
|
IWineD3DSurfaceImpl **render_targets;
|
2010-04-15 19:21:28 +02:00
|
|
|
IWineD3DSurfaceImpl *depth_stencil;
|
2010-07-26 12:06:32 +02:00
|
|
|
DWORD location;
|
2008-09-18 14:57:53 +02:00
|
|
|
BOOL attached;
|
|
|
|
GLuint id;
|
|
|
|
};
|
|
|
|
|
2011-02-03 20:14:03 +01:00
|
|
|
struct wined3d_clipper
|
2007-04-28 17:59:37 +02:00
|
|
|
{
|
|
|
|
LONG ref;
|
|
|
|
|
|
|
|
HWND hWnd;
|
2011-02-03 20:14:03 +01:00
|
|
|
};
|
2007-04-28 17:59:37 +02:00
|
|
|
|
2010-08-16 20:00:25 +02:00
|
|
|
enum wined3d_container_type
|
|
|
|
{
|
|
|
|
WINED3D_CONTAINER_NONE = 0,
|
|
|
|
WINED3D_CONTAINER_SWAPCHAIN,
|
|
|
|
WINED3D_CONTAINER_TEXTURE,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct wined3d_subresource_container
|
|
|
|
{
|
|
|
|
enum wined3d_container_type type;
|
|
|
|
union
|
|
|
|
{
|
|
|
|
struct IWineD3DBase *base;
|
|
|
|
struct IWineD3DSwapChainImpl *swapchain;
|
|
|
|
struct IWineD3DBaseTextureImpl *texture;
|
|
|
|
} u;
|
|
|
|
};
|
2007-04-28 17:59:37 +02:00
|
|
|
|
2011-01-24 11:19:37 +01:00
|
|
|
struct wined3d_surface_ops
|
|
|
|
{
|
|
|
|
void (*surface_realize_palette)(struct IWineD3DSurfaceImpl *surface);
|
2011-01-24 11:19:38 +01:00
|
|
|
HRESULT (*surface_draw_overlay)(struct IWineD3DSurfaceImpl *surface);
|
2011-01-24 11:19:37 +01:00
|
|
|
};
|
|
|
|
|
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 */
|
2011-01-24 11:19:37 +01:00
|
|
|
const struct wined3d_surface_ops *surface_ops;
|
2010-08-16 20:00:25 +02:00
|
|
|
struct wined3d_subresource_container container;
|
2005-03-02 13:16:10 +01:00
|
|
|
WINED3DSURFACET_DESC currentDesc;
|
2011-02-02 20:22:53 +01:00
|
|
|
struct wined3d_palette *palette; /* D3D7 style palette handling */
|
2007-02-19 15:23:36 +01:00
|
|
|
PALETTEENTRY *palette9; /* D3D8/9 style palette handling */
|
2005-01-09 18:37:02 +01:00
|
|
|
|
2010-11-12 13:12:04 +01: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 */
|
2009-08-03 08:06:51 +02:00
|
|
|
void (*get_drawable_size)(struct wined3d_context *context, UINT *width, UINT *height);
|
2007-11-30 20:22:33 +01:00
|
|
|
|
2007-09-11 10:31:54 +02:00
|
|
|
/* PBO */
|
|
|
|
GLuint pbo;
|
2009-07-10 10:20:13 +02:00
|
|
|
GLuint texture_name;
|
|
|
|
GLuint texture_name_srgb;
|
|
|
|
GLint texture_level;
|
|
|
|
GLenum texture_target;
|
2007-09-11 10:31:54 +02:00
|
|
|
|
2005-01-09 18:37:02 +01:00
|
|
|
RECT lockedRect;
|
|
|
|
RECT dirtyRect;
|
2007-01-12 18:57:26 +01:00
|
|
|
int lockCount;
|
|
|
|
#define MAXLOCKCOUNT 50 /* After this amount of locks do not free the sysmem copy */
|
2005-07-11 22:38:27 +02:00
|
|
|
|
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;
|
2010-04-29 00:08:59 +02:00
|
|
|
SIZE ds_current_size;
|
2007-04-28 17:59:37 +02:00
|
|
|
|
|
|
|
/* DirectDraw clippers */
|
2011-02-03 20:14:03 +01:00
|
|
|
struct wined3d_clipper *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
|
|
|
};
|
|
|
|
|
2009-09-11 19:01:19 +02:00
|
|
|
extern const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl DECLSPEC_HIDDEN;
|
|
|
|
extern const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl DECLSPEC_HIDDEN;
|
2006-05-13 22:22:16 +02:00
|
|
|
|
2010-07-19 18:36:21 +02:00
|
|
|
void surface_add_dirty_rect(IWineD3DSurfaceImpl *surface, const RECT *dirty_rect) DECLSPEC_HIDDEN;
|
2011-01-20 19:51:58 +01:00
|
|
|
void surface_bind(IWineD3DSurfaceImpl *surface, BOOL srgb) DECLSPEC_HIDDEN;
|
2010-08-29 21:57:43 +02:00
|
|
|
HRESULT surface_color_fill(IWineD3DSurfaceImpl *s, const RECT *rect, const WINED3DCOLORVALUE *color) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
void surface_gdi_cleanup(IWineD3DSurfaceImpl *This) DECLSPEC_HIDDEN;
|
2010-07-19 18:36:21 +02:00
|
|
|
GLenum surface_get_gl_buffer(IWineD3DSurfaceImpl *surface) DECLSPEC_HIDDEN;
|
2009-06-15 09:06:49 +02:00
|
|
|
HRESULT surface_init(IWineD3DSurfaceImpl *surface, WINED3DSURFTYPE surface_type, UINT alignment,
|
|
|
|
UINT width, UINT height, UINT level, BOOL lockable, BOOL discard, WINED3DMULTISAMPLE_TYPE multisample_type,
|
2010-08-23 18:28:10 +02:00
|
|
|
UINT multisample_quality, IWineD3DDeviceImpl *device, DWORD usage, enum wined3d_format_id format_id,
|
2010-08-31 18:41:40 +02:00
|
|
|
WINED3DPOOL pool, void *parent, const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
|
2010-07-19 18:36:21 +02:00
|
|
|
BOOL surface_init_sysmem(IWineD3DSurfaceImpl *surface) DECLSPEC_HIDDEN;
|
|
|
|
void surface_internal_preload(IWineD3DSurfaceImpl *surface, enum WINED3DSRGB srgb) DECLSPEC_HIDDEN;
|
|
|
|
BOOL surface_is_offscreen(IWineD3DSurfaceImpl *iface) DECLSPEC_HIDDEN;
|
2011-01-20 19:51:59 +01:00
|
|
|
HRESULT surface_load(IWineD3DSurfaceImpl *surface, BOOL srgb) DECLSPEC_HIDDEN;
|
2010-07-19 18:36:21 +02:00
|
|
|
void surface_load_ds_location(IWineD3DSurfaceImpl *surface,
|
|
|
|
struct wined3d_context *context, DWORD location) DECLSPEC_HIDDEN;
|
2010-07-21 18:48:22 +02:00
|
|
|
HRESULT surface_load_location(IWineD3DSurfaceImpl *surface, DWORD flag, const RECT *rect) DECLSPEC_HIDDEN;
|
2010-07-19 18:36:21 +02:00
|
|
|
void surface_modify_ds_location(IWineD3DSurfaceImpl *surface, DWORD location, UINT w, UINT h) DECLSPEC_HIDDEN;
|
2010-07-21 18:48:21 +02:00
|
|
|
void surface_modify_location(IWineD3DSurfaceImpl *surface, DWORD flag, BOOL persistent) DECLSPEC_HIDDEN;
|
2010-07-19 18:36:21 +02:00
|
|
|
void surface_prepare_texture(IWineD3DSurfaceImpl *surface,
|
|
|
|
const struct wined3d_gl_info *gl_info, BOOL srgb) DECLSPEC_HIDDEN;
|
|
|
|
void surface_set_compatible_renderbuffer(IWineD3DSurfaceImpl *surface,
|
|
|
|
unsigned int width, unsigned int height) DECLSPEC_HIDDEN;
|
2010-08-16 20:00:25 +02:00
|
|
|
void surface_set_container(IWineD3DSurfaceImpl *surface,
|
|
|
|
enum wined3d_container_type type, IWineD3DBase *container) DECLSPEC_HIDDEN;
|
2010-07-19 18:36:21 +02:00
|
|
|
void surface_set_texture_name(IWineD3DSurfaceImpl *surface, GLuint name, BOOL srgb_name) DECLSPEC_HIDDEN;
|
|
|
|
void surface_set_texture_target(IWineD3DSurfaceImpl *surface, GLenum target) DECLSPEC_HIDDEN;
|
2010-11-01 11:57:57 +01:00
|
|
|
void surface_translate_drawable_coords(IWineD3DSurfaceImpl *surface, HWND window, RECT *rect) DECLSPEC_HIDDEN;
|
2009-06-15 09:06:49 +02:00
|
|
|
|
2006-05-13 22:22:16 +02:00
|
|
|
/* Predeclare the shared Surface functions */
|
2009-09-11 19:01:19 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_QueryInterface(IWineD3DSurface *iface,
|
|
|
|
REFIID riid, LPVOID *ppobj) DECLSPEC_HIDDEN;
|
|
|
|
ULONG WINAPI IWineD3DBaseSurfaceImpl_AddRef(IWineD3DSurface *iface) DECLSPEC_HIDDEN;
|
2010-08-31 18:41:40 +02:00
|
|
|
void * WINAPI IWineD3DBaseSurfaceImpl_GetParent(IWineD3DSurface *iface) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetPrivateData(IWineD3DSurface *iface,
|
2010-11-18 20:50:40 +01:00
|
|
|
REFGUID refguid, const void *pData, DWORD SizeOfData, DWORD flags) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetPrivateData(IWineD3DSurface *iface,
|
|
|
|
REFGUID refguid, void *pData, DWORD *pSizeOfData) DECLSPEC_HIDDEN;
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_FreePrivateData(IWineD3DSurface *iface, REFGUID refguid) DECLSPEC_HIDDEN;
|
|
|
|
DWORD WINAPI IWineD3DBaseSurfaceImpl_SetPriority(IWineD3DSurface *iface, DWORD PriorityNew) DECLSPEC_HIDDEN;
|
|
|
|
DWORD WINAPI IWineD3DBaseSurfaceImpl_GetPriority(IWineD3DSurface *iface) DECLSPEC_HIDDEN;
|
|
|
|
WINED3DRESOURCETYPE WINAPI IWineD3DBaseSurfaceImpl_GetType(IWineD3DSurface *iface) DECLSPEC_HIDDEN;
|
2010-09-08 11:24:47 +02:00
|
|
|
void WINAPI IWineD3DBaseSurfaceImpl_GetDesc(IWineD3DSurface *iface, WINED3DSURFACE_DESC *desc) DECLSPEC_HIDDEN;
|
2010-11-18 20:50:40 +01:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetBltStatus(IWineD3DSurface *iface, DWORD flags) DECLSPEC_HIDDEN;
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetFlipStatus(IWineD3DSurface *iface, DWORD flags) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_IsLost(IWineD3DSurface *iface) DECLSPEC_HIDDEN;
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_Restore(IWineD3DSurface *iface) DECLSPEC_HIDDEN;
|
2011-02-02 20:22:53 +01:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetPalette(IWineD3DSurface *iface,
|
|
|
|
struct wined3d_palette **Pal) DECLSPEC_HIDDEN;
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetPalette(IWineD3DSurface *iface,
|
|
|
|
struct wined3d_palette *Pal) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetColorKey(IWineD3DSurface *iface,
|
2010-11-18 20:50:40 +01:00
|
|
|
DWORD flags, const WINEDDCOLORKEY *CKey) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
DWORD WINAPI IWineD3DBaseSurfaceImpl_GetPitch(IWineD3DSurface *iface) DECLSPEC_HIDDEN;
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetOverlayPosition(IWineD3DSurface *iface, LONG X, LONG Y) DECLSPEC_HIDDEN;
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetOverlayPosition(IWineD3DSurface *iface, LONG *X, LONG *Y) DECLSPEC_HIDDEN;
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_UpdateOverlayZOrder(IWineD3DSurface *iface,
|
2010-11-18 20:50:40 +01:00
|
|
|
DWORD flags, IWineD3DSurface *Ref) DECLSPEC_HIDDEN;
|
2008-11-25 11:57:39 +01:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_UpdateOverlay(IWineD3DSurface *iface, const RECT *SrcRect,
|
2010-11-18 20:50:40 +01:00
|
|
|
IWineD3DSurface *DstSurface, const RECT *DstRect, DWORD flags, const WINEDDOVERLAYFX *FX) DECLSPEC_HIDDEN;
|
2011-02-03 20:14:04 +01:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetClipper(IWineD3DSurface *iface,
|
|
|
|
struct wined3d_clipper *clipper) DECLSPEC_HIDDEN;
|
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_GetClipper(IWineD3DSurface *iface,
|
|
|
|
struct wined3d_clipper **clipper) DECLSPEC_HIDDEN;
|
2010-08-23 18:28:10 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_SetFormat(IWineD3DSurface *iface,
|
|
|
|
enum wined3d_format_id format_id) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
HRESULT IWineD3DBaseSurfaceImpl_CreateDIBSection(IWineD3DSurface *iface) DECLSPEC_HIDDEN;
|
2010-08-15 23:21:43 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_Blt(IWineD3DSurface *iface, const RECT *dst_rect, IWineD3DSurface *src_surface,
|
|
|
|
const RECT *src_rect, DWORD flags, const WINEDDBLTFX *fx, WINED3DTEXTUREFILTERTYPE filter) DECLSPEC_HIDDEN;
|
2008-11-25 11:57:39 +01:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_BltFast(IWineD3DSurface *iface, DWORD dstx, DWORD dsty,
|
2009-09-11 19:01:19 +02:00
|
|
|
IWineD3DSurface *Source, const RECT *rsrc, DWORD trans) DECLSPEC_HIDDEN;
|
2010-10-14 13:04:02 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSurfaceImpl_Map(IWineD3DSurface *iface, WINED3DLOCKED_RECT *pLockedRect,
|
2010-11-18 20:50:40 +01:00
|
|
|
const RECT *pRect, DWORD flags) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
const void *WINAPI IWineD3DBaseSurfaceImpl_GetData(IWineD3DSurface *iface) DECLSPEC_HIDDEN;
|
2007-09-16 16:33:23 +02:00
|
|
|
|
2009-09-11 19:01:19 +02:00
|
|
|
void get_drawable_size_swapchain(struct wined3d_context *context, UINT *width, UINT *height) DECLSPEC_HIDDEN;
|
|
|
|
void get_drawable_size_backbuffer(struct wined3d_context *context, UINT *width, UINT *height) DECLSPEC_HIDDEN;
|
|
|
|
void get_drawable_size_fbo(struct wined3d_context *context, UINT *width, UINT *height) DECLSPEC_HIDDEN;
|
2007-11-30 20:22:33 +01:00
|
|
|
|
2010-04-08 22:49:51 +02:00
|
|
|
void draw_textured_quad(IWineD3DSurfaceImpl *src_surface, const RECT *src_rect,
|
|
|
|
const RECT *dst_rect, WINED3DTEXTUREFILTERTYPE Filter) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
void flip_surface(IWineD3DSurfaceImpl *front, IWineD3DSurfaceImpl *back) DECLSPEC_HIDDEN;
|
2008-07-24 18:38:51 +02:00
|
|
|
|
2006-05-06 16:15:37 +02:00
|
|
|
/* Surface flags: */
|
2008-07-02 23:00:41 +02:00
|
|
|
#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 */
|
2006-05-06 16:15:37 +02:00
|
|
|
|
|
|
|
/* In some conditions the surface memory must not be freed:
|
|
|
|
* 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
|
|
|
*/
|
2010-03-11 15:03:50 +01:00
|
|
|
#define SFLAG_DONOTFREE (SFLAG_CONVERTED | \
|
2008-07-02 23:00:41 +02:00
|
|
|
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
|
|
|
|
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_RGB24,
|
2010-05-17 13:11:39 +02:00
|
|
|
CONVERT_RGB32_888
|
2007-08-11 20:02:01 +02:00
|
|
|
} CONVERT_TYPES;
|
|
|
|
|
2010-08-30 20:29:49 +02:00
|
|
|
HRESULT d3dfmt_get_conv(IWineD3DSurfaceImpl *surface, BOOL need_alpha_ck, BOOL use_texturing,
|
|
|
|
struct wined3d_format *format, CONVERT_TYPES *convert) DECLSPEC_HIDDEN;
|
|
|
|
void d3dfmt_p8_init_palette(IWineD3DSurfaceImpl *surface, BYTE table[256][4], BOOL colorkey) DECLSPEC_HIDDEN;
|
2007-08-11 20:02:01 +02:00
|
|
|
|
2009-09-11 19:01:19 +02:00
|
|
|
BOOL palette9_changed(IWineD3DSurfaceImpl *This) DECLSPEC_HIDDEN;
|
2008-04-02 23:12:16 +02:00
|
|
|
|
2009-03-27 10:25:56 +01:00
|
|
|
struct wined3d_vertex_declaration_element
|
|
|
|
{
|
2010-08-30 20:29:49 +02:00
|
|
|
const struct wined3d_format *format;
|
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;
|
|
|
|
};
|
|
|
|
|
2011-02-02 20:22:50 +01:00
|
|
|
struct wined3d_vertex_declaration
|
|
|
|
{
|
|
|
|
LONG ref;
|
2010-08-31 18:41:40 +02:00
|
|
|
void *parent;
|
2009-09-23 10:05:52 +02:00
|
|
|
const struct wined3d_parent_ops *parent_ops;
|
2009-12-09 20:32:08 +01:00
|
|
|
IWineD3DDeviceImpl *device;
|
2007-03-12 23:21:54 +01:00
|
|
|
|
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;
|
2011-02-02 20:22:50 +01:00
|
|
|
};
|
2005-01-19 20:34:49 +01:00
|
|
|
|
2011-02-02 20:22:51 +01:00
|
|
|
HRESULT vertexdeclaration_init(struct wined3d_vertex_declaration *declaration,
|
|
|
|
IWineD3DDeviceImpl *device, const WINED3DVERTEXELEMENT *elements, UINT element_count,
|
2010-08-31 18:41:40 +02:00
|
|
|
void *parent, const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
|
2009-03-27 10:25:55 +01:00
|
|
|
|
2004-10-21 22:59:12 +02:00
|
|
|
/* 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 */
|
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-10-14 10:55:19 +02:00
|
|
|
DWORD textures : 20; /* MAX_COMBINED_SAMPLERS, 20 */
|
|
|
|
DWORD primitive_type : 1;
|
|
|
|
DWORD indices : 1;
|
|
|
|
DWORD material : 1;
|
|
|
|
DWORD viewport : 1;
|
|
|
|
DWORD vertexDecl : 1;
|
|
|
|
DWORD pixelShader : 1;
|
|
|
|
DWORD vertexShader : 1;
|
|
|
|
DWORD scissorRect : 1;
|
|
|
|
DWORD padding : 4;
|
2004-10-21 22:59:12 +02:00
|
|
|
} SAVEDSTATES;
|
|
|
|
|
2007-08-09 17:45:29 +02:00
|
|
|
struct StageState {
|
|
|
|
DWORD stage;
|
|
|
|
DWORD state;
|
|
|
|
};
|
|
|
|
|
2010-09-14 13:38:41 +02:00
|
|
|
struct wined3d_stream_state
|
|
|
|
{
|
|
|
|
struct wined3d_buffer *buffer;
|
|
|
|
UINT offset;
|
|
|
|
UINT stride;
|
|
|
|
UINT frequency;
|
|
|
|
UINT flags;
|
|
|
|
};
|
|
|
|
|
2010-09-15 12:00:04 +02:00
|
|
|
struct wined3d_state
|
|
|
|
{
|
2011-02-02 20:22:51 +01:00
|
|
|
struct wined3d_vertex_declaration *vertex_declaration;
|
2010-09-20 19:41:22 +02:00
|
|
|
struct wined3d_stream_state streams[MAX_STREAMS + 1 /* tesselated pseudo-stream */];
|
|
|
|
BOOL user_stream;
|
2010-09-20 19:41:23 +02:00
|
|
|
struct wined3d_buffer *index_buffer;
|
|
|
|
enum wined3d_format_id index_format;
|
2010-09-20 19:41:24 +02:00
|
|
|
INT base_vertex_index;
|
|
|
|
INT load_base_vertex_index; /* Non-indexed drawing needs 0 here, indexed needs base_vertex_index. */
|
2010-09-21 21:20:53 +02:00
|
|
|
GLenum gl_primitive_type;
|
2010-09-17 11:59:41 +02:00
|
|
|
|
2010-09-20 12:04:27 +02:00
|
|
|
struct IWineD3DVertexShaderImpl *vertex_shader;
|
2010-09-20 12:04:28 +02:00
|
|
|
BOOL vs_consts_b[MAX_CONST_B];
|
|
|
|
INT vs_consts_i[MAX_CONST_I * 4];
|
|
|
|
float *vs_consts_f;
|
2010-09-20 12:04:27 +02:00
|
|
|
|
2010-09-20 12:04:29 +02:00
|
|
|
struct IWineD3DPixelShaderImpl *pixel_shader;
|
2010-09-20 12:04:30 +02:00
|
|
|
BOOL ps_consts_b[MAX_CONST_B];
|
|
|
|
INT ps_consts_i[MAX_CONST_I * 4];
|
|
|
|
float *ps_consts_f;
|
2010-09-20 12:04:29 +02:00
|
|
|
|
2010-09-17 11:59:40 +02:00
|
|
|
IWineD3DBaseTextureImpl *textures[MAX_COMBINED_SAMPLERS];
|
2010-09-16 11:19:58 +02:00
|
|
|
DWORD sampler_states[MAX_COMBINED_SAMPLERS][WINED3D_HIGHEST_SAMPLER_STATE + 1];
|
2010-09-16 11:19:57 +02:00
|
|
|
DWORD texture_states[MAX_TEXTURES][WINED3D_HIGHEST_TEXTURE_STATE + 1];
|
|
|
|
DWORD lowest_disabled_stage;
|
|
|
|
|
2010-09-16 11:19:56 +02:00
|
|
|
WINED3DMATRIX transforms[HIGHEST_TRANSFORMSTATE + 1];
|
2010-09-21 21:20:55 +02:00
|
|
|
double clip_planes[MAX_CLIPPLANES][4];
|
2010-09-21 21:20:56 +02:00
|
|
|
WINED3DCLIPSTATUS clip_status;
|
2010-09-16 11:19:55 +02:00
|
|
|
WINED3DMATERIAL material;
|
2010-09-15 12:00:06 +02:00
|
|
|
WINED3DVIEWPORT viewport;
|
2010-09-15 12:00:05 +02:00
|
|
|
RECT scissor_rect;
|
|
|
|
|
2010-09-21 21:20:54 +02: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 light_map[LIGHTMAP_SIZE]; /* Hash map containing the lights */
|
|
|
|
const struct wined3d_light_info *lights[MAX_ACTIVE_LIGHTS]; /* Map of opengl lights to d3d lights */
|
|
|
|
|
2010-09-15 12:00:04 +02:00
|
|
|
DWORD render_states[WINEHIGHEST_RENDER_STATE + 1];
|
|
|
|
};
|
|
|
|
|
2011-01-28 20:05:41 +01:00
|
|
|
struct wined3d_stateblock
|
2004-10-21 22:59:12 +02:00
|
|
|
{
|
2005-07-28 12:16:21 +02:00
|
|
|
LONG ref; /* Note: Ref counting not required */
|
2009-12-09 20:32:08 +01:00
|
|
|
IWineD3DDeviceImpl *device;
|
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;
|
2010-09-15 12:00:04 +02:00
|
|
|
struct wined3d_state state;
|
2005-07-05 16:05:18 +02:00
|
|
|
|
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
|
|
|
};
|
|
|
|
|
2011-01-28 20:05:43 +01:00
|
|
|
HRESULT stateblock_init(struct wined3d_stateblock *stateblock,
|
2009-12-04 11:50:48 +01:00
|
|
|
IWineD3DDeviceImpl *device, WINED3DSTATEBLOCKTYPE type) DECLSPEC_HIDDEN;
|
2011-01-28 20:05:43 +01:00
|
|
|
void stateblock_init_contained_states(struct wined3d_stateblock *stateblock) DECLSPEC_HIDDEN;
|
|
|
|
void stateblock_init_default_state(struct wined3d_stateblock *stateblock) DECLSPEC_HIDDEN;
|
2004-10-21 22:59:12 +02:00
|
|
|
|
2011-01-28 20:05:43 +01:00
|
|
|
static inline void stateblock_apply_state(DWORD state, struct wined3d_stateblock *stateblock,
|
2010-04-01 11:34:44 +02:00
|
|
|
struct wined3d_context *context)
|
|
|
|
{
|
|
|
|
const struct StateEntry *statetable = stateblock->device->StateTable;
|
|
|
|
DWORD rep = statetable[state].representative;
|
|
|
|
statetable[rep].apply(rep, stateblock, context);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
};
|
2011-02-03 20:14:05 +01:00
|
|
|
|
|
|
|
struct wined3d_query_ops
|
|
|
|
{
|
2011-02-03 20:14:06 +01:00
|
|
|
HRESULT (*query_get_data)(struct wined3d_query *query, void *data, DWORD data_size, DWORD flags);
|
|
|
|
HRESULT (*query_issue)(struct wined3d_query *query, DWORD flags);
|
2011-02-03 20:14:05 +01:00
|
|
|
};
|
|
|
|
|
2011-02-03 20:14:06 +01:00
|
|
|
struct wined3d_query
|
2005-03-03 14:57:15 +01:00
|
|
|
{
|
2011-02-03 20:14:06 +01:00
|
|
|
LONG ref;
|
2011-02-03 20:14:05 +01:00
|
|
|
const struct wined3d_query_ops *query_ops;
|
2009-12-09 20:32:08 +01:00
|
|
|
IWineD3DDeviceImpl *device;
|
2007-12-04 01:43:24 +01:00
|
|
|
enum query_state state;
|
2006-10-11 03:53:30 +02:00
|
|
|
WINED3DQUERYTYPE type;
|
2011-02-03 20:14:05 +01:00
|
|
|
DWORD data_size;
|
2005-03-03 14:57:15 +01:00
|
|
|
void *extendedData;
|
2011-02-03 20:14:06 +01:00
|
|
|
};
|
2005-03-03 14:57:15 +01:00
|
|
|
|
2011-02-03 20:14:07 +01:00
|
|
|
HRESULT query_init(struct wined3d_query *query, IWineD3DDeviceImpl *device, WINED3DQUERYTYPE type) DECLSPEC_HIDDEN;
|
2005-03-03 14:57:15 +01: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 */
|
|
|
|
};
|
|
|
|
|
2009-12-28 00:33:05 +01:00
|
|
|
struct wined3d_map_range
|
|
|
|
{
|
|
|
|
UINT offset;
|
|
|
|
UINT size;
|
|
|
|
};
|
|
|
|
|
2009-03-06 14:56:23 +01:00
|
|
|
#define WINED3D_BUFFER_OPTIMIZED 0x01 /* Optimize has been called for the buffer */
|
2009-12-28 00:33:05 +01:00
|
|
|
#define WINED3D_BUFFER_HASDESC 0x02 /* A vertex description has been found */
|
|
|
|
#define WINED3D_BUFFER_CREATEBO 0x04 /* Attempt to create a buffer object next PreLoad */
|
|
|
|
#define WINED3D_BUFFER_DOUBLEBUFFER 0x08 /* Use a vbo and local allocated memory */
|
2009-12-17 22:44:07 +01:00
|
|
|
#define WINED3D_BUFFER_FLUSH 0x10 /* Manual unmap flushing */
|
2010-03-20 15:24:53 +01:00
|
|
|
#define WINED3D_BUFFER_DISCARD 0x20 /* A DISCARD lock has occurred since the last PreLoad */
|
2010-03-11 12:34:22 +01:00
|
|
|
#define WINED3D_BUFFER_NOSYNC 0x40 /* All locks since the last PreLoad had NOOVERWRITE set */
|
2010-03-18 12:11:35 +01:00
|
|
|
#define WINED3D_BUFFER_APPLESYNC 0x80 /* Using sync as in GL_APPLE_flush_buffer_range */
|
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;
|
|
|
|
|
|
|
|
LONG lock_count;
|
2009-12-28 00:33:05 +01:00
|
|
|
struct wined3d_map_range *maps;
|
|
|
|
ULONG maps_size, modified_areas;
|
2010-03-21 13:26:36 +01:00
|
|
|
struct wined3d_event_query *query;
|
2009-03-06 14:56:23 +01:00
|
|
|
|
|
|
|
/* conversion stuff */
|
2009-12-24 16:35:07 +01:00
|
|
|
UINT decl_change_count, full_conversion_count;
|
2009-03-06 14:56:23 +01:00
|
|
|
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
|
|
|
};
|
|
|
|
|
2010-12-07 18:47:06 +01:00
|
|
|
const BYTE *buffer_get_memory(struct wined3d_buffer *buffer, const struct wined3d_gl_info *gl_info,
|
2010-05-21 09:35:23 +02:00
|
|
|
GLuint *buffer_object) DECLSPEC_HIDDEN;
|
2010-05-21 09:35:24 +02:00
|
|
|
BYTE *buffer_get_sysmem(struct wined3d_buffer *This, const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
|
2009-09-17 23:03:32 +02:00
|
|
|
HRESULT buffer_init(struct wined3d_buffer *buffer, IWineD3DDeviceImpl *device,
|
2010-08-23 18:28:10 +02:00
|
|
|
UINT size, DWORD usage, enum wined3d_format_id format_id, WINED3DPOOL pool, GLenum bind_hint,
|
2010-08-31 18:41:40 +02:00
|
|
|
const char *data, void *parent, const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
|
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;
|
|
|
|
|
2011-01-17 18:49:30 +01:00
|
|
|
struct IWineD3DResourceImpl *resource;
|
2010-08-31 18:41:40 +02:00
|
|
|
void *parent;
|
2009-02-24 07:43:02 +01:00
|
|
|
};
|
|
|
|
|
2010-04-13 20:46:24 +02:00
|
|
|
void wined3d_rendertarget_view_init(struct wined3d_rendertarget_view *view,
|
2011-01-17 18:49:29 +01:00
|
|
|
struct IWineD3DResourceImpl *resource, void *parent) DECLSPEC_HIDDEN;
|
2009-02-24 07:43:02 +01:00
|
|
|
|
2005-06-23 13:05:24 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
* IWineD3DSwapChainImpl implementation structure (extends IUnknown)
|
|
|
|
*/
|
|
|
|
|
2009-12-14 20:49:52 +01:00
|
|
|
struct IWineD3DSwapChainImpl
|
2005-06-23 13:05:24 +02:00
|
|
|
{
|
|
|
|
/*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
|
|
|
|
2010-08-31 18:41:40 +02:00
|
|
|
void *parent;
|
2009-12-09 20:32:08 +01:00
|
|
|
IWineD3DDeviceImpl *device;
|
2005-06-23 13:05:24 +02:00
|
|
|
|
|
|
|
/* IWineD3DSwapChain fields */
|
2010-04-26 21:33:01 +02:00
|
|
|
IWineD3DSurfaceImpl **back_buffers;
|
2010-04-26 21:33:00 +02:00
|
|
|
IWineD3DSurfaceImpl *front_buffer;
|
2007-02-15 22:36:50 +01:00
|
|
|
WINED3DPRESENT_PARAMETERS presentParms;
|
2006-12-08 16:13:15 +01:00
|
|
|
DWORD orig_width, orig_height;
|
2010-08-23 18:28:10 +02:00
|
|
|
enum wined3d_format_id orig_fmt;
|
2008-07-01 18:17:38 +02:00
|
|
|
WINED3DGAMMARAMP orig_gamma;
|
2009-12-06 17:39:47 +01:00
|
|
|
BOOL render_to_fbo;
|
2010-08-30 20:29:49 +02:00
|
|
|
const struct wined3d_format *ds_format;
|
2005-06-23 13:05:24 +02:00
|
|
|
|
2010-05-21 12:45:40 +02: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
|
|
|
|
2009-08-03 08:06:51 +02:00
|
|
|
struct wined3d_context **context;
|
2007-03-04 17:31:06 +01:00
|
|
|
unsigned int num_contexts;
|
2005-06-23 13:05:24 +02:00
|
|
|
|
|
|
|
HWND win_handle;
|
2010-03-15 21:07:30 +01:00
|
|
|
HWND device_window;
|
2009-12-14 20:49:52 +01:00
|
|
|
};
|
2005-06-23 13:05:24 +02:00
|
|
|
|
2010-10-01 13:42:22 +02:00
|
|
|
extern const IWineD3DSwapChainVtbl IWineGDISwapChain_Vtbl DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
void x11_copy_to_screen(IWineD3DSwapChainImpl *This, const RECT *rc) DECLSPEC_HIDDEN;
|
|
|
|
|
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_QueryInterface(IWineD3DSwapChain *iface,
|
|
|
|
REFIID riid, LPVOID *ppobj) DECLSPEC_HIDDEN;
|
|
|
|
ULONG WINAPI IWineD3DBaseSwapChainImpl_AddRef(IWineD3DSwapChain *iface) DECLSPEC_HIDDEN;
|
|
|
|
ULONG WINAPI IWineD3DBaseSwapChainImpl_Release(IWineD3DSwapChain *iface) DECLSPEC_HIDDEN;
|
2010-08-31 18:41:40 +02:00
|
|
|
void * WINAPI IWineD3DBaseSwapChainImpl_GetParent(IWineD3DSwapChain *iface) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_GetFrontBufferData(IWineD3DSwapChain *iface,
|
2010-08-15 23:21:43 +02:00
|
|
|
IWineD3DSurface *dst_surface) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_GetBackBuffer(IWineD3DSwapChain *iface, UINT iBackBuffer,
|
|
|
|
WINED3DBACKBUFFER_TYPE Type, IWineD3DSurface **ppBackBuffer) DECLSPEC_HIDDEN;
|
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_GetRasterStatus(IWineD3DSwapChain *iface,
|
|
|
|
WINED3DRASTER_STATUS *pRasterStatus) DECLSPEC_HIDDEN;
|
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_GetDisplayMode(IWineD3DSwapChain *iface,
|
|
|
|
WINED3DDISPLAYMODE *pMode) DECLSPEC_HIDDEN;
|
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_GetDevice(IWineD3DSwapChain *iface,
|
2010-04-20 22:38:39 +02:00
|
|
|
IWineD3DDevice **device) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_GetPresentParameters(IWineD3DSwapChain *iface,
|
|
|
|
WINED3DPRESENT_PARAMETERS *pPresentationParameters) DECLSPEC_HIDDEN;
|
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_SetGammaRamp(IWineD3DSwapChain *iface,
|
2010-11-18 20:50:40 +01:00
|
|
|
DWORD flags, const WINED3DGAMMARAMP *pRamp) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
HRESULT WINAPI IWineD3DBaseSwapChainImpl_GetGammaRamp(IWineD3DSwapChain *iface,
|
|
|
|
WINED3DGAMMARAMP *pRamp) DECLSPEC_HIDDEN;
|
|
|
|
|
2011-01-19 19:20:11 +01:00
|
|
|
struct wined3d_context *swapchain_get_context(struct IWineD3DSwapChainImpl *swapchain) DECLSPEC_HIDDEN;
|
2009-12-10 21:41:54 +01:00
|
|
|
HRESULT swapchain_init(IWineD3DSwapChainImpl *swapchain, WINED3DSURFTYPE surface_type,
|
2010-08-31 18:41:40 +02:00
|
|
|
IWineD3DDeviceImpl *device, WINED3DPRESENT_PARAMETERS *present_parameters, void *parent) DECLSPEC_HIDDEN;
|
2007-06-02 22:21:57 +02:00
|
|
|
|
2009-08-26 10:24:09 +02:00
|
|
|
#define DEFAULT_REFRESH_RATE 0
|
|
|
|
|
2004-10-21 22:59:12 +02:00
|
|
|
/*****************************************************************************
|
2009-08-27 10:04:56 +02:00
|
|
|
* Utility function prototypes
|
2004-10-21 22:59:12 +02:00
|
|
|
*/
|
2004-12-13 14:35:38 +01:00
|
|
|
|
|
|
|
/* Trace routines */
|
2010-08-23 18:28:10 +02:00
|
|
|
const char *debug_d3dformat(enum wined3d_format_id format_id) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
const char *debug_d3ddevicetype(WINED3DDEVTYPE devtype) DECLSPEC_HIDDEN;
|
|
|
|
const char *debug_d3dresourcetype(WINED3DRESOURCETYPE res) DECLSPEC_HIDDEN;
|
|
|
|
const char *debug_d3dusage(DWORD usage) DECLSPEC_HIDDEN;
|
|
|
|
const char *debug_d3dusagequery(DWORD usagequery) DECLSPEC_HIDDEN;
|
|
|
|
const char *debug_d3ddeclmethod(WINED3DDECLMETHOD method) DECLSPEC_HIDDEN;
|
|
|
|
const char *debug_d3ddeclusage(BYTE usage) DECLSPEC_HIDDEN;
|
|
|
|
const char *debug_d3dprimitivetype(WINED3DPRIMITIVETYPE PrimitiveType) DECLSPEC_HIDDEN;
|
|
|
|
const char *debug_d3drenderstate(DWORD state) DECLSPEC_HIDDEN;
|
|
|
|
const char *debug_d3dsamplerstate(DWORD state) DECLSPEC_HIDDEN;
|
2010-01-28 23:40:23 +01:00
|
|
|
const char *debug_d3dstate(DWORD state) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
const char *debug_d3dtexturefiltertype(WINED3DTEXTUREFILTERTYPE filter_type) DECLSPEC_HIDDEN;
|
|
|
|
const char *debug_d3dtexturestate(DWORD state) DECLSPEC_HIDDEN;
|
|
|
|
const char *debug_d3dtstype(WINED3DTRANSFORMSTATETYPE tstype) DECLSPEC_HIDDEN;
|
|
|
|
const char *debug_d3dpool(WINED3DPOOL pool) DECLSPEC_HIDDEN;
|
|
|
|
const char *debug_fbostatus(GLenum status) DECLSPEC_HIDDEN;
|
|
|
|
const char *debug_glerror(GLenum error) DECLSPEC_HIDDEN;
|
|
|
|
const char *debug_d3dbasis(WINED3DBASISTYPE basis) DECLSPEC_HIDDEN;
|
|
|
|
const char *debug_d3ddegree(WINED3DDEGREETYPE order) DECLSPEC_HIDDEN;
|
|
|
|
const char *debug_d3dtop(WINED3DTEXTUREOP d3dtop) DECLSPEC_HIDDEN;
|
|
|
|
void dump_color_fixup_desc(struct color_fixup_desc fixup) DECLSPEC_HIDDEN;
|
|
|
|
const char *debug_surflocation(DWORD flag) DECLSPEC_HIDDEN;
|
2004-12-13 14:35:38 +01:00
|
|
|
|
|
|
|
/* Routines for GL <-> D3D values */
|
2009-09-11 19:01:19 +02:00
|
|
|
GLenum StencilOp(DWORD op) DECLSPEC_HIDDEN;
|
|
|
|
GLenum CompareFunc(DWORD func) DECLSPEC_HIDDEN;
|
2010-09-23 11:48:02 +02:00
|
|
|
BOOL is_invalid_op(const struct wined3d_state *state, int stage,
|
|
|
|
WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3) DECLSPEC_HIDDEN;
|
2010-09-23 11:48:03 +02:00
|
|
|
void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d_state *state,
|
|
|
|
BOOL is_alpha, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3,
|
|
|
|
INT texture_idx, DWORD dst) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords,
|
2010-08-23 18:28:10 +02:00
|
|
|
BOOL transformed, enum wined3d_format_id coordtype, BOOL ffp_can_disable_proj) DECLSPEC_HIDDEN;
|
2010-09-23 21:33:27 +02:00
|
|
|
void texture_activate_dimensions(IWineD3DBaseTextureImpl *texture,
|
|
|
|
const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
|
2011-01-28 20:05:43 +01:00
|
|
|
void sampler_texdim(DWORD state, struct wined3d_stateblock *stateblock,
|
2009-09-11 19:01:19 +02:00
|
|
|
struct wined3d_context *context) DECLSPEC_HIDDEN;
|
2011-01-28 20:05:43 +01:00
|
|
|
void tex_alphaop(DWORD state, struct wined3d_stateblock *stateblock,
|
2009-09-11 19:01:19 +02:00
|
|
|
struct wined3d_context *context) DECLSPEC_HIDDEN;
|
2011-01-28 20:05:43 +01:00
|
|
|
void apply_pixelshader(DWORD state, struct wined3d_stateblock *stateblock,
|
2009-09-11 19:01:19 +02:00
|
|
|
struct wined3d_context *context) DECLSPEC_HIDDEN;
|
2011-01-28 20:05:43 +01:00
|
|
|
void state_fogcolor(DWORD state, struct wined3d_stateblock *stateblock,
|
2009-09-11 19:01:19 +02:00
|
|
|
struct wined3d_context *context) DECLSPEC_HIDDEN;
|
2011-01-28 20:05:43 +01:00
|
|
|
void state_fogdensity(DWORD state, struct wined3d_stateblock *stateblock,
|
2009-09-11 19:01:19 +02:00
|
|
|
struct wined3d_context *context) DECLSPEC_HIDDEN;
|
2011-01-28 20:05:43 +01:00
|
|
|
void state_fogstartend(DWORD state, struct wined3d_stateblock *stateblock,
|
2009-09-11 19:01:19 +02:00
|
|
|
struct wined3d_context *context) DECLSPEC_HIDDEN;
|
2011-01-28 20:05:43 +01:00
|
|
|
void state_fog_fragpart(DWORD state, struct wined3d_stateblock *stateblock,
|
2009-09-11 19:01:19 +02:00
|
|
|
struct wined3d_context *context) DECLSPEC_HIDDEN;
|
|
|
|
|
2010-08-30 20:29:49 +02:00
|
|
|
BOOL getColorBits(const struct wined3d_format *format,
|
2009-09-11 19:01:19 +02:00
|
|
|
short *redSize, short *greenSize, short *blueSize, short *alphaSize, short *totalSize) DECLSPEC_HIDDEN;
|
2010-08-30 20:29:49 +02:00
|
|
|
BOOL getDepthStencilBits(const struct wined3d_format *format,
|
2009-09-11 19:01:19 +02:00
|
|
|
short *depthSize, short *stencilSize) DECLSPEC_HIDDEN;
|
2007-08-09 01:04:30 +02:00
|
|
|
|
2006-05-12 22:21:31 +02:00
|
|
|
/* Math utils */
|
2009-09-11 19:01:19 +02:00
|
|
|
void multiply_matrix(WINED3DMATRIX *dest, const WINED3DMATRIX *src1, const WINED3DMATRIX *src2) DECLSPEC_HIDDEN;
|
|
|
|
UINT wined3d_log2i(UINT32 x) DECLSPEC_HIDDEN;
|
|
|
|
unsigned int count_bits(unsigned int mask) DECLSPEC_HIDDEN;
|
2005-07-07 22:35:05 +02:00
|
|
|
|
2009-11-18 10:45:52 +01:00
|
|
|
void select_shader_mode(const struct wined3d_gl_info *gl_info, int *ps_selected, int *vs_selected) DECLSPEC_HIDDEN;
|
|
|
|
|
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;
|
|
|
|
|
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
|
|
|
|
|
2009-07-09 09:56:08 +02:00
|
|
|
/* Base Shader utility functions. */
|
2009-09-11 19:01:19 +02:00
|
|
|
int shader_addline(struct wined3d_shader_buffer *buffer, const char *fmt, ...) PRINTF_ATTR(2,3) DECLSPEC_HIDDEN;
|
|
|
|
int shader_vaddline(struct wined3d_shader_buffer *buffer, const char *fmt, va_list args) DECLSPEC_HIDDEN;
|
2006-05-08 21:44:25 +02:00
|
|
|
|
2006-07-07 08:27:38 +02:00
|
|
|
/* Vertex shader utility functions */
|
2010-09-20 12:04:27 +02:00
|
|
|
extern BOOL vshader_get_input(struct IWineD3DVertexShaderImpl *shader,
|
2009-09-11 19:01:19 +02:00
|
|
|
BYTE usage_req, BYTE usage_idx_req, unsigned int *regnum) DECLSPEC_HIDDEN;
|
2006-07-07 08:27:38 +02:00
|
|
|
|
2006-03-30 19:14:31 +02:00
|
|
|
/*****************************************************************************
|
|
|
|
* IDirect3DBaseShader implementation structure
|
|
|
|
*/
|
|
|
|
typedef struct IWineD3DBaseShaderClass
|
|
|
|
{
|
2007-11-16 21:01:33 +01:00
|
|
|
LONG ref;
|
2006-05-08 23:09:21 +02:00
|
|
|
SHADER_LIMITS limits;
|
2007-11-16 21:02:29 +01:00
|
|
|
DWORD *function;
|
2006-03-30 19:14:31 +02:00
|
|
|
UINT functionLength;
|
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;
|
2009-09-25 13:31:44 +02:00
|
|
|
void *backend_data;
|
|
|
|
|
2010-08-31 18:41:40 +02:00
|
|
|
void *parent;
|
2009-09-25 13:31:44 +02:00
|
|
|
const struct wined3d_parent_ops *parent_ops;
|
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;
|
2010-12-06 20:33:02 +01:00
|
|
|
struct wined3d_shader_reg_maps reg_maps;
|
2006-07-10 06:51:03 +02:00
|
|
|
|
2009-12-30 19:33:41 +01:00
|
|
|
struct wined3d_shader_signature_element input_signature[max(MAX_ATTRIBS, MAX_REG_INPUT)];
|
|
|
|
struct wined3d_shader_signature_element output_signature[MAX_REG_OUTPUT];
|
|
|
|
|
2006-09-27 13:14:46 +02:00
|
|
|
/* Pointer to the parent device */
|
2010-12-07 18:47:08 +01:00
|
|
|
struct IWineD3DDeviceImpl *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;
|
|
|
|
|
2009-09-11 19:01:19 +02:00
|
|
|
void shader_buffer_clear(struct wined3d_shader_buffer *buffer) DECLSPEC_HIDDEN;
|
|
|
|
BOOL shader_buffer_init(struct wined3d_shader_buffer *buffer) DECLSPEC_HIDDEN;
|
|
|
|
void shader_buffer_free(struct wined3d_shader_buffer *buffer) DECLSPEC_HIDDEN;
|
2009-05-06 17:59:21 +02:00
|
|
|
void shader_dump_src_param(const struct wined3d_shader_src_param *param,
|
2009-09-11 19:01:19 +02:00
|
|
|
const struct wined3d_shader_version *shader_version) DECLSPEC_HIDDEN;
|
2009-05-06 17:59:21 +02:00
|
|
|
void shader_dump_dst_param(const struct wined3d_shader_dst_param *param,
|
2009-09-11 19:01:19 +02:00
|
|
|
const struct wined3d_shader_version *shader_version) DECLSPEC_HIDDEN;
|
2010-12-06 20:33:02 +01:00
|
|
|
unsigned int shader_find_free_input_register(const struct wined3d_shader_reg_maps *reg_maps,
|
|
|
|
unsigned int max) DECLSPEC_HIDDEN;
|
2010-12-14 18:31:00 +01:00
|
|
|
void shader_generate_main(IWineD3DBaseShaderImpl *shader, struct wined3d_shader_buffer *buffer,
|
2010-12-06 20:33:02 +01:00
|
|
|
const struct wined3d_shader_reg_maps *reg_maps, const DWORD *pFunction, void *backend_ctx) DECLSPEC_HIDDEN;
|
2009-09-11 19:01:19 +02:00
|
|
|
BOOL shader_match_semantic(const char *semantic_name, WINED3DDECLUSAGE usage) DECLSPEC_HIDDEN;
|
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 */
|
2010-09-14 13:38:39 +02:00
|
|
|
if (reg->idx) 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:
|
2010-10-08 13:12:18 +02:00
|
|
|
return reg->immconst_type == WINED3D_IMMCONST_SCALAR;
|
2009-05-07 16:36:08 +02:00
|
|
|
|
2007-04-12 23:55:31 +02:00
|
|
|
default:
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-26 09:11:05 +02:00
|
|
|
static inline void shader_get_position_fixup(const struct wined3d_context *context,
|
|
|
|
const struct wined3d_state *state, float *position_fixup)
|
|
|
|
{
|
|
|
|
position_fixup[0] = 1.0f;
|
|
|
|
position_fixup[1] = 1.0f;
|
|
|
|
position_fixup[2] = (63.0f / 64.0f) / state->viewport.Width;
|
|
|
|
position_fixup[3] = -(63.0f / 64.0f) / state->viewport.Height;
|
|
|
|
|
|
|
|
if (context->render_offscreen)
|
|
|
|
{
|
|
|
|
position_fixup[1] *= -1.0f;
|
|
|
|
position_fixup[3] *= -1.0f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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 {
|
2009-08-27 10:04:56 +02:00
|
|
|
/* 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
|
|
|
|
2009-12-30 19:33:41 +01:00
|
|
|
/* Vertex shader attributes. */
|
2009-05-27 10:24:50 +02:00
|
|
|
struct wined3d_shader_attribute attributes[MAX_ATTRIBS];
|
2005-03-02 13:16:10 +01:00
|
|
|
} IWineD3DVertexShaderImpl;
|
2009-02-05 19:44:32 +01:00
|
|
|
|
2010-09-29 12:20:44 +02:00
|
|
|
void find_vs_compile_args(const struct wined3d_state *state,
|
|
|
|
IWineD3DVertexShaderImpl *shader, struct vs_compile_args *args) DECLSPEC_HIDDEN;
|
2009-09-23 18:42:04 +02:00
|
|
|
HRESULT vertexshader_init(IWineD3DVertexShaderImpl *shader, IWineD3DDeviceImpl *device,
|
|
|
|
const DWORD *byte_code, const struct wined3d_shader_signature *output_signature,
|
2010-08-31 18:41:40 +02:00
|
|
|
void *parent, const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
|
2010-01-03 21:18:23 +01:00
|
|
|
|
|
|
|
struct wined3d_geometryshader
|
|
|
|
{
|
|
|
|
const struct IWineD3DGeometryShaderVtbl *vtbl;
|
|
|
|
IWineD3DBaseShaderClass base_shader;
|
|
|
|
};
|
|
|
|
|
|
|
|
HRESULT geometryshader_init(struct wined3d_geometryshader *shader, IWineD3DDeviceImpl *device,
|
|
|
|
const DWORD *byte_code, const struct wined3d_shader_signature *output_signature,
|
2010-08-31 18:41:40 +02:00
|
|
|
void *parent, const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
|
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;
|
|
|
|
|
2006-07-04 10:01:46 +02:00
|
|
|
/* Pixel shader input semantics */
|
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];
|
2009-07-08 09:49:28 +02:00
|
|
|
unsigned int declared_in_count;
|
2006-07-04 10:01:46 +02: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
|
|
|
|
2009-09-23 18:42:09 +02:00
|
|
|
HRESULT pixelshader_init(IWineD3DPixelShaderImpl *shader, IWineD3DDeviceImpl *device,
|
|
|
|
const DWORD *byte_code, const struct wined3d_shader_signature *output_signature,
|
2010-08-31 18:41:40 +02:00
|
|
|
void *parent, const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
|
2010-12-06 20:33:02 +01:00
|
|
|
void pixelshader_update_samplers(struct wined3d_shader_reg_maps *reg_maps,
|
2010-12-15 21:06:23 +01:00
|
|
|
IWineD3DBaseTextureImpl * const *textures) DECLSPEC_HIDDEN;
|
2010-09-29 12:20:45 +02:00
|
|
|
void find_ps_compile_args(const struct wined3d_state *state,
|
|
|
|
IWineD3DPixelShaderImpl *shader, struct ps_compile_args *args) DECLSPEC_HIDDEN;
|
2006-04-17 17:04:59 +02:00
|
|
|
|
2007-09-14 13:02:59 +02:00
|
|
|
/* sRGB correction constants */
|
2009-07-07 11:08:01 +02:00
|
|
|
static const float srgb_cmp = 0.0031308f;
|
|
|
|
static const float srgb_mul_low = 12.92f;
|
|
|
|
static const float srgb_pow = 0.41666f;
|
|
|
|
static const float srgb_mul_high = 1.055f;
|
|
|
|
static const float srgb_sub_high = 0.055f;
|
2007-09-14 13:02:59 +02:00
|
|
|
|
2011-02-02 20:22:52 +01:00
|
|
|
struct wined3d_palette
|
|
|
|
{
|
|
|
|
LONG ref;
|
2010-08-31 18:41:40 +02:00
|
|
|
void *parent;
|
2009-12-09 20:32:08 +01:00
|
|
|
IWineD3DDeviceImpl *device;
|
2006-04-21 00:00:30 +02:00
|
|
|
|
|
|
|
HPALETTE hpal;
|
|
|
|
WORD palVersion; /*| */
|
|
|
|
WORD palNumEntries; /*| LOGPALETTE */
|
|
|
|
PALETTEENTRY palents[256]; /*| */
|
|
|
|
/* This is to store the palette in 'screen format' */
|
|
|
|
int screen_palents[256];
|
2010-11-15 13:43:33 +01:00
|
|
|
DWORD flags;
|
2006-04-17 17:04:59 +02:00
|
|
|
};
|
|
|
|
|
2011-02-02 20:22:53 +01:00
|
|
|
HRESULT wined3d_palette_init(struct wined3d_palette *palette, IWineD3DDeviceImpl *device,
|
2010-08-31 18:41:40 +02:00
|
|
|
DWORD flags, const PALETTEENTRY *entries, void *parent) DECLSPEC_HIDDEN;
|
2006-04-17 17:04:59 +02:00
|
|
|
|
2006-04-18 23:04:51 +02:00
|
|
|
/* DirectDraw utility functions */
|
2010-08-23 18:28:10 +02:00
|
|
|
extern enum wined3d_format_id pixelformat_for_depth(DWORD depth) DECLSPEC_HIDDEN;
|
2006-04-18 23:04:51 +02:00
|
|
|
|
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 */
|
2010-04-29 00:09:00 +02:00
|
|
|
#define WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING 0x00000001
|
|
|
|
#define WINED3DFMT_FLAG_FILTERING 0x00000002
|
|
|
|
#define WINED3DFMT_FLAG_DEPTH 0x00000004
|
|
|
|
#define WINED3DFMT_FLAG_STENCIL 0x00000008
|
|
|
|
#define WINED3DFMT_FLAG_RENDERTARGET 0x00000010
|
|
|
|
#define WINED3DFMT_FLAG_FOURCC 0x00000020
|
|
|
|
#define WINED3DFMT_FLAG_FBO_ATTACHABLE 0x00000040
|
2010-07-26 12:06:32 +02:00
|
|
|
#define WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB 0x00000080
|
2010-04-29 00:09:00 +02:00
|
|
|
#define WINED3DFMT_FLAG_GETDC 0x00000100
|
|
|
|
#define WINED3DFMT_FLAG_FLOAT 0x00000200
|
|
|
|
#define WINED3DFMT_FLAG_BUMPMAP 0x00000400
|
2010-04-29 00:09:01 +02:00
|
|
|
#define WINED3DFMT_FLAG_SRGB_READ 0x00000800
|
2010-04-29 00:09:02 +02:00
|
|
|
#define WINED3DFMT_FLAG_SRGB_WRITE 0x00001000
|
2010-04-29 00:09:03 +02:00
|
|
|
#define WINED3DFMT_FLAG_VTF 0x00002000
|
2010-05-17 11:14:48 +02:00
|
|
|
#define WINED3DFMT_FLAG_SHADOW 0x00004000
|
2010-07-26 12:06:32 +02:00
|
|
|
#define WINED3DFMT_FLAG_COMPRESSED 0x00008000
|
2010-08-15 23:21:46 +02:00
|
|
|
#define WINED3DFMT_FLAG_BROKEN_PITCH 0x00010000
|
2009-05-01 09:13:54 +02:00
|
|
|
|
2010-08-30 20:29:49 +02:00
|
|
|
struct wined3d_format
|
2008-12-03 14:53:42 +01:00
|
|
|
{
|
2010-08-25 20:46:51 +02:00
|
|
|
enum wined3d_format_id id;
|
|
|
|
|
2009-03-13 10:44:17 +01:00
|
|
|
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;
|
2010-04-08 22:49:45 +02:00
|
|
|
UINT conv_byte_count;
|
2010-11-12 13:12:05 +01:00
|
|
|
unsigned int flags;
|
2008-12-03 14:53:42 +01:00
|
|
|
float heightscale;
|
2008-12-03 14:53:43 +01:00
|
|
|
struct color_fixup_desc color_fixup;
|
2010-04-08 22:49:47 +02:00
|
|
|
void (*convert)(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height);
|
2008-12-03 14:53:42 +01:00
|
|
|
};
|
|
|
|
|
2010-08-30 20:29:49 +02:00
|
|
|
const struct wined3d_format *wined3d_get_format(const struct wined3d_gl_info *gl_info,
|
|
|
|
enum wined3d_format_id format_id) DECLSPEC_HIDDEN;
|
|
|
|
UINT wined3d_format_calculate_size(const struct wined3d_format *format,
|
2010-08-15 23:21:47 +02:00
|
|
|
UINT alignment, UINT width, UINT height) DECLSPEC_HIDDEN;
|
2010-08-30 20:29:49 +02:00
|
|
|
DWORD wined3d_format_convert_from_float(const struct wined3d_format *format,
|
2010-08-23 18:28:07 +02:00
|
|
|
const WINED3DCOLORVALUE *color) DECLSPEC_HIDDEN;
|
2007-03-12 23:22:00 +01:00
|
|
|
|
2010-09-28 12:00:23 +02:00
|
|
|
static inline BOOL use_vs(const struct wined3d_state *state)
|
2008-12-30 14:56:49 +01:00
|
|
|
{
|
2009-08-19 10:55:35 +02:00
|
|
|
/* Check stateblock->vertexDecl to allow this to be used from
|
|
|
|
* IWineD3DDeviceImpl_FindTexUnitMap(). This is safe because
|
|
|
|
* stateblock->vertexShader implies a vertex declaration instead of ddraw
|
|
|
|
* style strided data. */
|
2010-09-28 12:00:23 +02:00
|
|
|
return state->vertex_shader && !state->vertex_declaration->position_transformed;
|
2007-03-12 23:22:00 +01:00
|
|
|
}
|
|
|
|
|
2010-09-28 12:00:24 +02:00
|
|
|
static inline BOOL use_ps(const struct wined3d_state *state)
|
2008-12-30 14:56:49 +01:00
|
|
|
{
|
2010-09-28 12:00:24 +02:00
|
|
|
return !!state->pixel_shader;
|
2007-03-12 23:22:00 +01:00
|
|
|
}
|
|
|
|
|
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"
|
|
|
|
|
2009-12-22 18:32:17 +01:00
|
|
|
#define WINEMAKEFOURCC(ch0, ch1, ch2, ch3) \
|
|
|
|
((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | \
|
|
|
|
((DWORD)(BYTE)(ch2) << 16) | ((DWORD)(BYTE)(ch3) << 24 ))
|
|
|
|
|
2010-04-05 21:10:15 +02:00
|
|
|
#define MAKEDWORD_VERSION(maj, min) (((maj & 0xffff) << 16) | (min & 0xffff))
|
|
|
|
|
2003-11-14 04:50:35 +01:00
|
|
|
#endif
|