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

776 lines
39 KiB
C
Raw Normal View History

wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
/*
* Copyright 2002-2003 Jason Edmeades
* Copyright 2002-2003 Raphael Junqueira
* Copyright 2004 Christian Costa
* Copyright 2005 Oliver Stieber
* Copyright 2006 Ivan Gyurdiev
* Copyright 2007-2008 Stefan Dösinger for CodeWeavers
* Copyright 2009 Henri Verbeet for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "config.h"
#include "wine/port.h"
#include "wined3d_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
/* DCL usage masks */
#define WINED3DSP_DCL_USAGE_SHIFT 0
#define WINED3DSP_DCL_USAGE_MASK (0xf << WINED3DSP_DCL_USAGE_SHIFT)
#define WINED3DSP_DCL_USAGEINDEX_SHIFT 16
#define WINED3DSP_DCL_USAGEINDEX_MASK (0xf << WINED3DSP_DCL_USAGEINDEX_SHIFT)
/* DCL sampler type */
#define WINED3DSP_TEXTURETYPE_SHIFT 27
#define WINED3DSP_TEXTURETYPE_MASK (0xf << WINED3DSP_TEXTURETYPE_SHIFT)
/* Opcode-related masks */
#define WINED3DSI_OPCODE_MASK 0x0000ffff
#define WINED3D_OPCODESPECIFICCONTROL_SHIFT 16
#define WINED3D_OPCODESPECIFICCONTROL_MASK (0xff << WINED3D_OPCODESPECIFICCONTROL_SHIFT)
#define WINED3DSI_INSTLENGTH_SHIFT 24
#define WINED3DSI_INSTLENGTH_MASK (0xf << WINED3DSI_INSTLENGTH_SHIFT)
#define WINED3DSI_COISSUE (1 << 30)
#define WINED3DSI_COMMENTSIZE_SHIFT 16
#define WINED3DSI_COMMENTSIZE_MASK (0x7fff << WINED3DSI_COMMENTSIZE_SHIFT)
#define WINED3DSHADER_INSTRUCTION_PREDICATED (1 << 28)
/* Register number mask */
#define WINED3DSP_REGNUM_MASK 0x000007ff
/* Register type masks */
#define WINED3DSP_REGTYPE_SHIFT 28
#define WINED3DSP_REGTYPE_MASK (0x7 << WINED3DSP_REGTYPE_SHIFT)
#define WINED3DSP_REGTYPE_SHIFT2 8
#define WINED3DSP_REGTYPE_MASK2 (0x18 << WINED3DSP_REGTYPE_SHIFT2)
/* Relative addressing mask */
#define WINED3DSHADER_ADDRESSMODE_SHIFT 13
#define WINED3DSHADER_ADDRESSMODE_MASK (1 << WINED3DSHADER_ADDRESSMODE_SHIFT)
/* Destination modifier mask */
#define WINED3DSP_DSTMOD_SHIFT 20
#define WINED3DSP_DSTMOD_MASK (0xf << WINED3DSP_DSTMOD_SHIFT)
/* Destination shift mask */
#define WINED3DSP_DSTSHIFT_SHIFT 24
#define WINED3DSP_DSTSHIFT_MASK (0xf << WINED3DSP_DSTSHIFT_SHIFT)
wined3d: Shift the writemask in the frontend.
2009-05-06 10:05:45 +02:00
/* Write mask */
#define WINED3D_SM1_WRITEMASK_SHIFT 16
#define WINED3D_SM1_WRITEMASK_MASK (0xf << WINED3D_SM1_WRITEMASK_SHIFT)
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
/* Swizzle mask */
#define WINED3DSP_SWIZZLE_SHIFT 16
#define WINED3DSP_SWIZZLE_MASK (0xff << WINED3DSP_SWIZZLE_SHIFT)
/* Source modifier mask */
#define WINED3DSP_SRCMOD_SHIFT 24
#define WINED3DSP_SRCMOD_MASK (0xf << WINED3DSP_SRCMOD_SHIFT)
wined3d: Add a frontend function to determine if there are any tokens left.
2009-05-04 09:49:27 +02:00
#define WINED3DSP_END 0x0000ffff
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
#define WINED3D_SM1_VERSION_MAJOR(version) (((version) >> 8) & 0xff)
#define WINED3D_SM1_VERSION_MINOR(version) (((version) >> 0) & 0xff)
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
enum WINED3DSHADER_ADDRESSMODE_TYPE
{
WINED3DSHADER_ADDRMODE_ABSOLUTE = 0 << WINED3DSHADER_ADDRESSMODE_SHIFT,
WINED3DSHADER_ADDRMODE_RELATIVE = 1 << WINED3DSHADER_ADDRESSMODE_SHIFT,
};
wined3d: Move the SM1 opcode enum to shader_sm1.c.
2009-10-06 09:05:56 +02:00
enum wined3d_sm1_opcode
{
WINED3D_SM1_OP_NOP = 0x00,
WINED3D_SM1_OP_MOV = 0x01,
WINED3D_SM1_OP_ADD = 0x02,
WINED3D_SM1_OP_SUB = 0x03,
WINED3D_SM1_OP_MAD = 0x04,
WINED3D_SM1_OP_MUL = 0x05,
WINED3D_SM1_OP_RCP = 0x06,
WINED3D_SM1_OP_RSQ = 0x07,
WINED3D_SM1_OP_DP3 = 0x08,
WINED3D_SM1_OP_DP4 = 0x09,
WINED3D_SM1_OP_MIN = 0x0a,
WINED3D_SM1_OP_MAX = 0x0b,
WINED3D_SM1_OP_SLT = 0x0c,
WINED3D_SM1_OP_SGE = 0x0d,
WINED3D_SM1_OP_EXP = 0x0e,
WINED3D_SM1_OP_LOG = 0x0f,
WINED3D_SM1_OP_LIT = 0x10,
WINED3D_SM1_OP_DST = 0x11,
WINED3D_SM1_OP_LRP = 0x12,
WINED3D_SM1_OP_FRC = 0x13,
WINED3D_SM1_OP_M4x4 = 0x14,
WINED3D_SM1_OP_M4x3 = 0x15,
WINED3D_SM1_OP_M3x4 = 0x16,
WINED3D_SM1_OP_M3x3 = 0x17,
WINED3D_SM1_OP_M3x2 = 0x18,
WINED3D_SM1_OP_CALL = 0x19,
WINED3D_SM1_OP_CALLNZ = 0x1a,
WINED3D_SM1_OP_LOOP = 0x1b,
WINED3D_SM1_OP_RET = 0x1c,
WINED3D_SM1_OP_ENDLOOP = 0x1d,
WINED3D_SM1_OP_LABEL = 0x1e,
WINED3D_SM1_OP_DCL = 0x1f,
WINED3D_SM1_OP_POW = 0x20,
WINED3D_SM1_OP_CRS = 0x21,
WINED3D_SM1_OP_SGN = 0x22,
WINED3D_SM1_OP_ABS = 0x23,
WINED3D_SM1_OP_NRM = 0x24,
WINED3D_SM1_OP_SINCOS = 0x25,
WINED3D_SM1_OP_REP = 0x26,
WINED3D_SM1_OP_ENDREP = 0x27,
WINED3D_SM1_OP_IF = 0x28,
WINED3D_SM1_OP_IFC = 0x29,
WINED3D_SM1_OP_ELSE = 0x2a,
WINED3D_SM1_OP_ENDIF = 0x2b,
WINED3D_SM1_OP_BREAK = 0x2c,
WINED3D_SM1_OP_BREAKC = 0x2d,
WINED3D_SM1_OP_MOVA = 0x2e,
WINED3D_SM1_OP_DEFB = 0x2f,
WINED3D_SM1_OP_DEFI = 0x30,
WINED3D_SM1_OP_TEXCOORD = 0x40,
WINED3D_SM1_OP_TEXKILL = 0x41,
WINED3D_SM1_OP_TEX = 0x42,
WINED3D_SM1_OP_TEXBEM = 0x43,
WINED3D_SM1_OP_TEXBEML = 0x44,
WINED3D_SM1_OP_TEXREG2AR = 0x45,
WINED3D_SM1_OP_TEXREG2GB = 0x46,
WINED3D_SM1_OP_TEXM3x2PAD = 0x47,
WINED3D_SM1_OP_TEXM3x2TEX = 0x48,
WINED3D_SM1_OP_TEXM3x3PAD = 0x49,
WINED3D_SM1_OP_TEXM3x3TEX = 0x4a,
WINED3D_SM1_OP_TEXM3x3DIFF = 0x4b,
WINED3D_SM1_OP_TEXM3x3SPEC = 0x4c,
WINED3D_SM1_OP_TEXM3x3VSPEC = 0x4d,
WINED3D_SM1_OP_EXPP = 0x4e,
WINED3D_SM1_OP_LOGP = 0x4f,
WINED3D_SM1_OP_CND = 0x50,
WINED3D_SM1_OP_DEF = 0x51,
WINED3D_SM1_OP_TEXREG2RGB = 0x52,
WINED3D_SM1_OP_TEXDP3TEX = 0x53,
WINED3D_SM1_OP_TEXM3x2DEPTH = 0x54,
WINED3D_SM1_OP_TEXDP3 = 0x55,
WINED3D_SM1_OP_TEXM3x3 = 0x56,
WINED3D_SM1_OP_TEXDEPTH = 0x57,
WINED3D_SM1_OP_CMP = 0x58,
WINED3D_SM1_OP_BEM = 0x59,
WINED3D_SM1_OP_DP2ADD = 0x5a,
WINED3D_SM1_OP_DSX = 0x5b,
WINED3D_SM1_OP_DSY = 0x5c,
WINED3D_SM1_OP_TEXLDD = 0x5d,
WINED3D_SM1_OP_SETP = 0x5e,
WINED3D_SM1_OP_TEXLDL = 0x5f,
WINED3D_SM1_OP_BREAKP = 0x60,
WINED3D_SM1_OP_PHASE = 0xfffd,
WINED3D_SM1_OP_COMMENT = 0xfffe,
WINED3D_SM1_OP_END = 0Xffff,
};
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
struct wined3d_sm1_opcode_info
{
wined3d: Move the SM1 opcode enum to shader_sm1.c.
2009-10-06 09:05:56 +02:00
enum wined3d_sm1_opcode opcode;
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
UINT dst_count;
UINT param_count;
enum WINED3D_SHADER_INSTRUCTION_HANDLER handler_idx;
DWORD min_version;
DWORD max_version;
};
struct wined3d_sm1_data
{
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
struct wined3d_shader_version shader_version;
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
const struct wined3d_sm1_opcode_info *opcode_table;
wined3d: Read complete shader instructions at a time.
2012-09-04 20:15:08 +02:00
struct wined3d_shader_src_param src_rel_addr[4];
struct wined3d_shader_src_param pred_rel_addr;
struct wined3d_shader_src_param dst_rel_addr;
struct wined3d_shader_src_param src_param[4];
struct wined3d_shader_src_param pred_param;
struct wined3d_shader_dst_param dst_param;
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
};
/* This table is not order or position dependent. */
static const struct wined3d_sm1_opcode_info vs_opcode_table[] =
{
/* Arithmetic */
wined3d: Move the SM1 opcode enum to shader_sm1.c.
2009-10-06 09:05:56 +02:00
{WINED3D_SM1_OP_NOP, 0, 0, WINED3DSIH_NOP, 0, 0 },
{WINED3D_SM1_OP_MOV, 1, 2, WINED3DSIH_MOV, 0, 0 },
{WINED3D_SM1_OP_MOVA, 1, 2, WINED3DSIH_MOVA, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3D_SM1_OP_ADD, 1, 3, WINED3DSIH_ADD, 0, 0 },
{WINED3D_SM1_OP_SUB, 1, 3, WINED3DSIH_SUB, 0, 0 },
{WINED3D_SM1_OP_MAD, 1, 4, WINED3DSIH_MAD, 0, 0 },
{WINED3D_SM1_OP_MUL, 1, 3, WINED3DSIH_MUL, 0, 0 },
{WINED3D_SM1_OP_RCP, 1, 2, WINED3DSIH_RCP, 0, 0 },
{WINED3D_SM1_OP_RSQ, 1, 2, WINED3DSIH_RSQ, 0, 0 },
{WINED3D_SM1_OP_DP3, 1, 3, WINED3DSIH_DP3, 0, 0 },
{WINED3D_SM1_OP_DP4, 1, 3, WINED3DSIH_DP4, 0, 0 },
{WINED3D_SM1_OP_MIN, 1, 3, WINED3DSIH_MIN, 0, 0 },
{WINED3D_SM1_OP_MAX, 1, 3, WINED3DSIH_MAX, 0, 0 },
{WINED3D_SM1_OP_SLT, 1, 3, WINED3DSIH_SLT, 0, 0 },
{WINED3D_SM1_OP_SGE, 1, 3, WINED3DSIH_SGE, 0, 0 },
{WINED3D_SM1_OP_ABS, 1, 2, WINED3DSIH_ABS, 0, 0 },
{WINED3D_SM1_OP_EXP, 1, 2, WINED3DSIH_EXP, 0, 0 },
{WINED3D_SM1_OP_LOG, 1, 2, WINED3DSIH_LOG, 0, 0 },
{WINED3D_SM1_OP_EXPP, 1, 2, WINED3DSIH_EXPP, 0, 0 },
{WINED3D_SM1_OP_LOGP, 1, 2, WINED3DSIH_LOGP, 0, 0 },
{WINED3D_SM1_OP_LIT, 1, 2, WINED3DSIH_LIT, 0, 0 },
{WINED3D_SM1_OP_DST, 1, 3, WINED3DSIH_DST, 0, 0 },
{WINED3D_SM1_OP_LRP, 1, 4, WINED3DSIH_LRP, 0, 0 },
{WINED3D_SM1_OP_FRC, 1, 2, WINED3DSIH_FRC, 0, 0 },
{WINED3D_SM1_OP_POW, 1, 3, WINED3DSIH_POW, 0, 0 },
{WINED3D_SM1_OP_CRS, 1, 3, WINED3DSIH_CRS, 0, 0 },
{WINED3D_SM1_OP_SGN, 1, 4, WINED3DSIH_SGN, WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
{WINED3D_SM1_OP_SGN, 1, 2, WINED3DSIH_SGN, WINED3D_SHADER_VERSION(3,0), -1 },
{WINED3D_SM1_OP_NRM, 1, 2, WINED3DSIH_NRM, 0, 0 },
{WINED3D_SM1_OP_SINCOS, 1, 4, WINED3DSIH_SINCOS, WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
{WINED3D_SM1_OP_SINCOS, 1, 2, WINED3DSIH_SINCOS, WINED3D_SHADER_VERSION(3,0), -1 },
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
/* Matrix */
wined3d: Move the SM1 opcode enum to shader_sm1.c.
2009-10-06 09:05:56 +02:00
{WINED3D_SM1_OP_M4x4, 1, 3, WINED3DSIH_M4x4, 0, 0 },
{WINED3D_SM1_OP_M4x3, 1, 3, WINED3DSIH_M4x3, 0, 0 },
{WINED3D_SM1_OP_M3x4, 1, 3, WINED3DSIH_M3x4, 0, 0 },
{WINED3D_SM1_OP_M3x3, 1, 3, WINED3DSIH_M3x3, 0, 0 },
{WINED3D_SM1_OP_M3x2, 1, 3, WINED3DSIH_M3x2, 0, 0 },
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
/* Declare registers */
wined3d: Move the SM1 opcode enum to shader_sm1.c.
2009-10-06 09:05:56 +02:00
{WINED3D_SM1_OP_DCL, 0, 2, WINED3DSIH_DCL, 0, 0 },
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
/* Constant definitions */
wined3d: Move the SM1 opcode enum to shader_sm1.c.
2009-10-06 09:05:56 +02:00
{WINED3D_SM1_OP_DEF, 1, 5, WINED3DSIH_DEF, 0, 0 },
{WINED3D_SM1_OP_DEFB, 1, 2, WINED3DSIH_DEFB, 0, 0 },
{WINED3D_SM1_OP_DEFI, 1, 5, WINED3DSIH_DEFI, 0, 0 },
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
/* Flow control */
wined3d: Move the SM1 opcode enum to shader_sm1.c.
2009-10-06 09:05:56 +02:00
{WINED3D_SM1_OP_REP, 0, 1, WINED3DSIH_REP, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3D_SM1_OP_ENDREP, 0, 0, WINED3DSIH_ENDREP, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3D_SM1_OP_IF, 0, 1, WINED3DSIH_IF, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3D_SM1_OP_IFC, 0, 2, WINED3DSIH_IFC, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3D_SM1_OP_ELSE, 0, 0, WINED3DSIH_ELSE, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3D_SM1_OP_ENDIF, 0, 0, WINED3DSIH_ENDIF, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3D_SM1_OP_BREAK, 0, 0, WINED3DSIH_BREAK, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3D_SM1_OP_BREAKC, 0, 2, WINED3DSIH_BREAKC, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3D_SM1_OP_BREAKP, 0, 1, WINED3DSIH_BREAKP, 0, 0 },
{WINED3D_SM1_OP_CALL, 0, 1, WINED3DSIH_CALL, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3D_SM1_OP_CALLNZ, 0, 2, WINED3DSIH_CALLNZ, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3D_SM1_OP_LOOP, 0, 2, WINED3DSIH_LOOP, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3D_SM1_OP_RET, 0, 0, WINED3DSIH_RET, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3D_SM1_OP_ENDLOOP, 0, 0, WINED3DSIH_ENDLOOP, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3D_SM1_OP_LABEL, 0, 1, WINED3DSIH_LABEL, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3D_SM1_OP_SETP, 1, 3, WINED3DSIH_SETP, 0, 0 },
{WINED3D_SM1_OP_TEXLDL, 1, 3, WINED3DSIH_TEXLDL, WINED3D_SHADER_VERSION(3,0), -1 },
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
{0, 0, 0, WINED3DSIH_TABLE_SIZE, 0, 0 },
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
};
static const struct wined3d_sm1_opcode_info ps_opcode_table[] =
{
/* Arithmetic */
wined3d: Move the SM1 opcode enum to shader_sm1.c.
2009-10-06 09:05:56 +02:00
{WINED3D_SM1_OP_NOP, 0, 0, WINED3DSIH_NOP, 0, 0 },
{WINED3D_SM1_OP_MOV, 1, 2, WINED3DSIH_MOV, 0, 0 },
{WINED3D_SM1_OP_ADD, 1, 3, WINED3DSIH_ADD, 0, 0 },
{WINED3D_SM1_OP_SUB, 1, 3, WINED3DSIH_SUB, 0, 0 },
{WINED3D_SM1_OP_MAD, 1, 4, WINED3DSIH_MAD, 0, 0 },
{WINED3D_SM1_OP_MUL, 1, 3, WINED3DSIH_MUL, 0, 0 },
{WINED3D_SM1_OP_RCP, 1, 2, WINED3DSIH_RCP, 0, 0 },
{WINED3D_SM1_OP_RSQ, 1, 2, WINED3DSIH_RSQ, 0, 0 },
{WINED3D_SM1_OP_DP3, 1, 3, WINED3DSIH_DP3, 0, 0 },
{WINED3D_SM1_OP_DP4, 1, 3, WINED3DSIH_DP4, 0, 0 },
{WINED3D_SM1_OP_MIN, 1, 3, WINED3DSIH_MIN, 0, 0 },
{WINED3D_SM1_OP_MAX, 1, 3, WINED3DSIH_MAX, 0, 0 },
{WINED3D_SM1_OP_SLT, 1, 3, WINED3DSIH_SLT, 0, 0 },
{WINED3D_SM1_OP_SGE, 1, 3, WINED3DSIH_SGE, 0, 0 },
{WINED3D_SM1_OP_ABS, 1, 2, WINED3DSIH_ABS, 0, 0 },
{WINED3D_SM1_OP_EXP, 1, 2, WINED3DSIH_EXP, 0, 0 },
{WINED3D_SM1_OP_LOG, 1, 2, WINED3DSIH_LOG, 0, 0 },
{WINED3D_SM1_OP_EXPP, 1, 2, WINED3DSIH_EXPP, 0, 0 },
{WINED3D_SM1_OP_LOGP, 1, 2, WINED3DSIH_LOGP, 0, 0 },
{WINED3D_SM1_OP_DST, 1, 3, WINED3DSIH_DST, 0, 0 },
{WINED3D_SM1_OP_LRP, 1, 4, WINED3DSIH_LRP, 0, 0 },
{WINED3D_SM1_OP_FRC, 1, 2, WINED3DSIH_FRC, 0, 0 },
{WINED3D_SM1_OP_CND, 1, 4, WINED3DSIH_CND, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,4)},
{WINED3D_SM1_OP_CMP, 1, 4, WINED3DSIH_CMP, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(3,0)},
{WINED3D_SM1_OP_POW, 1, 3, WINED3DSIH_POW, 0, 0 },
{WINED3D_SM1_OP_CRS, 1, 3, WINED3DSIH_CRS, 0, 0 },
{WINED3D_SM1_OP_NRM, 1, 2, WINED3DSIH_NRM, 0, 0 },
{WINED3D_SM1_OP_SINCOS, 1, 4, WINED3DSIH_SINCOS, WINED3D_SHADER_VERSION(2,0), WINED3D_SHADER_VERSION(2,1)},
{WINED3D_SM1_OP_SINCOS, 1, 2, WINED3DSIH_SINCOS, WINED3D_SHADER_VERSION(3,0), -1 },
{WINED3D_SM1_OP_DP2ADD, 1, 4, WINED3DSIH_DP2ADD, WINED3D_SHADER_VERSION(2,0), -1 },
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
/* Matrix */
wined3d: Move the SM1 opcode enum to shader_sm1.c.
2009-10-06 09:05:56 +02:00
{WINED3D_SM1_OP_M4x4, 1, 3, WINED3DSIH_M4x4, 0, 0 },
{WINED3D_SM1_OP_M4x3, 1, 3, WINED3DSIH_M4x3, 0, 0 },
{WINED3D_SM1_OP_M3x4, 1, 3, WINED3DSIH_M3x4, 0, 0 },
{WINED3D_SM1_OP_M3x3, 1, 3, WINED3DSIH_M3x3, 0, 0 },
{WINED3D_SM1_OP_M3x2, 1, 3, WINED3DSIH_M3x2, 0, 0 },
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
/* Register declarations */
wined3d: Move the SM1 opcode enum to shader_sm1.c.
2009-10-06 09:05:56 +02:00
{WINED3D_SM1_OP_DCL, 0, 2, WINED3DSIH_DCL, 0, 0 },
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
/* Flow control */
wined3d: Move the SM1 opcode enum to shader_sm1.c.
2009-10-06 09:05:56 +02:00
{WINED3D_SM1_OP_REP, 0, 1, WINED3DSIH_REP, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3D_SM1_OP_ENDREP, 0, 0, WINED3DSIH_ENDREP, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3D_SM1_OP_IF, 0, 1, WINED3DSIH_IF, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3D_SM1_OP_IFC, 0, 2, WINED3DSIH_IFC, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3D_SM1_OP_ELSE, 0, 0, WINED3DSIH_ELSE, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3D_SM1_OP_ENDIF, 0, 0, WINED3DSIH_ENDIF, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3D_SM1_OP_BREAK, 0, 0, WINED3DSIH_BREAK, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3D_SM1_OP_BREAKC, 0, 2, WINED3DSIH_BREAKC, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3D_SM1_OP_BREAKP, 0, 1, WINED3DSIH_BREAKP, 0, 0 },
{WINED3D_SM1_OP_CALL, 0, 1, WINED3DSIH_CALL, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3D_SM1_OP_CALLNZ, 0, 2, WINED3DSIH_CALLNZ, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3D_SM1_OP_LOOP, 0, 2, WINED3DSIH_LOOP, WINED3D_SHADER_VERSION(3,0), -1 },
{WINED3D_SM1_OP_RET, 0, 0, WINED3DSIH_RET, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3D_SM1_OP_ENDLOOP, 0, 0, WINED3DSIH_ENDLOOP, WINED3D_SHADER_VERSION(3,0), -1 },
{WINED3D_SM1_OP_LABEL, 0, 1, WINED3DSIH_LABEL, WINED3D_SHADER_VERSION(2,1), -1 },
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
/* Constant definitions */
wined3d: Move the SM1 opcode enum to shader_sm1.c.
2009-10-06 09:05:56 +02:00
{WINED3D_SM1_OP_DEF, 1, 5, WINED3DSIH_DEF, 0, 0 },
{WINED3D_SM1_OP_DEFB, 1, 2, WINED3DSIH_DEFB, 0, 0 },
{WINED3D_SM1_OP_DEFI, 1, 5, WINED3DSIH_DEFI, 0, 0 },
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
/* Texture */
wined3d: Move the SM1 opcode enum to shader_sm1.c.
2009-10-06 09:05:56 +02:00
{WINED3D_SM1_OP_TEXCOORD, 1, 1, WINED3DSIH_TEXCOORD, 0, WINED3D_SHADER_VERSION(1,3)},
{WINED3D_SM1_OP_TEXCOORD, 1, 2, WINED3DSIH_TEXCOORD, WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
{WINED3D_SM1_OP_TEXKILL, 1, 1, WINED3DSIH_TEXKILL, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(3,0)},
{WINED3D_SM1_OP_TEX, 1, 1, WINED3DSIH_TEX, 0, WINED3D_SHADER_VERSION(1,3)},
{WINED3D_SM1_OP_TEX, 1, 2, WINED3DSIH_TEX, WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
{WINED3D_SM1_OP_TEX, 1, 3, WINED3DSIH_TEX, WINED3D_SHADER_VERSION(2,0), -1 },
{WINED3D_SM1_OP_TEXBEM, 1, 2, WINED3DSIH_TEXBEM, 0, WINED3D_SHADER_VERSION(1,3)},
{WINED3D_SM1_OP_TEXBEML, 1, 2, WINED3DSIH_TEXBEML, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3D_SM1_OP_TEXREG2AR, 1, 2, WINED3DSIH_TEXREG2AR, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3D_SM1_OP_TEXREG2GB, 1, 2, WINED3DSIH_TEXREG2GB, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3D_SM1_OP_TEXREG2RGB, 1, 2, WINED3DSIH_TEXREG2RGB, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
{WINED3D_SM1_OP_TEXM3x2PAD, 1, 2, WINED3DSIH_TEXM3x2PAD, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3D_SM1_OP_TEXM3x2TEX, 1, 2, WINED3DSIH_TEXM3x2TEX, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3D_SM1_OP_TEXM3x3PAD, 1, 2, WINED3DSIH_TEXM3x3PAD, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3D_SM1_OP_TEXM3x3DIFF, 1, 2, WINED3DSIH_TEXM3x3DIFF, WINED3D_SHADER_VERSION(0,0), WINED3D_SHADER_VERSION(0,0)},
{WINED3D_SM1_OP_TEXM3x3SPEC, 1, 3, WINED3DSIH_TEXM3x3SPEC, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3D_SM1_OP_TEXM3x3VSPEC, 1, 2, WINED3DSIH_TEXM3x3VSPEC, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3D_SM1_OP_TEXM3x3TEX, 1, 2, WINED3DSIH_TEXM3x3TEX, WINED3D_SHADER_VERSION(1,0), WINED3D_SHADER_VERSION(1,3)},
{WINED3D_SM1_OP_TEXDP3TEX, 1, 2, WINED3DSIH_TEXDP3TEX, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
{WINED3D_SM1_OP_TEXM3x2DEPTH, 1, 2, WINED3DSIH_TEXM3x2DEPTH, WINED3D_SHADER_VERSION(1,3), WINED3D_SHADER_VERSION(1,3)},
{WINED3D_SM1_OP_TEXDP3, 1, 2, WINED3DSIH_TEXDP3, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
{WINED3D_SM1_OP_TEXM3x3, 1, 2, WINED3DSIH_TEXM3x3, WINED3D_SHADER_VERSION(1,2), WINED3D_SHADER_VERSION(1,3)},
{WINED3D_SM1_OP_TEXDEPTH, 1, 1, WINED3DSIH_TEXDEPTH, WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
{WINED3D_SM1_OP_BEM, 1, 3, WINED3DSIH_BEM, WINED3D_SHADER_VERSION(1,4), WINED3D_SHADER_VERSION(1,4)},
{WINED3D_SM1_OP_DSX, 1, 2, WINED3DSIH_DSX, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3D_SM1_OP_DSY, 1, 2, WINED3DSIH_DSY, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3D_SM1_OP_TEXLDD, 1, 5, WINED3DSIH_TEXLDD, WINED3D_SHADER_VERSION(2,1), -1 },
{WINED3D_SM1_OP_SETP, 1, 3, WINED3DSIH_SETP, 0, 0 },
{WINED3D_SM1_OP_TEXLDL, 1, 3, WINED3DSIH_TEXLDL, WINED3D_SHADER_VERSION(3,0), -1 },
{WINED3D_SM1_OP_PHASE, 0, 0, WINED3DSIH_PHASE, 0, 0 },
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
{0, 0, 0, WINED3DSIH_TABLE_SIZE, 0, 0 },
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
};
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
/* Read a parameter opcode from the input stream,
* and possibly a relative addressing token.
* Return the number of tokens read */
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
static int shader_get_param(const struct wined3d_sm1_data *priv, const DWORD *ptr, DWORD *token, DWORD *addr_token)
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
{
UINT count = 1;
*token = *ptr;
/* PS >= 3.0 have relative addressing (with token)
* VS >= 2.0 have relative addressing (with token)
* VS >= 1.0 < 2.0 have relative addressing (without token)
* The version check below should work in general */
if (*ptr & WINED3DSHADER_ADDRMODE_RELATIVE)
{
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
if (priv->shader_version.major < 2)
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
{
*addr_token = (1 << 31)
| ((WINED3DSPR_ADDR << WINED3DSP_REGTYPE_SHIFT2) & WINED3DSP_REGTYPE_MASK2)
| ((WINED3DSPR_ADDR << WINED3DSP_REGTYPE_SHIFT) & WINED3DSP_REGTYPE_MASK)
| (WINED3DSP_NOSWIZZLE << WINED3DSP_SWIZZLE_SHIFT);
}
else
{
*addr_token = *(ptr + 1);
++count;
}
}
return count;
}
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
static const struct wined3d_sm1_opcode_info *shader_get_opcode(const struct wined3d_sm1_data *priv, DWORD code)
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
{
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
DWORD shader_version = WINED3D_SHADER_VERSION(priv->shader_version.major, priv->shader_version.minor);
const struct wined3d_sm1_opcode_info *opcode_table = priv->opcode_table;
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
DWORD i = 0;
while (opcode_table[i].handler_idx != WINED3DSIH_TABLE_SIZE)
{
if ((code & WINED3DSI_OPCODE_MASK) == opcode_table[i].opcode
&& shader_version >= opcode_table[i].min_version
&& (!opcode_table[i].max_version || shader_version <= opcode_table[i].max_version))
{
return &opcode_table[i];
}
++i;
}
FIXME("Unsupported opcode %#x(%d) masked %#x, shader version %#x\n",
code, code, code & WINED3DSI_OPCODE_MASK, shader_version);
return NULL;
}
/* Return the number of parameters to skip for an opcode */
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
static int shader_skip_opcode(const struct wined3d_sm1_data *priv,
const struct wined3d_sm1_opcode_info *opcode_info, DWORD opcode_token)
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
{
/* Shaders >= 2.0 may contain address tokens, but fortunately they
* have a useful length mask - use it here. Shaders 1.0 contain no such tokens */
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
return (priv->shader_version.major >= 2)
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
? ((opcode_token & WINED3DSI_INSTLENGTH_MASK) >> WINED3DSI_INSTLENGTH_SHIFT) : opcode_info->param_count;
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
}
static void shader_parse_src_param(DWORD param, const struct wined3d_shader_src_param *rel_addr,
struct wined3d_shader_src_param *src)
{
wined3d: Group register information into struct wined3d_shader_register.
2009-05-07 16:36:07 +02:00
src->reg.type = ((param & WINED3DSP_REGTYPE_MASK) >> WINED3DSP_REGTYPE_SHIFT)
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
| ((param & WINED3DSP_REGTYPE_MASK2) >> WINED3DSP_REGTYPE_SHIFT2);
wined3d: Add type information to shader registers.
2012-09-04 20:15:09 +02:00
src->reg.data_type = WINED3D_DATA_FLOAT;
wined3d: Introduce a structure for shader register indices.
2012-10-14 18:40:36 +02:00
src->reg.idx[0].offset = param & WINED3DSP_REGNUM_MASK;
src->reg.idx[0].rel_addr = rel_addr;
src->reg.idx[1].offset = ~0U;
src->reg.idx[1].rel_addr = NULL;
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
src->swizzle = (param & WINED3DSP_SWIZZLE_MASK) >> WINED3DSP_SWIZZLE_SHIFT;
src->modifiers = (param & WINED3DSP_SRCMOD_MASK) >> WINED3DSP_SRCMOD_SHIFT;
}
static void shader_parse_dst_param(DWORD param, const struct wined3d_shader_src_param *rel_addr,
struct wined3d_shader_dst_param *dst)
{
wined3d: Group register information into struct wined3d_shader_register.
2009-05-07 16:36:07 +02:00
dst->reg.type = ((param & WINED3DSP_REGTYPE_MASK) >> WINED3DSP_REGTYPE_SHIFT)
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
| ((param & WINED3DSP_REGTYPE_MASK2) >> WINED3DSP_REGTYPE_SHIFT2);
wined3d: Add type information to shader registers.
2012-09-04 20:15:09 +02:00
dst->reg.data_type = WINED3D_DATA_FLOAT;
wined3d: Introduce a structure for shader register indices.
2012-10-14 18:40:36 +02:00
dst->reg.idx[0].offset = param & WINED3DSP_REGNUM_MASK;
dst->reg.idx[0].rel_addr = rel_addr;
dst->reg.idx[1].offset = ~0U;
dst->reg.idx[1].rel_addr = NULL;
wined3d: Shift the writemask in the frontend.
2009-05-06 10:05:45 +02:00
dst->write_mask = (param & WINED3D_SM1_WRITEMASK_MASK) >> WINED3D_SM1_WRITEMASK_SHIFT;
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
dst->modifiers = (param & WINED3DSP_DSTMOD_MASK) >> WINED3DSP_DSTMOD_SHIFT;
dst->shift = (param & WINED3DSP_DSTSHIFT_MASK) >> WINED3DSP_DSTSHIFT_SHIFT;
}
/* Read the parameters of an unrecognized opcode from the input stream
* Return the number of tokens read.
*
* Note: This function assumes source or destination token format.
* It will not work with specially-formatted tokens like DEF or DCL,
* but hopefully those would be recognized */
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
static int shader_skip_unrecognized(const struct wined3d_sm1_data *priv, const DWORD *ptr)
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
{
int tokens_read = 0;
int i = 0;
/* TODO: Think of a good name for 0x80000000 and replace it with a constant */
while (*ptr & 0x80000000)
{
DWORD token, addr_token = 0;
struct wined3d_shader_src_param rel_addr;
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
tokens_read += shader_get_param(priv, ptr, &token, &addr_token);
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
ptr += tokens_read;
FIXME("Unrecognized opcode param: token=0x%08x addr_token=0x%08x name=", token, addr_token);
if (token & WINED3DSHADER_ADDRMODE_RELATIVE) shader_parse_src_param(addr_token, NULL, &rel_addr);
if (!i)
{
struct wined3d_shader_dst_param dst;
shader_parse_dst_param(token, token & WINED3DSHADER_ADDRMODE_RELATIVE ? &rel_addr : NULL, &dst);
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
shader_dump_dst_param(&dst, &priv->shader_version);
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
}
else
{
struct wined3d_shader_src_param src;
shader_parse_src_param(token, token & WINED3DSHADER_ADDRMODE_RELATIVE ? &rel_addr : NULL, &src);
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
shader_dump_src_param(&src, &priv->shader_version);
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
}
FIXME("\n");
++i;
}
return tokens_read;
}
wined3d: Use the output signature to map SM4 pixel shader outputs to the appropriate register.
2009-05-08 17:44:25 +02:00
static void *shader_sm1_init(const DWORD *byte_code, const struct wined3d_shader_signature *output_signature)
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
{
wined3d: Refuse to parse shaders with an invalid version token.
2009-10-26 10:12:17 +01:00
struct wined3d_sm1_data *priv;
BYTE major, minor;
major = WINED3D_SM1_VERSION_MAJOR(*byte_code);
minor = WINED3D_SM1_VERSION_MINOR(*byte_code);
if (WINED3D_SHADER_VERSION(major, minor) > WINED3D_SHADER_VERSION(3, 0))
{
WARN("Invalid shader version %u.%u (%#x).\n", major, minor, *byte_code);
return NULL;
}
priv = HeapAlloc(GetProcessHeap(), 0, sizeof(*priv));
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
if (!priv)
{
ERR("Failed to allocate private data\n");
return NULL;
}
wined3d: Use the output signature to map SM4 pixel shader outputs to the appropriate register.
2009-05-08 17:44:25 +02:00
if (output_signature)
{
FIXME("SM 1-3 shader shouldn't have output signatures.\n");
}
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
switch (*byte_code >> 16)
{
case WINED3D_SM1_VS:
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
priv->shader_version.type = WINED3D_SHADER_TYPE_VERTEX;
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
priv->opcode_table = vs_opcode_table;
break;
case WINED3D_SM1_PS:
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
priv->shader_version.type = WINED3D_SHADER_TYPE_PIXEL;
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
priv->opcode_table = ps_opcode_table;
break;
default:
FIXME("Unrecognized shader type %#x\n", *byte_code >> 16);
HeapFree(GetProcessHeap(), 0, priv);
return NULL;
}
return priv;
}
static void shader_sm1_free(void *data)
{
HeapFree(GetProcessHeap(), 0, data);
}
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
static void shader_sm1_read_header(void *data, const DWORD **ptr, struct wined3d_shader_version *shader_version)
wined3d: Handle reading the shader header in the frontend. In SM 1-3 this is just the version, in SM4 this also includes the token count.
2009-05-05 09:38:03 +02:00
{
wined3d: Store the shader version in the frontend's private data.
2009-05-06 17:59:21 +02:00
struct wined3d_sm1_data *priv = data;
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
DWORD version_token;
wined3d: Store the shader version in the frontend's private data.
2009-05-06 17:59:21 +02:00
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
version_token = *(*ptr)++;
TRACE("version: 0x%08x\n", version_token);
wined3d: Store the shader version in the frontend's private data.
2009-05-06 17:59:21 +02:00
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
priv->shader_version.major = WINED3D_SM1_VERSION_MAJOR(version_token);
priv->shader_version.minor = WINED3D_SM1_VERSION_MINOR(version_token);
*shader_version = priv->shader_version;
wined3d: Handle reading the shader header in the frontend. In SM 1-3 this is just the version, in SM4 this also includes the token count.
2009-05-05 09:38:03 +02:00
}
wined3d: Read complete shader instructions at a time.
2012-09-04 20:15:08 +02:00
static void shader_sm1_read_src_param(struct wined3d_sm1_data *priv, const DWORD **ptr,
struct wined3d_shader_src_param *src_param, struct wined3d_shader_src_param *src_rel_addr)
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
{
DWORD token, addr_token;
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
*ptr += shader_get_param(priv, *ptr, &token, &addr_token);
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
if (token & WINED3DSHADER_ADDRMODE_RELATIVE)
{
shader_parse_src_param(addr_token, NULL, src_rel_addr);
shader_parse_src_param(token, src_rel_addr, src_param);
}
else
{
shader_parse_src_param(token, NULL, src_param);
}
}
wined3d: Read complete shader instructions at a time.
2012-09-04 20:15:08 +02:00
static void shader_sm1_read_dst_param(struct wined3d_sm1_data *priv, const DWORD **ptr,
struct wined3d_shader_dst_param *dst_param, struct wined3d_shader_src_param *dst_rel_addr)
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
{
DWORD token, addr_token;
wined3d: Create a struct wined3d_shader_version to store version information. The version tokens in SM1-3 and SM4 are similar, but not the same.
2009-05-06 17:59:21 +02:00
*ptr += shader_get_param(priv, *ptr, &token, &addr_token);
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
if (token & WINED3DSHADER_ADDRMODE_RELATIVE)
{
shader_parse_src_param(addr_token, NULL, dst_rel_addr);
shader_parse_dst_param(token, dst_rel_addr, dst_param);
}
else
{
shader_parse_dst_param(token, NULL, dst_param);
}
}
wined3d: Create a frontend for parsing shaders.
2009-05-04 09:49:27 +02:00
static void shader_sm1_read_semantic(const DWORD **ptr, struct wined3d_shader_semantic *semantic)
wined3d: Move SM 1-3 parsing functions to their own file.
2009-05-04 09:49:27 +02:00
{
DWORD usage_token = *(*ptr)++;
DWORD dst_token = *(*ptr)++;
semantic->usage = (usage_token & WINED3DSP_DCL_USAGE_MASK) >> WINED3DSP_DCL_USAGE_SHIFT;
semantic->usage_idx = (usage_token & WINED3DSP_DCL_USAGEINDEX_MASK) >> WINED3DSP_DCL_USAGEINDEX_SHIFT;
semantic->sampler_type = (usage_token & WINED3DSP_TEXTURETYPE_MASK) >> WINED3DSP_TEXTURETYPE_SHIFT;
shader_parse_dst_param(dst_token, NULL, &semantic->reg);
}
wined3d: Read complete shader instructions at a time.
2012-09-04 20:15:08 +02:00
static void shader_sm1_read_immconst(const DWORD **ptr, struct wined3d_shader_src_param *src_param,
wined3d: Add type information to shader registers.
2012-09-04 20:15:09 +02:00
enum wined3d_immconst_type type, enum wined3d_data_type data_type)
wined3d: Read complete shader instructions at a time.
2012-09-04 20:15:08 +02:00
{
UINT count = type == WINED3D_IMMCONST_VEC4 ? 4 : 1;
src_param->reg.type = WINED3DSPR_IMMCONST;
wined3d: Add type information to shader registers.
2012-09-04 20:15:09 +02:00
src_param->reg.data_type = data_type;
wined3d: Introduce a structure for shader register indices.
2012-10-14 18:40:36 +02:00
src_param->reg.idx[0].offset = ~0U;
src_param->reg.idx[0].rel_addr = NULL;
src_param->reg.idx[1].offset = ~0U;
src_param->reg.idx[1].rel_addr = NULL;
wined3d: Read complete shader instructions at a time.
2012-09-04 20:15:08 +02:00
src_param->reg.immconst_type = type;
memcpy(src_param->reg.immconst_data, *ptr, count * sizeof(DWORD));
src_param->swizzle = WINED3DSP_NOSWIZZLE;
src_param->modifiers = 0;
*ptr += count;
}
wined3d: Handle SM1 comments in the frontend.
2012-10-14 18:40:37 +02:00
static void shader_sm1_read_comment(const DWORD **ptr)
{
DWORD token = **ptr;
const char *comment;
UINT size;
while ((token & WINED3DSI_OPCODE_MASK) == WINED3D_SM1_OP_COMMENT)
{
size = (token & WINED3DSI_COMMENTSIZE_MASK) >> WINED3DSI_COMMENTSIZE_SHIFT;
comment = (const char *)++(*ptr);
*ptr += size;
if (size > 1 && *(const DWORD *)comment == WINEMAKEFOURCC('T', 'E', 'X', 'T'))
{
const char *end = comment + size * sizeof(token);
const char *p = comment + sizeof(token);
const char *line = p;
TRACE("// TEXT\n");
while (p != end)
{
if (*p == '\n')
{
UINT len = p - line;
if (len && *(p - 1) == '\r') --len;
TRACE("// %s\n", debugstr_an(line, len));
line = ++p;
}
else ++p;
}
if (line != p)
TRACE("// %s\n", debugstr_an(line, p - line));
}
else if (size)
TRACE("// %s\n", debugstr_an(comment, size * sizeof(token)));
else
break;
token = **ptr;
}
}
wined3d: Read complete shader instructions at a time.
2012-09-04 20:15:08 +02:00
static void shader_sm1_read_instruction(void *data, const DWORD **ptr, struct wined3d_shader_instruction *ins)
{
const struct wined3d_sm1_opcode_info *opcode_info;
struct wined3d_sm1_data *priv = data;
DWORD opcode_token;
unsigned int i;
const DWORD *p;
wined3d: Handle SM1 comments in the frontend.
2012-10-14 18:40:37 +02:00
shader_sm1_read_comment(ptr);
wined3d: Read complete shader instructions at a time.
2012-09-04 20:15:08 +02:00
opcode_token = *(*ptr)++;
if (!(opcode_info = shader_get_opcode(priv, opcode_token)))
{
FIXME("Unrecognized opcode: token=0x%08x.\n", opcode_token);
ins->handler_idx = WINED3DSIH_TABLE_SIZE;
*ptr += shader_skip_unrecognized(priv, *ptr);
return;
}
ins->handler_idx = opcode_info->handler_idx;
ins->flags = (opcode_token & WINED3D_OPCODESPECIFICCONTROL_MASK) >> WINED3D_OPCODESPECIFICCONTROL_SHIFT;
ins->coissue = opcode_token & WINED3DSI_COISSUE;
ins->predicate = opcode_token & WINED3DSHADER_INSTRUCTION_PREDICATED ? &priv->pred_param : NULL;
ins->dst_count = opcode_info->dst_count ? 1 : 0;
ins->dst = &priv->dst_param;
ins->src_count = opcode_info->param_count - opcode_info->dst_count;
ins->src = priv->src_param;
p = *ptr;
*ptr += shader_skip_opcode(priv, opcode_info, opcode_token);
if (ins->handler_idx == WINED3DSIH_DCL)
{
wined3d: Introduce a union for declaration shader instruction arguments.
2012-09-17 12:22:22 +02:00
shader_sm1_read_semantic(&p, &ins->declaration.semantic);
wined3d: Read complete shader instructions at a time.
2012-09-04 20:15:08 +02:00
}
wined3d: Add type information to shader registers.
2012-09-04 20:15:09 +02:00
else if (ins->handler_idx == WINED3DSIH_DEF)
wined3d: Read complete shader instructions at a time.
2012-09-04 20:15:08 +02:00
{
shader_sm1_read_dst_param(priv, &p, &priv->dst_param, &priv->dst_rel_addr);
wined3d: Add type information to shader registers.
2012-09-04 20:15:09 +02:00
shader_sm1_read_immconst(&p, &priv->src_param[0], WINED3D_IMMCONST_VEC4, WINED3D_DATA_FLOAT);
}
else if (ins->handler_idx == WINED3DSIH_DEFI)
{
shader_sm1_read_dst_param(priv, &p, &priv->dst_param, &priv->dst_rel_addr);
shader_sm1_read_immconst(&p, &priv->src_param[0], WINED3D_IMMCONST_VEC4, WINED3D_DATA_INT);
wined3d: Read complete shader instructions at a time.
2012-09-04 20:15:08 +02:00
}
else if (ins->handler_idx == WINED3DSIH_DEFB)
{
shader_sm1_read_dst_param(priv, &p, &priv->dst_param, &priv->dst_rel_addr);
wined3d: Add type information to shader registers.
2012-09-04 20:15:09 +02:00
shader_sm1_read_immconst(&p, &priv->src_param[0], WINED3D_IMMCONST_SCALAR, WINED3D_DATA_UINT);
wined3d: Read complete shader instructions at a time.
2012-09-04 20:15:08 +02:00
}
else
{
/* Destination token */
if (ins->dst_count)
shader_sm1_read_dst_param(priv, &p, &priv->dst_param, &priv->dst_rel_addr);
/* Predication token */
if (ins->predicate)
shader_sm1_read_src_param(priv, &p, &priv->pred_param, &priv->pred_rel_addr);
/* Other source tokens */
for (i = 0; i < ins->src_count; ++i)
{
shader_sm1_read_src_param(priv, &p, &priv->src_param[i], &priv->src_rel_addr[i]);
}
}
}
wined3d: Implement shader_sm4_is_end().
2009-05-05 09:38:03 +02:00
static BOOL shader_sm1_is_end(void *data, const DWORD **ptr)
wined3d: Add a frontend function to determine if there are any tokens left.
2009-05-04 09:49:27 +02:00
{
wined3d: Also read comments in shader_sm1_is_end().
2012-10-21 20:20:36 +02:00
shader_sm1_read_comment(ptr);
wined3d: Add a frontend function to determine if there are any tokens left.
2009-05-04 09:49:27 +02:00
if (**ptr == WINED3DSP_END)
{
++(*ptr);
return TRUE;
}
return FALSE;
}
wined3d: Create a frontend for parsing shaders.
2009-05-04 09:49:27 +02:00
const struct wined3d_shader_frontend sm1_shader_frontend =
{
wined3d: Store the SM 1-3 opcode information tables in the SM 1-3 frontend.
2009-05-05 09:38:03 +02:00
shader_sm1_init,
shader_sm1_free,
wined3d: Handle reading the shader header in the frontend. In SM 1-3 this is just the version, in SM4 this also includes the token count.
2009-05-05 09:38:03 +02:00
shader_sm1_read_header,
wined3d: Read complete shader instructions at a time.
2012-09-04 20:15:08 +02:00
shader_sm1_read_instruction,
wined3d: Add a frontend function to determine if there are any tokens left.
2009-05-04 09:49:27 +02:00
shader_sm1_is_end,
wined3d: Create a frontend for parsing shaders.
2009-05-04 09:49:27 +02:00
};