058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * Copyright 2002-2003 Jason Edmeades
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * Copyright 2002-2003 Raphael Junqueira
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * Copyright 2004 Christian Costa
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * Copyright 2005 Oliver Stieber
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * Copyright 2006 Ivan Gyurdiev
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * Copyright 2007-2008, 2013 Stefan Dösinger for CodeWeavers
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * Copyright 2009-2011 Henri Verbeet for CodeWeavers
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * This library is free software; you can redistribute it and/or
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * modify it under the terms of the GNU Lesser General Public
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * License as published by the Free Software Foundation; either
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * version 2.1 of the License, or (at your option) any later version.
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * This library is distributed in the hope that it will be useful,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * but WITHOUT ANY WARRANTY; without even the implied warranty of
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * Lesser General Public License for more details.
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * You should have received a copy of the GNU Lesser General Public
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * License along with this library; if not, write to the Free Software
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
4237d5a79f48789aacc67dc43378d2d7813a39f4vboxsync * Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
4237d5a79f48789aacc67dc43378d2d7813a39f4vboxsync * other than GPL or LGPL is available it will apply instead, Oracle elects to use only
4237d5a79f48789aacc67dc43378d2d7813a39f4vboxsync * the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
4237d5a79f48789aacc67dc43378d2d7813a39f4vboxsync * a choice of LGPL license versions is made available with the language indicating
4237d5a79f48789aacc67dc43378d2d7813a39f4vboxsync * that LGPLv2 or any later version may be used, or where a choice of which version
4237d5a79f48789aacc67dc43378d2d7813a39f4vboxsync * of the LGPL is applied is otherwise unspecified.
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_chache_put(PVBOXEXT_HASHCACHE pCache, struct wined3d_shader *shader);
76f3927069cc452e77bf72f32d9175c0256ed3b3vboxsync/* pow, mul_high, sub_high, mul_low */
76f3927069cc452e77bf72f32d9175c0256ed3b3vboxsyncconst float wined3d_srgb_const0[] = {0.41666f, 1.055f, 0.055f, 12.92f};
76f3927069cc452e77bf72f32d9175c0256ed3b3vboxsyncconst float wined3d_srgb_const1[] = {0.0031308f, 0.0f, 0.0f, 0.0f};
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* WINED3DSIH_DCL_CONSTANT_BUFFER */ "dcl_constantBuffer",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* WINED3DSIH_DCL_INPUT_PRIMITIVE */ "dcl_inputPrimitive",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* WINED3DSIH_DCL_OUTPUT_TOPOLOGY */ "dcl_outputTopology",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* WINED3DSIH_DCL_VERTICES_OUT */ "dcl_maxOutputVertexCount",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* WINED3D_DECL_USAGE_BLEND_WEIGHT */ "BLENDWEIGHT",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* WINED3D_DECL_USAGE_BLEND_INDICES */ "BLENDINDICES",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic const char *shader_semantic_name_from_usage(enum wined3d_decl_usage usage)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (usage >= sizeof(semantic_names) / sizeof(*semantic_names))
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync return "UNRECOGNIZED";
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic enum wined3d_decl_usage shader_usage_from_semantic_name(const char *name)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync unsigned int i;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync for (i = 0; i < sizeof(semantic_names) / sizeof(*semantic_names); ++i)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync return ~0U;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncBOOL shader_match_semantic(const char *semantic_name, enum wined3d_decl_usage usage)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync return !strcmp(semantic_name, shader_semantic_name_from_usage(usage));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_signature_from_semantic(struct wined3d_shader_signature_element *e,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_shader_semantic *s)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync e->semantic_name = shader_semantic_name_from_usage(s->usage);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_signature_from_usage(struct wined3d_shader_signature_element *e,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync enum wined3d_decl_usage usage, UINT usage_idx, UINT reg_idx, DWORD write_mask)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync e->semantic_name = shader_semantic_name_from_usage(usage);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic const struct wined3d_shader_frontend *shader_select_frontend(DWORD version_token)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync FIXME("Unrecognised version token %#x\n", version_token);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncvoid shader_buffer_clear(struct wined3d_shader_buffer *buffer)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncBOOL shader_buffer_init(struct wined3d_shader_buffer *buffer)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync buffer->buffer = HeapAlloc(GetProcessHeap(), 0, SHADER_PGMSIZE);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncvoid shader_buffer_free(struct wined3d_shader_buffer *buffer)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncint shader_vaddline(struct wined3d_shader_buffer *buffer, const char *format, va_list args)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync char *base = buffer->buffer + buffer->content_size;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync rc = vsnprintf(base, buffer->buffer_size - buffer->content_size, format, args);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (rc < 0 /* C89 */ || (unsigned int)rc >= buffer->buffer_size - buffer->content_size /* C99 */)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync new_buffer = HeapReAlloc(GetProcessHeap(), 0, buffer->buffer, buffer->buffer_size * 2);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync ERR("The buffer allocated for the shader program string is too small at %d bytes.\n", buffer->buffer_size);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("GL HW (%u, %u) : %s", buffer->lineNo + 1, buffer->content_size, base);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (buffer->buffer[buffer->content_size-1] == '\n')
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncint shader_addline(struct wined3d_shader_buffer *buffer, const char *format, ...)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_init(struct wined3d_shader *shader, struct wined3d_device *device,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync void *parent, const struct wined3d_parent_ops *parent_ops)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync list_add_head(&device->shaders, &shader->shader_list_entry);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync/* Convert floating point offset relative to a register file to an absolute
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * offset for float constants. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic unsigned int shader_get_float_offset(enum wined3d_shader_register_type register_type, UINT register_idx)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case WINED3DSPR_CONST2: return 2048 + register_idx;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case WINED3DSPR_CONST3: return 4096 + register_idx;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case WINED3DSPR_CONST4: return 6144 + register_idx;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync FIXME("Unsupported register type: %u.\n", register_type);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_delete_constant_list(struct list *clist)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync constant = LIST_ENTRY(ptr, struct wined3d_shader_lconst, entry);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic inline void set_bitmap_bit(DWORD *bitmap, DWORD bit)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_record_register_usage(struct wined3d_shader *shader, struct wined3d_shader_reg_maps *reg_maps,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_shader_register *reg, enum wined3d_shader_type shader_type)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* If relative addressing is used, we must assume that all registers
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * are used. Even if it is a construct like v3[aL], we can't assume
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * that v0, v1 and v2 aren't read because aL can be negative */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync unsigned int i;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync for (i = 0; i < MAX_REG_INPUT; ++i)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->u.ps.input_reg_used[reg->idx[0].offset] = TRUE;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg_maps->input_registers |= 1 << reg->idx[0].offset;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync set_bitmap_bit(reg_maps->constf, reg->idx[0].offset);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg_maps->integer_constants |= (1 << reg->idx[0].offset);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg_maps->boolean_constants |= (1 << reg->idx[0].offset);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("Not recording register of type %#x and [%#x][%#x].\n",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg->type, reg->idx[0].offset, reg->idx[1].offset);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic unsigned int get_instr_extra_regcount(enum WINED3D_SHADER_INSTRUCTION_HANDLER instr, unsigned int param)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync/* Note that this does not count the loop register as an address register. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic HRESULT shader_get_registers_used(struct wined3d_shader *shader, const struct wined3d_shader_frontend *fe,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_shader_reg_maps *reg_maps, struct wined3d_shader_signature_element *input_signature,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_shader_signature_element *output_signature, const DWORD *byte_code, DWORD constf_size)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync unsigned int cur_loop_depth = 0, max_loop_depth = 0;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync fe->shader_read_header(fe_data, &ptr, &shader_version);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg_maps->constf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync sizeof(*reg_maps->constf) * ((constf_size + 31) / 32));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Fetch opcode. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Unhandled opcode, and its parameters. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Handle declarations. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_shader_semantic *semantic = &ins.declaration.semantic;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Mark input registers used. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg_maps->input_registers |= 1 << semantic->reg.reg.idx[0].offset;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_signature_from_semantic(&input_signature[semantic->reg.reg.idx[0].offset], semantic);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Vertex shader: mark 3.0 output registers used, save token. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg_maps->output_registers |= 1 << semantic->reg.reg.idx[0].offset;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_signature_from_semantic(&output_signature[semantic->reg.reg.idx[0].offset], semantic);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Save sampler usage token. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg_maps->sampler_type[semantic->reg.reg.idx[0].offset] = semantic->sampler_type;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("Not recording DCL register type %#x.\n", semantic->reg.reg.type);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync else if (ins.handler_idx == WINED3DSIH_DCL_CONSTANT_BUFFER)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_shader_register *reg = &ins.declaration.src.reg;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg_maps->cb_sizes[reg->idx[0].offset] = reg->idx[1].offset;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PRIMITIVE)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (shader_version.type == WINED3D_SHADER_TYPE_GEOMETRY)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->u.gs.input_type = ins.declaration.primitive_type;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync FIXME("Invalid instruction %#x for shader type %#x.\n",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync else if (ins.handler_idx == WINED3DSIH_DCL_OUTPUT_TOPOLOGY)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (shader_version.type == WINED3D_SHADER_TYPE_GEOMETRY)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->u.gs.output_type = ins.declaration.primitive_type;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync FIXME("Invalid instruction %#x for shader type %#x.\n",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync else if (ins.handler_idx == WINED3DSIH_DCL_VERTICES_OUT)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (shader_version.type == WINED3D_SHADER_TYPE_GEOMETRY)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync FIXME("Invalid instruction %#x for shader type %#x.\n",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_shader_lconst *lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(*lconst));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync memcpy(lconst->value, ins.src[0].reg.immconst_data, 4 * sizeof(DWORD));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* In pixel shader 1.X shaders, the constants are clamped between [-1;1] */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (shader_version.major == 1 && shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync list_add_head(&shader->constantsF, &lconst->entry);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (isinf(value[0]) || isnan(value[0]) || isinf(value[1]) || isnan(value[1])
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync || isinf(value[2]) || isnan(value[2]) || isinf(value[3]) || isnan(value[3]))
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_shader_lconst *lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(*lconst));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync memcpy(lconst->value, ins.src[0].reg.immconst_data, 4 * sizeof(DWORD));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync list_add_head(&shader->constantsI, &lconst->entry);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_shader_lconst *lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(*lconst));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync memcpy(lconst->value, ins.src[0].reg.immconst_data, sizeof(DWORD));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync list_add_head(&shader->constantsB, &lconst->entry);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* For subroutine prototypes. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg_maps->labels |= 1 << ins.src[0].reg.idx[0].offset;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Set texture, address, temporary registers. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync unsigned int i;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* This will loop over all the registers and try to
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * make a bitmask of the ones we're interested in.
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * Relative addressing tokens are ignored, but that's
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * okay, since we'll catch any address registers when
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * they are initialized (required by spec). */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_record_register_usage(shader, reg_maps, &ins.dst[i].reg, shader_version.type);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* WINED3DSPR_TEXCRDOUT is the same as WINED3DSPR_OUTPUT. _OUTPUT can be > MAX_REG_TEXCRD and
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * is used in >= 3.0 shaders. Filter 3.0 shaders to prevent overflows, and also filter pixel
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * shaders because TECRDOUT isn't used in them, but future register types might cause issues */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (shader_version.type == WINED3D_SHADER_TYPE_VERTEX && shader_version.major < 3)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case 0: /* oPos */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync WINED3D_DECL_USAGE_POSITION, 0, 10, WINED3DSP_WRITEMASK_ALL);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync WINED3D_DECL_USAGE_FOG, 0, 11, WINED3DSP_WRITEMASK_0);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync WINED3D_DECL_USAGE_PSIZE, 0, 11, WINED3DSP_WRITEMASK_1);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync output_signature[idx].mask |= ins.dst[i].write_mask;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_signature_from_usage(&output_signature[idx],
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync WINED3D_DECL_USAGE_COLOR, idx - 8, idx, ins.dst[i].write_mask);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg_maps->texcoord_mask[idx] |= ins.dst[i].write_mask;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync output_signature[idx].mask |= ins.dst[i].write_mask;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_signature_from_usage(&output_signature[idx],
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync WINED3D_DECL_USAGE_TEXCOORD, idx, idx, ins.dst[i].write_mask);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (ins.dst[i].reg.type == WINED3DSPR_COLOROUT && !ins.dst[i].reg.idx[0].offset)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Many 2.0 and 3.0 pixel shaders end with a MOV from a temp register to
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * COLOROUT 0. If we know this in advance, the ARB shader backend can skip
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * the mov and perform the sRGB write correction from the source register.
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * However, if the mov is only partial, we can't do this, and if the write
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * comes from an instruction other than MOV it is hard to do as well. If
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * COLOROUT 0 is overwritten partially later, the marker is dropped again. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync && ins.dst[i].write_mask == WINED3DSP_WRITEMASK_ALL)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Used later when the source register is read. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Also drop the MOV marker if the source register is overwritten prior to the shader
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync && ins.dst[i].reg.idx[0].offset == shader->u.ps.color0_reg)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Declare 1.x samplers implicitly, based on the destination reg. number. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Fake sampler usage, only set reserved bit and type. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("Setting fake 2D sampler for 1.x pixelshader.\n");
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg_maps->sampler_type[sampler_code] = WINED3DSTT_2D;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* texbem is only valid with < 1.4 pixel shaders */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg_maps->bumpmat |= 1 << ins.dst[i].reg.idx[0].offset;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg_maps->luminanceparams |= 1 << ins.dst[i].reg.idx[0].offset;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg_maps->bumpmat |= 1 << ins.dst[i].reg.idx[0].offset;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (ins.handler_idx == WINED3DSIH_NRM) reg_maps->usesnrm = 1;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync else if (ins.handler_idx == WINED3DSIH_DSY) reg_maps->usesdsy = 1;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync else if (ins.handler_idx == WINED3DSIH_DSX) reg_maps->usesdsx = 1;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync else if (ins.handler_idx == WINED3DSIH_TEXLDD) reg_maps->usestexldd = 1;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync else if (ins.handler_idx == WINED3DSIH_TEXLDL) reg_maps->usestexldl = 1;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync else if (ins.handler_idx == WINED3DSIH_MOVA) reg_maps->usesmova = 1;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync else if (ins.handler_idx == WINED3DSIH_IFC) reg_maps->usesifc = 1;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync else if (ins.handler_idx == WINED3DSIH_CALL) reg_maps->usescall = 1;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync else if (ins.handler_idx == WINED3DSIH_POW) reg_maps->usespow = 1;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_record_register_usage(shader, reg_maps, &ins.predicate->reg, shader_version.type);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync unsigned int count = get_instr_extra_regcount(ins.handler_idx, i);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_shader_register reg = ins.src[i].reg;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_record_register_usage(shader, reg_maps, &ins.src[i].reg, shader_version.type);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_record_register_usage(shader, reg_maps, ®, shader_version.type);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->u.ps.color0_reg = ins.src[i].reg.idx[0].offset;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* PS before 2.0 don't have explicit color outputs. Instead the value of
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * R0 is written to the render target. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (shader_version.major < 2 && shader_version.type == WINED3D_SHADER_TYPE_PIXEL)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->functionLength = ((const char *)ptr - (const char *)byte_code);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncunsigned int shader_find_free_input_register(const struct wined3d_shader_reg_maps *reg_maps, unsigned int max)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync map &= reg_maps->shader_version.major < 3 ? ~reg_maps->texcoord : ~reg_maps->input_registers;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_dump_decl_usage(const struct wined3d_shader_semantic *semantic,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_shader_version *shader_version)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync default: TRACE("_unknown_ttype(0x%08x)", semantic->sampler_type);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Pixel shaders 3.0 don't have usage semantics. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (shader_version->major < 3 && shader_version->type == WINED3D_SHADER_TYPE_PIXEL) return;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync else TRACE("specular%u", (semantic->usage_idx - 1));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync FIXME("unknown_semantics(0x%08x)", semantic->usage);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_dump_register(const struct wined3d_shader_register *reg,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_shader_version *shader_version)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync static const char * const rastout_reg_names[] = {"oPos", "oFog", "oPts"};
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync static const char * const misctype_reg_names[] = {"vPos", "vFace"};
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync offset = shader_get_float_offset(reg->type, offset);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case WINED3DSPR_TEXTURE: /* vs: case WINED3DSPR_ADDR */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("%c", shader_version->type == WINED3D_SHADER_TYPE_PIXEL ? 't' : 'a');
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Vertex shaders >= 3.0 use general purpose output registers
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * (WINED3DSPR_OUTPUT), which can include an address token. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync FIXME("Unhandled misctype register %u.\n", offset);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("<unhandled data type %#x>", reg->data_type);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync *(const float *)®->immconst_data[0], *(const float *)®->immconst_data[1],
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync *(const float *)®->immconst_data[2], *(const float *)®->immconst_data[3]);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("<unhandled data type %#x>", reg->data_type);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("<unhandled immconst_type %#x>", reg->immconst_type);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_dump_src_param(reg->idx[0].rel_addr, shader_version);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_dump_src_param(reg->idx[1].rel_addr, shader_version);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncvoid shader_dump_dst_param(const struct wined3d_shader_dst_param *param,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_shader_version *shader_version)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (write_mask && write_mask != WINED3DSP_WRITEMASK_ALL)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (write_mask & WINED3DSP_WRITEMASK_0) TRACE("%c", write_mask_chars[0]);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (write_mask & WINED3DSP_WRITEMASK_1) TRACE("%c", write_mask_chars[1]);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (write_mask & WINED3DSP_WRITEMASK_2) TRACE("%c", write_mask_chars[2]);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (write_mask & WINED3DSP_WRITEMASK_3) TRACE("%c", write_mask_chars[3]);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncvoid shader_dump_src_param(const struct wined3d_shader_src_param *param,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_shader_version *shader_version)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync enum wined3d_shader_src_modifier src_modifier = param->modifiers;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (src_modifier == WINED3DSPSM_ABS || src_modifier == WINED3DSPSM_ABSNEG)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync default: TRACE("_unknown_modifier(%#x)", src_modifier);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE(".%c%c%c%c", swizzle_chars[swizzle_x], swizzle_chars[swizzle_y],
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync swizzle_chars[swizzle_z], swizzle_chars[swizzle_w]);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync/* Shared code in order to generate the bulk of the shader string.
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * NOTE: A description of how to parse tokens can be found on MSDN. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncvoid shader_generate_main(const struct wined3d_shader *shader, struct wined3d_shader_buffer *buffer,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_shader_reg_maps *reg_maps, const DWORD *byte_code, void *backend_ctx)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_shader_frontend *fe = shader->frontend;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Initialize current parsing state. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync fe->shader_read_header(fe_data, &ptr, &shader_version);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Read opcode. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Unknown opcode and its parameters. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Call appropriate function for output target */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync device->shader_backend->shader_handle_instruction(&ins);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_dump_ins_modifiers(const struct wined3d_shader_dst_param *dst)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case 0: break;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync default: TRACE("_unhandled_shift(%d)", dst->shift); break;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (mmask & WINED3DSPDM_PARTIALPRECISION) TRACE("_pp");
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (mmask & WINED3DSPDM_MSAMPCENTROID) TRACE("_centroid");
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync mmask &= ~(WINED3DSPDM_SATURATE | WINED3DSPDM_PARTIALPRECISION | WINED3DSPDM_MSAMPCENTROID);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (mmask) FIXME("_unrecognized_modifier(%#x)", mmask);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_dump_primitive_type(enum wined3d_primitive_type primitive_type)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("<unrecognized_primitive_type %#x>", primitive_type);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_trace_init(const struct wined3d_shader_frontend *fe, void *fe_data, const DWORD *byte_code)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync fe->shader_read_header(fe_data, &ptr, &shader_version);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync FIXME("Unhandled shader type %#x.\n", shader_version.type);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("%s_%u_%u\n", type_prefix, shader_version.major, shader_version.minor);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_dump_decl_usage(&ins.declaration.semantic, &shader_version);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_dump_ins_modifiers(&ins.declaration.semantic.reg);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_dump_dst_param(&ins.declaration.semantic.reg, &shader_version);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync else if (ins.handler_idx == WINED3DSIH_DCL_CONSTANT_BUFFER)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("%s ", shader_opcode_names[ins.handler_idx]);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_dump_src_param(&ins.declaration.src, &shader_version);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE(", %s", ins.flags & WINED3DSI_INDEXED_DYNAMIC ? "dynamicIndexed" : "immediateIndexed");
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync else if (ins.handler_idx == WINED3DSIH_DCL_INPUT_PRIMITIVE
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync || ins.handler_idx == WINED3DSIH_DCL_OUTPUT_TOPOLOGY)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("%s ", shader_opcode_names[ins.handler_idx]);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_dump_primitive_type(ins.declaration.primitive_type);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync else if (ins.handler_idx == WINED3DSIH_DCL_VERTICES_OUT)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("%s %u", shader_opcode_names[ins.handler_idx], ins.declaration.count);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("def c%u = %f, %f, %f, %f", shader_get_float_offset(ins.dst[0].reg.type,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("defi i%u = %d, %d, %d, %d", ins.dst[0].reg.idx[0].offset,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("defb b%u = %s", ins.dst[0].reg.idx[0].offset, ins.src[0].reg.immconst_data[0] ? "true" : "false");
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_dump_src_param(ins.predicate, &shader_version);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* PixWin marks instructions with the coissue flag with a '+' */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case WINED3D_SHADER_REL_OP_GT: TRACE("_gt"); break;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case WINED3D_SHADER_REL_OP_EQ: TRACE("_eq"); break;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case WINED3D_SHADER_REL_OP_GE: TRACE("_ge"); break;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case WINED3D_SHADER_REL_OP_LT: TRACE("_lt"); break;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case WINED3D_SHADER_REL_OP_NE: TRACE("_ne"); break;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case WINED3D_SHADER_REL_OP_LE: TRACE("_le"); break;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_dump_dst_param(&ins.dst[i], &shader_version);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Other source tokens */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync for (i = ins.dst_count; i < (ins.dst_count + ins.src_count); ++i)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_dump_src_param(&ins.src[i - ins.dst_count], &shader_version);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_cleanup(struct wined3d_shader *shader)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->device->shader_backend->shader_destroy(shader);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync HeapFree(GetProcessHeap(), 0, shader->reg_maps.constf);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->frontend->shader_free(shader->frontend_data);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_none_handle_instruction(const struct wined3d_shader_instruction *ins) {}
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_none_select_depth_blt(void *shader_priv, const struct wined3d_gl_info *gl_info,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync enum tex_types tex_type, const SIZE *ds_mask_size) {}
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_none_deselect_depth_blt(void *shader_priv, const struct wined3d_gl_info *gl_info) {}
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_none_update_float_vertex_constants(struct wined3d_device *device, UINT start, UINT count) {}
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_none_update_float_pixel_constants(struct wined3d_device *device, UINT start, UINT count) {}
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_none_load_constants(void *shader_priv, const struct wined3d_context *context,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_none_load_np2fixup_constants(void *shader_priv,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_gl_info *gl_info, const struct wined3d_state *state) {}
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_none_destroy(struct wined3d_shader *shader) {}
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_none_context_destroyed(void *shader_priv, const struct wined3d_context *context) {}
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync/* Context activation is done by the caller. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_none_select(void *shader_priv, const struct wined3d_context *context,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync priv->vertex_pipe->vp_enable(gl_info, !use_vs(state));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync priv->fragment_pipe->enable_extension(gl_info, !use_ps(state));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync/* Context activation is done by the caller. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_none_disable(void *shader_priv, const struct wined3d_context *context)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_gl_info *gl_info = context->gl_info;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync priv->fragment_pipe->enable_extension(gl_info, FALSE);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic HRESULT shader_none_alloc(struct wined3d_device *device, const struct wined3d_vertex_pipe_ops *vertex_pipe,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (!(priv = HeapAlloc(GetProcessHeap(), 0, sizeof(*priv))))
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (!(vertex_priv = vertex_pipe->vp_alloc(&none_shader_backend, priv)))
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (!(fragment_priv = fragment_pipe->alloc_private(&none_shader_backend, priv)))
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync fragment_pipe->get_caps(&device->adapter->gl_info, &fragment_caps);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync priv->ffp_proj_control = fragment_caps.wined3d_caps & WINED3D_FRAGMENT_CAP_PROJ_CONTROL;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_none_free(struct wined3d_device *device)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct shader_none_priv *priv = device->shader_priv;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_none_get_caps(const struct wined3d_gl_info *gl_info, struct shader_caps *caps)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Set the shader caps to 0 for the none shader backend */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic BOOL shader_none_color_fixup_supported(struct color_fixup_desc fixup)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* We "support" every possible fixup, since we don't support any shader
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * model, and will never have to actually sample a texture. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic BOOL shader_none_has_ffp_proj_control(void *shader_priv)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncconst struct wined3d_shader_backend_ops none_shader_backend =
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic HRESULT shader_set_function(struct wined3d_shader *shader, const DWORD *byte_code,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_shader_signature *output_signature, DWORD float_const_count,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync enum wined3d_shader_type type, unsigned int max_version)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_d3d_info *d3d_info = &shader->device->adapter->d3d_info;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("shader %p, byte_code %p, output_signature %p, float_const_count %u.\n",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader, byte_code, output_signature, float_const_count);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->frontend_data = fe->shader_init(byte_code, output_signature);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* First pass: trace shader. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_trace_init(fe, shader->frontend_data, byte_code);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Initialize immediate constant lists. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Second pass: figure out which registers are used, what the semantics are, etc. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg_maps, shader->input_signature, shader->output_signature,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync WARN("Wrong shader type %d.\n", reg_maps->shader_version.type);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync WARN("Shader version %d not supported by this D3D API version.\n", reg_maps->shader_version.major);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync FIXME("No backend version-checking for this shader type\n");
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (reg_maps->shader_version.major > backend_version)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync WARN("Shader version %d.%d not supported by your GPU with the current shader backend.\n",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg_maps->shader_version.major, reg_maps->shader_version.minor);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->function = HeapAlloc(GetProcessHeap(), 0, shader->functionLength);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync memcpy(shader->function, byte_code, shader->functionLength);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncULONG CDECL wined3d_shader_incref(struct wined3d_shader *shader)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync ULONG refcount = InterlockedIncrement(&shader->ref);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("%p increasing refcount to %u.\n", shader, refcount);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync/* Do not call while under the GL lock. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncULONG CDECL wined3d_shader_decref(struct wined3d_shader *shader)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync ULONG refcount = InterlockedDecrement(&shader->ref);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("%p decreasing refcount to %u.\n", shader, refcount);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->parent_ops->wined3d_object_destroyed(shader->parent);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncvoid * CDECL wined3d_shader_get_parent(const struct wined3d_shader *shader)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncHRESULT CDECL wined3d_shader_get_byte_code(const struct wined3d_shader *shader,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("shader %p, byte_code %p, byte_code_size %p.\n", shader, byte_code, byte_code_size);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* MSDN claims (for d3d8 at least) that if *byte_code_size is smaller
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * than the required size we should write the required size and
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * return D3DERR_MOREDATA. That's not actually true. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync memcpy(byte_code, shader->function, shader->functionLength);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync/* Set local constants for d3d8 shaders. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncHRESULT CDECL wined3d_shader_set_local_constants_float(struct wined3d_shader *shader,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("shader %p, start_idx %u, src_data %p, count %u.\n", shader, start_idx, src_data, count);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_shader_lconst *lconst = HeapAlloc(GetProcessHeap(), 0, sizeof(*lconst));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync memcpy(value, src_data + (i - start_idx) * 4 /* 4 components */, 4 * sizeof(float));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync list_add_head(&shader->constantsF, &lconst->entry);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (isinf(value[0]) || isnan(value[0]) || isinf(value[1]) || isnan(value[1])
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync || isinf(value[2]) || isnan(value[2]) || isinf(value[3]) || isnan(value[3]))
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncvoid find_vs_compile_args(const struct wined3d_state *state,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_shader *shader, struct vs_compile_args *args)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync args->fog_src = state->render_states[WINED3D_RS_FOGTABLEMODE]
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync args->clip_enabled = state->render_states[WINED3D_RS_CLIPPING]
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync && state->render_states[WINED3D_RS_CLIPPLANEENABLE];
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync args->swizzle_map = shader->device->stream_info.swizzle_map;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic BOOL match_usage(BYTE usage1, BYTE usage_idx1, BYTE usage2, BYTE usage_idx2)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (usage1 == WINED3D_DECL_USAGE_POSITION && usage2 == WINED3D_DECL_USAGE_POSITIONT)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (usage2 == WINED3D_DECL_USAGE_POSITION && usage1 == WINED3D_DECL_USAGE_POSITIONT)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncBOOL vshader_get_input(const struct wined3d_shader *shader,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync BYTE usage_req, BYTE usage_idx_req, unsigned int *regnum)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync unsigned int i;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->u.vs.attributes[i].usage_idx, usage_req, usage_idx_req))
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void vertexshader_set_limits(struct wined3d_shader *shader)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync DWORD shader_version = WINED3D_SHADER_VERSION(shader->reg_maps.shader_version.major,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const DWORD vs_uniform_count = device->adapter->d3d_info.limits.vs_uniform_count;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* TODO: vs_1_1 has a minimum of 96 constants. What happens when
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * a vs_1_1 shader is used on a vs_3_0 capable card that has 256
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * constants? */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->limits.constant_float = min(256, vs_uniform_count);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->limits.constant_float = min(256, vs_uniform_count);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* DX10 cards on Windows advertise a d3d9 constant limit of 256
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * even though they are capable of supporting much more (GL
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * drivers advertise 1024). d3d9.dll and d3d8.dll clamp the
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * wined3d-advertised maximum. Clamp the constant limit for <= 3.0
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * shaders to 256. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->limits.constant_float = min(256, vs_uniform_count);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->limits.sampler = 16; /* FIXME: 128 resources, 16 sampler states */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->limits.constant_float = min(256, vs_uniform_count);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync FIXME("Unrecognized vertex shader version \"%u.%u\".\n",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic HRESULT vertexshader_init(struct wined3d_shader *shader, struct wined3d_device *device,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const DWORD *byte_code, const struct wined3d_shader_signature *output_signature,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync void *parent, const struct wined3d_parent_ops *parent_ops, unsigned int max_version)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync unsigned int i;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const DWORD vs_uniform_count = device->adapter->d3d_info.limits.vs_uniform_count;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync hr = shader_set_function(shader, byte_code, output_signature, vs_uniform_count,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (!(map & 1) || !shader->input_signature[i].semantic_name)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader_usage_from_semantic_name(shader->input_signature[i].semantic_name);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->u.vs.attributes[i].usage_idx = shader->input_signature[i].semantic_idx;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync for (i = 0; i < output_signature->element_count; ++i)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_shader_signature_element *e = &output_signature->elements[i];
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync reg_maps->output_registers |= 1 << e->register_idx;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->load_local_constsF = (reg_maps->usesrelconstF && !list_empty(&shader->constantsF)) ||
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void geometryshader_set_limits(struct wined3d_shader *shader)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync DWORD shader_version = WINED3D_SHADER_VERSION(shader->reg_maps.shader_version.major,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->limits.sampler = 16; /* FIXME: 128 resources, 16 sampler states */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync memset(&shader->limits, 0, sizeof(shader->limits));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync FIXME("Unhandled geometry shader version \"%u.%u\".\n",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic HRESULT geometryshader_init(struct wined3d_shader *shader, struct wined3d_device *device,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const DWORD *byte_code, const struct wined3d_shader_signature *output_signature,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync void *parent, const struct wined3d_parent_ops *parent_ops, unsigned int max_version)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync hr = shader_set_function(shader, byte_code, output_signature, 0,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->load_local_constsF = shader->lconst_inf_or_nan;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncvoid find_ps_compile_args(const struct wined3d_state *state,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_shader *shader, struct ps_compile_args *args)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync memset(args, 0, sizeof(*args)); /* FIXME: Make sure all bits are set. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (!gl_info->supported[ARB_FRAMEBUFFER_SRGB] && state->render_states[WINED3D_RS_SRGBWRITEENABLE])
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_surface *rt = state->fb->render_targets[0];
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (rt->resource.format->flags & WINED3DFMT_FLAG_SRGB_WRITE)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (state->render_states[WINED3D_RS_ALPHABLENDENABLE] && !warned++)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync WARN("Blending into a sRGB render target with no GL_ARB_framebuffer_sRGB "
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync "support, expect rendering artifacts.\n");
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync DWORD flags = state->texture_states[i][WINED3D_TSS_TEXTURE_TRANSFORM_FLAGS];
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync DWORD tex_transform = flags & ~WINED3D_TTFF_PROJECTED;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync unsigned int j;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync unsigned int index = state->texture_states[i][WINED3D_TSS_TEXCOORD_INDEX];
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync enum wined3d_sampler_texture_type sampler_type = shader->reg_maps.sampler_type[i];
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync for (j = 0; j < state->vertex_declaration->element_count; ++j)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_vertex_declaration_element *element =
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync WARN("Fixing up projected texture transform flags from %#x to %#x.\n",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if ((sampler_type == WINED3DSTT_1D && tex_transform > WINED3D_TTFF_COUNT1)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync || (sampler_type == WINED3DSTT_2D && tex_transform > WINED3D_TTFF_COUNT2)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync || (sampler_type == WINED3DSTT_VOLUME && tex_transform > WINED3D_TTFF_COUNT3))
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync WARN("Application requested projected texture with unsuitable texture coordinates.\n");
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync WARN("(texture unit %u, transform flags %#x, sampler type %u).\n",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync tex_transform = WINED3D_TTFF_COUNT4 | WINED3D_PSARGS_PROJECTED;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync args->tex_transform |= tex_transform << i * WINED3D_PSARGS_TEXTRANSFORM_SHIFT;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_texture *texture = state->textures[i];
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Treat unbound textures as 2D. The dummy texture will provide
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * the proper sample value. The tex_types bitmap defaults to
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * 2D because of the memset. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* RECT textures are distinguished from 2D textures via np2_fixup */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync args->tex_types |= WINED3D_SHADER_TEX_3D << i * WINED3D_PSARGS_TEXTYPE_SHIFT;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync args->tex_types |= WINED3D_SHADER_TEX_CUBE << i * WINED3D_PSARGS_TEXTYPE_SHIFT;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync for (i = 0; i < MAX_FRAGMENT_SAMPLERS; ++i)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync args->color_fixup[i] = texture->resource.format->color_fixup;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (texture->resource.format->flags & WINED3DFMT_FLAG_SHADOW)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Flag samplers that need NP2 texcoord fixup. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (!(texture->flags & WINED3D_TEXTURE_POW2_MAT_IDENT))
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync switch (state->render_states[WINED3D_RS_FOGTABLEMODE])
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (device->stream_info.position_transformed || use_vs(state))
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync switch (state->render_states[WINED3D_RS_FOGVERTEXMODE])
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case WINED3D_FOG_LINEAR: args->fog = WINED3D_FFP_PS_FOG_LINEAR; break;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case WINED3D_FOG_EXP: args->fog = WINED3D_FFP_PS_FOG_EXP; break;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case WINED3D_FOG_EXP2: args->fog = WINED3D_FFP_PS_FOG_EXP2; break;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case WINED3D_FOG_LINEAR: args->fog = WINED3D_FFP_PS_FOG_LINEAR; break;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case WINED3D_FOG_EXP: args->fog = WINED3D_FFP_PS_FOG_EXP; break;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync case WINED3D_FOG_EXP2: args->fog = WINED3D_FFP_PS_FOG_EXP2; break;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void pixelshader_set_limits(struct wined3d_shader *shader)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync DWORD shader_version = WINED3D_SHADER_VERSION(shader->reg_maps.shader_version.major,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* FIXME: Temporaries must match D3DPSHADERCAPS2_0.NumTemps. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->limits.sampler = 16; /* FIXME: 128 resources, 16 sampler states */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic HRESULT pixelshader_init(struct wined3d_shader *shader, struct wined3d_device *device,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const DWORD *byte_code, const struct wined3d_shader_signature *output_signature,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync void *parent, const struct wined3d_parent_ops *parent_ops, unsigned int max_version)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync unsigned int i, highest_reg_used = 0, num_regs_used = 0;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const DWORD ps_uniform_count = device->adapter->d3d_info.limits.ps_uniform_count;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync hr = shader_set_function(shader, byte_code, output_signature, ps_uniform_count,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync for (i = 0; i < MAX_REG_INPUT; ++i)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* Don't do any register mapping magic if it is not needed, or if we can't
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * achieve anything anyway */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (highest_reg_used < (gl_info->limits.glsl_varyings / 4)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync || num_regs_used > (gl_info->limits.glsl_varyings / 4))
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (num_regs_used > (gl_info->limits.glsl_varyings / 4))
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* This happens with relative addressing. The input mapper function
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * warns about this if the higher registers are declared too, so
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync * don't write a FIXME here */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync WARN("More varying registers used than supported\n");
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync for (i = 0; i < MAX_REG_INPUT; ++i)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->u.ps.declared_in_count = highest_reg_used + 1;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync for (i = 0; i < MAX_REG_INPUT; ++i)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->u.ps.input_reg_map[i] = shader->u.ps.declared_in_count++;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->load_local_constsF = shader->lconst_inf_or_nan;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncvoid pixelshader_update_samplers(struct wined3d_shader *shader, WORD tex_types)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_shader_reg_maps *reg_maps = &shader->reg_maps;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync enum wined3d_sampler_texture_type *sampler_type = reg_maps->sampler_type;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync unsigned int i;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* We don't sample from this sampler. */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (!sampler_type[i]) continue;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync switch ((tex_types >> i * WINED3D_PSARGS_TEXTYPE_SHIFT) & WINED3D_PSARGS_TEXTYPE_MASK)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncHRESULT CDECL wined3d_shader_create_gs(struct wined3d_device *device, const DWORD *byte_code,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_shader_signature *output_signature, void *parent,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader, unsigned int max_version)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("device %p, byte_code %p, output_signature %p, parent %p, parent_ops %p, shader %p.\n",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync device, byte_code, output_signature, parent, parent_ops, shader);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync hr = geometryshader_init(object, device, byte_code, output_signature, parent, parent_ops, max_version);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync WARN("Failed to initialize geometry shader, hr %#x.\n", hr);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncHRESULT CDECL wined3d_shader_create_ps(struct wined3d_device *device, const DWORD *byte_code,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_shader_signature *output_signature, void *parent,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader, unsigned int max_version)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("device %p, byte_code %p, output_signature %p, parent %p, parent_ops %p, shader %p.\n",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync device, byte_code, output_signature, parent, parent_ops, shader);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync hr = pixelshader_init(object, device, byte_code, output_signature, parent, parent_ops, max_version);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync WARN("Failed to initialize pixel shader, hr %#x.\n", hr);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncHRESULT CDECL wined3d_shader_create_vs(struct wined3d_device *device, const DWORD *byte_code,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_shader_signature *output_signature, void *parent,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync const struct wined3d_parent_ops *parent_ops, struct wined3d_shader **shader, unsigned int max_version)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync TRACE("device %p, byte_code %p, output_signature %p, parent %p, parent_ops %p, shader %p.\n",
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync device, byte_code, output_signature, parent, parent_ops, shader);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync hr = vertexshader_init(object, device, byte_code, output_signature, parent, parent_ops, max_version);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync WARN("Failed to initialize vertex shader, hr %#x.\n", hr);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync object = vertexshader_check_cached(device, object);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_reinit(struct wined3d_shader *shader, struct wined3d_device *device,
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync void *parent, const struct wined3d_parent_ops *parent_ops)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync LIST_FOR_EACH_ENTRY(tst_shader, &device->shaders, struct wined3d_shader, shader_list_entry) {
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic DECLCALLBACK(uint32_t) shader_cache_hash(void *pvKey)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_shader * shader = (struct wined3d_shader *)pvKey;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic DECLCALLBACK(bool) shader_cache_equal(void *pvKey1, void *pvKey2)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_shader *shader1 = (struct wined3d_shader *)pvKey1;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_shader *shader2 = (struct wined3d_shader *)pvKey2;
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (shader1->functionLength != shader2->functionLength)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync if (shader_cache_hash(pvKey1) != shader_cache_hash(pvKey2))
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync Assert(memcmp(shader1->function, shader2->function, shader1->functionLength));
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync return !memcmp(shader1->function, shader2->function, shader1->functionLength);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync#define VBOX_SHADER_FROM_CACHE_ENTRY(_pEntry) RT_FROM_MEMBER((_pEntry), struct wined3d_shader, CacheEntry)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic DECLCALLBACK(void) shader_cache_cleanup_entry(void *pvKey, struct VBOXEXT_HASHCACHE_ENTRY *pEntry)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync struct wined3d_shader *shader = VBOX_SHADER_FROM_CACHE_ENTRY(pEntry);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->parent_ops->wined3d_object_destroyed(shader->parent);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_chache_init(PVBOXEXT_HASHCACHE pCache)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync VBoxExtCacheInit(pCache, 1024, shader_cache_hash, shader_cache_equal, shader_cache_cleanup_entry);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_chache_term(PVBOXEXT_HASHCACHE pCache)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic void shader_chache_put(PVBOXEXT_HASHCACHE pCache, struct wined3d_shader *shader)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync shader->parent_ops->wined3d_object_destroyed(shader->parent);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync VBoxExtCachePut(pCache, shader, &shader->CacheEntry);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstatic struct wined3d_shader* shader_chache_get(PVBOXEXT_HASHCACHE pCache, struct wined3d_shader *shader)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync PVBOXEXT_HASHCACHE_ENTRY pEntry = VBoxExtCacheGet(pCache, shader);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync cached_shader = VBOX_SHADER_FROM_CACHE_ENTRY(pEntry);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync /* we can not do a IWineD3DBaseShader_Release here since this would result in putting a shader to the cache */
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstruct wined3d_shader * vertexshader_check_cached(struct wined3d_device *device, struct wined3d_shader *object)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync return shader_chache_get(&device->vshaderCache, (struct wined3d_shader *)object);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncstruct wined3d_shader * pixelshader_check_cached(struct wined3d_device *device, struct wined3d_shader *object)
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsync return shader_chache_get(&device->pshaderCache, (struct wined3d_shader *)object);
058c0c53c37f5cb271aeb3c385c10766f84f4aefvboxsyncvoid shader_chaches_init(struct wined3d_device *device)