ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/dlls/wined3d/glsl_shader.c

3891 lines
168 KiB
C
Raw Normal View History

wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
/*
* GLSL pixel and vertex shader implementation
*
* Copyright 2006 Jason Green
wined3d: Split shader_glsl_add_param() in shader_glsl_add_src_param() and shader_glsl_add_dst_param().
2007-01-15 19:30:20 +01:00
* Copyright 2006-2007 Henri Verbeet
wined3d: Update copyright lines.
2008-03-29 02:36:13 +01:00
* Copyright 2007-2008 Stefan D<EFBFBD>singer for CodeWeavers
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
wined3d: Add a comment about D3D write masks and GLSL destination swizzles.
2007-01-15 19:30:12 +01:00
/*
* D3D shader asm has swizzles on source parameters, and write masks for
* destination parameters. GLSL uses swizzles for both. The result of this is
* that for example "mov dst.xw, src.zyxw" becomes "dst.xw = src.zw" in GLSL.
* Ie, to generate a proper GLSL source swizzle, we need to take the D3D write
* mask for the destination parameter into account.
*/
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
#include "config.h"
#include <stdio.h>
#include "wined3d_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
wined3d: Give shader constants their own debug channel.
2007-01-17 21:41:46 +01:00
WINE_DECLARE_DEBUG_CHANNEL(d3d_constants);
wined3d: Move shader caps setting into the arb and glsl shader backends.
2008-03-22 14:27:53 +01:00
WINE_DECLARE_DEBUG_CHANNEL(d3d_caps);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
#define GLINFO_LOCATION (*gl_info)
wined3d: Add a glsl_dst_param_t type, pass it to shader_glsl_add_dst_param() instead of three separate character arrays.
2007-01-15 19:36:58 +01:00
typedef struct {
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
char reg_name[150];
wined3d: Add a glsl_dst_param_t type, pass it to shader_glsl_add_dst_param() instead of three separate character arrays.
2007-01-15 19:36:58 +01:00
char mask_str[6];
} glsl_dst_param_t;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
typedef struct {
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
char reg_name[150];
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
char param_str[100];
} glsl_src_param_t;
wined3d: Split out getting the sample function and coordinate mask from shader_glsl_sample().
2007-01-15 19:33:38 +01:00
typedef struct {
const char *name;
DWORD coord_mask;
} glsl_sample_function_t;
wined3d: Make some GLSL structs and functions private to the backend.
2008-09-16 14:55:39 +02:00
/* GLSL shader private data */
struct shader_glsl_priv {
struct hash_table_t *glsl_program_lookup;
struct glsl_shader_prog_link *glsl_program;
GLhandleARB depth_blt_glsl_program_id;
};
/* Struct to maintain data about a linked GLSL program */
struct glsl_shader_prog_link {
struct list vshader_entry;
struct list pshader_entry;
GLhandleARB programId;
GLhandleARB *vuniformF_locations;
GLhandleARB *puniformF_locations;
GLhandleARB vuniformI_locations[MAX_CONST_I];
GLhandleARB puniformI_locations[MAX_CONST_I];
GLhandleARB posFixup_location;
GLhandleARB bumpenvmat_location[MAX_TEXTURES];
GLhandleARB luminancescale_location[MAX_TEXTURES];
GLhandleARB luminanceoffset_location[MAX_TEXTURES];
GLhandleARB srgb_comparison_location;
GLhandleARB srgb_mul_low_location;
GLhandleARB ycorrection_location;
GLenum vertex_color_clamp;
GLhandleARB vshader;
GLhandleARB pshader;
};
typedef struct {
GLhandleARB vshader;
GLhandleARB pshader;
} glsl_program_key_t;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
/** Prints the GLSL info log which will contain error messages if they exist */
wined3d: Make some GLSL structs and functions private to the backend.
2008-09-16 14:55:39 +02:00
static void print_glsl_info_log(WineD3D_GL_Info *gl_info, GLhandleARB obj) {
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
int infologLength = 0;
char *infoLog;
wined3d: Filter out some shader compilation spam.
2007-12-15 11:43:51 +01:00
int i;
BOOL is_spam;
const char *spam[] = {
wined3d: More fglrx spam.
2008-04-23 21:36:39 +02:00
"Vertex shader was successfully compiled to run on hardware.\n", /* fglrx */
"Fragment shader was successfully compiled to run on hardware.\n", /* fglrx */
"Fragment shader(s) linked, vertex shader(s) linked. \n ", /* fglrx, with \n */
"Fragment shader(s) linked, vertex shader(s) linked.", /* fglrx, no \n */
"Vertex shader(s) linked, no fragment shader(s) defined. \n ", /* fglrx, with \n */
"Vertex shader(s) linked, no fragment shader(s) defined.", /* fglrx, no \n */
wined3d: Extend out anti-spam database a bit.
2008-02-10 16:43:24 +01:00
"Fragment shader was successfully compiled to run on hardware.\nWARNING: 0:1: extension 'GL_ARB_draw_buffers' is not supported",
wined3d: More fglrx spam.
2008-04-23 21:36:39 +02:00
"Fragment shader(s) linked, no vertex shader(s) defined.", /* fglrx, no \n */
wined3d: Filter out more spam.
2008-08-13 00:52:35 +02:00
"Fragment shader(s) linked, no vertex shader(s) defined. \n ", /* fglrx, with \n */
"WARNING: 0:2: extension 'GL_ARB_draw_buffers' is not supported\n" /* MacOS ati */
wined3d: Filter out some shader compilation spam.
2007-12-15 11:43:51 +01:00
};
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
GL_EXTCALL(glGetObjectParameterivARB(obj,
GL_OBJECT_INFO_LOG_LENGTH_ARB,
&infologLength));
/* A size of 1 is just a null-terminated string, so the log should be bigger than
* that if there are errors. */
if (infologLength > 1)
{
wined3d: Extend out anti-spam database a bit.
2008-02-10 16:43:24 +01:00
/* Fglrx doesn't terminate the string properly, but it tells us the proper length.
* So use HEAP_ZERO_MEMORY to avoid uninitialized bytes
*/
infoLog = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, infologLength);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
GL_EXTCALL(glGetInfoLogARB(obj, infologLength, NULL, infoLog));
wined3d: Filter out some shader compilation spam.
2007-12-15 11:43:51 +01:00
is_spam = FALSE;
for(i = 0; i < sizeof(spam) / sizeof(spam[0]); i++) {
if(strcmp(infoLog, spam[i]) == 0) {
is_spam = TRUE;
break;
}
}
if(is_spam) {
TRACE("Spam received from GLSL shader #%u: %s\n", obj, debugstr_a(infoLog));
} else {
FIXME("Error received from GLSL shader #%u: %s\n", obj, debugstr_a(infoLog));
}
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
HeapFree(GetProcessHeap(), 0, infoLog);
}
}
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
/**
* Loads (pixel shader) samplers
*/
Mark several functions as static.
2007-03-12 16:50:54 +01:00
static void shader_glsl_load_psamplers(
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
WineD3D_GL_Info *gl_info,
wined3d: Load GLSL sampler uniforms at shader link time.
2007-11-07 23:03:15 +01:00
IWineD3DStateBlock* iface,
GLhandleARB programId) {
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
IWineD3DStateBlockImpl* stateBlock = (IWineD3DStateBlockImpl*) iface;
GLhandleARB name_loc;
int i;
char sampler_name[20];
wined3d: Cleanup shader_glsl_load_psamplers().
2007-07-01 23:41:57 +02:00
for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i) {
snprintf(sampler_name, sizeof(sampler_name), "Psampler%d", i);
name_loc = GL_EXTCALL(glGetUniformLocationARB(programId, sampler_name));
if (name_loc != -1) {
int mapped_unit = stateBlock->wineD3DDevice->texUnitMap[i];
if (mapped_unit != -1 && mapped_unit < GL_LIMITS(fragment_samplers)) {
wined3d: Take the texUnitMap into account when loading shader_glsl_load_psamplers().
2007-06-12 23:08:11 +02:00
TRACE("Loading %s for texture %d\n", sampler_name, mapped_unit);
GL_EXTCALL(glUniform1iARB(name_loc, mapped_unit));
checkGLcall("glUniform1iARB");
wined3d: Cleanup shader_glsl_load_psamplers().
2007-07-01 23:41:57 +02:00
} else {
ERR("Trying to load sampler %s on unsupported unit %d\n", sampler_name, mapped_unit);
wined3d: Take the texUnitMap into account when loading shader_glsl_load_psamplers().
2007-06-12 23:08:11 +02:00
}
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
}
}
}
wined3d: Load GLSL sampler uniforms at shader link time.
2007-11-07 23:03:15 +01:00
static void shader_glsl_load_vsamplers(WineD3D_GL_Info *gl_info, IWineD3DStateBlock* iface, GLhandleARB programId) {
wined3d: Implement texldl.
2007-06-27 23:46:53 +02:00
IWineD3DStateBlockImpl* stateBlock = (IWineD3DStateBlockImpl*) iface;
GLhandleARB name_loc;
char sampler_name[20];
int i;
for (i = 0; i < MAX_VERTEX_SAMPLERS; ++i) {
snprintf(sampler_name, sizeof(sampler_name), "Vsampler%d", i);
name_loc = GL_EXTCALL(glGetUniformLocationARB(programId, sampler_name));
if (name_loc != -1) {
int mapped_unit = stateBlock->wineD3DDevice->texUnitMap[MAX_FRAGMENT_SAMPLERS + i];
if (mapped_unit != -1 && mapped_unit < GL_LIMITS(combined_samplers)) {
TRACE("Loading %s for texture %d\n", sampler_name, mapped_unit);
GL_EXTCALL(glUniform1iARB(name_loc, mapped_unit));
checkGLcall("glUniform1iARB");
} else {
ERR("Trying to load sampler %s on unsupported unit %d\n", sampler_name, mapped_unit);
}
}
}
}
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
/**
* Loads floating point constants (aka uniforms) into the currently set GLSL program.
wined3d: Improve float constant loading a bit. - Use a list to keep track of what constants are set. - Move TRACEs and checkGLcall calls out of the main constant loading loop.
2006-08-19 17:24:02 +02:00
* When constant_list == NULL, it will load all the constants.
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
*/
wined3d: Improve float constant loading a bit. - Use a list to keep track of what constants are set. - Move TRACEs and checkGLcall calls out of the main constant loading loop.
2006-08-19 17:24:02 +02:00
static void shader_glsl_load_constantsF(IWineD3DBaseShaderImpl* This, WineD3D_GL_Info *gl_info,
wined3d: Lookup GLSL float uniform locations only once per program.
2006-08-19 17:23:20 +02:00
unsigned int max_constants, float* constants, GLhandleARB *constant_locations,
wined3d: Improve float constant loading a bit. - Use a list to keep track of what constants are set. - Move TRACEs and checkGLcall calls out of the main constant loading loop.
2006-08-19 17:24:02 +02:00
struct list *constant_list) {
wined3d: Store multiple constant indices per list entry.
2007-02-27 20:51:58 +01:00
constants_entry *constant;
wined3d: Improve float constant loading a bit. - Use a list to keep track of what constants are set. - Move TRACEs and checkGLcall calls out of the main constant loading loop.
2006-08-19 17:24:02 +02:00
local_constant* lconst;
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
GLhandleARB tmp_loc;
wined3d: Pixel shader 1.x constants are clamped to [-1;1].
2007-09-13 13:34:29 +02:00
DWORD i, j, k;
wined3d: Store multiple constant indices per list entry.
2007-02-27 20:51:58 +01:00
DWORD *idx;
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
d3d8: Move loading local d3d8 vertex shader constants from wined3d to d3d8.
2007-02-13 23:12:40 +01:00
if (TRACE_ON(d3d_shader)) {
wined3d: Store multiple constant indices per list entry.
2007-02-27 20:51:58 +01:00
LIST_FOR_EACH_ENTRY(constant, constant_list, constants_entry, entry) {
idx = constant->idx;
j = constant->count;
while (j--) {
i = *idx++;
tmp_loc = constant_locations[i];
if (tmp_loc != -1) {
TRACE_(d3d_constants)("Loading constants %i: %f, %f, %f, %f\n", i,
constants[i * 4 + 0], constants[i * 4 + 1],
constants[i * 4 + 2], constants[i * 4 + 3]);
}
wined3d: Improve float constant loading a bit. - Use a list to keep track of what constants are set. - Move TRACEs and checkGLcall calls out of the main constant loading loop.
2006-08-19 17:24:02 +02:00
}
}
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
}
wined3d: Pixel shader 1.x constants are clamped to [-1;1].
2007-09-13 13:34:29 +02:00
/* 1.X pshaders have the constants clamped to [-1;1] implicitly. */
if(WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) == 1 &&
shader_is_pshader_version(This->baseShader.hex_version)) {
float lcl_const[4];
LIST_FOR_EACH_ENTRY(constant, constant_list, constants_entry, entry) {
idx = constant->idx;
j = constant->count;
while (j--) {
i = *idx++;
tmp_loc = constant_locations[i];
if (tmp_loc != -1) {
/* We found this uniform name in the program - go ahead and send the data */
k = i * 4;
if(constants[k + 0] < -1.0) lcl_const[0] = -1.0;
else if(constants[k + 0] > 1.0) lcl_const[0] = 1.0;
else lcl_const[0] = constants[k + 0];
if(constants[k + 1] < -1.0) lcl_const[1] = -1.0;
else if(constants[k + 1] > 1.0) lcl_const[1] = 1.0;
else lcl_const[1] = constants[k + 1];
if(constants[k + 2] < -1.0) lcl_const[2] = -1.0;
else if(constants[k + 2] > 1.0) lcl_const[2] = 1.0;
else lcl_const[2] = constants[k + 2];
if(constants[k + 3] < -1.0) lcl_const[3] = -1.0;
else if(constants[k + 3] > 1.0) lcl_const[3] = 1.0;
else lcl_const[3] = constants[k + 3];
GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, lcl_const));
}
}
}
} else {
LIST_FOR_EACH_ENTRY(constant, constant_list, constants_entry, entry) {
idx = constant->idx;
j = constant->count;
while (j--) {
i = *idx++;
tmp_loc = constant_locations[i];
if (tmp_loc != -1) {
/* We found this uniform name in the program - go ahead and send the data */
GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, constants + (i * 4)));
}
wined3d: Store multiple constant indices per list entry.
2007-02-27 20:51:58 +01:00
}
d3d8: Move loading local d3d8 vertex shader constants from wined3d to d3d8.
2007-02-13 23:12:40 +01:00
}
}
checkGLcall("glUniform4fvARB()");
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
wined3d: Hardcode local constants into the shader if possible.
2007-11-09 14:48:47 +01:00
if(!This->baseShader.load_local_constsF) {
TRACE("No need to load local float constants for this shader\n");
return;
}
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
/* Load immediate constants */
wined3d: Improve float constant loading a bit. - Use a list to keep track of what constants are set. - Move TRACEs and checkGLcall calls out of the main constant loading loop.
2006-08-19 17:24:02 +02:00
if (TRACE_ON(d3d_shader)) {
LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
tmp_loc = constant_locations[lconst->idx];
if (tmp_loc != -1) {
GLfloat* values = (GLfloat*)lconst->value;
wined3d: Give shader constants their own debug channel.
2007-01-17 21:41:46 +01:00
TRACE_(d3d_constants)("Loading local constants %i: %f, %f, %f, %f\n", lconst->idx,
wined3d: Improve float constant loading a bit. - Use a list to keep track of what constants are set. - Move TRACEs and checkGLcall calls out of the main constant loading loop.
2006-08-19 17:24:02 +02:00
values[0], values[1], values[2], values[3]);
}
}
}
wined3d: Pixel shader 1.x constants are clamped to [-1;1].
2007-09-13 13:34:29 +02:00
/* Immediate constants are clamped to [-1;1] at shader creation time if needed */
wined3d: Improve float constant loading a bit. - Use a list to keep track of what constants are set. - Move TRACEs and checkGLcall calls out of the main constant loading loop.
2006-08-19 17:24:02 +02:00
LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
tmp_loc = constant_locations[lconst->idx];
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
if (tmp_loc != -1) {
/* We found this uniform name in the program - go ahead and send the data */
wined3d: Improve float constant loading a bit. - Use a list to keep track of what constants are set. - Move TRACEs and checkGLcall calls out of the main constant loading loop.
2006-08-19 17:24:02 +02:00
GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, (GLfloat*)lconst->value));
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
}
}
wined3d: Improve float constant loading a bit. - Use a list to keep track of what constants are set. - Move TRACEs and checkGLcall calls out of the main constant loading loop.
2006-08-19 17:24:02 +02:00
checkGLcall("glUniform4fvARB()");
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
}
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
/**
* Loads integer constants (aka uniforms) into the currently set GLSL program.
* When @constants_set == NULL, it will load all the constants.
*/
Mark several functions as static.
2007-03-12 16:50:54 +01:00
static void shader_glsl_load_constantsI(
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
IWineD3DBaseShaderImpl* This,
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
WineD3D_GL_Info *gl_info,
GLhandleARB programId,
wined3d: Store integer uniform locations.
2007-11-06 23:36:10 +01:00
GLhandleARB locations[MAX_CONST_I],
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
unsigned max_constants,
int* constants,
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
BOOL* constants_set) {
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
int i;
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
struct list* ptr;
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
for (i=0; i<max_constants; ++i) {
if (NULL == constants_set || constants_set[i]) {
wined3d: Give shader constants their own debug channel.
2007-01-17 21:41:46 +01:00
TRACE_(d3d_constants)("Loading constants %i: %i, %i, %i, %i\n",
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
i, constants[i*4], constants[i*4+1], constants[i*4+2], constants[i*4+3]);
wined3d: Store integer uniform locations.
2007-11-06 23:36:10 +01:00
/* We found this uniform name in the program - go ahead and send the data */
GL_EXTCALL(glUniform4ivARB(locations[i], 1, &constants[i*4]));
checkGLcall("glUniform4ivARB");
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
}
}
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
/* Load immediate constants */
ptr = list_head(&This->baseShader.constantsI);
while (ptr) {
local_constant* lconst = LIST_ENTRY(ptr, struct local_constant, entry);
unsigned int idx = lconst->idx;
GLint* values = (GLint*) lconst->value;
wined3d: Give shader constants their own debug channel.
2007-01-17 21:41:46 +01:00
TRACE_(d3d_constants)("Loading local constants %i: %i, %i, %i, %i\n", idx,
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
values[0], values[1], values[2], values[3]);
wined3d: Store integer uniform locations.
2007-11-06 23:36:10 +01:00
/* We found this uniform name in the program - go ahead and send the data */
GL_EXTCALL(glUniform4ivARB(locations[idx], 1, values));
checkGLcall("glUniform4ivARB");
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
ptr = list_next(&This->baseShader.constantsI, ptr);
}
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
}
/**
* Loads boolean constants (aka uniforms) into the currently set GLSL program.
* When @constants_set == NULL, it will load all the constants.
*/
Mark several functions as static.
2007-03-12 16:50:54 +01:00
static void shader_glsl_load_constantsB(
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
IWineD3DBaseShaderImpl* This,
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
WineD3D_GL_Info *gl_info,
GLhandleARB programId,
unsigned max_constants,
BOOL* constants,
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
BOOL* constants_set) {
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
GLhandleARB tmp_loc;
int i;
wined3d: Fix vertex shader corruption issue.
2006-08-13 11:18:12 +02:00
char tmp_name[8];
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
char is_pshader = shader_is_pshader_version(This->baseShader.hex_version);
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
const char* prefix = is_pshader? "PB":"VB";
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
struct list* ptr;
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
for (i=0; i<max_constants; ++i) {
if (NULL == constants_set || constants_set[i]) {
wined3d: Bool constants aren't vectors.
2007-11-18 17:28:32 +01:00
TRACE_(d3d_constants)("Loading constants %i: %i;\n", i, constants[i]);
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
/* TODO: Benchmark and see if it would be beneficial to store the
* locations of the constants to avoid looking up each time */
snprintf(tmp_name, sizeof(tmp_name), "%s[%i]", prefix, i);
tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name));
if (tmp_loc != -1) {
/* We found this uniform name in the program - go ahead and send the data */
wined3d: Bool constants aren't vectors.
2007-11-18 17:28:32 +01:00
GL_EXTCALL(glUniform1ivARB(tmp_loc, 1, &constants[i]));
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
checkGLcall("glUniform1ivARB");
}
}
}
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
/* Load immediate constants */
ptr = list_head(&This->baseShader.constantsB);
while (ptr) {
local_constant* lconst = LIST_ENTRY(ptr, struct local_constant, entry);
unsigned int idx = lconst->idx;
GLint* values = (GLint*) lconst->value;
wined3d: Give shader constants their own debug channel.
2007-01-17 21:41:46 +01:00
TRACE_(d3d_constants)("Loading local constants %i: %i\n", idx, values[0]);
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
snprintf(tmp_name, sizeof(tmp_name), "%s[%i]", prefix, idx);
tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name));
if (tmp_loc != -1) {
/* We found this uniform name in the program - go ahead and send the data */
GL_EXTCALL(glUniform1ivARB(tmp_loc, 1, values));
checkGLcall("glUniform1ivARB");
}
ptr = list_next(&This->baseShader.constantsB, ptr);
}
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
}
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
/**
* Loads the app-supplied constants into the currently set GLSL program.
*/
wined3d: Make some GLSL structs and functions private to the backend.
2008-09-16 14:55:39 +02:00
static void shader_glsl_load_constants(
wined3d: Read GL info and load constants into the same device.
2006-09-27 13:15:58 +02:00
IWineD3DDevice* device,
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
char usePixelShader,
char useVertexShader) {
wined3d: Read GL info and load constants into the same device.
2006-09-27 13:15:58 +02:00
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) device;
wined3d: Store the current GLSL program in the backend's private data.
2008-07-07 21:02:57 +02:00
struct shader_glsl_priv *priv = (struct shader_glsl_priv *)deviceImpl->shader_priv;
wined3d: Read GL info and load constants into the same device.
2006-09-27 13:15:58 +02:00
IWineD3DStateBlockImpl* stateBlock = deviceImpl->stateBlock;
wined3d: Store the gl information in a per adapter structure and initialize it only once.
2007-06-09 14:27:41 +02:00
WineD3D_GL_Info *gl_info = &deviceImpl->adapter->gl_info;
wined3d: Read GL info and load constants into the same device.
2006-09-27 13:15:58 +02:00
wined3d: Lookup GLSL float uniform locations only once per program.
2006-08-19 17:23:20 +02:00
GLhandleARB *constant_locations;
wined3d: Improve float constant loading a bit. - Use a list to keep track of what constants are set. - Move TRACEs and checkGLcall calls out of the main constant loading loop.
2006-08-19 17:24:02 +02:00
struct list *constant_list;
wined3d: Lookup GLSL float uniform locations only once per program.
2006-08-19 17:23:20 +02:00
GLhandleARB programId;
wined3d: Store the current GLSL program in the backend's private data.
2008-07-07 21:02:57 +02:00
struct glsl_shader_prog_link *prog = priv->glsl_program;
wined3d: Support more than one texbem instruction per shader.
2008-03-05 03:18:55 +01:00
unsigned int i;
wined3d: Load one bump mapping environment matrix into pixel shaders if needed.
2007-02-15 03:05:17 +01:00
wined3d: Store the special uniforms' locations in the linked program.
2007-11-06 23:05:38 +01:00
if (!prog) {
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
/* No GLSL program set - nothing to do. */
return;
}
wined3d: Store the special uniforms' locations in the linked program.
2007-11-06 23:05:38 +01:00
programId = prog->programId;
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
if (useVertexShader) {
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
IWineD3DBaseShaderImpl* vshader = (IWineD3DBaseShaderImpl*) stateBlock->vertexShader;
wined3d: Store the special uniforms' locations in the linked program.
2007-11-06 23:05:38 +01:00
constant_locations = prog->vuniformF_locations;
wined3d: Improve float constant loading a bit. - Use a list to keep track of what constants are set. - Move TRACEs and checkGLcall calls out of the main constant loading loop.
2006-08-19 17:24:02 +02:00
constant_list = &stateBlock->set_vconstantsF;
wined3d: Lookup GLSL float uniform locations only once per program.
2006-08-19 17:23:20 +02:00
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
/* Load DirectX 9 float constants/uniforms for vertex shader */
wined3d: Lookup GLSL float uniform locations only once per program.
2006-08-19 17:23:20 +02:00
shader_glsl_load_constantsF(vshader, gl_info, GL_LIMITS(vshader_constantsF),
wined3d: Improve float constant loading a bit. - Use a list to keep track of what constants are set. - Move TRACEs and checkGLcall calls out of the main constant loading loop.
2006-08-19 17:24:02 +02:00
stateBlock->vertexShaderConstantF, constant_locations, constant_list);
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
/* Load DirectX 9 integer constants/uniforms for vertex shader */
wined3d: Store integer uniform locations.
2007-11-06 23:36:10 +01:00
shader_glsl_load_constantsI(vshader, gl_info, programId,
prog->vuniformI_locations, MAX_CONST_I,
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
stateBlock->vertexShaderConstantI,
wined3d: Remove stateblock::set.*.
2007-07-30 19:28:33 +02:00
stateBlock->changed.vertexShaderConstantsI);
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
/* Load DirectX 9 boolean constants/uniforms for vertex shader */
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
shader_glsl_load_constantsB(vshader, gl_info, programId, MAX_CONST_B,
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
stateBlock->vertexShaderConstantB,
wined3d: Remove stateblock::set.*.
2007-07-30 19:28:33 +02:00
stateBlock->changed.vertexShaderConstantsB);
wined3d: Avoid wasting a uniform.
2006-09-23 19:09:06 +02:00
/* Upload the position fixup params */
wined3d: Store the special uniforms' locations in the linked program.
2007-11-06 23:05:38 +01:00
GL_EXTCALL(glUniform4fvARB(prog->posFixup_location, 1, &deviceImpl->posFixup[0]));
wined3d: Avoid wasting a uniform.
2006-09-23 19:09:06 +02:00
checkGLcall("glUniform4fvARB");
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
}
if (usePixelShader) {
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
IWineD3DBaseShaderImpl* pshader = (IWineD3DBaseShaderImpl*) stateBlock->pixelShader;
wined3d: Store integer uniform locations.
2007-11-06 23:36:10 +01:00
constant_locations = prog->puniformF_locations;
wined3d: Improve float constant loading a bit. - Use a list to keep track of what constants are set. - Move TRACEs and checkGLcall calls out of the main constant loading loop.
2006-08-19 17:24:02 +02:00
constant_list = &stateBlock->set_pconstantsF;
wined3d: Lookup GLSL float uniform locations only once per program.
2006-08-19 17:23:20 +02:00
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
/* Load DirectX 9 float constants/uniforms for pixel shader */
wined3d: Lookup GLSL float uniform locations only once per program.
2006-08-19 17:23:20 +02:00
shader_glsl_load_constantsF(pshader, gl_info, GL_LIMITS(pshader_constantsF),
wined3d: Improve float constant loading a bit. - Use a list to keep track of what constants are set. - Move TRACEs and checkGLcall calls out of the main constant loading loop.
2006-08-19 17:24:02 +02:00
stateBlock->pixelShaderConstantF, constant_locations, constant_list);
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
/* Load DirectX 9 integer constants/uniforms for pixel shader */
wined3d: Store integer uniform locations.
2007-11-06 23:36:10 +01:00
shader_glsl_load_constantsI(pshader, gl_info, programId,
prog->puniformI_locations, MAX_CONST_I,
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
stateBlock->pixelShaderConstantI,
wined3d: Remove stateblock::set.*.
2007-07-30 19:28:33 +02:00
stateBlock->changed.pixelShaderConstantsI);
wined3d: Load one bump mapping environment matrix into pixel shaders if needed.
2007-02-15 03:05:17 +01:00
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
/* Load DirectX 9 boolean constants/uniforms for pixel shader */
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
shader_glsl_load_constantsB(pshader, gl_info, programId, MAX_CONST_B,
wined3d: Load boolean and integer constants into the GLSL shader program.
2006-06-16 22:08:34 +02:00
stateBlock->pixelShaderConstantB,
wined3d: Remove stateblock::set.*.
2007-07-30 19:28:33 +02:00
stateBlock->changed.pixelShaderConstantsB);
wined3d: Load one bump mapping environment matrix into pixel shaders if needed.
2007-02-15 03:05:17 +01:00
/* Upload the environment bump map matrix if needed. The needsbumpmat member specifies the texture stage to load the matrix from.
* It can't be 0 for a valid texbem instruction.
*/
wined3d: Support more than one texbem instruction per shader.
2008-03-05 03:18:55 +01:00
for(i = 0; i < ((IWineD3DPixelShaderImpl *) pshader)->numbumpenvmatconsts; i++) {
IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *) pshader;
int stage = ps->luminanceconst[i].texunit;
float *data = (float *) &stateBlock->textureState[(int) ps->bumpenvmatconst[i].texunit][WINED3DTSS_BUMPENVMAT00];
GL_EXTCALL(glUniformMatrix2fvARB(prog->bumpenvmat_location[i], 1, 0, data));
wined3d: Implement texbeml.
2007-09-01 20:11:17 +02:00
checkGLcall("glUniformMatrix2fvARB");
/* texbeml needs the luminance scale and offset too. If texbeml is used, needsbumpmat
* is set too, so we can check that in the needsbumpmat check
*/
wined3d: Support more than one texbem instruction per shader.
2008-03-05 03:18:55 +01:00
if(ps->baseShader.reg_maps.luminanceparams[stage]) {
wined3d: Implement texbeml.
2007-09-01 20:11:17 +02:00
GLfloat *scale = (GLfloat *) &stateBlock->textureState[stage][WINED3DTSS_BUMPENVLSCALE];
GLfloat *offset = (GLfloat *) &stateBlock->textureState[stage][WINED3DTSS_BUMPENVLOFFSET];
wined3d: Support more than one texbem instruction per shader.
2008-03-05 03:18:55 +01:00
GL_EXTCALL(glUniform1fvARB(prog->luminancescale_location[i], 1, scale));
wined3d: Implement texbeml.
2007-09-01 20:11:17 +02:00
checkGLcall("glUniform1fvARB");
wined3d: Support more than one texbem instruction per shader.
2008-03-05 03:18:55 +01:00
GL_EXTCALL(glUniform1fvARB(prog->luminanceoffset_location[i], 1, offset));
wined3d: Implement texbeml.
2007-09-01 20:11:17 +02:00
checkGLcall("glUniform1fvARB");
}
wined3d: Support more than one texbem instruction per shader.
2008-03-05 03:18:55 +01:00
}
if(((IWineD3DPixelShaderImpl *) pshader)->srgb_enabled &&
wined3d: SRGB write correction emulation.
2007-09-14 13:02:59 +02:00
!((IWineD3DPixelShaderImpl *) pshader)->srgb_mode_hardcoded) {
float comparison[4];
float mul_low[4];
if(stateBlock->renderState[WINED3DRS_SRGBWRITEENABLE]) {
comparison[0] = srgb_cmp; comparison[1] = srgb_cmp;
comparison[2] = srgb_cmp; comparison[3] = srgb_cmp;
mul_low[0] = srgb_mul_low; mul_low[1] = srgb_mul_low;
mul_low[2] = srgb_mul_low; mul_low[3] = srgb_mul_low;
} else {
comparison[0] = 1.0 / 0.0; comparison[1] = 1.0 / 0.0;
comparison[2] = 1.0 / 0.0; comparison[3] = 1.0 / 0.0;
mul_low[0] = 1.0; mul_low[1] = 1.0;
mul_low[2] = 1.0; mul_low[3] = 1.0;
}
wined3d: Store the special uniforms' locations in the linked program.
2007-11-06 23:05:38 +01:00
GL_EXTCALL(glUniform4fvARB(prog->srgb_comparison_location, 1, comparison));
GL_EXTCALL(glUniform4fvARB(prog->srgb_mul_low_location, 1, mul_low));
wined3d: Load one bump mapping environment matrix into pixel shaders if needed.
2007-02-15 03:05:17 +01:00
}
wined3d: Reverse the position fixup if the pshader is reading vpos.
2007-09-14 13:11:00 +02:00
if(((IWineD3DPixelShaderImpl *) pshader)->vpos_uniform) {
float correction_params[4];
if(deviceImpl->render_offscreen) {
correction_params[0] = 0.0;
correction_params[1] = 1.0;
} else {
/* position is window relative, not viewport relative */
correction_params[0] = ((IWineD3DSurfaceImpl *) deviceImpl->render_targets[0])->currentDesc.Height;
correction_params[1] = -1.0;
}
wined3d: Store the special uniforms' locations in the linked program.
2007-11-06 23:05:38 +01:00
GL_EXTCALL(glUniform4fvARB(prog->ycorrection_location, 1, correction_params));
wined3d: Reverse the position fixup if the pshader is reading vpos.
2007-09-14 13:11:00 +02:00
}
wined3d: Move constant loading into target-specific files. - Moves GLSL constant loading code into glsl_shader.c and out of the over-populated drawprim.c. - Creates a new file named arb_program_shader.c which will hold code specific to ARB_vertex_program & ARB_fragment_program. - Remove the constant loading calls from drawprim.c
2006-06-16 22:07:00 +02:00
}
}
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
/** Generate the variable & register declarations for the GLSL output target */
wined3d: Make some GLSL structs and functions private to the backend.
2008-09-16 14:55:39 +02:00
static void shader_generate_glsl_declarations(
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
IWineD3DBaseShader *iface,
shader_reg_maps* reg_maps,
wined3d: Make the number of floating point shader constants dynamic.
2006-07-19 06:06:07 +02:00
SHADER_BUFFER* buffer,
WineD3D_GL_Info* gl_info) {
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
wined3d: SRGB write correction emulation.
2007-09-14 13:02:59 +02:00
IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device;
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
int i;
wined3d: SRGB write correction emulation.
2007-09-14 13:02:59 +02:00
unsigned int extra_constants_needed = 0;
wined3d: Hardcode local constants into the shader if possible.
2007-11-09 14:48:47 +01:00
local_constant* lconst;
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
/* There are some minor differences between pixel and vertex shaders */
char pshader = shader_is_pshader_version(This->baseShader.hex_version);
char prefix = pshader ? 'P' : 'V';
wined3d: More flow control instructions. - Implement call, callnz, label, and ret - Implement support for NOT modifier
2006-07-10 12:35:15 +02:00
/* Prototype the subroutines */
for (i = 0; i < This->baseShader.limits.label; i++) {
if (reg_maps->labels[i])
wined3d: Add printf format checking to the shader_addline function and fix resulting warnings.
2007-11-28 12:55:11 +01:00
shader_addline(buffer, "void subroutine%u();\n", i);
wined3d: More flow control instructions. - Implement call, callnz, label, and ret - Implement support for NOT modifier
2006-07-10 12:35:15 +02:00
}
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
/* Declare the constants (aka uniforms) */
wined3d: Make the number of floating point shader constants dynamic.
2006-07-19 06:06:07 +02:00
if (This->baseShader.limits.constant_float > 0) {
unsigned max_constantsF = min(This->baseShader.limits.constant_float,
(pshader ? GL_LIMITS(pshader_constantsF) : GL_LIMITS(vshader_constantsF)));
shader_addline(buffer, "uniform vec4 %cC[%u];\n", prefix, max_constantsF);
}
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
if (This->baseShader.limits.constant_int > 0)
shader_addline(buffer, "uniform ivec4 %cI[%u];\n", prefix, This->baseShader.limits.constant_int);
if (This->baseShader.limits.constant_bool > 0)
shader_addline(buffer, "uniform bool %cB[%u];\n", prefix, This->baseShader.limits.constant_bool);
wined3d: SRGB write correction emulation.
2007-09-14 13:02:59 +02:00
if(!pshader) {
wined3d: Avoid wasting a uniform.
2006-09-23 19:09:06 +02:00
shader_addline(buffer, "uniform vec4 posFixup;\n");
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
/* Predeclaration; This function is added at link time based on the pixel shader.
* VS 3.0 shaders have an array OUT[] the shader writes to, earlier versions don't have
* that. We know the input to the reorder function at vertex shader compile time, so
* we can deal with that. The reorder function for a 1.x and 2.x vertex shader can just
* read gl_FrontColor. The output depends on the pixel shader. The reorder function for a
* 1.x and 2.x pshader or for fixed function will write gl_FrontColor, and for a 3.0 shader
* it will write to the varying array. Here we depend on the shader optimizer on sorting that
* out. The nvidia driver only does that if the parameter is inout instead of out, hence the
* inout.
*/
if(This->baseShader.hex_version >= WINED3DVS_VERSION(3, 0)) {
shader_addline(buffer, "void order_ps_input(in vec4[%u]);\n", MAX_REG_OUTPUT);
} else {
shader_addline(buffer, "void order_ps_input();\n");
}
wined3d: SRGB write correction emulation.
2007-09-14 13:02:59 +02:00
} else {
IWineD3DPixelShaderImpl *ps_impl = (IWineD3DPixelShaderImpl *) This;
wined3d: Support more than one texbem instruction per shader.
2008-03-05 03:18:55 +01:00
ps_impl->numbumpenvmatconsts = 0;
for(i = 0; i < (sizeof(reg_maps->bumpmat) / sizeof(reg_maps->bumpmat[0])); i++) {
if(!reg_maps->bumpmat[i]) {
continue;
}
ps_impl->bumpenvmatconst[(int) ps_impl->numbumpenvmatconsts].texunit = i;
shader_addline(buffer, "uniform mat2 bumpenvmat%d;\n", i);
wined3d: SRGB write correction emulation.
2007-09-14 13:02:59 +02:00
if(reg_maps->luminanceparams) {
wined3d: Support more than one texbem instruction per shader.
2008-03-05 03:18:55 +01:00
ps_impl->luminanceconst[(int) ps_impl->numbumpenvmatconsts].texunit = i;
shader_addline(buffer, "uniform float luminancescale%d;\n", i);
shader_addline(buffer, "uniform float luminanceoffset%d;\n", i);
wined3d: SRGB write correction emulation.
2007-09-14 13:02:59 +02:00
extra_constants_needed++;
wined3d: Support more than one texbem instruction per shader.
2008-03-05 03:18:55 +01:00
} else {
ps_impl->luminanceconst[(int) ps_impl->numbumpenvmatconsts].texunit = -1;
wined3d: SRGB write correction emulation.
2007-09-14 13:02:59 +02:00
}
wined3d: Support more than one texbem instruction per shader.
2008-03-05 03:18:55 +01:00
wined3d: SRGB write correction emulation.
2007-09-14 13:02:59 +02:00
extra_constants_needed++;
wined3d: Support more than one texbem instruction per shader.
2008-03-05 03:18:55 +01:00
ps_impl->numbumpenvmatconsts++;
wined3d: SRGB write correction emulation.
2007-09-14 13:02:59 +02:00
}
if(device->stateBlock->renderState[WINED3DRS_SRGBWRITEENABLE]) {
ps_impl->srgb_enabled = 1;
if(This->baseShader.limits.constant_float + extra_constants_needed + 1 < GL_LIMITS(pshader_constantsF)) {
shader_addline(buffer, "uniform vec4 srgb_mul_low;\n");
shader_addline(buffer, "uniform vec4 srgb_comparison;\n");
ps_impl->srgb_mode_hardcoded = 0;
wined3d: Reverse the position fixup if the pshader is reading vpos.
2007-09-14 13:11:00 +02:00
extra_constants_needed++;
wined3d: SRGB write correction emulation.
2007-09-14 13:02:59 +02:00
} else {
ps_impl->srgb_mode_hardcoded = 1;
wined3d: Get rid of a few Nvidiaisms in glsl shaders.
2007-11-09 14:52:56 +01:00
shader_addline(buffer, "const vec4 srgb_mul_low = vec4(%f, %f, %f, %f);\n",
wined3d: SRGB write correction emulation.
2007-09-14 13:02:59 +02:00
srgb_mul_low, srgb_mul_low, srgb_mul_low, srgb_mul_low);
wined3d: Get rid of a few Nvidiaisms in glsl shaders.
2007-11-09 14:52:56 +01:00
shader_addline(buffer, "const vec4 srgb_comparison = vec4(%f, %f, %f, %f);\n",
wined3d: SRGB write correction emulation.
2007-09-14 13:02:59 +02:00
srgb_cmp, srgb_cmp, srgb_cmp, srgb_cmp);
}
} else {
IWineD3DPixelShaderImpl *ps_impl = (IWineD3DPixelShaderImpl *) This;
/* Do not write any srgb fixup into the shader to save shader size and processing time.
* As a consequence, we can't toggle srgb write on without recompilation
*/
ps_impl->srgb_enabled = 0;
ps_impl->srgb_mode_hardcoded = 1;
wined3d: Implement texbeml.
2007-09-01 20:11:17 +02:00
}
wined3d: Care for the inverted y coords in dsy.
2007-10-13 13:03:56 +02:00
if(reg_maps->vpos || reg_maps->usesdsy) {
wined3d: Reverse the position fixup if the pshader is reading vpos.
2007-09-14 13:11:00 +02:00
if(This->baseShader.limits.constant_float + extra_constants_needed + 1 < GL_LIMITS(pshader_constantsF)) {
shader_addline(buffer, "uniform vec4 ycorrection;\n");
((IWineD3DPixelShaderImpl *) This)->vpos_uniform = 1;
extra_constants_needed++;
} else {
/* This happens because we do not have proper tracking of the constant registers that are
* actually used, only the max limit of the shader version
*/
FIXME("Cannot find a free uniform for vpos correction params\n");
wined3d: Get rid of a few Nvidiaisms in glsl shaders.
2007-11-09 14:52:56 +01:00
shader_addline(buffer, "const vec4 ycorrection = vec4(%f, %f, 0.0, 0.0);\n",
wined3d: Reverse the position fixup if the pshader is reading vpos.
2007-09-14 13:11:00 +02:00
device->render_offscreen ? 0.0 : ((IWineD3DSurfaceImpl *) device->render_targets[0])->currentDesc.Height,
device->render_offscreen ? 1.0 : -1.0);
}
shader_addline(buffer, "vec4 vpos;\n");
}
wined3d: Implement texbeml.
2007-09-01 20:11:17 +02:00
}
wined3d: Avoid wasting a uniform.
2006-09-23 19:09:06 +02:00
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
/* Declare texture samplers */
for (i = 0; i < This->baseShader.limits.sampler; i++) {
if (reg_maps->samplers[i]) {
wined3d: Declare a 1D sampler for TEXDP3TEX (GLSL).
2006-07-28 21:34:39 +02:00
DWORD stype = reg_maps->samplers[i] & WINED3DSP_TEXTURETYPE_MASK;
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
switch (stype) {
wined3d: Declare a 1D sampler for TEXDP3TEX (GLSL).
2006-07-28 21:34:39 +02:00
case WINED3DSTT_1D:
wined3d: Add printf format checking to the shader_addline function and fix resulting warnings.
2007-11-28 12:55:11 +01:00
shader_addline(buffer, "uniform sampler1D %csampler%u;\n", prefix, i);
wined3d: Declare a 1D sampler for TEXDP3TEX (GLSL).
2006-07-28 21:34:39 +02:00
break;
case WINED3DSTT_2D:
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
if(device->stateBlock->textures[i] &&
IWineD3DBaseTexture_GetTextureDimensions(device->stateBlock->textures[i]) == GL_TEXTURE_RECTANGLE_ARB) {
shader_addline(buffer, "uniform sampler2DRect %csampler%u;\n", prefix, i);
} else {
shader_addline(buffer, "uniform sampler2D %csampler%u;\n", prefix, i);
}
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
break;
wined3d: Declare a 1D sampler for TEXDP3TEX (GLSL).
2006-07-28 21:34:39 +02:00
case WINED3DSTT_CUBE:
wined3d: Add printf format checking to the shader_addline function and fix resulting warnings.
2007-11-28 12:55:11 +01:00
shader_addline(buffer, "uniform samplerCube %csampler%u;\n", prefix, i);
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
break;
wined3d: Declare a 1D sampler for TEXDP3TEX (GLSL).
2006-07-28 21:34:39 +02:00
case WINED3DSTT_VOLUME:
wined3d: Add printf format checking to the shader_addline function and fix resulting warnings.
2007-11-28 12:55:11 +01:00
shader_addline(buffer, "uniform sampler3D %csampler%u;\n", prefix, i);
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
break;
default:
wined3d: Add printf format checking to the shader_addline function and fix resulting warnings.
2007-11-28 12:55:11 +01:00
shader_addline(buffer, "uniform unsupported_sampler %csampler%u;\n", prefix, i);
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
FIXME("Unrecognized sampler type: %#x\n", stype);
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
break;
}
}
}
/* Declare address variables */
for (i = 0; i < This->baseShader.limits.address; i++) {
if (reg_maps->address[i])
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
shader_addline(buffer, "ivec4 A%d;\n", i);
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
}
/* Declare texture coordinate temporaries and initialize them */
for (i = 0; i < This->baseShader.limits.texcoord; i++) {
if (reg_maps->texcoord[i])
wined3d: Add printf format checking to the shader_addline function and fix resulting warnings.
2007-11-28 12:55:11 +01:00
shader_addline(buffer, "vec4 T%u = gl_TexCoord[%u];\n", i, i);
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
}
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
/* Declare input register varyings. Only pixel shader, vertex shaders have that declared in the
* helper function shader that is linked in at link time
*/
wined3d: Correct a pixel shader version comparison.
2007-12-14 22:09:07 +01:00
if(pshader && This->baseShader.hex_version >= WINED3DPS_VERSION(3, 0)) {
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
if(use_vs(device)) {
wined3d: Add printf format checking to the shader_addline function and fix resulting warnings.
2007-11-28 12:55:11 +01:00
shader_addline(buffer, "varying vec4 IN[%u];\n", GL_LIMITS(glsl_varyings) / 4);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
} else {
/* TODO: Write a replacement shader for the fixed function vertex pipeline, so this isn't needed.
* For fixed function vertex processing + 3.0 pixel shader we need a separate function in the
* pixel shader that reads the fixed function color into the packed input registers.
*/
wined3d: Add printf format checking to the shader_addline function and fix resulting warnings.
2007-11-28 12:55:11 +01:00
shader_addline(buffer, "vec4 IN[%u];\n", GL_LIMITS(glsl_varyings) / 4);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
}
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
}
/* Declare output register temporaries */
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
if(This->baseShader.limits.packed_output) {
wined3d: Add printf format checking to the shader_addline function and fix resulting warnings.
2007-11-28 12:55:11 +01:00
shader_addline(buffer, "vec4 OUT[%u];\n", This->baseShader.limits.packed_output);
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
}
/* Declare temporary variables */
for(i = 0; i < This->baseShader.limits.temporary; i++) {
if (reg_maps->temporary[i])
wined3d: Add printf format checking to the shader_addline function and fix resulting warnings.
2007-11-28 12:55:11 +01:00
shader_addline(buffer, "vec4 R%u;\n", i);
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
}
/* Declare attributes */
for (i = 0; i < This->baseShader.limits.attributes; i++) {
if (reg_maps->attributes[i])
shader_addline(buffer, "attribute vec4 attrib%i;\n", i);
}
Spelling fixes.
2008-04-23 07:13:32 +02:00
/* Declare loop registers aLx */
wined3d: Nested loop support.
2007-09-14 13:21:52 +02:00
for (i = 0; i < reg_maps->loop_depth; i++) {
shader_addline(buffer, "int aL%u;\n", i);
shader_addline(buffer, "int tmpInt%u;\n", i);
wined3d: Correct implementation of D3DSIO_LOOP. I initially misread the specification. src0.x is the iteration count, not the max amount for the loop register. This fixes that.
2006-06-17 05:01:20 +02:00
}
wined3d: Nested loop support.
2007-09-14 13:21:52 +02:00
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
/* Temporary variables for matrix operations */
shader_addline(buffer, "vec4 tmp0;\n");
shader_addline(buffer, "vec4 tmp1;\n");
wined3d: Hardcode local constants with glUniform4fvARB.
2008-06-02 21:44:06 +02:00
/* Local constants use a different name so they can be loaded once at shader link time
* They can't be hardcoded into the shader text via LC = {x, y, z, w}; because the
* float -> string conversion can cause precision loss.
*/
wined3d: Hardcode local constants into the shader if possible.
2007-11-09 14:48:47 +01:00
if(!This->baseShader.load_local_constsF) {
LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
wined3d: Hardcode local constants with glUniform4fvARB.
2008-06-02 21:44:06 +02:00
shader_addline(buffer, "uniform vec4 %cLC%u;\n", prefix, lconst->idx);
wined3d: Hardcode local constants into the shader if possible.
2007-11-09 14:48:47 +01:00
}
}
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
/* Start the main program */
shader_addline(buffer, "void main() {\n");
wined3d: Reverse the position fixup if the pshader is reading vpos.
2007-09-14 13:11:00 +02:00
if(pshader && reg_maps->vpos) {
wined3d: gl_FragCoord isn't exact.
2008-03-07 03:13:07 +01:00
/* DirectX apps expect integer values, while OpenGL drivers add approximately 0.5. This causes
* off-by-one problems as spotted by the vPos d3d9 visual test. Unfortunately the ATI cards do
* not add exactly 0.5, but rather something like 0.49999999 or 0.50000001, which still causes
* precision troubles when we just substract 0.5.
*
* To deal with that just floor() the position. This will eliminate the fraction on all cards.
*
* TODO: Test how that behaves with multisampling once we can enable multisampling in winex11.
*
* An advantage of floor is that it works even if the driver doesn't add 1/2. It is somewhat
* questionable if 1.5, 2.5, ... are the proper values to return in gl_FragCoord, even though
* coordinates specify the pixel centers instead of the pixel corners. This code will behave
* correctly on drivers that returns integer values.
*/
shader_addline(buffer, "vpos = floor(vec4(0, ycorrection[0], 0, 0) + gl_FragCoord * vec4(1, ycorrection[1], 1, 1));\n");
wined3d: Reverse the position fixup if the pshader is reading vpos.
2007-09-14 13:11:00 +02:00
}
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
}
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
/*****************************************************************************
* Functions to generate GLSL strings from DirectX Shader bytecode begin here.
*
* For more information, see http://wiki.winehq.org/DirectX-Shaders
****************************************************************************/
/* Prototypes */
wined3d: Split shader_glsl_add_param() in shader_glsl_add_src_param() and shader_glsl_add_dst_param().
2007-01-15 19:30:20 +01:00
static void shader_glsl_add_src_param(SHADER_OPCODE_ARG* arg, const DWORD param,
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
const DWORD addr_token, DWORD mask, glsl_src_param_t *src_param);
wined3d: Pass a mask to shader_glsl_add_src_param().
2007-01-15 19:31:06 +01:00
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
/** Used for opcode modifiers - They multiply the result by the specified amount */
wined3d: Make some data const.
2006-12-14 15:47:59 +01:00
static const char * const shift_glsl_tab[] = {
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
"", /* 0 (none) */
"2.0 * ", /* 1 (x2) */
"4.0 * ", /* 2 (x4) */
"8.0 * ", /* 3 (x8) */
"16.0 * ", /* 4 (x16) */
"32.0 * ", /* 5 (x32) */
"", /* 6 (x64) */
"", /* 7 (x128) */
"", /* 8 (d256) */
"", /* 9 (d128) */
"", /* 10 (d64) */
"", /* 11 (d32) */
"0.0625 * ", /* 12 (d16) */
"0.125 * ", /* 13 (d8) */
"0.25 * ", /* 14 (d4) */
"0.5 * " /* 15 (d2) */
};
/* Generate a GLSL parameter that does the input modifier computation and return the input register/mask to use */
wined3d: Make all the local shader functions static.
2006-06-10 13:22:27 +02:00
static void shader_glsl_gen_modifier (
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
const DWORD instr,
const char *in_reg,
const char *in_regswizzle,
char *out_str) {
out_str[0] = 0;
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
if (instr == WINED3DSIO_TEXKILL)
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
return;
wined3d: Move D3DSP source modifier-related items into the WINED3D namespace.
2006-10-10 01:47:42 +02:00
switch (instr & WINED3DSP_SRCMOD_MASK) {
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
case WINED3DSPSM_DZ: /* Need to handle this in the instructions itself (texld & texcrd). */
case WINED3DSPSM_DW:
wined3d: Move D3DSP source modifier-related items into the WINED3D namespace.
2006-10-10 01:47:42 +02:00
case WINED3DSPSM_NONE:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
sprintf(out_str, "%s%s", in_reg, in_regswizzle);
break;
wined3d: Move D3DSP source modifier-related items into the WINED3D namespace.
2006-10-10 01:47:42 +02:00
case WINED3DSPSM_NEG:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
sprintf(out_str, "-%s%s", in_reg, in_regswizzle);
break;
wined3d: Move D3DSP source modifier-related items into the WINED3D namespace.
2006-10-10 01:47:42 +02:00
case WINED3DSPSM_NOT:
wined3d: More flow control instructions. - Implement call, callnz, label, and ret - Implement support for NOT modifier
2006-07-10 12:35:15 +02:00
sprintf(out_str, "!%s%s", in_reg, in_regswizzle);
break;
wined3d: Move D3DSP source modifier-related items into the WINED3D namespace.
2006-10-10 01:47:42 +02:00
case WINED3DSPSM_BIAS:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
sprintf(out_str, "(%s%s - vec4(0.5)%s)", in_reg, in_regswizzle, in_regswizzle);
break;
wined3d: Move D3DSP source modifier-related items into the WINED3D namespace.
2006-10-10 01:47:42 +02:00
case WINED3DSPSM_BIASNEG:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
sprintf(out_str, "-(%s%s - vec4(0.5)%s)", in_reg, in_regswizzle, in_regswizzle);
break;
wined3d: Move D3DSP source modifier-related items into the WINED3D namespace.
2006-10-10 01:47:42 +02:00
case WINED3DSPSM_SIGN:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
sprintf(out_str, "(2.0 * (%s%s - 0.5))", in_reg, in_regswizzle);
break;
wined3d: Move D3DSP source modifier-related items into the WINED3D namespace.
2006-10-10 01:47:42 +02:00
case WINED3DSPSM_SIGNNEG:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
sprintf(out_str, "-(2.0 * (%s%s - 0.5))", in_reg, in_regswizzle);
break;
wined3d: Move D3DSP source modifier-related items into the WINED3D namespace.
2006-10-10 01:47:42 +02:00
case WINED3DSPSM_COMP:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
sprintf(out_str, "(1.0 - %s%s)", in_reg, in_regswizzle);
break;
wined3d: Move D3DSP source modifier-related items into the WINED3D namespace.
2006-10-10 01:47:42 +02:00
case WINED3DSPSM_X2:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
sprintf(out_str, "(2.0 * %s%s)", in_reg, in_regswizzle);
break;
wined3d: Move D3DSP source modifier-related items into the WINED3D namespace.
2006-10-10 01:47:42 +02:00
case WINED3DSPSM_X2NEG:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
sprintf(out_str, "-(2.0 * %s%s)", in_reg, in_regswizzle);
break;
wined3d: Move D3DSP source modifier-related items into the WINED3D namespace.
2006-10-10 01:47:42 +02:00
case WINED3DSPSM_ABS:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
sprintf(out_str, "abs(%s%s)", in_reg, in_regswizzle);
break;
wined3d: Move D3DSP source modifier-related items into the WINED3D namespace.
2006-10-10 01:47:42 +02:00
case WINED3DSPSM_ABSNEG:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
sprintf(out_str, "-abs(%s%s)", in_reg, in_regswizzle);
break;
default:
wined3d: Move D3DSP source modifier-related items into the WINED3D namespace.
2006-10-10 01:47:42 +02:00
FIXME("Unhandled modifier %u\n", (instr & WINED3DSP_SRCMOD_MASK));
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
sprintf(out_str, "%s%s", in_reg, in_regswizzle);
}
}
/** Writes the GLSL variable name that corresponds to the register that the
* DX opcode parameter is trying to access */
wined3d: Make all the local shader functions static.
2006-06-10 13:22:27 +02:00
static void shader_glsl_get_register_name(
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
const DWORD param,
const DWORD addr_token,
char* regstr,
BOOL* is_color,
SHADER_OPCODE_ARG* arg) {
/* oPos, oFog and oPts in D3D */
wined3d: Make some data const.
2006-12-14 15:47:59 +01:00
static const char * const hwrastout_reg_names[] = { "gl_Position", "gl_FogFragCoord", "gl_PointSize" };
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Move D3DSP_REG structures into the WINED3D namespace.
2006-10-10 01:47:12 +02:00
DWORD reg = param & WINED3DSP_REGNUM_MASK;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
DWORD regtype = shader_get_regtype(param);
IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) arg->shader;
wined3d: Move device pointer into the BaseShader class.
2006-09-27 13:14:46 +02:00
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
wined3d: Store the gl information in a per adapter structure and initialize it only once.
2007-06-09 14:27:41 +02:00
WineD3D_GL_Info* gl_info = &deviceImpl->adapter->gl_info;
wined3d: Move device pointer into the BaseShader class.
2006-09-27 13:14:46 +02:00
wined3d: Trivial cleanups - compiler warnings and errors should be FIXME - remove obsolete comment, and change variable type.
2006-06-12 08:56:13 +02:00
char pshader = shader_is_pshader_version(This->baseShader.hex_version);
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
char tmpStr[150];
wined3d: Rework dcl processing. The new function is called in pass 2 (getister counting/maps), and it's now in baseshader. It operates on all INPUT and OUTPUT registers, which, in addition to the old vertex shader input declarations covers Shader Model 3.0 vshader output and pshader input declarations. The result is stored into the reg_map structure.
2006-06-12 08:53:32 +02:00
*is_color = FALSE;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
switch (regtype) {
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-10 01:45:55 +02:00
case WINED3DSPR_TEMP:
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
sprintf(tmpStr, "R%u", reg);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-10 01:45:55 +02:00
case WINED3DSPR_INPUT:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
if (pshader) {
wined3d: Add support for shader model 3.0 I/O registers. SM 3.0 can pack multiple "semantics" into 12 generic input/output registers. To support that, define temporaries called IN and OUT, and use those as the output registers. At the end of the vshader, unpack the OUT temps into the proper GL variables. At the beginning of the pshader, pack the GL variables back into 12 IN registers.
2006-06-12 08:57:07 +02:00
/* Pixel shaders >= 3.0 */
wined3d: Pixel Shader varying indexing.
2007-10-28 00:08:56 +02:00
if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 3) {
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
DWORD in_count = GL_LIMITS(glsl_varyings) / 4;
wined3d: Pixel Shader varying indexing.
2007-10-28 00:08:56 +02:00
if (param & WINED3DSHADER_ADDRMODE_RELATIVE) {
glsl_src_param_t rel_param;
shader_glsl_add_src_param(arg, addr_token, 0, WINED3DSP_WRITEMASK_0, &rel_param);
wined3d: Avoid NOP additions.
2007-11-02 01:50:20 +01:00
/* Removing a + 0 would be an obvious optimization, but macos doesn't see the NOP
* operation there
*/
if(((IWineD3DPixelShaderImpl *) This)->input_reg_map[reg]) {
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
if (((IWineD3DPixelShaderImpl *)This)->declared_in_count > in_count) {
sprintf(tmpStr, "((%s + %u) > %d ? (%s + %u) > %d ? gl_SecondaryColor : gl_Color : IN[%s + %u])",
rel_param.param_str, ((IWineD3DPixelShaderImpl *)This)->input_reg_map[reg], in_count - 1,
rel_param.param_str, ((IWineD3DPixelShaderImpl *)This)->input_reg_map[reg], in_count,
rel_param.param_str, ((IWineD3DPixelShaderImpl *)This)->input_reg_map[reg]);
} else {
sprintf(tmpStr, "IN[%s + %u]", rel_param.param_str, ((IWineD3DPixelShaderImpl *)This)->input_reg_map[reg]);
}
wined3d: Avoid NOP additions.
2007-11-02 01:50:20 +01:00
} else {
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
if (((IWineD3DPixelShaderImpl *)This)->declared_in_count > in_count) {
sprintf(tmpStr, "((%s) > %d ? (%s) > %d ? gl_SecondaryColor : gl_Color : IN[%s])",
rel_param.param_str, in_count - 1,
rel_param.param_str, in_count,
rel_param.param_str);
} else {
sprintf(tmpStr, "IN[%s]", rel_param.param_str);
}
wined3d: Avoid NOP additions.
2007-11-02 01:50:20 +01:00
}
wined3d: Pixel Shader varying indexing.
2007-10-28 00:08:56 +02:00
} else {
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
DWORD idx = ((IWineD3DPixelShaderImpl *) This)->input_reg_map[reg];
if (idx == in_count) {
sprintf(tmpStr, "gl_Color");
} else if (idx == in_count + 1) {
sprintf(tmpStr, "gl_SecondaryColor");
} else {
sprintf(tmpStr, "IN[%u]", idx);
}
wined3d: Pixel Shader varying indexing.
2007-10-28 00:08:56 +02:00
}
} else {
wined3d: Add support for shader model 3.0 I/O registers. SM 3.0 can pack multiple "semantics" into 12 generic input/output registers. To support that, define temporaries called IN and OUT, and use those as the output registers. At the end of the vshader, unpack the OUT temps into the proper GL variables. At the beginning of the pshader, pack the GL variables back into 12 IN registers.
2006-06-12 08:57:07 +02:00
if (reg==0)
strcpy(tmpStr, "gl_Color");
else
strcpy(tmpStr, "gl_SecondaryColor");
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
} else {
wined3d: Reverse semantics maps for shaders.
2006-07-07 08:27:38 +02:00
if (vshader_input_is_color((IWineD3DVertexShader*) This, reg))
*is_color = TRUE;
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
sprintf(tmpStr, "attrib%u", reg);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-10 01:45:55 +02:00
case WINED3DSPR_CONST:
wined3d: Keep pshader and vshader constants in GLSL separate. GLSL uniforms have as scope the entire program. To prevent conflicts, name pshader and vshader constants differently. Based on a patch by Jason Green.
2006-06-12 09:00:03 +02:00
{
wined3d: Give local constants a shader type prefix.
2008-06-02 21:12:27 +02:00
const char prefix = pshader? 'P':'V';
wined3d: Keep pshader and vshader constants in GLSL separate. GLSL uniforms have as scope the entire program. To prevent conflicts, name pshader and vshader constants differently. Based on a patch by Jason Green.
2006-06-12 09:00:03 +02:00
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
/* Relative addressing */
wined3d: Add D3DSHADER_ADDRMODE masks to the WINED3D namespace.
2006-10-13 05:35:03 +02:00
if (param & WINED3DSHADER_ADDRMODE_RELATIVE) {
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
/* Relative addressing on shaders 2.0+ have a relative address token,
* prior to that, it was hard-coded as "A0.x" because there's only 1 register */
wined3d: Add shader version/end masks to the WINED3D namespace.
2006-10-13 05:36:41 +02:00
if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 2) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t rel_param;
shader_glsl_add_src_param(arg, addr_token, 0, WINED3DSP_WRITEMASK_0, &rel_param);
wined3d: Avoid NOP additions.
2007-11-02 01:50:20 +01:00
if(reg) {
wined3d: Give local constants a shader type prefix.
2008-06-02 21:12:27 +02:00
sprintf(tmpStr, "%cC[%s + %u]", prefix, rel_param.param_str, reg);
wined3d: Avoid NOP additions.
2007-11-02 01:50:20 +01:00
} else {
wined3d: Give local constants a shader type prefix.
2008-06-02 21:12:27 +02:00
sprintf(tmpStr, "%cC[%s]", prefix, rel_param.param_str);
wined3d: Avoid NOP additions.
2007-11-02 01:50:20 +01:00
}
} else {
if(reg) {
wined3d: Give local constants a shader type prefix.
2008-06-02 21:12:27 +02:00
sprintf(tmpStr, "%cC[A0.x + %u]", prefix, reg);
wined3d: Avoid NOP additions.
2007-11-02 01:50:20 +01:00
} else {
wined3d: Give local constants a shader type prefix.
2008-06-02 21:12:27 +02:00
sprintf(tmpStr, "%cC[A0.x]", prefix);
wined3d: Avoid NOP additions.
2007-11-02 01:50:20 +01:00
}
}
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
wined3d: Hardcode local constants into the shader if possible.
2007-11-09 14:48:47 +01:00
} else {
wined3d: Hardcode local constants in ARB shaders if possible.
2008-02-14 14:15:49 +01:00
if(shader_constant_is_local(This, reg)) {
wined3d: Give local constants a shader type prefix.
2008-06-02 21:12:27 +02:00
sprintf(tmpStr, "%cLC%u", prefix, reg);
wined3d: Hardcode local constants into the shader if possible.
2007-11-09 14:48:47 +01:00
} else {
wined3d: Give local constants a shader type prefix.
2008-06-02 21:12:27 +02:00
sprintf(tmpStr, "%cC[%u]", prefix, reg);
wined3d: Hardcode local constants into the shader if possible.
2007-11-09 14:48:47 +01:00
}
}
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
wined3d: Keep pshader and vshader constants in GLSL separate. GLSL uniforms have as scope the entire program. To prevent conflicts, name pshader and vshader constants differently. Based on a patch by Jason Green.
2006-06-12 09:00:03 +02:00
break;
}
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-10 01:45:55 +02:00
case WINED3DSPR_CONSTINT:
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
if (pshader)
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
sprintf(tmpStr, "PI[%u]", reg);
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
else
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
sprintf(tmpStr, "VI[%u]", reg);
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-10 01:45:55 +02:00
case WINED3DSPR_CONSTBOOL:
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
if (pshader)
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
sprintf(tmpStr, "PB[%u]", reg);
wined3d: Place immediate constants in the same array as global constants. - move DEF, DEFI, DEFB handling into the register counting pass - keep track of defined constants as a linked list (because there's a few of them) - apply immediate constants after global constants in the constant loading function - both types of constants now get loaded with array notation in the shader (into the same array)
2006-07-10 06:51:03 +02:00
else
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
sprintf(tmpStr, "VB[%u]", reg);
wined3d: Add preliminary support for constant boolean and integer registers in GLSL. - Separate the declaration phase of the shader string generator into the arb and glsl specific files. - Add declarations and recognition for application-sent constant integers and booleans (locally defined ones will follow). - Standardize capitilization of pixel/vertex specific variable names.
2006-06-16 22:07:31 +02:00
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-10 01:45:55 +02:00
case WINED3DSPR_TEXTURE: /* case WINED3DSPR_ADDR: */
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
if (pshader) {
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
sprintf(tmpStr, "T%u", reg);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
} else {
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
sprintf(tmpStr, "A%u", reg);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-10 01:45:55 +02:00
case WINED3DSPR_LOOP:
wined3d: Nested loop support.
2007-09-14 13:21:52 +02:00
sprintf(tmpStr, "aL%u", This->baseShader.cur_loop_regno - 1);
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 04:32:14 +02:00
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-10 01:45:55 +02:00
case WINED3DSPR_SAMPLER:
wined3d: Improve Sampler support on 2.0 and 3.0 shaders. - track sampler declarations and store the sampler usage in reg_maps structure - store a fake sampler usage for 1.X shaders (defined as 2D sampler) - re-sync glsl TEX implementation with the ARB one (no idea why they diverged..) - use sampler type in new TEX implementation to support 2D, 3D, and Cube sampling - change drawprim to bind pixel shader samplers Additional improvements: - rename texture limit to texcoord to prevent confusion - add sampler limit, and use that for samplers - *not* the same as texcoord above
2006-06-12 08:59:16 +02:00
if (pshader)
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
sprintf(tmpStr, "Psampler%u", reg);
wined3d: Improve Sampler support on 2.0 and 3.0 shaders. - track sampler declarations and store the sampler usage in reg_maps structure - store a fake sampler usage for 1.X shaders (defined as 2D sampler) - re-sync glsl TEX implementation with the ARB one (no idea why they diverged..) - use sampler type in new TEX implementation to support 2D, 3D, and Cube sampling - change drawprim to bind pixel shader samplers Additional improvements: - rename texture limit to texcoord to prevent confusion - add sampler limit, and use that for samplers - *not* the same as texcoord above
2006-06-12 08:59:16 +02:00
else
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
sprintf(tmpStr, "Vsampler%u", reg);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-10 01:45:55 +02:00
case WINED3DSPR_COLOROUT:
wined3d: Allow wined3d to handle multiple render targets.
2006-12-19 19:25:42 +01:00
if (reg >= GL_LIMITS(buffers)) {
WARN("Write to render target %u, only %d supported\n", reg, 4);
}
wined3d: Draw buffers support.
2006-08-09 22:54:14 +02:00
if (GL_SUPPORT(ARB_DRAW_BUFFERS)) {
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
sprintf(tmpStr, "gl_FragData[%u]", reg);
wined3d: Draw buffers support.
2006-08-09 22:54:14 +02:00
} else { /* On older cards with GLSL support like the GeforceFX there's only one buffer. */
wined3d: Allow wined3d to handle multiple render targets.
2006-12-19 19:25:42 +01:00
sprintf(tmpStr, "gl_FragColor");
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-10 01:45:55 +02:00
case WINED3DSPR_RASTOUT:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
sprintf(tmpStr, "%s", hwrastout_reg_names[reg]);
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-10 01:45:55 +02:00
case WINED3DSPR_DEPTHOUT:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
sprintf(tmpStr, "gl_FragDepth");
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-10 01:45:55 +02:00
case WINED3DSPR_ATTROUT:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
if (reg == 0) {
sprintf(tmpStr, "gl_FrontColor");
} else {
sprintf(tmpStr, "gl_FrontSecondaryColor");
}
break;
wined3d: Move D3DSPR structure into the WINED3D namespace.
2006-10-10 01:45:55 +02:00
case WINED3DSPR_TEXCRDOUT:
/* Vertex shaders >= 3.0: WINED3DSPR_OUTPUT */
wined3d: Add shader version/end masks to the WINED3D namespace.
2006-10-13 05:36:41 +02:00
if (WINED3DSHADER_VERSION_MAJOR(This->baseShader.hex_version) >= 3)
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
sprintf(tmpStr, "OUT[%u]", reg);
wined3d: Add support for shader model 3.0 I/O registers. SM 3.0 can pack multiple "semantics" into 12 generic input/output registers. To support that, define temporaries called IN and OUT, and use those as the output registers. At the end of the vshader, unpack the OUT temps into the proper GL variables. At the beginning of the pshader, pack the GL variables back into 12 IN registers.
2006-06-12 08:57:07 +02:00
else
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
sprintf(tmpStr, "gl_TexCoord[%u]", reg);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
break;
wined3d: Handle the ps_3_0 vPos field.
2007-05-03 21:01:09 +02:00
case WINED3DSPR_MISCTYPE:
if (reg == 0) {
/* vPos */
wined3d: Reverse the position fixup if the pshader is reading vpos.
2007-09-14 13:11:00 +02:00
sprintf(tmpStr, "vpos");
wined3d: Implement the vFace register.
2007-10-04 08:24:03 +02:00
} else if (reg == 1){
/* Note that gl_FrontFacing is a bool, while vFace is
* a float for which the sign determines front/back
*/
sprintf(tmpStr, "(gl_FrontFacing ? 1.0 : -1.0)");
wined3d: Handle the ps_3_0 vPos field.
2007-05-03 21:01:09 +02:00
} else {
FIXME("Unhandled misctype register %d\n", reg);
sprintf(tmpStr, "unrecognized_register");
}
break;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
default:
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
FIXME("Unhandled register name Type(%d)\n", regtype);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
sprintf(tmpStr, "unrecognized_register");
break;
}
strcat(regstr, tmpStr);
}
wined3d: Cleanup shader_glsl_get_output_register_swizzle().
2006-12-29 15:31:26 +01:00
/* Get the GLSL write mask for the destination register */
wined3d: Return the (binary) write mask from shader_glsl_add_dst_param().
2007-01-15 19:30:28 +01:00
static DWORD shader_glsl_get_write_mask(const DWORD param, char *write_mask) {
wined3d: Cleanup shader_glsl_get_output_register_swizzle().
2006-12-29 15:31:26 +01:00
char *ptr = write_mask;
wined3d: Return the (binary) write mask from shader_glsl_add_dst_param().
2007-01-15 19:30:28 +01:00
DWORD mask = param & WINED3DSP_WRITEMASK_ALL;
wined3d: Cleanup shader_glsl_get_output_register_swizzle().
2006-12-29 15:31:26 +01:00
wined3d: Fix some swizzles on scalars.
2007-04-12 23:55:31 +02:00
if (shader_is_scalar(param)) {
wined3d: Fixup the write mask for gl_FogFragCoord and gl_PointSize. gl_FogFragCoord and gl_PointSize are floats rather than vec4s in GLSL, so they shouldn't have a destination swizzle, and the write mask we return should consist of only the first component.
2007-01-15 19:30:35 +01:00
mask = WINED3DSP_WRITEMASK_0;
} else {
wined3d: Simplify shader_glsl_get_write_mask().
2007-01-15 19:36:52 +01:00
*ptr++ = '.';
if (param & WINED3DSP_WRITEMASK_0) *ptr++ = 'x';
if (param & WINED3DSP_WRITEMASK_1) *ptr++ = 'y';
if (param & WINED3DSP_WRITEMASK_2) *ptr++ = 'z';
if (param & WINED3DSP_WRITEMASK_3) *ptr++ = 'w';
Revert "wined3d: Simplify the get_write_mask and get_swizzle functions." This reverts commit a9f658f6a68fbe53bcf30ab0329e5ff91451bf30.
2007-01-02 13:21:47 +01:00
}
wined3d: Cleanup shader_glsl_get_output_register_swizzle().
2006-12-29 15:31:26 +01:00
*ptr = '\0';
wined3d: Return the (binary) write mask from shader_glsl_add_dst_param().
2007-01-15 19:30:28 +01:00
return mask;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
wined3d: Use unsigned int instead of size_t for the glsl mask size.
2008-01-07 17:17:27 +01:00
static unsigned int shader_glsl_get_write_mask_size(DWORD write_mask) {
unsigned int size = 0;
wined3d: Move WINED3DSIO_SGE & WINED3DSIO_SLT from shader_glsl_map2gl() to shader_glsl_compare() where they belong. Properly take the write mask into account
2007-01-15 19:31:49 +01:00
if (write_mask & WINED3DSP_WRITEMASK_0) ++size;
if (write_mask & WINED3DSP_WRITEMASK_1) ++size;
if (write_mask & WINED3DSP_WRITEMASK_2) ++size;
if (write_mask & WINED3DSP_WRITEMASK_3) ++size;
return size;
}
wined3d: Pass a mask to shader_glsl_add_src_param().
2007-01-15 19:31:06 +01:00
static void shader_glsl_get_swizzle(const DWORD param, BOOL fixup, DWORD mask, char *swizzle_str) {
wined3d: Cleanup shader_glsl_get_input_register_swizzle().
2006-12-29 15:31:43 +01:00
/* For registers of type WINED3DDECLTYPE_D3DCOLOR, data is stored as "bgra",
* but addressed as "rgba". To fix this we need to swap the register's x
* and z components. */
wined3d: Simplify shader_glsl_get_swizzle().
2007-01-15 19:36:46 +01:00
DWORD swizzle = (param & WINED3DSP_SWIZZLE_MASK) >> WINED3DSP_SWIZZLE_SHIFT;
wined3d: Cleanup shader_glsl_get_input_register_swizzle().
2006-12-29 15:31:43 +01:00
const char *swizzle_chars = fixup ? "zyxw" : "xyzw";
char *ptr = swizzle_str;
wined3d: Fix some swizzles on scalars.
2007-04-12 23:55:31 +02:00
if (!shader_is_scalar(param)) {
*ptr++ = '.';
/* swizzle bits fields: wwzzyyxx */
if (mask & WINED3DSP_WRITEMASK_0) *ptr++ = swizzle_chars[swizzle & 0x03];
if (mask & WINED3DSP_WRITEMASK_1) *ptr++ = swizzle_chars[(swizzle >> 2) & 0x03];
if (mask & WINED3DSP_WRITEMASK_2) *ptr++ = swizzle_chars[(swizzle >> 4) & 0x03];
if (mask & WINED3DSP_WRITEMASK_3) *ptr++ = swizzle_chars[(swizzle >> 6) & 0x03];
}
Revert "wined3d: Simplify the get_write_mask and get_swizzle functions." This reverts commit a9f658f6a68fbe53bcf30ab0329e5ff91451bf30.
2007-01-02 13:21:47 +01:00
wined3d: Cleanup shader_glsl_get_input_register_swizzle().
2006-12-29 15:31:43 +01:00
*ptr = '\0';
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
wined3d: Split shader_glsl_add_param() in shader_glsl_add_src_param() and shader_glsl_add_dst_param().
2007-01-15 19:30:20 +01:00
/* From a given parameter token, generate the corresponding GLSL string.
* Also, return the actual register name and swizzle in case the
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
* caller needs this information as well. */
wined3d: Split shader_glsl_add_param() in shader_glsl_add_src_param() and shader_glsl_add_dst_param().
2007-01-15 19:30:20 +01:00
static void shader_glsl_add_src_param(SHADER_OPCODE_ARG* arg, const DWORD param,
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
const DWORD addr_token, DWORD mask, glsl_src_param_t *src_param) {
wined3d: Split shader_glsl_add_param() in shader_glsl_add_src_param() and shader_glsl_add_dst_param().
2007-01-15 19:30:20 +01:00
BOOL is_color = FALSE;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
char swizzle_str[6];
src_param->reg_name[0] = '\0';
src_param->param_str[0] = '\0';
swizzle_str[0] = '\0';
wined3d: Split shader_glsl_add_param() in shader_glsl_add_src_param() and shader_glsl_add_dst_param().
2007-01-15 19:30:20 +01:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_get_register_name(param, addr_token, src_param->reg_name, &is_color, arg);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_get_swizzle(param, is_color, mask, swizzle_str);
shader_glsl_gen_modifier(param, src_param->reg_name, swizzle_str, src_param->param_str);
wined3d: Split shader_glsl_add_param() in shader_glsl_add_src_param() and shader_glsl_add_dst_param().
2007-01-15 19:30:20 +01:00
}
/* From a given parameter token, generate the corresponding GLSL string.
* Also, return the actual register name and swizzle in case the
* caller needs this information as well. */
wined3d: Return the (binary) write mask from shader_glsl_add_dst_param().
2007-01-15 19:30:28 +01:00
static DWORD shader_glsl_add_dst_param(SHADER_OPCODE_ARG* arg, const DWORD param,
wined3d: Add a glsl_dst_param_t type, pass it to shader_glsl_add_dst_param() instead of three separate character arrays.
2007-01-15 19:36:58 +01:00
const DWORD addr_token, glsl_dst_param_t *dst_param) {
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
BOOL is_color = FALSE;
wined3d: Add a glsl_dst_param_t type, pass it to shader_glsl_add_dst_param() instead of three separate character arrays.
2007-01-15 19:36:58 +01:00
dst_param->mask_str[0] = '\0';
dst_param->reg_name[0] = '\0';
wined3d: Split shader_glsl_add_param() in shader_glsl_add_src_param() and shader_glsl_add_dst_param().
2007-01-15 19:30:20 +01:00
wined3d: Add a glsl_dst_param_t type, pass it to shader_glsl_add_dst_param() instead of three separate character arrays.
2007-01-15 19:36:58 +01:00
shader_glsl_get_register_name(param, addr_token, dst_param->reg_name, &is_color, arg);
return shader_glsl_get_write_mask(param, dst_param->mask_str);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
wined3d: Rename shader_glsl_add_dst() to shader_glsl_add_dst_old(), add shader_glsl_append_dst().
2007-01-15 19:30:59 +01:00
/* Append the destination part of the instruction to the buffer, return the effective write mask */
wined3d: Fix GLSL cmp instruction for INF and NAN arguments.
2007-03-29 19:57:41 +02:00
static DWORD shader_glsl_append_dst_ext(SHADER_BUFFER *buffer, SHADER_OPCODE_ARG *arg, const DWORD param) {
wined3d: Add a glsl_dst_param_t type, pass it to shader_glsl_add_dst_param() instead of three separate character arrays.
2007-01-15 19:36:58 +01:00
glsl_dst_param_t dst_param;
wined3d: Rename shader_glsl_add_dst() to shader_glsl_add_dst_old(), add shader_glsl_append_dst().
2007-01-15 19:30:59 +01:00
DWORD mask;
int shift;
wined3d: Fix GLSL cmp instruction for INF and NAN arguments.
2007-03-29 19:57:41 +02:00
mask = shader_glsl_add_dst_param(arg, param, arg->dst_addr, &dst_param);
if(mask) {
shift = (param & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
shader_addline(buffer, "%s%s = %s(", dst_param.reg_name, dst_param.mask_str, shift_glsl_tab[shift]);
}
wined3d: Rename shader_glsl_add_dst() to shader_glsl_add_dst_old(), add shader_glsl_append_dst().
2007-01-15 19:30:59 +01:00
return mask;
}
wined3d: Fix GLSL cmp instruction for INF and NAN arguments.
2007-03-29 19:57:41 +02:00
/* Append the destination part of the instruction to the buffer, return the effective write mask */
static DWORD shader_glsl_append_dst(SHADER_BUFFER *buffer, SHADER_OPCODE_ARG *arg) {
return shader_glsl_append_dst_ext(buffer, arg, arg->dst);
}
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
/** Process GLSL instruction modifiers */
void shader_glsl_add_instruction_modifiers(SHADER_OPCODE_ARG* arg) {
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 11:11:35 +02:00
wined3d: Move D3DSP dest modifier related items into the WINED3D namespace.
2006-10-10 01:48:12 +02:00
DWORD mask = arg->dst & WINED3DSP_DSTMOD_MASK;
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 11:11:35 +02:00
if (arg->opcode->dst_token && mask != 0) {
wined3d: Add a glsl_dst_param_t type, pass it to shader_glsl_add_dst_param() instead of three separate character arrays.
2007-01-15 19:36:58 +01:00
glsl_dst_param_t dst_param;
shader_glsl_add_dst_param(arg, arg->dst, 0, &dst_param);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Move D3DSP dest modifier related items into the WINED3D namespace.
2006-10-10 01:48:12 +02:00
if (mask & WINED3DSPDM_SATURATE) {
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
/* _SAT means to clamp the value of the register to between 0 and 1 */
wined3d: Add a glsl_dst_param_t type, pass it to shader_glsl_add_dst_param() instead of three separate character arrays.
2007-01-15 19:36:58 +01:00
shader_addline(arg->buffer, "%s%s = clamp(%s%s, 0.0, 1.0);\n", dst_param.reg_name,
dst_param.mask_str, dst_param.reg_name, dst_param.mask_str);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
wined3d: Move D3DSP dest modifier related items into the WINED3D namespace.
2006-10-10 01:48:12 +02:00
if (mask & WINED3DSPDM_MSAMPCENTROID) {
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
FIXME("_centroid modifier not handled\n");
}
wined3d: Move D3DSP dest modifier related items into the WINED3D namespace.
2006-10-10 01:48:12 +02:00
if (mask & WINED3DSPDM_PARTIALPRECISION) {
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
/* MSDN says this modifier can be safely ignored, so that's what we'll do. */
}
}
}
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 11:11:35 +02:00
static inline const char* shader_get_comp_op(
const DWORD opcode) {
DWORD op = (opcode & INST_CONTROLS_MASK) >> INST_CONTROLS_SHIFT;
switch (op) {
case COMPARISON_GT: return ">";
case COMPARISON_EQ: return "==";
case COMPARISON_GE: return ">=";
case COMPARISON_LT: return "<";
case COMPARISON_NE: return "!=";
case COMPARISON_LE: return "<=";
default:
wined3d: Win64 printf fixes.
2006-10-01 05:20:10 +02:00
FIXME("Unrecognized comparison value: %u\n", op);
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 11:11:35 +02:00
return "(\?\?)";
}
}
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
static void shader_glsl_get_sample_function(DWORD sampler_type, BOOL projected, BOOL texrect, glsl_sample_function_t *sample_function) {
wined3d: Split out getting the sample function and coordinate mask from shader_glsl_sample().
2007-01-15 19:33:38 +01:00
/* Note that there's no such thing as a projected cube texture. */
switch(sampler_type) {
case WINED3DSTT_1D:
sample_function->name = projected ? "texture1DProj" : "texture1D";
sample_function->coord_mask = WINED3DSP_WRITEMASK_0;
break;
case WINED3DSTT_2D:
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
if(texrect) {
sample_function->name = projected ? "texture2DRectProj" : "texture2DRect";
} else {
sample_function->name = projected ? "texture2DProj" : "texture2D";
}
wined3d: Split out getting the sample function and coordinate mask from shader_glsl_sample().
2007-01-15 19:33:38 +01:00
sample_function->coord_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1;
break;
case WINED3DSTT_CUBE:
sample_function->name = "textureCube";
sample_function->coord_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
break;
case WINED3DSTT_VOLUME:
sample_function->name = projected ? "texture3DProj" : "texture3D";
sample_function->coord_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
break;
default:
sample_function->name = "";
wined3d: Make sure some variables are always initialized.
2008-10-08 17:34:51 +02:00
sample_function->coord_mask = 0;
wined3d: Split out getting the sample function and coordinate mask from shader_glsl_sample().
2007-01-15 19:33:38 +01:00
FIXME("Unrecognized sampler type: %#x;\n", sampler_type);
break;
}
}
wined3d: Unify pixel format correction.
2007-09-21 23:53:57 +02:00
static void shader_glsl_color_correction(SHADER_OPCODE_ARG* arg) {
wined3d: Add signed format conversion for glsl.
2007-09-21 23:34:09 +02:00
IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) shader->baseShader.device;
WineD3D_GL_Info *gl_info = &deviceImpl->adapter->gl_info;
glsl_dst_param_t dst_param;
glsl_dst_param_t dst_param2;
WINED3DFORMAT fmt;
wined3d: Recompile glsl pixelshaders if the sampler format changes.
2007-09-21 23:47:40 +02:00
WINED3DFORMAT conversion_group;
wined3d: Add signed format conversion for glsl.
2007-09-21 23:34:09 +02:00
IWineD3DBaseTextureImpl *texture;
DWORD mask, mask_size;
wined3d: Recompile glsl pixelshaders if the sampler format changes.
2007-09-21 23:47:40 +02:00
UINT i;
BOOL recorded = FALSE;
wined3d: Unify pixel format correction.
2007-09-21 23:53:57 +02:00
DWORD sampler_idx;
DWORD hex_version = shader->baseShader.hex_version;
switch(arg->opcode->opcode) {
case WINED3DSIO_TEX:
if (hex_version < WINED3DPS_VERSION(2,0)) {
sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
} else {
sampler_idx = arg->src[1] & WINED3DSP_REGNUM_MASK;
}
break;
case WINED3DSIO_TEXLDL:
FIXME("Add color fixup for vertex texture WINED3DSIO_TEXLDL\n");
return;
case WINED3DSIO_TEXDP3TEX:
case WINED3DSIO_TEXM3x3TEX:
case WINED3DSIO_TEXM3x3SPEC:
case WINED3DSIO_TEXM3x3VSPEC:
case WINED3DSIO_TEXBEM:
case WINED3DSIO_TEXREG2AR:
case WINED3DSIO_TEXREG2GB:
case WINED3DSIO_TEXREG2RGB:
sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
break;
default:
/* Not a texture sampling instruction, nothing to do */
return;
};
wined3d: Add signed format conversion for glsl.
2007-09-21 23:34:09 +02:00
texture = (IWineD3DBaseTextureImpl *) deviceImpl->stateBlock->textures[sampler_idx];
if(texture) {
fmt = texture->resource.format;
wined3d: Recompile glsl pixelshaders if the sampler format changes.
2007-09-21 23:47:40 +02:00
conversion_group = texture->baseTexture.shader_conversion_group;
wined3d: Add signed format conversion for glsl.
2007-09-21 23:34:09 +02:00
} else {
fmt = WINED3DFMT_UNKNOWN;
wined3d: Recompile glsl pixelshaders if the sampler format changes.
2007-09-21 23:47:40 +02:00
conversion_group = WINED3DFMT_UNKNOWN;
}
/* before doing anything, record the sampler with the format in the format conversion list,
* but check if it's not there already
*/
for(i = 0; i < shader->baseShader.num_sampled_samplers; i++) {
if(shader->baseShader.sampled_samplers[i] == sampler_idx) {
recorded = TRUE;
break;
}
}
if(!recorded) {
shader->baseShader.sampled_samplers[shader->baseShader.num_sampled_samplers] = sampler_idx;
shader->baseShader.num_sampled_samplers++;
shader->baseShader.sampled_format[sampler_idx] = conversion_group;
wined3d: Add signed format conversion for glsl.
2007-09-21 23:34:09 +02:00
}
switch(fmt) {
case WINED3DFMT_V8U8:
case WINED3DFMT_V16U16:
if(GL_SUPPORT(NV_TEXTURE_SHADER) ||
(GL_SUPPORT(ATI_ENVMAP_BUMPMAP) && fmt == WINED3DFMT_V8U8)) {
/* The 3rd channel returns 1.0 in d3d, but 0.0 in gl. Fix this while we're at it :-) */
mask = shader_glsl_add_dst_param(arg, arg->dst, WINED3DSP_WRITEMASK_2, &dst_param);
mask_size = shader_glsl_get_write_mask_size(mask);
if(mask_size >= 3) {
shader_addline(arg->buffer, "%s.%c = 1.0;\n", dst_param.reg_name, dst_param.mask_str[3]);
}
} else {
/* Correct the sign, but leave the blue as it is - it was loaded correctly already */
mask = shader_glsl_add_dst_param(arg, arg->dst,
WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1,
&dst_param);
mask_size = shader_glsl_get_write_mask_size(mask);
if(mask_size >= 2) {
shader_addline(arg->buffer, "%s.%c%c = %s.%c%c * 2.0 - 1.0;\n",
dst_param.reg_name, dst_param.mask_str[1], dst_param.mask_str[2],
dst_param.reg_name, dst_param.mask_str[1], dst_param.mask_str[2]);
} else if(mask_size == 1) {
shader_addline(arg->buffer, "%s.%c = %s.%c * 2.0 - 1.0;\n", dst_param.reg_name, dst_param.mask_str[1],
dst_param.reg_name, dst_param.mask_str[1]);
}
}
break;
case WINED3DFMT_X8L8V8U8:
if(!GL_SUPPORT(NV_TEXTURE_SHADER)) {
/* Red and blue are the signed channels, fix them up; Blue(=L) is correct already,
* and a(X) is always 1.0
*/
mask = shader_glsl_add_dst_param(arg, arg->dst, WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &dst_param);
mask_size = shader_glsl_get_write_mask_size(mask);
if(mask_size >= 2) {
shader_addline(arg->buffer, "%s.%c%c = %s.%c%c * 2.0 - 1.0;\n",
dst_param.reg_name, dst_param.mask_str[1], dst_param.mask_str[2],
dst_param.reg_name, dst_param.mask_str[1], dst_param.mask_str[2]);
} else if(mask_size == 1) {
shader_addline(arg->buffer, "%s.%c = %s.%c * 2.0 - 1.0;\n",
dst_param.reg_name, dst_param.mask_str[1],
dst_param.reg_name, dst_param.mask_str[1]);
}
}
break;
case WINED3DFMT_L6V5U5:
if(!GL_SUPPORT(NV_TEXTURE_SHADER)) {
mask = shader_glsl_add_dst_param(arg, arg->dst, WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &dst_param);
mask_size = shader_glsl_get_write_mask_size(mask);
shader_glsl_add_dst_param(arg, arg->dst, WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_2, &dst_param2);
if(mask_size >= 3) {
/* Swap y and z (U and L), and do a sign conversion on x and the new y(V and U) */
shader_addline(arg->buffer, "tmp0.g = %s.%c;\n",
dst_param.reg_name, dst_param.mask_str[2]);
shader_addline(arg->buffer, "%s.%c%c = %s.%c%c * 2.0 - 1.0;\n",
dst_param.reg_name, dst_param.mask_str[2], dst_param.mask_str[1],
dst_param2.reg_name, dst_param.mask_str[1], dst_param.mask_str[3]);
shader_addline(arg->buffer, "%s.%c = tmp0.g;\n", dst_param.reg_name,
dst_param.mask_str[3]);
} else if(mask_size == 2) {
/* This is bad: We have VL, but we need VU */
FIXME("2 components sampled from a converted L6V5U5 texture\n");
} else {
shader_addline(arg->buffer, "%s.%c = %s.%c * 2.0 - 1.0;\n",
dst_param.reg_name, dst_param.mask_str[1],
dst_param2.reg_name, dst_param.mask_str[1]);
}
}
break;
case WINED3DFMT_Q8W8V8U8:
if(!GL_SUPPORT(NV_TEXTURE_SHADER)) {
/* Correct the sign in all channels. The writemask just applies as-is, no
* need for checking the mask size
*/
shader_glsl_add_dst_param(arg, arg->dst,
WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 |
WINED3DSP_WRITEMASK_2 | WINED3DSP_WRITEMASK_3,
&dst_param);
shader_addline(arg->buffer, "%s%s = %s%s * 2.0 - 1.0;\n", dst_param.reg_name, dst_param.mask_str,
dst_param.reg_name, dst_param.mask_str);
}
break;
wined3d: Support ATI's D3DFMT_ATI2N format. This is an ATI specific format designed for compressed normal maps, and quite a few games check for its existence. While it is an ATI-specific "extension" in d3d9, it is a core part of D3D10(DXGI_FORMAT_BC5), and supported on Geforce 8 cards.
2008-07-23 17:33:10 +02:00
case WINED3DFMT_ATI2N:
/* GL_ATI_texture_compression_3dc returns the two channels as luminance-alpha,
Assorted spelling fixes.
2008-08-04 10:20:20 +02:00
* which means the first one is replicated across .rgb, and the 2nd one is in
wined3d: Support ATI's D3DFMT_ATI2N format. This is an ATI specific format designed for compressed normal maps, and quite a few games check for its existence. While it is an ATI-specific "extension" in d3d9, it is a core part of D3D10(DXGI_FORMAT_BC5), and supported on Geforce 8 cards.
2008-07-23 17:33:10 +02:00
* .a. We need the 2nd in .g
wined3d: ATI2N support using GL_EXT_texture_compression_rgtc.
2008-07-23 17:39:04 +02:00
*
* GL_EXT_texture_compression_rgtc returns the values in .rg, however, they
* are swapped compared to d3d. So swap red and green.
wined3d: Support ATI's D3DFMT_ATI2N format. This is an ATI specific format designed for compressed normal maps, and quite a few games check for its existence. While it is an ATI-specific "extension" in d3d9, it is a core part of D3D10(DXGI_FORMAT_BC5), and supported on Geforce 8 cards.
2008-07-23 17:33:10 +02:00
*/
mask = shader_glsl_add_dst_param(arg, arg->dst, WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &dst_param);
mask_size = shader_glsl_get_write_mask_size(mask);
wined3d: ATI2N support using GL_EXT_texture_compression_rgtc.
2008-07-23 17:39:04 +02:00
if(GL_SUPPORT(EXT_TEXTURE_COMPRESSION_RGTC)) {
if(mask_size >= 2) {
shader_addline(arg->buffer, "%s.%c%c = %s.%c%c;\n",
dst_param.reg_name, dst_param.mask_str[1],
dst_param.mask_str[2],
dst_param.reg_name, dst_param.mask_str[2],
dst_param.mask_str[1]);
} else {
FIXME("%u components sampled from a converted ATI2N texture\n", mask_size);
}
wined3d: Support ATI's D3DFMT_ATI2N format. This is an ATI specific format designed for compressed normal maps, and quite a few games check for its existence. While it is an ATI-specific "extension" in d3d9, it is a core part of D3D10(DXGI_FORMAT_BC5), and supported on Geforce 8 cards.
2008-07-23 17:33:10 +02:00
} else {
wined3d: ATI2N support using GL_EXT_texture_compression_rgtc.
2008-07-23 17:39:04 +02:00
if(mask_size == 4) {
/* Swap y and z (U and L), and do a sign conversion on x and the new y(V and U) */
shader_addline(arg->buffer, "%s.%c = %s.%c;\n",
dst_param.reg_name, dst_param.mask_str[2],
dst_param.reg_name, dst_param.mask_str[4]);
} else if(mask_size == 1) {
/* Nothing to do */
} else {
FIXME("%u components sampled from a converted ATI2N texture\n", mask_size);
/* This is bad: We have .r[gb], but we need .ra */
}
wined3d: Support ATI's D3DFMT_ATI2N format. This is an ATI specific format designed for compressed normal maps, and quite a few games check for its existence. While it is an ATI-specific "extension" in d3d9, it is a core part of D3D10(DXGI_FORMAT_BC5), and supported on Geforce 8 cards.
2008-07-23 17:33:10 +02:00
}
break;
wined3d: Add signed format conversion for glsl.
2007-09-21 23:34:09 +02:00
/* stupid compiler */
default:
break;
}
}
wined3d: Create a separate function for sampling a texture.
2006-11-27 20:50:47 +01:00
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
/*****************************************************************************
*
* Begin processing individual instruction opcodes
*
****************************************************************************/
Assorted spelling fixes.
2006-06-15 17:38:04 +02:00
/* Generate GLSL arithmetic functions (dst = src1 + src2) */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_arith(SHADER_OPCODE_ARG* arg) {
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
CONST SHADER_OPCODE* curOpcode = arg->opcode;
SHADER_BUFFER* buffer = arg->buffer;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
wined3d: Rewrite shader_glsl_arith() to properly take the write mask into account.
2007-01-15 19:31:31 +01:00
DWORD write_mask;
char op;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
/* Determine the GLSL operator to use based on the opcode */
switch (curOpcode->opcode) {
wined3d: Rewrite shader_glsl_arith() to properly take the write mask into account.
2007-01-15 19:31:31 +01:00
case WINED3DSIO_MUL: op = '*'; break;
case WINED3DSIO_ADD: op = '+'; break;
case WINED3DSIO_SUB: op = '-'; break;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
default:
wined3d: Rewrite shader_glsl_arith() to properly take the write mask into account.
2007-01-15 19:31:31 +01:00
op = ' ';
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
FIXME("Opcode %s not yet handled in GLSL\n", curOpcode->name);
break;
}
wined3d: Rewrite shader_glsl_arith() to properly take the write mask into account.
2007-01-15 19:31:31 +01:00
write_mask = shader_glsl_append_dst(buffer, arg);
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
shader_addline(buffer, "%s %c %s);\n", src0_param.param_str, op, src1_param.param_str);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/* Process the WINED3DSIO_MOV opcode using GLSL (dst = src) */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_mov(SHADER_OPCODE_ARG* arg) {
wined3d: Rewrite shader_glsl_mov() to properly take the write mask into account. In case of writing to an address register round the source.
2007-01-15 19:32:27 +01:00
IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
SHADER_BUFFER* buffer = arg->buffer;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
wined3d: Rewrite shader_glsl_mov() to properly take the write mask into account. In case of writing to an address register round the source.
2007-01-15 19:32:27 +01:00
DWORD write_mask;
write_mask = shader_glsl_append_dst(buffer, arg);
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
wined3d: Rewrite shader_glsl_mov() to properly take the write mask into account. In case of writing to an address register round the source.
2007-01-15 19:32:27 +01:00
Assorted spelling fixes.
2007-02-14 16:22:07 +01:00
/* In vs_1_1 WINED3DSIO_MOV can write to the address register. In later
wined3d: Rewrite shader_glsl_mov() to properly take the write mask into account. In case of writing to an address register round the source.
2007-01-15 19:32:27 +01:00
* shader versions WINED3DSIO_MOVA is used for this. */
if ((WINED3DSHADER_VERSION_MAJOR(shader->baseShader.hex_version) == 1 &&
!shader_is_pshader_version(shader->baseShader.hex_version) &&
wined3d: mov to a0.x does a floor(), not a round to nearest.
2007-11-30 16:20:22 +01:00
shader_get_regtype(arg->dst) == WINED3DSPR_ADDR)) {
/* This is a simple floor() */
wined3d: Use unsigned int instead of size_t for the glsl mask size.
2008-01-07 17:17:27 +01:00
unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
wined3d: mov to a0.x does a floor(), not a round to nearest.
2007-11-30 16:20:22 +01:00
if (mask_size > 1) {
shader_addline(buffer, "ivec%d(floor(%s)));\n", mask_size, src0_param.param_str);
} else {
shader_addline(buffer, "int(floor(%s)));\n", src0_param.param_str);
}
} else if(arg->opcode->opcode == WINED3DSIO_MOVA) {
wined3d: Rewrite shader_glsl_mov() to properly take the write mask into account. In case of writing to an address register round the source.
2007-01-15 19:32:27 +01:00
/* We need to *round* to the nearest int here. */
wined3d: Use unsigned int instead of size_t for the glsl mask size.
2008-01-07 17:17:27 +01:00
unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
wined3d: Rewrite shader_glsl_mov() to properly take the write mask into account. In case of writing to an address register round the source.
2007-01-15 19:32:27 +01:00
if (mask_size > 1) {
wined3d: Properly round negative values in shader_glsl_mov.
2007-02-11 08:04:55 +01:00
shader_addline(buffer, "ivec%d(floor(abs(%s) + vec%d(0.5)) * sign(%s)));\n", mask_size, src0_param.param_str, mask_size, src0_param.param_str);
wined3d: Rewrite shader_glsl_mov() to properly take the write mask into account. In case of writing to an address register round the source.
2007-01-15 19:32:27 +01:00
} else {
wined3d: Properly round negative values in shader_glsl_mov.
2007-02-11 08:04:55 +01:00
shader_addline(buffer, "int(floor(abs(%s) + 0.5) * sign(%s)));\n", src0_param.param_str, src0_param.param_str);
wined3d: Rewrite shader_glsl_mov() to properly take the write mask into account. In case of writing to an address register round the source.
2007-01-15 19:32:27 +01:00
}
} else {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(buffer, "%s);\n", src0_param.param_str);
wined3d: Rewrite shader_glsl_mov() to properly take the write mask into account. In case of writing to an address register round the source.
2007-01-15 19:32:27 +01:00
}
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
/* Process the dot product operators DP3 and DP4 in GLSL (dst = dot(src0, src1)) */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_dot(SHADER_OPCODE_ARG* arg) {
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
CONST SHADER_OPCODE* curOpcode = arg->opcode;
SHADER_BUFFER* buffer = arg->buffer;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
wined3d: Rewrite shader_glsl_dot() to properly take the write mask into account.
2007-01-15 19:32:13 +01:00
DWORD dst_write_mask, src_write_mask;
wined3d: Use unsigned int instead of size_t for the glsl mask size.
2008-01-07 17:17:27 +01:00
unsigned int dst_size = 0;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Rewrite shader_glsl_dot() to properly take the write mask into account.
2007-01-15 19:32:13 +01:00
dst_write_mask = shader_glsl_append_dst(buffer, arg);
dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Rewrite shader_glsl_dot() to properly take the write mask into account.
2007-01-15 19:32:13 +01:00
/* dp3 works on vec3, dp4 on vec4 */
if (curOpcode->opcode == WINED3DSIO_DP4) {
src_write_mask = WINED3DSP_WRITEMASK_ALL;
} else {
src_write_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
}
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_write_mask, &src0_param);
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], src_write_mask, &src1_param);
wined3d: Rewrite shader_glsl_dot() to properly take the write mask into account.
2007-01-15 19:32:13 +01:00
if (dst_size > 1) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(buffer, "vec%d(dot(%s, %s)));\n", dst_size, src0_param.param_str, src1_param.param_str);
wined3d: Rewrite shader_glsl_dot() to properly take the write mask into account.
2007-01-15 19:32:13 +01:00
} else {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(buffer, "dot(%s, %s));\n", src0_param.param_str, src1_param.param_str);
wined3d: Rewrite shader_glsl_dot() to properly take the write mask into account.
2007-01-15 19:32:13 +01:00
}
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
wined3d: Give WINED3DSIO_CRS its own function, properly take the write mask into account.
2007-01-15 19:31:56 +01:00
/* Note that this instruction has some restrictions. The destination write mask
* can't contain the w component, and the source swizzles have to be .xyzw */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_cross(SHADER_OPCODE_ARG *arg) {
wined3d: Give WINED3DSIO_CRS its own function, properly take the write mask into account.
2007-01-15 19:31:56 +01:00
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
wined3d: Give WINED3DSIO_CRS its own function, properly take the write mask into account.
2007-01-15 19:31:56 +01:00
char dst_mask[6];
shader_glsl_get_write_mask(arg->dst, dst_mask);
shader_glsl_append_dst(arg->buffer, arg);
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], src_mask, &src1_param);
wined3d: Fix a typo in shader_glsl_cross.
2007-09-13 12:41:18 +02:00
shader_addline(arg->buffer, "cross(%s, %s)%s);\n", src0_param.param_str, src1_param.param_str, dst_mask);
wined3d: Give WINED3DSIO_CRS its own function, properly take the write mask into account.
2007-01-15 19:31:56 +01:00
}
wined3d: WINED3DSIO_POW should use the absolute value of the first source register.
2007-05-11 12:12:40 +02:00
/* Process the WINED3DSIO_POW instruction in GLSL (dst = |src0|^src1)
* Src0 and src1 are scalars. Note that D3D uses the absolute of src0, while
* GLSL uses the value as-is. */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_pow(SHADER_OPCODE_ARG *arg) {
wined3d: WINED3DSIO_POW should use the absolute value of the first source register.
2007-05-11 12:12:40 +02:00
SHADER_BUFFER *buffer = arg->buffer;
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
DWORD dst_write_mask;
wined3d: Use unsigned int instead of size_t for the glsl mask size.
2008-01-07 17:17:27 +01:00
unsigned int dst_size;
wined3d: WINED3DSIO_POW should use the absolute value of the first source register.
2007-05-11 12:12:40 +02:00
dst_write_mask = shader_glsl_append_dst(buffer, arg);
dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
if (dst_size > 1) {
shader_addline(buffer, "vec%d(pow(abs(%s), %s)));\n", dst_size, src0_param.param_str, src1_param.param_str);
} else {
shader_addline(buffer, "pow(abs(%s), %s));\n", src0_param.param_str, src1_param.param_str);
}
}
wined3d: d3d ignores the sign of the input value in the log instruction.
2007-09-09 21:24:53 +02:00
/* Process the WINED3DSIO_LOG instruction in GLSL (dst = log2(|src0|))
* Src0 is a scalar. Note that D3D uses the absolute of src0, while
* GLSL uses the value as-is. */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_log(SHADER_OPCODE_ARG *arg) {
wined3d: d3d ignores the sign of the input value in the log instruction.
2007-09-09 21:24:53 +02:00
SHADER_BUFFER *buffer = arg->buffer;
glsl_src_param_t src0_param;
DWORD dst_write_mask;
wined3d: Use unsigned int instead of size_t for the glsl mask size.
2008-01-07 17:17:27 +01:00
unsigned int dst_size;
wined3d: d3d ignores the sign of the input value in the log instruction.
2007-09-09 21:24:53 +02:00
dst_write_mask = shader_glsl_append_dst(buffer, arg);
dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
if (dst_size > 1) {
shader_addline(buffer, "vec%d(log2(abs(%s))));\n", dst_size, src0_param.param_str);
} else {
shader_addline(buffer, "log2(abs(%s)));\n", src0_param.param_str);
}
}
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
/* Map the opcode 1-to-1 to the GL code (arg->dst = instruction(src0, src1, ...) */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_map2gl(SHADER_OPCODE_ARG* arg) {
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
CONST SHADER_OPCODE* curOpcode = arg->opcode;
SHADER_BUFFER* buffer = arg->buffer;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src_param;
wined3d: Rewrite shader_glsl_map2gl() to properly take the write mask into account.
2007-01-15 19:32:07 +01:00
const char *instruction;
char arguments[256];
DWORD write_mask;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
unsigned i;
/* Determine the GLSL function to use based on the opcode */
/* TODO: Possibly make this a table for faster lookups */
switch (curOpcode->opcode) {
wined3d: Rewrite shader_glsl_map2gl() to properly take the write mask into account.
2007-01-15 19:32:07 +01:00
case WINED3DSIO_MIN: instruction = "min"; break;
case WINED3DSIO_MAX: instruction = "max"; break;
case WINED3DSIO_ABS: instruction = "abs"; break;
case WINED3DSIO_FRC: instruction = "fract"; break;
case WINED3DSIO_NRM: instruction = "normalize"; break;
case WINED3DSIO_EXP: instruction = "exp2"; break;
case WINED3DSIO_SGN: instruction = "sign"; break;
wined3d: Implement dsx & dsy shader instructions.
2007-07-03 00:22:18 +02:00
case WINED3DSIO_DSX: instruction = "dFdx"; break;
wined3d: Care for the inverted y coords in dsy.
2007-10-13 13:03:56 +02:00
case WINED3DSIO_DSY: instruction = "ycorrection.y * dFdy"; break;
wined3d: Rewrite shader_glsl_map2gl() to properly take the write mask into account.
2007-01-15 19:32:07 +01:00
default: instruction = "";
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
FIXME("Opcode %s not yet handled in GLSL\n", curOpcode->name);
break;
}
wined3d: Rewrite shader_glsl_map2gl() to properly take the write mask into account.
2007-01-15 19:32:07 +01:00
write_mask = shader_glsl_append_dst(buffer, arg);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Rewrite shader_glsl_map2gl() to properly take the write mask into account.
2007-01-15 19:32:07 +01:00
arguments[0] = '\0';
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
if (curOpcode->num_params > 0) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src_param);
strcat(arguments, src_param.param_str);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
for (i = 2; i < curOpcode->num_params; ++i) {
wined3d: Rewrite shader_glsl_map2gl() to properly take the write mask into account.
2007-01-15 19:32:07 +01:00
strcat(arguments, ", ");
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[i-1], arg->src_addr[i-1], write_mask, &src_param);
strcat(arguments, src_param.param_str);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
}
wined3d: Rewrite shader_glsl_map2gl() to properly take the write mask into account.
2007-01-15 19:32:07 +01:00
shader_addline(buffer, "%s(%s));\n", instruction, arguments);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_EXPP instruction in GLSL:
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
* For shader model 1.x, do the following (and honor the writemask, so use a temporary variable):
* dst.x = 2^(floor(src))
* dst.y = src - floor(src)
* dst.z = 2^src (partial precision is allowed, but optional)
* dst.w = 1.0;
* For 2.0 shaders, just do this (honoring writemask and swizzle):
* dst = 2^src; (partial precision is allowed, but optional)
*/
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_expp(SHADER_OPCODE_ARG* arg) {
wined3d: Rewrite shader_glsl_expp() to properly take the write mask into account.
2007-01-15 19:33:01 +01:00
IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)arg->shader;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src_param;
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src_param);
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
wined3d: Rewrite shader_glsl_expp() to properly take the write mask into account.
2007-01-15 19:33:01 +01:00
if (shader->baseShader.hex_version < WINED3DPS_VERSION(2,0)) {
char dst_mask[6];
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(arg->buffer, "tmp0.x = exp2(floor(%s));\n", src_param.param_str);
shader_addline(arg->buffer, "tmp0.y = %s - floor(%s);\n", src_param.param_str, src_param.param_str);
shader_addline(arg->buffer, "tmp0.z = exp2(%s);\n", src_param.param_str);
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
shader_addline(arg->buffer, "tmp0.w = 1.0;\n");
wined3d: Rewrite shader_glsl_expp() to properly take the write mask into account.
2007-01-15 19:33:01 +01:00
shader_glsl_append_dst(arg->buffer, arg);
shader_glsl_get_write_mask(arg->dst, dst_mask);
shader_addline(arg->buffer, "tmp0%s);\n", dst_mask);
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
} else {
wined3d: Rewrite shader_glsl_expp() to properly take the write mask into account.
2007-01-15 19:33:01 +01:00
DWORD write_mask;
wined3d: Use unsigned int instead of size_t for the glsl mask size.
2008-01-07 17:17:27 +01:00
unsigned int mask_size;
wined3d: Rewrite shader_glsl_expp() to properly take the write mask into account.
2007-01-15 19:33:01 +01:00
write_mask = shader_glsl_append_dst(arg->buffer, arg);
mask_size = shader_glsl_get_write_mask_size(write_mask);
if (mask_size > 1) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(arg->buffer, "vec%d(exp2(%s)));\n", mask_size, src_param.param_str);
wined3d: Rewrite shader_glsl_expp() to properly take the write mask into account.
2007-01-15 19:33:01 +01:00
} else {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(arg->buffer, "exp2(%s));\n", src_param.param_str);
wined3d: Rewrite shader_glsl_expp() to properly take the write mask into account.
2007-01-15 19:33:01 +01:00
}
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
}
}
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
/** Process the RCP (reciprocal or inverse) opcode in GLSL (dst = 1 / src) */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_rcp(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src_param;
wined3d: Rewrite shader_glsl_rcp() to properly take the write mask into account.
2007-01-15 19:33:06 +01:00
DWORD write_mask;
wined3d: Use unsigned int instead of size_t for the glsl mask size.
2008-01-07 17:17:27 +01:00
unsigned int mask_size;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Rewrite shader_glsl_rcp() to properly take the write mask into account.
2007-01-15 19:33:06 +01:00
write_mask = shader_glsl_append_dst(arg->buffer, arg);
mask_size = shader_glsl_get_write_mask_size(write_mask);
wined3d: rsq and rcp use the .w component if no swizzle is given.
2007-07-02 22:40:06 +02:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &src_param);
wined3d: Rewrite shader_glsl_rcp() to properly take the write mask into account.
2007-01-15 19:33:06 +01:00
if (mask_size > 1) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(arg->buffer, "vec%d(1.0 / %s));\n", mask_size, src_param.param_str);
wined3d: Rewrite shader_glsl_rcp() to properly take the write mask into account.
2007-01-15 19:33:06 +01:00
} else {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(arg->buffer, "1.0 / %s);\n", src_param.param_str);
wined3d: Rewrite shader_glsl_rcp() to properly take the write mask into account.
2007-01-15 19:33:06 +01:00
}
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_rsq(SHADER_OPCODE_ARG* arg) {
wined3d: rsq and rcp use the .w component if no swizzle is given.
2007-07-02 22:40:06 +02:00
SHADER_BUFFER* buffer = arg->buffer;
glsl_src_param_t src_param;
DWORD write_mask;
wined3d: Use unsigned int instead of size_t for the glsl mask size.
2008-01-07 17:17:27 +01:00
unsigned int mask_size;
wined3d: rsq and rcp use the .w component if no swizzle is given.
2007-07-02 22:40:06 +02:00
write_mask = shader_glsl_append_dst(buffer, arg);
mask_size = shader_glsl_get_write_mask_size(write_mask);
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &src_param);
if (mask_size > 1) {
shader_addline(buffer, "vec%d(inversesqrt(%s)));\n", mask_size, src_param.param_str);
} else {
shader_addline(buffer, "inversesqrt(%s));\n", src_param.param_str);
}
}
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
/** Process signed comparison opcodes in GLSL. */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_compare(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
wined3d: Move WINED3DSIO_SGE & WINED3DSIO_SLT from shader_glsl_map2gl() to shader_glsl_compare() where they belong. Properly take the write mask into account
2007-01-15 19:31:49 +01:00
DWORD write_mask;
wined3d: Use unsigned int instead of size_t for the glsl mask size.
2008-01-07 17:17:27 +01:00
unsigned int mask_size;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Move WINED3DSIO_SGE & WINED3DSIO_SLT from shader_glsl_map2gl() to shader_glsl_compare() where they belong. Properly take the write mask into account
2007-01-15 19:31:49 +01:00
write_mask = shader_glsl_append_dst(arg->buffer, arg);
mask_size = shader_glsl_get_write_mask_size(write_mask);
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Move WINED3DSIO_SGE & WINED3DSIO_SLT from shader_glsl_map2gl() to shader_glsl_compare() where they belong. Properly take the write mask into account
2007-01-15 19:31:49 +01:00
if (mask_size > 1) {
const char *compare;
switch(arg->opcode->opcode) {
case WINED3DSIO_SLT: compare = "lessThan"; break;
case WINED3DSIO_SGE: compare = "greaterThanEqual"; break;
default: compare = "";
FIXME("Can't handle opcode %s\n", arg->opcode->name);
}
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(arg->buffer, "vec%d(%s(%s, %s)));\n", mask_size, compare,
src0_param.param_str, src1_param.param_str);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
} else {
wined3d: Move WINED3DSIO_SGE & WINED3DSIO_SLT from shader_glsl_map2gl() to shader_glsl_compare() where they belong. Properly take the write mask into account
2007-01-15 19:31:49 +01:00
switch(arg->opcode->opcode) {
wined3d: Get rid of the conditionals in shader_glsl_compare.
2007-11-05 23:13:00 +01:00
case WINED3DSIO_SLT:
wined3d: Partially revert "Get rid of the conditionals in shader_glsl".
2007-11-09 19:53:20 +01:00
/* Step(src0, src1) is not suitable here because if src0 == src1 SLT is supposed,
* to return 0.0 but step returns 1.0 because step is not < x
Assorted spelling fixes.
2007-12-07 01:03:54 +01:00
* An alternative is a bvec compare padded with an unused second component.
wined3d: Partially revert "Get rid of the conditionals in shader_glsl".
2007-11-09 19:53:20 +01:00
* step(src1 * -1.0, src0 * -1.0) is not an option because it suffers from the same
* issue. Playing with not() is not possible either because not() does not accept
* a scalar.
*/
shader_addline(arg->buffer, "(%s < %s) ? 1.0 : 0.0);\n", src0_param.param_str, src1_param.param_str);
wined3d: Get rid of the conditionals in shader_glsl_compare.
2007-11-05 23:13:00 +01:00
break;
case WINED3DSIO_SGE:
wined3d: Partially revert "Get rid of the conditionals in shader_glsl".
2007-11-09 19:53:20 +01:00
/* Here we can use the step() function and safe a conditional */
wined3d: Get rid of the conditionals in shader_glsl_compare.
2007-11-05 23:13:00 +01:00
shader_addline(arg->buffer, "step(%s, %s));\n", src1_param.param_str, src0_param.param_str);
break;
default:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
FIXME("Can't handle opcode %s\n", arg->opcode->name);
}
wined3d: Move WINED3DSIO_SGE & WINED3DSIO_SLT from shader_glsl_map2gl() to shader_glsl_compare() where they belong. Properly take the write mask into account
2007-01-15 19:31:49 +01:00
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
}
wined3d: Rewrite shader_glsl_cmp() to properly take the write mask into account.
2007-01-15 19:32:48 +01:00
/** Process CMP instruction in GLSL (dst = src0 >= 0.0 ? src1 : src2), per channel */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_cmp(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
glsl_src_param_t src2_param;
wined3d: Fix GLSL cmp instruction for INF and NAN arguments.
2007-03-29 19:57:41 +02:00
DWORD write_mask, cmp_channel = 0;
unsigned int i, j;
wined3d: Take care against overwriting a source register in cmp.
2007-09-09 16:54:51 +02:00
char mask_char[6];
BOOL temp_destination = FALSE;
wined3d: Add a test for the vFace register.
2008-02-11 12:04:57 +01:00
if(shader_is_scalar(arg->src[0])) {
write_mask = shader_glsl_append_dst(arg->buffer, arg);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Add a test for the vFace register.
2008-02-11 12:04:57 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
wined3d: Fix GLSL cmp instruction for INF and NAN arguments.
2007-03-29 19:57:41 +02:00
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Add a test for the vFace register.
2008-02-11 12:04:57 +01:00
shader_addline(arg->buffer, "%s >= 0.0 ? %s : %s);\n",
src0_param.param_str, src1_param.param_str, src2_param.param_str);
} else {
DWORD src0reg = arg->src[0] & WINED3DSP_REGNUM_MASK;
DWORD src1reg = arg->src[1] & WINED3DSP_REGNUM_MASK;
DWORD src2reg = arg->src[2] & WINED3DSP_REGNUM_MASK;
DWORD src0regtype = shader_get_regtype(arg->src[0]);
DWORD src1regtype = shader_get_regtype(arg->src[1]);
DWORD src2regtype = shader_get_regtype(arg->src[2]);
DWORD dstreg = arg->dst & WINED3DSP_REGNUM_MASK;
DWORD dstregtype = shader_get_regtype(arg->dst);
/* Cycle through all source0 channels */
for (i=0; i<4; i++) {
write_mask = 0;
/* Find the destination channels which use the current source0 channel */
for (j=0; j<4; j++) {
if ( ((arg->src[0] >> (WINED3DSP_SWIZZLE_SHIFT + 2*j)) & 0x3) == i ) {
write_mask |= WINED3DSP_WRITEMASK_0 << j;
cmp_channel = WINED3DSP_WRITEMASK_0 << j;
}
}
/* Splitting the cmp instruction up in multiple lines imposes a problem:
* The first lines may overwrite source parameters of the following lines.
* Deal with that by using a temporary destination register if needed
*/
if((src0reg == dstreg && src0regtype == dstregtype) ||
(src1reg == dstreg && src1regtype == dstregtype) ||
(src2reg == dstreg && src2regtype == dstregtype)) {
write_mask = shader_glsl_get_write_mask(arg->dst & (~WINED3DSP_SWIZZLE_MASK | write_mask), mask_char);
if (!write_mask) continue;
shader_addline(arg->buffer, "tmp0%s = (", mask_char);
temp_destination = TRUE;
} else {
write_mask = shader_glsl_append_dst_ext(arg->buffer, arg, arg->dst & (~WINED3DSP_SWIZZLE_MASK | write_mask));
if (!write_mask) continue;
}
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], cmp_channel, &src0_param);
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
wined3d: Take care against overwriting a source register in cmp.
2007-09-09 16:54:51 +02:00
shader_addline(arg->buffer, "%s >= 0.0 ? %s : %s);\n",
wined3d: Add a test for the vFace register.
2008-02-11 12:04:57 +01:00
src0_param.param_str, src1_param.param_str, src2_param.param_str);
}
wined3d: Take care against overwriting a source register in cmp.
2007-09-09 16:54:51 +02:00
wined3d: Add a test for the vFace register.
2008-02-11 12:04:57 +01:00
if(temp_destination) {
shader_glsl_get_write_mask(arg->dst, mask_char);
shader_glsl_append_dst_ext(arg->buffer, arg, arg->dst);
shader_addline(arg->buffer, "tmp0%s);\n", mask_char);
}
wined3d: Take care against overwriting a source register in cmp.
2007-09-09 16:54:51 +02:00
}
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
wined3d: Fix GLSL cnd instruction. According to MSDN the cnd instruction should translate: dst = src0 > 0.5 ? src1 : src2;
2007-04-05 00:26:35 +02:00
/** Process the CND opcode in GLSL (dst = (src0 > 0.5) ? src1 : src2) */
wined3d: Rewrite shader_glsl_cnd() to properly take the write mask into account. Take the difference between ps 1.4 and earlier versions into account.
2007-01-15 19:32:54 +01:00
/* For ps 1.1-1.3, only a single component of src0 is used. For ps 1.4
* the compare is done per component of src0. */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_cnd(SHADER_OPCODE_ARG* arg) {
wined3d: Rewrite shader_glsl_cnd() to properly take the write mask into account. Take the difference between ps 1.4 and earlier versions into account.
2007-01-15 19:32:54 +01:00
IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
glsl_src_param_t src2_param;
wined3d: Fix GLSL cnd instruction for INF and NAN arguments.
2007-03-29 19:59:11 +02:00
DWORD write_mask, cmp_channel = 0;
unsigned int i, j;
wined3d: Rewrite shader_glsl_cnd() to properly take the write mask into account. Take the difference between ps 1.4 and earlier versions into account.
2007-01-15 19:32:54 +01:00
if (shader->baseShader.hex_version < WINED3DPS_VERSION(1, 4)) {
wined3d: Fix GLSL cnd instruction for INF and NAN arguments.
2007-03-29 19:59:11 +02:00
write_mask = shader_glsl_append_dst(arg->buffer, arg);
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
wined3d: Fix GLSL cnd instruction for INF and NAN arguments.
2007-03-29 19:59:11 +02:00
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
wined3d: The D3DSI_COISSUE flag changes the behavior of cnd.
2007-09-13 14:48:57 +02:00
/* Fun: The D3DSI_COISSUE flag changes the semantic of the cnd instruction for < 1.4 shaders */
if(arg->opcode_token & WINED3DSI_COISSUE) {
shader_addline(arg->buffer, "%s /* COISSUE! */);\n", src1_param.param_str);
} else {
shader_addline(arg->buffer, "%s > 0.5 ? %s : %s);\n",
src0_param.param_str, src1_param.param_str, src2_param.param_str);
}
wined3d: Fix GLSL cnd instruction for INF and NAN arguments.
2007-03-29 19:59:11 +02:00
return;
wined3d: Rewrite shader_glsl_cnd() to properly take the write mask into account. Take the difference between ps 1.4 and earlier versions into account.
2007-01-15 19:32:54 +01:00
}
wined3d: Fix GLSL cnd instruction for INF and NAN arguments.
2007-03-29 19:59:11 +02:00
/* Cycle through all source0 channels */
for (i=0; i<4; i++) {
write_mask = 0;
/* Find the destination channels which use the current source0 channel */
for (j=0; j<4; j++) {
if ( ((arg->src[0] >> (WINED3DSP_SWIZZLE_SHIFT + 2*j)) & 0x3) == i ) {
write_mask |= WINED3DSP_WRITEMASK_0 << j;
cmp_channel = WINED3DSP_WRITEMASK_0 << j;
}
}
write_mask = shader_glsl_append_dst_ext(arg->buffer, arg, arg->dst & (~WINED3DSP_SWIZZLE_MASK | write_mask));
if (!write_mask) continue;
wined3d: Rewrite shader_glsl_cnd() to properly take the write mask into account. Take the difference between ps 1.4 and earlier versions into account.
2007-01-15 19:32:54 +01:00
wined3d: Fix GLSL cnd instruction for INF and NAN arguments.
2007-03-29 19:59:11 +02:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], cmp_channel, &src0_param);
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
wined3d: Rewrite shader_glsl_cnd() to properly take the write mask into account. Take the difference between ps 1.4 and earlier versions into account.
2007-01-15 19:32:54 +01:00
wined3d: Fix GLSL cnd instruction. According to MSDN the cnd instruction should translate: dst = src0 > 0.5 ? src1 : src2;
2007-04-05 00:26:35 +02:00
shader_addline(arg->buffer, "%s > 0.5 ? %s : %s);\n",
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
src0_param.param_str, src1_param.param_str, src2_param.param_str);
wined3d: Rewrite shader_glsl_cnd() to properly take the write mask into account. Take the difference between ps 1.4 and earlier versions into account.
2007-01-15 19:32:54 +01:00
}
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** GLSL code generation for WINED3DSIO_MAD: Multiply the first 2 opcodes, then add the last */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_mad(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
glsl_src_param_t src2_param;
wined3d: Rewrite shader_glsl_mad() to properly take the write mask into account.
2007-01-15 19:31:37 +01:00
DWORD write_mask;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Rewrite shader_glsl_mad() to properly take the write mask into account.
2007-01-15 19:31:37 +01:00
write_mask = shader_glsl_append_dst(arg->buffer, arg);
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
shader_addline(arg->buffer, "(%s * %s) + %s);\n",
src0_param.param_str, src1_param.param_str, src2_param.param_str);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Handles transforming all WINED3DSIO_M?x? opcodes for
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
Vertex shaders to GLSL codes */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_mnxn(SHADER_OPCODE_ARG* arg) {
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
int i;
int nComponents = 0;
SHADER_OPCODE_ARG tmpArg;
memset(&tmpArg, 0, sizeof(SHADER_OPCODE_ARG));
/* Set constants for the temporary argument */
tmpArg.shader = arg->shader;
tmpArg.buffer = arg->buffer;
tmpArg.src[0] = arg->src[0];
tmpArg.src_addr[0] = arg->src_addr[0];
wined3d: Fix D3DSIO_M#X# instruction for both ARB and GLSL shaders. This instruction was being handled incorrectly in the case where the 2nd src argument contained a relatively addressed constant.
2006-07-06 04:35:56 +02:00
tmpArg.src_addr[1] = arg->src_addr[1];
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
tmpArg.reg_maps = arg->reg_maps;
switch(arg->opcode->opcode) {
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
case WINED3DSIO_M4x4:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
nComponents = 4;
wined3d: Fix introduced regression in shader_glsl_mnxn and vshader_hw_mnxn.
2006-10-30 20:27:01 +01:00
tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP4);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
break;
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
case WINED3DSIO_M4x3:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
nComponents = 3;
wined3d: Fix introduced regression in shader_glsl_mnxn and vshader_hw_mnxn.
2006-10-30 20:27:01 +01:00
tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP4);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
break;
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
case WINED3DSIO_M3x4:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
nComponents = 4;
wined3d: Fix introduced regression in shader_glsl_mnxn and vshader_hw_mnxn.
2006-10-30 20:27:01 +01:00
tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
break;
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
case WINED3DSIO_M3x3:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
nComponents = 3;
wined3d: Fix introduced regression in shader_glsl_mnxn and vshader_hw_mnxn.
2006-10-30 20:27:01 +01:00
tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
break;
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
case WINED3DSIO_M3x2:
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
nComponents = 2;
wined3d: Fix introduced regression in shader_glsl_mnxn and vshader_hw_mnxn.
2006-10-30 20:27:01 +01:00
tmpArg.opcode = shader_get_opcode(arg->shader, WINED3DSIO_DP3);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
break;
default:
break;
}
for (i = 0; i < nComponents; i++) {
wined3d: Move D3DSP dest modifier related items into the WINED3D namespace.
2006-10-10 01:48:12 +02:00
tmpArg.dst = ((arg->dst) & ~WINED3DSP_WRITEMASK_ALL)|(WINED3DSP_WRITEMASK_0<<i);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
tmpArg.src[1] = arg->src[1]+i;
shader_glsl_dot(&tmpArg);
}
}
/**
The LRP instruction performs a component-wise linear interpolation
between the second and third operands using the first operand as the
wined3d: Rewrite shader_glsl_lrp() to properly take the write mask into account, use the GLSL mix instruction.
2007-01-15 19:32:40 +01:00
blend factor. Equation: (dst = src2 + src0 * (src1 - src2))
This is equivalent to mix(src2, src1, src0);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
*/
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_lrp(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
glsl_src_param_t src2_param;
wined3d: Rewrite shader_glsl_lrp() to properly take the write mask into account, use the GLSL mix instruction.
2007-01-15 19:32:40 +01:00
DWORD write_mask;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Rewrite shader_glsl_lrp() to properly take the write mask into account, use the GLSL mix instruction.
2007-01-15 19:32:40 +01:00
write_mask = shader_glsl_append_dst(arg->buffer, arg);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], write_mask, &src0_param);
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], write_mask, &src1_param);
shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], write_mask, &src2_param);
wined3d: Rewrite shader_glsl_lrp() to properly take the write mask into account, use the GLSL mix instruction.
2007-01-15 19:32:40 +01:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(arg->buffer, "mix(%s, %s, %s));\n",
src2_param.param_str, src1_param.param_str, src0_param.param_str);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_LIT instruction in GLSL:
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 04:32:14 +02:00
* dst.x = dst.w = 1.0
* dst.y = (src0.x > 0) ? src0.x
* dst.z = (src0.x > 0) ? ((src0.y > 0) ? pow(src0.y, src.w) : 0) : 0
* where src.w is clamped at +- 128
*/
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_lit(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
glsl_src_param_t src3_param;
wined3d: Pass the correct mask to shader_glsl_add_src_param() in shader_glsl_lit().
2007-01-15 19:32:33 +01:00
char dst_mask[6];
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 04:32:14 +02:00
wined3d: Pass the correct mask to shader_glsl_add_src_param() in shader_glsl_lit().
2007-01-15 19:32:33 +01:00
shader_glsl_append_dst(arg->buffer, arg);
shader_glsl_get_write_mask(arg->dst, dst_mask);
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_1, &src1_param);
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &src3_param);
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 04:32:14 +02:00
wined3d: Get rid of the conditionals in the glsl lit implementation.
2007-10-28 21:21:24 +01:00
/* The sdk specifies the instruction like this
* dst.x = 1.0;
* if(src.x > 0.0) dst.y = src.x
* else dst.y = 0.0.
* if(src.x > 0.0 && src.y > 0.0) dst.z = pow(src.y, power);
* else dst.z = 0.0;
* dst.w = 1.0;
*
* Obviously that has quite a few conditionals in it which we don't like. So the first step is this:
* dst.x = 1.0 ... No further explanation needed
* dst.y = max(src.y, 0.0); ... If x < 0.0, use 0.0, otherwise x. Same as the conditional
* dst.z = x > 0.0 ? pow(max(y, 0.0), p) : 0; ... 0 ^ power is 0, and otherwise we use y anyway
* dst.w = 1.0. ... Nothing fancy.
*
* So we still have one conditional in there. So do this:
* dst.z = pow(max(0.0, src.y) * step(0.0, src.x), power);
*
* step(0.0, x) will return 1 if src.x > 0.0, and 0 otherwise. So if y is 0 we get pow(0.0 * 1.0, power),
* which sets dst.z to 0. If y > 0, but x = 0.0, we get pow(y * 0.0, power), which results in 0 too.
* if both x and y are > 0, we get pow(y * 1.0, power), as it is supposed to
*/
shader_addline(arg->buffer, "vec4(1.0, max(%s, 0.0), pow(max(0.0, %s) * step(0.0, %s), clamp(%s, -128.0, 128.0)), 1.0)%s);\n",
src0_param.param_str, src1_param.param_str, src0_param.param_str, src3_param.param_str, dst_mask);
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 04:32:14 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_DST instruction in GLSL:
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 04:32:14 +02:00
* dst.x = 1.0
* dst.y = src0.x * src0.y
* dst.z = src0.z
* dst.w = src1.w
*/
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_dst(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0y_param;
glsl_src_param_t src0z_param;
glsl_src_param_t src1y_param;
glsl_src_param_t src1w_param;
char dst_mask[6];
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 04:32:14 +02:00
wined3d: Pass the correct mask to shader_glsl_add_src_param() in shader_glsl_dst().
2007-01-15 19:33:15 +01:00
shader_glsl_append_dst(arg->buffer, arg);
shader_glsl_get_write_mask(arg->dst, dst_mask);
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_1, &src0y_param);
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_2, &src0z_param);
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_1, &src1y_param);
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_3, &src1w_param);
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 04:32:14 +02:00
wined3d: Pass the correct mask to shader_glsl_add_src_param() in shader_glsl_dst().
2007-01-15 19:33:15 +01:00
shader_addline(arg->buffer, "vec4(1.0, %s * %s, %s, %s))%s;\n",
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
src0y_param.param_str, src1y_param.param_str, src0z_param.param_str, src1w_param.param_str, dst_mask);
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 04:32:14 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_SINCOS instruction in GLSL:
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 04:32:14 +02:00
* VS 2.0 requires that specific cosine and sine constants be passed to this instruction so the hardware
* can handle it. But, these functions are built-in for GLSL, so we can just ignore the last 2 params.
*
* dst.x = cos(src0.?)
* dst.y = sin(src0.?)
* dst.z = dst.z
* dst.w = dst.w
*/
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_sincos(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
wined3d: Rewrite shader_glsl_sincos() to properly take the write mask into account. The write mask can only be one of .x, .y, .xy
2007-01-15 19:31:25 +01:00
DWORD write_mask;
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 04:32:14 +02:00
wined3d: Rewrite shader_glsl_sincos() to properly take the write mask into account. The write mask can only be one of .x, .y, .xy
2007-01-15 19:31:25 +01:00
write_mask = shader_glsl_append_dst(arg->buffer, arg);
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
wined3d: Rewrite shader_glsl_sincos() to properly take the write mask into account. The write mask can only be one of .x, .y, .xy
2007-01-15 19:31:25 +01:00
switch (write_mask) {
case WINED3DSP_WRITEMASK_0:
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(arg->buffer, "cos(%s));\n", src0_param.param_str);
wined3d: Rewrite shader_glsl_sincos() to properly take the write mask into account. The write mask can only be one of .x, .y, .xy
2007-01-15 19:31:25 +01:00
break;
case WINED3DSP_WRITEMASK_1:
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(arg->buffer, "sin(%s));\n", src0_param.param_str);
wined3d: Rewrite shader_glsl_sincos() to properly take the write mask into account. The write mask can only be one of .x, .y, .xy
2007-01-15 19:31:25 +01:00
break;
case (WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1):
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(arg->buffer, "vec2(cos(%s), sin(%s)));\n", src0_param.param_str, src0_param.param_str);
wined3d: Rewrite shader_glsl_sincos() to properly take the write mask into account. The write mask can only be one of .x, .y, .xy
2007-01-15 19:31:25 +01:00
break;
default:
ERR("Write mask should be .x, .y or .xy\n");
break;
}
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 04:32:14 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_LOOP instruction in GLSL:
wined3d: Pass the correct mask to shader_glsl_add_src_param() in shader_glsl_loop(). Fix the comment.
2007-01-15 19:36:11 +01:00
* Start a for() loop where src1.y is the initial value of aL,
* increment aL by src1.z for a total of src1.x iterations.
wined3d: Correct implementation of D3DSIO_LOOP. I initially misread the specification. src0.x is the iteration count, not the max amount for the loop register. This fixes that.
2006-06-17 05:01:20 +02:00
* Need to use a temporary variable for this operation.
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 04:32:14 +02:00
*/
wined3d: Pass the correct mask to shader_glsl_add_src_param() in shader_glsl_loop(). Fix the comment.
2007-01-15 19:36:11 +01:00
/* FIXME: I don't think nested loops will work correctly this way. */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_loop(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src1_param;
wined3d: Nested loop support.
2007-09-14 13:21:52 +02:00
IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
wined3d: Pixel Shader varying indexing.
2007-10-28 00:08:56 +02:00
DWORD regtype = shader_get_regtype(arg->src[1]);
DWORD reg = arg->src[1] & WINED3DSP_REGNUM_MASK;
const DWORD *control_values = NULL;
local_constant *constant;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_ALL, &src1_param);
wined3d: Nested loop support.
2007-09-14 13:21:52 +02:00
wined3d: Pixel Shader varying indexing.
2007-10-28 00:08:56 +02:00
/* Try to hardcode the loop control parameters if possible. Direct3D 9 class hardware doesn't support real
* varying indexing, but Microsoft designed this feature for Shader model 2.x+. If the loop control is
* known at compile time, the GLSL compiler can unroll the loop, and replace indirect addressing with direct
* addressing.
*/
if(regtype == WINED3DSPR_CONSTINT) {
LIST_FOR_EACH_ENTRY(constant, &shader->baseShader.constantsI, local_constant, entry) {
if(constant->idx == reg) {
control_values = constant->value;
break;
}
}
}
if(control_values) {
if(control_values[2] > 0) {
shader_addline(arg->buffer, "for (aL%u = %d; aL%u < (%d * %d + %d); aL%u += %d) {\n",
shader->baseShader.cur_loop_depth, control_values[1],
shader->baseShader.cur_loop_depth, control_values[0], control_values[2], control_values[1],
shader->baseShader.cur_loop_depth, control_values[2]);
} else if(control_values[2] == 0) {
shader_addline(arg->buffer, "for (aL%u = %d, tmpInt%u = 0; tmpInt%u < %d; tmpInt%u++) {\n",
shader->baseShader.cur_loop_depth, control_values[1], shader->baseShader.cur_loop_depth,
shader->baseShader.cur_loop_depth, control_values[0],
shader->baseShader.cur_loop_depth);
} else {
shader_addline(arg->buffer, "for (aL%u = %d; aL%u > (%d * %d + %d); aL%u += %d) {\n",
shader->baseShader.cur_loop_depth, control_values[1],
shader->baseShader.cur_loop_depth, control_values[0], control_values[2], control_values[1],
shader->baseShader.cur_loop_depth, control_values[2]);
}
} else {
shader_addline(arg->buffer, "for (tmpInt%u = 0, aL%u = %s.y; tmpInt%u < %s.x; tmpInt%u++, aL%u += %s.z) {\n",
shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_regno,
src1_param.reg_name, shader->baseShader.cur_loop_depth, src1_param.reg_name,
shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_regno, src1_param.reg_name);
}
wined3d: Nested loop support.
2007-09-14 13:21:52 +02:00
shader->baseShader.cur_loop_depth++;
shader->baseShader.cur_loop_regno++;
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 11:11:35 +02:00
}
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_end(SHADER_OPCODE_ARG* arg) {
wined3d: Nested loop support.
2007-09-14 13:21:52 +02:00
IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 11:11:35 +02:00
shader_addline(arg->buffer, "}\n");
wined3d: Nested loop support.
2007-09-14 13:21:52 +02:00
if(arg->opcode->opcode == WINED3DSIO_ENDLOOP) {
shader->baseShader.cur_loop_depth--;
shader->baseShader.cur_loop_regno--;
}
if(arg->opcode->opcode == WINED3DSIO_ENDREP) {
shader->baseShader.cur_loop_depth--;
}
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 11:11:35 +02:00
}
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_rep(SHADER_OPCODE_ARG* arg) {
wined3d: Nested loop support.
2007-09-14 13:21:52 +02:00
IWineD3DBaseShaderImpl* shader = (IWineD3DBaseShaderImpl*) arg->shader;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 11:11:35 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
wined3d: Nested loop support.
2007-09-14 13:21:52 +02:00
shader_addline(arg->buffer, "for (tmpInt%d = 0; tmpInt%d < %s; tmpInt%d++) {\n",
shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_depth,
src0_param.param_str, shader->baseShader.cur_loop_depth);
shader->baseShader.cur_loop_depth++;
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 04:32:14 +02:00
}
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_if(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 04:32:14 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
shader_addline(arg->buffer, "if (%s) {\n", src0_param.param_str);
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 11:11:35 +02:00
}
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_ifc(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 11:11:35 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 11:11:35 +02:00
shader_addline(arg->buffer, "if (%s %s %s) {\n",
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
src0_param.param_str, shader_get_comp_op(arg->opcode_token), src1_param.param_str);
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 11:11:35 +02:00
}
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_else(SHADER_OPCODE_ARG* arg) {
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 11:11:35 +02:00
shader_addline(arg->buffer, "} else {\n");
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 04:32:14 +02:00
}
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_break(SHADER_OPCODE_ARG* arg) {
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 11:11:35 +02:00
shader_addline(arg->buffer, "break;\n");
}
wined3d: Pass the correct mask to shader_glsl_add_src_param() in shader_glsl_breakc().
2007-01-15 19:36:29 +01:00
/* FIXME: According to MSDN the compare is done per component. */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_breakc(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 11:11:35 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0, &src0_param);
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 11:11:35 +02:00
shader_addline(arg->buffer, "if (%s %s %s) break;\n",
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
src0_param.param_str, shader_get_comp_op(arg->opcode_token), src1_param.param_str);
wined3d: More flow control instructions - Implement if, else, endif, rep, endrep, break - Implement ifc, breakc, using undocumented comparison bits in the instruction token - Fix bug in main loop processing of codes with no dst token - Fix bug in GLSL output modifier processing of codes with no dst token - Fix bug in loop implementation (src1 contains the integer data, src0 is aL) - Add versioning for all the instructions above, and remove GLSL_REQUIRED thing, which is useless and should be removed from all opcodes in general.
2006-07-10 11:11:35 +02:00
}
wined3d: Implement more GLSL instructions. - Implemented: D3DSIO_SGN, LOOP, ENDLOOP, LOGP, LIT, DST, SINCOS - Process instruction-based modifiers (function existed, it just wasn't being called) - Add loop checking to register maps. - Renamed "sng" to "sgn" for D3DSIO_SGN - it's not handled anywhere except for GLSL, so won't matter.
2006-06-14 04:32:14 +02:00
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_label(SHADER_OPCODE_ARG* arg) {
wined3d: More flow control instructions. - Implement call, callnz, label, and ret - Implement support for NOT modifier
2006-07-10 12:35:15 +02:00
wined3d: Move D3DSP_REG structures into the WINED3D namespace.
2006-10-10 01:47:12 +02:00
DWORD snum = (arg->src[0]) & WINED3DSP_REGNUM_MASK;
wined3d: More flow control instructions. - Implement call, callnz, label, and ret - Implement support for NOT modifier
2006-07-10 12:35:15 +02:00
shader_addline(arg->buffer, "}\n");
wined3d: Add printf format checking to the shader_addline function and fix resulting warnings.
2007-11-28 12:55:11 +01:00
shader_addline(arg->buffer, "void subroutine%u () {\n", snum);
wined3d: More flow control instructions. - Implement call, callnz, label, and ret - Implement support for NOT modifier
2006-07-10 12:35:15 +02:00
}
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_call(SHADER_OPCODE_ARG* arg) {
wined3d: Move D3DSP_REG structures into the WINED3D namespace.
2006-10-10 01:47:12 +02:00
DWORD snum = (arg->src[0]) & WINED3DSP_REGNUM_MASK;
wined3d: Add printf format checking to the shader_addline function and fix resulting warnings.
2007-11-28 12:55:11 +01:00
shader_addline(arg->buffer, "subroutine%u();\n", snum);
wined3d: More flow control instructions. - Implement call, callnz, label, and ret - Implement support for NOT modifier
2006-07-10 12:35:15 +02:00
}
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_callnz(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src1_param;
wined3d: More flow control instructions. - Implement call, callnz, label, and ret - Implement support for NOT modifier
2006-07-10 12:35:15 +02:00
wined3d: Move D3DSP_REG structures into the WINED3D namespace.
2006-10-10 01:47:12 +02:00
DWORD snum = (arg->src[0]) & WINED3DSP_REGNUM_MASK;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0, &src1_param);
wined3d: Add printf format checking to the shader_addline function and fix resulting warnings.
2007-11-28 12:55:11 +01:00
shader_addline(arg->buffer, "if (%s) subroutine%u();\n", src1_param.param_str, snum);
wined3d: More flow control instructions. - Implement call, callnz, label, and ret - Implement support for NOT modifier
2006-07-10 12:35:15 +02:00
}
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
/*********************************************
* Pixel Shader Specific Code begins here
********************************************/
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_tex(SHADER_OPCODE_ARG* arg) {
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
wined3d: Add signed format conversion for glsl.
2007-09-21 23:34:09 +02:00
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early]
2006-06-12 08:54:30 +02:00
DWORD hex_version = This->baseShader.hex_version;
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
char dst_swizzle[6];
glsl_sample_function_t sample_function;
DWORD sampler_type;
DWORD sampler_idx;
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
BOOL projected, texrect = FALSE;
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
DWORD mask = 0;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
/* All versions have a destination register */
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
shader_glsl_append_dst(arg->buffer, arg);
wined3d: Improve Sampler support on 2.0 and 3.0 shaders. - track sampler declarations and store the sampler usage in reg_maps structure - store a fake sampler usage for 1.X shaders (defined as 2D sampler) - re-sync glsl TEX implementation with the ARB one (no idea why they diverged..) - use sampler type in new TEX implementation to support 2D, 3D, and Cube sampling - change drawprim to bind pixel shader samplers Additional improvements: - rename texture limit to texcoord to prevent confusion - add sampler limit, and use that for samplers - *not* the same as texcoord above
2006-06-12 08:59:16 +02:00
wined3d: Create a separate function for sampling a texture.
2006-11-27 20:50:47 +01:00
/* 1.0-1.4: Use destination register as sampler source.
* 2.0+: Use provided sampler source. */
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
if (hex_version < WINED3DPS_VERSION(1,4)) {
DWORD flags;
sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
flags = deviceImpl->stateBlock->textureState[sampler_idx][WINED3DTSS_TEXTURETRANSFORMFLAGS];
if (flags & WINED3DTTFF_PROJECTED) {
projected = TRUE;
switch (flags & ~WINED3DTTFF_PROJECTED) {
case WINED3DTTFF_COUNT1: FIXME("WINED3DTTFF_PROJECTED with WINED3DTTFF_COUNT1?\n"); break;
case WINED3DTTFF_COUNT2: mask = WINED3DSP_WRITEMASK_1; break;
case WINED3DTTFF_COUNT3: mask = WINED3DSP_WRITEMASK_2; break;
case WINED3DTTFF_COUNT4:
case WINED3DTTFF_DISABLE: mask = WINED3DSP_WRITEMASK_3; break;
}
} else {
projected = FALSE;
}
} else if (hex_version < WINED3DPS_VERSION(2,0)) {
DWORD src_mod = arg->src[0] & WINED3DSP_SRCMOD_MASK;
sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
if (src_mod == WINED3DSPSM_DZ) {
projected = TRUE;
mask = WINED3DSP_WRITEMASK_2;
} else if (src_mod == WINED3DSPSM_DW) {
projected = TRUE;
mask = WINED3DSP_WRITEMASK_3;
} else {
projected = FALSE;
}
} else {
sampler_idx = arg->src[1] & WINED3DSP_REGNUM_MASK;
wined3d: Implement support for projective textures in ps 2.0 and later.
2007-03-29 18:44:57 +02:00
if(arg->opcode_token & WINED3DSI_TEXLD_PROJECT) {
/* ps 2.0 texldp instruction always divides by the fourth component. */
projected = TRUE;
mask = WINED3DSP_WRITEMASK_3;
} else {
projected = FALSE;
}
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
}
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
if(deviceImpl->stateBlock->textures[sampler_idx] &&
IWineD3DBaseTexture_GetTextureDimensions(deviceImpl->stateBlock->textures[sampler_idx]) == GL_TEXTURE_RECTANGLE_ARB) {
texrect = TRUE;
}
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
shader_glsl_get_sample_function(sampler_type, projected, texrect, &sample_function);
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
mask |= sample_function.coord_mask;
wined3d: Add shader version/end masks to the WINED3D namespace.
2006-10-13 05:36:41 +02:00
if (hex_version < WINED3DPS_VERSION(2,0)) {
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
shader_glsl_get_write_mask(arg->dst, dst_swizzle);
wined3d: Load projected textures in fragment shaders.
2006-08-24 23:57:46 +02:00
} else {
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
shader_glsl_get_swizzle(arg->src[1], FALSE, arg->dst, dst_swizzle);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
wined3d: Create a separate function for sampling a texture.
2006-11-27 20:50:47 +01:00
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
/* 1.0-1.3: Use destination register as coordinate source.
1.4+: Use provided coordinate source register. */
if (hex_version < WINED3DPS_VERSION(1,4)) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
char coord_mask[6];
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
shader_glsl_get_write_mask(mask, coord_mask);
shader_addline(arg->buffer, "%s(Psampler%u, T%u%s)%s);\n",
sample_function.name, sampler_idx, sampler_idx, coord_mask, dst_swizzle);
} else {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t coord_param;
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], mask, &coord_param);
wined3d: Implement texldb.
2007-08-30 22:59:14 +02:00
if(arg->opcode_token & WINED3DSI_TEXLD_BIAS) {
glsl_src_param_t bias;
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &bias);
shader_addline(arg->buffer, "%s(Psampler%u, %s, %s)%s);\n",
sample_function.name, sampler_idx, coord_param.param_str,
bias.param_str, dst_swizzle);
} else {
shader_addline(arg->buffer, "%s(Psampler%u, %s)%s);\n",
sample_function.name, sampler_idx, coord_param.param_str, dst_swizzle);
}
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
}
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void shader_glsl_texldl(SHADER_OPCODE_ARG* arg) {
wined3d: Implement texldl.
2007-06-27 23:46:53 +02:00
IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*)arg->shader;
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
wined3d: Implement texldl.
2007-06-27 23:46:53 +02:00
glsl_sample_function_t sample_function;
glsl_src_param_t coord_param, lod_param;
char dst_swizzle[6];
DWORD sampler_type;
DWORD sampler_idx;
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
BOOL texrect = FALSE;
wined3d: Implement texldl.
2007-06-27 23:46:53 +02:00
shader_glsl_append_dst(arg->buffer, arg);
shader_glsl_get_swizzle(arg->src[1], FALSE, arg->dst, dst_swizzle);
sampler_idx = arg->src[1] & WINED3DSP_REGNUM_MASK;
sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
if(deviceImpl->stateBlock->textures[sampler_idx] &&
IWineD3DBaseTexture_GetTextureDimensions(deviceImpl->stateBlock->textures[sampler_idx]) == GL_TEXTURE_RECTANGLE_ARB) {
texrect = TRUE;
}
shader_glsl_get_sample_function(sampler_type, FALSE, texrect, &sample_function); shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], sample_function.coord_mask, &coord_param);
wined3d: Implement texldl.
2007-06-27 23:46:53 +02:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &lod_param);
if (shader_is_pshader_version(This->baseShader.hex_version)) {
/* The GLSL spec claims the Lod sampling functions are only supported in vertex shaders.
* However, they seem to work just fine in fragment shaders as well. */
WARN("Using %sLod in fragment shader.\n", sample_function.name);
shader_addline(arg->buffer, "%sLod(Psampler%u, %s, %s)%s);\n",
sample_function.name, sampler_idx, coord_param.param_str, lod_param.param_str, dst_swizzle);
} else {
shader_addline(arg->buffer, "%sLod(Vsampler%u, %s, %s)%s);\n",
sample_function.name, sampler_idx, coord_param.param_str, lod_param.param_str, dst_swizzle);
}
}
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_texcoord(SHADER_OPCODE_ARG* arg) {
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
/* FIXME: Make this work for more than just 2D textures */
IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
SHADER_BUFFER* buffer = arg->buffer;
wined3d: Share trace pass Now that the declaration function is out of the way, the tracing pass, which is very long and 100% the same can be shared between pixel and vertex shaders. The new function is called shader_trace_init(), and is responsible for: - tracing the shader - initializing the function length - setting the shader version [needed very early]
2006-06-12 08:54:30 +02:00
DWORD hex_version = This->baseShader.hex_version;
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
DWORD write_mask;
char dst_mask[6];
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
write_mask = shader_glsl_append_dst(arg->buffer, arg);
shader_glsl_get_write_mask(write_mask, dst_mask);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Add shader version/end masks to the WINED3D namespace.
2006-10-13 05:36:41 +02:00
if (hex_version != WINED3DPS_VERSION(1,4)) {
wined3d: Move D3DSP_REG structures into the WINED3D namespace.
2006-10-10 01:47:12 +02:00
DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
shader_addline(buffer, "clamp(gl_TexCoord[%u], 0.0, 1.0)%s);\n", reg, dst_mask);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
} else {
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
DWORD reg = arg->src[0] & WINED3DSP_REGNUM_MASK;
DWORD src_mod = arg->src[0] & WINED3DSP_SRCMOD_MASK;
char dst_swizzle[6];
shader_glsl_get_swizzle(arg->src[0], FALSE, write_mask, dst_swizzle);
if (src_mod == WINED3DSPSM_DZ) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t div_param;
wined3d: Use unsigned int instead of size_t for the glsl mask size.
2008-01-07 17:17:27 +01:00
unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_2, &div_param);
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
if (mask_size > 1) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(buffer, "gl_TexCoord[%u]%s / vec%d(%s));\n", reg, dst_swizzle, mask_size, div_param.param_str);
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
} else {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(buffer, "gl_TexCoord[%u]%s / %s);\n", reg, dst_swizzle, div_param.param_str);
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
}
} else if (src_mod == WINED3DSPSM_DW) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t div_param;
wined3d: Use unsigned int instead of size_t for the glsl mask size.
2008-01-07 17:17:27 +01:00
unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_3, &div_param);
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
if (mask_size > 1) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(buffer, "gl_TexCoord[%u]%s / vec%d(%s));\n", reg, dst_swizzle, mask_size, div_param.param_str);
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
} else {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(buffer, "gl_TexCoord[%u]%s / %s);\n", reg, dst_swizzle, div_param.param_str);
wined3d: Fix pshader_glsl_tex() and pshader_glsl_texcoord().
2007-01-15 19:36:40 +01:00
}
} else {
shader_addline(buffer, "gl_TexCoord[%u]%s);\n", reg, dst_swizzle);
}
}
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_TEXDP3TEX instruction in GLSL:
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
* Take a 3-component dot product of the TexCoord[dstreg] and src,
* then perform a 1D texture lookup from stage dstregnum, place into dst. */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_texdp3tex(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texdp3tex().
2007-01-15 19:34:18 +01:00
char dst_mask[6];
wined3d: Fix texdp3tex in glsl.
2007-09-13 12:25:29 +02:00
glsl_sample_function_t sample_function;
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texdp3tex().
2007-01-15 19:34:18 +01:00
DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
wined3d: Fix texdp3tex in glsl.
2007-09-13 12:25:29 +02:00
DWORD sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texdp3tex().
2007-01-15 19:34:18 +01:00
shader_glsl_append_dst(arg->buffer, arg);
shader_glsl_get_write_mask(arg->dst, dst_mask);
wined3d: Fix texdp3tex in glsl.
2007-09-13 12:25:29 +02:00
/* Do I have to take care about the projected bit? I don't think so, since the dp3 returns only one
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
* scalar, and projected sampling would require 4.
*
* It is a dependent read - not valid with conditional NP2 textures
wined3d: Fix texdp3tex in glsl.
2007-09-13 12:25:29 +02:00
*/
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
shader_glsl_get_sample_function(sampler_type, FALSE, FALSE, &sample_function);
wined3d: Fix texdp3tex in glsl.
2007-09-13 12:25:29 +02:00
switch(count_bits(sample_function.coord_mask)) {
case 1:
shader_addline(arg->buffer, "%s(Psampler%u, dot(gl_TexCoord[%u].xyz, %s))%s);\n",
sample_function.name, sampler_idx, sampler_idx, src0_param.param_str, dst_mask);
break;
case 2:
shader_addline(arg->buffer, "%s(Psampler%u, vec2(dot(gl_TexCoord[%u].xyz, %s), 0.0))%s);\n",
sample_function.name, sampler_idx, sampler_idx, src0_param.param_str, dst_mask);
break;
case 3:
shader_addline(arg->buffer, "%s(Psampler%u, vec3(dot(gl_TexCoord[%u].xyz, %s), 0.0, 0.0))%s);\n",
sample_function.name, sampler_idx, sampler_idx, src0_param.param_str, dst_mask);
break;
default:
FIXME("Unexpected mask bitcount %d\n", count_bits(sample_function.coord_mask));
}
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_TEXDP3 instruction in GLSL:
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
* Take a 3-component dot product of the TexCoord[dstreg] and src. */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_texdp3(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
wined3d: Move D3DSP_REG structures into the WINED3D namespace.
2006-10-10 01:47:12 +02:00
DWORD dstreg = arg->dst & WINED3DSP_REGNUM_MASK;
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texdp3().
2007-01-15 19:34:25 +01:00
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
DWORD dst_mask;
wined3d: Use unsigned int instead of size_t for the glsl mask size.
2008-01-07 17:17:27 +01:00
unsigned int mask_size;
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texdp3().
2007-01-15 19:34:25 +01:00
dst_mask = shader_glsl_append_dst(arg->buffer, arg);
mask_size = shader_glsl_get_write_mask_size(dst_mask);
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texdp3().
2007-01-15 19:34:25 +01:00
if (mask_size > 1) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(arg->buffer, "vec%d(dot(T%u.xyz, %s)));\n", mask_size, dstreg, src0_param.param_str);
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texdp3().
2007-01-15 19:34:25 +01:00
} else {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(arg->buffer, "dot(T%u.xyz, %s));\n", dstreg, src0_param.param_str);
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texdp3().
2007-01-15 19:34:25 +01:00
}
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_TEXDEPTH instruction in GLSL:
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
* Calculate the depth as dst.x / dst.y */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_texdepth(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_dst_param_t type, pass it to shader_glsl_add_dst_param() instead of three separate character arrays.
2007-01-15 19:36:58 +01:00
glsl_dst_param_t dst_param;
shader_glsl_add_dst_param(arg, arg->dst, 0, &dst_param);
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
wined3d: Fix texdepth instruction.
2007-08-31 17:00:16 +02:00
/* Tests show that texdepth never returns anything below 0.0, and that r5.y is clamped to 1.0.
* Negative input is accepted, -0.25 / -0.5 returns 0.5. GL should clamp gl_FragDepth to [0;1], but
Assorted spelling fixes.
2007-09-27 18:57:51 +02:00
* this doesn't always work, so clamp the results manually. Whether or not the x value is clamped at 1
* too is irrelevant, since if x = 0, any y value < 1.0 (and > 1.0 is not allowed) results in a result
wined3d: Fix texdepth instruction.
2007-08-31 17:00:16 +02:00
* >= 1.0 or < 0.0
*/
wined3d: Add printf format checking to the shader_addline function and fix resulting warnings.
2007-11-28 12:55:11 +01:00
shader_addline(arg->buffer, "gl_FragDepth = clamp((%s.x / min(%s.y, 1.0)), 0.0, 1.0);\n", dst_param.reg_name, dst_param.reg_name);
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_TEXM3X2DEPTH instruction in GLSL:
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
* Last row of a 3x2 matrix multiply, use the result to calculate the depth:
* Calculate tmp0.y = TexCoord[dstreg] . src.xyz; (tmp0.x has already been calculated)
* depth = (tmp0.y == 0.0) ? 1.0 : tmp0.x / tmp0.y
*/
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_texm3x2depth(SHADER_OPCODE_ARG* arg) {
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x2depth().
2007-01-15 19:34:33 +01:00
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
wined3d: Move D3DSP_REG structures into the WINED3D namespace.
2006-10-10 01:47:12 +02:00
DWORD dstreg = arg->dst & WINED3DSP_REGNUM_MASK;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(arg->buffer, "tmp0.y = dot(T%u.xyz, %s);\n", dstreg, src0_param.param_str);
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x2depth().
2007-01-15 19:34:33 +01:00
shader_addline(arg->buffer, "gl_FragDepth = (tmp0.y == 0.0) ? 1.0 : clamp(tmp0.x / tmp0.y, 0.0, 1.0);\n");
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_TEXM3X2PAD instruction in GLSL
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
* Calculate the 1st of a 2-row matrix multiplication. */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_texm3x2pad(SHADER_OPCODE_ARG* arg) {
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x2pad().
2007-01-15 19:34:58 +01:00
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
wined3d: Move D3DSP_REG structures into the WINED3D namespace.
2006-10-10 01:47:12 +02:00
DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
SHADER_BUFFER* buffer = arg->buffer;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
shader_addline(buffer, "tmp0.x = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
}
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_TEXM3X3PAD instruction in GLSL
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
* Calculate the 1st or 2nd row of a 3-row matrix multiplication. */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_texm3x3pad(SHADER_OPCODE_ARG* arg) {
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
IWineD3DPixelShaderImpl* shader = (IWineD3DPixelShaderImpl*) arg->shader;
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3pad().
2007-01-15 19:35:06 +01:00
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
wined3d: Move D3DSP_REG structures into the WINED3D namespace.
2006-10-10 01:47:12 +02:00
DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
SHADER_BUFFER* buffer = arg->buffer;
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
shader_addline(buffer, "tmp0.%c = dot(T%u.xyz, %s);\n", 'x' + current_state->current_row, reg, src0_param.param_str);
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
current_state->texcoord_w[current_state->current_row++] = reg;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_texm3x2tex(SHADER_OPCODE_ARG* arg) {
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x2tex().
2007-01-15 19:35:14 +01:00
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
wined3d: Move D3DSP_REG structures into the WINED3D namespace.
2006-10-10 01:47:12 +02:00
DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
SHADER_BUFFER* buffer = arg->buffer;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x2tex().
2007-01-15 19:35:14 +01:00
char dst_mask[6];
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
shader_addline(buffer, "tmp0.y = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x2tex().
2007-01-15 19:35:14 +01:00
shader_glsl_append_dst(buffer, arg);
shader_glsl_get_write_mask(arg->dst, dst_mask);
wined3d: Use the texture sampling function in a few more instructions (GLSL).
2006-11-27 20:51:01 +01:00
/* Sample the texture using the calculated coordinates */
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x2tex().
2007-01-15 19:35:14 +01:00
shader_addline(buffer, "texture2D(Psampler%u, tmp0.xy)%s);\n", reg, dst_mask);
wined3d: Add the bulk of the GLSL string generation functions. - Add a new file glsl_shader.c which contains almost every GLSL specific function we'll need - Move print_glsl_info() into glsl_shader.c - Move the shader_reg_maps struct info into the private header, and make it part of SHADER_OPCODE_ARG. - Create a new shared ps/vs register map for float constants (future patch will make ARB programs use this, too)
2006-06-09 09:33:01 +02:00
}
wined3d: Add support for shader model 3.0 I/O registers. SM 3.0 can pack multiple "semantics" into 12 generic input/output registers. To support that, define temporaries called IN and OUT, and use those as the output registers. At the end of the vshader, unpack the OUT temps into the proper GL variables. At the beginning of the pshader, pack the GL variables back into 12 IN registers.
2006-06-12 08:57:07 +02:00
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_TEXM3X3TEX instruction in GLSL
wined3d: Fix the texm3x3tex instruction to sample properly.
2006-11-27 20:50:51 +01:00
* Perform the 3rd row of a 3x3 matrix multiply, then sample the texture using the calculated coordinates */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_texm3x3tex(SHADER_OPCODE_ARG* arg) {
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3tex(). Use shader_glsl_get_sample_function().
2007-01-15 19:35:22 +01:00
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3tex(). Use shader_glsl_get_sample_function().
2007-01-15 19:35:22 +01:00
char dst_mask[6];
wined3d: Move D3DSP_REG structures into the WINED3D namespace.
2006-10-10 01:47:12 +02:00
DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3tex(). Use shader_glsl_get_sample_function().
2007-01-15 19:35:22 +01:00
DWORD sampler_type = arg->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
glsl_sample_function_t sample_function;
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
shader_addline(arg->buffer, "tmp0.z = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3tex(). Use shader_glsl_get_sample_function().
2007-01-15 19:35:22 +01:00
shader_glsl_append_dst(arg->buffer, arg);
shader_glsl_get_write_mask(arg->dst, dst_mask);
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
/* Dependent read, not valid with conditional NP2 */
shader_glsl_get_sample_function(sampler_type, FALSE, FALSE, &sample_function);
wined3d: Fix the texm3x3tex instruction to sample properly.
2006-11-27 20:50:51 +01:00
/* Sample the texture using the calculated coordinates */
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3tex(). Use shader_glsl_get_sample_function().
2007-01-15 19:35:22 +01:00
shader_addline(arg->buffer, "%s(Psampler%u, tmp0.xyz)%s);\n", sample_function.name, reg, dst_mask);
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
current_state->current_row = 0;
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_TEXM3X3 instruction in GLSL
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
* Perform the 3rd row of a 3x3 matrix multiply */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_texm3x3(SHADER_OPCODE_ARG* arg) {
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3().
2007-01-15 19:35:28 +01:00
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3().
2007-01-15 19:35:28 +01:00
char dst_mask[6];
wined3d: Move D3DSP_REG structures into the WINED3D namespace.
2006-10-10 01:47:12 +02:00
DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
SHADER_PARSE_STATE* current_state = &This->baseShader.parse_state;
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3().
2007-01-15 19:35:28 +01:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3().
2007-01-15 19:35:28 +01:00
shader_glsl_append_dst(arg->buffer, arg);
shader_glsl_get_write_mask(arg->dst, dst_mask);
wined3d: The temp vars are tmp0 and tmp1.
2007-08-28 11:54:44 +02:00
shader_addline(arg->buffer, "vec4(tmp0.xy, dot(T%u.xyz, %s), 1.0)%s);\n", reg, src0_param.param_str, dst_mask);
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3().
2007-01-15 19:35:28 +01:00
wined3d: More shader fixes / new instructions. - Replace gl_FragColor with gl_FragData[0] for GLSL pixel shader output. - Subtract 1 more constant from total GLSL allowed float constants to accommodate the PROJECTION matrix row that we reference.
2006-07-28 10:14:14 +02:00
current_state->current_row = 0;
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_TEXM3X3SPEC instruction in GLSL
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
* Peform the final texture lookup based on the previous 2 3x3 matrix multiplies */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_texm3x3spec(SHADER_OPCODE_ARG* arg) {
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
IWineD3DPixelShaderImpl* shader = (IWineD3DPixelShaderImpl*) arg->shader;
wined3d: Move D3DSP_REG structures into the WINED3D namespace.
2006-10-10 01:47:12 +02:00
DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3spec(). Use shader_glsl_get_sample_function().
2007-01-15 19:35:36 +01:00
char dst_mask[6];
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
SHADER_BUFFER* buffer = arg->buffer;
SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
wined3d: Declare a 1D sampler for TEXDP3TEX (GLSL).
2006-07-28 21:34:39 +02:00
DWORD stype = arg->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3spec(). Use shader_glsl_get_sample_function().
2007-01-15 19:35:36 +01:00
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
glsl_sample_function_t sample_function;
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], src_mask, &src1_param);
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
/* Perform the last matrix multiply operation */
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(buffer, "tmp0.z = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
wined3d: texm3x3(v)spec normalizes the normal vector.
2007-09-12 23:46:47 +02:00
/* Reflection calculation */
shader_addline(buffer, "tmp0.xyz = -reflect((%s), normalize(tmp0.xyz));\n", src1_param.param_str);
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3spec(). Use shader_glsl_get_sample_function().
2007-01-15 19:35:36 +01:00
shader_glsl_append_dst(buffer, arg);
shader_glsl_get_write_mask(arg->dst, dst_mask);
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
/* Dependent read, not valid with conditional NP2 */
shader_glsl_get_sample_function(stype, FALSE, FALSE, &sample_function);
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
/* Sample the texture */
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3spec(). Use shader_glsl_get_sample_function().
2007-01-15 19:35:36 +01:00
shader_addline(buffer, "%s(Psampler%u, tmp0.xyz)%s);\n", sample_function.name, reg, dst_mask);
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
current_state->current_row = 0;
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_TEXM3X3VSPEC instruction in GLSL
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
* Peform the final texture lookup based on the previous 2 3x3 matrix multiplies */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_texm3x3vspec(SHADER_OPCODE_ARG* arg) {
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
IWineD3DPixelShaderImpl* shader = (IWineD3DPixelShaderImpl*) arg->shader;
wined3d: Move D3DSP_REG structures into the WINED3D namespace.
2006-10-10 01:47:12 +02:00
DWORD reg = arg->dst & WINED3DSP_REGNUM_MASK;
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
SHADER_BUFFER* buffer = arg->buffer;
SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
char dst_mask[6];
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3vspec(). Use shader_glsl_get_sample_function(). Use the GLSL builtin reflect() function.
2007-01-15 19:35:48 +01:00
DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
DWORD sampler_type = arg->reg_maps->samplers[reg] & WINED3DSP_TEXTURETYPE_MASK;
glsl_sample_function_t sample_function;
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], src_mask, &src0_param);
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
/* Perform the last matrix multiply operation */
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(buffer, "tmp0.z = dot(vec3(T%u), vec3(%s));\n", reg, src0_param.param_str);
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
/* Construct the eye-ray vector from w coordinates */
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3vspec(). Use shader_glsl_get_sample_function(). Use the GLSL builtin reflect() function.
2007-01-15 19:35:48 +01:00
shader_addline(buffer, "tmp1.xyz = normalize(vec3(gl_TexCoord[%u].w, gl_TexCoord[%u].w, gl_TexCoord[%u].w));\n",
current_state->texcoord_w[0], current_state->texcoord_w[1], reg);
wined3d: texm3x3(v)spec normalizes the normal vector.
2007-09-12 23:46:47 +02:00
shader_addline(buffer, "tmp0.xyz = -reflect(tmp1.xyz, normalize(tmp0.xyz));\n");
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3vspec(). Use shader_glsl_get_sample_function(). Use the GLSL builtin reflect() function.
2007-01-15 19:35:48 +01:00
shader_glsl_append_dst(buffer, arg);
shader_glsl_get_write_mask(arg->dst, dst_mask);
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
/* Dependent read, not valid with conditional NP2 */
shader_glsl_get_sample_function(sampler_type, FALSE, FALSE, &sample_function);
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
wined3d: Use the texture sampling function in a few more instructions (GLSL).
2006-11-27 20:51:01 +01:00
/* Sample the texture using the calculated coordinates */
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texm3x3vspec(). Use shader_glsl_get_sample_function(). Use the GLSL builtin reflect() function.
2007-01-15 19:35:48 +01:00
shader_addline(buffer, "%s(Psampler%u, tmp0.xyz)%s);\n", sample_function.name, reg, dst_mask);
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
current_state->current_row = 0;
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_TEXBEM instruction in GLSL.
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
* Apply a fake bump map transform.
wined3d: Implement texbem in arb, improve it in glsl.
2007-02-15 03:00:57 +01:00
* texbem is pshader <= 1.3 only, this saves a few version checks
*/
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_texbem(SHADER_OPCODE_ARG* arg) {
wined3d: Implement texbem in arb, improve it in glsl.
2007-02-15 03:00:57 +01:00
IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
char dst_swizzle[6];
glsl_sample_function_t sample_function;
wined3d: Implemented bump map transform for texbem in GLSL with native signed textures.
2007-03-22 17:42:03 +01:00
glsl_src_param_t coord_param;
wined3d: Implement texbem in arb, improve it in glsl.
2007-02-15 03:00:57 +01:00
DWORD sampler_type;
DWORD sampler_idx;
wined3d: Fix glsl texbem instruction for projective textures.
2007-03-22 17:42:41 +01:00
DWORD mask;
wined3d: Implement texbem in arb, improve it in glsl.
2007-02-15 03:00:57 +01:00
DWORD flags;
char coord_mask[6];
sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
flags = deviceImpl->stateBlock->textureState[sampler_idx][WINED3DTSS_TEXTURETRANSFORMFLAGS];
wined3d: Fix glsl texbem instruction for projective textures.
2007-03-22 17:42:41 +01:00
sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
/* Dependent read, not valid with conditional NP2 */
shader_glsl_get_sample_function(sampler_type, FALSE, FALSE, &sample_function);
wined3d: Fix glsl texbem instruction for projective textures.
2007-03-22 17:42:41 +01:00
mask = sample_function.coord_mask;
shader_glsl_get_write_mask(arg->dst, dst_swizzle);
shader_glsl_get_write_mask(mask, coord_mask);
/* with projective textures, texbem only divides the static texture coord, not the displacement,
* so we can't let the GL handle this.
*/
wined3d: Implement texbem in arb, improve it in glsl.
2007-02-15 03:00:57 +01:00
if (flags & WINED3DTTFF_PROJECTED) {
wined3d: Fix glsl texbem instruction for projective textures.
2007-03-22 17:42:41 +01:00
DWORD div_mask=0;
char coord_div_mask[3];
wined3d: Implement texbem in arb, improve it in glsl.
2007-02-15 03:00:57 +01:00
switch (flags & ~WINED3DTTFF_PROJECTED) {
case WINED3DTTFF_COUNT1: FIXME("WINED3DTTFF_PROJECTED with WINED3DTTFF_COUNT1?\n"); break;
wined3d: Fix glsl texbem instruction for projective textures.
2007-03-22 17:42:41 +01:00
case WINED3DTTFF_COUNT2: div_mask = WINED3DSP_WRITEMASK_1; break;
case WINED3DTTFF_COUNT3: div_mask = WINED3DSP_WRITEMASK_2; break;
wined3d: Implement texbem in arb, improve it in glsl.
2007-02-15 03:00:57 +01:00
case WINED3DTTFF_COUNT4:
wined3d: Fix glsl texbem instruction for projective textures.
2007-03-22 17:42:41 +01:00
case WINED3DTTFF_DISABLE: div_mask = WINED3DSP_WRITEMASK_3; break;
wined3d: Implement texbem in arb, improve it in glsl.
2007-02-15 03:00:57 +01:00
}
wined3d: Fix glsl texbem instruction for projective textures.
2007-03-22 17:42:41 +01:00
shader_glsl_get_write_mask(div_mask, coord_div_mask);
shader_addline(arg->buffer, "T%u%s /= T%u%s;\n", sampler_idx, coord_mask, sampler_idx, coord_div_mask);
wined3d: Implement texbem in arb, improve it in glsl.
2007-02-15 03:00:57 +01:00
}
wined3d: Fix glsl texbem instruction for projective textures.
2007-03-22 17:42:41 +01:00
shader_glsl_append_dst(arg->buffer, arg);
wined3d: Implemented bump map transform for texbem in GLSL with native signed textures.
2007-03-22 17:42:03 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0|WINED3DSP_WRITEMASK_1, &coord_param);
wined3d: Implement texbeml.
2007-09-01 20:11:17 +02:00
if(arg->opcode->opcode == WINED3DSIO_TEXBEML) {
glsl_src_param_t luminance_param;
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_2, &luminance_param);
wined3d: Support more than one texbem instruction per shader.
2008-03-05 03:18:55 +01:00
shader_addline(arg->buffer, "(%s(Psampler%u, T%u%s + vec4(bumpenvmat%d * %s, 0.0, 0.0)%s )*(%s * luminancescale%d + luminanceoffset%d))%s);\n",
sample_function.name, sampler_idx, sampler_idx, coord_mask, sampler_idx, coord_param.param_str, coord_mask,
luminance_param.param_str, sampler_idx, sampler_idx, dst_swizzle);
wined3d: Implement texbeml.
2007-09-01 20:11:17 +02:00
} else {
wined3d: Support more than one texbem instruction per shader.
2008-03-05 03:18:55 +01:00
shader_addline(arg->buffer, "%s(Psampler%u, T%u%s + vec4(bumpenvmat%d * %s, 0.0, 0.0)%s )%s);\n",
sample_function.name, sampler_idx, sampler_idx, coord_mask, sampler_idx, coord_param.param_str, coord_mask, dst_swizzle);
wined3d: Implement texbeml.
2007-09-01 20:11:17 +02:00
}
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
}
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_bem(SHADER_OPCODE_ARG* arg) {
wined3d: Implement bem shader instruction.
2007-03-26 23:34:32 +02:00
glsl_src_param_t src0_param, src1_param;
wined3d: Support more than one texbem instruction per shader.
2008-03-05 03:18:55 +01:00
DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
wined3d: Implement bem shader instruction.
2007-03-26 23:34:32 +02:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0|WINED3DSP_WRITEMASK_1, &src0_param);
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0|WINED3DSP_WRITEMASK_1, &src1_param);
shader_glsl_append_dst(arg->buffer, arg);
wined3d: Support more than one texbem instruction per shader.
2008-03-05 03:18:55 +01:00
shader_addline(arg->buffer, "%s + bumpenvmat%d * %s);\n",
src0_param.param_str, sampler_idx, src1_param.param_str);
wined3d: Implement bem shader instruction.
2007-03-26 23:34:32 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_TEXREG2AR instruction in GLSL
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
* Sample 2D texture at dst using the alpha & red (wx) components of src as texture coordinates */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_texreg2ar(SHADER_OPCODE_ARG* arg) {
wined3d: Add signed format conversion for glsl.
2007-09-21 23:34:09 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texreg2ar. Use the correct source swizzle.
2007-01-15 19:33:24 +01:00
DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
char dst_mask[6];
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texreg2ar. Use the correct source swizzle.
2007-01-15 19:33:24 +01:00
shader_glsl_append_dst(arg->buffer, arg);
shader_glsl_get_write_mask(arg->dst, dst_mask);
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(arg->buffer, "texture2D(Psampler%u, %s.wx)%s);\n", sampler_idx, src0_param.reg_name, dst_mask);
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_TEXREG2GB instruction in GLSL
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
* Sample 2D texture at dst using the green & blue (yz) components of src as texture coordinates */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_texreg2gb(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texreg2gb().
2007-01-15 19:33:32 +01:00
DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
char dst_mask[6];
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
wined3d: Pass the correct mask to shader_glsl_add_src_param() in pshader_glsl_texreg2gb().
2007-01-15 19:33:32 +01:00
shader_glsl_append_dst(arg->buffer, arg);
shader_glsl_get_write_mask(arg->dst, dst_mask);
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(arg->buffer, "texture2D(Psampler%u, %s.yz)%s);\n", sampler_idx, src0_param.reg_name, dst_mask);
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_TEXREG2RGB instruction in GLSL
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
* Sample texture at dst using the rgb (xyz) components of src as texture coordinates */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_texreg2rgb(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
wined3d: Rewrite pshader_glsl_texreg2rgb to properly take the write mask into account. Use shader_glsl_get_sample_function() rather than having the instruction handler figure it out itself. Get rid of shader_glsl_add_dst_old().
2007-01-15 19:33:44 +01:00
char dst_mask[6];
DWORD sampler_idx = arg->dst & WINED3DSP_REGNUM_MASK;
DWORD sampler_type = arg->reg_maps->samplers[sampler_idx] & WINED3DSP_TEXTURETYPE_MASK;
glsl_sample_function_t sample_function;
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
wined3d: Rewrite pshader_glsl_texreg2rgb to properly take the write mask into account. Use shader_glsl_get_sample_function() rather than having the instruction handler figure it out itself. Get rid of shader_glsl_add_dst_old().
2007-01-15 19:33:44 +01:00
shader_glsl_append_dst(arg->buffer, arg);
shader_glsl_get_write_mask(arg->dst, dst_mask);
wined3d: Make the code aware of GL_ARB_texture_rectangle.
2007-11-27 22:25:07 +01:00
/* Dependent read, not valid with conditional NP2 */
shader_glsl_get_sample_function(sampler_type, FALSE, FALSE, &sample_function);
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], sample_function.coord_mask, &src0_param);
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_addline(arg->buffer, "%s(Psampler%u, %s)%s);\n", sample_function.name, sampler_idx, src0_param.param_str, dst_mask);
wined3d: Implement more GLSL instructions. Implement D3DSIO_TEXREG2AR, TEXREG2GB, TEXREG2RGB, TEXM3X3TEX, TEXM3X3SPEC.
2006-07-25 04:52:38 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_TEXKILL instruction in GLSL.
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
* If any of the first 3 components are < 0, discard this pixel */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_texkill(SHADER_OPCODE_ARG* arg) {
wined3d: texkill ignores the .w only in ps 1.x.
2007-08-30 23:35:50 +02:00
IWineD3DPixelShaderImpl* This = (IWineD3DPixelShaderImpl*) arg->shader;
DWORD hex_version = This->baseShader.hex_version;
wined3d: Add a glsl_dst_param_t type, pass it to shader_glsl_add_dst_param() instead of three separate character arrays.
2007-01-15 19:36:58 +01:00
glsl_dst_param_t dst_param;
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
wined3d: texkill ignores the .w only in ps 1.x.
2007-08-30 23:35:50 +02:00
/* The argument is a destination parameter, and no writemasks are allowed */
wined3d: Add a glsl_dst_param_t type, pass it to shader_glsl_add_dst_param() instead of three separate character arrays.
2007-01-15 19:36:58 +01:00
shader_glsl_add_dst_param(arg, arg->dst, 0, &dst_param);
wined3d: texkill ignores the .w only in ps 1.x.
2007-08-30 23:35:50 +02:00
if((hex_version >= WINED3DPS_VERSION(2,0))) {
/* 2.0 shaders compare all 4 components in texkill */
shader_addline(arg->buffer, "if (any(lessThan(%s.xyzw, vec4(0.0)))) discard;\n", dst_param.reg_name);
} else {
Assorted spelling fixes.
2007-11-09 12:37:53 +01:00
/* 1.X shaders only compare the first 3 components, probably due to the nature of the texkill
wined3d: texkill ignores the .w only in ps 1.x.
2007-08-30 23:35:50 +02:00
* instruction as a tex* instruction, and phase, which kills all a / w components. Even if all
* 4 components are defined, only the first 3 are used
*/
shader_addline(arg->buffer, "if (any(lessThan(%s.xyz, vec3(0.0)))) discard;\n", dst_param.reg_name);
}
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
}
wined3d: Move D3DSIO structure into WINED3D namespace.
2006-10-10 01:45:12 +02:00
/** Process the WINED3DSIO_DP2ADD instruction in GLSL.
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
* dst = dot2(src0, src1) + src2 */
wined3d: Make some more GLSL functions private to the backend.
2008-09-23 17:39:34 +02:00
static void pshader_glsl_dp2add(SHADER_OPCODE_ARG* arg) {
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
glsl_src_param_t src0_param;
glsl_src_param_t src1_param;
glsl_src_param_t src2_param;
wined3d: Rewrite pshader_glsl_dp2add() to properly take the write mask into account.
2007-01-15 19:32:20 +01:00
DWORD write_mask;
wined3d: Use unsigned int instead of size_t for the glsl mask size.
2008-01-07 17:17:27 +01:00
unsigned int mask_size;
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
wined3d: Rewrite pshader_glsl_dp2add() to properly take the write mask into account.
2007-01-15 19:32:20 +01:00
write_mask = shader_glsl_append_dst(arg->buffer, arg);
mask_size = shader_glsl_get_write_mask_size(write_mask);
wined3d: Add a glsl_src_param_t type, pass it to shader_glsl_add_src_param() instead of three separate character arrays.
2007-01-15 19:37:04 +01:00
shader_glsl_add_src_param(arg, arg->src[0], arg->src_addr[0], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src0_param);
shader_glsl_add_src_param(arg, arg->src[1], arg->src_addr[1], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src1_param);
shader_glsl_add_src_param(arg, arg->src[2], arg->src_addr[2], WINED3DSP_WRITEMASK_0, &src2_param);
wined3d: Rewrite pshader_glsl_dp2add() to properly take the write mask into account.
2007-01-15 19:32:20 +01:00
wined3d: Fix DP2ADD in GLSL. DP2ADD returns a scalar, and fglrx (correctly) complains that it can't assign that to a 3 component vector.
2008-04-23 22:18:32 +02:00
if (mask_size > 1) {
shader_addline(arg->buffer, "vec%d(dot(%s, %s) + %s));\n", mask_size, src0_param.param_str, src1_param.param_str, src2_param.param_str);
} else {
shader_addline(arg->buffer, "dot(%s, %s) + %s);\n", src0_param.param_str, src1_param.param_str, src2_param.param_str);
}
wined3d: Implement more GLSL instructions and a little cleanup. - Implement D3DSIO_DP2ADD, D3DSIO_TEXKILL, D3DSIO_TEXM3X3PAD - Partially implement D3DSIO_TEXBEM, D3DSIO_TEXM3X3VSPEC (as much as they are implemented in ARB_fragment_program at least). - Stop copying the SHADER_PARSE_STATE struct in each ARB shader routine - use a pointer instead.
2006-06-27 08:00:02 +02:00
}
wined3d: Make some GLSL structs and functions private to the backend.
2008-09-16 14:55:39 +02:00
static void pshader_glsl_input_pack(
wined3d: Add support for shader model 3.0 I/O registers. SM 3.0 can pack multiple "semantics" into 12 generic input/output registers. To support that, define temporaries called IN and OUT, and use those as the output registers. At the end of the vshader, unpack the OUT temps into the proper GL variables. At the beginning of the pshader, pack the GL variables back into 12 IN registers.
2006-06-12 08:57:07 +02:00
SHADER_BUFFER* buffer,
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
semantic* semantics_in,
IWineD3DPixelShader *iface) {
wined3d: Add support for shader model 3.0 I/O registers. SM 3.0 can pack multiple "semantics" into 12 generic input/output registers. To support that, define temporaries called IN and OUT, and use those as the output registers. At the end of the vshader, unpack the OUT temps into the proper GL variables. At the beginning of the pshader, pack the GL variables back into 12 IN registers.
2006-06-12 08:57:07 +02:00
unsigned int i;
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *) iface;
wined3d: Add support for shader model 3.0 I/O registers. SM 3.0 can pack multiple "semantics" into 12 generic input/output registers. To support that, define temporaries called IN and OUT, and use those as the output registers. At the end of the vshader, unpack the OUT temps into the proper GL variables. At the beginning of the pshader, pack the GL variables back into 12 IN registers.
2006-06-12 08:57:07 +02:00
wined3d: Reverse semantics maps for shaders.
2006-07-07 08:27:38 +02:00
for (i = 0; i < MAX_REG_INPUT; i++) {
wined3d: Add support for shader model 3.0 I/O registers. SM 3.0 can pack multiple "semantics" into 12 generic input/output registers. To support that, define temporaries called IN and OUT, and use those as the output registers. At the end of the vshader, unpack the OUT temps into the proper GL variables. At the beginning of the pshader, pack the GL variables back into 12 IN registers.
2006-06-12 08:57:07 +02:00
wined3d: Reverse semantics maps for shaders.
2006-07-07 08:27:38 +02:00
DWORD usage_token = semantics_in[i].usage;
DWORD register_token = semantics_in[i].reg;
DWORD usage, usage_idx;
wined3d: Add support for shader model 3.0 I/O registers. SM 3.0 can pack multiple "semantics" into 12 generic input/output registers. To support that, define temporaries called IN and OUT, and use those as the output registers. At the end of the vshader, unpack the OUT temps into the proper GL variables. At the beginning of the pshader, pack the GL variables back into 12 IN registers.
2006-06-12 08:57:07 +02:00
char reg_mask[6];
/* Uninitialized */
wined3d: Reverse semantics maps for shaders.
2006-07-07 08:27:38 +02:00
if (!usage_token) continue;
wined3d: Move D3DSP DCL-related structures into WINED3D namespace.
2006-10-10 01:46:35 +02:00
usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
wined3d: Cleanup shader_glsl_get_output_register_swizzle().
2006-12-29 15:31:26 +01:00
shader_glsl_get_write_mask(register_token, reg_mask);
wined3d: Reverse semantics maps for shaders.
2006-07-07 08:27:38 +02:00
switch(usage) {
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
case WINED3DDECLUSAGE_TEXCOORD:
if(usage_idx < 8 && This->vertexprocessing == pretransformed) {
shader_addline(buffer, "IN[%u]%s = gl_TexCoord[%u]%s;\n",
wined3d: Install a varying map.
2007-10-28 00:12:37 +02:00
This->input_reg_map[i], reg_mask, usage_idx, reg_mask);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
} else {
shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
wined3d: Install a varying map.
2007-10-28 00:12:37 +02:00
This->input_reg_map[i], reg_mask, reg_mask);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
}
break;
wined3d: Add WINED3DDECLUSAGE, use it.
2007-02-13 23:12:14 +01:00
case WINED3DDECLUSAGE_COLOR:
wined3d: Reverse semantics maps for shaders.
2006-07-07 08:27:38 +02:00
if (usage_idx == 0)
wined3d: Make pixel shader input an array.
2007-10-18 14:45:32 +02:00
shader_addline(buffer, "IN[%u]%s = vec4(gl_Color)%s;\n",
wined3d: Install a varying map.
2007-10-28 00:12:37 +02:00
This->input_reg_map[i], reg_mask, reg_mask);
wined3d: Fix typo breaking 3.0 pshaders color input.
2006-07-07 19:01:27 +02:00
else if (usage_idx == 1)
wined3d: Make pixel shader input an array.
2007-10-18 14:45:32 +02:00
shader_addline(buffer, "IN[%u]%s = vec4(gl_SecondaryColor)%s;\n",
wined3d: Install a varying map.
2007-10-28 00:12:37 +02:00
This->input_reg_map[i], reg_mask, reg_mask);
wined3d: Reverse semantics maps for shaders.
2006-07-07 08:27:38 +02:00
else
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
wined3d: Install a varying map.
2007-10-28 00:12:37 +02:00
This->input_reg_map[i], reg_mask, reg_mask);
wined3d: Add support for shader model 3.0 I/O registers. SM 3.0 can pack multiple "semantics" into 12 generic input/output registers. To support that, define temporaries called IN and OUT, and use those as the output registers. At the end of the vshader, unpack the OUT temps into the proper GL variables. At the beginning of the pshader, pack the GL variables back into 12 IN registers.
2006-06-12 08:57:07 +02:00
break;
default:
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
wined3d: Install a varying map.
2007-10-28 00:12:37 +02:00
This->input_reg_map[i], reg_mask, reg_mask);
wined3d: Add support for shader model 3.0 I/O registers. SM 3.0 can pack multiple "semantics" into 12 generic input/output registers. To support that, define temporaries called IN and OUT, and use those as the output registers. At the end of the vshader, unpack the OUT temps into the proper GL variables. At the beginning of the pshader, pack the GL variables back into 12 IN registers.
2006-06-12 08:57:07 +02:00
}
}
}
/*********************************************
* Vertex Shader Specific Code begins here
********************************************/
wined3d: Store the glsl program lookup table in the backend's private data.
2008-07-08 21:44:20 +02:00
static void add_glsl_program_entry(struct shader_glsl_priv *priv, struct glsl_shader_prog_link *entry) {
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
glsl_program_key_t *key;
key = HeapAlloc(GetProcessHeap(), 0, sizeof(glsl_program_key_t));
key->vshader = entry->vshader;
key->pshader = entry->pshader;
wined3d: Store the glsl program lookup table in the backend's private data.
2008-07-08 21:44:20 +02:00
hash_table_put(priv->glsl_program_lookup, key, entry);
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
}
wined3d: Store the glsl program lookup table in the backend's private data.
2008-07-08 21:44:20 +02:00
static struct glsl_shader_prog_link *get_glsl_program_entry(struct shader_glsl_priv *priv,
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
GLhandleARB vshader, GLhandleARB pshader) {
glsl_program_key_t key;
key.vshader = vshader;
key.pshader = pshader;
wined3d: Store the glsl program lookup table in the backend's private data.
2008-07-08 21:44:20 +02:00
return (struct glsl_shader_prog_link *)hash_table_get(priv->glsl_program_lookup, &key);
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
}
wined3d: Make some GLSL structs and functions private to the backend.
2008-09-16 14:55:39 +02:00
static void delete_glsl_program_entry(struct shader_glsl_priv *priv, WineD3D_GL_Info *gl_info, struct glsl_shader_prog_link *entry) {
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
glsl_program_key_t *key;
key = HeapAlloc(GetProcessHeap(), 0, sizeof(glsl_program_key_t));
key->vshader = entry->vshader;
key->pshader = entry->pshader;
wined3d: Store the glsl program lookup table in the backend's private data.
2008-07-08 21:44:20 +02:00
hash_table_remove(priv->glsl_program_lookup, key);
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
GL_EXTCALL(glDeleteObjectARB(entry->programId));
if (entry->vshader) list_remove(&entry->vshader_entry);
if (entry->pshader) list_remove(&entry->pshader_entry);
HeapFree(GetProcessHeap(), 0, entry->vuniformF_locations);
HeapFree(GetProcessHeap(), 0, entry->puniformF_locations);
HeapFree(GetProcessHeap(), 0, entry);
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
}
wined3d: Install a varying map.
2007-10-28 00:12:37 +02:00
static void handle_ps3_input(SHADER_BUFFER *buffer, semantic *semantics_in, semantic *semantics_out, WineD3D_GL_Info *gl_info, DWORD *map) {
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
unsigned int i, j;
DWORD usage_token, usage_token_out;
DWORD register_token, register_token_out;
DWORD usage, usage_idx, usage_out, usage_idx_out;
DWORD *set;
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
DWORD in_idx;
DWORD in_count = GL_LIMITS(glsl_varyings) / 4;
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
char reg_mask[6], reg_mask_out[6];
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
char destination[50];
set = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*set) * (in_count + 2));
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
if (!semantics_out) {
/* Save gl_FrontColor & gl_FrontSecondaryColor before overwriting them. */
wined3d: Add a trailing '\n' to a couple of shader_addline() calls.
2008-06-26 14:08:59 +02:00
shader_addline(buffer, "vec4 front_color = gl_FrontColor;\n");
shader_addline(buffer, "vec4 front_secondary_color = gl_FrontSecondaryColor;\n");
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
}
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
wined3d: Install a varying map.
2007-10-28 00:12:37 +02:00
for(i = 0; i < MAX_REG_INPUT; i++) {
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
usage_token = semantics_in[i].usage;
if (!usage_token) continue;
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
in_idx = map[i];
if (in_idx >= (in_count + 2)) {
wined3d: Install a varying map.
2007-10-28 00:12:37 +02:00
FIXME("More input varyings declared than supported, expect issues\n");
continue;
wined3d: Implement the varying map.
2007-11-06 12:34:22 +01:00
} else if(map[i] == -1) {
/* Declared, but not read register */
continue;
wined3d: Install a varying map.
2007-10-28 00:12:37 +02:00
}
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
if (in_idx == in_count) {
sprintf(destination, "gl_FrontColor");
} else if (in_idx == in_count + 1) {
sprintf(destination, "gl_FrontSecondaryColor");
} else {
sprintf(destination, "IN[%u]", in_idx);
}
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
register_token = semantics_in[i].reg;
usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
wined3d: Install a varying map.
2007-10-28 00:12:37 +02:00
set[map[i]] = shader_glsl_get_write_mask(register_token, reg_mask);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
if(!semantics_out) {
switch(usage) {
case WINED3DDECLUSAGE_COLOR:
if (usage_idx == 0)
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
shader_addline(buffer, "%s%s = front_color%s;\n",
destination, reg_mask, reg_mask);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
else if (usage_idx == 1)
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
shader_addline(buffer, "%s%s = front_secondary_color%s;\n",
destination, reg_mask, reg_mask);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
else
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
shader_addline(buffer, "%s%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
destination, reg_mask, reg_mask);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
break;
case WINED3DDECLUSAGE_TEXCOORD:
if (usage_idx < 8) {
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
shader_addline(buffer, "%s%s = gl_TexCoord[%u]%s;\n",
destination, reg_mask, usage_idx, reg_mask);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
} else {
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
shader_addline(buffer, "%s%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
destination, reg_mask, reg_mask);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
}
break;
case WINED3DDECLUSAGE_FOG:
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
shader_addline(buffer, "%s%s = vec4(gl_FogFragCoord, 0.0, 0.0, 0.0)%s;\n",
destination, reg_mask, reg_mask);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
break;
default:
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
shader_addline(buffer, "%s%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
destination, reg_mask, reg_mask);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
}
} else {
BOOL found = FALSE;
for(j = 0; j < MAX_REG_OUTPUT; j++) {
usage_token_out = semantics_out[j].usage;
if (!usage_token_out) continue;
register_token_out = semantics_out[j].reg;
usage_out = (usage_token_out & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
usage_idx_out = (usage_token_out & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
shader_glsl_get_write_mask(register_token_out, reg_mask_out);
if(usage == usage_out &&
usage_idx == usage_idx_out) {
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
shader_addline(buffer, "%s%s = OUT[%u]%s;\n",
destination, reg_mask, j, reg_mask);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
found = TRUE;
}
}
if(!found) {
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
shader_addline(buffer, "%s%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
destination, reg_mask, reg_mask);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
}
}
}
/* This is solely to make the compiler / linker happy and avoid warning about undefined
* varyings. It shouldn't result in any real code executed on the GPU, since all read
* input varyings are assigned above, if the optimizer works properly.
*/
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
for(i = 0; i < in_count + 2; i++) {
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
if(set[i] != WINED3DSP_WRITEMASK_ALL) {
unsigned int size = 0;
memset(reg_mask, 0, sizeof(reg_mask));
if(!(set[i] & WINED3DSP_WRITEMASK_0)) {
reg_mask[size] = 'x';
size++;
}
if(!(set[i] & WINED3DSP_WRITEMASK_1)) {
reg_mask[size] = 'y';
size++;
}
if(!(set[i] & WINED3DSP_WRITEMASK_2)) {
reg_mask[size] = 'z';
size++;
}
if(!(set[i] & WINED3DSP_WRITEMASK_3)) {
reg_mask[size] = 'w';
size++;
}
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
if (i == in_count) {
sprintf(destination, "gl_FrontColor");
} else if (i == in_count + 1) {
sprintf(destination, "gl_FrontSecondaryColor");
} else {
sprintf(destination, "IN[%u]", i);
}
if (size == 1) {
shader_addline(buffer, "%s.%s = 0.0;\n", destination, reg_mask);
} else {
shader_addline(buffer, "%s.%s = vec%u(0.0);\n", destination, reg_mask, size);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
}
}
}
HeapFree(GetProcessHeap(), 0, set);
}
static GLhandleARB generate_param_reorder_function(IWineD3DVertexShader *vertexshader,
IWineD3DPixelShader *pixelshader,
WineD3D_GL_Info *gl_info) {
GLhandleARB ret = 0;
IWineD3DVertexShaderImpl *vs = (IWineD3DVertexShaderImpl *) vertexshader;
IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *) pixelshader;
wined3d: Handle projected textures properly in arbfp and atifs. GL_ARB_fragment_program and GL_ATI_fragment_shader can disable projected textures properly, and they can also handle D3DTTFF_PROJECTED | D3DTTFF_COUNT3 properly.
2008-08-23 22:41:51 +02:00
IWineD3DDeviceImpl *device;
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
DWORD vs_major = vs ? WINED3DSHADER_VERSION_MAJOR(vs->baseShader.hex_version) : 0;
DWORD ps_major = ps ? WINED3DSHADER_VERSION_MAJOR(ps->baseShader.hex_version) : 0;
unsigned int i;
SHADER_BUFFER buffer;
DWORD usage_token;
DWORD register_token;
wined3d: Initialize output texcoord .w to 1.0 if needed. The GL_ARB_vertex_program extension does not define a standard value for output texture coordinates. This makes problems when using vertex shaders with fixed function fragment processing because fffp divides the texture coords by its .w component. This means that gl shaders have to write to the .w component of texture coords. Direct3D shaders however do not.
2007-12-06 22:10:11 +01:00
DWORD usage, usage_idx, writemask;
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
char reg_mask[6];
semantic *semantics_out, *semantics_in;
buffer.buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, SHADER_PGMSIZE);
buffer.bsize = 0;
buffer.lineNo = 0;
buffer.newline = TRUE;
wined3d: Specify the GLSL language version our shaders are written to. This prevents some driver warnings when using language features from 1.20, like "first class arrays".
2008-06-30 23:03:47 +02:00
shader_addline(&buffer, "#version 120\n");
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
if(vs_major < 3 && ps_major < 3) {
wined3d: Initialize output texcoord .w to 1.0 if needed. The GL_ARB_vertex_program extension does not define a standard value for output texture coordinates. This makes problems when using vertex shaders with fixed function fragment processing because fffp divides the texture coords by its .w component. This means that gl shaders have to write to the .w component of texture coords. Direct3D shaders however do not.
2007-12-06 22:10:11 +01:00
/* That one is easy: The vertex shader writes to the builtin varyings, the pixel shader reads from them.
* Take care about the texcoord .w fixup though if we're using the fixed function fragment pipeline
*/
wined3d: Handle projected textures properly in arbfp and atifs. GL_ARB_fragment_program and GL_ATI_fragment_shader can disable projected textures properly, and they can also handle D3DTTFF_PROJECTED | D3DTTFF_COUNT3 properly.
2008-08-23 22:41:51 +02:00
device = (IWineD3DDeviceImpl *) vs->baseShader.device;
if((GLINFO_LOCATION).set_texcoord_w && ps_major == 0 && vs_major > 0 &&
!device->frag_pipe->ffp_proj_control) {
wined3d: Initialize output texcoord .w to 1.0 if needed. The GL_ARB_vertex_program extension does not define a standard value for output texture coordinates. This makes problems when using vertex shaders with fixed function fragment processing because fffp divides the texture coords by its .w component. This means that gl shaders have to write to the .w component of texture coords. Direct3D shaders however do not.
2007-12-06 22:10:11 +01:00
shader_addline(&buffer, "void order_ps_input() {\n");
for(i = 0; i < min(8, MAX_REG_TEXCRD); i++) {
if(vs->baseShader.reg_maps.texcoord_mask[i] != 0 &&
vs->baseShader.reg_maps.texcoord_mask[i] != WINED3DSP_WRITEMASK_ALL) {
shader_addline(&buffer, "gl_TexCoord[%u].w = 1.0;\n", i);
}
}
shader_addline(&buffer, "}\n");
} else {
shader_addline(&buffer, "void order_ps_input() { /* do nothing */ }\n");
}
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
} else if(ps_major < 3 && vs_major >= 3) {
/* The vertex shader writes to its own varyings, the pixel shader needs them in the builtin ones */
semantics_out = vs->semantics_out;
shader_addline(&buffer, "void order_ps_input(in vec4 OUT[%u]) {\n", MAX_REG_OUTPUT);
for(i = 0; i < MAX_REG_OUTPUT; i++) {
usage_token = semantics_out[i].usage;
if (!usage_token) continue;
register_token = semantics_out[i].reg;
usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
wined3d: Initialize output texcoord .w to 1.0 if needed. The GL_ARB_vertex_program extension does not define a standard value for output texture coordinates. This makes problems when using vertex shaders with fixed function fragment processing because fffp divides the texture coords by its .w component. This means that gl shaders have to write to the .w component of texture coords. Direct3D shaders however do not.
2007-12-06 22:10:11 +01:00
writemask = shader_glsl_get_write_mask(register_token, reg_mask);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
switch(usage) {
case WINED3DDECLUSAGE_COLOR:
if (usage_idx == 0)
shader_addline(&buffer, "gl_FrontColor%s = OUT[%u]%s;\n", reg_mask, i, reg_mask);
else if (usage_idx == 1)
shader_addline(&buffer, "gl_FrontSecondaryColor%s = OUT[%u]%s;\n", reg_mask, i, reg_mask);
break;
case WINED3DDECLUSAGE_POSITION:
shader_addline(&buffer, "gl_Position%s = OUT[%u]%s;\n", reg_mask, i, reg_mask);
break;
case WINED3DDECLUSAGE_TEXCOORD:
if (usage_idx < 8) {
wined3d: Initialize output texcoord .w to 1.0 if needed. The GL_ARB_vertex_program extension does not define a standard value for output texture coordinates. This makes problems when using vertex shaders with fixed function fragment processing because fffp divides the texture coords by its .w component. This means that gl shaders have to write to the .w component of texture coords. Direct3D shaders however do not.
2007-12-06 22:10:11 +01:00
if(!(GLINFO_LOCATION).set_texcoord_w || ps_major > 0) writemask |= WINED3DSP_WRITEMASK_3;
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
shader_addline(&buffer, "gl_TexCoord[%u]%s = OUT[%u]%s;\n",
wined3d: Initialize output texcoord .w to 1.0 if needed. The GL_ARB_vertex_program extension does not define a standard value for output texture coordinates. This makes problems when using vertex shaders with fixed function fragment processing because fffp divides the texture coords by its .w component. This means that gl shaders have to write to the .w component of texture coords. Direct3D shaders however do not.
2007-12-06 22:10:11 +01:00
usage_idx, reg_mask, i, reg_mask);
if(!(writemask & WINED3DSP_WRITEMASK_3)) {
shader_addline(&buffer, "gl_TexCoord[%u].w = 1.0;\n", usage_idx);
}
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
}
break;
case WINED3DDECLUSAGE_PSIZE:
shader_addline(&buffer, "gl_PointSize = OUT[%u].x;\n", i);
break;
case WINED3DDECLUSAGE_FOG:
shader_addline(&buffer, "gl_FogFragCoord = OUT[%u].%c;\n", i, reg_mask[1]);
break;
default:
break;
}
}
shader_addline(&buffer, "}\n");
} else if(ps_major >= 3 && vs_major >= 3) {
semantics_out = vs->semantics_out;
semantics_in = ps->semantics_in;
/* This one is tricky: a 3.0 pixel shader reads from a 3.0 vertex shader */
wined3d: Add printf format checking to the shader_addline function and fix resulting warnings.
2007-11-28 12:55:11 +01:00
shader_addline(&buffer, "varying vec4 IN[%u];\n", GL_LIMITS(glsl_varyings) / 4);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
shader_addline(&buffer, "void order_ps_input(in vec4 OUT[%u]) {\n", MAX_REG_OUTPUT);
/* First, sort out position and point size. Those are not passed to the pixel shader */
for(i = 0; i < MAX_REG_OUTPUT; i++) {
usage_token = semantics_out[i].usage;
if (!usage_token) continue;
register_token = semantics_out[i].reg;
usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
shader_glsl_get_write_mask(register_token, reg_mask);
switch(usage) {
case WINED3DDECLUSAGE_POSITION:
shader_addline(&buffer, "gl_Position%s = OUT[%u]%s;\n", reg_mask, i, reg_mask);
break;
case WINED3DDECLUSAGE_PSIZE:
shader_addline(&buffer, "gl_PointSize = OUT[%u].x;\n", i);
break;
default:
break;
}
}
/* Then, fix the pixel shader input */
wined3d: Install a varying map.
2007-10-28 00:12:37 +02:00
handle_ps3_input(&buffer, semantics_in, semantics_out, gl_info, ps->input_reg_map);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
shader_addline(&buffer, "}\n");
} else if(ps_major >= 3 && vs_major < 3) {
semantics_in = ps->semantics_in;
wined3d: Add printf format checking to the shader_addline function and fix resulting warnings.
2007-11-28 12:55:11 +01:00
shader_addline(&buffer, "varying vec4 IN[%u];\n", GL_LIMITS(glsl_varyings) / 4);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
shader_addline(&buffer, "void order_ps_input() {\n");
/* The vertex shader wrote to the builtin varyings. There is no need to figure out position and
* point size, but we depend on the optimizers kindness to find out that the pixel shader doesn't
* read gl_TexCoord and gl_ColorX, otherwise we'll run out of varyings
*/
wined3d: Install a varying map.
2007-10-28 00:12:37 +02:00
handle_ps3_input(&buffer, semantics_in, NULL, gl_info, ps->input_reg_map);
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
shader_addline(&buffer, "}\n");
} else {
ERR("Unexpected vertex and pixel shader version condition: vs: %d, ps: %d\n", vs_major, ps_major);
}
ret = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
checkGLcall("glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB)");
GL_EXTCALL(glShaderSourceARB(ret, 1, (const char**)&buffer.buffer, NULL));
checkGLcall("glShaderSourceARB(ret, 1, (const char**)&buffer.buffer, NULL)");
GL_EXTCALL(glCompileShaderARB(ret));
checkGLcall("glCompileShaderARB(ret)");
HeapFree(GetProcessHeap(), 0, buffer.buffer);
return ret;
}
wined3d: Hardcode local constants with glUniform4fvARB.
2008-06-02 21:44:06 +02:00
static void hardcode_local_constants(IWineD3DBaseShaderImpl *shader, WineD3D_GL_Info *gl_info, GLhandleARB programId, char prefix) {
local_constant* lconst;
GLuint tmp_loc;
float *value;
char glsl_name[8];
LIST_FOR_EACH_ENTRY(lconst, &shader->baseShader.constantsF, local_constant, entry) {
value = (float *) lconst->value;
snprintf(glsl_name, sizeof(glsl_name), "%cLC%u", prefix, lconst->idx);
tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
GL_EXTCALL(glUniform4fvARB(tmp_loc, 1, value));
}
checkGLcall("Hardcoding local constants\n");
}
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
/** Sets the GLSL program ID for the given pixel and vertex shader combination.
* It sets the programId on the current StateBlock (because it should be called
* inside of the DrawPrimitive() part of the render loop).
*
* If a program for the given combination does not exist, create one, and store
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
* the program in the hash table. If it creates a program, it will link the
* given objects, too.
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
*/
wined3d: Disable vertex shaders when transformed vertices are used.
2007-03-12 23:22:00 +01:00
static void set_glsl_shader_program(IWineD3DDevice *iface, BOOL use_ps, BOOL use_vs) {
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
wined3d: Store the current GLSL program in the backend's private data.
2008-07-07 21:02:57 +02:00
struct shader_glsl_priv *priv = (struct shader_glsl_priv *)This->shader_priv;
wined3d: Store the gl information in a per adapter structure and initialize it only once.
2007-06-09 14:27:41 +02:00
WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
IWineD3DPixelShader *pshader = This->stateBlock->pixelShader;
IWineD3DVertexShader *vshader = This->stateBlock->vertexShader;
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
struct glsl_shader_prog_link *entry = NULL;
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
GLhandleARB programId = 0;
wined3d: Handle ps 3.0 varyings in a different way.
2007-10-26 02:11:00 +02:00
GLhandleARB reorder_shader_id = 0;
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
int i;
char glsl_name[8];
wined3d: Disable vertex shaders when transformed vertices are used.
2007-03-12 23:22:00 +01:00
GLhandleARB vshader_id = use_vs ? ((IWineD3DBaseShaderImpl*)vshader)->baseShader.prgId : 0;
GLhandleARB pshader_id = use_ps ? ((IWineD3DBaseShaderImpl*)pshader)->baseShader.prgId : 0;
wined3d: Store the glsl program lookup table in the backend's private data.
2008-07-08 21:44:20 +02:00
entry = get_glsl_program_entry(priv, vshader_id, pshader_id);
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
if (entry) {
wined3d: Store the current GLSL program in the backend's private data.
2008-07-07 21:02:57 +02:00
priv->glsl_program = entry;
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
return;
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
}
/* If we get to this point, then no matching program exists, so we create one */
programId = GL_EXTCALL(glCreateProgramObjectARB());
TRACE("Created new GLSL shader program %u\n", programId);
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
/* Create the entry */
entry = HeapAlloc(GetProcessHeap(), 0, sizeof(struct glsl_shader_prog_link));
entry->programId = programId;
entry->vshader = vshader_id;
entry->pshader = pshader_id;
/* Add the hash table entry */
wined3d: Store the glsl program lookup table in the backend's private data.
2008-07-08 21:44:20 +02:00
add_glsl_program_entry(priv, entry);
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
/* Set the current program */
wined3d: Store the current GLSL program in the backend's private data.
2008-07-07 21:02:57 +02:00
priv->glsl_program = entry;
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
/* Attach GLSL vshader */
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
if (vshader_id) {
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
int max_attribs = 16; /* TODO: Will this always be the case? It is at the moment... */
char tmp_name[10];
wined3d: Work around nvidia beta driver bug.
2007-11-22 22:18:53 +01:00
reorder_shader_id = generate_param_reorder_function(vshader, pshader, gl_info);
TRACE("Attaching GLSL shader object %u to program %u\n", reorder_shader_id, programId);
GL_EXTCALL(glAttachObjectARB(programId, reorder_shader_id));
checkGLcall("glAttachObjectARB");
/* Flag the reorder function for deletion, then it will be freed automatically when the program
* is destroyed
*/
GL_EXTCALL(glDeleteObjectARB(reorder_shader_id));
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
TRACE("Attaching GLSL shader object %u to program %u\n", vshader_id, programId);
GL_EXTCALL(glAttachObjectARB(programId, vshader_id));
checkGLcall("glAttachObjectARB");
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
/* Bind vertex attributes to a corresponding index number to match
* the same index numbers as ARB_vertex_programs (makes loading
* vertex attributes simpler). With this method, we can use the
* exact same code to load the attributes later for both ARB and
* GLSL shaders.
*
* We have to do this here because we need to know the Program ID
* in order to make the bindings work, and it has to be done prior
* to linking the GLSL program. */
for (i = 0; i < max_attribs; ++i) {
wined3d: Only glBindAttribLocation used attributes.
2007-10-22 14:08:23 +02:00
if (((IWineD3DBaseShaderImpl*)vshader)->baseShader.reg_maps.attributes[i]) {
snprintf(tmp_name, sizeof(tmp_name), "attrib%i", i);
GL_EXTCALL(glBindAttribLocationARB(programId, i, tmp_name));
}
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
}
checkGLcall("glBindAttribLocationARB");
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
list_add_head(&((IWineD3DBaseShaderImpl *)vshader)->baseShader.linked_programs, &entry->vshader_entry);
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
}
/* Attach GLSL pshader */
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
if (pshader_id) {
TRACE("Attaching GLSL shader object %u to program %u\n", pshader_id, programId);
GL_EXTCALL(glAttachObjectARB(programId, pshader_id));
checkGLcall("glAttachObjectARB");
list_add_head(&((IWineD3DBaseShaderImpl *)pshader)->baseShader.linked_programs, &entry->pshader_entry);
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
}
/* Link the program */
TRACE("Linking GLSL shader program %u\n", programId);
GL_EXTCALL(glLinkProgramARB(programId));
print_glsl_info_log(&GLINFO_LOCATION, programId);
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
entry->vuniformF_locations = HeapAlloc(GetProcessHeap(), 0, sizeof(GLhandleARB) * GL_LIMITS(vshader_constantsF));
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
for (i = 0; i < GL_LIMITS(vshader_constantsF); ++i) {
snprintf(glsl_name, sizeof(glsl_name), "VC[%i]", i);
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
entry->vuniformF_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
}
wined3d: Store integer uniform locations.
2007-11-06 23:36:10 +01:00
for (i = 0; i < MAX_CONST_I; ++i) {
snprintf(glsl_name, sizeof(glsl_name), "VI[%i]", i);
entry->vuniformI_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
}
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
entry->puniformF_locations = HeapAlloc(GetProcessHeap(), 0, sizeof(GLhandleARB) * GL_LIMITS(pshader_constantsF));
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
for (i = 0; i < GL_LIMITS(pshader_constantsF); ++i) {
snprintf(glsl_name, sizeof(glsl_name), "PC[%i]", i);
wined3d: Store GLSL programs in a hash table rather than a linked list.
2007-02-27 20:51:53 +01:00
entry->puniformF_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
}
wined3d: Store integer uniform locations.
2007-11-06 23:36:10 +01:00
for (i = 0; i < MAX_CONST_I; ++i) {
snprintf(glsl_name, sizeof(glsl_name), "PI[%i]", i);
entry->puniformI_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
}
wined3d: Store the special uniforms' locations in the linked program.
2007-11-06 23:05:38 +01:00
wined3d: Support more than one texbem instruction per shader.
2008-03-05 03:18:55 +01:00
if(pshader) {
for(i = 0; i < ((IWineD3DPixelShaderImpl*)pshader)->numbumpenvmatconsts; i++) {
char name[32];
sprintf(name, "bumpenvmat%d", ((IWineD3DPixelShaderImpl*)pshader)->bumpenvmatconst[i].texunit);
entry->bumpenvmat_location[i] = GL_EXTCALL(glGetUniformLocationARB(programId, name));
sprintf(name, "luminancescale%d", ((IWineD3DPixelShaderImpl*)pshader)->luminanceconst[i].texunit);
entry->luminancescale_location[i] = GL_EXTCALL(glGetUniformLocationARB(programId, name));
sprintf(name, "luminanceoffset%d", ((IWineD3DPixelShaderImpl*)pshader)->luminanceconst[i].texunit);
entry->luminanceoffset_location[i] = GL_EXTCALL(glGetUniformLocationARB(programId, name));
}
}
wined3d: Store the special uniforms' locations in the linked program.
2007-11-06 23:05:38 +01:00
entry->posFixup_location = GL_EXTCALL(glGetUniformLocationARB(programId, "posFixup"));
entry->srgb_comparison_location = GL_EXTCALL(glGetUniformLocationARB(programId, "srgb_comparison"));
entry->srgb_mul_low_location = GL_EXTCALL(glGetUniformLocationARB(programId, "srgb_mul_low"));
entry->ycorrection_location = GL_EXTCALL(glGetUniformLocationARB(programId, "ycorrection"));
wined3d: Store integer uniform locations.
2007-11-06 23:36:10 +01:00
checkGLcall("Find glsl program uniform locations");
wined3d: Load GLSL sampler uniforms at shader link time.
2007-11-07 23:03:15 +01:00
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
if (pshader && WINED3DSHADER_VERSION_MAJOR(((IWineD3DPixelShaderImpl *)pshader)->baseShader.hex_version) >= 3
&& ((IWineD3DPixelShaderImpl *)pshader)->declared_in_count > GL_LIMITS(glsl_varyings) / 4) {
TRACE("Shader %d needs vertex color clamping disabled\n", programId);
entry->vertex_color_clamp = GL_FALSE;
} else {
entry->vertex_color_clamp = GL_FIXED_ONLY_ARB;
}
wined3d: Load GLSL sampler uniforms at shader link time.
2007-11-07 23:03:15 +01:00
/* Set the shader to allow uniform loading on it */
GL_EXTCALL(glUseProgramObjectARB(programId));
checkGLcall("glUseProgramObjectARB(programId)");
/* Load the vertex and pixel samplers now. The function that finds the mappings makes sure
* that it stays the same for each vertexshader-pixelshader pair(=linked glsl program). If
* a pshader with fixed function pipeline is used there are no vertex samplers, and if a
* vertex shader with fixed function pixel processing is used we make sure that the card
* supports enough samplers to allow the max number of vertex samplers with all possible
* fixed function fragment processing setups. So once the program is linked these samplers
* won't change.
*/
if(vshader_id) {
/* Load vertex shader samplers */
shader_glsl_load_vsamplers(gl_info, (IWineD3DStateBlock*)This->stateBlock, programId);
}
if(pshader_id) {
/* Load pixel shader samplers */
shader_glsl_load_psamplers(gl_info, (IWineD3DStateBlock*)This->stateBlock, programId);
}
wined3d: Hardcode local constants with glUniform4fvARB.
2008-06-02 21:44:06 +02:00
/* If the local constants do not have to be loaded with the environment constants,
* load them now to have them hardcoded in the GLSL program. This saves some CPU cycles
* later
*/
if(pshader && !((IWineD3DPixelShaderImpl*)pshader)->baseShader.load_local_constsF) {
hardcode_local_constants((IWineD3DBaseShaderImpl *) pshader, gl_info, programId, 'P');
}
if(vshader && !((IWineD3DVertexShaderImpl*)vshader)->baseShader.load_local_constsF) {
hardcode_local_constants((IWineD3DBaseShaderImpl *) vshader, gl_info, programId, 'V');
}
wined3d: Move set_glsl_shader_program() to glsl_shader.c.
2006-12-28 03:13:24 +01:00
}
wined3d: Move some code specific to the different shader backends into the respective source files.
2006-11-27 20:50:37 +01:00
static GLhandleARB create_glsl_blt_shader(WineD3D_GL_Info *gl_info) {
GLhandleARB program_id;
GLhandleARB vshader_id, pshader_id;
const char *blt_vshader[] = {
wined3d: Specify the GLSL language version our shaders are written to. This prevents some driver warnings when using language features from 1.20, like "first class arrays".
2008-06-30 23:03:47 +02:00
"#version 120\n"
wined3d: Move some code specific to the different shader backends into the respective source files.
2006-11-27 20:50:37 +01:00
"void main(void)\n"
"{\n"
" gl_Position = gl_Vertex;\n"
" gl_FrontColor = vec4(1.0);\n"
" gl_TexCoord[0].x = (gl_Vertex.x * 0.5) + 0.5;\n"
" gl_TexCoord[0].y = (-gl_Vertex.y * 0.5) + 0.5;\n"
"}\n"
};
const char *blt_pshader[] = {
wined3d: Specify the GLSL language version our shaders are written to. This prevents some driver warnings when using language features from 1.20, like "first class arrays".
2008-06-30 23:03:47 +02:00
"#version 120\n"
wined3d: Move some code specific to the different shader backends into the respective source files.
2006-11-27 20:50:37 +01:00
"uniform sampler2D sampler;\n"
"void main(void)\n"
"{\n"
" gl_FragDepth = texture2D(sampler, gl_TexCoord[0].xy).x;\n"
"}\n"
};
vshader_id = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
GL_EXTCALL(glShaderSourceARB(vshader_id, 1, blt_vshader, NULL));
GL_EXTCALL(glCompileShaderARB(vshader_id));
pshader_id = GL_EXTCALL(glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB));
GL_EXTCALL(glShaderSourceARB(pshader_id, 1, blt_pshader, NULL));
GL_EXTCALL(glCompileShaderARB(pshader_id));
program_id = GL_EXTCALL(glCreateProgramObjectARB());
GL_EXTCALL(glAttachObjectARB(program_id, vshader_id));
GL_EXTCALL(glAttachObjectARB(program_id, pshader_id));
GL_EXTCALL(glLinkProgramARB(program_id));
print_glsl_info_log(&GLINFO_LOCATION, program_id);
wined3d: Move shader model private data into its own structure.
2008-02-24 11:23:53 +01:00
/* Once linked we can mark the shaders for deletion. They will be deleted once the program
* is destroyed
*/
GL_EXTCALL(glDeleteObjectARB(vshader_id));
GL_EXTCALL(glDeleteObjectARB(pshader_id));
wined3d: Move some code specific to the different shader backends into the respective source files.
2006-11-27 20:50:37 +01:00
return program_id;
}
static void shader_glsl_select(IWineD3DDevice *iface, BOOL usePS, BOOL useVS) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
wined3d: Store the current GLSL program in the backend's private data.
2008-07-07 21:02:57 +02:00
struct shader_glsl_priv *priv = (struct shader_glsl_priv *)This->shader_priv;
wined3d: Store the gl information in a per adapter structure and initialize it only once.
2007-06-09 14:27:41 +02:00
WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
wined3d: Move some code specific to the different shader backends into the respective source files.
2006-11-27 20:50:37 +01:00
GLhandleARB program_id = 0;
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
GLenum old_vertex_color_clamp, current_vertex_color_clamp;
wined3d: Store the current GLSL program in the backend's private data.
2008-07-07 21:02:57 +02:00
old_vertex_color_clamp = priv->glsl_program ? priv->glsl_program->vertex_color_clamp : GL_FIXED_ONLY_ARB;
wined3d: Move some code specific to the different shader backends into the respective source files.
2006-11-27 20:50:37 +01:00
wined3d: Disable vertex shaders when transformed vertices are used.
2007-03-12 23:22:00 +01:00
if (useVS || usePS) set_glsl_shader_program(iface, usePS, useVS);
wined3d: Store the current GLSL program in the backend's private data.
2008-07-07 21:02:57 +02:00
else priv->glsl_program = NULL;
wined3d: Move some code specific to the different shader backends into the respective source files.
2006-11-27 20:50:37 +01:00
wined3d: Store the current GLSL program in the backend's private data.
2008-07-07 21:02:57 +02:00
current_vertex_color_clamp = priv->glsl_program ? priv->glsl_program->vertex_color_clamp : GL_FIXED_ONLY_ARB;
wined3d: Use gl_Color and gl_SecondaryColor to support more varyings in SM3.0 shaders. SM3.0 requires 10 4 component float varyings for passing stuff between vertex and pixel shaders. GF7 and earlier report 8 generic varyings + gl_Color and gl_SecondaryColor in GLSL. This patch allows us to use gl_Color and gl_SecondaryColor to get 2 extra varyings, which some games, like C&C3 with highest gfx settings, require.
2008-06-19 00:36:35 +02:00
if (old_vertex_color_clamp != current_vertex_color_clamp) {
if (GL_SUPPORT(ARB_COLOR_BUFFER_FLOAT)) {
GL_EXTCALL(glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, current_vertex_color_clamp));
checkGLcall("glClampColorARB");
} else {
FIXME("vertex color clamp needs to be changed, but extension not supported.\n");
}
}
wined3d: Store the current GLSL program in the backend's private data.
2008-07-07 21:02:57 +02:00
program_id = priv->glsl_program ? priv->glsl_program->programId : 0;
wined3d: Move some code specific to the different shader backends into the respective source files.
2006-11-27 20:50:37 +01:00
if (program_id) TRACE("Using GLSL program %u\n", program_id);
GL_EXTCALL(glUseProgramObjectARB(program_id));
checkGLcall("glUseProgramObjectARB");
}
static void shader_glsl_select_depth_blt(IWineD3DDevice *iface) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
wined3d: Store the gl information in a per adapter structure and initialize it only once.
2007-06-09 14:27:41 +02:00
WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
wined3d: Move shader model private data into its own structure.
2008-02-24 11:23:53 +01:00
struct shader_glsl_priv *priv = (struct shader_glsl_priv *) This->shader_priv;
wined3d: Move some code specific to the different shader backends into the respective source files.
2006-11-27 20:50:37 +01:00
static GLhandleARB loc = -1;
wined3d: Move shader model private data into its own structure.
2008-02-24 11:23:53 +01:00
if (!priv->depth_blt_glsl_program_id) {
priv->depth_blt_glsl_program_id = create_glsl_blt_shader(gl_info);
loc = GL_EXTCALL(glGetUniformLocationARB(priv->depth_blt_glsl_program_id, "sampler"));
wined3d: Move some code specific to the different shader backends into the respective source files.
2006-11-27 20:50:37 +01:00
}
wined3d: Move shader model private data into its own structure.
2008-02-24 11:23:53 +01:00
GL_EXTCALL(glUseProgramObjectARB(priv->depth_blt_glsl_program_id));
wined3d: Move some code specific to the different shader backends into the respective source files.
2006-11-27 20:50:37 +01:00
GL_EXTCALL(glUniform1iARB(loc, 0));
}
wined3d: Don't call shader_select() in depth_blt(). Calling shader_select() from inside depth_blt() isn't necessarily safe. shader_select() assumes CompileShader() has been called for the current shaders, but that depends on STATE_VSHADER / STATE_PIXELSHADER being applied. That isn't always true when depth_blt() gets called, with the result that sometimes GLSL programs could be created with no shader objects attached.
2008-07-10 17:57:35 +02:00
static void shader_glsl_deselect_depth_blt(IWineD3DDevice *iface) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
struct shader_glsl_priv *priv = (struct shader_glsl_priv *) This->shader_priv;
GLhandleARB program_id;
program_id = priv->glsl_program ? priv->glsl_program->programId : 0;
if (program_id) TRACE("Using GLSL program %u\n", program_id);
GL_EXTCALL(glUseProgramObjectARB(program_id));
checkGLcall("glUseProgramObjectARB");
}
wined3d: Make shader_cleanup more useful.
2007-02-08 22:31:01 +01:00
static void shader_glsl_cleanup(IWineD3DDevice *iface) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
wined3d: Store the gl information in a per adapter structure and initialize it only once.
2007-06-09 14:27:41 +02:00
WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
wined3d: Make shader_cleanup more useful.
2007-02-08 22:31:01 +01:00
GL_EXTCALL(glUseProgramObjectARB(0));
wined3d: Move some code specific to the different shader backends into the respective source files.
2006-11-27 20:50:37 +01:00
}
wined3d: Move glsl shader destruction to the glsl shader backend.
2007-11-20 17:40:54 +01:00
static void shader_glsl_destroy(IWineD3DBaseShader *iface) {
struct list *linked_programs;
IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *) iface;
wined3d: Store the glsl program lookup table in the backend's private data.
2008-07-08 21:44:20 +02:00
IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *)This->baseShader.device;
struct shader_glsl_priv *priv = (struct shader_glsl_priv *)device->shader_priv;
WineD3D_GL_Info *gl_info = &device->adapter->gl_info;
wined3d: Move glsl shader destruction to the glsl shader backend.
2007-11-20 17:40:54 +01:00
/* Note: Do not use QueryInterface here to find out which shader type this is because this code
* can be called from IWineD3DBaseShader::Release
*/
char pshader = shader_is_pshader_version(This->baseShader.hex_version);
if(This->baseShader.prgId == 0) return;
linked_programs = &This->baseShader.linked_programs;
TRACE("Deleting linked programs\n");
if (linked_programs->next) {
struct glsl_shader_prog_link *entry, *entry2;
if(pshader) {
LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs, struct glsl_shader_prog_link, pshader_entry) {
wined3d: Store the glsl program lookup table in the backend's private data.
2008-07-08 21:44:20 +02:00
delete_glsl_program_entry(priv, gl_info, entry);
wined3d: Move glsl shader destruction to the glsl shader backend.
2007-11-20 17:40:54 +01:00
}
} else {
LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs, struct glsl_shader_prog_link, vshader_entry) {
wined3d: Store the glsl program lookup table in the backend's private data.
2008-07-08 21:44:20 +02:00
delete_glsl_program_entry(priv, gl_info, entry);
wined3d: Move glsl shader destruction to the glsl shader backend.
2007-11-20 17:40:54 +01:00
}
}
}
TRACE("Deleting shader object %u\n", This->baseShader.prgId);
GL_EXTCALL(glDeleteObjectARB(This->baseShader.prgId));
checkGLcall("glDeleteObjectARB");
wined3d: Reset the shader state on shader_*_destroy.
2008-01-08 20:53:17 +01:00
This->baseShader.prgId = 0;
This->baseShader.is_compiled = FALSE;
wined3d: Move glsl shader destruction to the glsl shader backend.
2007-11-20 17:40:54 +01:00
}
wined3d: Move the shader backend selection into a separate function.
2008-03-18 19:37:53 +01:00
static unsigned int glsl_program_key_hash(void *key) {
glsl_program_key_t *k = (glsl_program_key_t *)key;
unsigned int hash = k->vshader | k->pshader << 16;
hash += ~(hash << 15);
hash ^= (hash >> 10);
hash += (hash << 3);
hash ^= (hash >> 6);
hash += ~(hash << 11);
hash ^= (hash >> 16);
return hash;
}
static BOOL glsl_program_key_compare(void *keya, void *keyb) {
glsl_program_key_t *ka = (glsl_program_key_t *)keya;
glsl_program_key_t *kb = (glsl_program_key_t *)keyb;
return ka->vshader == kb->vshader && ka->pshader == kb->pshader;
}
wined3d: Move shader model private data into its own structure.
2008-02-24 11:23:53 +01:00
static HRESULT shader_glsl_alloc(IWineD3DDevice *iface) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
wined3d: Store the glsl program lookup table in the backend's private data.
2008-07-08 21:44:20 +02:00
struct shader_glsl_priv *priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct shader_glsl_priv));
priv->glsl_program_lookup = hash_table_create(glsl_program_key_hash, glsl_program_key_compare);
This->shader_priv = priv;
wined3d: Move shader model private data into its own structure.
2008-02-24 11:23:53 +01:00
return WINED3D_OK;
}
static void shader_glsl_free(IWineD3DDevice *iface) {
IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
wined3d: Destroy depth_blt resources in the backend's destructor. No need to expose this in the interface.
2008-07-09 17:59:39 +02:00
WineD3D_GL_Info *gl_info = &This->adapter->gl_info;
struct shader_glsl_priv *priv = (struct shader_glsl_priv *)This->shader_priv;
if(priv->depth_blt_glsl_program_id) {
GL_EXTCALL(glDeleteObjectARB(priv->depth_blt_glsl_program_id));
}
wined3d: Use a hashmap to store the ffp shaders.
2008-07-29 17:51:52 +02:00
hash_table_destroy(priv->glsl_program_lookup, NULL, NULL);
wined3d: Destroy depth_blt resources in the backend's destructor. No need to expose this in the interface.
2008-07-09 17:59:39 +02:00
wined3d: Move shader model private data into its own structure.
2008-02-24 11:23:53 +01:00
HeapFree(GetProcessHeap(), 0, This->shader_priv);
wined3d: Free shader private data on reset. Since the shader backend implementations might track opengl resources in their private data inform them about reset calls. For example, the atifs backend keeps track of the replacement shaders, which are lost during an opengl context recreation.
2008-03-18 19:31:24 +01:00
This->shader_priv = NULL;
wined3d: Move shader model private data into its own structure.
2008-02-24 11:23:53 +01:00
}
wined3d: Implement a different constant dirtification algorithm. Add a new property of the shader backend which indicates whether the shader backend is able to dirtify single constants rather than dirtifying vshader and pshader constants as a whole. Depending on this a different Set*ConstantF implementation is used which marks constants dirty. The ARB shader backend uses this and marks constants clean after uploading.
2008-03-04 02:30:23 +01:00
static BOOL shader_glsl_dirty_const(IWineD3DDevice *iface) {
Assorted spelling fixes.
2008-03-18 15:21:13 +01:00
/* TODO: GL_EXT_bindable_uniform can be used to share constants across shaders */
wined3d: Implement a different constant dirtification algorithm. Add a new property of the shader backend which indicates whether the shader backend is able to dirtify single constants rather than dirtifying vshader and pshader constants as a whole. Depending on this a different Set*ConstantF implementation is used which marks constants dirty. The ARB shader backend uses this and marks constants clean after uploading.
2008-03-04 02:30:23 +01:00
return FALSE;
}
wined3d: Move shader generation into the shader backend. Generating the shader ID and parts of the shader prolog and epilog was done by the common vertexshader.c / pixelshader.c, which is ugly. This patch doesn't get rid of all the uglyness, somewhen we'll still have to sort out the relationship of [arb|glsl]_generate_shader and [arb|glsl]_generate_declarations.
2008-03-18 19:19:16 +01:00
static void shader_glsl_generate_pshader(IWineD3DPixelShader *iface, SHADER_BUFFER *buffer) {
IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)iface;
shader_reg_maps* reg_maps = &This->baseShader.reg_maps;
CONST DWORD *function = This->baseShader.function;
const char *fragcolor;
WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *)This->baseShader.device)->adapter->gl_info;
/* Create the hw GLSL shader object and assign it as the baseShader.prgId */
GLhandleARB shader_obj = GL_EXTCALL(glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB));
wined3d: Specify the GLSL language version our shaders are written to. This prevents some driver warnings when using language features from 1.20, like "first class arrays".
2008-06-30 23:03:47 +02:00
shader_addline(buffer, "#version 120\n");
wined3d: Move shader generation into the shader backend. Generating the shader ID and parts of the shader prolog and epilog was done by the common vertexshader.c / pixelshader.c, which is ugly. This patch doesn't get rid of all the uglyness, somewhen we'll still have to sort out the relationship of [arb|glsl]_generate_shader and [arb|glsl]_generate_declarations.
2008-03-18 19:19:16 +01:00
if (GL_SUPPORT(ARB_DRAW_BUFFERS)) {
shader_addline(buffer, "#extension GL_ARB_draw_buffers : enable\n");
}
if (GL_SUPPORT(ARB_TEXTURE_RECTANGLE)) {
/* The spec says that it doesn't have to be explicitly enabled, but the nvidia
* drivers write a warning if we don't do so
*/
shader_addline(buffer, "#extension GL_ARB_texture_rectangle : enable\n");
}
/* Base Declarations */
shader_generate_glsl_declarations( (IWineD3DBaseShader*) This, reg_maps, buffer, &GLINFO_LOCATION);
/* Pack 3.0 inputs */
if (This->baseShader.hex_version >= WINED3DPS_VERSION(3,0)) {
if(((IWineD3DDeviceImpl *) This->baseShader.device)->strided_streams.u.s.position_transformed) {
This->vertexprocessing = pretransformed;
pshader_glsl_input_pack(buffer, This->semantics_in, iface);
} else if(!use_vs((IWineD3DDeviceImpl *) This->baseShader.device)) {
This->vertexprocessing = fixedfunction;
pshader_glsl_input_pack(buffer, This->semantics_in, iface);
} else {
This->vertexprocessing = vertexshader;
}
}
/* Base Shader Body */
shader_generate_main( (IWineD3DBaseShader*) This, buffer, reg_maps, function);
/* Pixel shaders < 2.0 place the resulting color in R0 implicitly */
if (This->baseShader.hex_version < WINED3DPS_VERSION(2,0)) {
/* Some older cards like GeforceFX ones don't support multiple buffers, so also not gl_FragData */
if(GL_SUPPORT(ARB_DRAW_BUFFERS))
shader_addline(buffer, "gl_FragData[0] = R0;\n");
else
shader_addline(buffer, "gl_FragColor = R0;\n");
}
if(GL_SUPPORT(ARB_DRAW_BUFFERS)) {
fragcolor = "gl_FragData[0]";
} else {
fragcolor = "gl_FragColor";
}
if(This->srgb_enabled) {
shader_addline(buffer, "tmp0.xyz = pow(%s.xyz, vec3(%f, %f, %f)) * vec3(%f, %f, %f) - vec3(%f, %f, %f);\n",
fragcolor, srgb_pow, srgb_pow, srgb_pow, srgb_mul_high, srgb_mul_high, srgb_mul_high,
srgb_sub_high, srgb_sub_high, srgb_sub_high);
shader_addline(buffer, "tmp1.xyz = %s.xyz * srgb_mul_low.xyz;\n", fragcolor);
shader_addline(buffer, "%s.x = %s.x < srgb_comparison.x ? tmp1.x : tmp0.x;\n", fragcolor, fragcolor);
shader_addline(buffer, "%s.y = %s.y < srgb_comparison.y ? tmp1.y : tmp0.y;\n", fragcolor, fragcolor);
shader_addline(buffer, "%s.z = %s.z < srgb_comparison.z ? tmp1.z : tmp0.z;\n", fragcolor, fragcolor);
shader_addline(buffer, "%s = clamp(%s, 0.0, 1.0);\n", fragcolor, fragcolor);
}
/* Pixel shader < 3.0 do not replace the fog stage.
* This implements linear fog computation and blending.
* TODO: non linear fog
* NOTE: gl_Fog.start and gl_Fog.end don't hold fog start s and end e but
* -1/(e-s) and e/(e-s) respectively.
*/
if(This->baseShader.hex_version < WINED3DPS_VERSION(3,0)) {
shader_addline(buffer, "float Fog = clamp(gl_FogFragCoord * gl_Fog.start + gl_Fog.end, 0.0, 1.0);\n");
shader_addline(buffer, "%s.xyz = mix(gl_Fog.color.xyz, %s.xyz, Fog);\n", fragcolor, fragcolor);
}
shader_addline(buffer, "}\n");
TRACE("Compiling shader object %u\n", shader_obj);
GL_EXTCALL(glShaderSourceARB(shader_obj, 1, (const char**)&buffer->buffer, NULL));
GL_EXTCALL(glCompileShaderARB(shader_obj));
print_glsl_info_log(&GLINFO_LOCATION, shader_obj);
/* Store the shader object */
This->baseShader.prgId = shader_obj;
}
static void shader_glsl_generate_vshader(IWineD3DVertexShader *iface, SHADER_BUFFER *buffer) {
IWineD3DVertexShaderImpl *This = (IWineD3DVertexShaderImpl *)iface;
shader_reg_maps* reg_maps = &This->baseShader.reg_maps;
CONST DWORD *function = This->baseShader.function;
WineD3D_GL_Info *gl_info = &((IWineD3DDeviceImpl *)This->baseShader.device)->adapter->gl_info;
/* Create the hw GLSL shader program and assign it as the baseShader.prgId */
GLhandleARB shader_obj = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
wined3d: Specify the GLSL language version our shaders are written to. This prevents some driver warnings when using language features from 1.20, like "first class arrays".
2008-06-30 23:03:47 +02:00
shader_addline(buffer, "#version 120\n");
wined3d: Move shader generation into the shader backend. Generating the shader ID and parts of the shader prolog and epilog was done by the common vertexshader.c / pixelshader.c, which is ugly. This patch doesn't get rid of all the uglyness, somewhen we'll still have to sort out the relationship of [arb|glsl]_generate_shader and [arb|glsl]_generate_declarations.
2008-03-18 19:19:16 +01:00
/* Base Declarations */
shader_generate_glsl_declarations( (IWineD3DBaseShader*) This, reg_maps, buffer, &GLINFO_LOCATION);
/* Base Shader Body */
shader_generate_main( (IWineD3DBaseShader*) This, buffer, reg_maps, function);
/* Unpack 3.0 outputs */
if (This->baseShader.hex_version >= WINED3DVS_VERSION(3,0)) {
shader_addline(buffer, "order_ps_input(OUT);\n");
} else {
shader_addline(buffer, "order_ps_input();\n");
}
/* If this shader doesn't use fog copy the z coord to the fog coord so that we can use table fog */
if (!reg_maps->fog)
shader_addline(buffer, "gl_FogFragCoord = gl_Position.z;\n");
/* Write the final position.
*
* OpenGL coordinates specify the center of the pixel while d3d coords specify
* the corner. The offsets are stored in z and w in posFixup. posFixup.y contains
* 1.0 or -1.0 to turn the rendering upside down for offscreen rendering. PosFixup.x
* contains 1.0 to allow a mad.
*/
shader_addline(buffer, "gl_Position.y = gl_Position.y * posFixup.y;\n");
shader_addline(buffer, "gl_Position.xy += posFixup.zw * gl_Position.ww;\n");
/* Z coord [0;1]->[-1;1] mapping, see comment in transform_projection in state.c
*
* Basically we want (in homogeneous coordinates) z = z * 2 - 1. However, shaders are run
* before the homogeneous divide, so we have to take the w into account: z = ((z / w) * 2 - 1) * w,
wined3d: Correct a comment.
2008-09-10 11:08:40 +02:00
* which is the same as z = z * 2 - w.
wined3d: Move shader generation into the shader backend. Generating the shader ID and parts of the shader prolog and epilog was done by the common vertexshader.c / pixelshader.c, which is ugly. This patch doesn't get rid of all the uglyness, somewhen we'll still have to sort out the relationship of [arb|glsl]_generate_shader and [arb|glsl]_generate_declarations.
2008-03-18 19:19:16 +01:00
*/
shader_addline(buffer, "gl_Position.z = gl_Position.z * 2.0 - gl_Position.w;\n");
shader_addline(buffer, "}\n");
TRACE("Compiling shader object %u\n", shader_obj);
GL_EXTCALL(glShaderSourceARB(shader_obj, 1, (const char**)&buffer->buffer, NULL));
GL_EXTCALL(glCompileShaderARB(shader_obj));
print_glsl_info_log(&GLINFO_LOCATION, shader_obj);
/* Store the shader object */
This->baseShader.prgId = shader_obj;
}
wined3d: Move shader caps setting into the arb and glsl shader backends.
2008-03-22 14:27:53 +01:00
static void shader_glsl_get_caps(WINED3DDEVTYPE devtype, WineD3D_GL_Info *gl_info, struct shader_caps *pCaps) {
/* Nvidia Geforce6/7 or Ati R4xx/R5xx cards with GLSL support, support VS 3.0 but older Nvidia/Ati
* models with GLSL support only support 2.0. In case of nvidia we can detect VS 2.0 support using
* vs_nv_version which is based on NV_vertex_program.
* For Ati cards there's no way using glsl (it abstracts the lowlevel info away) and also not
* using ARB_vertex_program. It is safe to assume that when a card supports pixel shader 2.0 it
* supports vertex shader 2.0 too and the way around. We can detect ps2.0 using the maximum number
* of native instructions, so use that here. For more info see the pixel shader versioning code below.
*/
if((GLINFO_LOCATION.vs_nv_version == VS_VERSION_20) || (GLINFO_LOCATION.ps_arb_max_instructions <= 512))
pCaps->VertexShaderVersion = WINED3DVS_VERSION(2,0);
else
pCaps->VertexShaderVersion = WINED3DVS_VERSION(3,0);
TRACE_(d3d_caps)("Hardware vertex shader version %d.%d enabled (GLSL)\n", (pCaps->VertexShaderVersion >> 8) & 0xff, pCaps->VertexShaderVersion & 0xff);
pCaps->MaxVertexShaderConst = GL_LIMITS(vshader_constantsF);
/* Older DX9-class videocards (GeforceFX / Radeon >9500/X*00) only support pixel shader 2.0/2.0a/2.0b.
* In OpenGL the extensions related to GLSL abstract lowlevel GL info away which is needed
* to distinguish between 2.0 and 3.0 (and 2.0a/2.0b). In case of Nvidia we use their fragment
* program extensions. On other hardware including ATI GL_ARB_fragment_program offers the info
* in max native instructions. Intel and others also offer the info in this extension but they
* don't support GLSL (at least on Windows).
*
* PS2.0 requires at least 96 instructions, 2.0a/2.0b go up to 512. Assume that if the number
* of instructions is 512 or less we have to do with ps2.0 hardware.
* NOTE: ps3.0 hardware requires 512 or more instructions but ati and nvidia offer 'enough' (1024 vs 4096) on their most basic ps3.0 hardware.
*/
if((GLINFO_LOCATION.ps_nv_version == PS_VERSION_20) || (GLINFO_LOCATION.ps_arb_max_instructions <= 512))
pCaps->PixelShaderVersion = WINED3DPS_VERSION(2,0);
else
pCaps->PixelShaderVersion = WINED3DPS_VERSION(3,0);
/* FIXME: The following line is card dependent. -8.0 to 8.0 is the
* Direct3D minimum requirement.
*
* Both GL_ARB_fragment_program and GLSL require a "maximum representable magnitude"
* of colors to be 2^10, and 2^32 for other floats. Should we use 1024 here?
*
* The problem is that the refrast clamps temporary results in the shader to
* [-MaxValue;+MaxValue]. If the card's max value is bigger than the one we advertize here,
* then applications may miss the clamping behavior. On the other hand, if it is smaller,
* the shader will generate incorrect results too. Unfortunately, GL deliberately doesn't
* offer a way to query this.
*/
pCaps->PixelShader1xMaxValue = 8.0;
TRACE_(d3d_caps)("Hardware pixel shader version %d.%d enabled (GLSL)\n", (pCaps->PixelShaderVersion >> 8) & 0xff, pCaps->PixelShaderVersion & 0xff);
wined3d: Set shader specific caps in the shader backend. The whole control structures in directx.c get terribly confusing with the various codepaths for texturing and different shader implementations. It is also hard to reflect the shader model decisions this way too. This patch moves the shader specific parts of the caps code into the shader backend where we can set our caps dependent of the shader model decisions and without complex caps flag checks.
2008-03-18 19:39:26 +01:00
}
wined3d: Ask the ffp/shader/blit implementation about format support. If a format is not supported natively by opengl, a shader may be able to convert it. Up to now, CheckDeviceFormat had magic knowldge which GL extensions lead to which supported format. This patch adds functions that allow CheckDeviceFormat to ask the actual implementation for its capabilities.
2008-08-07 21:51:35 +02:00
static BOOL shader_glsl_conv_supported(WINED3DFORMAT fmt) {
TRACE("Checking shader format support for format %s:", debug_d3dformat(fmt));
switch(fmt) {
case WINED3DFMT_V8U8:
case WINED3DFMT_V16U16:
case WINED3DFMT_X8L8V8U8:
case WINED3DFMT_L6V5U5:
case WINED3DFMT_Q8W8V8U8:
case WINED3DFMT_ATI2N:
TRACE("[OK]\n");
return TRUE;
default:
TRACE("[FAILED\n");
return FALSE;
}
}
wined3d: Move part of the shader instruction table to the backend.
2008-09-23 17:39:34 +02:00
static const SHADER_HANDLER shader_glsl_instruction_handler_table[WINED3DSIH_TABLE_SIZE] =
{
/* WINED3DSIH_ABS */ shader_glsl_map2gl,
/* WINED3DSIH_ADD */ shader_glsl_arith,
/* WINED3DSIH_BEM */ pshader_glsl_bem,
/* WINED3DSIH_BREAK */ shader_glsl_break,
/* WINED3DSIH_BREAKC */ shader_glsl_breakc,
/* WINED3DSIH_BREAKP */ NULL,
/* WINED3DSIH_CALL */ shader_glsl_call,
/* WINED3DSIH_CALLNZ */ shader_glsl_callnz,
/* WINED3DSIH_CMP */ shader_glsl_cmp,
/* WINED3DSIH_CND */ shader_glsl_cnd,
/* WINED3DSIH_CRS */ shader_glsl_cross,
/* WINED3DSIH_DCL */ NULL,
/* WINED3DSIH_DEF */ NULL,
/* WINED3DSIH_DEFB */ NULL,
/* WINED3DSIH_DEFI */ NULL,
/* WINED3DSIH_DP2ADD */ pshader_glsl_dp2add,
/* WINED3DSIH_DP3 */ shader_glsl_dot,
/* WINED3DSIH_DP4 */ shader_glsl_dot,
/* WINED3DSIH_DST */ shader_glsl_dst,
/* WINED3DSIH_DSX */ shader_glsl_map2gl,
/* WINED3DSIH_DSY */ shader_glsl_map2gl,
/* WINED3DSIH_ELSE */ shader_glsl_else,
/* WINED3DSIH_ENDIF */ shader_glsl_end,
/* WINED3DSIH_ENDLOOP */ shader_glsl_end,
/* WINED3DSIH_ENDREP */ shader_glsl_end,
/* WINED3DSIH_EXP */ shader_glsl_map2gl,
/* WINED3DSIH_EXPP */ shader_glsl_expp,
/* WINED3DSIH_FRC */ shader_glsl_map2gl,
/* WINED3DSIH_IF */ shader_glsl_if,
/* WINED3DSIH_IFC */ shader_glsl_ifc,
/* WINED3DSIH_LABEL */ shader_glsl_label,
/* WINED3DSIH_LIT */ shader_glsl_lit,
/* WINED3DSIH_LOG */ shader_glsl_log,
/* WINED3DSIH_LOGP */ shader_glsl_log,
/* WINED3DSIH_LOOP */ shader_glsl_loop,
/* WINED3DSIH_LRP */ shader_glsl_lrp,
/* WINED3DSIH_M3x2 */ shader_glsl_mnxn,
/* WINED3DSIH_M3x3 */ shader_glsl_mnxn,
/* WINED3DSIH_M3x4 */ shader_glsl_mnxn,
/* WINED3DSIH_M4x3 */ shader_glsl_mnxn,
/* WINED3DSIH_M4x4 */ shader_glsl_mnxn,
/* WINED3DSIH_MAD */ shader_glsl_mad,
/* WINED3DSIH_MAX */ shader_glsl_map2gl,
/* WINED3DSIH_MIN */ shader_glsl_map2gl,
/* WINED3DSIH_MOV */ shader_glsl_mov,
/* WINED3DSIH_MOVA */ shader_glsl_mov,
/* WINED3DSIH_MUL */ shader_glsl_arith,
/* WINED3DSIH_NOP */ NULL,
/* WINED3DSIH_NRM */ shader_glsl_map2gl,
/* WINED3DSIH_PHASE */ NULL,
/* WINED3DSIH_POW */ shader_glsl_pow,
/* WINED3DSIH_RCP */ shader_glsl_rcp,
/* WINED3DSIH_REP */ shader_glsl_rep,
/* WINED3DSIH_RET */ NULL,
/* WINED3DSIH_RSQ */ shader_glsl_rsq,
/* WINED3DSIH_SETP */ NULL,
/* WINED3DSIH_SGE */ shader_glsl_compare,
/* WINED3DSIH_SGN */ shader_glsl_map2gl,
/* WINED3DSIH_SINCOS */ shader_glsl_sincos,
/* WINED3DSIH_SLT */ shader_glsl_compare,
/* WINED3DSIH_SUB */ shader_glsl_arith,
/* WINED3DSIH_TEX */ pshader_glsl_tex,
/* WINED3DSIH_TEXBEM */ pshader_glsl_texbem,
/* WINED3DSIH_TEXBEML */ pshader_glsl_texbem,
/* WINED3DSIH_TEXCOORD */ pshader_glsl_texcoord,
/* WINED3DSIH_TEXDEPTH */ pshader_glsl_texdepth,
/* WINED3DSIH_TEXDP3 */ pshader_glsl_texdp3,
/* WINED3DSIH_TEXDP3TEX */ pshader_glsl_texdp3tex,
/* WINED3DSIH_TEXKILL */ pshader_glsl_texkill,
/* WINED3DSIH_TEXLDD */ NULL,
/* WINED3DSIH_TEXLDL */ shader_glsl_texldl,
/* WINED3DSIH_TEXM3x2DEPTH */ pshader_glsl_texm3x2depth,
/* WINED3DSIH_TEXM3x2PAD */ pshader_glsl_texm3x2pad,
/* WINED3DSIH_TEXM3x2TEX */ pshader_glsl_texm3x2tex,
/* WINED3DSIH_TEXM3x3 */ pshader_glsl_texm3x3,
/* WINED3DSIH_TEXM3x3DIFF */ NULL,
/* WINED3DSIH_TEXM3x3PAD */ pshader_glsl_texm3x3pad,
/* WINED3DSIH_TEXM3x3SPEC */ pshader_glsl_texm3x3spec,
/* WINED3DSIH_TEXM3x3TEX */ pshader_glsl_texm3x3tex,
/* WINED3DSIH_TEXM3x3VSPEC */ pshader_glsl_texm3x3vspec,
/* WINED3DSIH_TEXREG2AR */ pshader_glsl_texreg2ar,
/* WINED3DSIH_TEXREG2GB */ pshader_glsl_texreg2gb,
/* WINED3DSIH_TEXREG2RGB */ pshader_glsl_texreg2rgb,
};
wined3d: Move some code specific to the different shader backends into the respective source files.
2006-11-27 20:50:37 +01:00
const shader_backend_t glsl_shader_backend = {
wined3d: Move part of the shader instruction table to the backend.
2008-09-23 17:39:34 +02:00
shader_glsl_instruction_handler_table,
wined3d: Remove unneeded address-of operators from function names.
2008-07-06 14:00:52 +02:00
shader_glsl_select,
shader_glsl_select_depth_blt,
wined3d: Don't call shader_select() in depth_blt(). Calling shader_select() from inside depth_blt() isn't necessarily safe. shader_select() assumes CompileShader() has been called for the current shaders, but that depends on STATE_VSHADER / STATE_PIXELSHADER being applied. That isn't always true when depth_blt() gets called, with the result that sometimes GLSL programs could be created with no shader objects attached.
2008-07-10 17:57:35 +02:00
shader_glsl_deselect_depth_blt,
wined3d: Remove unneeded address-of operators from function names.
2008-07-06 14:00:52 +02:00
shader_glsl_load_constants,
shader_glsl_cleanup,
shader_glsl_color_correction,
shader_glsl_destroy,
shader_glsl_alloc,
shader_glsl_free,
shader_glsl_dirty_const,
shader_glsl_generate_pshader,
shader_glsl_generate_vshader,
shader_glsl_get_caps,
wined3d: Ask the ffp/shader/blit implementation about format support. If a format is not supported natively by opengl, a shader may be able to convert it. Up to now, CheckDeviceFormat had magic knowldge which GL extensions lead to which supported format. This patch adds functions that allow CheckDeviceFormat to ask the actual implementation for its capabilities.
2008-08-07 21:51:35 +02:00
shader_glsl_conv_supported,
wined3d: Move some code specific to the different shader backends into the respective source files.
2006-11-27 20:50:37 +01:00
};