* Copyright 2002-2003 Raphael Junqueira
* Copyright 2002-2003, 2004 Jason Edmeades
* Copyright 2005 Oliver Stieber
+ * Copyright 2006-2011, 2013 Stefan Dösinger for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
#ifndef __WINE_WINED3D_PRIVATE_H
#define __WINE_WINED3D_PRIVATE_H
-#include <stdarg.h>
-#include <math.h>
-#include <limits.h>
+#include <wine/config.h>
+#include <wine/port.h>
+
+#ifdef USE_WIN32_OPENGL
+#define WINE_GLAPI __stdcall
+#else
+#define WINE_GLAPI
+#endif
+
+#ifdef HAVE_FLOAT_H
+# include <float.h>
+#endif
+
+#include <stdio.h>
+
+#define WIN32_NO_STATUS
+#define _INC_WINDOWS
+#define COM_NO_WINDOWS_H
+
#define NONAMELESSUNION
#define NONAMELESSSTRUCT
#define COBJMACROS
-#include "windef.h"
-#include "winbase.h"
-#include "winreg.h"
-#include "wingdi.h"
-#include "winuser.h"
-#include "wine/debug.h"
-#include "wine/unicode.h"
-
-#include "objbase.h"
-#include "wine/wined3d.h"
+
+#include <windef.h>
+#include <winbase.h>
+#include <wingdi.h>
+#include <winuser.h>
+#include <objbase.h>
+
+#include <wine/debug.h>
+#include <wine/list.h>
+#include <wine/rbtree.h>
+#include <wine/wined3d.h>
#include "wined3d_gl.h"
-#include "wine/list.h"
-#include "wine/rbtree.h"
+#include <wine/wgl_driver.h>
/* Driver quirks */
#define WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT 0x00000001
#define WINED3D_QUIRK_BROKEN_RGBA16 0x00000040
#define WINED3D_QUIRK_INFO_LOG_SPAM 0x00000080
#define WINED3D_QUIRK_LIMITED_TEX_FILTERING 0x00000100
+#define WINED3D_QUIRK_BROKEN_ARB_FOG 0x00000200
/* Texture format fixups */
void wined3d_rb_free(void *ptr) DECLSPEC_HIDDEN;
/* Device caps */
-#define MAX_PALETTES 65536
+#define MAX_STREAM_OUT 4
#define MAX_STREAMS 16
#define MAX_TEXTURES 8
#define MAX_FRAGMENT_SAMPLERS 16
#define MAX_COMBINED_SAMPLERS (MAX_FRAGMENT_SAMPLERS + MAX_VERTEX_SAMPLERS)
#define MAX_ACTIVE_LIGHTS 8
#define MAX_CLIPPLANES WINED3DMAXUSERCLIPPLANES
+#define MAX_CONSTANT_BUFFERS 15
+#define MAX_SAMPLER_OBJECTS 16
struct min_lookup
{
*
* See GL_NV_half_float for a reference of the FLOAT16 / GL_HALF format
*/
-static inline float float_16_to_32(const unsigned short *in) {
+static inline float float_16_to_32(const unsigned short *in)
+{
const unsigned short s = ((*in) & 0x8000);
- const unsigned short e = ((*in) & 0x7C00) >> 10;
- const unsigned short m = (*in) & 0x3FF;
+ const unsigned short e = ((*in) & 0x7c00) >> 10;
+ const unsigned short m = (*in) & 0x3ff;
const float sgn = (s ? -1.0f : 1.0f);
if(e == 0) {
} else if(e < 31) {
return sgn * powf(2, (float)e - 15.0f) * (1.0f + ((float)m / 1024.0f));
} else {
- if(m == 0) return sgn * INFINITY; /* +INF / -INF */
- else return NAN; /* NAN */
+ if(m == 0) return sgn * INFINITY;
+ else return NAN;
}
}
}
else
{
- if (m == 0) return sgn * INFINITY; /* +INF / -INF */
- else return NAN; /* NAN */
+ if (m == 0) return sgn * INFINITY;
+ else return NAN;
}
}
-/**
- * Settings
- */
-#define VS_NONE 0
-#define VS_HW 1
-
-#define PS_NONE 0
-#define PS_HW 1
-
-#define VBO_NONE 0
-#define VBO_HW 1
-
#define ORM_BACKBUFFER 0
#define ORM_FBO 1
-#define SHADER_ARB 1
-#define SHADER_GLSL 2
-#define SHADER_ATI 3
-#define SHADER_NONE 4
-
-#define RTL_READDRAW 1
-#define RTL_READTEX 2
-
#define PCI_VENDOR_NONE 0xffff /* e.g. 0x8086 for Intel and 0x10de for Nvidia */
#define PCI_DEVICE_NONE 0xffff /* e.g. 0x14f for a Geforce6200 */
* values in wined3d_main.c as well. */
struct wined3d_settings
{
- /* vertex and pixel shader modes */
- int vs_mode;
- int ps_mode;
/* 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. */
BOOL glslRequested;
int offscreen_rendering_mode;
- int rendertargetlock_mode;
unsigned short pci_vendor_id;
unsigned short pci_device_id;
/* Memory tracking and object counting. */
int allow_multisampling;
BOOL strict_draw_ordering;
BOOL always_offscreen;
+ unsigned int max_sm_vs;
+ unsigned int max_sm_gs;
+ unsigned int max_sm_ps;
+ BOOL no_3d;
};
extern struct wined3d_settings wined3d_settings DECLSPEC_HIDDEN;
WINED3DSTT_VOLUME = 4,
};
+#define WINED3D_SHADER_CONST_VS_F 0x00000001
+#define WINED3D_SHADER_CONST_VS_I 0x00000002
+#define WINED3D_SHADER_CONST_VS_B 0x00000004
+#define WINED3D_SHADER_CONST_VS_POS_FIXUP 0x00000008
+#define WINED3D_SHADER_CONST_PS_F 0x00000010
+#define WINED3D_SHADER_CONST_PS_I 0x00000020
+#define WINED3D_SHADER_CONST_PS_B 0x00000040
+#define WINED3D_SHADER_CONST_PS_BUMP_ENV 0x00000080
+#define WINED3D_SHADER_CONST_PS_Y_CORR 0x00000100
+#define WINED3D_SHADER_CONST_PS_NP2_FIXUP 0x00000200
+#define WINED3D_SHADER_CONST_FFP_PS 0x00000400
+
enum wined3d_shader_register_type
{
WINED3DSPR_TEMP = 0,
WINED3DSPR_PREDICATE = 19,
WINED3DSPR_IMMCONST,
WINED3DSPR_CONSTBUFFER,
+ WINED3DSPR_PRIMID,
WINED3DSPR_NULL,
WINED3DSPR_RESOURCE,
};
+enum wined3d_data_type
+{
+ WINED3D_DATA_FLOAT,
+ WINED3D_DATA_INT,
+ WINED3D_DATA_RESOURCE,
+ WINED3D_DATA_SAMPLER,
+ WINED3D_DATA_UINT,
+};
+
enum wined3d_immconst_type
{
WINED3D_IMMCONST_SCALAR,
};
/* Undocumented opcode control to identify projective texture lookups in ps 2.0 and later */
-#define WINED3DSI_TEXLD_PROJECT 1
-#define WINED3DSI_TEXLD_BIAS 2
+#define WINED3DSI_TEXLD_PROJECT 0x1
+#define WINED3DSI_TEXLD_BIAS 0x2
+#define WINED3DSI_INDEXED_DYNAMIC 0x4
enum wined3d_shader_rel_op
{
#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_REG_INPUT 32
+#define MAX_REG_OUTPUT 32
#define MAX_CONST_I 16
#define MAX_CONST_B 16
+#define WINED3D_MAX_CBS 15
/* FIXME: This needs to go up to 2048 for
* Shader model 3 according to msdn (and for software shaders) */
#define MAX_LABELS 16
-#define SHADER_PGMSIZE 65535
-
struct wined3d_shader_buffer
{
char *buffer;
- unsigned int bsize;
+ unsigned int buffer_size;
+ unsigned int content_size;
unsigned int lineNo;
BOOL newline;
};
WINED3DSIH_CRS,
WINED3DSIH_CUT,
WINED3DSIH_DCL,
+ WINED3DSIH_DCL_CONSTANT_BUFFER,
+ WINED3DSIH_DCL_INPUT_PRIMITIVE,
+ WINED3DSIH_DCL_OUTPUT_TOPOLOGY,
+ WINED3DSIH_DCL_VERTICES_OUT,
WINED3DSIH_DEF,
WINED3DSIH_DEFB,
WINED3DSIH_DEFI,
DWORD temporary; /* MAX_REG_TEMP, 32 */
DWORD *constf; /* pixel, vertex */
DWORD texcoord_mask[MAX_REG_TEXCRD]; /* vertex < 3.0 */
- WORD input_registers; /* max(MAX_REG_INPUT, MAX_ATTRIBS), 16 */
- WORD output_registers; /* MAX_REG_OUTPUT, 12 */
+ DWORD input_registers; /* max(MAX_REG_INPUT, MAX_ATTRIBS), 32 */
+ DWORD output_registers; /* MAX_REG_OUTPUT, 32 */
WORD integer_constants; /* MAX_CONST_I, 16 */
WORD boolean_constants; /* MAX_CONST_B, 16 */
WORD local_int_consts; /* MAX_CONST_I, 16 */
WORD local_bool_consts; /* MAX_CONST_B, 16 */
+ UINT cb_sizes[WINED3D_MAX_CBS];
enum wined3d_sampler_texture_type sampler_type[max(MAX_FRAGMENT_SAMPLERS, MAX_VERTEX_SAMPLERS)];
BYTE bumpmat; /* MAX_TEXTURES, 8 */
void *backend_data;
};
+struct wined3d_shader_register_index
+{
+ const struct wined3d_shader_src_param *rel_addr;
+ unsigned int offset;
+};
+
struct wined3d_shader_register
{
enum wined3d_shader_register_type type;
- UINT idx;
- UINT array_idx;
- const struct wined3d_shader_src_param *rel_addr;
+ enum wined3d_data_type data_type;
+ struct wined3d_shader_register_index idx[2];
enum wined3d_immconst_type immconst_type;
DWORD immconst_data[4];
};
enum wined3d_shader_src_modifier modifiers;
};
+struct wined3d_shader_semantic
+{
+ enum wined3d_decl_usage usage;
+ UINT usage_idx;
+ enum wined3d_sampler_texture_type sampler_type;
+ struct wined3d_shader_dst_param reg;
+};
+
struct wined3d_shader_instruction
{
const struct wined3d_shader_context *ctx;
enum WINED3D_SHADER_INSTRUCTION_HANDLER handler_idx;
DWORD flags;
BOOL coissue;
- DWORD predicate;
+ const struct wined3d_shader_src_param *predicate;
UINT dst_count;
const struct wined3d_shader_dst_param *dst;
UINT src_count;
const struct wined3d_shader_src_param *src;
-};
-
-struct wined3d_shader_semantic
-{
- WINED3DDECLUSAGE usage;
- UINT usage_idx;
- enum wined3d_sampler_texture_type sampler_type;
- struct wined3d_shader_dst_param reg;
+ union
+ {
+ struct wined3d_shader_semantic semantic;
+ enum wined3d_primitive_type primitive_type;
+ struct wined3d_shader_src_param src;
+ UINT count;
+ } declaration;
};
struct wined3d_shader_attribute
{
- WINED3DDECLUSAGE usage;
+ enum wined3d_decl_usage usage;
UINT usage_idx;
};
void *(*shader_init)(const DWORD *ptr, const struct wined3d_shader_signature *output_signature);
void (*shader_free)(void *data);
void (*shader_read_header)(void *data, const DWORD **ptr, struct wined3d_shader_version *shader_version);
- 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);
- void (*shader_read_semantic)(const DWORD **ptr, struct wined3d_shader_semantic *semantic);
- void (*shader_read_comment)(const DWORD **ptr, const char **comment, UINT *comment_size);
+ void (*shader_read_instruction)(void *data, const DWORD **ptr, struct wined3d_shader_instruction *ins);
BOOL (*shader_is_end)(void *data, const DWORD **ptr);
};
typedef void (*SHADER_HANDLER)(const struct wined3d_shader_instruction *);
-struct shader_caps {
- DWORD VertexShaderVersion;
- DWORD MaxVertexShaderConst;
+#define WINED3D_SHADER_CAP_VS_CLIPPING 0x00000001
+#define WINED3D_SHADER_CAP_SRGB_WRITE 0x00000002
+
+struct shader_caps
+{
+ UINT vs_version;
+ UINT gs_version;
+ UINT ps_version;
- DWORD PixelShaderVersion;
- float PixelShader1xMaxValue;
- DWORD MaxPixelShaderConst;
+ DWORD vs_uniform_count;
+ DWORD ps_uniform_count;
+ float ps_1x_max_value;
- BOOL VSClipping;
+ DWORD wined3d_caps;
};
enum tex_types
#define WINED3D_CONST_NUM_UNUSED ~0U
-enum fogmode {
- FOG_OFF,
- FOG_LINEAR,
- FOG_EXP,
- FOG_EXP2
+enum wined3d_ffp_ps_fog_mode
+{
+ WINED3D_FFP_PS_FOG_OFF,
+ WINED3D_FFP_PS_FOG_LINEAR,
+ WINED3D_FFP_PS_FOG_EXP,
+ WINED3D_FFP_PS_FOG_EXP2,
};
/* Stateblock dependent parameters which have to be hardcoded
#define WINED3D_PSARGS_PROJECTED (1 << 3)
#define WINED3D_PSARGS_TEXTRANSFORM_SHIFT 4
#define WINED3D_PSARGS_TEXTRANSFORM_MASK 0xf
+#define WINED3D_PSARGS_TEXTYPE_SHIFT 2
+#define WINED3D_PSARGS_TEXTYPE_MASK 0x3
+
+/* Similar to tex_types, except that it doesn't have 1d textures
+ * (can't be bound), rect textures (handled via np2_fixup) and
+ * none / unknown (treated as 2d and handled via dummy textures). */
+enum wined3d_shader_tex_types
+{
+ WINED3D_SHADER_TEX_2D = 0,
+ WINED3D_SHADER_TEX_3D = 1,
+ WINED3D_SHADER_TEX_CUBE = 2,
+};
struct ps_compile_args {
struct color_fixup_desc color_fixup[MAX_FRAGMENT_SAMPLERS];
enum vertexprocessing_mode vp_mode;
- enum fogmode fog;
+ enum wined3d_ffp_ps_fog_mode fog;
WORD tex_transform; /* ps 1.0-1.3, 4 textures */
- /* Texture types(2D, Cube, 3D) in ps 1.x */
+ WORD tex_types; /* ps 1.0 - 1.4, 6 textures */
WORD srgb_correction;
WORD np2_fixup;
/* Bitmap for NP2 texcoord fixups (16 samplers max currently).
struct wined3d_context;
struct wined3d_state;
+struct fragment_pipeline;
+struct wined3d_vertex_pipe_ops;
struct wined3d_shader_backend_ops
{
void (*shader_handle_instruction)(const struct wined3d_shader_instruction *);
- void (*shader_select)(const struct wined3d_context *context, BOOL usePS, BOOL useVS);
+ void (*shader_select)(void *shader_priv, struct wined3d_context *context,
+ const struct wined3d_state *state);
+ void (*shader_disable)(void *shader_priv, struct wined3d_context *context);
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);
void (*shader_deselect_depth_blt)(void *shader_priv, const struct wined3d_gl_info *gl_info);
void (*shader_update_float_vertex_constants)(struct wined3d_device *device, UINT start, UINT count);
void (*shader_update_float_pixel_constants)(struct wined3d_device *device, UINT start, UINT count);
- void (*shader_load_constants)(const struct wined3d_context *context, char usePS, char useVS);
- void (*shader_load_np2fixup_constants)(void *shader_priv, const struct wined3d_gl_info *gl_info,
+ void (*shader_load_constants)(void *shader_priv, struct wined3d_context *context,
const struct wined3d_state *state);
void (*shader_destroy)(struct wined3d_shader *shader);
- HRESULT (*shader_alloc_private)(struct wined3d_device *device);
+ HRESULT (*shader_alloc_private)(struct wined3d_device *device, const struct wined3d_vertex_pipe_ops *vertex_pipe,
+ const struct fragment_pipeline *fragment_pipe);
void (*shader_free_private)(struct wined3d_device *device);
- void (*shader_context_destroyed)(void *shader_priv, const struct wined3d_context *context);
+ BOOL (*shader_allocate_context_data)(struct wined3d_context *context);
+ void (*shader_free_context_data)(struct wined3d_context *context);
void (*shader_get_caps)(const struct wined3d_gl_info *gl_info, struct shader_caps *caps);
BOOL (*shader_color_fixup_supported)(struct color_fixup_desc fixup);
+ BOOL (*shader_has_ffp_proj_control)(void *shader_priv);
};
extern const struct wined3d_shader_backend_ops glsl_shader_backend DECLSPEC_HIDDEN;
extern const struct wined3d_shader_backend_ops arb_program_shader_backend DECLSPEC_HIDDEN;
extern const struct wined3d_shader_backend_ops none_shader_backend DECLSPEC_HIDDEN;
-/* X11 locking */
-
-extern void (CDECL *wine_tsx11_lock_ptr)(void) DECLSPEC_HIDDEN;
-extern void (CDECL *wine_tsx11_unlock_ptr)(void) DECLSPEC_HIDDEN;
-
-/* As GLX relies on X, this is needed */
-extern int num_lock DECLSPEC_HIDDEN;
-
-#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
- */
-
-/* GL related defines */
-/* ------------------ */
-#define GL_EXTCALL(f) (gl_info->f)
+#define GL_EXTCALL(f) (gl_info->gl_ops.ext.p_##f)
-#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)
+#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)
-#define D3DCOLOR_R(dw) (((float) (((dw) >> 16) & 0xFF)) / 255.0f)
-#define D3DCOLOR_G(dw) (((float) (((dw) >> 8) & 0xFF)) / 255.0f)
-#define D3DCOLOR_B(dw) (((float) (((dw) >> 0) & 0xFF)) / 255.0f)
-#define D3DCOLOR_A(dw) (((float) (((dw) >> 24) & 0xFF)) / 255.0f)
+#define D3DCOLOR_R(dw) (((float) (((dw) >> 16) & 0xff)) / 255.0f)
+#define D3DCOLOR_G(dw) (((float) (((dw) >> 8) & 0xff)) / 255.0f)
+#define D3DCOLOR_B(dw) (((float) (((dw) >> 0) & 0xff)) / 255.0f)
+#define D3DCOLOR_A(dw) (((float) (((dw) >> 24) & 0xff)) / 255.0f)
#define D3DCOLORTOGLFLOAT4(dw, vec) do { \
(vec)[0] = D3DCOLOR_R(dw); \
do { \
GLint err; \
if (!__WINE_IS_DEBUG_ON(_ERR, __wine_dbch___default)) break; \
- err = glGetError(); \
+ err = gl_info->gl_ops.gl.p_glGetError(); \
if (err == GL_NO_ERROR) { \
TRACE("%s call ok %s / %d\n", A, __FILE__, __LINE__); \
\
} else do { \
ERR(">>>>>>>>>>>>>>>>> %s (%#x) from %s @ %s / %d\n", \
debug_glerror(err), err, A, __FILE__, __LINE__); \
- err = glGetError(); \
+ err = gl_info->gl_ops.gl.p_glGetError(); \
} while (err != GL_NO_ERROR); \
} while(0)
#else
#define checkGLcall(A) do {} while(0)
#endif
-/* Trace routines / diagnostics */
-/* ---------------------------- */
-
-/* Dump out a matrix and copy it */
-#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)
-
-/* Trace vector and strided data information */
-#define TRACE_STRIDED(si, name) do { if (si->use_map & (1 << name)) \
- TRACE( #name " = (data {%#x:%p}, stride %d, format %s, stream %u)\n", \
- si->elements[name].data.buffer_object, si->elements[name].data.addr, si->elements[name].stride, \
- debug_d3dformat(si->elements[name].format->id), si->elements[name].stream_idx); } while(0)
-
-/* Global variables */
-extern const float identity[16] DECLSPEC_HIDDEN;
-
enum wined3d_ffp_idx
{
WINED3D_FFP_POSITION = 0,
WINED3D_FFP_EMIT_DEC3N = 14,
WINED3D_FFP_EMIT_FLOAT16_2 = 15,
WINED3D_FFP_EMIT_FLOAT16_4 = 16,
- WINED3D_FFP_EMIT_COUNT = 17
+ WINED3D_FFP_EMIT_INVALID = 17,
+ WINED3D_FFP_EMIT_COUNT = 18
};
struct wined3d_bo_address
{
GLuint buffer_object;
- const BYTE *addr;
+ BYTE *addr;
};
struct wined3d_stream_info_element
struct wined3d_stream_info
{
struct wined3d_stream_info_element elements[MAX_ATTRIBS];
- BOOL position_transformed;
+ DWORD position_transformed : 1;
+ DWORD all_vbo : 1;
WORD swizzle_map; /* MAX_ATTRIBS, 16 */
WORD use_map; /* MAX_ATTRIBS, 16 */
};
-/*****************************************************************************
- * Prototypes
- */
-
-/* Routine common to the draw primitive and draw indexed primitive routines */
-void drawPrimitive(struct wined3d_device *device, UINT index_count,
- UINT start_idx, UINT idxBytes, const void *idxData) DECLSPEC_HIDDEN;
+void draw_primitive(struct wined3d_device *device, UINT start_idx, UINT index_count,
+ UINT start_instance, UINT instance_count, BOOL indexed) DECLSPEC_HIDDEN;
DWORD get_flexible_vertex_size(DWORD d3dvtVertexType) DECLSPEC_HIDDEN;
-typedef void (WINE_GLAPI *glAttribFunc)(const void *data);
-typedef void (WINE_GLAPI *glMultiTexCoordFunc)(GLenum unit, const void *data);
-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;
-
#define eps 1e-8
#define GET_TEXCOORD_SIZE_FROM_FVF(d3dvtVertexType, tex_num) \
#define STATE_VSHADER (STATE_VDECL + 1)
#define STATE_IS_VSHADER(a) ((a) == STATE_VSHADER)
-#define STATE_VIEWPORT (STATE_VSHADER + 1)
-#define STATE_IS_VIEWPORT(a) ((a) == STATE_VIEWPORT)
+#define STATE_GEOMETRY_SHADER (STATE_VSHADER + 1)
+#define STATE_IS_GEOMETRY_SHADER(a) ((a) == STATE_GEOMETRY_SHADER)
-#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)
+#define STATE_VIEWPORT (STATE_GEOMETRY_SHADER + 1)
+#define STATE_IS_VIEWPORT(a) ((a) == STATE_VIEWPORT)
-#define STATE_ACTIVELIGHT(a) (STATE_PIXELSHADERCONSTANT + (a) + 1)
+#define STATE_LIGHT_TYPE (STATE_VIEWPORT + 1)
+#define STATE_IS_LIGHT_TYPE(a) ((a) == STATE_LIGHT_TYPE)
+#define STATE_ACTIVELIGHT(a) (STATE_LIGHT_TYPE + 1 + (a))
#define STATE_IS_ACTIVELIGHT(a) ((a) >= STATE_ACTIVELIGHT(0) && (a) < STATE_ACTIVELIGHT(MAX_ACTIVE_LIGHTS))
#define STATE_SCISSORRECT (STATE_ACTIVELIGHT(MAX_ACTIVE_LIGHTS - 1) + 1)
#define STATE_FRAMEBUFFER (STATE_BASEVERTEXINDEX + 1)
#define STATE_IS_FRAMEBUFFER(a) ((a) == STATE_FRAMEBUFFER)
-#define STATE_HIGHEST (STATE_FRAMEBUFFER)
+#define STATE_POINT_SIZE_ENABLE (STATE_FRAMEBUFFER + 1)
+#define STATE_IS_POINT_SIZE_ENABLE(a) ((a) == STATE_POINT_SIZE_ENABLE)
+
+#define STATE_HIGHEST (STATE_POINT_SIZE_ENABLE)
enum fogsource {
FOGSOURCE_FFP,
FOGSOURCE_COORD,
};
-#define WINED3D_MAX_FBO_ENTRIES 64
-
struct wined3d_occlusion_query
{
struct list entry;
struct wined3d_context
{
const struct wined3d_gl_info *gl_info;
+ const struct wined3d_d3d_info *d3d_info;
const struct StateEntry *state_table;
/* State dirtification
* dirtyArray is an array that contains markers for dirty states. numDirtyEntries states are dirty, their numbers are in indices
DWORD tid; /* Thread ID which owns this context at the moment */
/* Stores some information about the context state for optimization */
- WORD render_offscreen : 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 */
- WORD current : 1;
- WORD destroyed : 1;
- WORD valid : 1;
- WORD padding : 1;
- BYTE texShaderBumpMap; /* MAX_TEXTURES, 8 */
- BYTE lastWasPow2Texture; /* MAX_TEXTURES, 8 */
+ DWORD render_offscreen : 1;
+ DWORD last_was_rhw : 1; /* true iff last draw_primitive was in xyzrhw mode */
+ DWORD last_was_pshader : 1;
+ DWORD last_was_vshader : 1;
+ DWORD namedArraysLoaded : 1;
+ DWORD numberedArraysLoaded : 1;
+ DWORD last_was_blit : 1;
+ DWORD last_was_ckey : 1;
+ DWORD fog_coord : 1;
+ DWORD fog_enabled : 1;
+ DWORD num_untracked_materials : 2; /* Max value 2 */
+ DWORD current : 1;
+ DWORD destroyed : 1;
+ DWORD valid : 1;
+ DWORD padding : 1;
+ DWORD texShaderBumpMap : 8; /* MAX_TEXTURES, 8 */
+ DWORD lastWasPow2Texture : 8; /* MAX_TEXTURES, 8 */
+ DWORD shader_update_mask;
+ DWORD constant_update_mask;
DWORD numbered_array_mask;
GLenum tracking_parm; /* Which source is tracking current colour */
GLenum untracked_materials[2];
int pixel_format;
GLint aux_buffers;
+ void *shader_backend_data;
+
/* FBOs */
UINT fbo_entry_count;
struct list fbo_list;
enum wined3d_gl_extension extension;
};
+#define WINED3D_FRAGMENT_CAP_PROJ_CONTROL 0x00000001
+#define WINED3D_FRAGMENT_CAP_SRGB_WRITE 0x00000002
+
struct fragment_caps
{
+ DWORD wined3d_caps;
DWORD PrimitiveMiscCaps;
DWORD TextureOpCaps;
DWORD MaxTextureBlendStages;
struct fragment_pipeline
{
- void (*enable_extension)(BOOL enable);
+ void (*enable_extension)(const struct wined3d_gl_info *gl_info, BOOL enable);
void (*get_caps)(const struct wined3d_gl_info *gl_info, struct fragment_caps *caps);
- HRESULT (*alloc_private)(struct wined3d_device *device);
+ void *(*alloc_private)(const struct wined3d_shader_backend_ops *shader_backend, void *shader_priv);
void (*free_private)(struct wined3d_device *device);
BOOL (*color_fixup_supported)(struct color_fixup_desc fixup);
const struct StateEntryTemplate *states;
- BOOL ffp_proj_control;
+};
+
+struct wined3d_vertex_caps
+{
+ BOOL xyzrhw;
+ DWORD max_active_lights;
+ DWORD max_vertex_blend_matrices;
+ DWORD max_vertex_blend_matrix_index;
+ DWORD vertex_processing_caps;
+ DWORD fvf_caps;
+ DWORD max_user_clip_planes;
+ DWORD raster_caps;
+};
+
+struct wined3d_vertex_pipe_ops
+{
+ void (*vp_enable)(const struct wined3d_gl_info *gl_info, BOOL enable);
+ void (*vp_get_caps)(const struct wined3d_gl_info *gl_info, struct wined3d_vertex_caps *caps);
+ void *(*vp_alloc)(const struct wined3d_shader_backend_ops *shader_backend, void *shader_priv);
+ void (*vp_free)(struct wined3d_device *device);
+ const struct StateEntryTemplate *vp_states;
};
extern const struct StateEntryTemplate misc_state_template[] DECLSPEC_HIDDEN;
-extern const struct StateEntryTemplate ffp_vertexstate_template[] DECLSPEC_HIDDEN;
+extern const struct fragment_pipeline none_fragment_pipe 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;
+extern const struct fragment_pipeline glsl_fragment_pipe DECLSPEC_HIDDEN;
+
+extern const struct wined3d_vertex_pipe_ops none_vertex_pipe DECLSPEC_HIDDEN;
+extern const struct wined3d_vertex_pipe_ops ffp_vertex_pipe DECLSPEC_HIDDEN;
+extern const struct wined3d_vertex_pipe_ops glsl_vertex_pipe DECLSPEC_HIDDEN;
/* "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,
- const struct fragment_pipeline *fragment, const struct StateEntryTemplate *misc) DECLSPEC_HIDDEN;
+ const struct wined3d_gl_info *gl_info, const struct wined3d_d3d_info *d3d_info,
+ const struct wined3d_vertex_pipe_ops *vertex, const struct fragment_pipeline *fragment,
+ const struct StateEntryTemplate *misc) DECLSPEC_HIDDEN;
enum wined3d_blit_op
{
void context_check_fbo_status(const struct wined3d_context *context, GLenum target) DECLSPEC_HIDDEN;
struct wined3d_context *context_create(struct wined3d_swapchain *swapchain, struct wined3d_surface *target,
const struct wined3d_format *ds_format) DECLSPEC_HIDDEN;
+BOOL context_debug_output_enabled(const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
void context_destroy(struct wined3d_device *device, struct wined3d_context *context) DECLSPEC_HIDDEN;
void context_free_event_query(struct wined3d_event_query *query) DECLSPEC_HIDDEN;
void context_free_occlusion_query(struct wined3d_occlusion_query *query) DECLSPEC_HIDDEN;
CARD_AMD_RADEON_HD2600 = 0x9581,
CARD_AMD_RADEON_HD2900 = 0x9400,
CARD_AMD_RADEON_HD3200 = 0x9620,
+ CARD_AMD_RADEON_HD4200M = 0x9712,
CARD_AMD_RADEON_HD4350 = 0x954f,
- CARD_AMD_RADEON_HD4550 = 0x9540,
CARD_AMD_RADEON_HD4600 = 0x9495,
- CARD_AMD_RADEON_HD4650 = 0x9498,
- CARD_AMD_RADEON_HD4670 = 0x9490,
CARD_AMD_RADEON_HD4700 = 0x944e,
- CARD_AMD_RADEON_HD4770 = 0x94b3,
- CARD_AMD_RADEON_HD4800 = 0x944c, /* Picked one value between 9440, 944c, 9442, 9460 */
- CARD_AMD_RADEON_HD4830 = 0x944c,
- CARD_AMD_RADEON_HD4850 = 0x9442,
- CARD_AMD_RADEON_HD4870 = 0x9440,
- CARD_AMD_RADEON_HD4890 = 0x9460,
+ CARD_AMD_RADEON_HD4800 = 0x944c,
CARD_AMD_RADEON_HD5400 = 0x68f9,
CARD_AMD_RADEON_HD5600 = 0x68d8,
- CARD_AMD_RADEON_HD5700 = 0x68BE, /* Picked HD5750 */
- CARD_AMD_RADEON_HD5750 = 0x68BE,
- CARD_AMD_RADEON_HD5770 = 0x68B8,
- CARD_AMD_RADEON_HD5800 = 0x6898, /* Picked HD5850 */
- CARD_AMD_RADEON_HD5850 = 0x6898,
- CARD_AMD_RADEON_HD5870 = 0x6899,
+ CARD_AMD_RADEON_HD5700 = 0x68be,
+ CARD_AMD_RADEON_HD5800 = 0x6898,
CARD_AMD_RADEON_HD5900 = 0x689c,
CARD_AMD_RADEON_HD6300 = 0x9803,
CARD_AMD_RADEON_HD6400 = 0x6770,
CARD_AMD_RADEON_HD6550D = 0x9640,
CARD_AMD_RADEON_HD6600 = 0x6758,
CARD_AMD_RADEON_HD6600M = 0x6741,
+ CARD_AMD_RADEON_HD6700 = 0x68ba,
CARD_AMD_RADEON_HD6800 = 0x6739,
CARD_AMD_RADEON_HD6900 = 0x6719,
+ CARD_AMD_RADEON_HD7700 = 0x683d,
+ CARD_AMD_RADEON_HD7800 = 0x6819,
+ CARD_AMD_RADEON_HD7900 = 0x679a,
CARD_NVIDIA_RIVA_128 = 0x0018,
CARD_NVIDIA_RIVA_TNT = 0x0020,
CARD_NVIDIA_GEFORCE_7300 = 0x01d7, /* GeForce Go 7300 */
CARD_NVIDIA_GEFORCE_7600 = 0x0391,
CARD_NVIDIA_GEFORCE_7800GT = 0x0092,
- CARD_NVIDIA_GEFORCE_8100 = 0x084F,
- CARD_NVIDIA_GEFORCE_8200 = 0x0849, /* Other PCI ID 0x084B */
+ CARD_NVIDIA_GEFORCE_8200 = 0x0849, /* Other PCI ID 0x084b */
CARD_NVIDIA_GEFORCE_8300GS = 0x0423,
CARD_NVIDIA_GEFORCE_8400GS = 0x0404,
CARD_NVIDIA_GEFORCE_8500GT = 0x0421,
CARD_NVIDIA_GEFORCE_8800GTS = 0x0193,
CARD_NVIDIA_GEFORCE_8800GTX = 0x0191,
CARD_NVIDIA_GEFORCE_9200 = 0x086d,
+ CARD_NVIDIA_GEFORCE_9300 = 0x086c,
+ CARD_NVIDIA_GEFORCE_9400M = 0x0863,
CARD_NVIDIA_GEFORCE_9400GT = 0x042c,
CARD_NVIDIA_GEFORCE_9500GT = 0x0640,
CARD_NVIDIA_GEFORCE_9600GT = 0x0622,
CARD_NVIDIA_GEFORCE_GTX260 = 0x05e2,
CARD_NVIDIA_GEFORCE_GTX275 = 0x05e6,
CARD_NVIDIA_GEFORCE_GTX280 = 0x05e1,
+ CARD_NVIDIA_GEFORCE_315M = 0x0a7a,
+ CARD_NVIDIA_GEFORCE_320M = 0x08a3,
CARD_NVIDIA_GEFORCE_GT320M = 0x0a2d,
CARD_NVIDIA_GEFORCE_GT325M = 0x0a35,
CARD_NVIDIA_GEFORCE_GT330 = 0x0ca0,
CARD_NVIDIA_GEFORCE_GTS350M = 0x0cb0,
+ CARD_NVIDIA_GEFORCE_410M = 0x1055,
CARD_NVIDIA_GEFORCE_GT420 = 0x0de2,
CARD_NVIDIA_GEFORCE_GT430 = 0x0de1,
CARD_NVIDIA_GEFORCE_GT440 = 0x0de0,
CARD_NVIDIA_GEFORCE_GTX465 = 0x06c4,
CARD_NVIDIA_GEFORCE_GTX470 = 0x06cd,
CARD_NVIDIA_GEFORCE_GTX480 = 0x06c0,
+ CARD_NVIDIA_GEFORCE_GT520 = 0x1040,
CARD_NVIDIA_GEFORCE_GT540M = 0x0df4,
CARD_NVIDIA_GEFORCE_GTX550 = 0x1244,
CARD_NVIDIA_GEFORCE_GT555M = 0x04b8,
CARD_NVIDIA_GEFORCE_GTX560 = 0x1201,
CARD_NVIDIA_GEFORCE_GTX570 = 0x1081,
CARD_NVIDIA_GEFORCE_GTX580 = 0x1080,
+ CARD_NVIDIA_GEFORCE_GT610 = 0x104a,
+ CARD_NVIDIA_GEFORCE_GT630 = 0x0f00,
+ CARD_NVIDIA_GEFORCE_GT630M = 0x0de9,
+ CARD_NVIDIA_GEFORCE_GT640M = 0x0fd2,
+ CARD_NVIDIA_GEFORCE_GT650M = 0x0fd1,
+ CARD_NVIDIA_GEFORCE_GTX650 = 0x0fc6,
+ CARD_NVIDIA_GEFORCE_GTX650TI = 0x11c6,
+ CARD_NVIDIA_GEFORCE_GTX660 = 0x11c0,
+ CARD_NVIDIA_GEFORCE_GTX660TI = 0x1183,
+ CARD_NVIDIA_GEFORCE_GTX670 = 0x1189,
+ CARD_NVIDIA_GEFORCE_GTX670MX = 0x11a1,
+ CARD_NVIDIA_GEFORCE_GTX680 = 0x1180,
+ CARD_NVIDIA_GEFORCE_GTX770M = 0x11e0,
+ CARD_NVIDIA_GEFORCE_GTX770 = 0x1184,
CARD_INTEL_830M = 0x3577,
CARD_INTEL_855GM = 0x3582,
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;
+ GLboolean (WINE_GLAPI *glIsRenderbuffer)(GLuint renderbuffer);
+ void (WINE_GLAPI *glBindRenderbuffer)(GLenum target, GLuint renderbuffer);
+ void (WINE_GLAPI *glDeleteRenderbuffers)(GLsizei n, const GLuint *renderbuffers);
+ void (WINE_GLAPI *glGenRenderbuffers)(GLsizei n, GLuint *renderbuffers);
+ void (WINE_GLAPI *glRenderbufferStorage)(GLenum target, GLenum internalformat,
+ GLsizei width, GLsizei height);
+ void (WINE_GLAPI *glRenderbufferStorageMultisample)(GLenum target, GLsizei samples,
+ GLenum internalformat, GLsizei width, GLsizei height);
+ void (WINE_GLAPI *glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint *params);
+ GLboolean (WINE_GLAPI *glIsFramebuffer)(GLuint framebuffer);
+ void (WINE_GLAPI *glBindFramebuffer)(GLenum target, GLuint framebuffer);
+ void (WINE_GLAPI *glDeleteFramebuffers)(GLsizei n, const GLuint *framebuffers);
+ void (WINE_GLAPI *glGenFramebuffers)(GLsizei n, GLuint *framebuffers);
+ GLenum (WINE_GLAPI *glCheckFramebufferStatus)(GLenum target);
+ void (WINE_GLAPI *glFramebufferTexture1D)(GLenum target, GLenum attachment,
+ GLenum textarget, GLuint texture, GLint level);
+ void (WINE_GLAPI *glFramebufferTexture2D)(GLenum target, GLenum attachment,
+ GLenum textarget, GLuint texture, GLint level);
+ void (WINE_GLAPI *glFramebufferTexture3D)(GLenum target, GLenum attachment,
+ GLenum textarget, GLuint texture, GLint level, GLint layer);
+ void (WINE_GLAPI *glFramebufferRenderbuffer)(GLenum target, GLenum attachment,
+ GLenum renderbuffertarget, GLuint renderbuffer);
+ void (WINE_GLAPI *glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment,
+ GLenum pname, GLint *params);
+ void (WINE_GLAPI *glBlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
+ GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
+ void (WINE_GLAPI *glGenerateMipmap)(GLenum target);
};
struct wined3d_gl_limits
UINT buffers;
UINT lights;
UINT textures;
- UINT texture_stages;
UINT texture_coords;
UINT fragment_samplers;
UINT vertex_samplers;
UINT combined_samplers;
UINT general_combiners;
- UINT sampler_stages;
UINT clipplanes;
UINT texture_size;
UINT texture3d_size;
{
DWORD glsl_version;
struct wined3d_gl_limits limits;
- DWORD reserved_glsl_constants;
+ DWORD reserved_glsl_constants, reserved_arb_constants;
DWORD quirks;
BOOL supported[WINED3D_GL_EXT_COUNT];
GLint wrap_lookup[WINED3D_TADDRESS_MIRROR_ONCE - WINED3D_TADDRESS_WRAP + 1];
+ HGLRC (WINAPI *p_wglCreateContextAttribsARB)(HDC dc, HGLRC share, const GLint *attribs);
+ struct opengl_funcs gl_ops;
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
struct wined3d_format *formats;
};
DWORD version_low;
};
+struct wined3d_d3d_limits
+{
+ UINT vs_version, gs_version, ps_version;
+ DWORD vs_uniform_count;
+ DWORD ps_uniform_count;
+ UINT ffp_textures;
+ UINT ffp_blend_stages;
+};
+
+typedef void (WINE_GLAPI *wined3d_ffp_attrib_func)(const void *data);
+typedef void (WINE_GLAPI *wined3d_ffp_texcoord_func)(GLenum unit, const void *data);
+extern wined3d_ffp_attrib_func specular_func_3ubv DECLSPEC_HIDDEN;
+
+struct wined3d_ffp_attrib_ops
+{
+ wined3d_ffp_attrib_func position[WINED3D_FFP_EMIT_COUNT];
+ wined3d_ffp_attrib_func diffuse[WINED3D_FFP_EMIT_COUNT];
+ wined3d_ffp_attrib_func specular[WINED3D_FFP_EMIT_COUNT];
+ wined3d_ffp_attrib_func normal[WINED3D_FFP_EMIT_COUNT];
+ wined3d_ffp_texcoord_func texcoord[WINED3D_FFP_EMIT_COUNT];
+};
+
+struct wined3d_d3d_info
+{
+ struct wined3d_d3d_limits limits;
+ struct wined3d_ffp_attrib_ops ffp_attrib_ops;
+ BOOL xyzrhw;
+ BOOL vs_clipping;
+ DWORD valid_rt_mask;
+};
+
/* The adapter structure */
struct wined3d_adapter
{
UINT ordinal;
- BOOL opengl;
-
POINT monitorPoint;
- SIZE screen_size;
enum wined3d_format_id screen_format;
struct wined3d_gl_info gl_info;
+ struct wined3d_d3d_info d3d_info;
struct wined3d_driver_info driver_info;
WCHAR DeviceName[CCHDEVICENAME]; /* DeviceName for use with e.g. ChangeDisplaySettings */
unsigned int cfg_count;
unsigned int UsedTextureRam;
LUID luid;
+ const struct wined3d_vertex_pipe_ops *vertex_pipe;
const struct fragment_pipeline *fragment_pipe;
const struct wined3d_shader_backend_ops *shader_backend;
const struct blit_shader *blitter;
};
+BOOL wined3d_adapter_init_format_info(struct wined3d_adapter *adapter) DECLSPEC_HIDDEN;
unsigned int adapter_adjust_memory(struct wined3d_adapter *adapter, int amount) DECLSPEC_HIDDEN;
-BOOL initPixelFormats(struct wined3d_gl_info *gl_info, enum wined3d_pci_vendor vendor) DECLSPEC_HIDDEN;
BOOL initPixelFormatsNoGL(struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
extern void add_gl_compat_wrappers(struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
-/*****************************************************************************
- * High order patch management
- */
-struct WineD3DRectPatch
-{
- UINT Handle;
- float *mem;
- struct wined3d_strided_data strided;
- struct wined3d_rect_patch_info rect_patch_info;
- float numSegs[4];
- char has_normals, has_texcoords;
- struct list entry;
-};
-
-HRESULT tesselate_rectpatch(struct wined3d_device *device, struct WineD3DRectPatch *patch) DECLSPEC_HIDDEN;
-
enum projection_types
{
proj_none = 0,
unsigned padding : 10;
};
-struct ffp_frag_settings {
- struct texture_stage_op op[MAX_TEXTURES];
- enum fogmode fog;
+struct ffp_frag_settings
+{
+ struct texture_stage_op op[MAX_TEXTURES];
+ enum wined3d_ffp_ps_fog_mode fog;
/* Use shorts instead of chars to get dword alignment */
unsigned short sRGB_write;
unsigned short emul_clipplanes;
};
extern const struct wine_rb_functions wined3d_ffp_frag_program_rb_functions DECLSPEC_HIDDEN;
+extern const struct wine_rb_functions wined3d_ffp_vertex_program_rb_functions DECLSPEC_HIDDEN;
extern const struct wined3d_parent_ops wined3d_null_parent_ops DECLSPEC_HIDDEN;
-void gen_ffp_frag_op(const struct wined3d_device *device, const struct wined3d_state *state,
+void gen_ffp_frag_op(const struct wined3d_context *context, const struct wined3d_state *state,
struct ffp_frag_settings *settings, BOOL ignore_textype) DECLSPEC_HIDDEN;
const struct ffp_frag_desc *find_ffp_frag_shader(const struct wine_rb_tree *fragment_shaders,
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;
void wined3d_get_draw_rect(const struct wined3d_state *state, RECT *rect) DECLSPEC_HIDDEN;
+enum wined3d_ffp_vs_fog_mode
+{
+ WINED3D_FFP_VS_FOG_OFF = 0,
+ WINED3D_FFP_VS_FOG_FOGCOORD = 1,
+ WINED3D_FFP_VS_FOG_DEPTH = 2,
+ WINED3D_FFP_VS_FOG_RANGE = 3,
+};
+
+#define WINED3D_FFP_TCI_SHIFT 16
+#define WINED3D_FFP_TCI_MASK 0xff
+
+#define WINED3D_FFP_LIGHT_TYPE_SHIFT(idx) (3 * (idx))
+#define WINED3D_FFP_LIGHT_TYPE_MASK 0x7
+
+struct wined3d_ffp_vs_settings
+{
+ DWORD light_type : 24; /* MAX_ACTIVE_LIGHTS, 8 * 3 */
+ DWORD diffuse_source : 2;
+ DWORD emission_source : 2;
+ DWORD ambient_source : 2;
+ DWORD specular_source : 2;
+
+ DWORD transformed : 1;
+ DWORD clipping : 1;
+ DWORD normal : 1;
+ DWORD normalize : 1;
+ DWORD lighting : 1;
+ DWORD localviewer : 1;
+ DWORD point_size : 1;
+ DWORD fog_mode : 2;
+ DWORD texcoords : 8; /* MAX_TEXTURES */
+ DWORD ortho_fog : 1;
+ DWORD padding : 14;
+
+ BYTE texgen[MAX_TEXTURES];
+};
+
+struct wined3d_ffp_vs_desc
+{
+ struct wine_rb_entry entry;
+ struct wined3d_ffp_vs_settings settings;
+};
+
+void wined3d_ffp_get_vs_settings(const struct wined3d_state *state, const struct wined3d_stream_info *si,
+ struct wined3d_ffp_vs_settings *settings) DECLSPEC_HIDDEN;
+
struct wined3d
{
LONG ref;
- void *parent;
DWORD flags;
UINT dxVersion;
UINT adapter_count;
struct wined3d_adapter adapters[1];
};
-HRESULT wined3d_init(struct wined3d *wined3d, UINT version, DWORD flags, void *parent) DECLSPEC_HIDDEN;
+HRESULT wined3d_init(struct wined3d *wined3d, UINT version, DWORD flags) DECLSPEC_HIDDEN;
BOOL wined3d_register_window(HWND window, struct wined3d_device *device) DECLSPEC_HIDDEN;
void wined3d_unregister_window(HWND window) DECLSPEC_HIDDEN;
+struct wined3d_stream_output
+{
+ struct wined3d_buffer *buffer;
+ UINT offset;
+};
+
+struct wined3d_stream_state
+{
+ struct wined3d_buffer *buffer;
+ UINT offset;
+ UINT stride;
+ UINT frequency;
+ UINT flags;
+};
+
+struct wined3d_state
+{
+ const struct wined3d_fb_state *fb;
+
+ struct wined3d_vertex_declaration *vertex_declaration;
+ struct wined3d_stream_output stream_output[MAX_STREAM_OUT];
+ struct wined3d_stream_state streams[MAX_STREAMS + 1 /* tesselated pseudo-stream */];
+ struct wined3d_buffer *index_buffer;
+ enum wined3d_format_id index_format;
+ INT base_vertex_index;
+ INT load_base_vertex_index; /* Non-indexed drawing needs 0 here, indexed needs base_vertex_index. */
+ GLenum gl_primitive_type;
+
+ struct wined3d_shader *vertex_shader;
+ struct wined3d_buffer *vs_cb[MAX_CONSTANT_BUFFERS];
+ struct wined3d_sampler *vs_sampler[MAX_SAMPLER_OBJECTS];
+ BOOL vs_consts_b[MAX_CONST_B];
+ INT vs_consts_i[MAX_CONST_I * 4];
+ float *vs_consts_f;
+
+ struct wined3d_shader *geometry_shader;
+ struct wined3d_buffer *gs_cb[MAX_CONSTANT_BUFFERS];
+ struct wined3d_sampler *gs_sampler[MAX_SAMPLER_OBJECTS];
+
+ struct wined3d_shader *pixel_shader;
+ struct wined3d_buffer *ps_cb[MAX_CONSTANT_BUFFERS];
+ struct wined3d_sampler *ps_sampler[MAX_SAMPLER_OBJECTS];
+ BOOL ps_consts_b[MAX_CONST_B];
+ INT ps_consts_i[MAX_CONST_I * 4];
+ float *ps_consts_f;
+
+ struct wined3d_texture *textures[MAX_COMBINED_SAMPLERS];
+ DWORD sampler_states[MAX_COMBINED_SAMPLERS][WINED3D_HIGHEST_SAMPLER_STATE + 1];
+ DWORD texture_states[MAX_TEXTURES][WINED3D_HIGHEST_TEXTURE_STATE + 1];
+ DWORD lowest_disabled_stage;
+
+ struct wined3d_matrix transforms[HIGHEST_TRANSFORMSTATE + 1];
+ struct wined3d_vec4 clip_planes[MAX_CLIPPLANES];
+ struct wined3d_material material;
+ struct wined3d_viewport viewport;
+ RECT scissor_rect;
+
+ /* Light hashmap. Collisions are handled using linked lists. */
+#define LIGHTMAP_SIZE 43
+#define LIGHTMAP_HASHFUNC(x) ((x) % LIGHTMAP_SIZE)
+ struct list light_map[LIGHTMAP_SIZE];
+ const struct wined3d_light_info *lights[MAX_ACTIVE_LIGHTS];
+
+ DWORD render_states[WINEHIGHEST_RENDER_STATE + 1];
+};
+
/*****************************************************************************
* IWineD3DDevice implementation structure
*/
/* X and GL Information */
GLenum offscreenBuffer;
- /* Selected capabilities */
- int vs_selected_mode;
- int ps_selected_mode;
const struct wined3d_shader_backend_ops *shader_backend;
void *shader_priv;
void *fragment_priv;
+ void *vertex_priv;
void *blit_priv;
struct StateEntry StateTable[STATE_HIGHEST + 1];
/* Array of functions for states which are handled by more than one pipeline part */
APPLYSTATEFUNC *multistate_funcs[STATE_HIGHEST + 1];
- const struct fragment_pipeline *frag_pipe;
const struct blit_shader *blitter;
- unsigned int max_ffp_textures;
- DWORD vshader_version, pshader_version;
- DWORD d3d_vshader_constantF, d3d_pshader_constantF; /* Advertised d3d caps, not GL ones */
- DWORD vs_clipping;
+ UINT instance_count;
- WORD view_ident : 1; /* true iff view matrix is identity */
WORD vertexBlendUsed : 1; /* To avoid needless setting of the blend matrices */
- WORD isRecordingState : 1;
WORD isInDraw : 1;
WORD bCursorVisible : 1;
WORD d3d_initialized : 1;
WORD inScene : 1; /* A flag to check for proper BeginScene / EndScene call pairs */
WORD softwareVertexProcessing : 1; /* process vertex shaders using software or hardware */
WORD useDrawStridedSlow : 1;
- WORD instancedDraw : 1;
WORD filter_messages : 1;
- WORD padding : 5;
+ WORD padding : 8;
BYTE fixed_function_usage_map; /* MAX_TEXTURES, 8 */
-#define DDRAW_PITCH_ALIGNMENT 8
-#define D3D8_PITCH_ALIGNMENT 4
unsigned char surface_alignment; /* Line Alignment of surfaces */
- /* State block related */
- struct wined3d_stateblock *stateBlock;
- struct wined3d_stateblock *updateStateBlock;
+ struct wined3d_state state;
+ struct wined3d_state *update_state;
+ struct wined3d_stateblock *recording;
/* Internal use fields */
struct wined3d_device_creation_parameters create_parms;
struct list shaders; /* a linked list to track shaders (pixel and vertex) */
/* Render Target Support */
- DWORD valid_rt_mask;
struct wined3d_fb_state fb;
struct wined3d_surface *onscreen_depth_stencil;
struct wined3d_surface *auto_depth_stencil;
DWORD rev_tex_unit_map[MAX_COMBINED_SAMPLERS];
/* Stream source management */
- struct wined3d_stream_info strided_streams;
- const struct wined3d_strided_data *up_strided;
+ struct wined3d_stream_info stream_info;
struct wined3d_event_query *buffer_queries[MAX_ATTRIBS];
unsigned int num_buffer_queries;
/* Context management */
struct wined3d_context **contexts;
UINT context_count;
-
- /* High level patch management */
-#define PATCHMAP_SIZE 43
-#define PATCHMAP_HASHFUNC(x) ((x) % PATCHMAP_SIZE) /* Primitive and simple function */
- struct list patches[PATCHMAP_SIZE];
};
-HRESULT device_clear_render_targets(struct wined3d_device *device, UINT rt_count, const struct wined3d_fb_state *fb,
+void device_clear_render_targets(struct wined3d_device *device, UINT rt_count, const struct wined3d_fb_state *fb,
UINT rect_count, const RECT *rects, const RECT *draw_rect, DWORD flags,
const struct wined3d_color *color, float depth, DWORD stencil) DECLSPEC_HIDDEN;
BOOL device_context_add(struct wined3d_device *device, struct wined3d_context *context) DECLSPEC_HIDDEN;
UINT message, WPARAM wparam, LPARAM lparam, WNDPROC proc) DECLSPEC_HIDDEN;
void device_resource_add(struct wined3d_device *device, struct wined3d_resource *resource) DECLSPEC_HIDDEN;
void device_resource_released(struct wined3d_device *device, struct wined3d_resource *resource) DECLSPEC_HIDDEN;
-void device_stream_info_from_declaration(struct wined3d_device *device,
- struct wined3d_stream_info *stream_info, BOOL *fixup) DECLSPEC_HIDDEN;
void device_switch_onscreen_ds(struct wined3d_device *device, struct wined3d_context *context,
struct wined3d_surface *depth_stencil) DECLSPEC_HIDDEN;
void device_update_stream_info(struct wined3d_device *device, const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
#define WINED3D_RESOURCE_ACCESS_GPU 0x1
#define WINED3D_RESOURCE_ACCESS_CPU 0x2
-/* SCRATCH is mostly the same as CPU, but can't be used by the GPU at all,
- * not even for resource uploads. */
-#define WINED3D_RESOURCE_ACCESS_SCRATCH 0x4
struct wined3d_resource_ops
{
void (*resource_unload)(struct wined3d_resource *resource);
};
+void *wined3d_resource_allocate_sysmem(SIZE_T size) DECLSPEC_HIDDEN;
+void wined3d_resource_free_sysmem(void *mem) DECLSPEC_HIDDEN;
+
struct wined3d_resource
{
LONG ref;
+ LONG bind_count;
+ LONG map_count;
struct wined3d_device *device;
enum wined3d_resource_type type;
const struct wined3d_format *format;
enum wined3d_multisample_type multisample_type;
- UINT multisample_quality;
- DWORD usage;
+ UINT multisample_quality;
+ DWORD usage;
enum wined3d_pool pool;
DWORD access_flags;
UINT width;
UINT height;
UINT depth;
- UINT size;
- DWORD priority;
- BYTE *allocatedMemory; /* Pointer to the real data location */
- BYTE *heapMemory; /* Pointer to the HeapAlloced block of memory */
- struct list privateData;
- struct list resource_list_entry;
+ UINT size;
+ DWORD priority;
+ BYTE *allocatedMemory; /* Pointer to the real data location */
+ void *heap_memory;
+ struct list privateData;
+ struct list resource_list_entry;
void *parent;
const struct wined3d_parent_ops *parent_ops;
const struct wined3d_resource_ops *resource_ops) DECLSPEC_HIDDEN;
DWORD resource_set_priority(struct wined3d_resource *resource, DWORD priority) DECLSPEC_HIDDEN;
void resource_unload(struct wined3d_resource *resource) DECLSPEC_HIDDEN;
+DWORD wined3d_resource_sanitize_map_flags(const struct wined3d_resource *resource,
+ DWORD flags) DECLSPEC_HIDDEN;
+GLbitfield wined3d_resource_gl_map_flags(DWORD d3d_flags) DECLSPEC_HIDDEN;
/* Tests show that the start address of resources is 32 byte aligned */
#define RESOURCE_ALIGNMENT 16
float pow2_matrix[16];
UINT lod;
enum wined3d_texture_filter_type filter_type;
- LONG bind_count;
DWORD sampler;
DWORD flags;
const struct min_lookup *min_mip_lookup;
const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
void wined3d_texture_set_dirty(struct wined3d_texture *texture, BOOL dirty) DECLSPEC_HIDDEN;
+#define WINED3D_VFLAG_LOCKED 0x00000001
+#define WINED3D_VFLAG_ALLOCATED 0x00000002
+#define WINED3D_VFLAG_SRGB_ALLOCATED 0x00000004
+#define WINED3D_VFLAG_PBO 0x00000008
+
+#define WINED3D_LOCATION_DISCARDED 0x00000001
+#define WINED3D_LOCATION_SYSMEM 0x00000002
+#define WINED3D_LOCATION_BUFFER 0x00000004
+#define WINED3D_LOCATION_TEXTURE_RGB 0x00000008
+#define WINED3D_LOCATION_TEXTURE_SRGB 0x00000010
+
+const char *wined3d_debug_location(DWORD location) DECLSPEC_HIDDEN;
+
struct wined3d_volume
{
struct wined3d_resource resource;
struct wined3d_texture *container;
- BOOL lockable;
- BOOL locked;
- struct wined3d_box lockedBox;
- struct wined3d_box dirtyBox;
- BOOL dirty;
+
+ DWORD flags, locations;
+ GLint texture_level;
+ DWORD download_count;
+ GLuint pbo;
};
static inline struct wined3d_volume *volume_from_resource(struct wined3d_resource *resource)
return CONTAINING_RECORD(resource, struct wined3d_volume, resource);
}
-void volume_add_dirty_box(struct wined3d_volume *volume, const struct wined3d_box *dirty_box) DECLSPEC_HIDDEN;
-void volume_load(const struct wined3d_volume *volume, struct wined3d_context *context, UINT level, BOOL srgb_mode) DECLSPEC_HIDDEN;
+void wined3d_volume_load(struct wined3d_volume *volume, struct wined3d_context *context, BOOL srgb_mode) DECLSPEC_HIDDEN;
void volume_set_container(struct wined3d_volume *volume, struct wined3d_texture *container) DECLSPEC_HIDDEN;
+void wined3d_volume_invalidate_location(struct wined3d_volume *volume, DWORD location) DECLSPEC_HIDDEN;
+void wined3d_volume_upload_data(struct wined3d_volume *volume, const struct wined3d_context *context,
+ const struct wined3d_bo_address *data) DECLSPEC_HIDDEN;
struct wined3d_surface_dib
{
GLuint id;
};
-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 wined3d_swapchain *swapchain;
- struct wined3d_texture *texture;
- void *base;
- } u;
-};
-
struct wined3d_surface_ops
{
HRESULT (*surface_private_setup)(struct wined3d_surface *surface);
{
struct wined3d_resource resource;
const struct wined3d_surface_ops *surface_ops;
- struct wined3d_subresource_container container;
+ struct wined3d_texture *container;
+ struct wined3d_swapchain *swapchain;
struct wined3d_palette *palette; /* D3D7 style palette handling */
DWORD draw_binding;
DWORD flags;
- WINED3DSURFTYPE surface_type;
- UINT pow2Width;
- UINT pow2Height;
+ UINT pitch;
+ UINT pow2Width;
+ UINT pow2Height;
/* A method to retrieve the drawable size. Not in the Vtable to make it changeable */
void (*get_drawable_size)(const struct wined3d_context *context, UINT *width, UINT *height);
}
void surface_add_dirty_rect(struct wined3d_surface *surface, const struct wined3d_box *dirty_rect) DECLSPEC_HIDDEN;
-void surface_bind(struct wined3d_surface *surface, struct wined3d_context *context, BOOL srgb) DECLSPEC_HIDDEN;
HRESULT surface_color_fill(struct wined3d_surface *s,
const RECT *rect, const struct wined3d_color *color) DECLSPEC_HIDDEN;
GLenum surface_get_gl_buffer(const struct wined3d_surface *surface) DECLSPEC_HIDDEN;
-BOOL surface_init_sysmem(struct wined3d_surface *surface) DECLSPEC_HIDDEN;
void surface_internal_preload(struct wined3d_surface *surface, enum WINED3DSRGB srgb) DECLSPEC_HIDDEN;
BOOL surface_is_offscreen(const struct wined3d_surface *surface) DECLSPEC_HIDDEN;
HRESULT surface_load(struct wined3d_surface *surface, BOOL srgb) DECLSPEC_HIDDEN;
struct wined3d_context *context, BOOL srgb) DECLSPEC_HIDDEN;
void surface_set_compatible_renderbuffer(struct wined3d_surface *surface,
const struct wined3d_surface *rt) DECLSPEC_HIDDEN;
-void surface_set_container(struct wined3d_surface *surface,
- enum wined3d_container_type type, void *container) DECLSPEC_HIDDEN;
+void surface_set_container(struct wined3d_surface *surface, struct wined3d_texture *container) DECLSPEC_HIDDEN;
+void surface_set_swapchain(struct wined3d_surface *surface, struct wined3d_swapchain *swapchain) DECLSPEC_HIDDEN;
void surface_set_texture_name(struct wined3d_surface *surface, GLuint name, BOOL srgb_name) DECLSPEC_HIDDEN;
-void surface_set_texture_target(struct wined3d_surface *surface, GLenum target) DECLSPEC_HIDDEN;
+void surface_set_texture_target(struct wined3d_surface *surface, GLenum target, GLint level) DECLSPEC_HIDDEN;
void surface_translate_drawable_coords(const struct wined3d_surface *surface, HWND window, RECT *rect) DECLSPEC_HIDDEN;
void surface_update_draw_binding(struct wined3d_surface *surface) DECLSPEC_HIDDEN;
HRESULT surface_upload_from_surface(struct wined3d_surface *dst_surface, const POINT *dst_point,
#define SFLAG_NORMCOORD 0x00000008 /* Set if GL texture coordinates are normalized (non-texture rectangle). */
#define SFLAG_LOCKABLE 0x00000010 /* Surface can be locked. */
#define SFLAG_DYNLOCK 0x00000020 /* Surface is often locked by the application. */
-#define SFLAG_LOCKED 0x00000040 /* Surface is currently locked. */
+#define SFLAG_PIN_SYSMEM 0x00000040 /* Keep the surface in sysmem, at the same address. */
#define SFLAG_DCINUSE 0x00000080 /* Set between GetDC and ReleaseDC calls. */
#define SFLAG_LOST 0x00000100 /* Surface lost flag for ddraw. */
#define SFLAG_GLCKEY 0x00000200 /* The GL texture was created with a color key. */
#define SFLAG_INDRAWABLE 0x00100000 /* The GL drawable is current. */
#define SFLAG_INRB_MULTISAMPLE 0x00200000 /* The multisample renderbuffer is current. */
#define SFLAG_INRB_RESOLVED 0x00400000 /* The resolved renderbuffer is current. */
-#define SFLAG_PIN_SYSMEM 0x02000000 /* Keep the surface in sysmem, at the same address. */
+#define SFLAG_DISCARDED 0x00800000 /* Surface was discarded, allocating new location is enough. */
/* 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
* SFLAG_PBO: PBOs don't use 'normal' memory. It is either allocated by the driver or must be NULL.
* SFLAG_CLIENT: OpenGL uses our memory as backup
*/
#define SFLAG_DONOTFREE (SFLAG_CONVERTED | \
SFLAG_DYNLOCK | \
- SFLAG_LOCKED | \
SFLAG_CLIENT | \
SFLAG_DIBSECTION | \
SFLAG_USERPTR | \
SFLAG_INRB_MULTISAMPLE | \
SFLAG_INRB_RESOLVED)
-typedef enum {
- NO_CONVERSION,
- CONVERT_PALETTED,
- CONVERT_PALETTED_CK,
- CONVERT_CK_565,
- CONVERT_CK_5551,
- CONVERT_CK_RGB24,
- CONVERT_RGB32_888
-} CONVERT_TYPES;
-
-HRESULT d3dfmt_get_conv(const struct wined3d_surface *surface, BOOL need_alpha_ck, BOOL use_texturing,
- struct wined3d_format *format, CONVERT_TYPES *convert) DECLSPEC_HIDDEN;
+enum wined3d_conversion_type
+{
+ WINED3D_CT_NONE,
+ WINED3D_CT_PALETTED,
+ WINED3D_CT_PALETTED_CK,
+ WINED3D_CT_CK_565,
+ WINED3D_CT_CK_5551,
+ WINED3D_CT_CK_RGB24,
+ WINED3D_CT_RGB32_888,
+ WINED3D_CT_CK_ARGB32,
+};
+
void d3dfmt_p8_init_palette(const struct wined3d_surface *surface, BYTE table[256][4], BOOL colorkey) DECLSPEC_HIDDEN;
+struct wined3d_sampler
+{
+ LONG refcount;
+ void *parent;
+};
+
struct wined3d_vertex_declaration_element
{
const struct wined3d_format *format;
struct wined3d_vertex_declaration_element *elements;
UINT element_count;
- DWORD streams[MAX_STREAMS];
- UINT num_streams;
- BOOL position_transformed;
- BOOL half_float_conv_needed;
+ BOOL position_transformed;
+ BOOL half_float_conv_needed;
};
struct wined3d_saved_states
DWORD state;
};
-struct wined3d_stream_state
-{
- struct wined3d_buffer *buffer;
- UINT offset;
- UINT stride;
- UINT frequency;
- UINT flags;
-};
-
-struct wined3d_state
-{
- const struct wined3d_fb_state *fb;
-
- struct wined3d_vertex_declaration *vertex_declaration;
- struct wined3d_stream_state streams[MAX_STREAMS + 1 /* tesselated pseudo-stream */];
- BOOL user_stream;
- struct wined3d_buffer *index_buffer;
- enum wined3d_format_id index_format;
- INT base_vertex_index;
- INT load_base_vertex_index; /* Non-indexed drawing needs 0 here, indexed needs base_vertex_index. */
- GLenum gl_primitive_type;
-
- struct wined3d_shader *vertex_shader;
- BOOL vs_consts_b[MAX_CONST_B];
- INT vs_consts_i[MAX_CONST_I * 4];
- float *vs_consts_f;
-
- struct wined3d_shader *pixel_shader;
- BOOL ps_consts_b[MAX_CONST_B];
- INT ps_consts_i[MAX_CONST_I * 4];
- float *ps_consts_f;
-
- struct wined3d_texture *textures[MAX_COMBINED_SAMPLERS];
- DWORD sampler_states[MAX_COMBINED_SAMPLERS][WINED3D_HIGHEST_SAMPLER_STATE + 1];
- DWORD texture_states[MAX_TEXTURES][WINED3D_HIGHEST_TEXTURE_STATE + 1];
- DWORD lowest_disabled_stage;
-
- struct wined3d_matrix transforms[HIGHEST_TRANSFORMSTATE + 1];
- double clip_planes[MAX_CLIPPLANES][4];
- struct wined3d_material material;
- struct wined3d_viewport viewport;
- RECT scissor_rect;
-
- /* 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 */
-
- DWORD render_states[WINEHIGHEST_RENDER_STATE + 1];
-};
-
struct wined3d_stateblock
{
LONG ref; /* Note: Ref counting not required */
struct wined3d_device *device;
- enum wined3d_stateblock_type blockType;
/* Array indicating whether things have been set or changed */
struct wined3d_saved_states changed;
};
void stateblock_init_contained_states(struct wined3d_stateblock *stateblock) DECLSPEC_HIDDEN;
-void stateblock_init_default_state(struct wined3d_stateblock *stateblock) DECLSPEC_HIDDEN;
-void stateblock_unbind_resources(struct wined3d_stateblock *stateblock) DECLSPEC_HIDDEN;
+
+void state_cleanup(struct wined3d_state *state) DECLSPEC_HIDDEN;
+HRESULT state_init(struct wined3d_state *state, const struct wined3d_d3d_info *d3d_info) DECLSPEC_HIDDEN;
+void state_init_default(struct wined3d_state *state, struct wined3d_device *device) DECLSPEC_HIDDEN;
+void state_unbind_resources(struct wined3d_state *state) DECLSPEC_HIDDEN;
/* 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
UINT size;
};
-#define WINED3D_BUFFER_OPTIMIZED 0x01 /* Optimize has been called for the buffer */
-#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 */
-#define WINED3D_BUFFER_FLUSH 0x10 /* Manual unmap flushing */
-#define WINED3D_BUFFER_DISCARD 0x20 /* A DISCARD lock has occurred since the last PreLoad */
-#define WINED3D_BUFFER_NOSYNC 0x40 /* All locks since the last PreLoad had NOOVERWRITE set */
-#define WINED3D_BUFFER_APPLESYNC 0x80 /* Using sync as in GL_APPLE_flush_buffer_range */
-
struct wined3d_buffer
{
struct wined3d_resource resource;
GLenum buffer_object_usage;
GLenum buffer_type_hint;
UINT buffer_object_size;
- LONG bind_count;
DWORD flags;
- LONG lock_count;
struct wined3d_map_range *maps;
ULONG maps_size, modified_areas;
struct wined3d_event_query *query;
struct wined3d_swapchain_ops
{
- HRESULT (*swapchain_present)(struct wined3d_swapchain *swapchain, const RECT *src_rect,
+ void (*swapchain_present)(struct wined3d_swapchain *swapchain, const RECT *src_rect,
const RECT *dst_rect, const RGNDATA *dirty_region, DWORD flags);
};
struct wined3d_surface **back_buffers;
struct wined3d_surface *front_buffer;
struct wined3d_swapchain_desc desc;
- DWORD orig_width, orig_height;
- enum wined3d_format_id orig_fmt;
+ struct wined3d_display_mode original_mode;
struct wined3d_gamma_ramp orig_gamma;
BOOL render_to_fbo;
const struct wined3d_format *ds_format;
void swapchain_update_draw_bindings(struct wined3d_swapchain *swapchain) DECLSPEC_HIDDEN;
void swapchain_update_render_to_fbo(struct wined3d_swapchain *swapchain) DECLSPEC_HIDDEN;
-#define DEFAULT_REFRESH_RATE 0
-
/*****************************************************************************
* Utility function prototypes
*/
const char *debug_d3dresourcetype(enum wined3d_resource_type resource_type) 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_d3ddeclmethod(enum wined3d_decl_method method) DECLSPEC_HIDDEN;
+const char *debug_d3ddeclusage(enum wined3d_decl_usage usage) DECLSPEC_HIDDEN;
const char *debug_d3dprimitivetype(enum wined3d_primitive_type primitive_type) DECLSPEC_HIDDEN;
const char *debug_d3drenderstate(enum wined3d_render_state state) DECLSPEC_HIDDEN;
const char *debug_d3dsamplerstate(enum wined3d_sampler_state state) DECLSPEC_HIDDEN;
const char *debug_d3dpool(enum wined3d_pool pool) DECLSPEC_HIDDEN;
const char *debug_fbostatus(GLenum status) DECLSPEC_HIDDEN;
const char *debug_glerror(GLenum error) DECLSPEC_HIDDEN;
-const char *debug_d3dbasis(enum wined3d_basis_type basis) DECLSPEC_HIDDEN;
-const char *debug_d3ddegree(enum wined3d_degree_type order) DECLSPEC_HIDDEN;
const char *debug_d3dtop(enum wined3d_texture_op d3dtop) DECLSPEC_HIDDEN;
void dump_color_fixup_desc(struct color_fixup_desc fixup) DECLSPEC_HIDDEN;
const char *debug_surflocation(DWORD flag) DECLSPEC_HIDDEN;
void set_tex_op_nvrc(const struct wined3d_gl_info *gl_info, const struct wined3d_state *state,
BOOL is_alpha, int stage, enum wined3d_texture_op op, DWORD arg1, DWORD arg2, DWORD arg3,
INT texture_idx, DWORD dst) DECLSPEC_HIDDEN;
-void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords,
- BOOL transformed, enum wined3d_format_id coordtype, BOOL ffp_can_disable_proj) DECLSPEC_HIDDEN;
+void set_texture_matrix(const struct wined3d_gl_info *gl_info, const float *smat, DWORD flags,
+ BOOL calculatedCoords, BOOL transformed, enum wined3d_format_id coordtype,
+ BOOL ffp_can_disable_proj) DECLSPEC_HIDDEN;
void texture_activate_dimensions(const struct wined3d_texture *texture,
const struct wined3d_gl_info *gl_info) DECLSPEC_HIDDEN;
void sampler_texdim(struct wined3d_context *context,
const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
void state_fog_fragpart(struct wined3d_context *context,
const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void state_srgbwrite(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+
+void sampler_texmatrix(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void state_specularenable(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void transform_world(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void transform_view(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void transform_projection(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void transform_texture(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void state_ambient(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void viewport_vertexpart(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void state_clipping(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void light(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void vertexdeclaration(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void clipplane(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void state_psizemin_w(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void state_psizemin_ext(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void state_psizemin_arb(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void state_pointsprite_w(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void state_pointsprite(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
+void state_pscale(struct wined3d_context *context,
+ const struct wined3d_state *state, DWORD state_id) DECLSPEC_HIDDEN;
BOOL getColorBits(const struct wined3d_format *format,
BYTE *redSize, BYTE *greenSize, BYTE *blueSize, BYTE *alphaSize, BYTE *totalSize) DECLSPEC_HIDDEN;
BOOL getDepthStencilBits(const struct wined3d_format *format,
BYTE *depthSize, BYTE *stencilSize) DECLSPEC_HIDDEN;
+GLenum gl_primitive_type_from_d3d(enum wined3d_primitive_type primitive_type) DECLSPEC_HIDDEN;
/* Math utils */
void multiply_matrix(struct wined3d_matrix *dest, const struct wined3d_matrix *src1,
UINT wined3d_log2i(UINT32 x) DECLSPEC_HIDDEN;
unsigned int count_bits(unsigned int mask) DECLSPEC_HIDDEN;
-void select_shader_mode(const struct wined3d_gl_info *gl_info, int *ps_selected, int *vs_selected) DECLSPEC_HIDDEN;
-
struct wined3d_shader_lconst
{
struct list entry;
struct wined3d_shader_limits
{
- unsigned int temporary;
- unsigned int texcoord;
unsigned int sampler;
unsigned int constant_int;
unsigned int constant_float;
unsigned int constant_bool;
- unsigned int address;
unsigned int packed_output;
unsigned int packed_input;
- unsigned int attributes;
- unsigned int label;
};
#ifdef __GNUC__
struct wined3d_shader_attribute attributes[MAX_ATTRIBS];
};
+struct wined3d_geometry_shader
+{
+ enum wined3d_primitive_type input_type;
+ enum wined3d_primitive_type output_type;
+ UINT vertices_out;
+};
+
struct wined3d_pixel_shader
{
/* Pixel shader input semantics */
struct list constantsF;
struct list constantsI;
struct wined3d_shader_reg_maps reg_maps;
+ BOOL lconst_inf_or_nan;
struct wined3d_shader_signature_element input_signature[max(MAX_ATTRIBS, MAX_REG_INPUT)];
struct wined3d_shader_signature_element output_signature[MAX_REG_OUTPUT];
union
{
struct wined3d_vertex_shader vs;
+ struct wined3d_geometry_shader gs;
struct wined3d_pixel_shader ps;
} u;
};
-void pixelshader_update_samplers(struct wined3d_shader_reg_maps *reg_maps,
- struct wined3d_texture * const *textures) DECLSPEC_HIDDEN;
+void pixelshader_update_samplers(struct wined3d_shader *shader, WORD tex_types) DECLSPEC_HIDDEN;
void find_ps_compile_args(const struct wined3d_state *state,
const struct wined3d_shader *shader, struct ps_compile_args *args) DECLSPEC_HIDDEN;
unsigned int max) DECLSPEC_HIDDEN;
void shader_generate_main(const struct wined3d_shader *shader, struct wined3d_shader_buffer *buffer,
const struct wined3d_shader_reg_maps *reg_maps, const DWORD *byte_code, void *backend_ctx) DECLSPEC_HIDDEN;
-BOOL shader_match_semantic(const char *semantic_name, WINED3DDECLUSAGE usage) DECLSPEC_HIDDEN;
-
-static inline BOOL shader_is_pshader_version(enum wined3d_shader_type type)
-{
- return type == WINED3D_SHADER_TYPE_PIXEL;
-}
-
-static inline BOOL shader_is_vshader_version(enum wined3d_shader_type type)
-{
- return type == WINED3D_SHADER_TYPE_VERTEX;
-}
+BOOL shader_match_semantic(const char *semantic_name, enum wined3d_decl_usage usage) DECLSPEC_HIDDEN;
static inline BOOL shader_is_scalar(const struct wined3d_shader_register *reg)
{
{
case WINED3DSPR_RASTOUT:
/* oFog & oPts */
- if (reg->idx) return TRUE;
+ if (reg->idx[0].offset)
+ return TRUE;
/* oPos */
return FALSE;
case WINED3DSPR_CONSTBOOL: /* b# */
case WINED3DSPR_LOOP: /* aL */
case WINED3DSPR_PREDICATE: /* p0 */
+ case WINED3DSPR_PRIMID: /* primID */
return TRUE;
case WINED3DSPR_MISCTYPE:
- switch(reg->idx)
+ switch (reg->idx[0].offset)
{
case 0: /* vPos */
return FALSE;
WORD num_consts;
};
-/* sRGB correction constants */
-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;
-
struct wined3d_palette
{
LONG ref;
#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
#define WINED3DFMT_FLAG_FBO_ATTACHABLE_SRGB 0x00000080
#define WINED3DFMT_FLAG_GETDC 0x00000100
#define WINED3DFMT_FLAG_COMPRESSED 0x00008000
#define WINED3DFMT_FLAG_BROKEN_PITCH 0x00010000
#define WINED3DFMT_FLAG_BLOCKS 0x00020000
+#define WINED3DFMT_FLAG_HEIGHT_SCALE 0x00040000
+#define WINED3DFMT_FLAG_TEXTURE 0x00080000
+
+struct wined3d_rational
+{
+ UINT numerator;
+ UINT denominator;
+};
struct wined3d_format
{
enum wined3d_format_id id;
- DWORD red_mask;
- DWORD green_mask;
- DWORD blue_mask;
- DWORD alpha_mask;
+ DWORD red_size;
+ DWORD green_size;
+ DWORD blue_size;
+ DWORD alpha_size;
+ DWORD red_offset;
+ DWORD green_offset;
+ DWORD blue_offset;
+ DWORD alpha_offset;
UINT byte_count;
BYTE depth_size;
BYTE stencil_size;
GLint glType;
UINT conv_byte_count;
unsigned int flags;
- float heightscale;
+ struct wined3d_rational height_scale;
struct color_fixup_desc color_fixup;
void (*convert)(const BYTE *src, BYTE *dst, UINT pitch, UINT width, UINT height);
};
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,
- UINT alignment, UINT width, UINT height) DECLSPEC_HIDDEN;
+ UINT alignment, UINT width, UINT height, UINT depth) DECLSPEC_HIDDEN;
DWORD wined3d_format_convert_from_float(const struct wined3d_surface *surface,
const struct wined3d_color *color) DECLSPEC_HIDDEN;
#define MAKEDWORD_VERSION(maj, min) (((maj & 0xffff) << 16) | (min & 0xffff))
-#endif
+#endif /* __WINE_WINED3D_PRIVATE_H */
projects / reactos.git / blobdiff