#include "wine/wined3d.h"
#include "wined3d_gl.h"
#include "wine/list.h"
+#include "wine/rbtree.h"
+
+/* Driver quirks */
+#define WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT 0x00000001
+#define WINED3D_QUIRK_SET_TEXCOORD_W 0x00000002
+#define WINED3D_QUIRK_GLSL_CLIP_VARYING 0x00000004
+#define WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA 0x00000008
/* Texture format fixups */
return yuv_fixup;
}
-/* Hash table functions */
-typedef unsigned int (hash_function_t)(const void *key);
-typedef BOOL (compare_function_t)(const void *keya, const void *keyb);
-
-#define ceilf(x) (float)ceil((double)x)
-
-struct hash_table_entry_t {
- void *key;
- void *value;
- unsigned int hash;
- struct list entry;
-};
-
-struct hash_table_t {
- hash_function_t *hash_function;
- compare_function_t *compare_function;
- struct list *buckets;
- unsigned int bucket_count;
- struct hash_table_entry_t *entries;
- unsigned int entry_count;
- struct list free_entries;
- unsigned int count;
- unsigned int grow_size;
- unsigned int shrink_size;
-};
-
-struct hash_table_t *hash_table_create(hash_function_t *hash_function, compare_function_t *compare_function);
-void hash_table_destroy(struct hash_table_t *table, void (*free_value)(void *value, void *cb), void *cb);
-void hash_table_for_each_entry(struct hash_table_t *table, void (*callback)(void *value, void *context), void *context);
-void *hash_table_get(const struct hash_table_t *table, const void *key);
-void hash_table_put(struct hash_table_t *table, void *key, void *value);
-void hash_table_remove(struct hash_table_t *table, void *key);
+void *wined3d_rb_alloc(size_t size);
+void *wined3d_rb_realloc(void *ptr, size_t size);
+void wined3d_rb_free(void *ptr);
/* Device caps */
#define MAX_PALETTES 65536
GLenum mip[WINED3DTEXF_LINEAR + 1];
};
-struct min_lookup minMipLookup[WINED3DTEXF_ANISOTROPIC + 1];
-const struct min_lookup minMipLookup_noFilter[WINED3DTEXF_ANISOTROPIC + 1];
-GLenum magLookup[WINED3DTEXF_ANISOTROPIC + 1];
-const GLenum magLookup_noFilter[WINED3DTEXF_ANISOTROPIC + 1];
+const struct min_lookup minMipLookup[WINED3DTEXF_LINEAR + 1];
+const struct min_lookup minMipLookup_noFilter[WINED3DTEXF_LINEAR + 1];
+const GLenum magLookup[WINED3DTEXF_LINEAR + 1];
+const GLenum magLookup_noFilter[WINED3DTEXF_LINEAR + 1];
+
+static inline GLenum wined3d_gl_mag_filter(const GLenum mag_lookup[], WINED3DTEXTUREFILTERTYPE mag_filter)
+{
+ return mag_lookup[mag_filter];
+}
-extern const struct filter_lookup filter_lookup_nofilter;
-extern struct filter_lookup filter_lookup;
+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];
+}
/* float_16_to_32() and float_32_to_16() (see implementation in
* surface_base.c) convert 16 bit floats in the FLOAT16 data type
const unsigned short s = ((*in) & 0x8000);
const unsigned short e = ((*in) & 0x7C00) >> 10;
const unsigned short m = (*in) & 0x3FF;
- const float sgn = (s ? -1.0 : 1.0);
+ const float sgn = (s ? -1.0f : 1.0f);
if(e == 0) {
- if(m == 0) return sgn * 0.0; /* +0.0 or -0.0 */
- else return sgn * pow(2, -14.0) * ( (float) m / 1024.0);
+ if(m == 0) return sgn * 0.0f; /* +0.0 or -0.0 */
+ else return sgn * pow(2, -14.0f) * ((float)m / 1024.0f);
} else if(e < 31) {
- return sgn * pow(2, (float) e-15.0) * (1.0 + ((float) m / 1024.0));
+ return sgn * pow(2, (float)e - 15.0f) * (1.0f + ((float)m / 1024.0f));
} else {
- if(m == 0) return sgn / 0.0; /* +INF / -INF */
- else return 0.0 / 0.0; /* NAN */
+ if(m == 0) return sgn / 0.0f; /* +INF / -INF */
+ else return 0.0f / 0.0f; /* NAN */
+ }
+}
+
+static inline float float_24_to_32(DWORD in)
+{
+ const float sgn = in & 0x800000 ? -1.0f : 1.0f;
+ const unsigned short e = (in & 0x780000) >> 19;
+ const unsigned short m = in & 0x7ffff;
+
+ if (e == 0)
+ {
+ if (m == 0) return sgn * 0.0f; /* +0.0 or -0.0 */
+ else return sgn * pow(2, -6.0f) * ((float)m / 524288.0f);
+ }
+ else if (e < 15)
+ {
+ return sgn * pow(2, (float)e - 7.0f) * (1.0f + ((float)m / 524288.0f));
+ }
+ else
+ {
+ if (m == 0) return sgn / 0.0f; /* +INF / -INF */
+ else return 0.0f / 0.0f; /* NAN */
}
}
/**
- * Settings
+ * Settings
*/
#define VS_NONE 0
#define VS_HW 1
#define SHADER_NONE 4
#define RTL_DISABLE -1
-#define RTL_AUTO 0
#define RTL_READDRAW 1
#define RTL_READTEX 2
-#define RTL_TEXDRAW 3
-#define RTL_TEXTEX 4
#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 */
/* vertex and pixel shader modes */
int vs_mode;
int ps_mode;
- int vbo_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. */
WINED3DSPR_LABEL = 18,
WINED3DSPR_PREDICATE = 19,
WINED3DSPR_IMMCONST,
+ WINED3DSPR_CONSTBUFFER,
} WINED3DSHADER_PARAM_REGISTER_TYPE;
enum wined3d_immconst_type
#define MAX_LABELS 16
#define SHADER_PGMSIZE 65535
-typedef struct SHADER_BUFFER {
- char* buffer;
+
+struct wined3d_shader_buffer
+{
+ char *buffer;
unsigned int bsize;
unsigned int lineNo;
BOOL newline;
-} SHADER_BUFFER;
+};
enum WINED3D_SHADER_INSTRUCTION_HANDLER
{
typedef struct shader_reg_maps
{
struct wined3d_shader_version shader_version;
- char texcoord[MAX_REG_TEXCRD]; /* pixel < 3.0 */
- char temporary[MAX_REG_TEMP]; /* pixel, vertex */
- char address[MAX_REG_ADDR]; /* vertex */
- char packed_input[MAX_REG_INPUT]; /* pshader >= 3.0 */
- char packed_output[MAX_REG_OUTPUT]; /* vertex >= 3.0 */
- char attributes[MAX_ATTRIBS]; /* vertex */
- char labels[MAX_LABELS]; /* pixel, vertex */
+ BYTE texcoord; /* MAX_REG_TEXCRD, 8 */
+ BYTE address; /* MAX_REG_ADDR, 1 */
+ WORD labels; /* MAX_LABELS, 16 */
+ 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 */
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 */
WINED3DSAMPLER_TEXTURE_TYPE sampler_type[max(MAX_FRAGMENT_SAMPLERS, MAX_VERTEX_SAMPLERS)];
- BOOL bumpmat[MAX_TEXTURES], luminanceparams[MAX_TEXTURES];
- char usesnrm, vpos, usesdsy, usestexldd;
- char usesrelconstF;
+ BYTE bumpmat; /* MAX_TEXTURES, 8 */
+ BYTE luminanceparams; /* MAX_TEXTURES, 8 */
+
+ 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;
+ WORD padding : 4;
/* Whether or not loops are used in this shader, and nesting depth */
unsigned loop_depth;
-
- /* Whether or not this shader uses fog */
- char fog;
+ unsigned highest_render_target;
} shader_reg_maps;
{
IWineD3DBaseShader *shader;
const struct shader_reg_maps *reg_maps;
- SHADER_BUFFER *buffer;
+ struct wined3d_shader_buffer *buffer;
+ void *backend_data;
};
struct wined3d_shader_register
{
WINED3DSHADER_PARAM_REGISTER_TYPE type;
UINT idx;
+ UINT array_idx;
const struct wined3d_shader_src_param *rel_addr;
enum wined3d_immconst_type immconst_type;
DWORD immconst_data[4];
struct wined3d_shader_dst_param reg;
};
+struct wined3d_shader_attribute
+{
+ WINED3DDECLUSAGE usage;
+ UINT usage_idx;
+};
+
+struct wined3d_shader_loop_control
+{
+ unsigned int count;
+ unsigned int start;
+ int step;
+};
+
struct wined3d_shader_frontend
{
void *(*shader_init)(const DWORD *ptr, const struct wined3d_shader_signature *output_signature);
DWORD MaxPShaderInstructionsExecuted;
DWORD MaxVertexShader30InstructionSlots;
DWORD MaxPixelShader30InstructionSlots;
+
+ BOOL VSClipping;
};
enum tex_types
#define WINED3D_CONST_NUM_UNUSED ~0U
-struct stb_const_desc {
- unsigned char texunit;
- UINT const_num;
-};
-
enum fogmode {
FOG_OFF,
FOG_LINEAR,
WORD swizzle_map; /* MAX_ATTRIBS, 16 */
};
+struct wined3d_context;
+
typedef struct {
- const SHADER_HANDLER *shader_instruction_handler_table;
- void (*shader_select)(IWineD3DDevice *iface, BOOL usePS, BOOL useVS);
+ void (*shader_handle_instruction)(const struct wined3d_shader_instruction *);
+ void (*shader_select)(const struct wined3d_context *context, BOOL usePS, BOOL useVS);
void (*shader_select_depth_blt)(IWineD3DDevice *iface, enum tex_types tex_type);
void (*shader_deselect_depth_blt)(IWineD3DDevice *iface);
void (*shader_update_float_vertex_constants)(IWineD3DDevice *iface, UINT start, UINT count);
void (*shader_update_float_pixel_constants)(IWineD3DDevice *iface, UINT start, UINT count);
- void (*shader_load_constants)(IWineD3DDevice *iface, char usePS, char useVS);
+ void (*shader_load_constants)(const struct wined3d_context *context, char usePS, char useVS);
void (*shader_load_np2fixup_constants)(IWineD3DDevice *iface, char usePS, char useVS);
void (*shader_destroy)(IWineD3DBaseShader *iface);
HRESULT (*shader_alloc_private)(IWineD3DDevice *iface);
void (*shader_free_private)(IWineD3DDevice *iface);
BOOL (*shader_dirtifyable_constants)(IWineD3DDevice *iface);
- GLuint (*shader_generate_pshader)(IWineD3DPixelShader *iface,
- SHADER_BUFFER *buffer, const struct ps_compile_args *args);
- GLuint (*shader_generate_vshader)(IWineD3DVertexShader *iface,
- SHADER_BUFFER *buffer, const struct vs_compile_args *args);
- void (*shader_get_caps)(WINED3DDEVTYPE devtype, const WineD3D_GL_Info *gl_info, struct shader_caps *caps);
+ void (*shader_get_caps)(WINED3DDEVTYPE devtype, const struct wined3d_gl_info *gl_info, struct shader_caps *caps);
BOOL (*shader_color_fixup_supported)(struct color_fixup_desc fixup);
void (*shader_add_instruction_modifiers)(const struct wined3d_shader_instruction *ins);
} shader_backend_t;
/* Checking of API calls */
/* --------------------- */
#ifndef WINE_NO_DEBUG_MSGS
-#define checkGLcall(A) \
-do { \
- GLint err = glGetError(); \
- if (err == GL_NO_ERROR) { \
- TRACE("%s call ok %s / %d\n", A, __FILE__, __LINE__); \
- \
- } else do { \
- FIXME(">>>>>>>>>>>>>>>>> %s (%#x) from %s @ %s / %d\n", \
- debug_glerror(err), err, A, __FILE__, __LINE__); \
- err = glGetError(); \
- } while (err != GL_NO_ERROR); \
+#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 { \
+ FIXME(">>>>>>>>>>>>>>>>> %s (%#x) from %s @ %s / %d\n", \
+ debug_glerror(err), err, A, __FILE__, __LINE__); \
+ err = glGetError(); \
+ } while (err != GL_NO_ERROR); \
} while(0)
#else
#define checkGLcall(A) do {} while(0)
} while(0)
/* Trace vector and strided data information */
-#define TRACE_VECTOR(name) TRACE( #name "=(%f, %f, %f, %f)\n", name.x, name.y, name.z, name.w);
-#define TRACE_STRIDED(si, name) TRACE( #name "=(data:%p, stride:%d, format:%#x, vbo %d, stream %u)\n", \
+#define TRACE_VECTOR(name) TRACE( #name "=(%f, %f, %f, %f)\n", name.x, name.y, name.z, name.w)
+#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", \
si->elements[name].data, si->elements[name].stride, si->elements[name].format_desc->format, \
- si->elements[name].buffer_object, si->elements[name].stream_idx);
+ si->elements[name].buffer_object, si->elements[name].stream_idx); } while(0)
/* Defines used for optimizations */
/* Trace information per-vertex: (extremely high amount of trace) */
#if 0 /* NOTE: Must be 0 in cvs */
# define VTRACE(A) TRACE A
-#else
-# define VTRACE(A)
+#else
+# define VTRACE(A)
#endif
/* TODO: Confirm each of these works when wined3d move completed */
the file is deleted */
# if 1 /* NOTE: Must be 1 in cvs, as this is mostly more useful than a trace from program start */
# define SINGLE_FRAME_DEBUGGING
-# endif
+# endif
/* The following, when enabled, lets you see the makeup of the frame, by drawprimitive calls.
- It can only be enabled when FRAME_DEBUGGING is also enabled
- The contents of the back buffer are written into /tmp/backbuffer_* after each primitive
+ It can only be enabled when FRAME_DEBUGGING is also enabled
+ The contents of the back buffer are written into /tmp/backbuffer_* after each primitive
array is drawn. */
-# if 0 /* NOTE: Must be 0 in cvs, as this give a lot of ppm files when compiled in */
+# if 0 /* NOTE: Must be 0 in cvs, as this give a lot of ppm files when compiled in */
# define SHOW_FRAME_MAKEUP 1
-# endif
+# endif
/* The following, when enabled, lets you see the makeup of the all the textures used during each
of the drawprimitive calls. It can only be enabled when SHOW_FRAME_MAKEUP is also enabled.
- The contents of the textures assigned to each stage are written into
+ The contents of the textures assigned to each stage are written into
/tmp/texture_*_<Stage>.ppm after each primitive array is drawn. */
# if 0 /* NOTE: Must be 0 in cvs, as this give a lot of ppm files when compiled in */
# define SHOW_TEXTURE_MAKEUP 0
-# endif
+# endif
extern BOOL isOn;
extern BOOL isDumpingFrames;
extern LONG primCounter;
(((((d3dvtVertexType) >> (16 + (2 * (tex_num)))) + 1) & 0x03) + 1)
/* Routines and structures related to state management */
-typedef struct WineD3DContext WineD3DContext;
-typedef void (*APPLYSTATEFUNC)(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *ctx);
#define STATE_RENDER(a) (a)
#define STATE_IS_RENDER(a) ((a) >= STATE_RENDER(1) && (a) <= STATE_RENDER(WINEHIGHEST_RENDER_STATE))
#define STATE_HIGHEST (STATE_FRONTFACE)
-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 {
- void (*enable_extension)(IWineD3DDevice *iface, BOOL enable);
- void (*get_caps)(WINED3DDEVTYPE devtype, const WineD3D_GL_Info *gl_info, struct fragment_caps *caps);
- HRESULT (*alloc_private)(IWineD3DDevice *iface);
- void (*free_private)(IWineD3DDevice *iface);
- BOOL (*color_fixup_supported)(struct color_fixup_desc fixup);
- const struct StateEntryTemplate *states;
- BOOL ffp_proj_control;
+enum fogsource {
+ FOGSOURCE_FFP,
+ FOGSOURCE_VS,
+ FOGSOURCE_COORD,
};
-extern const struct StateEntryTemplate misc_state_template[];
-extern const struct StateEntryTemplate ffp_vertexstate_template[];
-extern const struct fragment_pipeline ffp_fragment_pipeline;
-extern const struct fragment_pipeline atifs_fragment_pipeline;
-extern const struct fragment_pipeline arbfp_fragment_pipeline;
-extern const struct fragment_pipeline nvts_fragment_pipeline;
-extern const struct fragment_pipeline nvrc_fragment_pipeline;
-
-/* "Base" state table */
-HRESULT compile_state_table(struct StateEntry *StateTable, APPLYSTATEFUNC **dev_multistate_funcs,
- const WineD3D_GL_Info *gl_info, const struct StateEntryTemplate *vertex,
- const struct fragment_pipeline *fragment, const struct StateEntryTemplate *misc);
+#define WINED3D_MAX_FBO_ENTRIES 64
-/* Shaders for color conversions in blits */
-struct blit_shader {
- HRESULT (*alloc_private)(IWineD3DDevice *iface);
- void (*free_private)(IWineD3DDevice *iface);
- HRESULT (*set_shader)(IWineD3DDevice *iface, const struct GlPixelFormatDesc *format_desc,
- GLenum textype, UINT width, UINT height);
- void (*unset_shader)(IWineD3DDevice *iface);
- BOOL (*color_fixup_supported)(struct color_fixup_desc fixup);
+struct wined3d_occlusion_query
+{
+ struct list entry;
+ GLuint id;
+ struct wined3d_context *context;
};
-extern const struct blit_shader ffp_blit;
-extern const struct blit_shader arbfp_blit;
-
-enum fogsource {
- FOGSOURCE_FFP,
- FOGSOURCE_VS,
- FOGSOURCE_COORD,
+struct wined3d_event_query
+{
+ struct list entry;
+ GLuint id;
+ struct wined3d_context *context;
};
-/* The new context manager that should deal with onscreen and offscreen rendering */
-struct WineD3DContext {
+struct wined3d_context
+{
+ const struct wined3d_gl_info *gl_info;
/* 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,
DWORD isStateDirty[STATE_HIGHEST/32 + 1]; /* Bitmap to find out quickly if a state is dirty */
IWineD3DSurface *surface;
+ IWineD3DSurface *current_rt;
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 draw_buffer_dirty : 1;
WORD last_was_rhw : 1; /* true iff last draw_primitive was in xyzrhw mode */
WORD last_was_pshader : 1;
WORD isPBuffer : 1;
WORD fog_enabled : 1;
WORD num_untracked_materials : 2; /* Max value 2 */
- WORD padding : 3;
+ WORD current : 1;
+ WORD destroyed : 1;
BYTE texShaderBumpMap; /* MAX_TEXTURES, 8 */
BYTE lastWasPow2Texture; /* MAX_TEXTURES, 8 */
DWORD numbered_array_mask;
GLint aux_buffers;
/* FBOs */
+ UINT fbo_entry_count;
struct list fbo_list;
struct fbo_entry *current_fbo;
GLuint src_fbo;
GLuint dst_fbo;
+ GLuint fbo_read_binding;
+ GLuint fbo_draw_binding;
+
+ /* Queries */
+ GLuint *free_occlusion_queries;
+ UINT free_occlusion_query_size;
+ UINT free_occlusion_query_count;
+ struct list occlusion_queries;
+
+ GLuint *free_event_queries;
+ UINT free_event_query_size;
+ UINT free_event_query_count;
+ struct list event_queries;
/* Extension emulation */
GLint gl_fog_source;
GLfloat fog_coord_value;
GLfloat color[4], fogstart, fogend, fogcolor[4];
+ GLuint dummy_arbfp_prog;
+};
+
+typedef void (*APPLYSTATEFUNC)(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *ctx);
+
+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
+{
+ void (*enable_extension)(IWineD3DDevice *iface, BOOL enable);
+ void (*get_caps)(WINED3DDEVTYPE devtype, const struct wined3d_gl_info *gl_info, struct fragment_caps *caps);
+ HRESULT (*alloc_private)(IWineD3DDevice *iface);
+ void (*free_private)(IWineD3DDevice *iface);
+ BOOL (*color_fixup_supported)(struct color_fixup_desc fixup);
+ const struct StateEntryTemplate *states;
+ BOOL ffp_proj_control;
+};
+
+extern const struct StateEntryTemplate misc_state_template[];
+extern const struct StateEntryTemplate ffp_vertexstate_template[];
+extern const struct fragment_pipeline ffp_fragment_pipeline;
+extern const struct fragment_pipeline atifs_fragment_pipeline;
+extern const struct fragment_pipeline arbfp_fragment_pipeline;
+extern const struct fragment_pipeline nvts_fragment_pipeline;
+extern const struct fragment_pipeline nvrc_fragment_pipeline;
+
+/* "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);
+
+/* Shaders for color conversions in blits */
+struct blit_shader
+{
+ HRESULT (*alloc_private)(IWineD3DDevice *iface);
+ void (*free_private)(IWineD3DDevice *iface);
+ HRESULT (*set_shader)(IWineD3DDevice *iface, const struct GlPixelFormatDesc *format_desc,
+ GLenum textype, UINT width, UINT height);
+ void (*unset_shader)(IWineD3DDevice *iface);
+ BOOL (*color_fixup_supported)(struct color_fixup_desc fixup);
};
+extern const struct blit_shader ffp_blit;
+extern const struct blit_shader arbfp_blit;
+
typedef enum ContextUsage {
CTXUSAGE_RESOURCELOAD = 1, /* Only loads textures: No State is applied */
CTXUSAGE_DRAWPRIM = 2, /* OpenGL states are set up for blitting DirectDraw surfaces */
CTXUSAGE_CLEAR = 4, /* Drawable and states are set up for clearing */
} ContextUsage;
-void ActivateContext(IWineD3DDeviceImpl *device, IWineD3DSurface *target, ContextUsage usage);
-WineD3DContext *getActiveContext(void);
-WineD3DContext *CreateContext(IWineD3DDeviceImpl *This, IWineD3DSurfaceImpl *target, HWND win, BOOL create_pbuffer, const WINED3DPRESENT_PARAMETERS *pPresentParms);
-void DestroyContext(IWineD3DDeviceImpl *This, WineD3DContext *context);
+struct wined3d_context *ActivateContext(IWineD3DDeviceImpl *This, IWineD3DSurface *target, enum ContextUsage usage);
+struct wined3d_context *CreateContext(IWineD3DDeviceImpl *This, IWineD3DSurfaceImpl *target, HWND win,
+ BOOL create_pbuffer, const WINED3DPRESENT_PARAMETERS *pPresentParms);
+void DestroyContext(IWineD3DDeviceImpl *This, struct wined3d_context *context);
+void context_alloc_event_query(struct wined3d_context *context, struct wined3d_event_query *query);
+void context_alloc_occlusion_query(struct wined3d_context *context, struct wined3d_occlusion_query *query);
void context_resource_released(IWineD3DDevice *iface, IWineD3DResource *resource, WINED3DRESOURCETYPE type);
-void context_bind_fbo(IWineD3DDevice *iface, GLenum target, GLuint *fbo);
-void context_attach_depth_stencil_fbo(IWineD3DDeviceImpl *This, GLenum fbo_target, IWineD3DSurface *depth_stencil, BOOL use_render_buffer);
-void context_attach_surface_fbo(IWineD3DDeviceImpl *This, GLenum fbo_target, DWORD idx, IWineD3DSurface *surface);
+void context_bind_fbo(struct wined3d_context *context, GLenum target, GLuint *fbo);
+void context_attach_depth_stencil_fbo(struct wined3d_context *context,
+ GLenum fbo_target, IWineD3DSurface *depth_stencil, BOOL use_render_buffer);
+void context_attach_surface_fbo(const struct wined3d_context *context,
+ GLenum fbo_target, DWORD idx, IWineD3DSurface *surface);
+void context_free_event_query(struct wined3d_event_query *query);
+void context_free_occlusion_query(struct wined3d_occlusion_query *query);
+struct wined3d_context *context_get_current(void);
+DWORD context_get_tls_idx(void);
+BOOL context_set_current(struct wined3d_context *ctx);
+void context_set_tls_idx(DWORD idx);
void delete_opengl_contexts(IWineD3DDevice *iface, IWineD3DSwapChain *swapchain);
HRESULT create_primary_opengl_context(IWineD3DDevice *iface, IWineD3DSwapChain *swapchain);
UINT num;
BOOL opengl;
POINT monitorPoint;
- WineD3D_GL_Info gl_info;
+ struct wined3d_gl_info gl_info;
const char *driver;
const char *description;
WCHAR DeviceName[CCHDEVICENAME]; /* DeviceName for use with e.g. ChangeDisplaySettings */
unsigned int UsedTextureRam;
};
-extern BOOL initPixelFormats(WineD3D_GL_Info *gl_info);
-BOOL initPixelFormatsNoGL(WineD3D_GL_Info *gl_info);
+extern BOOL initPixelFormats(struct wined3d_gl_info *gl_info);
+BOOL initPixelFormatsNoGL(struct wined3d_gl_info *gl_info);
extern long WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl *D3DDevice, long glram);
-extern void add_gl_compat_wrappers(WineD3D_GL_Info *gl_info);
+extern void add_gl_compat_wrappers(struct wined3d_gl_info *gl_info);
/*****************************************************************************
* High order patch management
struct ffp_frag_settings {
struct texture_stage_op op[MAX_TEXTURES];
enum fogmode fog;
- /* Use an int instead of a char to get dword alignment */
- unsigned int sRGB_write;
+ /* Use shorts instead of chars to get dword alignment */
+ unsigned short sRGB_write;
+ unsigned short emul_clipplanes;
};
struct ffp_frag_desc
{
+ struct wine_rb_entry entry;
struct ffp_frag_settings settings;
};
+extern const struct wine_rb_functions wined3d_ffp_frag_program_rb_functions;
+
void gen_ffp_frag_op(IWineD3DStateBlockImpl *stateblock, struct ffp_frag_settings *settings, BOOL ignore_textype);
-const struct ffp_frag_desc *find_ffp_frag_shader(const struct hash_table_t *fragment_shaders,
+const struct ffp_frag_desc *find_ffp_frag_shader(const struct wine_rb_tree *fragment_shaders,
const struct ffp_frag_settings *settings);
-void add_ffp_frag_shader(struct hash_table_t *shaders, struct ffp_frag_desc *desc);
-BOOL ffp_frag_program_key_compare(const void *keya, const void *keyb);
-unsigned int ffp_frag_program_key_hash(const void *key);
+void add_ffp_frag_shader(struct wine_rb_tree *shaders, struct ffp_frag_desc *desc);
/*****************************************************************************
* IWineD3D implementation structure
BOOL InitAdapters(IWineD3DImpl *This);
-/* TODO: setup some flags in the registry to enable, disable pbuffer support
-(since it will break quite a few things until contexts are managed properly!) */
-extern BOOL pbuffer_support;
-/* allocate one pbuffer per surface */
-extern BOOL pbuffer_per_surface;
-
/* A helper function that dumps a resource list */
void dumpResources(struct list *list);
unsigned int max_ffp_textures, max_ffp_texture_stages;
DWORD d3d_vshader_constantF, d3d_pshader_constantF; /* Advertised d3d caps, not GL ones */
+ DWORD vs_clipping;
WORD view_ident : 1; /* true iff view matrix is identity */
WORD untransformed : 1;
WORD vertexBlendUsed : 1; /* To avoid needless setting of the blend matrices */
WORD isRecordingState : 1;
WORD isInDraw : 1;
- WORD render_offscreen : 1;
WORD bCursorVisible : 1;
WORD haveHardwareCursor : 1;
WORD d3d_initialized : 1;
WORD softwareVertexProcessing : 1; /* process vertex shaders using software or hardware */
WORD useDrawStridedSlow : 1;
WORD instancedDraw : 1;
- WORD padding : 3;
+ WORD padding : 4;
BYTE fixed_function_usage_map; /* MAX_TEXTURES, 8 */
IWineD3DSurface *auto_depth_stencil_buffer;
IWineD3DSurface *stencilBufferTarget;
- /* Caches to avoid unneeded context changes */
- IWineD3DSurface *lastActiveRenderTarget;
- IWineD3DSwapChain *lastActiveSwapChain;
-
/* palettes texture management */
UINT NumberOfPalettes;
PALETTEENTRY **palettes;
const WineDirect3DVertexStridedData *up_strided;
/* Context management */
- WineD3DContext **contexts; /* Dynamic array containing pointers to context structures */
- WineD3DContext *activeContext;
- DWORD lastThread;
+ struct wined3d_context **contexts;
UINT numContexts;
- WineD3DContext *pbufferContext; /* The context that has a pbuffer as drawable */
+ struct wined3d_context *pbufferContext; /* The context that has a pbuffer as drawable */
DWORD pbufferWidth, pbufferHeight; /* Size of the buffer drawable */
/* High level patch management */
extern const IWineD3DDeviceVtbl IWineD3DDevice_Vtbl;
+void device_resource_add(IWineD3DDeviceImpl *This, IWineD3DResource *resource);
+void device_resource_released(IWineD3DDeviceImpl *This, IWineD3DResource *resource);
void device_stream_info_from_declaration(IWineD3DDeviceImpl *This,
BOOL use_vshader, struct wined3d_stream_info *stream_info, BOOL *fixup);
void device_stream_info_from_strided(IWineD3DDeviceImpl *This,
float Z, DWORD Stencil);
void IWineD3DDeviceImpl_FindTexUnitMap(IWineD3DDeviceImpl *This);
void IWineD3DDeviceImpl_MarkStateDirty(IWineD3DDeviceImpl *This, DWORD state);
-static inline BOOL isStateDirty(WineD3DContext *context, DWORD state) {
+static inline BOOL isStateDirty(struct wined3d_context *context, DWORD state)
+{
DWORD idx = state >> 5;
BYTE shift = state & 0x1f;
return context->isStateDirty[idx] & (1 << shift);
DWORD resource_get_priority(IWineD3DResource *iface);
HRESULT resource_get_private_data(IWineD3DResource *iface, REFGUID guid,
void *data, DWORD *data_size);
-HRESULT resource_init(struct IWineD3DResourceClass *resource, WINED3DRESOURCETYPE resource_type,
+HRESULT resource_init(IWineD3DResource *iface, WINED3DRESOURCETYPE resource_type,
IWineD3DDeviceImpl *device, UINT size, DWORD usage, const struct GlPixelFormatDesc *format_desc,
WINED3DPOOL pool, IUnknown *parent);
WINED3DRESOURCETYPE resource_get_type(IWineD3DResource *iface);
/*****************************************************************************
* IWineD3DBaseTexture D3D- > openGL state map lookups
*/
-#define WINED3DFUNC_NOTSUPPORTED -2
-#define WINED3DFUNC_UNIMPLEMENTED -1
typedef enum winetexturestates {
WINED3DTEXSTA_ADDRESSU = 0,
void (*internal_preload)(IWineD3DBaseTexture *iface, enum WINED3DSRGB srgb);
} IWineD3DBaseTextureClass;
-void texture_internal_preload(IWineD3DBaseTexture *iface, enum WINED3DSRGB srgb);
-void cubetexture_internal_preload(IWineD3DBaseTexture *iface, enum WINED3DSRGB srgb);
-void volumetexture_internal_preload(IWineD3DBaseTexture *iface, enum WINED3DSRGB srgb);
void surface_internal_preload(IWineD3DSurface *iface, enum WINED3DSRGB srgb);
typedef struct IWineD3DBaseTextureImpl
BOOL basetexture_get_dirty(IWineD3DBaseTexture *iface);
DWORD basetexture_get_level_count(IWineD3DBaseTexture *iface);
DWORD basetexture_get_lod(IWineD3DBaseTexture *iface);
-void basetexture_init(struct IWineD3DBaseTextureClass *texture, UINT levels, DWORD usage);
+HRESULT basetexture_init(IWineD3DBaseTextureImpl *texture, UINT levels, WINED3DRESOURCETYPE resource_type,
+ IWineD3DDeviceImpl *device, UINT size, DWORD usage, const struct GlPixelFormatDesc *format_desc,
+ WINED3DPOOL pool, IUnknown *parent);
HRESULT basetexture_set_autogen_filter_type(IWineD3DBaseTexture *iface, WINED3DTEXTUREFILTERTYPE filter_type);
BOOL basetexture_set_dirty(IWineD3DBaseTexture *iface, BOOL dirty);
DWORD basetexture_set_lod(IWineD3DBaseTexture *iface, DWORD new_lod);
void basetexture_unload(IWineD3DBaseTexture *iface);
-static inline void basetexture_setsrgbcache(IWineD3DBaseTexture *iface, BOOL srgb) {
- IWineD3DBaseTextureImpl *This = (IWineD3DBaseTextureImpl *)iface;
- This->baseTexture.is_srgb = srgb;
-}
/*****************************************************************************
* IWineD3DTexture implementation structure (extends IWineD3DBaseTextureImpl)
extern const IWineD3DTextureVtbl IWineD3DTexture_Vtbl;
+HRESULT texture_init(IWineD3DTextureImpl *texture, UINT width, UINT height, UINT levels,
+ IWineD3DDeviceImpl *device, DWORD usage, WINED3DFORMAT format, WINED3DPOOL pool, IUnknown *parent);
+
/*****************************************************************************
* IWineD3DCubeTexture implementation structure (extends IWineD3DBaseTextureImpl)
*/
extern const IWineD3DCubeTextureVtbl IWineD3DCubeTexture_Vtbl;
+HRESULT cubetexture_init(IWineD3DCubeTextureImpl *texture, UINT edge_length, UINT levels,
+ IWineD3DDeviceImpl *device, DWORD usage, WINED3DFORMAT format, WINED3DPOOL pool, IUnknown *parent);
+
typedef struct _WINED3DVOLUMET_DESC
{
UINT Width;
extern const IWineD3DVolumeTextureVtbl IWineD3DVolumeTexture_Vtbl;
+HRESULT volumetexture_init(IWineD3DVolumeTextureImpl *texture, UINT width, UINT height, UINT depth, UINT levels,
+ IWineD3DDeviceImpl *device, DWORD usage, WINED3DFORMAT format, WINED3DPOOL pool, IUnknown *parent);
+
typedef struct _WINED3DSURFACET_DESC
{
WINED3DMULTISAMPLE_TYPE MultiSampleType;
UINT pow2Height;
/* A method to retrieve the drawable size. Not in the Vtable to make it changeable */
- void (*get_drawable_size)(IWineD3DSurfaceImpl *This, UINT *width, UINT *height);
+ void (*get_drawable_size)(struct wined3d_context *context, UINT *width, UINT *height);
/* Oversized texture */
RECT glRect;
/* PBO */
GLuint pbo;
+ GLuint texture_name;
+ GLuint texture_name_srgb;
+ GLint texture_level;
+ GLenum texture_target;
RECT lockedRect;
RECT dirtyRect;
int lockCount;
#define MAXLOCKCOUNT 50 /* After this amount of locks do not free the sysmem copy */
- glDescriptor glDescription;
-
/* For GetDC */
wineD3DSurface_DIB dib;
HDC hDC;
extern const IWineD3DSurfaceVtbl IWineD3DSurface_Vtbl;
extern const IWineD3DSurfaceVtbl IWineGDISurface_Vtbl;
+UINT surface_calculate_size(const struct GlPixelFormatDesc *format_desc, UINT alignment, UINT width, UINT height);
+void surface_gdi_cleanup(IWineD3DSurfaceImpl *This);
+HRESULT surface_init(IWineD3DSurfaceImpl *surface, WINED3DSURFTYPE surface_type, UINT alignment,
+ UINT width, UINT height, UINT level, BOOL lockable, BOOL discard, WINED3DMULTISAMPLE_TYPE multisample_type,
+ UINT multisample_quality, IWineD3DDeviceImpl *device, DWORD usage, WINED3DFORMAT format,
+ WINED3DPOOL pool, IUnknown *parent);
+
/* Predeclare the shared Surface functions */
HRESULT WINAPI IWineD3DBaseSurfaceImpl_QueryInterface(IWineD3DSurface *iface, REFIID riid, LPVOID *ppobj);
ULONG WINAPI IWineD3DBaseSurfaceImpl_AddRef(IWineD3DSurface *iface);
void WINAPI IWineD3DBaseSurfaceImpl_BindTexture(IWineD3DSurface *iface, BOOL srgb);
const void *WINAPI IWineD3DBaseSurfaceImpl_GetData(IWineD3DSurface *iface);
-void get_drawable_size_swapchain(IWineD3DSurfaceImpl *This, UINT *width, UINT *height);
-void get_drawable_size_backbuffer(IWineD3DSurfaceImpl *This, UINT *width, UINT *height);
-void get_drawable_size_pbuffer(IWineD3DSurfaceImpl *This, UINT *width, UINT *height);
-void get_drawable_size_fbo(IWineD3DSurfaceImpl *This, UINT *width, UINT *height);
+void get_drawable_size_swapchain(struct wined3d_context *context, UINT *width, UINT *height);
+void get_drawable_size_backbuffer(struct wined3d_context *context, UINT *width, UINT *height);
+void get_drawable_size_pbuffer(struct wined3d_context *context, UINT *width, UINT *height);
+void get_drawable_size_fbo(struct wined3d_context *context, UINT *width, UINT *height);
void flip_surface(IWineD3DSurfaceImpl *front, IWineD3DSurfaceImpl *back);
CONVERT_G16R16,
CONVERT_R16G16F,
CONVERT_R32G32F,
+ CONVERT_D15S1,
+ CONVERT_D24X4S4,
+ CONVERT_D24FS8,
} CONVERT_TYPES;
HRESULT d3dfmt_get_conv(IWineD3DSurfaceImpl *This, BOOL need_alpha_ck, BOOL use_texturing, GLenum *format, GLenum *internal, GLenum *type, CONVERT_TYPES *convert, int *target_bpp, BOOL srgb_mode);
{
const IWineD3DQueryVtbl *lpVtbl;
LONG ref; /* Note: Ref counting not required */
-
+
IUnknown *parent;
/*TODO: replace with iface usage */
#if 0
WINED3DQUERYTYPE type;
/* TODO: Think about using a IUnknown instead of a void* */
void *extendedData;
-
-
} IWineD3DQueryImpl;
extern const IWineD3DQueryVtbl IWineD3DQuery_Vtbl;
extern const IWineD3DQueryVtbl IWineD3DEventQuery_Vtbl;
extern const IWineD3DQueryVtbl IWineD3DOcclusionQuery_Vtbl;
-/* Datastructures for IWineD3DQueryImpl.extendedData */
-typedef struct WineQueryOcclusionData {
- GLuint queryId;
- WineD3DContext *ctx;
-} WineQueryOcclusionData;
-
-typedef struct WineQueryEventData {
- GLuint fenceId;
- WineD3DContext *ctx;
-} WineQueryEventData;
-
/* IWineD3DBuffer */
/* TODO: Add tests and support for FLOAT16_4 POSITIONT, D3DCOLOR position, other
extern const IWineD3DBufferVtbl wined3d_buffer_vtbl;
const BYTE *buffer_get_memory(IWineD3DBuffer *iface, UINT offset, GLuint *buffer_object);
-const BYTE *buffer_get_sysmem(struct wined3d_buffer *This);
+BYTE *buffer_get_sysmem(struct wined3d_buffer *This);
/* IWineD3DRendertargetView */
struct wined3d_rendertarget_view
long prev_time, frames; /* Performance tracking */
unsigned int vSyncCounter;
- WineD3DContext **context; /* Later a array for multithreading */
+ struct wined3d_context **context;
unsigned int num_contexts;
HWND win_handle;
HRESULT WINAPI IWineD3DBaseSwapChainImpl_SetGammaRamp(IWineD3DSwapChain *iface, DWORD Flags, CONST WINED3DGAMMARAMP *pRamp);
HRESULT WINAPI IWineD3DBaseSwapChainImpl_GetGammaRamp(IWineD3DSwapChain *iface, WINED3DGAMMARAMP *pRamp);
-WineD3DContext *IWineD3DSwapChainImpl_CreateContextForThread(IWineD3DSwapChain *iface);
+struct wined3d_context *IWineD3DSwapChainImpl_CreateContextForThread(IWineD3DSwapChain *iface);
+
+#define DEFAULT_REFRESH_RATE 0
/*****************************************************************************
- * Utility function prototypes
+ * Utility function prototypes
*/
/* Trace routines */
BOOL is_invalid_op(IWineD3DDeviceImpl *This, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3);
void set_tex_op_nvrc(IWineD3DDevice *iface, BOOL is_alpha, int stage, WINED3DTEXTUREOP op, DWORD arg1, DWORD arg2, DWORD arg3, INT texture_idx, DWORD dst);
void set_texture_matrix(const float *smat, DWORD flags, BOOL calculatedCoords, BOOL transformed, DWORD coordtype, BOOL ffp_can_disable_proj);
-void texture_activate_dimensions(DWORD stage, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context);
-void sampler_texdim(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context);
-void tex_alphaop(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context);
-void apply_pixelshader(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context);
-void state_fogcolor(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context);
-void state_fogdensity(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context);
-void state_fogstartend(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context);
-void state_fog_fragpart(DWORD state, IWineD3DStateBlockImpl *stateblock, WineD3DContext *context);
+void texture_activate_dimensions(DWORD stage, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context);
+void sampler_texdim(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context);
+void tex_alphaop(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context);
+void apply_pixelshader(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context);
+void state_fogcolor(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context);
+void state_fogdensity(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context);
+void state_fogstartend(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context);
+void state_fog_fragpart(DWORD state, IWineD3DStateBlockImpl *stateblock, struct wined3d_context *context);
void surface_add_dirty_rect(IWineD3DSurface *iface, const RECT *dirty_rect);
-void surface_force_reload(IWineD3DSurface *iface);
GLenum surface_get_gl_buffer(IWineD3DSurface *iface, IWineD3DSwapChain *swapchain);
-void surface_load_ds_location(IWineD3DSurface *iface, DWORD location);
+void surface_load_ds_location(IWineD3DSurface *iface, struct wined3d_context *context, DWORD location);
void surface_modify_ds_location(IWineD3DSurface *iface, DWORD location);
void surface_set_compatible_renderbuffer(IWineD3DSurface *iface, unsigned int width, unsigned int height);
void surface_set_texture_name(IWineD3DSurface *iface, GLuint name, BOOL srgb_name);
unsigned int label;
} SHADER_LIMITS;
-/** Keeps track of details for TEX_M#x# shader opcodes which need to
- maintain state information between multiple codes */
+/* Keeps track of details for TEX_M#x# shader opcodes which need to
+ * maintain state information between multiple codes */
typedef struct SHADER_PARSE_STATE {
unsigned int current_row;
DWORD texcoord_w[2];
#define PRINTF_ATTR(fmt,args)
#endif
-/* Base Shader utility functions.
- * (may move callers into the same file in the future) */
-extern int shader_addline(
- SHADER_BUFFER* buffer,
- const char* fmt, ...) PRINTF_ATTR(2,3);
-int shader_vaddline(SHADER_BUFFER *buffer, const char *fmt, va_list args);
+/* Base Shader utility functions. */
+int shader_addline(struct wined3d_shader_buffer *buffer, const char *fmt, ...) PRINTF_ATTR(2,3);
+int shader_vaddline(struct wined3d_shader_buffer *buffer, const char *fmt, va_list args);
/* Vertex shader utility functions */
extern BOOL vshader_get_input(
IWineD3DBaseShaderClass baseShader;
} IWineD3DBaseShaderImpl;
-void shader_buffer_init(struct SHADER_BUFFER *buffer);
-void shader_buffer_free(struct SHADER_BUFFER *buffer);
+void shader_buffer_clear(struct wined3d_shader_buffer *buffer);
+BOOL shader_buffer_init(struct wined3d_shader_buffer *buffer);
+void shader_buffer_free(struct wined3d_shader_buffer *buffer);
void shader_cleanup(IWineD3DBaseShader *iface);
void shader_dump_src_param(const struct wined3d_shader_src_param *param,
const struct wined3d_shader_version *shader_version);
void shader_dump_dst_param(const struct wined3d_shader_dst_param *param,
const struct wined3d_shader_version *shader_version);
-void shader_generate_main(IWineD3DBaseShader *iface, SHADER_BUFFER *buffer,
- const shader_reg_maps *reg_maps, const DWORD *pFunction);
+unsigned int shader_find_free_input_register(const struct shader_reg_maps *reg_maps, unsigned int max);
+void shader_generate_main(IWineD3DBaseShader *iface, struct wined3d_shader_buffer *buffer,
+ const shader_reg_maps *reg_maps, const DWORD *pFunction, void *backend_ctx);
HRESULT shader_get_registers_used(IWineD3DBaseShader *iface, const struct wined3d_shader_frontend *fe,
- struct shader_reg_maps *reg_maps, struct wined3d_shader_semantic *semantics_in,
- struct wined3d_shader_semantic *semantics_out, const DWORD *byte_code, DWORD constf_size);
+ struct shader_reg_maps *reg_maps, struct wined3d_shader_attribute *attributes,
+ struct wined3d_shader_signature_element *input_signature,
+ struct wined3d_shader_signature_element *output_signature, const DWORD *byte_code, DWORD constf_size);
void shader_init(struct IWineD3DBaseShaderClass *shader, IWineD3DDevice *device);
+BOOL shader_match_semantic(const char *semantic_name, WINED3DDECLUSAGE usage);
const struct wined3d_shader_frontend *shader_select_frontend(DWORD version_token);
void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data, const DWORD *pFunction);
/*****************************************************************************
* IDirect3DVertexShader implementation structures
*/
-
-struct vs_compiled_shader {
- struct vs_compile_args args;
- GLuint prgId;
-};
-
typedef struct IWineD3DVertexShaderImpl {
- /* IUnknown parts*/
+ /* IUnknown parts */
const IWineD3DVertexShaderVtbl *lpVtbl;
/* IWineD3DBaseShader */
DWORD usage;
/* The GL shader */
- struct vs_compiled_shader *gl_shaders;
- UINT num_gl_shaders, shader_array_size;
+ void *backend_priv;
/* Vertex shader input and output semantics */
- struct wined3d_shader_semantic semantics_in[MAX_ATTRIBS];
- struct wined3d_shader_semantic semantics_out[MAX_REG_OUTPUT];
+ struct wined3d_shader_attribute attributes[MAX_ATTRIBS];
+ struct wined3d_shader_signature_element output_signature[MAX_REG_OUTPUT];
UINT min_rel_offset, max_rel_offset;
UINT rel_offset;
UINT recompile_count;
-
- const struct vs_compile_args *cur_args;
} IWineD3DVertexShaderImpl;
extern const IWineD3DVertexShaderVtbl IWineD3DVertexShader_Vtbl;
void find_vs_compile_args(IWineD3DVertexShaderImpl *shader, IWineD3DStateBlockImpl *stateblock, struct vs_compile_args *args);
-GLuint find_gl_vshader(IWineD3DVertexShaderImpl *shader, const struct vs_compile_args *args);
/*****************************************************************************
* IDirect3DPixelShader implementation structure
*/
-struct ps_compiled_shader {
- struct ps_compile_args args;
- GLuint prgId;
+
+/* 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;
};
typedef struct IWineD3DPixelShaderImpl {
IUnknown *parent;
/* Pixel shader input semantics */
- struct wined3d_shader_semantic semantics_in[MAX_REG_INPUT];
+ struct wined3d_shader_signature_element input_signature[MAX_REG_INPUT];
DWORD input_reg_map[MAX_REG_INPUT];
BOOL input_reg_used[MAX_REG_INPUT];
- int declared_in_count;
+ unsigned int declared_in_count;
/* The GL shader */
- struct ps_compiled_shader *gl_shaders;
- UINT num_gl_shaders, shader_array_size;
+ void *backend_priv;
/* Some information about the shader behavior */
- struct stb_const_desc bumpenvmatconst[MAX_TEXTURES];
- unsigned char numbumpenvmatconsts;
- struct stb_const_desc luminanceconst[MAX_TEXTURES];
char vpos_uniform;
- const struct ps_compile_args *cur_args;
+ BOOL color0_mov;
+ DWORD color0_reg;
+
} IWineD3DPixelShaderImpl;
extern const IWineD3DPixelShaderVtbl IWineD3DPixelShader_Vtbl;
-GLuint find_gl_pshader(IWineD3DPixelShaderImpl *shader, const struct ps_compile_args *args);
+void pixelshader_update_samplers(struct shader_reg_maps *reg_maps, IWineD3DBaseTexture * const *textures);
void find_ps_compile_args(IWineD3DPixelShaderImpl *shader, IWineD3DStateBlockImpl *stateblock, struct ps_compile_args *args);
/* sRGB correction constants */
-static const float srgb_cmp = 0.0031308;
-static const float srgb_mul_low = 12.92;
-static const float srgb_pow = 0.41666;
-static const float srgb_mul_high = 1.055;
-static const float srgb_sub_high = 0.055;
+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;
/*****************************************************************************
* IWineD3DPalette implementation structure
#define WINED3DFMT_FLAG_STENCIL 0x8
#define WINED3DFMT_FLAG_RENDERTARGET 0x10
#define WINED3DFMT_FLAG_FOURCC 0x20
+#define WINED3DFMT_FLAG_FBO_ATTACHABLE 0x40
+#define WINED3DFMT_FLAG_COMPRESSED 0x80
struct GlPixelFormatDesc
{
WORD depth_size;
WORD stencil_size;
+ UINT block_width;
+ UINT block_height;
+ UINT block_byte_count;
+
enum wined3d_ffp_emit_idx emit_idx;
GLint component_count;
GLenum gl_vtx_type;
struct color_fixup_desc color_fixup;
};
-const struct GlPixelFormatDesc *getFormatDescEntry(WINED3DFORMAT fmt, const WineD3D_GL_Info *gl_info);
+const struct GlPixelFormatDesc *getFormatDescEntry(WINED3DFORMAT fmt, const struct wined3d_gl_info *gl_info);
static inline BOOL use_vs(IWineD3DStateBlockImpl *stateblock)
{
+ /* 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. */
return (stateblock->vertexShader
- && !stateblock->wineD3DDevice->strided_streams.position_transformed
+ && !((IWineD3DVertexDeclarationImpl *)stateblock->vertexDecl)->position_transformed
&& stateblock->wineD3DDevice->vs_selected_mode != SHADER_NONE);
}
void stretch_rect_fbo(IWineD3DDevice *iface, IWineD3DSurface *src_surface, WINED3DRECT *src_rect,
IWineD3DSurface *dst_surface, WINED3DRECT *dst_rect, const WINED3DTEXTUREFILTERTYPE filter, BOOL flip);
+
+/* The WNDCLASS-Name for the fake window which we use to retrieve the GL capabilities */
+#define WINED3D_OPENGL_WINDOW_CLASS_NAME "WineD3D_OpenGL"
+
#endif
projects / reactos.git / blobdiff