3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * GLSL pixel and vertex shader implementation
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Copyright 2006 Jason Green
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Copyright 2006-2007 Henri Verbeet
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Copyright 2009 Henri Verbeet for CodeWeavers
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * This library is free software; you can redistribute it and/or
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * modify it under the terms of the GNU Lesser General Public
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * License as published by the Free Software Foundation; either
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * version 2.1 of the License, or (at your option) any later version.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * This library is distributed in the hope that it will be useful,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * but WITHOUT ANY WARRANTY; without even the implied warranty of
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Lesser General Public License for more details.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * You should have received a copy of the GNU Lesser General Public
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * License along with this library; if not, write to the Free Software
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * other than GPL or LGPL is available it will apply instead, Oracle elects to use only
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * a choice of LGPL license versions is made available with the language indicating
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * that LGPLv2 or any later version may be used, or where a choice of which version
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * of the LGPL is applied is otherwise unspecified.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * D3D shader asm has swizzles on source parameters, and write masks for
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * destination parameters. GLSL uses swizzles for both. The result of this is
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * that for example "mov dst.xw, src.zyxw" becomes "dst.xw = src.zw" in GLSL.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Ie, to generate a proper GLSL source swizzle, we need to take the D3D write
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * mask for the destination parameter into account.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsynctypedef struct {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsynctypedef struct {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsynctypedef struct {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GLSL shader private data */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Struct to maintain data about a linked GLSL program */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync#define WINEFIXUPINFO_GET(_p) get_fixup_info((const IWineD3DPixelShaderImpl*)(_p)->pshader, (_p)->inp2Fixup_info)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync#define WINEFIXUPINFO_ISVALID(_p) ((_p)->inp2Fixup_info != WINEFIXUPINFO_NOINDEX)
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync# define WINEFIXUPINFO_INIT(_p) do { (_p)->inp2Fixup_info = WINEFIXUPINFO_NOINDEX; } while (0)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync#define WINEFIXUPINFO_INIT(_p) ((_p)->inp2Fixup_info == WINEFIXUPINFO_NOINDEX)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsynctypedef struct {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic const char *debug_gl_shader_type(GLenum type)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Extract a line from the info log.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Note that this modifies the source string. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic char *get_info_log_line(char **ptr, int *pcbStr)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync char *p, *q;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* zero-length string */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ERR("string should be null-rerminated, forcing it!");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* the string contains a single line! */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync *pcbStr = cbStr - (((uintptr_t)q) - ((uintptr_t)p)) - 1;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Prints the GLSL info log which will contain error messages if they exist */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void print_glsl_info_log(const struct wined3d_gl_info *gl_info, GLhandleARB obj)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync unsigned int i;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "Vertex shader was successfully compiled to run on hardware.\n", /* fglrx */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "Fragment shader was successfully compiled to run on hardware.\n", /* fglrx, with \n */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "Fragment shader was successfully compiled to run on hardware.", /* fglrx, no \n */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "Fragment shader(s) linked, vertex shader(s) linked. \n ", /* fglrx, with \n */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "Fragment shader(s) linked, vertex shader(s) linked.", /* fglrx, no \n */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "Vertex shader(s) linked, no fragment shader(s) defined. \n ", /* fglrx, with \n */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "Vertex shader(s) linked, no fragment shader(s) defined.", /* fglrx, no \n */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "Fragment shader(s) linked, no vertex shader(s) defined. \n ", /* fglrx, with \n */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "Fragment shader(s) linked, no vertex shader(s) defined.", /* fglrx, no \n */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (!TRACE_ON(d3d_shader) && !FIXME_ON(d3d_shader)) return;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* A size of 1 is just a null-terminated string, so the log should be bigger than
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * that if there are errors. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Fglrx doesn't terminate the string properly, but it tells us the proper length.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * So use HEAP_ZERO_MEMORY to avoid uninitialized bytes
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync infoLog = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, infologLength);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glGetInfoLogARB(obj, infologLength, NULL, infoLog));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for(i = 0; i < sizeof(spam) / sizeof(spam[0]); i++) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WDLOG(("Spam received from GLSL shader #%u:\n", obj));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync while ((line = get_info_log_line(&ptr, &cbPtr))) WDLOG((" %s\n", line));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WDLOG(("Error received from GLSL shader #%u:\n", obj));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync while ((line = get_info_log_line(&ptr, &cbPtr))) WDLOG((" %s\n", line));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_dump_shader_source(const struct wined3d_gl_info *gl_info, GLhandleARB shader)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glGetObjectParameterivARB(shader, GL_OBJECT_SHADER_SOURCE_LENGTH_ARB, &tmp));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync source = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, tmp);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ERR("Failed to allocate %d bytes for shader source.\n", tmp);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glGetObjectParameterivARB(shader, GL_OBJECT_SUBTYPE_ARB, &tmp));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WDLOG((" GL_OBJECT_SUBTYPE_ARB: %s.\n", debug_gl_shader_type(tmp)));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB, &tmp));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WDLOG((" GL_OBJECT_COMPILE_STATUS_ARB: %d.\n", tmp));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glGetShaderSourceARB(shader, source_size, NULL, source));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync while ((line = get_info_log_line(&ptr, &cbPtr))) WDLOG((" %s\n", line));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_dump_program_source(const struct wined3d_gl_info *gl_info, GLhandleARB program)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WDLOG(("\n***************************dumping program %d******************************\n", program));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glGetObjectParameterivARB(program, GL_OBJECT_ATTACHED_OBJECTS_ARB, &object_count));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync objects = HeapAlloc(GetProcessHeap(), 0, object_count * sizeof(*objects));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glGetAttachedObjectsARB(program, object_count, NULL, objects));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0; i < object_count; ++i)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_dump_shader_source(gl_info, objects[i]);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WDLOG(("\n***************************END dumping program %d******************************\n\n", program));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_validate_compile_link(const struct wined3d_gl_info *gl_info, GLhandleARB program, GLboolean fIsProgram)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (!TRACE_ON(d3d_shader) && !FIXME_ON(d3d_shader)) return;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glGetObjectParameterivARB(program, GL_OBJECT_TYPE_ARB, &tmp));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glGetObjectParameterivARB(program, GL_OBJECT_LINK_STATUS_ARB, &tmp));
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync ERR("Program %p link status invalid.\n", (void *)(uintptr_t)program);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glGetObjectParameterivARB(program, GL_OBJECT_COMPILE_STATUS_ARB, &tmp));
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync ERR("Shader %p compile status invalid.\n", (void *)(uintptr_t)program);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Loads (pixel shader) samplers
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_load_psamplers(const struct wined3d_gl_info *gl_info,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync snprintf(sampler_name, sizeof(sampler_name), "Psampler%d", i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync name_loc = GL_EXTCALL(glGetUniformLocationARB(programId, sampler_name));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (mapped_unit != WINED3D_UNMAPPED_STAGE && mapped_unit < gl_info->limits.fragment_samplers)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync TRACE("Loading %s for texture %d\n", sampler_name, mapped_unit);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ERR("Trying to load sampler %s on unsupported unit %d\n", sampler_name, mapped_unit);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_load_vsamplers(const struct wined3d_gl_info *gl_info,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0; i < MAX_VERTEX_SAMPLERS; ++i) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync snprintf(sampler_name, sizeof(sampler_name), "Vsampler%d", i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync name_loc = GL_EXTCALL(glGetUniformLocationARB(programId, sampler_name));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD mapped_unit = tex_unit_map[MAX_FRAGMENT_SAMPLERS + i];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (mapped_unit != WINED3D_UNMAPPED_STAGE && mapped_unit < gl_info->limits.combined_samplers)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync TRACE("Loading %s for texture %d\n", sampler_name, mapped_unit);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ERR("Trying to load sampler %s on unsupported unit %d\n", sampler_name, mapped_unit);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic inline void walk_constant_heap(const struct wined3d_gl_info *gl_info, const float *constants,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const GLint *constant_locations, const struct constant_heap *heap, unsigned char *stack, DWORD version)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (heap->entries[heap_idx].version <= version) return;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (constant_locations[idx] != -1) GL_EXTCALL(glUniform4fvARB(constant_locations[idx], 1, &constants[idx * 4]));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Note that we fall through to the next case statement. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (left_idx < heap->size && heap->entries[left_idx].version > version)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glUniform4fvARB(constant_locations[idx], 1, &constants[idx * 4]));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (right_idx < heap->size && heap->entries[right_idx].version > version)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glUniform4fvARB(constant_locations[idx], 1, &constants[idx * 4]));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic inline void apply_clamped_constant(const struct wined3d_gl_info *gl_info, GLint location, const GLfloat *data)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync clamped_constant[0] = data[0] < -1.0f ? -1.0f : data[0] > 1.0f ? 1.0f : data[0];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync clamped_constant[1] = data[1] < -1.0f ? -1.0f : data[1] > 1.0f ? 1.0f : data[1];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync clamped_constant[2] = data[2] < -1.0f ? -1.0f : data[2] > 1.0f ? 1.0f : data[2];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync clamped_constant[3] = data[3] < -1.0f ? -1.0f : data[3] > 1.0f ? 1.0f : data[3];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glUniform4fvARB(location, 1, clamped_constant));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic inline void walk_constant_heap_clamped(const struct wined3d_gl_info *gl_info, const float *constants,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const GLint *constant_locations, const struct constant_heap *heap, unsigned char *stack, DWORD version)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (heap->entries[heap_idx].version <= version) return;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync apply_clamped_constant(gl_info, constant_locations[idx], &constants[idx * 4]);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Note that we fall through to the next case statement. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (left_idx < heap->size && heap->entries[left_idx].version > version)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync apply_clamped_constant(gl_info, constant_locations[idx], &constants[idx * 4]);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (right_idx < heap->size && heap->entries[right_idx].version > version)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync apply_clamped_constant(gl_info, constant_locations[idx], &constants[idx * 4]);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Loads floating point constants (aka uniforms) into the currently set GLSL program. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_load_constantsF(IWineD3DBaseShaderImpl *This, const struct wined3d_gl_info *gl_info,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const float *constants, const GLint *constant_locations, const struct constant_heap *heap,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* 1.X pshaders have the constants clamped to [-1;1] implicitly. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (This->baseShader.reg_maps.shader_version.major == 1
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync && shader_is_pshader_version(This->baseShader.reg_maps.shader_version.type))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync walk_constant_heap_clamped(gl_info, constants, constant_locations, heap, stack, version);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync walk_constant_heap(gl_info, constants, constant_locations, heap, stack, version);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync TRACE("No need to load local float constants for this shader\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Immediate constants are clamped to [-1;1] at shader creation time if needed */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* We found this uniform name in the program - go ahead and send the data */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (location != -1) GL_EXTCALL(glUniform4fvARB(location, 1, (const GLfloat *)lconst->value));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Loads integer constants (aka uniforms) into the currently set GLSL program. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_load_constantsI(IWineD3DBaseShaderImpl *This, const struct wined3d_gl_info *gl_info,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const GLint locations[MAX_CONST_I], const int *constants, WORD constants_set)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync unsigned int i;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0; constants_set; constants_set >>= 1, ++i)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync TRACE_(d3d_constants)("Loading constants %u: %i, %i, %i, %i\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync i, constants[i*4], constants[i*4+1], constants[i*4+2], constants[i*4+3]);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* We found this uniform name in the program - go ahead and send the data */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glUniform4ivARB(locations[i], 1, &constants[i*4]));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Load immediate constants */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct local_constant *lconst = LIST_ENTRY(ptr, const struct local_constant, entry);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const GLint *values = (const GLint *)lconst->value;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync TRACE_(d3d_constants)("Loading local constants %i: %i, %i, %i, %i\n", idx,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* We found this uniform name in the program - go ahead and send the data */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glUniform4ivARB(locations[idx], 1, values));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ptr = list_next(&This->baseShader.constantsI, ptr);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Loads boolean constants (aka uniforms) into the currently set GLSL program. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_load_constantsB(IWineD3DBaseShaderImpl *This, const struct wined3d_gl_info *gl_info,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GLhandleARB programId, const BOOL *constants, WORD constants_set)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync unsigned int i;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync switch (This->baseShader.reg_maps.shader_version.type)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* TODO: Benchmark and see if it would be beneficial to store the
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * locations of the constants to avoid looking up each time */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0; constants_set; constants_set >>= 1, ++i)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync TRACE_(d3d_constants)("Loading constants %i: %i;\n", i, constants[i]);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* TODO: Benchmark and see if it would be beneficial to store the
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * locations of the constants to avoid looking up each time */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync snprintf(tmp_name, sizeof(tmp_name), "%s[%i]", prefix, i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* We found this uniform name in the program - go ahead and send the data */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glUniform1ivARB(tmp_loc, 1, &constants[i]));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Load immediate constants */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct local_constant *lconst = LIST_ENTRY(ptr, const struct local_constant, entry);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const GLint *values = (const GLint *)lconst->value;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync TRACE_(d3d_constants)("Loading local constants %i: %i\n", idx, values[0]);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync snprintf(tmp_name, sizeof(tmp_name), "%s[%i]", prefix, idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, tmp_name));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* We found this uniform name in the program - go ahead and send the data */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ptr = list_next(&This->baseShader.constantsB, ptr);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void reset_program_constant_version(struct wine_rb_entry *entry, void *context)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WINE_RB_ENTRY_VALUE(entry, struct glsl_shader_prog_link, program_lookup_entry)->constant_version = 0;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic const struct ps_np2fixup_info * get_fixup_info(const IWineD3DPixelShaderImpl *shader, UINT inp2fixup_info)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct glsl_pshader_private *shader_data = shader->baseShader.backend_data;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync return &shader_data->gl_shaders[inp2fixup_info].np2fixup;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Loads the texture dimensions for NP2 fixup into the currently set GLSL program.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller (state handler) */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const IWineD3DDeviceImpl* deviceImpl = (const IWineD3DDeviceImpl*) device;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct glsl_shader_prog_link* prog = ((struct shader_glsl_priv *)(deviceImpl->shader_priv))->glsl_program;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* No GLSL program set - nothing to do. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* NP2 texcoord fixup is (currently) only done for pixelshaders. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (prog->ps_args.np2_fixup && -1 != prog->np2Fixup_location) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = &deviceImpl->adapter->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const IWineD3DStateBlockImpl* stateBlock = (const IWineD3DStateBlockImpl*) deviceImpl->stateBlock;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GLfloat np2fixup_constants[4 * MAX_FRAGMENT_SAMPLERS];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct ps_np2fixup_info *np2Fixup_info = WINEFIXUPINFO_GET(prog);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const IWineD3DBaseTextureImpl* const tex = (const IWineD3DBaseTextureImpl*) stateBlock->textures[i];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GLfloat* tex_dim = &np2fixup_constants[(idx >> 1) * 4];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("Nonexistent texture is flagged for NP2 texcoord fixup\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync tex_dim[2] = tex->baseTexture.pow2Matrix[0]; tex_dim[3] = tex->baseTexture.pow2Matrix[5];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync tex_dim[0] = tex->baseTexture.pow2Matrix[0]; tex_dim[1] = tex->baseTexture.pow2Matrix[5];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glUniform4fvARB(prog->np2Fixup_location, np2Fixup_info->num_consts, np2fixup_constants));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Loads the app-supplied constants into the currently set GLSL program.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller (state handler) */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_load_constants(const struct wined3d_context *context,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DDeviceImpl *device = context_get_device(context);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DStateBlockImpl* stateBlock = device->stateBlock;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct shader_glsl_priv *priv = device->shader_priv;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct glsl_shader_prog_link *prog = priv->glsl_program;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* No GLSL program set - nothing to do. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseShaderImpl* vshader = (IWineD3DBaseShaderImpl*) stateBlock->vertexShader;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Load DirectX 9 float constants/uniforms for vertex shader */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_load_constantsF(vshader, gl_info, stateBlock->vertexShaderConstantF,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync prog->vuniformF_locations, &priv->vconst_heap, priv->stack, constant_version);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Load DirectX 9 integer constants/uniforms for vertex shader */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_load_constantsI(vshader, gl_info, prog->vuniformI_locations, stateBlock->vertexShaderConstantI,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync stateBlock->changed.vertexShaderConstantsI & vshader->baseShader.reg_maps.integer_constants);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Load DirectX 9 boolean constants/uniforms for vertex shader */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_load_constantsB(vshader, gl_info, programId, stateBlock->vertexShaderConstantB,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync stateBlock->changed.vertexShaderConstantsB & vshader->baseShader.reg_maps.boolean_constants);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Upload the position fixup params */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glUniform4fvARB(prog->posFixup_location, 1, &device->posFixup[0]));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseShaderImpl* pshader = (IWineD3DBaseShaderImpl*) stateBlock->pixelShader;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Load DirectX 9 float constants/uniforms for pixel shader */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_load_constantsF(pshader, gl_info, stateBlock->pixelShaderConstantF,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync prog->puniformF_locations, &priv->pconst_heap, priv->stack, constant_version);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Load DirectX 9 integer constants/uniforms for pixel shader */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_load_constantsI(pshader, gl_info, prog->puniformI_locations, stateBlock->pixelShaderConstantI,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync stateBlock->changed.pixelShaderConstantsI & pshader->baseShader.reg_maps.integer_constants);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Load DirectX 9 boolean constants/uniforms for pixel shader */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_load_constantsB(pshader, gl_info, programId, stateBlock->pixelShaderConstantB,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync stateBlock->changed.pixelShaderConstantsB & pshader->baseShader.reg_maps.boolean_constants);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Upload the environment bump map matrix if needed. The needsbumpmat member specifies the texture stage to load the matrix from.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * It can't be 0 for a valid texbem instruction.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for(i = 0; i < MAX_TEXTURES; i++) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync data = (const float *)&stateBlock->textureState[i][WINED3DTSS_BUMPENVMAT00];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glUniformMatrix2fvARB(prog->bumpenvmat_location[i], 1, 0, data));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* texbeml needs the luminance scale and offset too. If texbeml is used, needsbumpmat
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * is set too, so we can check that in the needsbumpmat check
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const GLfloat *scale = (const GLfloat *)&stateBlock->textureState[i][WINED3DTSS_BUMPENVLSCALE];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const GLfloat *offset = (const GLfloat *)&stateBlock->textureState[i][WINED3DTSS_BUMPENVLOFFSET];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glUniform1fvARB(prog->luminancescale_location[i], 1, scale));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glUniform1fvARB(prog->luminanceoffset_location[i], 1, offset));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if(((IWineD3DPixelShaderImpl *) pshader)->vpos_uniform) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* position is window relative, not viewport relative */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync correction_params[0] = ((IWineD3DSurfaceImpl *)context->current_rt)->currentDesc.Height;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glUniform4fvARB(prog->ycorrection_location, 1, correction_params));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync TRACE("Max constant version reached, resetting to 0.\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync wine_rb_for_each_entry(&priv->program_lookup, reset_program_constant_version, NULL);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync prog->constant_version = priv->next_constant_version++;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic inline void update_heap_entry(struct constant_heap *heap, unsigned int idx,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (new_version <= entries[parent_idx].version) break;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_update_float_vertex_constants(IWineD3DDevice *iface, UINT start, UINT count)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (!This->stateBlock->changed.vertexShaderConstantsF[i])
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync update_heap_entry(heap, i, heap->size++, priv->next_constant_version);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync update_heap_entry(heap, i, heap->positions[i], priv->next_constant_version);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_update_float_pixel_constants(IWineD3DDevice *iface, UINT start, UINT count)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (!This->stateBlock->changed.pixelShaderConstantsF[i])
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync update_heap_entry(heap, i, heap->size++, priv->next_constant_version);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync update_heap_entry(heap, i, heap->positions[i], priv->next_constant_version);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic unsigned int vec4_varyings(DWORD shader_major, const struct wined3d_gl_info *gl_info)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync unsigned int ret = gl_info->limits.glsl_varyings / 4;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* 4.0 shaders do not write clip coords because d3d10 does not support user clipplanes */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* 3.0 shaders may need an extra varying for the clip coord on some cards(mostly dx10 ones) */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (gl_info->quirks & WINED3D_QUIRK_GLSL_CLIP_VARYING) ret -= 1;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Generate the variable & register declarations for the GLSL output target */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_generate_glsl_declarations(const struct wined3d_context *context,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer, IWineD3DBaseShader *iface,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const shader_reg_maps *reg_maps, struct shader_glsl_ctx_priv *ctx_priv)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseShaderImpl* This = (IWineD3DBaseShaderImpl*) iface;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *) This->baseShader.device;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct ps_compile_args *ps_args = ctx_priv->cur_ps_args;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* There are some minor differences between pixel and vertex shaders */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync char pshader = shader_is_pshader_version(reg_maps->shader_version.type);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Prototype the subroutines */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0, map = reg_maps->labels; map; map >>= 1, ++i)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (map & 1) shader_addline(buffer, "void subroutine%u();\n", i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Declare the constants (aka uniforms) */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Unless the shader uses indirect addressing, always declare the maximum array size and ignore that we need some
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * uniforms privately. E.g. if GL supports 256 uniforms, and we need 2 for the pos fixup and immediate values, still
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * declare VC[256]. If the shader needs more uniforms than we have it won't work in any case. If it uses less, the
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * compiler will figure out which uniforms are really used and strip them out. This allows a shader to use c255 on
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * a dx9 card, as long as it doesn't also use all the other constants.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * If the shader uses indirect addressing the compiler must assume that all declared uniforms are used. In this case,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * declare only the amount that we're assured to have.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Thus we run into problems in these two cases:
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * 1) The shader really uses more uniforms than supported
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * 2) The shader uses indirect addressing, less constants than supported, but uses a constant index > #supported consts
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* No indirect addressing here. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync max_constantsF = gl_info->limits.glsl_ps_float_constants;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Subtract the other potential uniforms from the max available (bools, ints, and 1 row of projection matrix).
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Subtract another uniform for immediate values, which have to be loaded via uniform by the driver as well.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * The shader code only uses 0.5, 2.0, 1.0, 128 and -128 in vertex shader code, so one vec4 should be enough
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * (Unfortunately the Nvidia driver doesn't store 128 and -128 in one float).
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Writing gl_ClipVertex requires one uniform for each clipplane as well.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (gl_info->limits.glsl_vs_float_constants == 256)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD dwMajor = (DWORD)(LOBYTE(LOWORD(dwVersion)));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD dwMinor = (DWORD)(HIBYTE(LOWORD(dwVersion)));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* tmp workaround Win8 Aero requirement for 256 */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* tmp work-around to make Internet Explorer in win8 work with GPU supporting only with 256 shader uniform vars
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * @todo: make it more robust */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync max_constantsF = gl_info->limits.glsl_vs_float_constants - 1;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync max_constantsF = gl_info->limits.glsl_vs_float_constants - 3;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync max_constantsF = gl_info->limits.glsl_vs_float_constants - 3;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync max_constantsF -= count_bits(This->baseShader.reg_maps.integer_constants);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Strictly speaking a bool only uses one scalar, but the nvidia(Linux) compiler doesn't pack them properly,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * so each scalar requires a full vec4. We could work around this by packing the booleans ourselves, but
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * for now take this into account when calculating the number of available constants
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync max_constantsF -= count_bits(This->baseShader.reg_maps.boolean_constants);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Set by driver quirks in directx.c */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync max_constantsF -= gl_info->reserved_glsl_constants;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync max_constantsF = gl_info->limits.glsl_vs_float_constants;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync max_constantsF = min(This->baseShader.limits.constant_float, max_constantsF);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "uniform vec4 %cC[%u];\n", prefix, max_constantsF);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Always declare the full set of constants, the compiler can remove the unused ones because d3d doesn't(yet)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * support indirect int and bool constant addressing. This avoids problems if the app uses e.g. i0 and i9.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (This->baseShader.limits.constant_int > 0 && This->baseShader.reg_maps.integer_constants)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "uniform ivec4 %cI[%u];\n", prefix, This->baseShader.limits.constant_int);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (This->baseShader.limits.constant_bool > 0 && This->baseShader.reg_maps.boolean_constants)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "uniform bool %cB[%u];\n", prefix, This->baseShader.limits.constant_bool);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "uniform vec4 posFixup;\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Predeclaration; This function is added at link time based on the pixel shader.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * VS 3.0 shaders have an array OUT[] the shader writes to, earlier versions don't have
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * that. We know the input to the reorder function at vertex shader compile time, so
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * we can deal with that. The reorder function for a 1.x and 2.x vertex shader can just
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * read gl_FrontColor. The output depends on the pixel shader. The reorder function for a
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * 1.x and 2.x pshader or for fixed function will write gl_FrontColor, and for a 3.0 shader
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * it will write to the varying array. Here we depend on the shader optimizer on sorting that
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * out. The nvidia driver only does that if the parameter is inout instead of out, hence the
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "void order_ps_input(in vec4[%u]);\n", MAX_REG_OUTPUT);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "void order_ps_input();\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0, map = reg_maps->bumpmat; map; map >>= 1, ++i)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "uniform mat2 bumpenvmat%d;\n", i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "uniform float luminancescale%d;\n", i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "uniform float luminanceoffset%d;\n", i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "const vec4 srgb_const0 = vec4(%.8e, %.8e, %.8e, %.8e);\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync srgb_pow, srgb_mul_high, srgb_sub_high, srgb_mul_low);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "const vec4 srgb_const1 = vec4(%.8e, 0.0, 0.0, 0.0);\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (This->baseShader.limits.constant_float + extra_constants_needed
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "uniform vec4 ycorrection;\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ((IWineD3DPixelShaderImpl *) This)->vpos_uniform = 1;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* This happens because we do not have proper tracking of the constant registers that are
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * actually used, only the max limit of the shader version
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("Cannot find a free uniform for vpos correction params\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "const vec4 ycorrection = vec4(%f, %f, 0.0, 0.0);\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync context->render_offscreen ? 0.0f : ((IWineD3DSurfaceImpl *)device->render_targets[0])->currentDesc.Height,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Declare texture samplers */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0; i < This->baseShader.limits.sampler; i++) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "uniform sampler1D %csampler%u;\n", prefix, i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseTexture_GetTextureDimensions(device->stateBlock->textures[i]) == GL_TEXTURE_RECTANGLE_ARB) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "uniform sampler2DRect %csampler%u;\n", prefix, i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "uniform sampler2D %csampler%u;\n", prefix, i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "uniform samplerCube %csampler%u;\n", prefix, i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "uniform sampler3D %csampler%u;\n", prefix, i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "uniform unsupported_sampler %csampler%u;\n", prefix, i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("Unrecognized sampler type: %#x\n", reg_maps->sampler_type[i]);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Declare uniforms for NP2 texcoord fixup:
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * This is NOT done inside the loop that declares the texture samplers since the NP2 fixup code
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * is currently only used for the GeforceFX series and when forcing the ARB_npot extension off.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Modern cards just skip the code anyway, so put it inside a separate loop. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct ps_np2fixup_info* const fixup = ctx_priv->cur_np2fixup_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* NP2/RECT textures in OpenGL use texcoords in the range [0,width]x[0,height]
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * while D3D has them in the (normalized) [0,1]x[0,1] range.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * samplerNP2Fixup stores texture dimensions and is updated through
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * shader_glsl_load_np2fixup_constants when the sampler changes. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0; i < This->baseShader.limits.sampler; ++i) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("Non-2D texture is flagged for NP2 texcoord fixup.\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "uniform vec4 %csamplerNP2Fixup[%u];\n", prefix, fixup->num_consts);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Declare address variables */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0, map = reg_maps->address; map; map >>= 1, ++i)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (map & 1) shader_addline(buffer, "ivec4 A%u;\n", i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Declare texture coordinate temporaries and initialize them */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0, map = reg_maps->texcoord; map; map >>= 1, ++i)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (map & 1) shader_addline(buffer, "vec4 T%u = gl_TexCoord[%u];\n", i, i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Declare input register varyings. Only pixel shader, vertex shaders have that declared in the
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * helper function shader that is linked in at link time
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (pshader && reg_maps->shader_version.major >= 3)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "varying vec4 IN[%u];\n", vec4_varyings(reg_maps->shader_version.major, gl_info));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* TODO: Write a replacement shader for the fixed function vertex pipeline, so this isn't needed.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * For fixed function vertex processing + 3.0 pixel shader we need a separate function in the
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * pixel shader that reads the fixed function color into the packed input registers.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "vec4 IN[%u];\n", vec4_varyings(reg_maps->shader_version.major, gl_info));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Declare output register temporaries */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "vec4 OUT[%u];\n", This->baseShader.limits.packed_output);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Declare temporary variables */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0, map = reg_maps->temporary; map; map >>= 1, ++i)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (map & 1) shader_addline(buffer, "vec4 R%u;\n", i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Declare attributes */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (reg_maps->shader_version.type == WINED3D_SHADER_TYPE_VERTEX)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0, map = reg_maps->input_registers; map; map >>= 1, ++i)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (map & 1) shader_addline(buffer, "attribute vec4 attrib%i;\n", i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Declare loop registers aLx */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Temporary variables for matrix operations */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Local constants use a different name so they can be loaded once at shader link time
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * They can't be hardcoded into the shader text via LC = {x, y, z, w}; because the
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * float -> string conversion can cause precision loss.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync LIST_FOR_EACH_ENTRY(lconst, &This->baseShader.constantsF, local_constant, entry) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "uniform vec4 %cLC%u;\n", prefix, lconst->idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "const float FLT_MAX = 1e38;\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Start the main program */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* DirectX apps expect integer values, while OpenGL drivers add approximately 0.5. This causes
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * off-by-one problems as spotted by the vPos d3d9 visual test. Unfortunately the ATI cards do
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * not add exactly 0.5, but rather something like 0.49999999 or 0.50000001, which still causes
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * precision troubles when we just substract 0.5.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * To deal with that just floor() the position. This will eliminate the fraction on all cards.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * TODO: Test how that behaves with multisampling once we can enable multisampling in winex11.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * An advantage of floor is that it works even if the driver doesn't add 1/2. It is somewhat
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * questionable if 1.5, 2.5, ... are the proper values to return in gl_FragCoord, even though
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * coordinates specify the pixel centers instead of the pixel corners. This code will behave
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * correctly on drivers that returns integer values.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "vpos = floor(vec4(0, ycorrection[0], 0, 0) + gl_FragCoord * vec4(1, ycorrection[1], 1, 1));\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/*****************************************************************************
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Functions to generate GLSL strings from DirectX Shader bytecode begin here.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * For more information, see http://wiki.winehq.org/DirectX-Shaders
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ****************************************************************************/
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Prototypes */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_add_src_param(const struct wined3d_shader_instruction *ins,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_shader_src_param *wined3d_src, DWORD mask, glsl_src_param_t *glsl_src);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Used for opcode modifiers - They multiply the result by the specified amount */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Generate a GLSL parameter that does the input modifier computation and return the input register/mask to use */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_gen_modifier(DWORD src_modifier, const char *in_reg, const char *in_regswizzle, char *out_str)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync case WINED3DSPSM_DZ: /* Need to handle this in the instructions itself (texld & texcrd). */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(out_str, "(%s%s - vec4(0.5)%s)", in_reg, in_regswizzle, in_regswizzle);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(out_str, "-(%s%s - vec4(0.5)%s)", in_reg, in_regswizzle, in_regswizzle);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(out_str, "(2.0 * (%s%s - 0.5))", in_reg, in_regswizzle);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(out_str, "-(2.0 * (%s%s - 0.5))", in_reg, in_regswizzle);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(out_str, "(1.0 - %s%s)", in_reg, in_regswizzle);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(out_str, "(2.0 * %s%s)", in_reg, in_regswizzle);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(out_str, "-(2.0 * %s%s)", in_reg, in_regswizzle);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(out_str, "abs(%s%s)", in_reg, in_regswizzle);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(out_str, "-abs(%s%s)", in_reg, in_regswizzle);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Writes the GLSL variable name that corresponds to the register that the
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * DX opcode parameter is trying to access */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_get_register_name(const struct wined3d_shader_register *reg,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync char *register_name, BOOL *is_color, const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* oPos, oFog and oPts in D3D */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync static const char * const hwrastout_reg_names[] = { "gl_Position", "gl_FogFragCoord", "gl_PointSize" };
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync char pshader = shader_is_pshader_version(This->baseShader.reg_maps.shader_version.type);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* vertex shaders */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (priv->cur_vs_args->swizzle_map & (1 << reg->idx)) *is_color = TRUE;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* pixel shaders >= 3.0 */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (This->baseShader.reg_maps.shader_version.major >= 3)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD idx = ((IWineD3DPixelShaderImpl *)This)->input_reg_map[reg->idx];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync unsigned int in_count = vec4_varyings(This->baseShader.reg_maps.shader_version.major, gl_info);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, reg->rel_addr, WINED3DSP_WRITEMASK_0, &rel_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Removing a + 0 would be an obvious optimization, but macos doesn't see the NOP
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * operation there */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (((IWineD3DPixelShaderImpl *)This)->declared_in_count > in_count)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "((%s + %u) > %d ? (%s + %u) > %d ? gl_SecondaryColor : gl_Color : IN[%s + %u])",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync rel_param.param_str, idx, in_count - 1, rel_param.param_str, idx, in_count,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(register_name, "IN[%s + %u]", rel_param.param_str, idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (((IWineD3DPixelShaderImpl *)This)->declared_in_count > in_count)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(register_name, "((%s) > %d ? (%s) > %d ? gl_SecondaryColor : gl_Color : IN[%s])",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync rel_param.param_str, in_count - 1, rel_param.param_str, in_count,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(register_name, "IN[%s]", rel_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (idx == in_count) sprintf(register_name, "gl_Color");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else if (idx == in_count + 1) sprintf(register_name, "gl_SecondaryColor");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (reg->idx == 0) strcpy(register_name, "gl_Color");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Relative addressing */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, reg->rel_addr, WINED3DSP_WRITEMASK_0, &rel_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (reg->idx) sprintf(register_name, "%cC[%s + %u]", prefix, rel_param.param_str, reg->idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else sprintf(register_name, "%cC[%s]", prefix, rel_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(register_name, "%cLC%u", prefix, reg->idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(register_name, "%cC[%u]", prefix, reg->idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (pshader) sprintf(register_name, "PI[%u]", reg->idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (pshader) sprintf(register_name, "PB[%u]", reg->idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync case WINED3DSPR_TEXTURE: /* case WINED3DSPR_ADDR: */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (pshader) sprintf(register_name, "T%u", reg->idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(register_name, "aL%u", This->baseShader.cur_loop_regno - 1);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (pshader) sprintf(register_name, "Psampler%u", reg->idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else sprintf(register_name, "Vsampler%u", reg->idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WARN("Write to render target %u, only %d supported.\n", reg->idx, gl_info->limits.buffers);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(register_name, "gl_FragData[%u]", reg->idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(register_name, "%s", hwrastout_reg_names[reg->idx]);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (reg->idx == 0) sprintf(register_name, "gl_FrontColor");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else sprintf(register_name, "gl_FrontSecondaryColor");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Vertex shaders >= 3.0: WINED3DSPR_OUTPUT */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (This->baseShader.reg_maps.shader_version.major >= 3) sprintf(register_name, "OUT[%u]", reg->idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else sprintf(register_name, "gl_TexCoord[%u]", reg->idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Note that gl_FrontFacing is a bool, while vFace is
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * a float for which the sign determines front/back */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(register_name, "(gl_FrontFacing ? 1.0 : -1.0)");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("Unhandled misctype register %d\n", reg->idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(register_name, "%.8e", *(const float *)reg->immconst_data);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(register_name, "vec4(%.8e, %.8e, %.8e, %.8e)",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync *(const float *)®->immconst_data[0], *(const float *)®->immconst_data[1],
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync *(const float *)®->immconst_data[2], *(const float *)®->immconst_data[3]);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("Unhandled immconst type %#x\n", reg->immconst_type);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sprintf(register_name, "<unhandled_immconst_type %#x>", reg->immconst_type);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("Unhandled register name Type(%d)\n", reg->type);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_write_mask_to_str(DWORD write_mask, char *str)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (write_mask & WINED3DSP_WRITEMASK_0) *str++ = 'x';
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (write_mask & WINED3DSP_WRITEMASK_1) *str++ = 'y';
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (write_mask & WINED3DSP_WRITEMASK_2) *str++ = 'z';
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (write_mask & WINED3DSP_WRITEMASK_3) *str++ = 'w';
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Get the GLSL write mask for the destination register */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic DWORD shader_glsl_get_write_mask(const struct wined3d_shader_dst_param *param, char *write_mask)
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync if (mask & WINED3DSP_WRITEMASK_0) *write_mask++ = '0';
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync if (mask & WINED3DSP_WRITEMASK_1) *write_mask++ = '1';
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync if (mask & WINED3DSP_WRITEMASK_2) *write_mask++ = '2';
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync if (mask & WINED3DSP_WRITEMASK_3) *write_mask++ = '3';
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic unsigned int shader_glsl_get_write_mask_size(DWORD write_mask) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_swizzle_to_str(const DWORD swizzle, BOOL fixup, DWORD mask, char *str)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* For registers of type WINED3DDECLTYPE_D3DCOLOR, data is stored as "bgra",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * but addressed as "rgba". To fix this we need to swap the register's x
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * and z components. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const char *swizzle_chars = fixup ? "zyxw" : "xyzw";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* swizzle bits fields: wwzzyyxx */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (mask & WINED3DSP_WRITEMASK_0) *str++ = swizzle_chars[swizzle & 0x03];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (mask & WINED3DSP_WRITEMASK_1) *str++ = swizzle_chars[(swizzle >> 2) & 0x03];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (mask & WINED3DSP_WRITEMASK_2) *str++ = swizzle_chars[(swizzle >> 4) & 0x03];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (mask & WINED3DSP_WRITEMASK_3) *str++ = swizzle_chars[(swizzle >> 6) & 0x03];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_get_swizzle(const struct wined3d_shader_src_param *param,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_swizzle_to_str(param->swizzle, fixup, mask, swizzle_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* From a given parameter token, generate the corresponding GLSL string.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Also, return the actual register name and swizzle in case the
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * caller needs this information as well. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_add_src_param(const struct wined3d_shader_instruction *ins,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_shader_src_param *wined3d_src, DWORD mask, glsl_src_param_t *glsl_src)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_register_name(&wined3d_src->reg, glsl_src->reg_name, &is_color, ins);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_swizzle(wined3d_src, is_color, mask, swizzle_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_gen_modifier(wined3d_src->modifiers, glsl_src->reg_name, swizzle_str, glsl_src->param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* From a given parameter token, generate the corresponding GLSL string.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Also, return the actual register name and swizzle in case the
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * caller needs this information as well. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic DWORD shader_glsl_add_dst_param(const struct wined3d_shader_instruction *ins,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_shader_dst_param *wined3d_dst, glsl_dst_param_t *glsl_dst)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_register_name(&wined3d_dst->reg, glsl_dst->reg_name, &is_color, ins);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync return shader_glsl_get_write_mask(wined3d_dst, glsl_dst->mask_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Append the destination part of the instruction to the buffer, return the effective write mask */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic DWORD shader_glsl_append_dst_ext(struct wined3d_shader_buffer *buffer,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_shader_instruction *ins, const struct wined3d_shader_dst_param *dst)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync mask = shader_glsl_add_dst_param(ins, dst, &glsl_dst);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (mask) shader_addline(buffer, "%s%s = %s(", glsl_dst.reg_name, glsl_dst.mask_str, shift_glsl_tab[dst->shift]);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Append the destination part of the instruction to the buffer, return the effective write mask */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic DWORD shader_glsl_append_dst(struct wined3d_shader_buffer *buffer, const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync return shader_glsl_append_dst_ext(buffer, ins, &ins->dst[0]);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process GLSL instruction modifiers */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_add_instruction_modifiers(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (!modifiers) return;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_dst_param(ins, &ins->dst[0], &dst_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* _SAT means to clamp the value of the register to between 0 and 1 */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "%s%s = clamp(%s%s, 0.0, 1.0);\n", dst_param.reg_name,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync dst_param.mask_str, dst_param.reg_name, dst_param.mask_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* MSDN says this modifier can be safely ignored, so that's what we'll do. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic inline const char *shader_get_comp_op(DWORD op)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync return "(\?\?)";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_get_sample_function(const struct wined3d_gl_info *gl_info,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD sampler_type, DWORD flags, glsl_sample_function_t *sample_function)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync BOOL projected = flags & WINED3D_GLSL_SAMPLE_PROJECTED;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Note that there's no such thing as a projected cube texture. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->name = projected ? "texture1DProjLod" : "texture1DLod";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->name = projected ? "texture1DProjGrad" : "texture1DGrad";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else if (gl_info->supported[ARB_SHADER_TEXTURE_LOD])
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->name = projected ? "texture1DProjGradARB" : "texture1DGradARB";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->name = projected ? "texture1DProj" : "texture1D";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->coord_mask = WINED3DSP_WRITEMASK_0;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->name = projected ? "texture2DRectProjLod" : "texture2DRectLod";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->name = projected ? "texture2DRectProjGrad" : "texture2DRectGrad";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else if (gl_info->supported[ARB_SHADER_TEXTURE_LOD])
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->name = projected ? "texture2DRectProjGradARB" : "texture2DRectGradARB";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->name = projected ? "texture2DRectProj" : "texture2DRect";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->name = projected ? "texture2DProjLod" : "texture2DLod";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->name = projected ? "texture2DProjGrad" : "texture2DGrad";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else if (gl_info->supported[ARB_SHADER_TEXTURE_LOD])
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->name = projected ? "texture2DProjGradARB" : "texture2DGradARB";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->name = projected ? "texture2DProj" : "texture2D";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->coord_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else if (gl_info->supported[ARB_SHADER_TEXTURE_LOD])
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->coord_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->name = projected ? "texture3DProjLod" : "texture3DLod";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->name = projected ? "texture3DProjGrad" : "texture3DGrad";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else if (gl_info->supported[ARB_SHADER_TEXTURE_LOD])
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->name = projected ? "texture3DProjGradARB" : "texture3DGradARB";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->name = projected ? "texture3DProj" : "texture3D";
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sample_function->coord_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("Unrecognized sampler type: %#x;\n", sampler_type);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_append_fixup_arg(char *arguments, const char *reg_name,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync BOOL sign_fixup, enum fixup_channel_source channel_source)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("Unhandled channel source %#x\n", channel_source);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_color_correction(const struct wined3d_shader_instruction *ins, struct color_fixup_desc fixup)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (fixup.x_sign_fixup || fixup.x_source != CHANNEL_SOURCE_X) mask |= WINED3DSP_WRITEMASK_0;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (fixup.y_sign_fixup || fixup.y_source != CHANNEL_SOURCE_Y) mask |= WINED3DSP_WRITEMASK_1;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (fixup.z_sign_fixup || fixup.z_source != CHANNEL_SOURCE_Z) mask |= WINED3DSP_WRITEMASK_2;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (fixup.w_sign_fixup || fixup.w_source != CHANNEL_SOURCE_W) mask |= WINED3DSP_WRITEMASK_3;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync enum complex_fixup complex_fixup = get_complex_fixup(fixup);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("Complex fixup (%#x) not supported\n",complex_fixup);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_append_fixup_arg(arguments, dst_param.reg_name, fixup.x_sign_fixup, fixup.x_source);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_append_fixup_arg(arguments, dst_param.reg_name, fixup.y_sign_fixup, fixup.y_source);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_append_fixup_arg(arguments, dst_param.reg_name, fixup.z_sign_fixup, fixup.z_source);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_append_fixup_arg(arguments, dst_param.reg_name, fixup.w_sign_fixup, fixup.w_source);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "%s%s = vec%u(%s);\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync dst_param.reg_name, dst_param.mask_str, mask_size, arguments);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "%s%s = %s;\n", dst_param.reg_name, dst_param.mask_str, arguments);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void PRINTF_ATTR(8, 9) shader_glsl_gen_sample_code(const struct wined3d_shader_instruction *ins,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD sampler, const glsl_sample_function_t *sample_function, DWORD swizzle,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_swizzle_to_str(swizzle, FALSE, ins->dst[0].write_mask, dst_swizzle);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (priv->cur_ps_args->np2_fixup & (1 << sampler)) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("Biased sampling from NP2 textures is unsupported\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (ins->ctx->reg_maps->sampler_type[sampler]==WINED3DSTT_2D)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (sample_function->coord_mask & WINED3DSP_WRITEMASK_1)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], sample_function->coord_mask, &coord_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "%s.y=1.0-%s.y;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "tmp0.xy=vec2(%s.x, 1.0-%s.y).xy;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync fixup = COLOR_FIXUP_IDENTITY; /* FIXME: Vshader color fixup */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "%s(%s%u, ", sample_function->name, sampler_base, sampler);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_vaddline(ins->ctx->buffer, coord_reg_fmt, args);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, ", %s)%s);\n", bias, dst_swizzle);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const unsigned char idx = priv->cur_np2fixup_info->idx[sampler];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, " * PsamplerNP2Fixup[%u].%s)%s);\n", idx >> 1,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, ", %s, %s)%s);\n", dx, dy, dst_swizzle);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, ")%s);\n", dst_swizzle);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/*****************************************************************************
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Begin processing individual instruction opcodes
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ****************************************************************************/
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Generate GLSL arithmetic functions (dst = src1 + src2) */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_arith(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Determine the GLSL operator to use based on the opcode */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("Opcode %#x not yet handled in GLSL\n", ins->handler_idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "%s %c %s);\n", src0_param.param_str, op, src1_param.param_str);
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsyncstatic void shader_glsl_mov_impl(const struct wined3d_shader_instruction *ins, int p0_idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Process the WINED3DSIO_MOV opcode using GLSL (dst = src) */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_mov(const struct wined3d_shader_instruction *ins)
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync struct wined3d_shader_dst_param *dst = (struct wined3d_shader_dst_param *)&ins->dst[0];
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync for (i = 0; i < 4; i++)
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync/* Process the WINED3DSIO_MOV opcode using GLSL (dst = src) */
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsyncstatic void shader_glsl_mov_impl(const struct wined3d_shader_instruction *ins, int p0_idx)
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync/* Process the WINED3DSIO_MOV opcode using GLSL (dst = src) */
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsyncstatic void shader_glsl_mov(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* In vs_1_1 WINED3DSIO_MOV can write to the address register. In later
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * shader versions WINED3DSIO_MOVA is used for this. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync && !shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* This is a simple floor() */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "ivec%d(floor(%s)));\n", mask_size, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "int(floor(%s)));\n", src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* We need to *round* to the nearest int here. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "ivec%d(round(%s)));\n", mask_size, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "int(round(%s)));\n", src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "ivec%d(floor(abs(%s) + vec%d(0.5)) * sign(%s)));\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync mask_size, src0_param.param_str, mask_size, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "int(floor(abs(%s) + 0.5) * sign(%s)));\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "%s);\n", src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Process the dot product operators DP3 and DP4 in GLSL (dst = dot(src0, src1)) */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_dot(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync dst_write_mask = shader_glsl_append_dst(buffer, ins);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* dp3 works on vec3, dp4 on vec4 */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync src_write_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], src_write_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], src_write_mask, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "vec%d(dot(%s, %s)));\n", dst_size, src0_param.param_str, src1_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "dot(%s, %s));\n", src0_param.param_str, src1_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Note that this instruction has some restrictions. The destination write mask
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * can't contain the w component, and the source swizzles have to be .xyzw */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_cross(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], src_mask, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "cross(%s, %s)%s);\n", src0_param.param_str, src1_param.param_str, dst_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Process the WINED3DSIO_POW instruction in GLSL (dst = |src0|^src1)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Src0 and src1 are scalars. Note that D3D uses the absolute of src0, while
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * GLSL uses the value as-is. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_pow(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync dst_write_mask = shader_glsl_append_dst(buffer, ins);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_0, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "vec%d(pow(abs(%s), %s)));\n", dst_size, src0_param.param_str, src1_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "pow(abs(%s), %s));\n", src0_param.param_str, src1_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Process the WINED3DSIO_LOG instruction in GLSL (dst = log2(|src0|))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Src0 is a scalar. Note that D3D uses the absolute of src0, while
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * GLSL uses the value as-is. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_log(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync dst_write_mask = shader_glsl_append_dst(buffer, ins);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync dst_size = shader_glsl_get_write_mask_size(dst_write_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "vec%d(%s == 0.0 ? -FLT_MAX : log2(abs(%s))));\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync dst_size, src0_param.param_str, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "%s == 0.0 ? -FLT_MAX : log2(abs(%s)));\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Map the opcode 1-to-1 to the GL code (arg->dst = instruction(src0, src1, ...) */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_map2gl(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync unsigned i;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Determine the GLSL function to use based on the opcode */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* TODO: Possibly make this a table for faster lookups */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync case WINED3DSIH_DSY: instruction = "ycorrection.y * dFdy"; break;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("Opcode %#x not yet handled in GLSL\n", ins->handler_idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[i], write_mask, &src_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, ", %s", src_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_nrm(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync write_mask = shader_glsl_get_write_mask(ins->dst, dst_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync mask_size = shader_glsl_get_write_mask_size(write_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "tmp0.x = length(%s);\n", src_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "tmp0.x == 0.0 ? vec%u(0.0) : (%s / tmp0.x));\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "tmp0.x == 0.0 ? 0.0 : (%s / tmp0.x));\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_EXPP instruction in GLSL:
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * For shader model 1.x, do the following (and honor the writemask, so use a temporary variable):
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.x = 2^(floor(src))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.y = src - floor(src)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.z = 2^src (partial precision is allowed, but optional)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.w = 1.0;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * For 2.0 shaders, just do this (honoring writemask and swizzle):
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst = 2^src; (partial precision is allowed, but optional)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_expp(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "tmp0.x = exp2(floor(%s));\n", src_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "tmp0.y = %s - floor(%s);\n", src_param.param_str, src_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "tmp0.z = exp2(%s);\n", src_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "tmp0.w = 1.0;\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "tmp0%s);\n", dst_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync mask_size = shader_glsl_get_write_mask_size(write_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "vec%d(exp2(%s)));\n", mask_size, src_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "exp2(%s));\n", src_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the RCP (reciprocal or inverse) opcode in GLSL (dst = 1 / src) */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_rcp(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync mask_size = shader_glsl_get_write_mask_size(write_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_3, &src_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "vec%d(%s == 0.0 ? FLT_MAX : 1.0 / %s));\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync mask_size, src_param.param_str, src_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "%s == 0.0 ? FLT_MAX : 1.0 / %s);\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_rsq(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync mask_size = shader_glsl_get_write_mask_size(write_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_3, &src_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "vec%d(%s == 0.0 ? FLT_MAX : inversesqrt(abs(%s))));\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync mask_size, src_param.param_str, src_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "%s == 0.0 ? FLT_MAX : inversesqrt(abs(%s)));\n",
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsyncstatic void shader_glsl_setp(const struct wined3d_shader_instruction *ins)
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync /* Cycle through all source0 channels */
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync for (i=0; i<4; i++) {
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync write_mask = shader_glsl_append_dst_ext(ins->ctx->buffer, ins, &dst);
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src_param1);
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src_param2);
d200be7337d4aad2bec2961a885e856f7866d4f6vboxsync src_param1.param_str, shader_get_comp_op(ins->flags), src_param2.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process signed comparison opcodes in GLSL. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_compare(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync mask_size = shader_glsl_get_write_mask_size(write_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync case WINED3DSIH_SGE: compare = "greaterThanEqual"; break;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("Can't handle opcode %#x\n", ins->handler_idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "vec%d(%s(%s, %s)));\n", mask_size, compare,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Step(src0, src1) is not suitable here because if src0 == src1 SLT is supposed,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * to return 0.0 but step returns 1.0 because step is not < x
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * An alternative is a bvec compare padded with an unused second component.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * step(src1 * -1.0, src0 * -1.0) is not an option because it suffers from the same
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * issue. Playing with not() is not possible either because not() does not accept
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * a scalar.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "(%s < %s) ? 1.0 : 0.0);\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Here we can use the step() function and safe a conditional */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "step(%s, %s));\n", src1_param.param_str, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("Can't handle opcode %#x\n", ins->handler_idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process CMP instruction in GLSL (dst = src0 >= 0.0 ? src1 : src2), per channel */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_cmp(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync unsigned int i, j;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[2], write_mask, &src2_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "%s >= 0.0 ? %s : %s);\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync src0_param.param_str, src1_param.param_str, src2_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Cycle through all source0 channels */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i=0; i<4; i++) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Find the destination channels which use the current source0 channel */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (j=0; j<4; j++) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Splitting the cmp instruction up in multiple lines imposes a problem:
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * The first lines may overwrite source parameters of the following lines.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Deal with that by using a temporary destination register if needed
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync write_mask = shader_glsl_get_write_mask(&dst, mask_char);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (!write_mask) continue;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "tmp0%s = (", mask_char);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync write_mask = shader_glsl_append_dst_ext(ins->ctx->buffer, ins, &dst);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (!write_mask) continue;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], cmp_channel, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[2], write_mask, &src2_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "%s >= 0.0 ? %s : %s);\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync src0_param.param_str, src1_param.param_str, src2_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_write_mask(&ins->dst[0], mask_char);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "tmp0%s);\n", mask_char);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the CND opcode in GLSL (dst = (src0 > 0.5) ? src1 : src2) */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* For ps 1.1-1.3, only a single component of src0 is used. For ps 1.4
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * the compare is done per component of src0. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_cnd(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync unsigned int i, j;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[2], write_mask, &src2_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Fun: The D3DSI_COISSUE flag changes the semantic of the cnd instruction for < 1.4 shaders */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "%s /* COISSUE! */);\n", src1_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "%s > 0.5 ? %s : %s);\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync src0_param.param_str, src1_param.param_str, src2_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Cycle through all source0 channels */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i=0; i<4; i++) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Find the destination channels which use the current source0 channel */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (j=0; j<4; j++) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync write_mask = shader_glsl_append_dst_ext(ins->ctx->buffer, ins, &dst);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (!write_mask) continue;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], cmp_channel, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[2], write_mask, &src2_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "%s > 0.5 ? %s : %s);\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync src0_param.param_str, src1_param.param_str, src2_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** GLSL code generation for WINED3DSIO_MAD: Multiply the first 2 opcodes, then add the last */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_mad(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[2], write_mask, &src2_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "(%s * %s) + %s);\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync src0_param.param_str, src1_param.param_str, src2_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Handles transforming all WINED3DSIO_M?x? opcodes for
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync Vertex shaders to GLSL codes */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_mnxn(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_src_param tmp_src[2] = {{{0}}};
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Set constants for the temporary argument */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0; i < nComponents; ++i)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync The LRP instruction performs a component-wise linear interpolation
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync between the second and third operands using the first operand as the
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync blend factor. Equation: (dst = src2 + src0 * (src1 - src2))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync This is equivalent to mix(src2, src1, src0);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_lrp(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], write_mask, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[2], write_mask, &src2_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "mix(%s, %s, %s));\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync src2_param.param_str, src1_param.param_str, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_LIT instruction in GLSL:
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.x = dst.w = 1.0
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.y = (src0.x > 0) ? src0.x
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.z = (src0.x > 0) ? ((src0.y > 0) ? pow(src0.y, src.w) : 0) : 0
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * where src.w is clamped at +- 128
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_lit(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_1, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_3, &src3_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* The sdk specifies the instruction like this
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.x = 1.0;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * if(src.x > 0.0) dst.y = src.x
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * else dst.y = 0.0.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * if(src.x > 0.0 && src.y > 0.0) dst.z = pow(src.y, power);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * else dst.z = 0.0;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.w = 1.0;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Obviously that has quite a few conditionals in it which we don't like. So the first step is this:
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.x = 1.0 ... No further explanation needed
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.y = max(src.y, 0.0); ... If x < 0.0, use 0.0, otherwise x. Same as the conditional
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.z = x > 0.0 ? pow(max(y, 0.0), p) : 0; ... 0 ^ power is 0, and otherwise we use y anyway
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.w = 1.0. ... Nothing fancy.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * So we still have one conditional in there. So do this:
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.z = pow(max(0.0, src.y) * step(0.0, src.x), power);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * 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),
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * 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.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * if both x and y are > 0, we get pow(y * 1.0, power), as it is supposed to
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "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",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync src0_param.param_str, src1_param.param_str, src0_param.param_str, src3_param.param_str, dst_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_DST instruction in GLSL:
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.x = 1.0
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.y = src0.x * src0.y
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.z = src0.z
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.w = src1.w
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_dst(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_1, &src0y_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_2, &src0z_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_1, &src1y_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_3, &src1w_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "vec4(1.0, %s * %s, %s, %s))%s;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync src0y_param.param_str, src1y_param.param_str, src0z_param.param_str, src1w_param.param_str, dst_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_SINCOS instruction in GLSL:
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * VS 2.0 requires that specific cosine and sine constants be passed to this instruction so the hardware
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * can handle it. But, these functions are built-in for GLSL, so we can just ignore the last 2 params.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.x = cos(src0.?)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.y = sin(src0.?)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.z = dst.z
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst.w = dst.w
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_sincos(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "cos(%s));\n", src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "sin(%s));\n", src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync case (WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1):
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "vec2(cos(%s), sin(%s)));\n", src0_param.param_str, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* sgn in vs_2_0 has 2 extra parameters(registers for temporary storage) which we don't use
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * here. But those extra parameters require a dedicated function for sgn, since map2gl would
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * generate invalid code
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_sgn(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], write_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "sign(%s));\n", src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_LOOP instruction in GLSL:
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Start a for() loop where src1.y is the initial value of aL,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * increment aL by src1.z for a total of src1.x iterations.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Need to use a temporary variable for this operation.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* FIXME: I don't think nested loops will work correctly this way. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_loop(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_ALL, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Try to hardcode the loop control parameters if possible. Direct3D 9 class hardware doesn't support real
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * varying indexing, but Microsoft designed this feature for Shader model 2.x+. If the loop control is
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * known at compile time, the GLSL compiler can unroll the loop, and replace indirect addressing with direct
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * addressing.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync LIST_FOR_EACH_ENTRY(constant, &shader->baseShader.constantsI, local_constant, entry) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "for (aL%u = %u; aL%u < (%u * %d + %u); aL%u += %d) {\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader->baseShader.cur_loop_depth, loop_control.start,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader->baseShader.cur_loop_depth, loop_control.count, loop_control.step, loop_control.start,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader->baseShader.cur_loop_depth, loop_control.step);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "for (aL%u = %u; aL%u > (%u * %d + %u); aL%u += %d) {\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader->baseShader.cur_loop_depth, loop_control.start,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader->baseShader.cur_loop_depth, loop_control.count, loop_control.step, loop_control.start,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader->baseShader.cur_loop_depth, loop_control.step);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "for (aL%u = %u, tmpInt%u = 0; tmpInt%u < %u; tmpInt%u++) {\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader->baseShader.cur_loop_depth, loop_control.start, shader->baseShader.cur_loop_depth,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader->baseShader.cur_loop_depth, loop_control.count,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "for (tmpInt%u = 0, aL%u = %s.y; tmpInt%u < %s.x; tmpInt%u++, aL%u += %s.z) {\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_regno,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync src1_param.reg_name, shader->baseShader.cur_loop_depth, src1_param.reg_name,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_regno, src1_param.reg_name);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_end(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_rep(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Try to hardcode local values to help the GLSL compiler to unroll and optimize the loop */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync LIST_FOR_EACH_ENTRY(constant, &shader->baseShader.constantsI, local_constant, entry)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "for (tmpInt%d = 0; tmpInt%d < %d; tmpInt%d++) {\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_depth,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync control_values[0], shader->baseShader.cur_loop_depth);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "for (tmpInt%d = 0; tmpInt%d < %s; tmpInt%d++) {\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader->baseShader.cur_loop_depth, shader->baseShader.cur_loop_depth,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync src0_param.param_str, shader->baseShader.cur_loop_depth);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_if(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "if (%s) {\n", src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_ifc(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_0, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "if (%s %s %s) {\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync src0_param.param_str, shader_get_comp_op(ins->flags), src1_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_else(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_break(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* FIXME: According to MSDN the compare is done per component. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_breakc(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_0, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "if (%s %s %s) break;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync src0_param.param_str, shader_get_comp_op(ins->flags), src1_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_label(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "void subroutine%u () {\n", ins->src[0].reg.idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_call(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "subroutine%u();\n", ins->src[0].reg.idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_callnz(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_0, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "if (%s) subroutine%u();\n", src1_param.param_str, ins->src[0].reg.idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_ret(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* No-op. The closing } is written when a new function is started, and at the end of the shader. This
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * function only suppresses the unhandled instruction warning
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/*********************************************
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Pixel Shader Specific Code begins here
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ********************************************/
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_tex(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DDeviceImpl *deviceImpl = (IWineD3DDeviceImpl *)shader->baseShader.device;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD shader_version = WINED3D_SHADER_VERSION(ins->ctx->reg_maps->shader_version.major,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* 1.0-1.4: Use destination register as sampler source.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * 2.0+: Use provided sampler source. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (shader_version < WINED3D_SHADER_VERSION(2,0)) sampler_idx = ins->dst[0].reg.idx;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sampler_type = ins->ctx->reg_maps->sampler_type[sampler_idx];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD flags = (priv->cur_ps_args->tex_transform >> (sampler_idx * WINED3D_PSARGS_TEXTRANSFORM_SHIFT))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Projected cube textures don't make a lot of sense, the resulting coordinates stay the same. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (flags & WINED3D_PSARGS_PROJECTED && sampler_type != WINED3DSTT_CUBE) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync case WINED3DTTFF_COUNT1: FIXME("WINED3DTTFF_PROJECTED with WINED3DTTFF_COUNT1?\n"); break;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync case WINED3DTTFF_COUNT2: mask = WINED3DSP_WRITEMASK_1; break;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync case WINED3DTTFF_COUNT3: mask = WINED3DSP_WRITEMASK_2; break;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync case WINED3DTTFF_DISABLE: mask = WINED3DSP_WRITEMASK_3; break;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else if (shader_version < WINED3D_SHADER_VERSION(2,0))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* ps 2.0 texldp instruction always divides by the fourth component. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if(deviceImpl->stateBlock->textures[sampler_idx] &&
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseTexture_GetTextureDimensions(deviceImpl->stateBlock->textures[sampler_idx]) == GL_TEXTURE_RECTANGLE_ARB) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_sample_function(gl_info, sampler_type, sample_flags, &sample_function);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (shader_version < WINED3D_SHADER_VERSION(2,0)) swizzle = WINED3DSP_NOSWIZZLE;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* 1.0-1.3: Use destination register as coordinate source.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync 1.4+: Use provided coordinate source register. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, swizzle, NULL, NULL, NULL,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], mask, &coord_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_3, &bias);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, swizzle, NULL, NULL, bias.param_str,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, swizzle, NULL, NULL, NULL,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texldd(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (!gl_info->supported[ARB_SHADER_TEXTURE_LOD] && !gl_info->supported[EXT_GPU_SHADER4])
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("texldd used, but not supported by hardware. Falling back to regular tex\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sampler_type = ins->ctx->reg_maps->sampler_type[sampler_idx];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if(deviceImpl->stateBlock->textures[sampler_idx] &&
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseTexture_GetTextureDimensions(deviceImpl->stateBlock->textures[sampler_idx]) == GL_TEXTURE_RECTANGLE_ARB) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_sample_function(gl_info, sampler_type, sample_flags, &sample_function);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], sample_function.coord_mask, &coord_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[2], sample_function.coord_mask, &dx_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[3], sample_function.coord_mask, &dy_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, swizzle, dx_param.param_str, dy_param.param_str, NULL,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texldl(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DDeviceImpl* deviceImpl = (IWineD3DDeviceImpl*) This->baseShader.device;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sampler_type = ins->ctx->reg_maps->sampler_type[sampler_idx];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if(deviceImpl->stateBlock->textures[sampler_idx] &&
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseTexture_GetTextureDimensions(deviceImpl->stateBlock->textures[sampler_idx]) == GL_TEXTURE_RECTANGLE_ARB) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_sample_function(gl_info, sampler_type, sample_flags, &sample_function);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], sample_function.coord_mask, &coord_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_3, &lod_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (!gl_info->supported[ARB_SHADER_TEXTURE_LOD] && !gl_info->supported[EXT_GPU_SHADER4]
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync && shader_is_pshader_version(ins->ctx->reg_maps->shader_version.type))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* The GLSL spec claims the Lod sampling functions are only supported in vertex shaders.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * However, they seem to work just fine in fragment shaders as well. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WARN("Using %s in fragment shader.\n", sample_function.name);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, swizzle, NULL, NULL, lod_param.param_str,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texcoord(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* FIXME: Make this work for more than just 2D textures */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (!(ins->ctx->reg_maps->shader_version.major == 1 && ins->ctx->reg_maps->shader_version.minor == 4))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "clamp(gl_TexCoord[%u], 0.0, 1.0)%s);\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_swizzle(&ins->src[0], FALSE, write_mask, dst_swizzle);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_2, &div_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_TexCoord[%u]%s / vec%d(%s));\n", reg, dst_swizzle, mask_size, div_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_TexCoord[%u]%s / %s);\n", reg, dst_swizzle, div_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync unsigned int mask_size = shader_glsl_get_write_mask_size(write_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_3, &div_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_TexCoord[%u]%s / vec%d(%s));\n", reg, dst_swizzle, mask_size, div_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_TexCoord[%u]%s / %s);\n", reg, dst_swizzle, div_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_TexCoord[%u]%s);\n", reg, dst_swizzle);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_TEXDP3TEX instruction in GLSL:
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Take a 3-component dot product of the TexCoord[dstreg] and src,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * then perform a 1D texture lookup from stage dstregnum, place into dst. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texdp3tex(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WINED3DSAMPLER_TEXTURE_TYPE sampler_type = ins->ctx->reg_maps->sampler_type[sampler_idx];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Do I have to take care about the projected bit? I don't think so, since the dp3 returns only one
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * scalar, and projected sampling would require 4.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * It is a dependent read - not valid with conditional NP2 textures
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_sample_function(gl_info, sampler_type, 0, &sample_function);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync mask_size = shader_glsl_get_write_mask_size(sample_function.coord_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "dot(gl_TexCoord[%u].xyz, %s)", sampler_idx, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "vec2(dot(gl_TexCoord[%u].xyz, %s), 0.0)", sampler_idx, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "vec3(dot(gl_TexCoord[%u].xyz, %s), 0.0, 0.0)", sampler_idx, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_TEXDP3 instruction in GLSL:
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Take a 3-component dot product of the TexCoord[dstreg] and src. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texdp3(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync dst_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync mask_size = shader_glsl_get_write_mask_size(dst_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "vec%d(dot(T%u.xyz, %s)));\n", mask_size, dstreg, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "dot(T%u.xyz, %s));\n", dstreg, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_TEXDEPTH instruction in GLSL:
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Calculate the depth as dst.x / dst.y */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texdepth(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_dst_param(ins, &ins->dst[0], &dst_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Tests show that texdepth never returns anything below 0.0, and that r5.y is clamped to 1.0.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Negative input is accepted, -0.25 / -0.5 returns 0.5. GL should clamp gl_FragDepth to [0;1], but
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * this doesn't always work, so clamp the results manually. Whether or not the x value is clamped at 1
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * too is irrelevant, since if x = 0, any y value < 1.0 (and > 1.0 is not allowed) results in a result
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * >= 1.0 or < 0.0
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "gl_FragDepth = clamp((%s.x / min(%s.y, 1.0)), 0.0, 1.0);\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_TEXM3X2DEPTH instruction in GLSL:
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Last row of a 3x2 matrix multiply, use the result to calculate the depth:
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Calculate tmp0.y = TexCoord[dstreg] . src.xyz; (tmp0.x has already been calculated)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * depth = (tmp0.y == 0.0) ? 1.0 : tmp0.x / tmp0.y
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texm3x2depth(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "tmp0.y = dot(T%u.xyz, %s);\n", dstreg, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "gl_FragDepth = (tmp0.y == 0.0) ? 1.0 : clamp(tmp0.x / tmp0.y, 0.0, 1.0);\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_TEXM3X2PAD instruction in GLSL
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Calculate the 1st of a 2-row matrix multiplication. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texm3x2pad(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "tmp0.x = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_TEXM3X3PAD instruction in GLSL
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Calculate the 1st or 2nd row of a 3-row matrix multiplication. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texm3x3pad(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "tmp0.%c = dot(T%u.xyz, %s);\n", 'x' + current_state->current_row, reg, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync current_state->texcoord_w[current_state->current_row++] = reg;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texm3x2tex(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WINED3DSAMPLER_TEXTURE_TYPE sampler_type = ins->ctx->reg_maps->sampler_type[reg];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "tmp0.y = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_sample_function(gl_info, sampler_type, 0, &sample_function);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Sample the texture using the calculated coordinates */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_gen_sample_code(ins, reg, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL, "tmp0.xy");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_TEXM3X3TEX instruction in GLSL
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Perform the 3rd row of a 3x3 matrix multiply, then sample the texture using the calculated coordinates */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texm3x3tex(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync SHADER_PARSE_STATE *current_state = &shader->baseShader.parse_state;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WINED3DSAMPLER_TEXTURE_TYPE sampler_type = ins->ctx->reg_maps->sampler_type[reg];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "tmp0.z = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Dependent read, not valid with conditional NP2 */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_sample_function(gl_info, sampler_type, 0, &sample_function);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Sample the texture using the calculated coordinates */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_gen_sample_code(ins, reg, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL, "tmp0.xyz");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_TEXM3X3 instruction in GLSL
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Perform the 3rd row of a 3x3 matrix multiply */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texm3x3(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync SHADER_PARSE_STATE *current_state = &shader->baseShader.parse_state;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_write_mask(&ins->dst[0], dst_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "vec4(tmp0.xy, dot(T%u.xyz, %s), 1.0)%s);\n", reg, src0_param.param_str, dst_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Process the WINED3DSIO_TEXM3X3SPEC instruction in GLSL
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Perform the final texture lookup based on the previous 2 3x3 matrix multiplies */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texm3x3spec(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WINED3DSAMPLER_TEXTURE_TYPE stype = ins->ctx->reg_maps->sampler_type[reg];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], src_mask, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Perform the last matrix multiply operation */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "tmp0.z = dot(T%u.xyz, %s);\n", reg, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Reflection calculation */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "tmp0.xyz = -reflect((%s), normalize(tmp0.xyz));\n", src1_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Dependent read, not valid with conditional NP2 */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_sample_function(gl_info, stype, 0, &sample_function);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Sample the texture */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_gen_sample_code(ins, reg, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL, "tmp0.xyz");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Process the WINED3DSIO_TEXM3X3VSPEC instruction in GLSL
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Perform the final texture lookup based on the previous 2 3x3 matrix multiplies */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texm3x3vspec(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer = ins->ctx->buffer;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync SHADER_PARSE_STATE* current_state = &shader->baseShader.parse_state;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD src_mask = WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1 | WINED3DSP_WRITEMASK_2;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WINED3DSAMPLER_TEXTURE_TYPE sampler_type = ins->ctx->reg_maps->sampler_type[reg];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], src_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Perform the last matrix multiply operation */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "tmp0.z = dot(vec3(T%u), vec3(%s));\n", reg, src0_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Construct the eye-ray vector from w coordinates */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "tmp1.xyz = normalize(vec3(gl_TexCoord[%u].w, gl_TexCoord[%u].w, gl_TexCoord[%u].w));\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync current_state->texcoord_w[0], current_state->texcoord_w[1], reg);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "tmp0.xyz = -reflect(tmp1.xyz, normalize(tmp0.xyz));\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Dependent read, not valid with conditional NP2 */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_sample_function(gl_info, sampler_type, 0, &sample_function);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Sample the texture using the calculated coordinates */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_gen_sample_code(ins, reg, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL, "tmp0.xyz");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_TEXBEM instruction in GLSL.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Apply a fake bump map transform.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * texbem is pshader <= 1.3 only, this saves a few version checks
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texbem(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseShaderImpl *shader = (IWineD3DBaseShaderImpl *)ins->ctx->shader;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DDeviceImpl *deviceImpl = (IWineD3DDeviceImpl *)shader->baseShader.device;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct shader_glsl_ctx_priv *priv = ins->ctx->backend_data;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync flags = (priv->cur_ps_args->tex_transform >> (sampler_idx * WINED3D_PSARGS_TEXTRANSFORM_SHIFT))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sampler_type = ins->ctx->reg_maps->sampler_type[sampler_idx];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Dependent read, not valid with conditional NP2 */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_sample_function(gl_info, sampler_type, 0, &sample_function);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* with projective textures, texbem only divides the static texture coord, not the displacement,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * so we can't let the GL handle this.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync case WINED3DTTFF_COUNT1: FIXME("WINED3DTTFF_PROJECTED with WINED3DTTFF_COUNT1?\n"); break;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync case WINED3DTTFF_COUNT2: div_mask = WINED3DSP_WRITEMASK_1; break;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync case WINED3DTTFF_COUNT3: div_mask = WINED3DSP_WRITEMASK_2; break;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync case WINED3DTTFF_DISABLE: div_mask = WINED3DSP_WRITEMASK_3; break;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_write_mask_to_str(div_mask, coord_div_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "T%u%s /= T%u%s;\n", sampler_idx, coord_mask, sampler_idx, coord_div_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &coord_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "T%u%s + vec4(bumpenvmat%d * %s, 0.0, 0.0)%s", sampler_idx, coord_mask, sampler_idx,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_2, &luminance_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_dst_param(ins, &ins->dst[0], &dst_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "%s%s *= (%s * luminancescale%d + luminanceoffset%d);\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync luminance_param.param_str, sampler_idx, sampler_idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_bem(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "%s + bumpenvmat%d * %s);\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync src0_param.param_str, sampler_idx, src1_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_TEXREG2AR instruction in GLSL
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Sample 2D texture at dst using the alpha & red (wx) components of src as texture coordinates */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texreg2ar(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WINED3DSAMPLER_TEXTURE_TYPE sampler_type = ins->ctx->reg_maps->sampler_type[sampler_idx];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_sample_function(gl_info, sampler_type, 0, &sample_function);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_TEXREG2GB instruction in GLSL
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Sample 2D texture at dst using the green & blue (yz) components of src as texture coordinates */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texreg2gb(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WINED3DSAMPLER_TEXTURE_TYPE sampler_type = ins->ctx->reg_maps->sampler_type[sampler_idx];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_ALL, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_sample_function(gl_info, sampler_type, 0, &sample_function);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_TEXREG2RGB instruction in GLSL
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Sample texture at dst using the rgb (xyz) components of src as texture coordinates */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texreg2rgb(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = ins->ctx->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WINED3DSAMPLER_TEXTURE_TYPE sampler_type = ins->ctx->reg_maps->sampler_type[sampler_idx];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Dependent read, not valid with conditional NP2 */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_get_sample_function(gl_info, sampler_type, 0, &sample_function);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], sample_function.coord_mask, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_gen_sample_code(ins, sampler_idx, &sample_function, WINED3DSP_NOSWIZZLE, NULL, NULL, NULL,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_TEXKILL instruction in GLSL.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * If any of the first 3 components are < 0, discard this pixel */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_texkill(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* The argument is a destination parameter, and no writemasks are allowed */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_dst_param(ins, &ins->dst[0], &dst_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* 2.0 shaders compare all 4 components in texkill */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "if (any(lessThan(%s.xyzw, vec4(0.0)))) discard;\n", dst_param.reg_name);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* 1.X shaders only compare the first 3 components, probably due to the nature of the texkill
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * instruction as a tex* instruction, and phase, which kills all a / w components. Even if all
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * 4 components are defined, only the first 3 are used
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "if (any(lessThan(%s.xyz, vec3(0.0)))) discard;\n", dst_param.reg_name);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Process the WINED3DSIO_DP2ADD instruction in GLSL.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * dst = dot2(src0, src1) + src2 */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_dp2add(const struct wined3d_shader_instruction *ins)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync write_mask = shader_glsl_append_dst(ins->ctx->buffer, ins);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync mask_size = shader_glsl_get_write_mask_size(write_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[0], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src0_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[1], WINED3DSP_WRITEMASK_0 | WINED3DSP_WRITEMASK_1, &src1_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_add_src_param(ins, &ins->src[2], WINED3DSP_WRITEMASK_0, &src2_param);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "vec%d(dot(%s, %s) + %s));\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync mask_size, src0_param.param_str, src1_param.param_str, src2_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(ins->ctx->buffer, "dot(%s, %s) + %s);\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync src0_param.param_str, src1_param.param_str, src2_param.param_str);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_input_pack(IWineD3DPixelShader *iface, struct wined3d_shader_buffer *buffer,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_shader_signature_element *input_signature, const struct shader_reg_maps *reg_maps,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync unsigned int i;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DPixelShaderImpl *This = (IWineD3DPixelShaderImpl *)iface;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Unused */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_write_mask_to_str(input_signature[i].mask, reg_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (shader_match_semantic(semantic_name, WINED3DDECLUSAGE_TEXCOORD))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (semantic_idx < 8 && vertexprocessing == pretransformed)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "IN[%u]%s = gl_TexCoord[%u]%s;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync This->input_reg_map[i], reg_mask, semantic_idx, reg_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else if (shader_match_semantic(semantic_name, WINED3DDECLUSAGE_COLOR))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "IN[%u]%s = vec4(gl_Color)%s;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "IN[%u]%s = vec4(gl_SecondaryColor)%s;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "IN[%u]%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/*********************************************
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Vertex Shader Specific Code begins here
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ********************************************/
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void add_glsl_program_entry(struct shader_glsl_priv *priv, struct glsl_shader_prog_link *entry) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (wine_rb_put(&priv->program_lookup, &key, &entry->program_lookup_entry) == -1)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic struct glsl_shader_prog_link *get_glsl_program_entry(struct shader_glsl_priv *priv,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DVertexShader *vshader, IWineD3DPixelShader *pshader, struct vs_compile_args *vs_args,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct ps_compile_args *ps_args, const struct wined3d_context *context) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync return entry ? WINE_RB_ENTRY_VALUE(entry, struct glsl_shader_prog_link, program_lookup_entry) : NULL;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void delete_glsl_program_entry(struct shader_glsl_priv *priv, const struct wined3d_gl_info *gl_info,
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync TRACE("deleting program %p\n", (void *)(uintptr_t)entry->programId);
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync WARN("Attempting to delete program %p created in ctx %p from ctx %p\n", (void *)(uintptr_t)entry->programId, entry->context, context_get_current());
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (entry->vshader) list_remove(&entry->vshader_entry);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (entry->pshader) list_remove(&entry->pshader_entry);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync HeapFree(GetProcessHeap(), 0, entry->vuniformF_locations);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync HeapFree(GetProcessHeap(), 0, entry->puniformF_locations);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void handle_ps3_input(struct wined3d_shader_buffer *buffer, const struct wined3d_gl_info *gl_info, const DWORD *map,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_shader_signature_element *input_signature, const struct shader_reg_maps *reg_maps_in,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_shader_signature_element *output_signature, const struct shader_reg_maps *reg_maps_out)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync unsigned int i, j;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync set = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*set) * (in_count + 2));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Save gl_FrontColor & gl_FrontSecondaryColor before overwriting them. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "vec4 front_color = gl_FrontColor;\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "vec4 front_secondary_color = gl_FrontSecondaryColor;\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("More input varyings declared than supported, expect issues\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else if (map[i] == ~0U)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Declared, but not read register */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync semantic_name_in = input_signature[i].semantic_name;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_write_mask_to_str(input_signature[i].mask, reg_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (shader_match_semantic(semantic_name_in, WINED3DDECLUSAGE_COLOR))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "%s%s = front_secondary_color%s;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "%s%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else if (shader_match_semantic(semantic_name_in, WINED3DDECLUSAGE_TEXCOORD))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "%s%s = gl_TexCoord[%u]%s;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "%s%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else if (shader_match_semantic(semantic_name_in, WINED3DDECLUSAGE_FOG))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "%s%s = vec4(gl_FogFragCoord, 0.0, 0.0, 0.0)%s;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "%s%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync semantic_name_out = output_signature[j].semantic_name;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync semantic_idx_out = output_signature[j].semantic_idx;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_write_mask_to_str(output_signature[j].mask, reg_mask_out);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "%s%s = vec4(0.0, 0.0, 0.0, 0.0)%s;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* This is solely to make the compiler / linker happy and avoid warning about undefined
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * varyings. It shouldn't result in any real code executed on the GPU, since all read
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * input varyings are assigned above, if the optimizer works properly.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "%s.%s = 0.0;\n", destination, reg_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "%s.%s = vec%u(0.0);\n", destination, reg_mask, size);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void generate_texcoord_assignment(struct wined3d_shader_buffer *buffer, IWineD3DVertexShaderImpl *vs, IWineD3DPixelShaderImpl *ps)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync unsigned int i;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0, map = ps->baseShader.reg_maps.texcoord; map && i < min(8, MAX_REG_TEXCRD); map >>= 1, ++i)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* so far we assume that if texcoord_mask has any write flags, they are assigned appropriately with pixel shader */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if ((vs->baseShader.reg_maps.texcoord_mask[i]) & WINED3DSP_WRITEMASK_ALL)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_write_mask_to_str(WINED3DSP_WRITEMASK_ALL, reg_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_TexCoord[%u]%s = gl_MultiTexCoord%u%s;\n", i, reg_mask, i, reg_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic GLhandleARB generate_param_reorder_function(struct wined3d_shader_buffer *buffer,
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync IWineD3DVertexShader *a_vertexshader, IWineD3DPixelShader *pixelshader, const struct wined3d_gl_info *gl_info)
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync IWineD3DVertexShaderImpl *vs = (IWineD3DVertexShaderImpl *) a_vertexshader;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DPixelShaderImpl *ps = (IWineD3DPixelShaderImpl *) pixelshader;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD vs_major = vs->baseShader.reg_maps.shader_version.major;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD ps_major = ps ? ps->baseShader.reg_maps.shader_version.major : 0;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync unsigned int i;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_shader_signature_element *output_signature;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* That one is easy: The vertex shader writes to the builtin varyings, the pixel shader reads from them.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Take care about the texcoord .w fixup though if we're using the fixed function fragment pipeline
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync device = (IWineD3DDeviceImpl *) vs->baseShader.device;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if ((gl_info->quirks & WINED3D_QUIRK_SET_TEXCOORD_W)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync && ps_major == 0 && vs_major > 0 && !device->frag_pipe->ffp_proj_control)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "void order_ps_input() {\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if(vs->baseShader.reg_maps.texcoord_mask[i] != 0 &&
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync vs->baseShader.reg_maps.texcoord_mask[i] != WINED3DSP_WRITEMASK_ALL) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_TexCoord[%u].w = 1.0;\n", i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "void order_ps_input() {\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WORD map = vs->baseShader.reg_maps.output_registers;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* The vertex shader writes to its own varyings, the pixel shader needs them in the builtin ones */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync output_signature = vs->baseShader.output_signature;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "void order_ps_input(in vec4 OUT[%u]) {\n", MAX_REG_OUTPUT);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_write_mask_to_str(write_mask, reg_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (shader_match_semantic(semantic_name, WINED3DDECLUSAGE_COLOR))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_FrontColor%s = OUT[%u]%s;\n", reg_mask, i, reg_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_FrontSecondaryColor%s = OUT[%u]%s;\n", reg_mask, i, reg_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else if (shader_match_semantic(semantic_name, WINED3DDECLUSAGE_POSITION))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_Position%s = OUT[%u]%s;\n", reg_mask, i, reg_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else if (shader_match_semantic(semantic_name, WINED3DDECLUSAGE_TEXCOORD))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (!(gl_info->quirks & WINED3D_QUIRK_SET_TEXCOORD_W) || ps_major > 0)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_TexCoord[%u]%s = OUT[%u]%s;\n",
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_TexCoord[%u].w = 1.0;\n", semantic_idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else if (shader_match_semantic(semantic_name, WINED3DDECLUSAGE_PSIZE))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_PointSize = OUT[%u].x;\n", i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else if (shader_match_semantic(semantic_name, WINED3DDECLUSAGE_FOG))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_FogFragCoord = OUT[%u].%c;\n", i, reg_mask[1]);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WORD map = vs->baseShader.reg_maps.output_registers;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync output_signature = vs->baseShader.output_signature;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* This one is tricky: a 3.0 pixel shader reads from a 3.0 vertex shader */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "varying vec4 IN[%u];\n", vec4_varyings(3, gl_info));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "void order_ps_input(in vec4 OUT[%u]) {\n", MAX_REG_OUTPUT);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* First, sort out position and point size. Those are not passed to the pixel shader */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_write_mask_to_str(output_signature[i].mask, reg_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (shader_match_semantic(semantic_name, WINED3DDECLUSAGE_POSITION))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_Position%s = OUT[%u]%s;\n", reg_mask, i, reg_mask);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else if (shader_match_semantic(semantic_name, WINED3DDECLUSAGE_PSIZE))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_PointSize = OUT[%u].x;\n", i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Then, fix the pixel shader input */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync handle_ps3_input(buffer, gl_info, ps->input_reg_map, ps->baseShader.input_signature,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync &ps->baseShader.reg_maps, output_signature, &vs->baseShader.reg_maps);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "varying vec4 IN[%u];\n", vec4_varyings(3, gl_info));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "void order_ps_input() {\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* The vertex shader wrote to the builtin varyings. There is no need to figure out position and
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * point size, but we depend on the optimizers kindness to find out that the pixel shader doesn't
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * read gl_TexCoord and gl_ColorX, otherwise we'll run out of varyings
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync handle_ps3_input(buffer, gl_info, ps->input_reg_map, ps->baseShader.input_signature,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ERR("Unexpected vertex and pixel shader version condition: vs: %d, ps: %d\n", vs_major, ps_major);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ret = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync checkGLcall("glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB)");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glShaderSourceARB(ret, 1, (const char**)&buffer->buffer, NULL));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync checkGLcall("glShaderSourceARB(ret, 1, &buffer->buffer, NULL)");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_validate_compile_link(gl_info, ret, FALSE);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void hardcode_local_constants(IWineD3DBaseShaderImpl *shader, const struct wined3d_gl_info *gl_info,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync LIST_FOR_EACH_ENTRY(lconst, &shader->baseShader.constantsF, local_constant, entry) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync snprintf(glsl_name, sizeof(glsl_name), "%cLC%u", prefix, lconst->idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync tmp_loc = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsyncstatic GLhandleARB shader_glsl_generate_pshader(const struct wined3d_context *context,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic GLuint shader_glsl_generate_pshader(const struct wined3d_context *context,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer, IWineD3DPixelShaderImpl *This,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct ps_compile_args *args, struct ps_np2fixup_info *np2fixup_info)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct shader_reg_maps *reg_maps = &This->baseShader.reg_maps;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Create the hw GLSL shader object and assign it as the shader->prgId */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GLhandleARB shader_obj = GL_EXTCALL(glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (gl_info->supported[ARB_SHADER_TEXTURE_LOD] && reg_maps->usestexldd)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "#extension GL_ARB_shader_texture_lod : enable\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* The spec says that it doesn't have to be explicitly enabled, but the nvidia
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * drivers write a warning if we don't do so
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "#extension GL_ARB_texture_rectangle : enable\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "#extension GL_EXT_gpu_shader4 : enable\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Base Declarations */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_generate_glsl_declarations(context, buffer, (IWineD3DBaseShader *)This, reg_maps, &priv_ctx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Pack 3.0 inputs */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (reg_maps->shader_version.major >= 3 && args->vp_mode != vertexshader)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_input_pack((IWineD3DPixelShader *) This, buffer,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync This->baseShader.input_signature, reg_maps, args->vp_mode);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Base Shader Body */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_generate_main((IWineD3DBaseShader *)This, buffer, reg_maps, function, &priv_ctx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Pixel shaders < 2.0 place the resulting color in R0 implicitly */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Some older cards like GeforceFX ones don't support multiple buffers, so also not gl_FragData */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "tmp0.xyz = pow(gl_FragData[0].xyz, vec3(srgb_const0.x));\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "tmp0.xyz = tmp0.xyz * vec3(srgb_const0.y) - vec3(srgb_const0.z);\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "tmp1.xyz = gl_FragData[0].xyz * vec3(srgb_const0.w);\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "bvec3 srgb_compare = lessThan(gl_FragData[0].xyz, vec3(srgb_const1.x));\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_FragData[0].xyz = mix(tmp0.xyz, tmp1.xyz, vec3(srgb_compare));\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_FragData[0] = clamp(gl_FragData[0], 0.0, 1.0);\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Pixel shader < 3.0 do not replace the fog stage.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * This implements linear fog computation and blending.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * TODO: non linear fog
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * NOTE: gl_Fog.start and gl_Fog.end don't hold fog start s and end e but
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * -1/(e-s) and e/(e-s) respectively.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync case FOG_OFF: break;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "float fogstart = -1.0 / (gl_Fog.end - gl_Fog.start);\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "float fogend = gl_Fog.end * -fogstart;\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "float Fog = clamp(gl_FogFragCoord * fogstart + fogend, 0.0, 1.0);\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_FragData[0].xyz = mix(gl_Fog.color.xyz, gl_FragData[0].xyz, Fog);\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Fog = e^(-gl_Fog.density * gl_FogFragCoord) */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "float Fog = exp(-gl_Fog.density * gl_FogFragCoord);\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "Fog = clamp(Fog, 0.0, 1.0);\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_FragData[0].xyz = mix(gl_Fog.color.xyz, gl_FragData[0].xyz, Fog);\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Fog = e^(-(gl_Fog.density * gl_FogFragCoord)^2) */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "float Fog = exp(-gl_Fog.density * gl_Fog.density * gl_FogFragCoord * gl_FogFragCoord);\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "Fog = clamp(Fog, 0.0, 1.0);\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_FragData[0].xyz = mix(gl_Fog.color.xyz, gl_FragData[0].xyz, Fog);\n");
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync TRACE("Compiling shader object %p\n", (void *)(uintptr_t)shader_obj);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glShaderSourceARB(shader_obj, 1, (const char**)&buffer->buffer, NULL));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_validate_compile_link(gl_info, shader_obj, FALSE);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Store the shader object */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsyncstatic GLhandleARB shader_glsl_generate_vshader(const struct wined3d_context *context,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic GLuint shader_glsl_generate_vshader(const struct wined3d_context *context,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer, IWineD3DVertexShaderImpl *This,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct shader_reg_maps *reg_maps = &This->baseShader.reg_maps;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Create the hw GLSL shader program and assign it as the shader->prgId */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GLhandleARB shader_obj = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "#extension GL_EXT_gpu_shader4 : enable\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Base Declarations */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_generate_glsl_declarations(context, buffer, (IWineD3DBaseShader *)This, reg_maps, &priv_ctx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Base Shader Body */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_generate_main((IWineD3DBaseShader*)This, buffer, reg_maps, function, &priv_ctx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Unpack 3.0 outputs */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (reg_maps->shader_version.major >= 3) shader_addline(buffer, "order_ps_input(OUT);\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync else shader_addline(buffer, "order_ps_input();\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* The D3DRS_FOGTABLEMODE render state defines if the shader-generated fog coord is used
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * or if the fragment depth is used. If the fragment depth is used(FOGTABLEMODE != NONE),
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * the fog frag coord is thrown away. If the fog frag coord is used, but not written by
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * the shader, it is set to 0.0(fully fogged, since start = 1.0, end = 0.0)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_FogFragCoord = gl_Position.z;\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_FogFragCoord = 0.0;\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Write the final position.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * OpenGL coordinates specify the center of the pixel while d3d coords specify
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * the corner. The offsets are stored in z and w in posFixup. posFixup.y contains
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * 1.0 or -1.0 to turn the rendering upside down for offscreen rendering. PosFixup.x
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * contains 1.0 to allow a mad.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_Position.y = gl_Position.y * posFixup.y;\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_Position.xy += posFixup.zw * gl_Position.ww;\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_ClipVertex = gl_Position;\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Z coord [0;1]->[-1;1] mapping, see comment in transform_projection in state.c
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Basically we want (in homogeneous coordinates) z = z * 2 - 1. However, shaders are run
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * before the homogeneous divide, so we have to take the w into account: z = ((z / w) * 2 - 1) * w,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * which is the same as z = z * 2 - w.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_addline(buffer, "gl_Position.z = gl_Position.z * 2.0 - gl_Position.w;\n");
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync TRACE("Compiling shader object %p\n", (void *)(uintptr_t)shader_obj);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glShaderSourceARB(shader_obj, 1, (const char**)&buffer->buffer, NULL));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_validate_compile_link(gl_info, shader_obj, FALSE);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic GLhandleARB find_glsl_pshader(const struct wined3d_context *context,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer, IWineD3DPixelShaderImpl *shader,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader->baseShader.backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * so a linear search is more performant than a hashmap or a binary search
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * (cache coherency etc)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync && memcmp(&shader_data->gl_shaders[i].args, args, sizeof(*args)) == 0) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync TRACE("No matching GL shader found for shader %p, compiling a new shader.\n", shader);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if(shader_data->shader_array_size == shader_data->num_gl_shaders) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync new_size = shader_data->shader_array_size + max(1, shader_data->shader_array_size / 2);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync new_array = HeapReAlloc(GetProcessHeap(), 0, shader_data->gl_shaders,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync new_array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data->gl_shaders));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_data->gl_shaders[shader_data->num_gl_shaders].context = context;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_data->gl_shaders[shader_data->num_gl_shaders].args = *args;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync memset(&shader_data->gl_shaders[shader_data->num_gl_shaders].np2fixup, 0, sizeof(struct ps_np2fixup_info));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (args->np2_fixup) np2fixup = &shader_data->gl_shaders[shader_data->num_gl_shaders].np2fixup;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync pixelshader_update_samplers(&shader->baseShader.reg_maps,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ((IWineD3DDeviceImpl *)shader->baseShader.device)->stateBlock->textures);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ret = shader_glsl_generate_pshader(context, buffer, shader, args, np2fixup);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_data->gl_shaders[shader_data->num_gl_shaders++].prgId = ret;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic inline BOOL vs_args_equal(const struct vs_compile_args *stored, const struct vs_compile_args *new,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if((stored->swizzle_map & use_map) != new->swizzle_map) return FALSE;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if((stored->clip_enabled) != new->clip_enabled) return FALSE;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic GLhandleARB find_glsl_vshader(const struct wined3d_context *context,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct wined3d_shader_buffer *buffer, IWineD3DVertexShaderImpl *shader,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync DWORD use_map = ((IWineD3DDeviceImpl *)shader->baseShader.device)->strided_streams.use_map;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader->baseShader.backend_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Usually we have very few GL shaders for each d3d shader(just 1 or maybe 2),
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * so a linear search is more performant than a hashmap or a binary search
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * (cache coherency etc)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync && vs_args_equal(&shader_data->gl_shaders[i].args, args, use_map)) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync TRACE("No matching GL shader found for shader %p, compiling a new shader.\n", shader);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if(shader_data->shader_array_size == shader_data->num_gl_shaders) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync new_size = shader_data->shader_array_size + max(1, shader_data->shader_array_size / 2);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync new_array = HeapReAlloc(GetProcessHeap(), 0, shader_data->gl_shaders,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync new_array = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*shader_data->gl_shaders));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_data->gl_shaders[shader_data->num_gl_shaders].context = context;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_data->gl_shaders[shader_data->num_gl_shaders].args = *args;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ret = shader_glsl_generate_vshader(context, buffer, shader, args);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_data->gl_shaders[shader_data->num_gl_shaders++].prgId = ret;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/** Sets the GLSL program ID for the given pixel and vertex shader combination.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * It sets the programId on the current StateBlock (because it should be called
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * inside of the DrawPrimitive() part of the render loop).
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * If a program for the given combination does not exist, create one, and store
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * the program in the hash table. If it creates a program, it will link the
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * given objects, too.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void set_glsl_shader_program(const struct wined3d_context *context,
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync IWineD3DDeviceImpl *device, BOOL a_use_ps, BOOL a_use_vs)
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync IWineD3DVertexShader *vshader = a_use_vs ? device->stateBlock->vertexShader : NULL;
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync IWineD3DPixelShader *pshader = a_use_ps ? device->stateBlock->pixelShader : NULL;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct shader_glsl_priv *priv = device->shader_priv;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync unsigned int i;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (vshader) find_vs_compile_args((IWineD3DVertexShaderImpl *)vshader, device->stateBlock, &vs_compile_args);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (pshader) find_ps_compile_args((IWineD3DPixelShaderImpl *)pshader, device->stateBlock, &ps_compile_args);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync entry = get_glsl_program_entry(priv, vshader, pshader, &vs_compile_args, &ps_compile_args, context);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* If we get to this point, then no matching program exists, so we create one */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync programId = GL_EXTCALL(glCreateProgramObjectARB());
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync TRACE("Created new GLSL shader program %p\n", (void *)(uintptr_t)programId);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Create the entry */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync entry = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct glsl_shader_prog_link));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Add the hash table entry */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Set the current program */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Attach GLSL vshader */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GLhandleARB vshader_id = find_glsl_vshader(context, &priv->shader_buffer,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync (IWineD3DVertexShaderImpl *)vshader, &vs_compile_args);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync WORD map = ((IWineD3DBaseShaderImpl *)vshader)->baseShader.reg_maps.input_registers;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync reorder_shader_id = generate_param_reorder_function(&priv->shader_buffer, vshader, pshader, gl_info);
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync TRACE("Attaching GLSL shader object %p to program %p\n", (void *)(uintptr_t)reorder_shader_id, (void *)(uintptr_t)programId);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glAttachObjectARB(programId, reorder_shader_id));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Flag the reorder function for deletion, then it will be freed automatically when the program
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * is destroyed
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync TRACE("Attaching GLSL shader object %p to program %p\n", (void *)(uintptr_t)vshader_id, (void *)(uintptr_t)programId);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glAttachObjectARB(programId, vshader_id));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Bind vertex attributes to a corresponding index number to match
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * the same index numbers as ARB_vertex_programs (makes loading
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * vertex attributes simpler). With this method, we can use the
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * exact same code to load the attributes later for both ARB and
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * GLSL shaders.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * We have to do this here because we need to know the Program ID
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * in order to make the bindings work, and it has to be done prior
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * to linking the GLSL program. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync snprintf(tmp_name, sizeof(tmp_name), "attrib%u", i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glBindAttribLocationARB(programId, i, tmp_name));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync list_add_head(&((IWineD3DBaseShaderImpl *)vshader)->baseShader.linked_programs, &entry->vshader_entry);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Attach GLSL pshader */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GLhandleARB pshader_id = find_glsl_pshader(context, &priv->shader_buffer,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync (IWineD3DPixelShaderImpl *)pshader, &ps_compile_args,
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync TRACE("Attaching GLSL shader object %p to program %p\n", (void *)(uintptr_t)pshader_id, (void *)(uintptr_t)programId);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glAttachObjectARB(programId, pshader_id));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync list_add_head(&((IWineD3DBaseShaderImpl *)pshader)->baseShader.linked_programs, &entry->pshader_entry);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Link the program */
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync TRACE("Linking GLSL shader program %p\n", (void *)(uintptr_t)programId);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_validate_compile_link(gl_info, programId, TRUE);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync entry->vuniformF_locations = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sizeof(GLhandleARB) * gl_info->limits.glsl_vs_float_constants);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0; i < gl_info->limits.glsl_vs_float_constants; ++i)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync snprintf(glsl_name, sizeof(glsl_name), "VC[%i]", i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync entry->vuniformF_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0; i < MAX_CONST_I; ++i)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync snprintf(glsl_name, sizeof(glsl_name), "VI[%i]", i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync entry->vuniformI_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync entry->puniformF_locations = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync sizeof(GLhandleARB) * gl_info->limits.glsl_ps_float_constants);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0; i < gl_info->limits.glsl_ps_float_constants; ++i)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync snprintf(glsl_name, sizeof(glsl_name), "PC[%i]", i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync entry->puniformF_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0; i < MAX_CONST_I; ++i)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync snprintf(glsl_name, sizeof(glsl_name), "PI[%i]", i);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync entry->puniformI_locations[i] = GL_EXTCALL(glGetUniformLocationARB(programId, glsl_name));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for(i = 0; i < MAX_TEXTURES; i++) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync entry->bumpenvmat_location[i] = GL_EXTCALL(glGetUniformLocationARB(programId, name));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync entry->luminancescale_location[i] = GL_EXTCALL(glGetUniformLocationARB(programId, name));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync entry->luminanceoffset_location[i] = GL_EXTCALL(glGetUniformLocationARB(programId, name));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync entry->np2Fixup_location = GL_EXTCALL(glGetUniformLocationARB(programId, "PsamplerNP2Fixup"));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("NP2 texcoord fixup needed for this pixelshader, but no fixup uniform found.\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync entry->posFixup_location = GL_EXTCALL(glGetUniformLocationARB(programId, "posFixup"));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync entry->ycorrection_location = GL_EXTCALL(glGetUniformLocationARB(programId, "ycorrection"));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync checkGLcall("Find glsl program uniform locations");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync && ((IWineD3DPixelShaderImpl *)pshader)->baseShader.reg_maps.shader_version.major >= 3
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync && ((IWineD3DPixelShaderImpl *)pshader)->declared_in_count > vec4_varyings(3, gl_info))
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync TRACE("Shader %p needs vertex color clamping disabled\n", (void *)(uintptr_t)programId);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Set the shader to allow uniform loading on it */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Load the vertex and pixel samplers now. The function that finds the mappings makes sure
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * that it stays the same for each vertexshader-pixelshader pair(=linked glsl program). If
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * a pshader with fixed function pipeline is used there are no vertex samplers, and if a
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * vertex shader with fixed function pixel processing is used we make sure that the card
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * supports enough samplers to allow the max number of vertex samplers with all possible
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * fixed function fragment processing setups. So once the program is linked these samplers
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * won't change.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (vshader) shader_glsl_load_vsamplers(gl_info, device->texUnitMap, programId);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (pshader) shader_glsl_load_psamplers(gl_info, device->texUnitMap, programId);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* If the local constants do not have to be loaded with the environment constants,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * load them now to have them hardcoded in the GLSL program. This saves some CPU cycles
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (pshader && !((IWineD3DBaseShaderImpl *)pshader)->baseShader.load_local_constsF)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync hardcode_local_constants((IWineD3DBaseShaderImpl *) pshader, gl_info, programId, 'P');
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (vshader && !((IWineD3DBaseShaderImpl *)vshader)->baseShader.load_local_constsF)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync hardcode_local_constants((IWineD3DBaseShaderImpl *) vshader, gl_info, programId, 'V');
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic GLhandleARB create_glsl_blt_shader(const struct wined3d_gl_info *gl_info, enum tex_types tex_type)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "#version 120\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "void main(void)\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync " gl_Position = gl_Vertex;\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync " gl_FrontColor = vec4(1.0);\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync " gl_TexCoord[0] = gl_MultiTexCoord0;\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* tex_1d */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* tex_2d */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "#version 120\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "uniform sampler2D sampler;\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "void main(void)\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync " gl_FragDepth = texture2D(sampler, gl_TexCoord[0].xy).x;\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* tex_3d */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* tex_cube */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "#version 120\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "uniform samplerCube sampler;\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "void main(void)\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync " gl_FragDepth = textureCube(sampler, gl_TexCoord[0].xyz).x;\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* tex_rect */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "#version 120\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "#extension GL_ARB_texture_rectangle : enable\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "uniform sampler2DRect sampler;\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync "void main(void)\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync " gl_FragDepth = texture2DRect(sampler, gl_TexCoord[0].xy).x;\n"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync vshader_id = GL_EXTCALL(glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glShaderSourceARB(vshader_id, 1, blt_vshader, NULL));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_validate_compile_link(gl_info, vshader_id, FALSE);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync pshader_id = GL_EXTCALL(glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glShaderSourceARB(pshader_id, 1, &blt_pshaders[tex_type], NULL));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_validate_compile_link(gl_info, vshader_id, FALSE);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync program_id = GL_EXTCALL(glCreateProgramObjectARB());
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glAttachObjectARB(program_id, vshader_id));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glAttachObjectARB(program_id, pshader_id));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_validate_compile_link(gl_info, program_id, TRUE);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Once linked we can mark the shaders for deletion. They will be deleted once the program
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * is destroyed
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_select(const struct wined3d_context *context, BOOL usePS, BOOL useVS)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DDeviceImpl *device = context_get_device(context);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct shader_glsl_priv *priv = device->shader_priv;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GLenum old_vertex_color_clamp, current_vertex_color_clamp;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync old_vertex_color_clamp = priv->glsl_program ? priv->glsl_program->vertex_color_clamp : GL_FIXED_ONLY_ARB;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (useVS || usePS) set_glsl_shader_program(context, device, usePS, useVS);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync current_vertex_color_clamp = priv->glsl_program ? priv->glsl_program->vertex_color_clamp : GL_FIXED_ONLY_ARB;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (old_vertex_color_clamp != current_vertex_color_clamp)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glClampColorARB(GL_CLAMP_VERTEX_COLOR_ARB, current_vertex_color_clamp));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("vertex color clamp needs to be changed, but extension not supported.\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync program_id = priv->glsl_program ? priv->glsl_program->programId : 0;
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync if (program_id) TRACE("Using GLSL program %p\n", (void *)(uintptr_t)program_id);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* In case that NP2 texcoord fixup data is found for the selected program, trigger a reload of the
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * constants. This has to be done because it can't be guaranteed that sampler() (from state.c) is
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * called between selecting the shader and using it, which results in wrong fixup for some frames. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (priv->glsl_program && WINEFIXUPINFO_ISVALID(priv->glsl_program))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync shader_glsl_load_np2fixup_constants((IWineD3DDevice *)device, usePS, useVS);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_select_depth_blt(IWineD3DDevice *iface, enum tex_types tex_type) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GLhandleARB *blt_program = &priv->depth_blt_program[tex_type];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync *blt_program = create_glsl_blt_shader(gl_info, tex_type);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync loc = GL_EXTCALL(glGetUniformLocationARB(*blt_program, "sampler"));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* GL locking is done by the caller */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_deselect_depth_blt(IWineD3DDevice *iface) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync program_id = priv->glsl_program ? priv->glsl_program->programId : 0;
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync if (program_id) TRACE("Using GLSL program %p\n", (void *)(uintptr_t)program_id);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_destroy(IWineD3DBaseShader *iface) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DBaseShaderImpl *This = (IWineD3DBaseShaderImpl *) iface;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DDeviceImpl *device = (IWineD3DDeviceImpl *)This->baseShader.device;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct shader_glsl_priv *priv = device->shader_priv;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Note: Do not use QueryInterface here to find out which shader type this is because this code
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * can be called from IWineD3DBaseShader::Release
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync char pshader = shader_is_pshader_version(This->baseShader.reg_maps.shader_version.type);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if(!shader_data || shader_data->num_gl_shaders == 0)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync context = context_acquire(device, NULL, CTXUSAGE_RESOURCELOAD);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (priv->glsl_program && (IWineD3DBaseShader *)priv->glsl_program->pshader == iface)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if(!shader_data || shader_data->num_gl_shaders == 0)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync context = context_acquire(device, NULL, CTXUSAGE_RESOURCELOAD);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (priv->glsl_program && (IWineD3DBaseShader *)priv->glsl_program->vshader == iface)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync linked_programs = &This->baseShader.linked_programs;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs, struct glsl_shader_prog_link, pshader_entry) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, linked_programs, struct glsl_shader_prog_link, vshader_entry) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct glsl_pshader_private *shader_data = This->baseShader.backend_data;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (shader_data->gl_shaders[i].context==context_get_current())
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync TRACE("deleting pshader %p\n", (void *)(uintptr_t)shader_data->gl_shaders[i].prgId);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glDeleteObjectARB(shader_data->gl_shaders[i].prgId));
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync WARN("Attempting to delete pshader %p created in ctx %p from ctx %p\n",
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync (void *)(uintptr_t)shader_data->gl_shaders[i].prgId, shader_data->gl_shaders[i].context, context_get_current());
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct glsl_vshader_private *shader_data = This->baseShader.backend_data;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (shader_data->gl_shaders[i].context==context_get_current())
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync TRACE("deleting vshader %p\n", (void *)(uintptr_t)shader_data->gl_shaders[i].prgId);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glDeleteObjectARB(shader_data->gl_shaders[i].prgId));
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync WARN("Attempting to delete vshader %p created in ctx %p from ctx %p\n",
de267421e86f48bb0c7c454160f5066e1cc69c01vboxsync (void *)(uintptr_t)shader_data->gl_shaders[i].prgId, shader_data->gl_shaders[i].context, context_get_current());
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync HeapFree(GetProcessHeap(), 0, shader_data->gl_shaders);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync HeapFree(GetProcessHeap(), 0, This->baseShader.backend_data);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic int glsl_program_key_compare(const void *key, const struct wine_rb_entry *entry)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct glsl_shader_prog_link *prog = WINE_RB_ENTRY_VALUE(entry,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct glsl_shader_prog_link, program_lookup_entry);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (k->vshader && (cmp = memcmp(&k->vs_args, &prog->vs_args, sizeof(prog->vs_args)))) return cmp;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (k->pshader && (cmp = memcmp(&k->ps_args, &prog->ps_args, sizeof(prog->ps_args)))) return cmp;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic BOOL constant_heap_init(struct constant_heap *heap, unsigned int constant_count)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync SIZE_T size = (constant_count + 1) * sizeof(*heap->entries) + constant_count * sizeof(*heap->positions);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync void *mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
12c300500d278860963dbea4f5af1e99fc163334vboxsync /* Don't trash the heap if the input is bogus. */
12c300500d278860963dbea4f5af1e99fc163334vboxsync size = (constant_count + 1) * sizeof(*heap->entries) + constant_count * sizeof(*heap->positions);
12c300500d278860963dbea4f5af1e99fc163334vboxsync mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync heap->positions = (unsigned int *)(heap->entries + constant_count + 1);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void constant_heap_free(struct constant_heap *heap)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic const struct wine_rb_functions wined3d_glsl_program_rb_functions =
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic HRESULT shader_glsl_alloc(IWineD3DDevice *iface) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync struct shader_glsl_priv *priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct shader_glsl_priv));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync SIZE_T stack_size = wined3d_log2i(max(gl_info->limits.glsl_vs_float_constants,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync priv->stack = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, stack_size * sizeof(*priv->stack));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (!constant_heap_init(&priv->vconst_heap, gl_info->limits.glsl_vs_float_constants))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ERR("Failed to initialize vertex shader constant heap\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (!constant_heap_init(&priv->pconst_heap, gl_info->limits.glsl_ps_float_constants))
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync ERR("Failed to initialize pixel shader constant heap\n");
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if (wine_rb_init(&priv->program_lookup, &wined3d_glsl_program_rb_functions) == -1)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync/* Context activation is done by the caller. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_free(IWineD3DDevice *iface) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync const struct wined3d_gl_info *gl_info = &This->adapter->gl_info;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync for (i = 0; i < tex_type_count; ++i)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync GL_EXTCALL(glDeleteObjectARB(priv->depth_blt_program[i]));
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync wine_rb_destroy(&priv->program_lookup, NULL, NULL);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic BOOL shader_glsl_dirty_const(IWineD3DDevice *iface) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* TODO: GL_EXT_bindable_uniform can be used to share constants across shaders */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_get_caps(const struct wined3d_gl_info *gl_info, struct shader_caps *pCaps)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Nvidia Geforce6/7 or Ati R4xx/R5xx cards with GLSL support, support VS 3.0 but older Nvidia/Ati
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * models with GLSL support only support 2.0. In case of nvidia we can detect VS 2.0 support based
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * on the version of NV_vertex_program.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * For Ati cards there's no way using glsl (it abstracts the lowlevel info away) and also not
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * using ARB_vertex_program. It is safe to assume that when a card supports pixel shader 2.0 it
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * supports vertex shader 2.0 too and the way around. We can detect ps2.0 using the maximum number
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * of native instructions, so use that here. For more info see the pixel shader versioning code below.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if ((gl_info->supported[NV_VERTEX_PROGRAM2] && !gl_info->supported[NV_VERTEX_PROGRAM3])
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync pCaps->VertexShaderVersion = WINED3DVS_VERSION(2,0);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync pCaps->VertexShaderVersion = WINED3DVS_VERSION(3,0);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync TRACE_(d3d_caps)("Hardware vertex shader version %d.%d enabled (GLSL)\n", (pCaps->VertexShaderVersion >> 8) & 0xff, pCaps->VertexShaderVersion & 0xff);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync pCaps->MaxVertexShaderConst = gl_info->limits.glsl_vs_float_constants;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Older DX9-class videocards (GeforceFX / Radeon >9500/X*00) only support pixel shader 2.0/2.0a/2.0b.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * In OpenGL the extensions related to GLSL abstract lowlevel GL info away which is needed
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * to distinguish between 2.0 and 3.0 (and 2.0a/2.0b). In case of Nvidia we use their fragment
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * program extensions. On other hardware including ATI GL_ARB_fragment_program offers the info
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * in max native instructions. Intel and others also offer the info in this extension but they
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * don't support GLSL (at least on Windows).
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * PS2.0 requires at least 96 instructions, 2.0a/2.0b go up to 512. Assume that if the number
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * of instructions is 512 or less we have to do with ps2.0 hardware.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * 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.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync if ((gl_info->supported[NV_FRAGMENT_PROGRAM] && !gl_info->supported[NV_FRAGMENT_PROGRAM2])
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync pCaps->PixelShaderVersion = WINED3DPS_VERSION(2,0);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync pCaps->PixelShaderVersion = WINED3DPS_VERSION(3,0);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync pCaps->MaxPixelShaderConst = gl_info->limits.glsl_ps_float_constants;
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* FIXME: The following line is card dependent. -8.0 to 8.0 is the
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Direct3D minimum requirement.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * Both GL_ARB_fragment_program and GLSL require a "maximum representable magnitude"
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * of colors to be 2^10, and 2^32 for other floats. Should we use 1024 here?
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * The problem is that the refrast clamps temporary results in the shader to
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * [-MaxValue;+MaxValue]. If the card's max value is bigger than the one we advertize here,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * then applications may miss the clamping behavior. On the other hand, if it is smaller,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * the shader will generate incorrect results too. Unfortunately, GL deliberately doesn't
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync * offer a way to query this.
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync TRACE_(d3d_caps)("Hardware pixel shader version %d.%d enabled (GLSL)\n", (pCaps->PixelShaderVersion >> 8) & 0xff, pCaps->PixelShaderVersion & 0xff);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic BOOL shader_glsl_color_fixup_supported(struct color_fixup_desc fixup)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* We support everything except YUV conversions. */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic const SHADER_HANDLER shader_glsl_instruction_handler_table[WINED3DSIH_TABLE_SIZE] =
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* WINED3DSIH_TEXM3x2DEPTH */ shader_glsl_texm3x2depth,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* WINED3DSIH_TEXM3x2PAD */ shader_glsl_texm3x2pad,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* WINED3DSIH_TEXM3x2TEX */ shader_glsl_texm3x2tex,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* WINED3DSIH_TEXM3x3PAD */ shader_glsl_texm3x3pad,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* WINED3DSIH_TEXM3x3SPEC */ shader_glsl_texm3x3spec,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* WINED3DSIH_TEXM3x3TEX */ shader_glsl_texm3x3tex,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* WINED3DSIH_TEXM3x3VSPEC */ shader_glsl_texm3x3vspec,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* WINED3DSIH_TEXREG2RGB */ shader_glsl_texreg2rgb,
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsyncstatic void shader_glsl_handle_instruction(const struct wined3d_shader_instruction *ins) {
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Select handler */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync hw_fct = shader_glsl_instruction_handler_table[ins->handler_idx];
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync /* Unhandled opcode */
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync FIXME("Backend can't handle opcode %#x\n", ins->handler_idx);
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync#if defined(VBOXWINEDBG_SHADERS) || defined(VBOX_WINE_WITH_PROFILE)
3194da424708abdd288b28d96892b3a5f3f7df0bvboxsync _vsnprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), szString, pArgList);