6226 lines
191 KiB
C
6226 lines
191 KiB
C
/*
|
|
* Copyright 2010 Christian Costa
|
|
* Copyright 2011 Rico Schüller
|
|
*
|
|
* 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"
|
|
#define NONAMELESSUNION
|
|
#include "wine/debug.h"
|
|
#include "wine/unicode.h"
|
|
|
|
#include "windef.h"
|
|
#include "wingdi.h"
|
|
#include "d3dx9_36_private.h"
|
|
|
|
/* Constants for special INT/FLOAT conversation */
|
|
#define INT_FLOAT_MULTI 255.0f
|
|
#define INT_FLOAT_MULTI_INVERSE (1/INT_FLOAT_MULTI)
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(d3dx);
|
|
|
|
static const struct ID3DXEffectVtbl ID3DXEffect_Vtbl;
|
|
static const struct ID3DXBaseEffectVtbl ID3DXBaseEffect_Vtbl;
|
|
static const struct ID3DXEffectCompilerVtbl ID3DXEffectCompiler_Vtbl;
|
|
|
|
enum STATE_CLASS
|
|
{
|
|
SC_LIGHTENABLE,
|
|
SC_FVF,
|
|
SC_LIGHT,
|
|
SC_MATERIAL,
|
|
SC_NPATCHMODE,
|
|
SC_PIXELSHADER,
|
|
SC_RENDERSTATE,
|
|
SC_SETSAMPLER,
|
|
SC_SAMPLERSTATE,
|
|
SC_TEXTURE,
|
|
SC_TEXTURESTAGE,
|
|
SC_TRANSFORM,
|
|
SC_VERTEXSHADER,
|
|
SC_SHADERCONST,
|
|
SC_UNKNOWN,
|
|
};
|
|
|
|
enum MATERIAL_TYPE
|
|
{
|
|
MT_DIFFUSE,
|
|
MT_AMBIENT,
|
|
MT_SPECULAR,
|
|
MT_EMISSIVE,
|
|
MT_POWER,
|
|
};
|
|
|
|
enum LIGHT_TYPE
|
|
{
|
|
LT_TYPE,
|
|
LT_DIFFUSE,
|
|
LT_SPECULAR,
|
|
LT_AMBIENT,
|
|
LT_POSITION,
|
|
LT_DIRECTION,
|
|
LT_RANGE,
|
|
LT_FALLOFF,
|
|
LT_ATTENUATION0,
|
|
LT_ATTENUATION1,
|
|
LT_ATTENUATION2,
|
|
LT_THETA,
|
|
LT_PHI,
|
|
};
|
|
|
|
enum SHADER_CONSTANT_TYPE
|
|
{
|
|
SCT_VSFLOAT,
|
|
SCT_VSBOOL,
|
|
SCT_VSINT,
|
|
SCT_PSFLOAT,
|
|
SCT_PSBOOL,
|
|
SCT_PSINT,
|
|
};
|
|
|
|
enum STATE_TYPE
|
|
{
|
|
ST_CONSTANT,
|
|
ST_PARAMETER,
|
|
ST_FXLC,
|
|
};
|
|
|
|
struct d3dx_parameter
|
|
{
|
|
char *name;
|
|
char *semantic;
|
|
void *data;
|
|
D3DXPARAMETER_CLASS class;
|
|
D3DXPARAMETER_TYPE type;
|
|
UINT rows;
|
|
UINT columns;
|
|
UINT element_count;
|
|
UINT annotation_count;
|
|
UINT member_count;
|
|
DWORD flags;
|
|
UINT bytes;
|
|
|
|
D3DXHANDLE *annotation_handles;
|
|
D3DXHANDLE *member_handles;
|
|
};
|
|
|
|
struct d3dx_state
|
|
{
|
|
UINT operation;
|
|
UINT index;
|
|
enum STATE_TYPE type;
|
|
D3DXHANDLE parameter;
|
|
};
|
|
|
|
struct d3dx_sampler
|
|
{
|
|
UINT state_count;
|
|
struct d3dx_state *states;
|
|
};
|
|
|
|
struct d3dx_pass
|
|
{
|
|
char *name;
|
|
UINT state_count;
|
|
UINT annotation_count;
|
|
|
|
struct d3dx_state *states;
|
|
D3DXHANDLE *annotation_handles;
|
|
};
|
|
|
|
struct d3dx_technique
|
|
{
|
|
char *name;
|
|
UINT pass_count;
|
|
UINT annotation_count;
|
|
|
|
D3DXHANDLE *annotation_handles;
|
|
D3DXHANDLE *pass_handles;
|
|
};
|
|
|
|
struct ID3DXBaseEffectImpl
|
|
{
|
|
ID3DXBaseEffect ID3DXBaseEffect_iface;
|
|
LONG ref;
|
|
|
|
struct ID3DXEffectImpl *effect;
|
|
|
|
UINT parameter_count;
|
|
UINT technique_count;
|
|
|
|
D3DXHANDLE *parameter_handles;
|
|
D3DXHANDLE *technique_handles;
|
|
};
|
|
|
|
struct ID3DXEffectImpl
|
|
{
|
|
ID3DXEffect ID3DXEffect_iface;
|
|
LONG ref;
|
|
|
|
LPD3DXEFFECTSTATEMANAGER manager;
|
|
LPDIRECT3DDEVICE9 device;
|
|
LPD3DXEFFECTPOOL pool;
|
|
D3DXHANDLE active_technique;
|
|
D3DXHANDLE active_pass;
|
|
|
|
ID3DXBaseEffect *base_effect;
|
|
};
|
|
|
|
struct ID3DXEffectCompilerImpl
|
|
{
|
|
ID3DXEffectCompiler ID3DXEffectCompiler_iface;
|
|
LONG ref;
|
|
|
|
ID3DXBaseEffect *base_effect;
|
|
};
|
|
|
|
static struct d3dx_parameter *get_parameter_by_name(struct ID3DXBaseEffectImpl *base,
|
|
struct d3dx_parameter *parameter, LPCSTR name);
|
|
static struct d3dx_parameter *get_parameter_annotation_by_name(struct d3dx_parameter *parameter, LPCSTR name);
|
|
static HRESULT d3dx9_parse_state(struct d3dx_state *state, const char *data, const char **ptr, D3DXHANDLE *objects);
|
|
static void free_parameter_state(D3DXHANDLE handle, BOOL element, BOOL child, enum STATE_TYPE st);
|
|
|
|
static const struct
|
|
{
|
|
enum STATE_CLASS class;
|
|
UINT op;
|
|
LPCSTR name;
|
|
}
|
|
state_table[] =
|
|
{
|
|
/* Render sates */
|
|
{SC_RENDERSTATE, D3DRS_ZENABLE, "D3DRS_ZENABLE"}, /* 0x0 */
|
|
{SC_RENDERSTATE, D3DRS_FILLMODE, "D3DRS_FILLMODE"},
|
|
{SC_RENDERSTATE, D3DRS_SHADEMODE, "D3DRS_SHADEMODE"},
|
|
{SC_RENDERSTATE, D3DRS_ZWRITEENABLE, "D3DRS_ZWRITEENABLE"},
|
|
{SC_RENDERSTATE, D3DRS_ALPHATESTENABLE, "D3DRS_ALPHATESTENABLE"},
|
|
{SC_RENDERSTATE, D3DRS_LASTPIXEL, "D3DRS_LASTPIXEL"},
|
|
{SC_RENDERSTATE, D3DRS_SRCBLEND, "D3DRS_SRCBLEND"},
|
|
{SC_RENDERSTATE, D3DRS_DESTBLEND, "D3DRS_DESTBLEND"},
|
|
{SC_RENDERSTATE, D3DRS_CULLMODE, "D3DRS_CULLMODE"},
|
|
{SC_RENDERSTATE, D3DRS_ZFUNC, "D3DRS_ZFUNC"},
|
|
{SC_RENDERSTATE, D3DRS_ALPHAREF, "D3DRS_ALPHAREF"},
|
|
{SC_RENDERSTATE, D3DRS_ALPHAFUNC, "D3DRS_ALPHAFUNC"},
|
|
{SC_RENDERSTATE, D3DRS_DITHERENABLE, "D3DRS_DITHERENABLE"},
|
|
{SC_RENDERSTATE, D3DRS_ALPHABLENDENABLE, "D3DRS_ALPHABLENDENABLE"},
|
|
{SC_RENDERSTATE, D3DRS_FOGENABLE, "D3DRS_FOGENABLE"},
|
|
{SC_RENDERSTATE, D3DRS_SPECULARENABLE, "D3DRS_SPECULARENABLE"},
|
|
{SC_RENDERSTATE, D3DRS_FOGCOLOR, "D3DRS_FOGCOLOR"}, /* 0x10 */
|
|
{SC_RENDERSTATE, D3DRS_FOGTABLEMODE, "D3DRS_FOGTABLEMODE"},
|
|
{SC_RENDERSTATE, D3DRS_FOGSTART, "D3DRS_FOGSTART"},
|
|
{SC_RENDERSTATE, D3DRS_FOGEND, "D3DRS_FOGEND"},
|
|
{SC_RENDERSTATE, D3DRS_FOGDENSITY, "D3DRS_FOGDENSITY"},
|
|
{SC_RENDERSTATE, D3DRS_RANGEFOGENABLE, "D3DRS_RANGEFOGENABLE"},
|
|
{SC_RENDERSTATE, D3DRS_STENCILENABLE, "D3DRS_STENCILENABLE"},
|
|
{SC_RENDERSTATE, D3DRS_STENCILFAIL, "D3DRS_STENCILFAIL"},
|
|
{SC_RENDERSTATE, D3DRS_STENCILZFAIL, "D3DRS_STENCILZFAIL"},
|
|
{SC_RENDERSTATE, D3DRS_STENCILPASS, "D3DRS_STENCILPASS"},
|
|
{SC_RENDERSTATE, D3DRS_STENCILFUNC, "D3DRS_STENCILFUNC"},
|
|
{SC_RENDERSTATE, D3DRS_STENCILREF, "D3DRS_STENCILREF"},
|
|
{SC_RENDERSTATE, D3DRS_STENCILMASK, "D3DRS_STENCILMASK"},
|
|
{SC_RENDERSTATE, D3DRS_STENCILWRITEMASK, "D3DRS_STENCILWRITEMASK"},
|
|
{SC_RENDERSTATE, D3DRS_TEXTUREFACTOR, "D3DRS_TEXTUREFACTOR"},
|
|
{SC_RENDERSTATE, D3DRS_WRAP0, "D3DRS_WRAP0"},
|
|
{SC_RENDERSTATE, D3DRS_WRAP1, "D3DRS_WRAP1"}, /* 0x20 */
|
|
{SC_RENDERSTATE, D3DRS_WRAP2, "D3DRS_WRAP2"},
|
|
{SC_RENDERSTATE, D3DRS_WRAP3, "D3DRS_WRAP3"},
|
|
{SC_RENDERSTATE, D3DRS_WRAP4, "D3DRS_WRAP4"},
|
|
{SC_RENDERSTATE, D3DRS_WRAP5, "D3DRS_WRAP5"},
|
|
{SC_RENDERSTATE, D3DRS_WRAP6, "D3DRS_WRAP6"},
|
|
{SC_RENDERSTATE, D3DRS_WRAP7, "D3DRS_WRAP7"},
|
|
{SC_RENDERSTATE, D3DRS_WRAP8, "D3DRS_WRAP8"},
|
|
{SC_RENDERSTATE, D3DRS_WRAP9, "D3DRS_WRAP9"},
|
|
{SC_RENDERSTATE, D3DRS_WRAP10, "D3DRS_WRAP10"},
|
|
{SC_RENDERSTATE, D3DRS_WRAP11, "D3DRS_WRAP11"},
|
|
{SC_RENDERSTATE, D3DRS_WRAP12, "D3DRS_WRAP12"},
|
|
{SC_RENDERSTATE, D3DRS_WRAP13, "D3DRS_WRAP13"},
|
|
{SC_RENDERSTATE, D3DRS_WRAP14, "D3DRS_WRAP14"},
|
|
{SC_RENDERSTATE, D3DRS_WRAP15, "D3DRS_WRAP15"},
|
|
{SC_RENDERSTATE, D3DRS_CLIPPING, "D3DRS_CLIPPING"},
|
|
{SC_RENDERSTATE, D3DRS_LIGHTING, "D3DRS_LIGHTING"}, /* 0x30 */
|
|
{SC_RENDERSTATE, D3DRS_AMBIENT, "D3DRS_AMBIENT"},
|
|
{SC_RENDERSTATE, D3DRS_FOGVERTEXMODE, "D3DRS_FOGVERTEXMODE"},
|
|
{SC_RENDERSTATE, D3DRS_COLORVERTEX, "D3DRS_COLORVERTEX"},
|
|
{SC_RENDERSTATE, D3DRS_LOCALVIEWER, "D3DRS_LOCALVIEWER"},
|
|
{SC_RENDERSTATE, D3DRS_NORMALIZENORMALS, "D3DRS_NORMALIZENORMALS"},
|
|
{SC_RENDERSTATE, D3DRS_DIFFUSEMATERIALSOURCE, "D3DRS_DIFFUSEMATERIALSOURCE"},
|
|
{SC_RENDERSTATE, D3DRS_SPECULARMATERIALSOURCE, "D3DRS_SPECULARMATERIALSOURCE"},
|
|
{SC_RENDERSTATE, D3DRS_AMBIENTMATERIALSOURCE, "D3DRS_AMBIENTMATERIALSOURCE"},
|
|
{SC_RENDERSTATE, D3DRS_EMISSIVEMATERIALSOURCE, "D3DRS_EMISSIVEMATERIALSOURCE"},
|
|
{SC_RENDERSTATE, D3DRS_VERTEXBLEND, "D3DRS_VERTEXBLEND"},
|
|
{SC_RENDERSTATE, D3DRS_CLIPPLANEENABLE, "D3DRS_CLIPPLANEENABLE"},
|
|
{SC_RENDERSTATE, D3DRS_POINTSIZE, "D3DRS_POINTSIZE"},
|
|
{SC_RENDERSTATE, D3DRS_POINTSIZE_MIN, "D3DRS_POINTSIZE_MIN"},
|
|
{SC_RENDERSTATE, D3DRS_POINTSIZE_MAX, "D3DRS_POINTSIZE_MAX"},
|
|
{SC_RENDERSTATE, D3DRS_POINTSPRITEENABLE, "D3DRS_POINTSPRITEENABLE"},
|
|
{SC_RENDERSTATE, D3DRS_POINTSCALEENABLE, "D3DRS_POINTSCALEENABLE"}, /* 0x40 */
|
|
{SC_RENDERSTATE, D3DRS_POINTSCALE_A, "D3DRS_POINTSCALE_A"},
|
|
{SC_RENDERSTATE, D3DRS_POINTSCALE_B, "D3DRS_POINTSCALE_B"},
|
|
{SC_RENDERSTATE, D3DRS_POINTSCALE_C, "D3DRS_POINTSCALE_C"},
|
|
{SC_RENDERSTATE, D3DRS_MULTISAMPLEANTIALIAS, "D3DRS_MULTISAMPLEANTIALIAS"},
|
|
{SC_RENDERSTATE, D3DRS_MULTISAMPLEMASK, "D3DRS_MULTISAMPLEMASK"},
|
|
{SC_RENDERSTATE, D3DRS_PATCHEDGESTYLE, "D3DRS_PATCHEDGESTYLE"},
|
|
{SC_RENDERSTATE, D3DRS_DEBUGMONITORTOKEN, "D3DRS_DEBUGMONITORTOKEN"},
|
|
{SC_RENDERSTATE, D3DRS_INDEXEDVERTEXBLENDENABLE, "D3DRS_INDEXEDVERTEXBLENDENABLE"},
|
|
{SC_RENDERSTATE, D3DRS_COLORWRITEENABLE, "D3DRS_COLORWRITEENABLE"},
|
|
{SC_RENDERSTATE, D3DRS_TWEENFACTOR, "D3DRS_TWEENFACTOR"},
|
|
{SC_RENDERSTATE, D3DRS_BLENDOP, "D3DRS_BLENDOP"},
|
|
{SC_RENDERSTATE, D3DRS_POSITIONDEGREE, "D3DRS_POSITIONDEGREE"},
|
|
{SC_RENDERSTATE, D3DRS_NORMALDEGREE, "D3DRS_NORMALDEGREE"},
|
|
{SC_RENDERSTATE, D3DRS_SCISSORTESTENABLE, "D3DRS_SCISSORTESTENABLE"},
|
|
{SC_RENDERSTATE, D3DRS_SLOPESCALEDEPTHBIAS, "D3DRS_SLOPESCALEDEPTHBIAS"},
|
|
{SC_RENDERSTATE, D3DRS_ANTIALIASEDLINEENABLE, "D3DRS_ANTIALIASEDLINEENABLE"}, /* 0x50 */
|
|
{SC_RENDERSTATE, D3DRS_MINTESSELLATIONLEVEL, "D3DRS_MINTESSELLATIONLEVEL"},
|
|
{SC_RENDERSTATE, D3DRS_MAXTESSELLATIONLEVEL, "D3DRS_MAXTESSELLATIONLEVEL"},
|
|
{SC_RENDERSTATE, D3DRS_ADAPTIVETESS_X, "D3DRS_ADAPTIVETESS_X"},
|
|
{SC_RENDERSTATE, D3DRS_ADAPTIVETESS_Y, "D3DRS_ADAPTIVETESS_Y"},
|
|
{SC_RENDERSTATE, D3DRS_ADAPTIVETESS_Z, "D3DRS_ADAPTIVETESS_Z"},
|
|
{SC_RENDERSTATE, D3DRS_ADAPTIVETESS_W, "D3DRS_ADAPTIVETESS_W"},
|
|
{SC_RENDERSTATE, D3DRS_ENABLEADAPTIVETESSELLATION, "D3DRS_ENABLEADAPTIVETESSELLATION"},
|
|
{SC_RENDERSTATE, D3DRS_TWOSIDEDSTENCILMODE, "D3DRS_TWOSIDEDSTENCILMODE"},
|
|
{SC_RENDERSTATE, D3DRS_CCW_STENCILFAIL, "D3DRS_CCW_STENCILFAIL"},
|
|
{SC_RENDERSTATE, D3DRS_CCW_STENCILZFAIL, "D3DRS_CCW_STENCILZFAIL"},
|
|
{SC_RENDERSTATE, D3DRS_CCW_STENCILPASS, "D3DRS_CCW_STENCILPASS"},
|
|
{SC_RENDERSTATE, D3DRS_CCW_STENCILFUNC, "D3DRS_CCW_STENCILFUNC"},
|
|
{SC_RENDERSTATE, D3DRS_COLORWRITEENABLE1, "D3DRS_COLORWRITEENABLE1"},
|
|
{SC_RENDERSTATE, D3DRS_COLORWRITEENABLE2, "D3DRS_COLORWRITEENABLE2"},
|
|
{SC_RENDERSTATE, D3DRS_COLORWRITEENABLE3, "D3DRS_COLORWRITEENABLE3"},
|
|
{SC_RENDERSTATE, D3DRS_BLENDFACTOR, "D3DRS_BLENDFACTOR"}, /* 0x60 */
|
|
{SC_RENDERSTATE, D3DRS_SRGBWRITEENABLE, "D3DRS_SRGBWRITEENABLE"},
|
|
{SC_RENDERSTATE, D3DRS_DEPTHBIAS, "D3DRS_DEPTHBIAS"},
|
|
{SC_RENDERSTATE, D3DRS_SEPARATEALPHABLENDENABLE, "D3DRS_SEPARATEALPHABLENDENABLE"},
|
|
{SC_RENDERSTATE, D3DRS_SRCBLENDALPHA, "D3DRS_SRCBLENDALPHA"},
|
|
{SC_RENDERSTATE, D3DRS_DESTBLENDALPHA, "D3DRS_DESTBLENDALPHA"},
|
|
{SC_RENDERSTATE, D3DRS_BLENDOPALPHA, "D3DRS_BLENDOPALPHA"},
|
|
/* Texture stages */
|
|
{SC_TEXTURESTAGE, D3DTSS_COLOROP, "D3DTSS_COLOROP"},
|
|
{SC_TEXTURESTAGE, D3DTSS_COLORARG0, "D3DTSS_COLORARG0"},
|
|
{SC_TEXTURESTAGE, D3DTSS_COLORARG1, "D3DTSS_COLORARG1"},
|
|
{SC_TEXTURESTAGE, D3DTSS_COLORARG2, "D3DTSS_COLORARG2"},
|
|
{SC_TEXTURESTAGE, D3DTSS_ALPHAOP, "D3DTSS_ALPHAOP"},
|
|
{SC_TEXTURESTAGE, D3DTSS_ALPHAARG0, "D3DTSS_ALPHAARG0"},
|
|
{SC_TEXTURESTAGE, D3DTSS_ALPHAARG1, "D3DTSS_ALPHAARG1"},
|
|
{SC_TEXTURESTAGE, D3DTSS_ALPHAARG2, "D3DTSS_ALPHAARG2"},
|
|
{SC_TEXTURESTAGE, D3DTSS_RESULTARG, "D3DTSS_RESULTARG"},
|
|
{SC_TEXTURESTAGE, D3DTSS_BUMPENVMAT00, "D3DTSS_BUMPENVMAT00"}, /* 0x70 */
|
|
{SC_TEXTURESTAGE, D3DTSS_BUMPENVMAT01, "D3DTSS_BUMPENVMAT01"},
|
|
{SC_TEXTURESTAGE, D3DTSS_BUMPENVMAT10, "D3DTSS_BUMPENVMAT10"},
|
|
{SC_TEXTURESTAGE, D3DTSS_BUMPENVMAT11, "D3DTSS_BUMPENVMAT11"},
|
|
{SC_TEXTURESTAGE, D3DTSS_TEXCOORDINDEX, "D3DTSS_TEXCOORDINDEX"},
|
|
{SC_TEXTURESTAGE, D3DTSS_BUMPENVLSCALE, "D3DTSS_BUMPENVLSCALE"},
|
|
{SC_TEXTURESTAGE, D3DTSS_BUMPENVLOFFSET, "D3DTSS_BUMPENVLOFFSET"},
|
|
{SC_TEXTURESTAGE, D3DTSS_TEXTURETRANSFORMFLAGS, "D3DTSS_TEXTURETRANSFORMFLAGS"},
|
|
/* */
|
|
{SC_UNKNOWN, 0, "UNKNOWN"},
|
|
/* NPatchMode */
|
|
{SC_NPATCHMODE, 0, "NPatchMode"},
|
|
/* */
|
|
{SC_UNKNOWN, 0, "UNKNOWN"},
|
|
/* Transform */
|
|
{SC_TRANSFORM, D3DTS_PROJECTION, "D3DTS_PROJECTION"},
|
|
{SC_TRANSFORM, D3DTS_VIEW, "D3DTS_VIEW"},
|
|
{SC_TRANSFORM, D3DTS_WORLD, "D3DTS_WORLD"},
|
|
{SC_TRANSFORM, D3DTS_TEXTURE0, "D3DTS_TEXTURE0"},
|
|
/* Material */
|
|
{SC_MATERIAL, MT_DIFFUSE, "MaterialDiffuse"},
|
|
{SC_MATERIAL, MT_AMBIENT, "MaterialAmbient"}, /* 0x80 */
|
|
{SC_MATERIAL, MT_SPECULAR, "MaterialSpecular"},
|
|
{SC_MATERIAL, MT_EMISSIVE, "MaterialEmissive"},
|
|
{SC_MATERIAL, MT_POWER, "MaterialPower"},
|
|
/* Light */
|
|
{SC_LIGHT, LT_TYPE, "LightType"},
|
|
{SC_LIGHT, LT_DIFFUSE, "LightDiffuse"},
|
|
{SC_LIGHT, LT_SPECULAR, "LightSpecular"},
|
|
{SC_LIGHT, LT_AMBIENT, "LightAmbient"},
|
|
{SC_LIGHT, LT_POSITION, "LightPosition"},
|
|
{SC_LIGHT, LT_DIRECTION, "LightDirection"},
|
|
{SC_LIGHT, LT_RANGE, "LightRange"},
|
|
{SC_LIGHT, LT_FALLOFF, "LightFallOff"},
|
|
{SC_LIGHT, LT_ATTENUATION0, "LightAttenuation0"},
|
|
{SC_LIGHT, LT_ATTENUATION1, "LightAttenuation1"},
|
|
{SC_LIGHT, LT_ATTENUATION2, "LightAttenuation2"},
|
|
{SC_LIGHT, LT_THETA, "LightTheta"},
|
|
{SC_LIGHT, LT_PHI, "LightPhi"}, /* 0x90 */
|
|
/* Ligthenable */
|
|
{SC_LIGHTENABLE, 0, "LightEnable"},
|
|
/* Vertexshader */
|
|
{SC_VERTEXSHADER, 0, "Vertexshader"},
|
|
/* Pixelshader */
|
|
{SC_PIXELSHADER, 0, "Pixelshader"},
|
|
/* Shader constants */
|
|
{SC_SHADERCONST, SCT_VSFLOAT, "VertexShaderConstantF"},
|
|
{SC_SHADERCONST, SCT_VSBOOL, "VertexShaderConstantB"},
|
|
{SC_SHADERCONST, SCT_VSINT, "VertexShaderConstantI"},
|
|
{SC_SHADERCONST, SCT_VSFLOAT, "VertexShaderConstant"},
|
|
{SC_SHADERCONST, SCT_VSFLOAT, "VertexShaderConstant1"},
|
|
{SC_SHADERCONST, SCT_VSFLOAT, "VertexShaderConstant2"},
|
|
{SC_SHADERCONST, SCT_VSFLOAT, "VertexShaderConstant3"},
|
|
{SC_SHADERCONST, SCT_VSFLOAT, "VertexShaderConstant4"},
|
|
{SC_SHADERCONST, SCT_PSFLOAT, "PixelShaderConstantF"},
|
|
{SC_SHADERCONST, SCT_PSBOOL, "PixelShaderConstantB"},
|
|
{SC_SHADERCONST, SCT_PSINT, "PixelShaderConstantI"},
|
|
{SC_SHADERCONST, SCT_PSFLOAT, "PixelShaderConstant"},
|
|
{SC_SHADERCONST, SCT_PSFLOAT, "PixelShaderConstant1"}, /* 0xa0 */
|
|
{SC_SHADERCONST, SCT_PSFLOAT, "PixelShaderConstant2"},
|
|
{SC_SHADERCONST, SCT_PSFLOAT, "PixelShaderConstant3"},
|
|
{SC_SHADERCONST, SCT_PSFLOAT, "PixelShaderConstant4"},
|
|
/* Texture */
|
|
{SC_TEXTURE, 0, "Texture"},
|
|
/* Sampler states */
|
|
{SC_SAMPLERSTATE, D3DSAMP_ADDRESSU, "AddressU"},
|
|
{SC_SAMPLERSTATE, D3DSAMP_ADDRESSV, "AddressV"},
|
|
{SC_SAMPLERSTATE, D3DSAMP_ADDRESSW, "AddressW"},
|
|
{SC_SAMPLERSTATE, D3DSAMP_BORDERCOLOR, "BorderColor"},
|
|
{SC_SAMPLERSTATE, D3DSAMP_MAGFILTER, "MagFilter"},
|
|
{SC_SAMPLERSTATE, D3DSAMP_MINFILTER, "MinFilter"},
|
|
{SC_SAMPLERSTATE, D3DSAMP_MIPFILTER, "MipFilter"},
|
|
{SC_SAMPLERSTATE, D3DSAMP_MIPMAPLODBIAS, "MipMapLodBias"},
|
|
{SC_SAMPLERSTATE, D3DSAMP_MAXMIPLEVEL, "MaxMipLevel"},
|
|
{SC_SAMPLERSTATE, D3DSAMP_MAXANISOTROPY, "MaxAnisotropy"},
|
|
{SC_SAMPLERSTATE, D3DSAMP_SRGBTEXTURE, "SRGBTexture"},
|
|
{SC_SAMPLERSTATE, D3DSAMP_ELEMENTINDEX, "ElementIndex"}, /* 0xb0 */
|
|
{SC_SAMPLERSTATE, D3DSAMP_DMAPOFFSET, "DMAPOffset"},
|
|
/* Set sampler */
|
|
{SC_SETSAMPLER, 0, "Sampler"},
|
|
};
|
|
|
|
static inline void read_dword(const char **ptr, DWORD *d)
|
|
{
|
|
memcpy(d, *ptr, sizeof(*d));
|
|
*ptr += sizeof(*d);
|
|
}
|
|
|
|
static void skip_dword_unknown(const char **ptr, unsigned int count)
|
|
{
|
|
unsigned int i;
|
|
DWORD d;
|
|
|
|
FIXME("Skipping %u unknown DWORDs:\n", count);
|
|
for (i = 0; i < count; ++i)
|
|
{
|
|
read_dword(ptr, &d);
|
|
FIXME("\t0x%08x\n", d);
|
|
}
|
|
}
|
|
|
|
static inline struct d3dx_parameter *get_parameter_struct(D3DXHANDLE handle)
|
|
{
|
|
return (struct d3dx_parameter *) handle;
|
|
}
|
|
|
|
static inline struct d3dx_pass *get_pass_struct(D3DXHANDLE handle)
|
|
{
|
|
return (struct d3dx_pass *) handle;
|
|
}
|
|
|
|
static inline struct d3dx_technique *get_technique_struct(D3DXHANDLE handle)
|
|
{
|
|
return (struct d3dx_technique *) handle;
|
|
}
|
|
|
|
static inline D3DXHANDLE get_parameter_handle(struct d3dx_parameter *parameter)
|
|
{
|
|
return (D3DXHANDLE) parameter;
|
|
}
|
|
|
|
static inline D3DXHANDLE get_technique_handle(struct d3dx_technique *technique)
|
|
{
|
|
return (D3DXHANDLE) technique;
|
|
}
|
|
|
|
static inline D3DXHANDLE get_pass_handle(struct d3dx_pass *pass)
|
|
{
|
|
return (D3DXHANDLE) pass;
|
|
}
|
|
|
|
static struct d3dx_technique *is_valid_technique(struct ID3DXBaseEffectImpl *base, D3DXHANDLE technique)
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < base->technique_count; ++i)
|
|
{
|
|
if (base->technique_handles[i] == technique)
|
|
{
|
|
return get_technique_struct(technique);
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static struct d3dx_pass *is_valid_pass(struct ID3DXBaseEffectImpl *base, D3DXHANDLE pass)
|
|
{
|
|
unsigned int i, k;
|
|
|
|
for (i = 0; i < base->technique_count; ++i)
|
|
{
|
|
struct d3dx_technique *technique = get_technique_struct(base->technique_handles[i]);
|
|
|
|
for (k = 0; k < technique->pass_count; ++k)
|
|
{
|
|
if (technique->pass_handles[k] == pass)
|
|
{
|
|
return get_pass_struct(pass);
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static struct d3dx_parameter *is_valid_sub_parameter(struct d3dx_parameter *param, D3DXHANDLE parameter)
|
|
{
|
|
unsigned int i, count;
|
|
struct d3dx_parameter *p;
|
|
|
|
for (i = 0; i < param->annotation_count; ++i)
|
|
{
|
|
if (param->annotation_handles[i] == parameter)
|
|
{
|
|
return get_parameter_struct(parameter);
|
|
}
|
|
|
|
p = is_valid_sub_parameter(get_parameter_struct(param->annotation_handles[i]), parameter);
|
|
if (p) return p;
|
|
}
|
|
|
|
if (param->element_count) count = param->element_count;
|
|
else count = param->member_count;
|
|
|
|
for (i = 0; i < count; ++i)
|
|
{
|
|
if (param->member_handles[i] == parameter)
|
|
{
|
|
return get_parameter_struct(parameter);
|
|
}
|
|
|
|
p = is_valid_sub_parameter(get_parameter_struct(param->member_handles[i]), parameter);
|
|
if (p) return p;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static struct d3dx_parameter *is_valid_parameter(struct ID3DXBaseEffectImpl *base, D3DXHANDLE parameter)
|
|
{
|
|
unsigned int i, k, m;
|
|
struct d3dx_parameter *p;
|
|
|
|
for (i = 0; i < base->parameter_count; ++i)
|
|
{
|
|
if (base->parameter_handles[i] == parameter)
|
|
{
|
|
return get_parameter_struct(parameter);
|
|
}
|
|
|
|
p = is_valid_sub_parameter(get_parameter_struct(base->parameter_handles[i]), parameter);
|
|
if (p) return p;
|
|
}
|
|
|
|
for (i = 0; i < base->technique_count; ++i)
|
|
{
|
|
struct d3dx_technique *technique = get_technique_struct(base->technique_handles[i]);
|
|
|
|
for (k = 0; k < technique->pass_count; ++k)
|
|
{
|
|
struct d3dx_pass *pass = get_pass_struct(technique->pass_handles[k]);
|
|
|
|
for (m = 0; m < pass->annotation_count; ++m)
|
|
{
|
|
if (pass->annotation_handles[i] == parameter)
|
|
{
|
|
return get_parameter_struct(parameter);
|
|
}
|
|
|
|
p = is_valid_sub_parameter(get_parameter_struct(pass->annotation_handles[m]), parameter);
|
|
if (p) return p;
|
|
}
|
|
}
|
|
|
|
for (k = 0; k < technique->annotation_count; ++k)
|
|
{
|
|
if (technique->annotation_handles[k] == parameter)
|
|
{
|
|
return get_parameter_struct(parameter);
|
|
}
|
|
|
|
p = is_valid_sub_parameter(get_parameter_struct(technique->annotation_handles[k]), parameter);
|
|
if (p) return p;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static inline struct d3dx_parameter *get_valid_parameter(struct ID3DXBaseEffectImpl *base, D3DXHANDLE parameter)
|
|
{
|
|
struct d3dx_parameter *param = is_valid_parameter(base, parameter);
|
|
|
|
if (!param) param = get_parameter_by_name(base, NULL, parameter);
|
|
|
|
return param;
|
|
}
|
|
|
|
static void free_state(struct d3dx_state *state)
|
|
{
|
|
free_parameter_state(state->parameter, FALSE, FALSE, state->type);
|
|
}
|
|
|
|
static void free_sampler(struct d3dx_sampler *sampler)
|
|
{
|
|
UINT i;
|
|
|
|
for (i = 0; i < sampler->state_count; ++i)
|
|
{
|
|
free_state(&sampler->states[i]);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, sampler->states);
|
|
}
|
|
|
|
static void free_parameter(D3DXHANDLE handle, BOOL element, BOOL child)
|
|
{
|
|
free_parameter_state(handle, element, child, ST_CONSTANT);
|
|
}
|
|
|
|
static void free_parameter_state(D3DXHANDLE handle, BOOL element, BOOL child, enum STATE_TYPE st)
|
|
{
|
|
unsigned int i;
|
|
struct d3dx_parameter *param = get_parameter_struct(handle);
|
|
|
|
TRACE("Free parameter %p, name %s, type %s, child %s, state_type %x\n", param, param->name,
|
|
debug_d3dxparameter_type(param->type), child ? "yes" : "no", st);
|
|
|
|
if (!param)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (param->annotation_handles)
|
|
{
|
|
for (i = 0; i < param->annotation_count; ++i)
|
|
{
|
|
free_parameter(param->annotation_handles[i], FALSE, FALSE);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, param->annotation_handles);
|
|
}
|
|
|
|
if (param->member_handles)
|
|
{
|
|
unsigned int count;
|
|
|
|
if (param->element_count) count = param->element_count;
|
|
else count = param->member_count;
|
|
|
|
for (i = 0; i < count; ++i)
|
|
{
|
|
free_parameter(param->member_handles[i], param->element_count != 0, TRUE);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, param->member_handles);
|
|
}
|
|
|
|
if (param->class == D3DXPC_OBJECT && !param->element_count)
|
|
{
|
|
switch (param->type)
|
|
{
|
|
case D3DXPT_STRING:
|
|
HeapFree(GetProcessHeap(), 0, *(LPSTR *)param->data);
|
|
if (!child) HeapFree(GetProcessHeap(), 0, param->data);
|
|
break;
|
|
|
|
case D3DXPT_TEXTURE:
|
|
case D3DXPT_TEXTURE1D:
|
|
case D3DXPT_TEXTURE2D:
|
|
case D3DXPT_TEXTURE3D:
|
|
case D3DXPT_TEXTURECUBE:
|
|
case D3DXPT_PIXELSHADER:
|
|
case D3DXPT_VERTEXSHADER:
|
|
if (st == ST_CONSTANT)
|
|
{
|
|
if (*(IUnknown **)param->data) IUnknown_Release(*(IUnknown **)param->data);
|
|
}
|
|
else
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, *(LPSTR *)param->data);
|
|
}
|
|
if (!child) HeapFree(GetProcessHeap(), 0, param->data);
|
|
break;
|
|
|
|
case D3DXPT_SAMPLER:
|
|
case D3DXPT_SAMPLER1D:
|
|
case D3DXPT_SAMPLER2D:
|
|
case D3DXPT_SAMPLER3D:
|
|
case D3DXPT_SAMPLERCUBE:
|
|
if (st == ST_CONSTANT)
|
|
{
|
|
free_sampler((struct d3dx_sampler *)param->data);
|
|
}
|
|
else
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, *(LPSTR *)param->data);
|
|
}
|
|
/* samplers have always own data, so free that */
|
|
HeapFree(GetProcessHeap(), 0, param->data);
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!child)
|
|
{
|
|
if (st != ST_CONSTANT)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, *(LPSTR *)param->data);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, param->data);
|
|
}
|
|
}
|
|
|
|
/* only the parent has to release name and semantic */
|
|
if (!element)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, param->name);
|
|
HeapFree(GetProcessHeap(), 0, param->semantic);
|
|
}
|
|
|
|
HeapFree(GetProcessHeap(), 0, param);
|
|
}
|
|
|
|
static void free_pass(D3DXHANDLE handle)
|
|
{
|
|
unsigned int i;
|
|
struct d3dx_pass *pass = get_pass_struct(handle);
|
|
|
|
TRACE("Free pass %p\n", pass);
|
|
|
|
if (!pass)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (pass->annotation_handles)
|
|
{
|
|
for (i = 0; i < pass->annotation_count; ++i)
|
|
{
|
|
free_parameter(pass->annotation_handles[i], FALSE, FALSE);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, pass->annotation_handles);
|
|
}
|
|
|
|
if (pass->states)
|
|
{
|
|
for (i = 0; i < pass->state_count; ++i)
|
|
{
|
|
free_state(&pass->states[i]);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, pass->states);
|
|
}
|
|
|
|
HeapFree(GetProcessHeap(), 0, pass->name);
|
|
HeapFree(GetProcessHeap(), 0, pass);
|
|
}
|
|
|
|
static void free_technique(D3DXHANDLE handle)
|
|
{
|
|
unsigned int i;
|
|
struct d3dx_technique *technique = get_technique_struct(handle);
|
|
|
|
TRACE("Free technique %p\n", technique);
|
|
|
|
if (!technique)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (technique->annotation_handles)
|
|
{
|
|
for (i = 0; i < technique->annotation_count; ++i)
|
|
{
|
|
free_parameter(technique->annotation_handles[i], FALSE, FALSE);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, technique->annotation_handles);
|
|
}
|
|
|
|
if (technique->pass_handles)
|
|
{
|
|
for (i = 0; i < technique->pass_count; ++i)
|
|
{
|
|
free_pass(technique->pass_handles[i]);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, technique->pass_handles);
|
|
}
|
|
|
|
HeapFree(GetProcessHeap(), 0, technique->name);
|
|
HeapFree(GetProcessHeap(), 0, technique);
|
|
}
|
|
|
|
static void free_base_effect(struct ID3DXBaseEffectImpl *base)
|
|
{
|
|
unsigned int i;
|
|
|
|
TRACE("Free base effect %p\n", base);
|
|
|
|
if (base->parameter_handles)
|
|
{
|
|
for (i = 0; i < base->parameter_count; ++i)
|
|
{
|
|
free_parameter(base->parameter_handles[i], FALSE, FALSE);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, base->parameter_handles);
|
|
}
|
|
|
|
if (base->technique_handles)
|
|
{
|
|
for (i = 0; i < base->technique_count; ++i)
|
|
{
|
|
free_technique(base->technique_handles[i]);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, base->technique_handles);
|
|
}
|
|
}
|
|
|
|
static void free_effect(struct ID3DXEffectImpl *effect)
|
|
{
|
|
TRACE("Free effect %p\n", effect);
|
|
|
|
if (effect->base_effect)
|
|
{
|
|
effect->base_effect->lpVtbl->Release(effect->base_effect);
|
|
}
|
|
|
|
if (effect->pool)
|
|
{
|
|
effect->pool->lpVtbl->Release(effect->pool);
|
|
}
|
|
|
|
if (effect->manager)
|
|
{
|
|
IUnknown_Release(effect->manager);
|
|
}
|
|
|
|
IDirect3DDevice9_Release(effect->device);
|
|
}
|
|
|
|
static void free_effect_compiler(struct ID3DXEffectCompilerImpl *compiler)
|
|
{
|
|
TRACE("Free effect compiler %p\n", compiler);
|
|
|
|
if (compiler->base_effect)
|
|
{
|
|
compiler->base_effect->lpVtbl->Release(compiler->base_effect);
|
|
}
|
|
}
|
|
|
|
static INT get_int(D3DXPARAMETER_TYPE type, LPCVOID data)
|
|
{
|
|
INT i;
|
|
|
|
switch (type)
|
|
{
|
|
case D3DXPT_FLOAT:
|
|
i = *(FLOAT *)data;
|
|
break;
|
|
|
|
case D3DXPT_INT:
|
|
i = *(INT *)data;
|
|
break;
|
|
|
|
case D3DXPT_BOOL:
|
|
i = *(BOOL *)data;
|
|
break;
|
|
|
|
default:
|
|
i = 0;
|
|
FIXME("Unhandled type %s. This should not happen!\n", debug_d3dxparameter_type(type));
|
|
break;
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
inline static FLOAT get_float(D3DXPARAMETER_TYPE type, LPCVOID data)
|
|
{
|
|
FLOAT f;
|
|
|
|
switch (type)
|
|
{
|
|
case D3DXPT_FLOAT:
|
|
f = *(FLOAT *)data;
|
|
break;
|
|
|
|
case D3DXPT_INT:
|
|
f = *(INT *)data;
|
|
break;
|
|
|
|
case D3DXPT_BOOL:
|
|
f = *(BOOL *)data;
|
|
break;
|
|
|
|
default:
|
|
f = 0.0f;
|
|
FIXME("Unhandled type %s. This should not happen!\n", debug_d3dxparameter_type(type));
|
|
break;
|
|
}
|
|
|
|
return f;
|
|
}
|
|
|
|
static inline BOOL get_bool(LPCVOID data)
|
|
{
|
|
return (*(DWORD *)data) ? TRUE : FALSE;
|
|
}
|
|
|
|
static void set_number(LPVOID outdata, D3DXPARAMETER_TYPE outtype, LPCVOID indata, D3DXPARAMETER_TYPE intype)
|
|
{
|
|
TRACE("Changing from type %i to type %i\n", intype, outtype);
|
|
|
|
switch (outtype)
|
|
{
|
|
case D3DXPT_FLOAT:
|
|
*(FLOAT *)outdata = get_float(intype, indata);
|
|
break;
|
|
|
|
case D3DXPT_BOOL:
|
|
*(BOOL *)outdata = get_bool(indata);
|
|
break;
|
|
|
|
case D3DXPT_INT:
|
|
*(INT *)outdata = get_int(intype, indata);
|
|
break;
|
|
|
|
default:
|
|
FIXME("Error converting to type %i\n", outtype);
|
|
*(INT *)outdata = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void get_vector(struct d3dx_parameter *param, D3DXVECTOR4 *vector)
|
|
{
|
|
UINT i;
|
|
|
|
for (i = 0; i < 4; ++i)
|
|
{
|
|
((FLOAT *)vector)[i] = i < param->columns ? get_float(param->type, (DWORD *)param->data + i) : 0.0f;
|
|
}
|
|
}
|
|
|
|
static void set_vector(struct d3dx_parameter *param, CONST D3DXVECTOR4 *vector)
|
|
{
|
|
UINT i;
|
|
|
|
for (i = 0; i < param->columns; ++i)
|
|
{
|
|
set_number((FLOAT *)param->data + i, param->type, (FLOAT *)vector + i, D3DXPT_FLOAT);
|
|
}
|
|
}
|
|
|
|
static void get_matrix(struct d3dx_parameter *param, D3DXMATRIX *matrix)
|
|
{
|
|
UINT i, k;
|
|
|
|
for (i = 0; i < 4; ++i)
|
|
{
|
|
for (k = 0; k < 4; ++k)
|
|
{
|
|
if ((i < param->rows) && (k < param->columns))
|
|
matrix->u.m[i][k] = get_float(param->type, (FLOAT *)param->data + i * param->columns + k);
|
|
else
|
|
matrix->u.m[i][k] = 0.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void set_matrix(struct d3dx_parameter *param, CONST D3DXMATRIX *matrix)
|
|
{
|
|
UINT i, k;
|
|
|
|
for (i = 0; i < 4; ++i)
|
|
{
|
|
for (k = 0; k < 4; ++k)
|
|
{
|
|
if ((i < param->rows) && (k < param->columns))
|
|
set_number((FLOAT *)param->data + i * param->columns + k, param->type, &matrix->u.m[i][k], D3DXPT_FLOAT);
|
|
}
|
|
}
|
|
}
|
|
|
|
static struct d3dx_parameter *get_parameter_element_by_name(struct d3dx_parameter *parameter, LPCSTR name)
|
|
{
|
|
UINT element;
|
|
struct d3dx_parameter *temp_parameter;
|
|
LPCSTR part;
|
|
|
|
TRACE("parameter %p, name %s\n", parameter, debugstr_a(name));
|
|
|
|
if (!name || !*name) return parameter;
|
|
|
|
element = atoi(name);
|
|
part = strchr(name, ']') + 1;
|
|
|
|
if (parameter->element_count > element)
|
|
{
|
|
temp_parameter = get_parameter_struct(parameter->member_handles[element]);
|
|
|
|
switch (*part++)
|
|
{
|
|
case '.':
|
|
return get_parameter_by_name(NULL, temp_parameter, part);
|
|
|
|
case '@':
|
|
return get_parameter_annotation_by_name(temp_parameter, part);
|
|
|
|
case '\0':
|
|
TRACE("Returning parameter %p\n", temp_parameter);
|
|
return temp_parameter;
|
|
|
|
default:
|
|
FIXME("Unhandled case \"%c\"\n", *--part);
|
|
break;
|
|
}
|
|
}
|
|
|
|
TRACE("Parameter not found\n");
|
|
return NULL;
|
|
}
|
|
|
|
static struct d3dx_parameter *get_parameter_annotation_by_name(struct d3dx_parameter *parameter, LPCSTR name)
|
|
{
|
|
UINT i, length;
|
|
struct d3dx_parameter *temp_parameter;
|
|
LPCSTR part;
|
|
|
|
TRACE("parameter %p, name %s\n", parameter, debugstr_a(name));
|
|
|
|
if (!name || !*name) return parameter;
|
|
|
|
length = strcspn( name, "[.@" );
|
|
part = name + length;
|
|
|
|
for (i = 0; i < parameter->annotation_count; ++i)
|
|
{
|
|
temp_parameter = get_parameter_struct(parameter->annotation_handles[i]);
|
|
|
|
if (!strcmp(temp_parameter->name, name))
|
|
{
|
|
TRACE("Returning parameter %p\n", temp_parameter);
|
|
return temp_parameter;
|
|
}
|
|
else if (strlen(temp_parameter->name) == length && !strncmp(temp_parameter->name, name, length))
|
|
{
|
|
switch (*part++)
|
|
{
|
|
case '.':
|
|
return get_parameter_by_name(NULL, temp_parameter, part);
|
|
|
|
case '[':
|
|
return get_parameter_element_by_name(temp_parameter, part);
|
|
|
|
default:
|
|
FIXME("Unhandled case \"%c\"\n", *--part);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
TRACE("Parameter not found\n");
|
|
return NULL;
|
|
}
|
|
|
|
static struct d3dx_parameter *get_parameter_by_name(struct ID3DXBaseEffectImpl *base,
|
|
struct d3dx_parameter *parameter, LPCSTR name)
|
|
{
|
|
UINT i, count, length;
|
|
struct d3dx_parameter *temp_parameter;
|
|
D3DXHANDLE *handles;
|
|
LPCSTR part;
|
|
|
|
TRACE("base %p, parameter %p, name %s\n", base, parameter, debugstr_a(name));
|
|
|
|
if (!name || !*name) return parameter;
|
|
|
|
if (!parameter)
|
|
{
|
|
count = base->parameter_count;
|
|
handles = base->parameter_handles;
|
|
}
|
|
else
|
|
{
|
|
count = parameter->member_count;
|
|
handles = parameter->member_handles;
|
|
}
|
|
|
|
length = strcspn( name, "[.@" );
|
|
part = name + length;
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
temp_parameter = get_parameter_struct(handles[i]);
|
|
|
|
if (!strcmp(temp_parameter->name, name))
|
|
{
|
|
TRACE("Returning parameter %p\n", temp_parameter);
|
|
return temp_parameter;
|
|
}
|
|
else if (strlen(temp_parameter->name) == length && !strncmp(temp_parameter->name, name, length))
|
|
{
|
|
switch (*part++)
|
|
{
|
|
case '.':
|
|
return get_parameter_by_name(NULL, temp_parameter, part);
|
|
|
|
case '@':
|
|
return get_parameter_annotation_by_name(temp_parameter, part);
|
|
|
|
case '[':
|
|
return get_parameter_element_by_name(temp_parameter, part);
|
|
|
|
default:
|
|
FIXME("Unhandled case \"%c\"\n", *--part);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
TRACE("Parameter not found\n");
|
|
return NULL;
|
|
}
|
|
|
|
static inline DWORD d3dx9_effect_version(DWORD major, DWORD minor)
|
|
{
|
|
return (0xfeff0000 | ((major) << 8) | (minor));
|
|
}
|
|
|
|
static inline struct ID3DXBaseEffectImpl *impl_from_ID3DXBaseEffect(ID3DXBaseEffect *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, struct ID3DXBaseEffectImpl, ID3DXBaseEffect_iface);
|
|
}
|
|
|
|
/*** IUnknown methods ***/
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_QueryInterface(ID3DXBaseEffect *iface, REFIID riid, void **object)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
|
|
TRACE("iface %p, riid %s, object %p\n", This, debugstr_guid(riid), object);
|
|
|
|
if (IsEqualGUID(riid, &IID_IUnknown) ||
|
|
IsEqualGUID(riid, &IID_ID3DXBaseEffect))
|
|
{
|
|
This->ID3DXBaseEffect_iface.lpVtbl->AddRef(iface);
|
|
*object = This;
|
|
return S_OK;
|
|
}
|
|
|
|
ERR("Interface %s not found\n", debugstr_guid(riid));
|
|
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
static ULONG WINAPI ID3DXBaseEffectImpl_AddRef(ID3DXBaseEffect *iface)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
|
|
TRACE("iface %p: AddRef from %u\n", iface, This->ref);
|
|
|
|
return InterlockedIncrement(&This->ref);
|
|
}
|
|
|
|
static ULONG WINAPI ID3DXBaseEffectImpl_Release(ID3DXBaseEffect *iface)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
ULONG ref = InterlockedDecrement(&This->ref);
|
|
|
|
TRACE("iface %p: Release from %u\n", iface, ref + 1);
|
|
|
|
if (!ref)
|
|
{
|
|
free_base_effect(This);
|
|
HeapFree(GetProcessHeap(), 0, This);
|
|
}
|
|
|
|
return ref;
|
|
}
|
|
|
|
/*** ID3DXBaseEffect methods ***/
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetDesc(ID3DXBaseEffect *iface, D3DXEFFECT_DESC *desc)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
|
|
FIXME("iface %p, desc %p partial stub\n", This, desc);
|
|
|
|
if (!desc)
|
|
{
|
|
WARN("Invalid argument specified.\n");
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
/* Todo: add creator and function count */
|
|
desc->Creator = NULL;
|
|
desc->Functions = 0;
|
|
desc->Parameters = This->parameter_count;
|
|
desc->Techniques = This->technique_count;
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetParameterDesc(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXPARAMETER_DESC *desc)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, desc %p\n", This, parameter, desc);
|
|
|
|
if (!desc || !param)
|
|
{
|
|
WARN("Invalid argument specified.\n");
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
desc->Name = param->name;
|
|
desc->Semantic = param->semantic;
|
|
desc->Class = param->class;
|
|
desc->Type = param->type;
|
|
desc->Rows = param->rows;
|
|
desc->Columns = param->columns;
|
|
desc->Elements = param->element_count;
|
|
desc->Annotations = param->annotation_count;
|
|
desc->StructMembers = param->member_count;
|
|
desc->Flags = param->flags;
|
|
desc->Bytes = param->bytes;
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetTechniqueDesc(ID3DXBaseEffect *iface, D3DXHANDLE technique, D3DXTECHNIQUE_DESC *desc)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_technique *tech = technique ? is_valid_technique(This, technique) : get_technique_struct(This->technique_handles[0]);
|
|
|
|
TRACE("iface %p, technique %p, desc %p\n", This, technique, desc);
|
|
|
|
if (!desc || !tech)
|
|
{
|
|
WARN("Invalid argument specified.\n");
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
desc->Name = tech->name;
|
|
desc->Passes = tech->pass_count;
|
|
desc->Annotations = tech->annotation_count;
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetPassDesc(ID3DXBaseEffect *iface, D3DXHANDLE pass, D3DXPASS_DESC *desc)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_pass *p = is_valid_pass(This, pass);
|
|
|
|
TRACE("iface %p, pass %p, desc %p\n", This, pass, desc);
|
|
|
|
if (!desc || !p)
|
|
{
|
|
WARN("Invalid argument specified.\n");
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
desc->Name = p->name;
|
|
desc->Annotations = p->annotation_count;
|
|
|
|
FIXME("Pixel shader and vertex shader are not supported, yet.\n");
|
|
desc->pVertexShaderFunction = NULL;
|
|
desc->pPixelShaderFunction = NULL;
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetFunctionDesc(ID3DXBaseEffect *iface, D3DXHANDLE shader, D3DXFUNCTION_DESC *desc)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
|
|
FIXME("iface %p, shader %p, desc %p stub\n", This, shader, desc);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetParameter(ID3DXBaseEffect *iface, D3DXHANDLE parameter, UINT index)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, index %u\n", This, parameter, index);
|
|
|
|
if (!parameter)
|
|
{
|
|
if (index < This->parameter_count)
|
|
{
|
|
TRACE("Returning parameter %p\n", This->parameter_handles[index]);
|
|
return This->parameter_handles[index];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (param && !param->element_count && index < param->member_count)
|
|
{
|
|
TRACE("Returning parameter %p\n", param->member_handles[index]);
|
|
return param->member_handles[index];
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified.\n");
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetParameterByName(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPCSTR name)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
D3DXHANDLE handle;
|
|
|
|
TRACE("iface %p, parameter %p, name %s\n", This, parameter, debugstr_a(name));
|
|
|
|
if (!name)
|
|
{
|
|
handle = get_parameter_handle(param);
|
|
TRACE("Returning parameter %p\n", handle);
|
|
return handle;
|
|
}
|
|
|
|
handle = get_parameter_handle(get_parameter_by_name(This, param, name));
|
|
TRACE("Returning parameter %p\n", handle);
|
|
|
|
return handle;
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetParameterBySemantic(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPCSTR semantic)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
struct d3dx_parameter *temp_param;
|
|
UINT i;
|
|
|
|
TRACE("iface %p, parameter %p, semantic %s\n", This, parameter, debugstr_a(semantic));
|
|
|
|
if (!parameter)
|
|
{
|
|
for (i = 0; i < This->parameter_count; ++i)
|
|
{
|
|
temp_param = get_parameter_struct(This->parameter_handles[i]);
|
|
|
|
if (!temp_param->semantic)
|
|
{
|
|
if (!semantic)
|
|
{
|
|
TRACE("Returning parameter %p\n", This->parameter_handles[i]);
|
|
return This->parameter_handles[i];
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (!strcasecmp(temp_param->semantic, semantic))
|
|
{
|
|
TRACE("Returning parameter %p\n", This->parameter_handles[i]);
|
|
return This->parameter_handles[i];
|
|
}
|
|
}
|
|
}
|
|
else if (param)
|
|
{
|
|
for (i = 0; i < param->member_count; ++i)
|
|
{
|
|
temp_param = get_parameter_struct(param->member_handles[i]);
|
|
|
|
if (!temp_param->semantic)
|
|
{
|
|
if (!semantic)
|
|
{
|
|
TRACE("Returning parameter %p\n", param->member_handles[i]);
|
|
return param->member_handles[i];
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (!strcasecmp(temp_param->semantic, semantic))
|
|
{
|
|
TRACE("Returning parameter %p\n", param->member_handles[i]);
|
|
return param->member_handles[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetParameterElement(ID3DXBaseEffect *iface, D3DXHANDLE parameter, UINT index)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, index %u\n", This, parameter, index);
|
|
|
|
if (!param)
|
|
{
|
|
if (index < This->parameter_count)
|
|
{
|
|
TRACE("Returning parameter %p\n", This->parameter_handles[index]);
|
|
return This->parameter_handles[index];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (index < param->element_count)
|
|
{
|
|
TRACE("Returning parameter %p\n", param->member_handles[index]);
|
|
return param->member_handles[index];
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetTechnique(ID3DXBaseEffect *iface, UINT index)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
|
|
TRACE("iface %p, index %u\n", This, index);
|
|
|
|
if (index >= This->technique_count)
|
|
{
|
|
WARN("Invalid argument specified.\n");
|
|
return NULL;
|
|
}
|
|
|
|
TRACE("Returning technique %p\n", This->technique_handles[index]);
|
|
|
|
return This->technique_handles[index];
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetTechniqueByName(ID3DXBaseEffect *iface, LPCSTR name)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
unsigned int i;
|
|
|
|
TRACE("iface %p, name %s stub\n", This, debugstr_a(name));
|
|
|
|
if (!name)
|
|
{
|
|
WARN("Invalid argument specified.\n");
|
|
return NULL;
|
|
}
|
|
|
|
for (i = 0; i < This->technique_count; ++i)
|
|
{
|
|
struct d3dx_technique *tech = get_technique_struct(This->technique_handles[i]);
|
|
|
|
if (!strcmp(tech->name, name))
|
|
{
|
|
TRACE("Returning technique %p\n", This->technique_handles[i]);
|
|
return This->technique_handles[i];
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified.\n");
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetPass(ID3DXBaseEffect *iface, D3DXHANDLE technique, UINT index)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_technique *tech = is_valid_technique(This, technique);
|
|
|
|
TRACE("iface %p, technique %p, index %u\n", This, technique, index);
|
|
|
|
if (!tech) tech = get_technique_struct(iface->lpVtbl->GetTechniqueByName(iface, technique));
|
|
|
|
if (tech && index < tech->pass_count)
|
|
{
|
|
TRACE("Returning pass %p\n", tech->pass_handles[index]);
|
|
return tech->pass_handles[index];
|
|
}
|
|
|
|
WARN("Invalid argument specified.\n");
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetPassByName(ID3DXBaseEffect *iface, D3DXHANDLE technique, LPCSTR name)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_technique *tech = is_valid_technique(This, technique);
|
|
|
|
TRACE("iface %p, technique %p, name %s\n", This, technique, debugstr_a(name));
|
|
|
|
if (!tech) tech = get_technique_struct(iface->lpVtbl->GetTechniqueByName(iface, technique));
|
|
|
|
if (tech && name)
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i = 0; i < tech->pass_count; ++i)
|
|
{
|
|
struct d3dx_pass *pass = get_pass_struct(tech->pass_handles[i]);
|
|
|
|
if (!strcmp(pass->name, name))
|
|
{
|
|
TRACE("Returning pass %p\n", tech->pass_handles[i]);
|
|
return tech->pass_handles[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified.\n");
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetFunction(ID3DXBaseEffect *iface, UINT index)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
|
|
FIXME("iface %p, index %u stub\n", This, index);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetFunctionByName(ID3DXBaseEffect *iface, LPCSTR name)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
|
|
FIXME("iface %p, name %s stub\n", This, debugstr_a(name));
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetAnnotation(ID3DXBaseEffect *iface, D3DXHANDLE object, UINT index)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, object);
|
|
struct d3dx_pass *pass = is_valid_pass(This, object);
|
|
struct d3dx_technique *technique = is_valid_technique(This, object);
|
|
UINT annotation_count = 0;
|
|
D3DXHANDLE *annotation_handles = NULL;
|
|
|
|
FIXME("iface %p, object %p, index %u partial stub\n", This, object, index);
|
|
|
|
if (pass)
|
|
{
|
|
annotation_count = pass->annotation_count;
|
|
annotation_handles = pass->annotation_handles;
|
|
}
|
|
else if (technique)
|
|
{
|
|
annotation_count = technique->annotation_count;
|
|
annotation_handles = technique->annotation_handles;
|
|
}
|
|
else if (param)
|
|
{
|
|
annotation_count = param->annotation_count;
|
|
annotation_handles = param->annotation_handles;
|
|
}
|
|
/* Todo: add funcs */
|
|
|
|
if (index < annotation_count)
|
|
{
|
|
TRACE("Returning parameter %p\n", annotation_handles[index]);
|
|
return annotation_handles[index];
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXBaseEffectImpl_GetAnnotationByName(ID3DXBaseEffect *iface, D3DXHANDLE object, LPCSTR name)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, object);
|
|
struct d3dx_pass *pass = is_valid_pass(This, object);
|
|
struct d3dx_technique *technique = is_valid_technique(This, object);
|
|
UINT annotation_count = 0, i;
|
|
D3DXHANDLE *annotation_handles = NULL;
|
|
|
|
FIXME("iface %p, object %p, name %s partial stub\n", This, object, debugstr_a(name));
|
|
|
|
if (!name)
|
|
{
|
|
WARN("Invalid argument specified\n");
|
|
return NULL;
|
|
}
|
|
|
|
if (pass)
|
|
{
|
|
annotation_count = pass->annotation_count;
|
|
annotation_handles = pass->annotation_handles;
|
|
}
|
|
else if (technique)
|
|
{
|
|
annotation_count = technique->annotation_count;
|
|
annotation_handles = technique->annotation_handles;
|
|
}
|
|
else if (param)
|
|
{
|
|
annotation_count = param->annotation_count;
|
|
annotation_handles = param->annotation_handles;
|
|
}
|
|
/* Todo: add funcs */
|
|
|
|
for (i = 0; i < annotation_count; i++)
|
|
{
|
|
struct d3dx_parameter *anno = get_parameter_struct(annotation_handles[i]);
|
|
|
|
if (!strcmp(anno->name, name))
|
|
{
|
|
TRACE("Returning parameter %p\n", anno);
|
|
return get_parameter_handle(anno);
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetValue(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPCVOID data, UINT bytes)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, data %p, bytes %u\n", This, parameter, data, bytes);
|
|
|
|
if (!param)
|
|
{
|
|
WARN("Invalid parameter %p specified\n", parameter);
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
/* samplers don't touch data */
|
|
if (param->class == D3DXPC_OBJECT && (param->type == D3DXPT_SAMPLER
|
|
|| param->type == D3DXPT_SAMPLER1D || param->type == D3DXPT_SAMPLER2D
|
|
|| param->type == D3DXPT_SAMPLER3D || param->type == D3DXPT_SAMPLERCUBE))
|
|
{
|
|
TRACE("Sampler: returning E_FAIL\n");
|
|
return E_FAIL;
|
|
}
|
|
|
|
if (data && param->bytes >= bytes)
|
|
{
|
|
switch (param->type)
|
|
{
|
|
case D3DXPT_VOID:
|
|
case D3DXPT_BOOL:
|
|
case D3DXPT_INT:
|
|
case D3DXPT_FLOAT:
|
|
TRACE("Copy %u bytes\n", bytes);
|
|
memcpy(param->data, data, bytes);
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
|
|
break;
|
|
}
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetValue(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPVOID data, UINT bytes)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, data %p, bytes %u\n", This, parameter, data, bytes);
|
|
|
|
if (!param)
|
|
{
|
|
WARN("Invalid parameter %p specified\n", parameter);
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
/* samplers don't touch data */
|
|
if (param->class == D3DXPC_OBJECT && (param->type == D3DXPT_SAMPLER
|
|
|| param->type == D3DXPT_SAMPLER1D || param->type == D3DXPT_SAMPLER2D
|
|
|| param->type == D3DXPT_SAMPLER3D || param->type == D3DXPT_SAMPLERCUBE))
|
|
{
|
|
TRACE("Sampler: returning E_FAIL\n");
|
|
return E_FAIL;
|
|
}
|
|
|
|
if (data && param->bytes <= bytes)
|
|
{
|
|
TRACE("Type %s\n", debug_d3dxparameter_type(param->type));
|
|
|
|
switch (param->type)
|
|
{
|
|
case D3DXPT_VOID:
|
|
case D3DXPT_BOOL:
|
|
case D3DXPT_INT:
|
|
case D3DXPT_FLOAT:
|
|
case D3DXPT_STRING:
|
|
break;
|
|
|
|
case D3DXPT_VERTEXSHADER:
|
|
case D3DXPT_PIXELSHADER:
|
|
case D3DXPT_TEXTURE:
|
|
case D3DXPT_TEXTURE1D:
|
|
case D3DXPT_TEXTURE2D:
|
|
case D3DXPT_TEXTURE3D:
|
|
case D3DXPT_TEXTURECUBE:
|
|
{
|
|
UINT i;
|
|
|
|
for (i = 0; i < (param->element_count ? param->element_count : 1); ++i)
|
|
{
|
|
IUnknown *unk = ((IUnknown **)param->data)[i];
|
|
if (unk) IUnknown_AddRef(unk);
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
|
|
break;
|
|
}
|
|
|
|
TRACE("Copy %u bytes\n", param->bytes);
|
|
memcpy(data, param->data, param->bytes);
|
|
return D3D_OK;
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetBool(ID3DXBaseEffect *iface, D3DXHANDLE parameter, BOOL b)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, b %s\n", This, parameter, b ? "TRUE" : "FALSE");
|
|
|
|
if (param && !param->element_count && param->rows == 1 && param->columns == 1)
|
|
{
|
|
set_number(param->data, param->type, &b, D3DXPT_BOOL);
|
|
return D3D_OK;
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetBool(ID3DXBaseEffect *iface, D3DXHANDLE parameter, BOOL *b)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, b %p\n", This, parameter, b);
|
|
|
|
if (b && param && !param->element_count && param->rows == 1 && param->columns == 1)
|
|
{
|
|
*b = get_bool(param->data);
|
|
TRACE("Returning %s\n", *b ? "TRUE" : "FALSE");
|
|
return D3D_OK;
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetBoolArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST BOOL *b, UINT count)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, b %p, count %u\n", This, parameter, b, count);
|
|
|
|
if (param)
|
|
{
|
|
UINT i, size = min(count, param->bytes / sizeof(DWORD));
|
|
|
|
TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
|
|
|
|
switch (param->class)
|
|
{
|
|
case D3DXPC_SCALAR:
|
|
case D3DXPC_VECTOR:
|
|
case D3DXPC_MATRIX_ROWS:
|
|
for (i = 0; i < size; ++i)
|
|
{
|
|
set_number((DWORD *)param->data + i, param->type, &b[i], D3DXPT_BOOL);
|
|
}
|
|
return D3D_OK;
|
|
|
|
case D3DXPC_OBJECT:
|
|
case D3DXPC_STRUCT:
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
|
|
break;
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetBoolArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, BOOL *b, UINT count)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, b %p, count %u\n", This, parameter, b, count);
|
|
|
|
if (b && param && (param->class == D3DXPC_SCALAR
|
|
|| param->class == D3DXPC_VECTOR
|
|
|| param->class == D3DXPC_MATRIX_ROWS
|
|
|| param->class == D3DXPC_MATRIX_COLUMNS))
|
|
{
|
|
UINT i, size = min(count, param->bytes / sizeof(DWORD));
|
|
|
|
for (i = 0; i < size; ++i)
|
|
{
|
|
b[i] = get_bool((DWORD *)param->data + i);
|
|
}
|
|
return D3D_OK;
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetInt(ID3DXBaseEffect *iface, D3DXHANDLE parameter, INT n)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, n %i\n", This, parameter, n);
|
|
|
|
if (param && !param->element_count)
|
|
{
|
|
if (param->rows == 1 && param->columns == 1)
|
|
{
|
|
set_number(param->data, param->type, &n, D3DXPT_INT);
|
|
return D3D_OK;
|
|
}
|
|
|
|
/*
|
|
* Split the value, if parameter is a vector with dimension 3 or 4.
|
|
*/
|
|
if (param->type == D3DXPT_FLOAT &&
|
|
((param->class == D3DXPC_VECTOR && param->columns != 2) ||
|
|
(param->class == D3DXPC_MATRIX_ROWS && param->rows != 2 && param->columns == 1)))
|
|
{
|
|
TRACE("Vector fixup\n");
|
|
|
|
*(FLOAT *)param->data = ((n & 0xff0000) >> 16) * INT_FLOAT_MULTI_INVERSE;
|
|
((FLOAT *)param->data)[1] = ((n & 0xff00) >> 8) * INT_FLOAT_MULTI_INVERSE;
|
|
((FLOAT *)param->data)[2] = (n & 0xff) * INT_FLOAT_MULTI_INVERSE;
|
|
if (param->rows * param->columns > 3)
|
|
{
|
|
((FLOAT *)param->data)[3] = ((n & 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE;
|
|
}
|
|
return D3D_OK;
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetInt(ID3DXBaseEffect *iface, D3DXHANDLE parameter, INT *n)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, n %p\n", This, parameter, n);
|
|
|
|
if (n && param && !param->element_count)
|
|
{
|
|
if (param->columns == 1 && param->rows == 1)
|
|
{
|
|
*n = get_int(param->type, param->data);
|
|
TRACE("Returning %i\n", *n);
|
|
return D3D_OK;
|
|
}
|
|
|
|
if (param->type == D3DXPT_FLOAT &&
|
|
((param->class == D3DXPC_VECTOR && param->columns != 2)
|
|
|| (param->class == D3DXPC_MATRIX_ROWS && param->rows != 2 && param->columns == 1)))
|
|
{
|
|
TRACE("Vector fixup\n");
|
|
|
|
/* all components (3,4) are clamped (0,255) and put in the INT */
|
|
*n = (INT)(min(max(0.0f, *((FLOAT *)param->data + 2)), 1.0f) * INT_FLOAT_MULTI);
|
|
*n += ((INT)(min(max(0.0f, *((FLOAT *)param->data + 1)), 1.0f) * INT_FLOAT_MULTI)) << 8;
|
|
*n += ((INT)(min(max(0.0f, *((FLOAT *)param->data + 0)), 1.0f) * INT_FLOAT_MULTI)) << 16;
|
|
if (param->columns * param->rows > 3)
|
|
{
|
|
*n += ((INT)(min(max(0.0f, *((FLOAT *)param->data + 3)), 1.0f) * INT_FLOAT_MULTI)) << 24;
|
|
}
|
|
|
|
TRACE("Returning %i\n", *n);
|
|
return D3D_OK;
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetIntArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST INT *n, UINT count)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, n %p, count %u\n", This, parameter, n, count);
|
|
|
|
if (param)
|
|
{
|
|
UINT i, size = min(count, param->bytes / sizeof(DWORD));
|
|
|
|
TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
|
|
|
|
switch (param->class)
|
|
{
|
|
case D3DXPC_SCALAR:
|
|
case D3DXPC_VECTOR:
|
|
case D3DXPC_MATRIX_ROWS:
|
|
for (i = 0; i < size; ++i)
|
|
{
|
|
set_number((DWORD *)param->data + i, param->type, &n[i], D3DXPT_INT);
|
|
}
|
|
return D3D_OK;
|
|
|
|
case D3DXPC_OBJECT:
|
|
case D3DXPC_STRUCT:
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
|
|
break;
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetIntArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, INT *n, UINT count)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, n %p, count %u\n", This, parameter, n, count);
|
|
|
|
if (n && param && (param->class == D3DXPC_SCALAR
|
|
|| param->class == D3DXPC_VECTOR
|
|
|| param->class == D3DXPC_MATRIX_ROWS
|
|
|| param->class == D3DXPC_MATRIX_COLUMNS))
|
|
{
|
|
UINT i, size = min(count, param->bytes / sizeof(DWORD));
|
|
|
|
for (i = 0; i < size; ++i)
|
|
{
|
|
n[i] = get_int(param->type, (DWORD *)param->data + i);
|
|
}
|
|
return D3D_OK;
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetFloat(ID3DXBaseEffect *iface, D3DXHANDLE parameter, FLOAT f)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, f %f\n", This, parameter, f);
|
|
|
|
if (param && !param->element_count && param->rows == 1 && param->columns == 1)
|
|
{
|
|
set_number((DWORD *)param->data, param->type, &f, D3DXPT_FLOAT);
|
|
return D3D_OK;
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetFloat(ID3DXBaseEffect *iface, D3DXHANDLE parameter, FLOAT *f)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, f %p\n", This, parameter, f);
|
|
|
|
if (f && param && !param->element_count && param->columns == 1 && param->rows == 1)
|
|
{
|
|
*f = get_float(param->type, (DWORD *)param->data);
|
|
TRACE("Returning %f\n", *f);
|
|
return D3D_OK;
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetFloatArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST FLOAT *f, UINT count)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, f %p, count %u\n", This, parameter, f, count);
|
|
|
|
if (param)
|
|
{
|
|
UINT i, size = min(count, param->bytes / sizeof(DWORD));
|
|
|
|
TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
|
|
|
|
switch (param->class)
|
|
{
|
|
case D3DXPC_SCALAR:
|
|
case D3DXPC_VECTOR:
|
|
case D3DXPC_MATRIX_ROWS:
|
|
for (i = 0; i < size; ++i)
|
|
{
|
|
set_number((DWORD *)param->data + i, param->type, &f[i], D3DXPT_FLOAT);
|
|
}
|
|
return D3D_OK;
|
|
|
|
case D3DXPC_OBJECT:
|
|
case D3DXPC_STRUCT:
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
|
|
break;
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetFloatArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, FLOAT *f, UINT count)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, f %p, count %u\n", This, parameter, f, count);
|
|
|
|
if (f && param && (param->class == D3DXPC_SCALAR
|
|
|| param->class == D3DXPC_VECTOR
|
|
|| param->class == D3DXPC_MATRIX_ROWS
|
|
|| param->class == D3DXPC_MATRIX_COLUMNS))
|
|
{
|
|
UINT i, size = min(count, param->bytes / sizeof(DWORD));
|
|
|
|
for (i = 0; i < size; ++i)
|
|
{
|
|
f[i] = get_float(param->type, (DWORD *)param->data + i);
|
|
}
|
|
return D3D_OK;
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetVector(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, vector %p\n", This, parameter, vector);
|
|
|
|
if (param && !param->element_count)
|
|
{
|
|
TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
|
|
|
|
switch (param->class)
|
|
{
|
|
case D3DXPC_SCALAR:
|
|
case D3DXPC_VECTOR:
|
|
if (param->type == D3DXPT_INT && param->bytes == 4)
|
|
{
|
|
DWORD tmp;
|
|
|
|
TRACE("INT fixup\n");
|
|
tmp = (DWORD)(max(min(vector->z, 1.0f), 0.0f) * INT_FLOAT_MULTI);
|
|
tmp += ((DWORD)(max(min(vector->y, 1.0f), 0.0f) * INT_FLOAT_MULTI)) << 8;
|
|
tmp += ((DWORD)(max(min(vector->x, 1.0f), 0.0f) * INT_FLOAT_MULTI)) << 16;
|
|
tmp += ((DWORD)(max(min(vector->w, 1.0f), 0.0f) * INT_FLOAT_MULTI)) << 24;
|
|
|
|
*(INT *)param->data = tmp;
|
|
return D3D_OK;
|
|
}
|
|
set_vector(param, vector);
|
|
return D3D_OK;
|
|
|
|
case D3DXPC_MATRIX_ROWS:
|
|
case D3DXPC_OBJECT:
|
|
case D3DXPC_STRUCT:
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
|
|
break;
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetVector(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, vector %p\n", This, parameter, vector);
|
|
|
|
if (vector && param && !param->element_count)
|
|
{
|
|
TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
|
|
|
|
switch (param->class)
|
|
{
|
|
case D3DXPC_SCALAR:
|
|
case D3DXPC_VECTOR:
|
|
if (param->type == D3DXPT_INT && param->bytes == 4)
|
|
{
|
|
TRACE("INT fixup\n");
|
|
vector->x = (((*(INT *)param->data) & 0xff0000) >> 16) * INT_FLOAT_MULTI_INVERSE;
|
|
vector->y = (((*(INT *)param->data) & 0xff00) >> 8) * INT_FLOAT_MULTI_INVERSE;
|
|
vector->z = ((*(INT *)param->data) & 0xff) * INT_FLOAT_MULTI_INVERSE;
|
|
vector->w = (((*(INT *)param->data) & 0xff000000) >> 24) * INT_FLOAT_MULTI_INVERSE;
|
|
return D3D_OK;
|
|
}
|
|
get_vector(param, vector);
|
|
return D3D_OK;
|
|
|
|
case D3DXPC_MATRIX_ROWS:
|
|
case D3DXPC_OBJECT:
|
|
case D3DXPC_STRUCT:
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
|
|
break;
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetVectorArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector, UINT count)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, vector %p, count %u stub\n", This, parameter, vector, count);
|
|
|
|
if (param && param->element_count && param->element_count >= count)
|
|
{
|
|
UINT i;
|
|
|
|
TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
|
|
|
|
switch (param->class)
|
|
{
|
|
case D3DXPC_VECTOR:
|
|
for (i = 0; i < count; ++i)
|
|
{
|
|
set_vector(get_parameter_struct(param->member_handles[i]), &vector[i]);
|
|
}
|
|
return D3D_OK;
|
|
|
|
case D3DXPC_SCALAR:
|
|
case D3DXPC_MATRIX_ROWS:
|
|
case D3DXPC_OBJECT:
|
|
case D3DXPC_STRUCT:
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
|
|
break;
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetVectorArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector, UINT count)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, vector %p, count %u\n", This, parameter, vector, count);
|
|
|
|
if (!count) return D3D_OK;
|
|
|
|
if (vector && param && count <= param->element_count)
|
|
{
|
|
UINT i;
|
|
|
|
TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
|
|
|
|
switch (param->class)
|
|
{
|
|
case D3DXPC_VECTOR:
|
|
for (i = 0; i < count; ++i)
|
|
{
|
|
get_vector(get_parameter_struct(param->member_handles[i]), &vector[i]);
|
|
}
|
|
return D3D_OK;
|
|
|
|
case D3DXPC_SCALAR:
|
|
case D3DXPC_MATRIX_ROWS:
|
|
case D3DXPC_OBJECT:
|
|
case D3DXPC_STRUCT:
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
|
|
break;
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrix(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, matrix %p\n", This, parameter, matrix);
|
|
|
|
if (param && !param->element_count)
|
|
{
|
|
TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
|
|
|
|
switch (param->class)
|
|
{
|
|
case D3DXPC_MATRIX_ROWS:
|
|
set_matrix(param, matrix);
|
|
return D3D_OK;
|
|
|
|
case D3DXPC_SCALAR:
|
|
case D3DXPC_VECTOR:
|
|
case D3DXPC_OBJECT:
|
|
case D3DXPC_STRUCT:
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
|
|
break;
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrix(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, matrix %p\n", This, parameter, matrix);
|
|
|
|
if (matrix && param && !param->element_count)
|
|
{
|
|
TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
|
|
|
|
switch (param->class)
|
|
{
|
|
case D3DXPC_MATRIX_ROWS:
|
|
get_matrix(param, matrix);
|
|
return D3D_OK;
|
|
|
|
case D3DXPC_SCALAR:
|
|
case D3DXPC_VECTOR:
|
|
case D3DXPC_OBJECT:
|
|
case D3DXPC_STRUCT:
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
|
|
break;
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrixArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, matrix %p, count %u\n", This, parameter, matrix, count);
|
|
|
|
if (param && param->element_count >= count)
|
|
{
|
|
UINT i;
|
|
|
|
TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
|
|
|
|
switch (param->class)
|
|
{
|
|
case D3DXPC_MATRIX_ROWS:
|
|
for (i = 0; i < count; ++i)
|
|
{
|
|
set_matrix(get_parameter_struct(param->member_handles[i]), &matrix[i]);
|
|
}
|
|
return D3D_OK;
|
|
|
|
case D3DXPC_SCALAR:
|
|
case D3DXPC_VECTOR:
|
|
case D3DXPC_OBJECT:
|
|
case D3DXPC_STRUCT:
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
|
|
break;
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrixArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, matrix %p, count %u\n", This, parameter, matrix, count);
|
|
|
|
if (!count) return D3D_OK;
|
|
|
|
if (matrix && param && count <= param->element_count)
|
|
{
|
|
UINT i;
|
|
|
|
TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
|
|
|
|
switch (param->class)
|
|
{
|
|
case D3DXPC_MATRIX_ROWS:
|
|
for (i = 0; i < count; ++i)
|
|
{
|
|
get_matrix(get_parameter_struct(param->member_handles[i]), &matrix[i]);
|
|
}
|
|
return D3D_OK;
|
|
|
|
case D3DXPC_SCALAR:
|
|
case D3DXPC_VECTOR:
|
|
case D3DXPC_OBJECT:
|
|
case D3DXPC_STRUCT:
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
|
|
break;
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrixPointerArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
|
|
FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrixPointerArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
|
|
FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrixTranspose(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
D3DXMATRIX m;
|
|
|
|
TRACE("iface %p, parameter %p, matrix %p\n", This, parameter, matrix);
|
|
|
|
if (param && !param->element_count)
|
|
{
|
|
TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
|
|
|
|
switch (param->class)
|
|
{
|
|
case D3DXPC_MATRIX_ROWS:
|
|
set_matrix(param, D3DXMatrixTranspose(&m, matrix));
|
|
return D3D_OK;
|
|
|
|
case D3DXPC_SCALAR:
|
|
case D3DXPC_VECTOR:
|
|
case D3DXPC_OBJECT:
|
|
case D3DXPC_STRUCT:
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
|
|
break;
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrixTranspose(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
D3DXMATRIX m;
|
|
|
|
TRACE("iface %p, parameter %p, matrix %p\n", This, parameter, matrix);
|
|
|
|
if (matrix && param && !param->element_count)
|
|
{
|
|
TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
|
|
|
|
switch (param->class)
|
|
{
|
|
case D3DXPC_SCALAR:
|
|
case D3DXPC_VECTOR:
|
|
get_matrix(param, matrix);
|
|
return D3D_OK;
|
|
|
|
case D3DXPC_MATRIX_ROWS:
|
|
get_matrix(param, &m);
|
|
D3DXMatrixTranspose(matrix, &m);
|
|
return D3D_OK;
|
|
|
|
case D3DXPC_OBJECT:
|
|
case D3DXPC_STRUCT:
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
|
|
break;
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrixTransposeArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
D3DXMATRIX m;
|
|
|
|
TRACE("iface %p, parameter %p, matrix %p, count %u\n", This, parameter, matrix, count);
|
|
|
|
if (param && param->element_count >= count)
|
|
{
|
|
UINT i;
|
|
|
|
TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
|
|
|
|
switch (param->class)
|
|
{
|
|
case D3DXPC_MATRIX_ROWS:
|
|
for (i = 0; i < count; ++i)
|
|
{
|
|
set_matrix(get_parameter_struct(param->member_handles[i]), D3DXMatrixTranspose(&m, &matrix[i]));
|
|
}
|
|
return D3D_OK;
|
|
|
|
case D3DXPC_SCALAR:
|
|
case D3DXPC_VECTOR:
|
|
case D3DXPC_OBJECT:
|
|
case D3DXPC_STRUCT:
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
|
|
break;
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrixTransposeArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, matrix %p, count %u\n", This, parameter, matrix, count);
|
|
|
|
if (!count) return D3D_OK;
|
|
|
|
if (matrix && param && count <= param->element_count)
|
|
{
|
|
UINT i;
|
|
|
|
TRACE("Class %s\n", debug_d3dxparameter_class(param->class));
|
|
|
|
switch (param->class)
|
|
{
|
|
case D3DXPC_MATRIX_ROWS:
|
|
for (i = 0; i < count; ++i)
|
|
{
|
|
D3DXMATRIX m;
|
|
|
|
get_matrix(get_parameter_struct(param->member_handles[i]), &m);
|
|
D3DXMatrixTranspose(&matrix[i], &m);
|
|
}
|
|
return D3D_OK;
|
|
|
|
case D3DXPC_SCALAR:
|
|
case D3DXPC_VECTOR:
|
|
case D3DXPC_OBJECT:
|
|
case D3DXPC_STRUCT:
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
|
|
break;
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetMatrixTransposePointerArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
|
|
FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetMatrixTransposePointerArray(ID3DXBaseEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
|
|
FIXME("iface %p, parameter %p, matrix %p, count %u stub\n", This, parameter, matrix, count);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetString(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPCSTR string)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
|
|
FIXME("iface %p, parameter %p, string %p stub\n", This, parameter, string);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetString(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPCSTR *string)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, string %p\n", This, parameter, string);
|
|
|
|
if (string && param && !param->element_count && param->type == D3DXPT_STRING)
|
|
{
|
|
*string = *(LPCSTR *)param->data;
|
|
TRACE("Returning %s\n", debugstr_a(*string));
|
|
return D3D_OK;
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetTexture(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 texture)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, texture %p\n", This, parameter, texture);
|
|
|
|
if (param && !param->element_count &&
|
|
(param->type == D3DXPT_TEXTURE || param->type == D3DXPT_TEXTURE1D
|
|
|| param->type == D3DXPT_TEXTURE2D || param->type == D3DXPT_TEXTURE3D
|
|
|| param->type == D3DXPT_TEXTURECUBE))
|
|
{
|
|
LPDIRECT3DBASETEXTURE9 oltexture = *(LPDIRECT3DBASETEXTURE9 *)param->data;
|
|
|
|
if (texture) IDirect3DBaseTexture9_AddRef(texture);
|
|
if (oltexture) IDirect3DBaseTexture9_Release(oltexture);
|
|
|
|
*(LPDIRECT3DBASETEXTURE9 *)param->data = texture;
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetTexture(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 *texture)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, texture %p\n", This, parameter, texture);
|
|
|
|
if (texture && param && !param->element_count &&
|
|
(param->type == D3DXPT_TEXTURE || param->type == D3DXPT_TEXTURE1D
|
|
|| param->type == D3DXPT_TEXTURE2D || param->type == D3DXPT_TEXTURE3D
|
|
|| param->type == D3DXPT_TEXTURECUBE))
|
|
{
|
|
*texture = *(LPDIRECT3DBASETEXTURE9 *)param->data;
|
|
if (*texture) IDirect3DBaseTexture9_AddRef(*texture);
|
|
TRACE("Returning %p\n", *texture);
|
|
return D3D_OK;
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetPixelShader(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPDIRECT3DPIXELSHADER9 *pshader)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, pshader %p\n", This, parameter, pshader);
|
|
|
|
if (pshader && param && !param->element_count && param->type == D3DXPT_PIXELSHADER)
|
|
{
|
|
*pshader = *(LPDIRECT3DPIXELSHADER9 *)param->data;
|
|
if (*pshader) IDirect3DPixelShader9_AddRef(*pshader);
|
|
TRACE("Returning %p\n", *pshader);
|
|
return D3D_OK;
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_GetVertexShader(ID3DXBaseEffect *iface, D3DXHANDLE parameter, LPDIRECT3DVERTEXSHADER9 *vshader)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
struct d3dx_parameter *param = get_valid_parameter(This, parameter);
|
|
|
|
TRACE("iface %p, parameter %p, vshader %p\n", This, parameter, vshader);
|
|
|
|
if (vshader && param && !param->element_count && param->type == D3DXPT_VERTEXSHADER)
|
|
{
|
|
*vshader = *(LPDIRECT3DVERTEXSHADER9 *)param->data;
|
|
if (*vshader) IDirect3DVertexShader9_AddRef(*vshader);
|
|
TRACE("Returning %p\n", *vshader);
|
|
return D3D_OK;
|
|
}
|
|
|
|
WARN("Invalid argument specified\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXBaseEffectImpl_SetArrayRange(ID3DXBaseEffect *iface, D3DXHANDLE parameter, UINT start, UINT end)
|
|
{
|
|
struct ID3DXBaseEffectImpl *This = impl_from_ID3DXBaseEffect(iface);
|
|
|
|
FIXME("iface %p, parameter %p, start %u, end %u stub\n", This, parameter, start, end);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static const struct ID3DXBaseEffectVtbl ID3DXBaseEffect_Vtbl =
|
|
{
|
|
/*** IUnknown methods ***/
|
|
ID3DXBaseEffectImpl_QueryInterface,
|
|
ID3DXBaseEffectImpl_AddRef,
|
|
ID3DXBaseEffectImpl_Release,
|
|
/*** ID3DXBaseEffect methods ***/
|
|
ID3DXBaseEffectImpl_GetDesc,
|
|
ID3DXBaseEffectImpl_GetParameterDesc,
|
|
ID3DXBaseEffectImpl_GetTechniqueDesc,
|
|
ID3DXBaseEffectImpl_GetPassDesc,
|
|
ID3DXBaseEffectImpl_GetFunctionDesc,
|
|
ID3DXBaseEffectImpl_GetParameter,
|
|
ID3DXBaseEffectImpl_GetParameterByName,
|
|
ID3DXBaseEffectImpl_GetParameterBySemantic,
|
|
ID3DXBaseEffectImpl_GetParameterElement,
|
|
ID3DXBaseEffectImpl_GetTechnique,
|
|
ID3DXBaseEffectImpl_GetTechniqueByName,
|
|
ID3DXBaseEffectImpl_GetPass,
|
|
ID3DXBaseEffectImpl_GetPassByName,
|
|
ID3DXBaseEffectImpl_GetFunction,
|
|
ID3DXBaseEffectImpl_GetFunctionByName,
|
|
ID3DXBaseEffectImpl_GetAnnotation,
|
|
ID3DXBaseEffectImpl_GetAnnotationByName,
|
|
ID3DXBaseEffectImpl_SetValue,
|
|
ID3DXBaseEffectImpl_GetValue,
|
|
ID3DXBaseEffectImpl_SetBool,
|
|
ID3DXBaseEffectImpl_GetBool,
|
|
ID3DXBaseEffectImpl_SetBoolArray,
|
|
ID3DXBaseEffectImpl_GetBoolArray,
|
|
ID3DXBaseEffectImpl_SetInt,
|
|
ID3DXBaseEffectImpl_GetInt,
|
|
ID3DXBaseEffectImpl_SetIntArray,
|
|
ID3DXBaseEffectImpl_GetIntArray,
|
|
ID3DXBaseEffectImpl_SetFloat,
|
|
ID3DXBaseEffectImpl_GetFloat,
|
|
ID3DXBaseEffectImpl_SetFloatArray,
|
|
ID3DXBaseEffectImpl_GetFloatArray,
|
|
ID3DXBaseEffectImpl_SetVector,
|
|
ID3DXBaseEffectImpl_GetVector,
|
|
ID3DXBaseEffectImpl_SetVectorArray,
|
|
ID3DXBaseEffectImpl_GetVectorArray,
|
|
ID3DXBaseEffectImpl_SetMatrix,
|
|
ID3DXBaseEffectImpl_GetMatrix,
|
|
ID3DXBaseEffectImpl_SetMatrixArray,
|
|
ID3DXBaseEffectImpl_GetMatrixArray,
|
|
ID3DXBaseEffectImpl_SetMatrixPointerArray,
|
|
ID3DXBaseEffectImpl_GetMatrixPointerArray,
|
|
ID3DXBaseEffectImpl_SetMatrixTranspose,
|
|
ID3DXBaseEffectImpl_GetMatrixTranspose,
|
|
ID3DXBaseEffectImpl_SetMatrixTransposeArray,
|
|
ID3DXBaseEffectImpl_GetMatrixTransposeArray,
|
|
ID3DXBaseEffectImpl_SetMatrixTransposePointerArray,
|
|
ID3DXBaseEffectImpl_GetMatrixTransposePointerArray,
|
|
ID3DXBaseEffectImpl_SetString,
|
|
ID3DXBaseEffectImpl_GetString,
|
|
ID3DXBaseEffectImpl_SetTexture,
|
|
ID3DXBaseEffectImpl_GetTexture,
|
|
ID3DXBaseEffectImpl_GetPixelShader,
|
|
ID3DXBaseEffectImpl_GetVertexShader,
|
|
ID3DXBaseEffectImpl_SetArrayRange,
|
|
};
|
|
|
|
static inline struct ID3DXEffectImpl *impl_from_ID3DXEffect(ID3DXEffect *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, struct ID3DXEffectImpl, ID3DXEffect_iface);
|
|
}
|
|
|
|
/*** IUnknown methods ***/
|
|
static HRESULT WINAPI ID3DXEffectImpl_QueryInterface(ID3DXEffect *iface, REFIID riid, void **object)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), object);
|
|
|
|
if (IsEqualGUID(riid, &IID_IUnknown) ||
|
|
IsEqualGUID(riid, &IID_ID3DXEffect))
|
|
{
|
|
This->ID3DXEffect_iface.lpVtbl->AddRef(iface);
|
|
*object = This;
|
|
return S_OK;
|
|
}
|
|
|
|
ERR("Interface %s not found\n", debugstr_guid(riid));
|
|
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
static ULONG WINAPI ID3DXEffectImpl_AddRef(ID3DXEffect *iface)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
TRACE("(%p)->(): AddRef from %u\n", This, This->ref);
|
|
|
|
return InterlockedIncrement(&This->ref);
|
|
}
|
|
|
|
static ULONG WINAPI ID3DXEffectImpl_Release(ID3DXEffect *iface)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ULONG ref = InterlockedDecrement(&This->ref);
|
|
|
|
TRACE("(%p)->(): Release from %u\n", This, ref + 1);
|
|
|
|
if (!ref)
|
|
{
|
|
free_effect(This);
|
|
HeapFree(GetProcessHeap(), 0, This);
|
|
}
|
|
|
|
return ref;
|
|
}
|
|
|
|
/*** ID3DXBaseEffect methods ***/
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetDesc(ID3DXEffect *iface, D3DXEFFECT_DESC *desc)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetDesc(base, desc);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetParameterDesc(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXPARAMETER_DESC *desc)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetParameterDesc(base, parameter, desc);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetTechniqueDesc(ID3DXEffect *iface, D3DXHANDLE technique, D3DXTECHNIQUE_DESC *desc)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetTechniqueDesc(base, technique, desc);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetPassDesc(ID3DXEffect *iface, D3DXHANDLE pass, D3DXPASS_DESC *desc)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetPassDesc(base, pass, desc);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetFunctionDesc(ID3DXEffect *iface, D3DXHANDLE shader, D3DXFUNCTION_DESC *desc)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetFunctionDesc(base, shader, desc);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameter(ID3DXEffect *iface, D3DXHANDLE parameter, UINT index)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetParameter(base, parameter, index);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameterByName(ID3DXEffect *iface, D3DXHANDLE parameter, LPCSTR name)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetParameterByName(base, parameter, name);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameterBySemantic(ID3DXEffect *iface, D3DXHANDLE parameter, LPCSTR semantic)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetParameterBySemantic(base, parameter, semantic);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectImpl_GetParameterElement(ID3DXEffect *iface, D3DXHANDLE parameter, UINT index)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetParameterElement(base, parameter, index);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectImpl_GetTechnique(ID3DXEffect *iface, UINT index)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetTechnique(base, index);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectImpl_GetTechniqueByName(ID3DXEffect *iface, LPCSTR name)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetTechniqueByName(base, name);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectImpl_GetPass(ID3DXEffect *iface, D3DXHANDLE technique, UINT index)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetPass(base, technique, index);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectImpl_GetPassByName(ID3DXEffect *iface, D3DXHANDLE technique, LPCSTR name)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetPassByName(base, technique, name);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectImpl_GetFunction(ID3DXEffect *iface, UINT index)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetFunction(base, index);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectImpl_GetFunctionByName(ID3DXEffect *iface, LPCSTR name)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetFunctionByName(base, name);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectImpl_GetAnnotation(ID3DXEffect *iface, D3DXHANDLE object, UINT index)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetAnnotation(base, object, index);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectImpl_GetAnnotationByName(ID3DXEffect *iface, D3DXHANDLE object, LPCSTR name)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetAnnotationByName(base, object, name);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetValue(ID3DXEffect *iface, D3DXHANDLE parameter, LPCVOID data, UINT bytes)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetValue(base, parameter, data, bytes);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetValue(ID3DXEffect *iface, D3DXHANDLE parameter, LPVOID data, UINT bytes)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetValue(base, parameter, data, bytes);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetBool(ID3DXEffect *iface, D3DXHANDLE parameter, BOOL b)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetBool(base, parameter, b);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetBool(ID3DXEffect *iface, D3DXHANDLE parameter, BOOL *b)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetBool(base, parameter, b);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetBoolArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST BOOL *b, UINT count)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetBoolArray(base, parameter, b, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetBoolArray(ID3DXEffect *iface, D3DXHANDLE parameter, BOOL *b, UINT count)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetBoolArray(base, parameter, b, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetInt(ID3DXEffect *iface, D3DXHANDLE parameter, INT n)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetInt(base, parameter, n);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetInt(ID3DXEffect *iface, D3DXHANDLE parameter, INT *n)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetInt(base, parameter, n);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetIntArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST INT *n, UINT count)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetIntArray(base, parameter, n, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetIntArray(ID3DXEffect *iface, D3DXHANDLE parameter, INT *n, UINT count)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetIntArray(base, parameter, n, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetFloat(ID3DXEffect *iface, D3DXHANDLE parameter, FLOAT f)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetFloat(base, parameter, f);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetFloat(ID3DXEffect *iface, D3DXHANDLE parameter, FLOAT *f)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetFloat(base, parameter, f);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetFloatArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST FLOAT *f, UINT count)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetFloatArray(base, parameter, f, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetFloatArray(ID3DXEffect *iface, D3DXHANDLE parameter, FLOAT *f, UINT count)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetFloatArray(base, parameter, f, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetVector(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetVector(base, parameter, vector);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetVector(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetVector(base, parameter, vector);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetVectorArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector, UINT count)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetVectorArray(base, parameter, vector, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetVectorArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector, UINT count)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetVectorArray(base, parameter, vector, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetMatrix(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetMatrix(base, parameter, matrix);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetMatrix(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetMatrix(base, parameter, matrix);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetMatrixArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetMatrixArray(base, parameter, matrix, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetMatrixArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetMatrixArray(base, parameter, matrix, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetMatrixPointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetMatrixPointerArray(base, parameter, matrix, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetMatrixPointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetMatrixPointerArray(base, parameter, matrix, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetMatrixTranspose(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetMatrixTranspose(base, parameter, matrix);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetMatrixTranspose(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetMatrixTranspose(base, parameter, matrix);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetMatrixTransposeArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetMatrixTransposeArray(base, parameter, matrix, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetMatrixTransposeArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetMatrixTransposeArray(base, parameter, matrix, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetMatrixTransposePointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetMatrixTransposePointerArray(base, parameter, matrix, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetMatrixTransposePointerArray(ID3DXEffect *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetMatrixTransposePointerArray(base, parameter, matrix, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetString(ID3DXEffect *iface, D3DXHANDLE parameter, LPCSTR string)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetString(base, parameter, string);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetString(ID3DXEffect *iface, D3DXHANDLE parameter, LPCSTR *string)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetString(base, parameter, string);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetTexture(ID3DXEffect *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 texture)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetTexture(base, parameter, texture);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetTexture(ID3DXEffect *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 *texture)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetTexture(base, parameter, texture);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetPixelShader(ID3DXEffect *iface, D3DXHANDLE parameter, LPDIRECT3DPIXELSHADER9 *pshader)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetPixelShader(base, parameter, pshader);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetVertexShader(ID3DXEffect *iface, D3DXHANDLE parameter, LPDIRECT3DVERTEXSHADER9 *vshader)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetVertexShader(base, parameter, vshader);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetArrayRange(ID3DXEffect *iface, D3DXHANDLE parameter, UINT start, UINT end)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetArrayRange(base, parameter, start, end);
|
|
}
|
|
|
|
/*** ID3DXEffect methods ***/
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetPool(ID3DXEffect *iface, LPD3DXEFFECTPOOL *pool)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
TRACE("iface %p, pool %p\n", This, pool);
|
|
|
|
if (!pool)
|
|
{
|
|
WARN("Invalid argument supplied.\n");
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
if (This->pool)
|
|
{
|
|
This->pool->lpVtbl->AddRef(This->pool);
|
|
}
|
|
|
|
*pool = This->pool;
|
|
|
|
TRACE("Returning pool %p\n", *pool);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetTechnique(ID3DXEffect *iface, D3DXHANDLE technique)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
struct ID3DXBaseEffectImpl *base = impl_from_ID3DXBaseEffect(This->base_effect);
|
|
struct d3dx_technique *tech = is_valid_technique(base, technique);
|
|
|
|
TRACE("iface %p, technique %p\n", This, technique);
|
|
|
|
if (!tech) tech = get_technique_struct(iface->lpVtbl->GetTechniqueByName(iface, technique));
|
|
|
|
if (tech)
|
|
{
|
|
UINT i;
|
|
|
|
for (i = 0; i < base->technique_count; ++i)
|
|
{
|
|
struct d3dx_technique *t = get_technique_struct(base->technique_handles[i]);
|
|
|
|
if (tech == t)
|
|
{
|
|
This->active_technique = get_technique_handle(t);
|
|
TRACE("Technique %u (%p)\n", i, tech);
|
|
return D3D_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
WARN("Invalid argument supplied.\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectImpl_GetCurrentTechnique(ID3DXEffect *iface)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
TRACE("iface %p\n", This);
|
|
|
|
return This->active_technique;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_ValidateTechnique(ID3DXEffect* iface, D3DXHANDLE technique)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
FIXME("(%p)->(%p): stub\n", This, technique);
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_FindNextValidTechnique(ID3DXEffect* iface, D3DXHANDLE technique, D3DXHANDLE* next_technique)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
FIXME("(%p)->(%p, %p): stub\n", This, technique, next_technique);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static BOOL WINAPI ID3DXEffectImpl_IsParameterUsed(ID3DXEffect* iface, D3DXHANDLE parameter, D3DXHANDLE technique)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
FIXME("(%p)->(%p, %p): stub\n", This, parameter, technique);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_Begin(ID3DXEffect *iface, UINT *passes, DWORD flags)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
struct d3dx_technique *technique = get_technique_struct(This->active_technique);
|
|
|
|
FIXME("iface %p, passes %p, flags %#x partial stub\n", This, passes, flags);
|
|
|
|
if (passes && technique)
|
|
{
|
|
if (This->manager || flags & D3DXFX_DONOTSAVESTATE)
|
|
{
|
|
TRACE("State capturing disabled.\n");
|
|
}
|
|
else
|
|
{
|
|
FIXME("State capturing not supported, yet!\n");
|
|
}
|
|
|
|
*passes = technique->pass_count;
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
WARN("Invalid argument supplied.\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_BeginPass(ID3DXEffect *iface, UINT pass)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
struct d3dx_technique *technique = get_technique_struct(This->active_technique);
|
|
|
|
TRACE("iface %p, pass %u\n", This, pass);
|
|
|
|
if (technique && pass < technique->pass_count && !This->active_pass)
|
|
{
|
|
This->active_pass = technique->pass_handles[pass];
|
|
|
|
FIXME("No states applied, yet!\n");
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
WARN("Invalid argument supplied.\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_CommitChanges(ID3DXEffect* iface)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
FIXME("(%p)->(): stub\n", This);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_EndPass(ID3DXEffect *iface)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
TRACE("iface %p\n", This);
|
|
|
|
if (This->active_pass)
|
|
{
|
|
This->active_pass = NULL;
|
|
return D3D_OK;
|
|
}
|
|
|
|
WARN("Invalid call.\n");
|
|
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_End(ID3DXEffect* iface)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
FIXME("(%p)->(): stub\n", This);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetDevice(ID3DXEffect *iface, LPDIRECT3DDEVICE9 *device)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
TRACE("iface %p, device %p\n", This, device);
|
|
|
|
if (!device)
|
|
{
|
|
WARN("Invalid argument supplied.\n");
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
IDirect3DDevice9_AddRef(This->device);
|
|
|
|
*device = This->device;
|
|
|
|
TRACE("Returning device %p\n", *device);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_OnLostDevice(ID3DXEffect* iface)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
FIXME("(%p)->(): stub\n", This);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_OnResetDevice(ID3DXEffect* iface)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
FIXME("(%p)->(): stub\n", This);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetStateManager(ID3DXEffect *iface, LPD3DXEFFECTSTATEMANAGER manager)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
TRACE("iface %p, manager %p\n", This, manager);
|
|
|
|
if (manager) IUnknown_AddRef(manager);
|
|
if (This->manager) IUnknown_Release(This->manager);
|
|
|
|
This->manager = manager;
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_GetStateManager(ID3DXEffect *iface, LPD3DXEFFECTSTATEMANAGER *manager)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
TRACE("iface %p, manager %p\n", This, manager);
|
|
|
|
if (!manager)
|
|
{
|
|
WARN("Invalid argument supplied.\n");
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
if (This->manager) IUnknown_AddRef(This->manager);
|
|
*manager = This->manager;
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_BeginParameterBlock(ID3DXEffect* iface)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
FIXME("(%p)->(): stub\n", This);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectImpl_EndParameterBlock(ID3DXEffect* iface)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
FIXME("(%p)->(): stub\n", This);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_ApplyParameterBlock(ID3DXEffect* iface, D3DXHANDLE parameter_block)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
FIXME("(%p)->(%p): stub\n", This, parameter_block);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_DeleteParameterBlock(ID3DXEffect* iface, D3DXHANDLE parameter_block)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
FIXME("(%p)->(%p): stub\n", This, parameter_block);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_CloneEffect(ID3DXEffect* iface, LPDIRECT3DDEVICE9 device, LPD3DXEFFECT* effect)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
FIXME("(%p)->(%p, %p): stub\n", This, device, effect);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectImpl_SetRawValue(ID3DXEffect* iface, D3DXHANDLE parameter, LPCVOID data, UINT byte_offset, UINT bytes)
|
|
{
|
|
struct ID3DXEffectImpl *This = impl_from_ID3DXEffect(iface);
|
|
|
|
FIXME("(%p)->(%p, %p, %u, %u): stub\n", This, parameter, data, byte_offset, bytes);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static const struct ID3DXEffectVtbl ID3DXEffect_Vtbl =
|
|
{
|
|
/*** IUnknown methods ***/
|
|
ID3DXEffectImpl_QueryInterface,
|
|
ID3DXEffectImpl_AddRef,
|
|
ID3DXEffectImpl_Release,
|
|
/*** ID3DXBaseEffect methods ***/
|
|
ID3DXEffectImpl_GetDesc,
|
|
ID3DXEffectImpl_GetParameterDesc,
|
|
ID3DXEffectImpl_GetTechniqueDesc,
|
|
ID3DXEffectImpl_GetPassDesc,
|
|
ID3DXEffectImpl_GetFunctionDesc,
|
|
ID3DXEffectImpl_GetParameter,
|
|
ID3DXEffectImpl_GetParameterByName,
|
|
ID3DXEffectImpl_GetParameterBySemantic,
|
|
ID3DXEffectImpl_GetParameterElement,
|
|
ID3DXEffectImpl_GetTechnique,
|
|
ID3DXEffectImpl_GetTechniqueByName,
|
|
ID3DXEffectImpl_GetPass,
|
|
ID3DXEffectImpl_GetPassByName,
|
|
ID3DXEffectImpl_GetFunction,
|
|
ID3DXEffectImpl_GetFunctionByName,
|
|
ID3DXEffectImpl_GetAnnotation,
|
|
ID3DXEffectImpl_GetAnnotationByName,
|
|
ID3DXEffectImpl_SetValue,
|
|
ID3DXEffectImpl_GetValue,
|
|
ID3DXEffectImpl_SetBool,
|
|
ID3DXEffectImpl_GetBool,
|
|
ID3DXEffectImpl_SetBoolArray,
|
|
ID3DXEffectImpl_GetBoolArray,
|
|
ID3DXEffectImpl_SetInt,
|
|
ID3DXEffectImpl_GetInt,
|
|
ID3DXEffectImpl_SetIntArray,
|
|
ID3DXEffectImpl_GetIntArray,
|
|
ID3DXEffectImpl_SetFloat,
|
|
ID3DXEffectImpl_GetFloat,
|
|
ID3DXEffectImpl_SetFloatArray,
|
|
ID3DXEffectImpl_GetFloatArray,
|
|
ID3DXEffectImpl_SetVector,
|
|
ID3DXEffectImpl_GetVector,
|
|
ID3DXEffectImpl_SetVectorArray,
|
|
ID3DXEffectImpl_GetVectorArray,
|
|
ID3DXEffectImpl_SetMatrix,
|
|
ID3DXEffectImpl_GetMatrix,
|
|
ID3DXEffectImpl_SetMatrixArray,
|
|
ID3DXEffectImpl_GetMatrixArray,
|
|
ID3DXEffectImpl_SetMatrixPointerArray,
|
|
ID3DXEffectImpl_GetMatrixPointerArray,
|
|
ID3DXEffectImpl_SetMatrixTranspose,
|
|
ID3DXEffectImpl_GetMatrixTranspose,
|
|
ID3DXEffectImpl_SetMatrixTransposeArray,
|
|
ID3DXEffectImpl_GetMatrixTransposeArray,
|
|
ID3DXEffectImpl_SetMatrixTransposePointerArray,
|
|
ID3DXEffectImpl_GetMatrixTransposePointerArray,
|
|
ID3DXEffectImpl_SetString,
|
|
ID3DXEffectImpl_GetString,
|
|
ID3DXEffectImpl_SetTexture,
|
|
ID3DXEffectImpl_GetTexture,
|
|
ID3DXEffectImpl_GetPixelShader,
|
|
ID3DXEffectImpl_GetVertexShader,
|
|
ID3DXEffectImpl_SetArrayRange,
|
|
/*** ID3DXEffect methods ***/
|
|
ID3DXEffectImpl_GetPool,
|
|
ID3DXEffectImpl_SetTechnique,
|
|
ID3DXEffectImpl_GetCurrentTechnique,
|
|
ID3DXEffectImpl_ValidateTechnique,
|
|
ID3DXEffectImpl_FindNextValidTechnique,
|
|
ID3DXEffectImpl_IsParameterUsed,
|
|
ID3DXEffectImpl_Begin,
|
|
ID3DXEffectImpl_BeginPass,
|
|
ID3DXEffectImpl_CommitChanges,
|
|
ID3DXEffectImpl_EndPass,
|
|
ID3DXEffectImpl_End,
|
|
ID3DXEffectImpl_GetDevice,
|
|
ID3DXEffectImpl_OnLostDevice,
|
|
ID3DXEffectImpl_OnResetDevice,
|
|
ID3DXEffectImpl_SetStateManager,
|
|
ID3DXEffectImpl_GetStateManager,
|
|
ID3DXEffectImpl_BeginParameterBlock,
|
|
ID3DXEffectImpl_EndParameterBlock,
|
|
ID3DXEffectImpl_ApplyParameterBlock,
|
|
ID3DXEffectImpl_DeleteParameterBlock,
|
|
ID3DXEffectImpl_CloneEffect,
|
|
ID3DXEffectImpl_SetRawValue
|
|
};
|
|
|
|
static inline struct ID3DXEffectCompilerImpl *impl_from_ID3DXEffectCompiler(ID3DXEffectCompiler *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, struct ID3DXEffectCompilerImpl, ID3DXEffectCompiler_iface);
|
|
}
|
|
|
|
/*** IUnknown methods ***/
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_QueryInterface(ID3DXEffectCompiler *iface, REFIID riid, void **object)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
|
|
TRACE("iface %p, riid %s, object %p\n", This, debugstr_guid(riid), object);
|
|
|
|
if (IsEqualGUID(riid, &IID_IUnknown) ||
|
|
IsEqualGUID(riid, &IID_ID3DXEffectCompiler))
|
|
{
|
|
This->ID3DXEffectCompiler_iface.lpVtbl->AddRef(iface);
|
|
*object = This;
|
|
return S_OK;
|
|
}
|
|
|
|
ERR("Interface %s not found\n", debugstr_guid(riid));
|
|
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
static ULONG WINAPI ID3DXEffectCompilerImpl_AddRef(ID3DXEffectCompiler *iface)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
|
|
TRACE("iface %p: AddRef from %u\n", iface, This->ref);
|
|
|
|
return InterlockedIncrement(&This->ref);
|
|
}
|
|
|
|
static ULONG WINAPI ID3DXEffectCompilerImpl_Release(ID3DXEffectCompiler *iface)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ULONG ref = InterlockedDecrement(&This->ref);
|
|
|
|
TRACE("iface %p: Release from %u\n", iface, ref + 1);
|
|
|
|
if (!ref)
|
|
{
|
|
free_effect_compiler(This);
|
|
HeapFree(GetProcessHeap(), 0, This);
|
|
}
|
|
|
|
return ref;
|
|
}
|
|
|
|
/*** ID3DXBaseEffect methods ***/
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetDesc(ID3DXEffectCompiler *iface, D3DXEFFECT_DESC *desc)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetDesc(base, desc);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetParameterDesc(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXPARAMETER_DESC *desc)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetParameterDesc(base, parameter, desc);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetTechniqueDesc(ID3DXEffectCompiler *iface, D3DXHANDLE technique, D3DXTECHNIQUE_DESC *desc)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetTechniqueDesc(base, technique, desc);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetPassDesc(ID3DXEffectCompiler *iface, D3DXHANDLE pass, D3DXPASS_DESC *desc)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetPassDesc(base, pass, desc);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFunctionDesc(ID3DXEffectCompiler *iface, D3DXHANDLE shader, D3DXFUNCTION_DESC *desc)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetFunctionDesc(base, shader, desc);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameter(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT index)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetParameter(base, parameter, index);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterByName(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCSTR name)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetParameterByName(base, parameter, name);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterBySemantic(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCSTR semantic)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetParameterBySemantic(base, parameter, semantic);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetParameterElement(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT index)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetParameterElement(base, parameter, index);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetTechnique(ID3DXEffectCompiler *iface, UINT index)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetTechnique(base, index);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetTechniqueByName(ID3DXEffectCompiler *iface, LPCSTR name)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetTechniqueByName(base, name);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetPass(ID3DXEffectCompiler *iface, D3DXHANDLE technique, UINT index)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetPass(base, technique, index);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetPassByName(ID3DXEffectCompiler *iface, D3DXHANDLE technique, LPCSTR name)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetPassByName(base, technique, name);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetFunction(ID3DXEffectCompiler *iface, UINT index)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetFunction(base, index);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetFunctionByName(ID3DXEffectCompiler *iface, LPCSTR name)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetFunctionByName(base, name);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetAnnotation(ID3DXEffectCompiler *iface, D3DXHANDLE object, UINT index)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetAnnotation(base, object, index);
|
|
}
|
|
|
|
static D3DXHANDLE WINAPI ID3DXEffectCompilerImpl_GetAnnotationByName(ID3DXEffectCompiler *iface, D3DXHANDLE object, LPCSTR name)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetAnnotationByName(base, object, name);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetValue(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCVOID data, UINT bytes)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetValue(base, parameter, data, bytes);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetValue(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPVOID data, UINT bytes)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetValue(base, parameter, data, bytes);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetBool(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL b)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetBool(base, parameter, b);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetBool(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *b)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetBool(base, parameter, b);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetBoolArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST BOOL *b, UINT count)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetBoolArray(base, parameter, b, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetBoolArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *b, UINT count)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetBoolArray(base, parameter, b, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetInt(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT n)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetInt(base, parameter, n);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetInt(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT *n)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetInt(base, parameter, n);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetIntArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST INT *n, UINT count)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetIntArray(base, parameter, n, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetIntArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, INT *n, UINT count)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetIntArray(base, parameter, n, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetFloat(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, FLOAT f)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetFloat(base, parameter, f);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFloat(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, FLOAT *f)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetFloat(base, parameter, f);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetFloatArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST FLOAT *f, UINT count)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetFloatArray(base, parameter, f, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetFloatArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, FLOAT *f, UINT count)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetFloatArray(base, parameter, f, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetVector(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetVector(base, parameter, vector);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVector(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetVector(base, parameter, vector);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetVectorArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXVECTOR4 *vector, UINT count)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetVectorArray(base, parameter, vector, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVectorArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXVECTOR4 *vector, UINT count)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetVectorArray(base, parameter, vector, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrix(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetMatrix(base, parameter, matrix);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrix(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetMatrix(base, parameter, matrix);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetMatrixArray(base, parameter, matrix, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetMatrixArray(base, parameter, matrix, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixPointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetMatrixPointerArray(base, parameter, matrix, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixPointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetMatrixPointerArray(base, parameter, matrix, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTranspose(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetMatrixTranspose(base, parameter, matrix);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTranspose(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetMatrixTranspose(base, parameter, matrix);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTransposeArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX *matrix, UINT count)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetMatrixTransposeArray(base, parameter, matrix, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTransposeArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX *matrix, UINT count)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetMatrixTransposeArray(base, parameter, matrix, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, CONST D3DXMATRIX **matrix, UINT count)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetMatrixTransposePointerArray(base, parameter, matrix, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, D3DXMATRIX **matrix, UINT count)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetMatrixTransposePointerArray(base, parameter, matrix, count);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetString(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCSTR string)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetString(base, parameter, string);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetString(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPCSTR *string)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetString(base, parameter, string);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetTexture(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 texture)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetTexture(base, parameter, texture);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetTexture(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPDIRECT3DBASETEXTURE9 *texture)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetTexture(base, parameter, texture);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetPixelShader(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPDIRECT3DPIXELSHADER9 *pshader)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetPixelShader(base, parameter, pshader);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetVertexShader(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, LPDIRECT3DVERTEXSHADER9 *vshader)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_GetVertexShader(base, parameter, vshader);
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetArrayRange(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, UINT start, UINT end)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
ID3DXBaseEffect *base = This->base_effect;
|
|
|
|
TRACE("Forward iface %p, base %p\n", This, base);
|
|
|
|
return ID3DXBaseEffectImpl_SetArrayRange(base, parameter, start, end);
|
|
}
|
|
|
|
/*** ID3DXEffectCompiler methods ***/
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_SetLiteral(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL literal)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
|
|
FIXME("iface %p, parameter %p, literal %u\n", This, parameter, literal);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_GetLiteral(ID3DXEffectCompiler *iface, D3DXHANDLE parameter, BOOL *literal)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
|
|
FIXME("iface %p, parameter %p, literal %p\n", This, parameter, literal);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_CompileEffect(ID3DXEffectCompiler *iface, DWORD flags,
|
|
LPD3DXBUFFER *effect, LPD3DXBUFFER *error_msgs)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
|
|
FIXME("iface %p, flags %#x, effect %p, error_msgs %p stub\n", This, flags, effect, error_msgs);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static HRESULT WINAPI ID3DXEffectCompilerImpl_CompileShader(ID3DXEffectCompiler *iface, D3DXHANDLE function,
|
|
LPCSTR target, DWORD flags, LPD3DXBUFFER *shader, LPD3DXBUFFER *error_msgs, LPD3DXCONSTANTTABLE *constant_table)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *This = impl_from_ID3DXEffectCompiler(iface);
|
|
|
|
FIXME("iface %p, function %p, target %p, flags %#x, shader %p, error_msgs %p, constant_table %p stub\n",
|
|
This, function, target, flags, shader, error_msgs, constant_table);
|
|
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
static const struct ID3DXEffectCompilerVtbl ID3DXEffectCompiler_Vtbl =
|
|
{
|
|
/*** IUnknown methods ***/
|
|
ID3DXEffectCompilerImpl_QueryInterface,
|
|
ID3DXEffectCompilerImpl_AddRef,
|
|
ID3DXEffectCompilerImpl_Release,
|
|
/*** ID3DXBaseEffect methods ***/
|
|
ID3DXEffectCompilerImpl_GetDesc,
|
|
ID3DXEffectCompilerImpl_GetParameterDesc,
|
|
ID3DXEffectCompilerImpl_GetTechniqueDesc,
|
|
ID3DXEffectCompilerImpl_GetPassDesc,
|
|
ID3DXEffectCompilerImpl_GetFunctionDesc,
|
|
ID3DXEffectCompilerImpl_GetParameter,
|
|
ID3DXEffectCompilerImpl_GetParameterByName,
|
|
ID3DXEffectCompilerImpl_GetParameterBySemantic,
|
|
ID3DXEffectCompilerImpl_GetParameterElement,
|
|
ID3DXEffectCompilerImpl_GetTechnique,
|
|
ID3DXEffectCompilerImpl_GetTechniqueByName,
|
|
ID3DXEffectCompilerImpl_GetPass,
|
|
ID3DXEffectCompilerImpl_GetPassByName,
|
|
ID3DXEffectCompilerImpl_GetFunction,
|
|
ID3DXEffectCompilerImpl_GetFunctionByName,
|
|
ID3DXEffectCompilerImpl_GetAnnotation,
|
|
ID3DXEffectCompilerImpl_GetAnnotationByName,
|
|
ID3DXEffectCompilerImpl_SetValue,
|
|
ID3DXEffectCompilerImpl_GetValue,
|
|
ID3DXEffectCompilerImpl_SetBool,
|
|
ID3DXEffectCompilerImpl_GetBool,
|
|
ID3DXEffectCompilerImpl_SetBoolArray,
|
|
ID3DXEffectCompilerImpl_GetBoolArray,
|
|
ID3DXEffectCompilerImpl_SetInt,
|
|
ID3DXEffectCompilerImpl_GetInt,
|
|
ID3DXEffectCompilerImpl_SetIntArray,
|
|
ID3DXEffectCompilerImpl_GetIntArray,
|
|
ID3DXEffectCompilerImpl_SetFloat,
|
|
ID3DXEffectCompilerImpl_GetFloat,
|
|
ID3DXEffectCompilerImpl_SetFloatArray,
|
|
ID3DXEffectCompilerImpl_GetFloatArray,
|
|
ID3DXEffectCompilerImpl_SetVector,
|
|
ID3DXEffectCompilerImpl_GetVector,
|
|
ID3DXEffectCompilerImpl_SetVectorArray,
|
|
ID3DXEffectCompilerImpl_GetVectorArray,
|
|
ID3DXEffectCompilerImpl_SetMatrix,
|
|
ID3DXEffectCompilerImpl_GetMatrix,
|
|
ID3DXEffectCompilerImpl_SetMatrixArray,
|
|
ID3DXEffectCompilerImpl_GetMatrixArray,
|
|
ID3DXEffectCompilerImpl_SetMatrixPointerArray,
|
|
ID3DXEffectCompilerImpl_GetMatrixPointerArray,
|
|
ID3DXEffectCompilerImpl_SetMatrixTranspose,
|
|
ID3DXEffectCompilerImpl_GetMatrixTranspose,
|
|
ID3DXEffectCompilerImpl_SetMatrixTransposeArray,
|
|
ID3DXEffectCompilerImpl_GetMatrixTransposeArray,
|
|
ID3DXEffectCompilerImpl_SetMatrixTransposePointerArray,
|
|
ID3DXEffectCompilerImpl_GetMatrixTransposePointerArray,
|
|
ID3DXEffectCompilerImpl_SetString,
|
|
ID3DXEffectCompilerImpl_GetString,
|
|
ID3DXEffectCompilerImpl_SetTexture,
|
|
ID3DXEffectCompilerImpl_GetTexture,
|
|
ID3DXEffectCompilerImpl_GetPixelShader,
|
|
ID3DXEffectCompilerImpl_GetVertexShader,
|
|
ID3DXEffectCompilerImpl_SetArrayRange,
|
|
/*** ID3DXEffectCompiler methods ***/
|
|
ID3DXEffectCompilerImpl_SetLiteral,
|
|
ID3DXEffectCompilerImpl_GetLiteral,
|
|
ID3DXEffectCompilerImpl_CompileEffect,
|
|
ID3DXEffectCompilerImpl_CompileShader,
|
|
};
|
|
|
|
static HRESULT d3dx9_parse_sampler(struct d3dx_sampler *sampler, const char *data, const char **ptr, D3DXHANDLE *objects)
|
|
{
|
|
HRESULT hr;
|
|
UINT i;
|
|
struct d3dx_state *states;
|
|
|
|
read_dword(ptr, &sampler->state_count);
|
|
TRACE("Count: %u\n", sampler->state_count);
|
|
|
|
states = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*states) * sampler->state_count);
|
|
if (!states)
|
|
{
|
|
ERR("Out of memory\n");
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
for (i = 0; i < sampler->state_count; ++i)
|
|
{
|
|
hr = d3dx9_parse_state(&states[i], data, ptr, objects);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse state\n");
|
|
goto err_out;
|
|
}
|
|
}
|
|
|
|
sampler->states = states;
|
|
|
|
return D3D_OK;
|
|
|
|
err_out:
|
|
|
|
for (i = 0; i < sampler->state_count; ++i)
|
|
{
|
|
free_state(&states[i]);
|
|
}
|
|
|
|
HeapFree(GetProcessHeap(), 0, states);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT d3dx9_parse_value(struct d3dx_parameter *param, void *value, const char *data, const char **ptr, D3DXHANDLE *objects)
|
|
{
|
|
unsigned int i;
|
|
HRESULT hr;
|
|
UINT old_size = 0;
|
|
DWORD id;
|
|
|
|
if (param->element_count)
|
|
{
|
|
param->data = value;
|
|
|
|
for (i = 0; i < param->element_count; ++i)
|
|
{
|
|
struct d3dx_parameter *member = get_parameter_struct(param->member_handles[i]);
|
|
|
|
hr = d3dx9_parse_value(member, value ? (char *)value + old_size : NULL, data, ptr, objects);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse value\n");
|
|
return hr;
|
|
}
|
|
|
|
old_size += member->bytes;
|
|
}
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
switch(param->class)
|
|
{
|
|
case D3DXPC_SCALAR:
|
|
case D3DXPC_VECTOR:
|
|
case D3DXPC_MATRIX_ROWS:
|
|
case D3DXPC_MATRIX_COLUMNS:
|
|
param->data = value;
|
|
break;
|
|
|
|
case D3DXPC_STRUCT:
|
|
param->data = value;
|
|
|
|
for (i = 0; i < param->member_count; ++i)
|
|
{
|
|
struct d3dx_parameter *member = get_parameter_struct(param->member_handles[i]);
|
|
|
|
hr = d3dx9_parse_value(member, (char *)value + old_size, data, ptr, objects);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse value\n");
|
|
return hr;
|
|
}
|
|
|
|
old_size += member->bytes;
|
|
}
|
|
break;
|
|
|
|
case D3DXPC_OBJECT:
|
|
switch (param->type)
|
|
{
|
|
case D3DXPT_STRING:
|
|
case D3DXPT_TEXTURE:
|
|
case D3DXPT_TEXTURE1D:
|
|
case D3DXPT_TEXTURE2D:
|
|
case D3DXPT_TEXTURE3D:
|
|
case D3DXPT_TEXTURECUBE:
|
|
case D3DXPT_PIXELSHADER:
|
|
case D3DXPT_VERTEXSHADER:
|
|
read_dword(ptr, &id);
|
|
TRACE("Id: %u\n", id);
|
|
objects[id] = get_parameter_handle(param);
|
|
param->data = value;
|
|
break;
|
|
|
|
case D3DXPT_SAMPLER:
|
|
case D3DXPT_SAMPLER1D:
|
|
case D3DXPT_SAMPLER2D:
|
|
case D3DXPT_SAMPLER3D:
|
|
case D3DXPT_SAMPLERCUBE:
|
|
{
|
|
struct d3dx_sampler *sampler;
|
|
|
|
sampler = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*sampler));
|
|
if (!sampler)
|
|
{
|
|
ERR("Out of memory\n");
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
hr = d3dx9_parse_sampler(sampler, data, ptr, objects);
|
|
if (hr != D3D_OK)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, sampler);
|
|
WARN("Failed to parse sampler\n");
|
|
return hr;
|
|
}
|
|
|
|
param->data = sampler;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
|
|
break;
|
|
}
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
static HRESULT d3dx9_parse_init_value(struct d3dx_parameter *param, const char *data, const char *ptr, D3DXHANDLE *objects)
|
|
{
|
|
UINT size = param->bytes;
|
|
HRESULT hr;
|
|
void *value = NULL;
|
|
|
|
TRACE("param size: %u\n", size);
|
|
|
|
if (size)
|
|
{
|
|
value = HeapAlloc(GetProcessHeap(), 0, size);
|
|
if (!value)
|
|
{
|
|
ERR("Failed to allocate data memory.\n");
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
TRACE("Data: %s.\n", debugstr_an(ptr, size));
|
|
memcpy(value, ptr, size);
|
|
}
|
|
|
|
hr = d3dx9_parse_value(param, value, data, &ptr, objects);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse value\n");
|
|
HeapFree(GetProcessHeap(), 0, value);
|
|
return hr;
|
|
}
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
static HRESULT d3dx9_parse_name(char **name, const char *ptr)
|
|
{
|
|
DWORD size;
|
|
|
|
read_dword(&ptr, &size);
|
|
TRACE("Name size: %#x\n", size);
|
|
|
|
if (!size)
|
|
{
|
|
return D3D_OK;
|
|
}
|
|
|
|
*name = HeapAlloc(GetProcessHeap(), 0, size);
|
|
if (!*name)
|
|
{
|
|
ERR("Failed to allocate name memory.\n");
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
TRACE("Name: %s.\n", debugstr_an(ptr, size));
|
|
memcpy(*name, ptr, size);
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
static HRESULT d3dx9_copy_data(char **str, const char **ptr)
|
|
{
|
|
DWORD size;
|
|
|
|
read_dword(ptr, &size);
|
|
TRACE("Data size: %#x\n", size);
|
|
|
|
*str = HeapAlloc(GetProcessHeap(), 0, size);
|
|
if (!*str)
|
|
{
|
|
ERR("Failed to allocate name memory.\n");
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
TRACE("Data: %s.\n", debugstr_an(*ptr, size));
|
|
memcpy(*str, *ptr, size);
|
|
|
|
*ptr += ((size + 3) & ~3);
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
static HRESULT d3dx9_parse_data(struct d3dx_parameter *param, const char **ptr, LPDIRECT3DDEVICE9 device)
|
|
{
|
|
DWORD size;
|
|
HRESULT hr;
|
|
|
|
TRACE("Parse data for parameter %s, type %s\n", debugstr_a(param->name), debug_d3dxparameter_type(param->type));
|
|
|
|
read_dword(ptr, &size);
|
|
TRACE("Data size: %#x\n", size);
|
|
|
|
if (!size)
|
|
{
|
|
TRACE("Size is 0\n");
|
|
*(void **)param->data = NULL;
|
|
return D3D_OK;
|
|
}
|
|
|
|
switch (param->type)
|
|
{
|
|
case D3DXPT_STRING:
|
|
/* re-read with size (sizeof(DWORD) = 4) */
|
|
hr = d3dx9_parse_name((LPSTR *)param->data, *ptr - 4);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse string data\n");
|
|
return hr;
|
|
}
|
|
break;
|
|
|
|
case D3DXPT_VERTEXSHADER:
|
|
hr = IDirect3DDevice9_CreateVertexShader(device, (DWORD *)*ptr, (LPDIRECT3DVERTEXSHADER9 *)param->data);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to create vertex shader\n");
|
|
return hr;
|
|
}
|
|
break;
|
|
|
|
case D3DXPT_PIXELSHADER:
|
|
hr = IDirect3DDevice9_CreatePixelShader(device, (DWORD *)*ptr, (LPDIRECT3DPIXELSHADER9 *)param->data);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to create pixel shader\n");
|
|
return hr;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
|
|
break;
|
|
}
|
|
|
|
|
|
*ptr += ((size + 3) & ~3);
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
static HRESULT d3dx9_parse_effect_typedef(struct d3dx_parameter *param, const char *data, const char **ptr,
|
|
struct d3dx_parameter *parent, UINT flags)
|
|
{
|
|
DWORD offset;
|
|
HRESULT hr;
|
|
D3DXHANDLE *member_handles = NULL;
|
|
UINT i;
|
|
|
|
param->flags = flags;
|
|
|
|
if (!parent)
|
|
{
|
|
read_dword(ptr, ¶m->type);
|
|
TRACE("Type: %s\n", debug_d3dxparameter_type(param->type));
|
|
|
|
read_dword(ptr, ¶m->class);
|
|
TRACE("Class: %s\n", debug_d3dxparameter_class(param->class));
|
|
|
|
read_dword(ptr, &offset);
|
|
TRACE("Type name offset: %#x\n", offset);
|
|
hr = d3dx9_parse_name(¶m->name, data + offset);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse name\n");
|
|
goto err_out;
|
|
}
|
|
|
|
read_dword(ptr, &offset);
|
|
TRACE("Type semantic offset: %#x\n", offset);
|
|
hr = d3dx9_parse_name(¶m->semantic, data + offset);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse semantic\n");
|
|
goto err_out;
|
|
}
|
|
|
|
read_dword(ptr, ¶m->element_count);
|
|
TRACE("Elements: %u\n", param->element_count);
|
|
|
|
switch (param->class)
|
|
{
|
|
case D3DXPC_VECTOR:
|
|
read_dword(ptr, ¶m->columns);
|
|
TRACE("Columns: %u\n", param->columns);
|
|
|
|
read_dword(ptr, ¶m->rows);
|
|
TRACE("Rows: %u\n", param->rows);
|
|
|
|
/* sizeof(DWORD) * rows * columns */
|
|
param->bytes = 4 * param->rows * param->columns;
|
|
break;
|
|
|
|
case D3DXPC_SCALAR:
|
|
case D3DXPC_MATRIX_ROWS:
|
|
case D3DXPC_MATRIX_COLUMNS:
|
|
read_dword(ptr, ¶m->rows);
|
|
TRACE("Rows: %u\n", param->rows);
|
|
|
|
read_dword(ptr, ¶m->columns);
|
|
TRACE("Columns: %u\n", param->columns);
|
|
|
|
/* sizeof(DWORD) * rows * columns */
|
|
param->bytes = 4 * param->rows * param->columns;
|
|
break;
|
|
|
|
case D3DXPC_STRUCT:
|
|
read_dword(ptr, ¶m->member_count);
|
|
TRACE("Members: %u\n", param->member_count);
|
|
break;
|
|
|
|
case D3DXPC_OBJECT:
|
|
switch (param->type)
|
|
{
|
|
case D3DXPT_STRING:
|
|
param->bytes = sizeof(LPCSTR);
|
|
break;
|
|
|
|
case D3DXPT_PIXELSHADER:
|
|
param->bytes = sizeof(LPDIRECT3DPIXELSHADER9);
|
|
break;
|
|
|
|
case D3DXPT_VERTEXSHADER:
|
|
param->bytes = sizeof(LPDIRECT3DVERTEXSHADER9);
|
|
break;
|
|
|
|
case D3DXPT_TEXTURE:
|
|
case D3DXPT_TEXTURE1D:
|
|
case D3DXPT_TEXTURE2D:
|
|
case D3DXPT_TEXTURE3D:
|
|
case D3DXPT_TEXTURECUBE:
|
|
param->bytes = sizeof(LPDIRECT3DBASETEXTURE9);
|
|
break;
|
|
|
|
case D3DXPT_SAMPLER:
|
|
case D3DXPT_SAMPLER1D:
|
|
case D3DXPT_SAMPLER2D:
|
|
case D3DXPT_SAMPLER3D:
|
|
case D3DXPT_SAMPLERCUBE:
|
|
param->bytes = 0;
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled class %s\n", debug_d3dxparameter_class(param->class));
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* elements */
|
|
param->type = parent->type;
|
|
param->class = parent->class;
|
|
param->name = parent->name;
|
|
param->semantic = parent->semantic;
|
|
param->element_count = 0;
|
|
param->annotation_count = 0;
|
|
param->member_count = parent->member_count;
|
|
param->bytes = parent->bytes;
|
|
param->rows = parent->rows;
|
|
param->columns = parent->columns;
|
|
}
|
|
|
|
if (param->element_count)
|
|
{
|
|
unsigned int param_bytes = 0;
|
|
const char *save_ptr = *ptr;
|
|
|
|
member_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*member_handles) * param->element_count);
|
|
if (!member_handles)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
for (i = 0; i < param->element_count; ++i)
|
|
{
|
|
struct d3dx_parameter *member;
|
|
*ptr = save_ptr;
|
|
|
|
member = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*member));
|
|
if (!member)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
member_handles[i] = get_parameter_handle(member);
|
|
|
|
hr = d3dx9_parse_effect_typedef(member, data, ptr, param, flags);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse member\n");
|
|
goto err_out;
|
|
}
|
|
|
|
param_bytes += member->bytes;
|
|
}
|
|
|
|
param->bytes = param_bytes;
|
|
}
|
|
else if (param->member_count)
|
|
{
|
|
member_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*member_handles) * param->member_count);
|
|
if (!member_handles)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
for (i = 0; i < param->member_count; ++i)
|
|
{
|
|
struct d3dx_parameter *member;
|
|
|
|
member = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*member));
|
|
if (!member)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
member_handles[i] = get_parameter_handle(member);
|
|
|
|
hr = d3dx9_parse_effect_typedef(member, data, ptr, NULL, flags);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse member\n");
|
|
goto err_out;
|
|
}
|
|
|
|
param->bytes += member->bytes;
|
|
}
|
|
}
|
|
|
|
param->member_handles = member_handles;
|
|
|
|
return D3D_OK;
|
|
|
|
err_out:
|
|
|
|
if (member_handles)
|
|
{
|
|
unsigned int count;
|
|
|
|
if (param->element_count) count = param->element_count;
|
|
else count = param->member_count;
|
|
|
|
for (i = 0; i < count; ++i)
|
|
{
|
|
free_parameter(member_handles[i], param->element_count != 0, TRUE);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, member_handles);
|
|
}
|
|
|
|
if (!parent)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, param->name);
|
|
HeapFree(GetProcessHeap(), 0, param->semantic);
|
|
}
|
|
param->name = NULL;
|
|
param->semantic = NULL;
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT d3dx9_parse_effect_annotation(struct d3dx_parameter *anno, const char *data, const char **ptr, D3DXHANDLE *objects)
|
|
{
|
|
DWORD offset;
|
|
const char *ptr2;
|
|
HRESULT hr;
|
|
|
|
anno->flags = D3DX_PARAMETER_ANNOTATION;
|
|
|
|
read_dword(ptr, &offset);
|
|
TRACE("Typedef offset: %#x\n", offset);
|
|
ptr2 = data + offset;
|
|
hr = d3dx9_parse_effect_typedef(anno, data, &ptr2, NULL, D3DX_PARAMETER_ANNOTATION);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse type definition\n");
|
|
return hr;
|
|
}
|
|
|
|
read_dword(ptr, &offset);
|
|
TRACE("Value offset: %#x\n", offset);
|
|
hr = d3dx9_parse_init_value(anno, data, data + offset, objects);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse value\n");
|
|
return hr;
|
|
}
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
static HRESULT d3dx9_parse_state(struct d3dx_state *state, const char *data, const char **ptr, D3DXHANDLE *objects)
|
|
{
|
|
DWORD offset;
|
|
const char *ptr2;
|
|
HRESULT hr;
|
|
struct d3dx_parameter *parameter;
|
|
|
|
parameter = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*parameter));
|
|
if (!parameter)
|
|
{
|
|
ERR("Out of memory\n");
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
state->type = ST_CONSTANT;
|
|
|
|
read_dword(ptr, &state->operation);
|
|
TRACE("Operation: %#x (%s)\n", state->operation, state_table[state->operation].name);
|
|
|
|
read_dword(ptr, &state->index);
|
|
TRACE("Index: %#x\n", state->index);
|
|
|
|
read_dword(ptr, &offset);
|
|
TRACE("Typedef offset: %#x\n", offset);
|
|
ptr2 = data + offset;
|
|
hr = d3dx9_parse_effect_typedef(parameter, data, &ptr2, NULL, 0);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse type definition\n");
|
|
goto err_out;
|
|
}
|
|
|
|
read_dword(ptr, &offset);
|
|
TRACE("Value offset: %#x\n", offset);
|
|
hr = d3dx9_parse_init_value(parameter, data, data + offset, objects);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse value\n");
|
|
goto err_out;
|
|
}
|
|
|
|
state->parameter = get_parameter_handle(parameter);
|
|
|
|
return D3D_OK;
|
|
|
|
err_out:
|
|
|
|
free_parameter(get_parameter_handle(parameter), FALSE, FALSE);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT d3dx9_parse_effect_parameter(struct d3dx_parameter *param, const char *data, const char **ptr, D3DXHANDLE *objects)
|
|
{
|
|
DWORD offset;
|
|
HRESULT hr;
|
|
unsigned int i;
|
|
D3DXHANDLE *annotation_handles = NULL;
|
|
const char *ptr2;
|
|
|
|
read_dword(ptr, &offset);
|
|
TRACE("Typedef offset: %#x\n", offset);
|
|
ptr2 = data + offset;
|
|
|
|
read_dword(ptr, &offset);
|
|
TRACE("Value offset: %#x\n", offset);
|
|
|
|
read_dword(ptr, ¶m->flags);
|
|
TRACE("Flags: %#x\n", param->flags);
|
|
|
|
read_dword(ptr, ¶m->annotation_count);
|
|
TRACE("Annotation count: %u\n", param->annotation_count);
|
|
|
|
hr = d3dx9_parse_effect_typedef(param, data, &ptr2, NULL, param->flags);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse type definition\n");
|
|
return hr;
|
|
}
|
|
|
|
hr = d3dx9_parse_init_value(param, data, data + offset, objects);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse value\n");
|
|
return hr;
|
|
}
|
|
|
|
if (param->annotation_count)
|
|
{
|
|
annotation_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation_handles) * param->annotation_count);
|
|
if (!annotation_handles)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
for (i = 0; i < param->annotation_count; ++i)
|
|
{
|
|
struct d3dx_parameter *annotation;
|
|
|
|
annotation = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation));
|
|
if (!annotation)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
annotation_handles[i] = get_parameter_handle(annotation);
|
|
|
|
hr = d3dx9_parse_effect_annotation(annotation, data, ptr, objects);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse annotation\n");
|
|
goto err_out;
|
|
}
|
|
}
|
|
}
|
|
|
|
param->annotation_handles = annotation_handles;
|
|
|
|
return D3D_OK;
|
|
|
|
err_out:
|
|
|
|
if (annotation_handles)
|
|
{
|
|
for (i = 0; i < param->annotation_count; ++i)
|
|
{
|
|
free_parameter(annotation_handles[i], FALSE, FALSE);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, annotation_handles);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT d3dx9_parse_effect_pass(struct d3dx_pass *pass, const char *data, const char **ptr, D3DXHANDLE *objects)
|
|
{
|
|
DWORD offset;
|
|
HRESULT hr;
|
|
unsigned int i;
|
|
D3DXHANDLE *annotation_handles = NULL;
|
|
struct d3dx_state *states = NULL;
|
|
char *name = NULL;
|
|
|
|
read_dword(ptr, &offset);
|
|
TRACE("Pass name offset: %#x\n", offset);
|
|
hr = d3dx9_parse_name(&name, data + offset);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse name\n");
|
|
goto err_out;
|
|
}
|
|
|
|
read_dword(ptr, &pass->annotation_count);
|
|
TRACE("Annotation count: %u\n", pass->annotation_count);
|
|
|
|
read_dword(ptr, &pass->state_count);
|
|
TRACE("State count: %u\n", pass->state_count);
|
|
|
|
if (pass->annotation_count)
|
|
{
|
|
annotation_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation_handles) * pass->annotation_count);
|
|
if (!annotation_handles)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
for (i = 0; i < pass->annotation_count; ++i)
|
|
{
|
|
struct d3dx_parameter *annotation;
|
|
|
|
annotation = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation));
|
|
if (!annotation)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
annotation_handles[i] = get_parameter_handle(annotation);
|
|
|
|
hr = d3dx9_parse_effect_annotation(annotation, data, ptr, objects);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse annotations\n");
|
|
goto err_out;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pass->state_count)
|
|
{
|
|
states = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*states) * pass->state_count);
|
|
if (!states)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
for (i = 0; i < pass->state_count; ++i)
|
|
{
|
|
hr = d3dx9_parse_state(&states[i], data, ptr, objects);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse annotations\n");
|
|
goto err_out;
|
|
}
|
|
}
|
|
}
|
|
|
|
pass->name = name;
|
|
pass->annotation_handles = annotation_handles;
|
|
pass->states = states;
|
|
|
|
return D3D_OK;
|
|
|
|
err_out:
|
|
|
|
if (annotation_handles)
|
|
{
|
|
for (i = 0; i < pass->annotation_count; ++i)
|
|
{
|
|
free_parameter(annotation_handles[i], FALSE, FALSE);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, annotation_handles);
|
|
}
|
|
|
|
if (states)
|
|
{
|
|
for (i = 0; i < pass->state_count; ++i)
|
|
{
|
|
free_state(&states[i]);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, states);
|
|
}
|
|
|
|
HeapFree(GetProcessHeap(), 0, name);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT d3dx9_parse_effect_technique(struct d3dx_technique *technique, const char *data, const char **ptr, D3DXHANDLE *objects)
|
|
{
|
|
DWORD offset;
|
|
HRESULT hr;
|
|
unsigned int i;
|
|
D3DXHANDLE *annotation_handles = NULL;
|
|
D3DXHANDLE *pass_handles = NULL;
|
|
char *name = NULL;
|
|
|
|
read_dword(ptr, &offset);
|
|
TRACE("Technique name offset: %#x\n", offset);
|
|
hr = d3dx9_parse_name(&name, data + offset);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse name\n");
|
|
goto err_out;
|
|
}
|
|
|
|
read_dword(ptr, &technique->annotation_count);
|
|
TRACE("Annotation count: %u\n", technique->annotation_count);
|
|
|
|
read_dword(ptr, &technique->pass_count);
|
|
TRACE("Pass count: %u\n", technique->pass_count);
|
|
|
|
if (technique->annotation_count)
|
|
{
|
|
annotation_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation_handles) * technique->annotation_count);
|
|
if (!annotation_handles)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
for (i = 0; i < technique->annotation_count; ++i)
|
|
{
|
|
struct d3dx_parameter *annotation;
|
|
|
|
annotation = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*annotation));
|
|
if (!annotation)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
annotation_handles[i] = get_parameter_handle(annotation);
|
|
|
|
hr = d3dx9_parse_effect_annotation(annotation, data, ptr, objects);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse annotations\n");
|
|
goto err_out;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (technique->pass_count)
|
|
{
|
|
pass_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pass_handles) * technique->pass_count);
|
|
if (!pass_handles)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
for (i = 0; i < technique->pass_count; ++i)
|
|
{
|
|
struct d3dx_pass *pass;
|
|
|
|
pass = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pass));
|
|
if (!pass)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
pass_handles[i] = get_pass_handle(pass);
|
|
|
|
hr = d3dx9_parse_effect_pass(pass, data, ptr, objects);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse passes\n");
|
|
goto err_out;
|
|
}
|
|
}
|
|
}
|
|
|
|
technique->name = name;
|
|
technique->pass_handles = pass_handles;
|
|
technique->annotation_handles = annotation_handles;
|
|
|
|
return D3D_OK;
|
|
|
|
err_out:
|
|
|
|
if (pass_handles)
|
|
{
|
|
for (i = 0; i < technique->pass_count; ++i)
|
|
{
|
|
free_pass(pass_handles[i]);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, pass_handles);
|
|
}
|
|
|
|
if (annotation_handles)
|
|
{
|
|
for (i = 0; i < technique->annotation_count; ++i)
|
|
{
|
|
free_parameter(annotation_handles[i], FALSE, FALSE);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, annotation_handles);
|
|
}
|
|
|
|
HeapFree(GetProcessHeap(), 0, name);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT d3dx9_parse_resource(struct ID3DXBaseEffectImpl *base, const char *data, const char **ptr)
|
|
{
|
|
DWORD technique_index;
|
|
DWORD index, state_index, usage, element_index;
|
|
struct d3dx_state *state;
|
|
struct d3dx_parameter *param;
|
|
HRESULT hr = E_FAIL;
|
|
|
|
read_dword(ptr, &technique_index);
|
|
TRACE("techn: %u\n", technique_index);
|
|
|
|
read_dword(ptr, &index);
|
|
TRACE("index: %u\n", index);
|
|
|
|
read_dword(ptr, &element_index);
|
|
TRACE("element_index: %u\n", element_index);
|
|
|
|
read_dword(ptr, &state_index);
|
|
TRACE("state_index: %u\n", state_index);
|
|
|
|
read_dword(ptr, &usage);
|
|
TRACE("usage: %u\n", usage);
|
|
|
|
if (technique_index == 0xffffffff)
|
|
{
|
|
struct d3dx_parameter *parameter;
|
|
struct d3dx_sampler *sampler;
|
|
|
|
if (index >= base->parameter_count)
|
|
{
|
|
FIXME("Index out of bounds: index %u >= parameter_count %u\n", index, base->parameter_count);
|
|
return E_FAIL;
|
|
}
|
|
|
|
parameter = get_parameter_struct(base->parameter_handles[index]);
|
|
if (element_index != 0xffffffff)
|
|
{
|
|
if (element_index >= parameter->element_count && parameter->element_count != 0)
|
|
{
|
|
FIXME("Index out of bounds: element_index %u >= element_count %u\n", element_index, parameter->element_count);
|
|
return E_FAIL;
|
|
}
|
|
|
|
if (parameter->element_count != 0) parameter = get_parameter_struct(parameter->member_handles[element_index]);
|
|
}
|
|
|
|
sampler = parameter->data;
|
|
if (state_index >= sampler->state_count)
|
|
{
|
|
FIXME("Index out of bounds: state_index %u >= state_count %u\n", state_index, sampler->state_count);
|
|
return E_FAIL;
|
|
}
|
|
|
|
state = &sampler->states[state_index];
|
|
}
|
|
else
|
|
{
|
|
struct d3dx_technique *technique;
|
|
struct d3dx_pass *pass;
|
|
|
|
if (technique_index >= base->technique_count)
|
|
{
|
|
FIXME("Index out of bounds: technique_index %u >= technique_count %u\n", technique_index, base->technique_count);
|
|
return E_FAIL;
|
|
}
|
|
|
|
technique = get_technique_struct(base->technique_handles[technique_index]);
|
|
if (index >= technique->pass_count)
|
|
{
|
|
FIXME("Index out of bounds: index %u >= pass_count %u\n", index, technique->pass_count);
|
|
return E_FAIL;
|
|
}
|
|
|
|
pass = get_pass_struct(technique->pass_handles[index]);
|
|
if (state_index >= pass->state_count)
|
|
{
|
|
FIXME("Index out of bounds: state_index %u >= state_count %u\n", state_index, pass->state_count);
|
|
return E_FAIL;
|
|
}
|
|
|
|
state = &pass->states[state_index];
|
|
}
|
|
|
|
param = get_parameter_struct(state->parameter);
|
|
|
|
switch (usage)
|
|
{
|
|
case 0:
|
|
TRACE("usage 0: type %s\n", debug_d3dxparameter_type(param->type));
|
|
switch (param->type)
|
|
{
|
|
case D3DXPT_VERTEXSHADER:
|
|
case D3DXPT_PIXELSHADER:
|
|
state->type = ST_CONSTANT;
|
|
hr = d3dx9_parse_data(param, ptr, base->effect->device);
|
|
break;
|
|
|
|
case D3DXPT_BOOL:
|
|
case D3DXPT_INT:
|
|
case D3DXPT_FLOAT:
|
|
case D3DXPT_STRING:
|
|
state->type = ST_FXLC;
|
|
hr = d3dx9_copy_data(param->data, ptr);
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unhandled type %s\n", debug_d3dxparameter_type(param->type));
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
state->type = ST_PARAMETER;
|
|
hr = d3dx9_copy_data(param->data, ptr);
|
|
if (hr == D3D_OK)
|
|
{
|
|
TRACE("Mapping to parameter %s\n", *(char **)param->data);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
FIXME("Unknown usage %x\n", usage);
|
|
break;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT d3dx9_parse_effect(struct ID3DXBaseEffectImpl *base, const char *data, UINT data_size, DWORD start)
|
|
{
|
|
const char *ptr = data + start;
|
|
D3DXHANDLE *parameter_handles = NULL;
|
|
D3DXHANDLE *technique_handles = NULL;
|
|
D3DXHANDLE *objects = NULL;
|
|
UINT stringcount, objectcount, resourcecount;
|
|
HRESULT hr;
|
|
UINT i;
|
|
|
|
read_dword(&ptr, &base->parameter_count);
|
|
TRACE("Parameter count: %u\n", base->parameter_count);
|
|
|
|
read_dword(&ptr, &base->technique_count);
|
|
TRACE("Technique count: %u\n", base->technique_count);
|
|
|
|
skip_dword_unknown(&ptr, 1);
|
|
|
|
read_dword(&ptr, &objectcount);
|
|
TRACE("Object count: %u\n", objectcount);
|
|
|
|
objects = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*objects) * objectcount);
|
|
if (!objects)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
if (base->parameter_count)
|
|
{
|
|
parameter_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*parameter_handles) * base->parameter_count);
|
|
if (!parameter_handles)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
for (i = 0; i < base->parameter_count; ++i)
|
|
{
|
|
struct d3dx_parameter *parameter;
|
|
|
|
parameter = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*parameter));
|
|
if (!parameter)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
parameter_handles[i] = get_parameter_handle(parameter);
|
|
|
|
hr = d3dx9_parse_effect_parameter(parameter, data, &ptr, objects);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse parameter\n");
|
|
goto err_out;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (base->technique_count)
|
|
{
|
|
technique_handles = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*technique_handles) * base->technique_count);
|
|
if (!technique_handles)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
for (i = 0; i < base->technique_count; ++i)
|
|
{
|
|
struct d3dx_technique *technique;
|
|
|
|
technique = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*technique));
|
|
if (!technique)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
technique_handles[i] = get_technique_handle(technique);
|
|
|
|
hr = d3dx9_parse_effect_technique(technique, data, &ptr, objects);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse technique\n");
|
|
goto err_out;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* needed for further parsing */
|
|
base->technique_handles = technique_handles;
|
|
base->parameter_handles = parameter_handles;
|
|
|
|
read_dword(&ptr, &stringcount);
|
|
TRACE("String count: %u\n", stringcount);
|
|
|
|
read_dword(&ptr, &resourcecount);
|
|
TRACE("Resource count: %u\n", resourcecount);
|
|
|
|
for (i = 0; i < stringcount; ++i)
|
|
{
|
|
DWORD id;
|
|
struct d3dx_parameter *param;
|
|
|
|
read_dword(&ptr, &id);
|
|
TRACE("Id: %u\n", id);
|
|
|
|
param = get_parameter_struct(objects[id]);
|
|
|
|
hr = d3dx9_parse_data(param, &ptr, base->effect->device);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse data\n");
|
|
goto err_out;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < resourcecount; ++i)
|
|
{
|
|
TRACE("parse resource %u\n", i);
|
|
|
|
hr = d3dx9_parse_resource(base, data, &ptr);
|
|
if (hr != D3D_OK)
|
|
{
|
|
WARN("Failed to parse data\n");
|
|
goto err_out;
|
|
}
|
|
}
|
|
|
|
HeapFree(GetProcessHeap(), 0, objects);
|
|
|
|
return D3D_OK;
|
|
|
|
err_out:
|
|
|
|
if (technique_handles)
|
|
{
|
|
for (i = 0; i < base->technique_count; ++i)
|
|
{
|
|
free_technique(technique_handles[i]);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, technique_handles);
|
|
}
|
|
|
|
if (parameter_handles)
|
|
{
|
|
for (i = 0; i < base->parameter_count; ++i)
|
|
{
|
|
free_parameter(parameter_handles[i], FALSE, FALSE);
|
|
}
|
|
HeapFree(GetProcessHeap(), 0, parameter_handles);
|
|
}
|
|
|
|
base->technique_handles = NULL;
|
|
base->parameter_handles = NULL;
|
|
|
|
HeapFree(GetProcessHeap(), 0, objects);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static HRESULT d3dx9_base_effect_init(struct ID3DXBaseEffectImpl *base,
|
|
const char *data, SIZE_T data_size, struct ID3DXEffectImpl *effect)
|
|
{
|
|
DWORD tag, offset;
|
|
const char *ptr = data;
|
|
HRESULT hr;
|
|
|
|
TRACE("base %p, data %p, data_size %lu, effect %p\n", base, data, data_size, effect);
|
|
|
|
base->ID3DXBaseEffect_iface.lpVtbl = &ID3DXBaseEffect_Vtbl;
|
|
base->ref = 1;
|
|
base->effect = effect;
|
|
|
|
read_dword(&ptr, &tag);
|
|
TRACE("Tag: %x\n", tag);
|
|
|
|
if (tag != d3dx9_effect_version(9, 1))
|
|
{
|
|
/* todo: compile hlsl ascii code */
|
|
FIXME("HLSL ascii effects not supported, yet\n");
|
|
|
|
/* Show the start of the shader for debugging info. */
|
|
TRACE("effect:\n%s\n", debugstr_an(data, data_size > 40 ? 40 : data_size));
|
|
}
|
|
else
|
|
{
|
|
read_dword(&ptr, &offset);
|
|
TRACE("Offset: %x\n", offset);
|
|
|
|
hr = d3dx9_parse_effect(base, ptr, data_size, offset);
|
|
if (hr != D3D_OK)
|
|
{
|
|
FIXME("Failed to parse effect.\n");
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
static HRESULT d3dx9_effect_init(struct ID3DXEffectImpl *effect, LPDIRECT3DDEVICE9 device,
|
|
const char *data, SIZE_T data_size, LPD3DXEFFECTPOOL pool)
|
|
{
|
|
HRESULT hr;
|
|
struct ID3DXBaseEffectImpl *object = NULL;
|
|
|
|
TRACE("effect %p, device %p, data %p, data_size %lu, pool %p\n", effect, device, data, data_size, pool);
|
|
|
|
effect->ID3DXEffect_iface.lpVtbl = &ID3DXEffect_Vtbl;
|
|
effect->ref = 1;
|
|
|
|
if (pool) pool->lpVtbl->AddRef(pool);
|
|
effect->pool = pool;
|
|
|
|
IDirect3DDevice9_AddRef(device);
|
|
effect->device = device;
|
|
|
|
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
|
|
if (!object)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
hr = d3dx9_base_effect_init(object, data, data_size, effect);
|
|
if (hr != D3D_OK)
|
|
{
|
|
FIXME("Failed to parse effect.\n");
|
|
goto err_out;
|
|
}
|
|
|
|
effect->base_effect = &object->ID3DXBaseEffect_iface;
|
|
|
|
/* initialize defaults - check because of unsupported ascii effects */
|
|
if (object->technique_handles)
|
|
{
|
|
effect->active_technique = object->technique_handles[0];
|
|
effect->active_pass = NULL;
|
|
}
|
|
|
|
return D3D_OK;
|
|
|
|
err_out:
|
|
|
|
HeapFree(GetProcessHeap(), 0, object);
|
|
free_effect(effect);
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT WINAPI D3DXCreateEffectEx(LPDIRECT3DDEVICE9 device,
|
|
LPCVOID srcdata,
|
|
UINT srcdatalen,
|
|
CONST D3DXMACRO* defines,
|
|
LPD3DXINCLUDE include,
|
|
LPCSTR skip_constants,
|
|
DWORD flags,
|
|
LPD3DXEFFECTPOOL pool,
|
|
LPD3DXEFFECT* effect,
|
|
LPD3DXBUFFER* compilation_errors)
|
|
{
|
|
struct ID3DXEffectImpl *object;
|
|
HRESULT hr;
|
|
|
|
FIXME("(%p, %p, %u, %p, %p, %p, %#x, %p, %p, %p): semi-stub\n", device, srcdata, srcdatalen, defines, include,
|
|
skip_constants, flags, pool, effect, compilation_errors);
|
|
|
|
if (!device || !srcdata)
|
|
return D3DERR_INVALIDCALL;
|
|
|
|
if (!srcdatalen)
|
|
return E_FAIL;
|
|
|
|
/* Native dll allows effect to be null so just return D3D_OK after doing basic checks */
|
|
if (!effect)
|
|
return D3D_OK;
|
|
|
|
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
|
|
if (!object)
|
|
{
|
|
ERR("Out of memory\n");
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
hr = d3dx9_effect_init(object, device, srcdata, srcdatalen, pool);
|
|
if (FAILED(hr))
|
|
{
|
|
WARN("Failed to initialize shader reflection\n");
|
|
HeapFree(GetProcessHeap(), 0, object);
|
|
return hr;
|
|
}
|
|
|
|
*effect = &object->ID3DXEffect_iface;
|
|
|
|
TRACE("Created ID3DXEffect %p\n", object);
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
HRESULT WINAPI D3DXCreateEffect(LPDIRECT3DDEVICE9 device,
|
|
LPCVOID srcdata,
|
|
UINT srcdatalen,
|
|
CONST D3DXMACRO* defines,
|
|
LPD3DXINCLUDE include,
|
|
DWORD flags,
|
|
LPD3DXEFFECTPOOL pool,
|
|
LPD3DXEFFECT* effect,
|
|
LPD3DXBUFFER* compilation_errors)
|
|
{
|
|
TRACE("(%p, %p, %u, %p, %p, %#x, %p, %p, %p): Forwarded to D3DXCreateEffectEx\n", device, srcdata, srcdatalen, defines,
|
|
include, flags, pool, effect, compilation_errors);
|
|
|
|
return D3DXCreateEffectEx(device, srcdata, srcdatalen, defines, include, NULL, flags, pool, effect, compilation_errors);
|
|
}
|
|
|
|
static HRESULT d3dx9_effect_compiler_init(struct ID3DXEffectCompilerImpl *compiler, const char *data, SIZE_T data_size)
|
|
{
|
|
HRESULT hr;
|
|
struct ID3DXBaseEffectImpl *object = NULL;
|
|
|
|
TRACE("effect %p, data %p, data_size %lu\n", compiler, data, data_size);
|
|
|
|
compiler->ID3DXEffectCompiler_iface.lpVtbl = &ID3DXEffectCompiler_Vtbl;
|
|
compiler->ref = 1;
|
|
|
|
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
|
|
if (!object)
|
|
{
|
|
ERR("Out of memory\n");
|
|
hr = E_OUTOFMEMORY;
|
|
goto err_out;
|
|
}
|
|
|
|
hr = d3dx9_base_effect_init(object, data, data_size, NULL);
|
|
if (hr != D3D_OK)
|
|
{
|
|
FIXME("Failed to parse effect.\n");
|
|
goto err_out;
|
|
}
|
|
|
|
compiler->base_effect = &object->ID3DXBaseEffect_iface;
|
|
|
|
return D3D_OK;
|
|
|
|
err_out:
|
|
|
|
HeapFree(GetProcessHeap(), 0, object);
|
|
free_effect_compiler(compiler);
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT WINAPI D3DXCreateEffectCompiler(LPCSTR srcdata,
|
|
UINT srcdatalen,
|
|
CONST D3DXMACRO *defines,
|
|
LPD3DXINCLUDE include,
|
|
DWORD flags,
|
|
LPD3DXEFFECTCOMPILER *compiler,
|
|
LPD3DXBUFFER *parse_errors)
|
|
{
|
|
struct ID3DXEffectCompilerImpl *object;
|
|
HRESULT hr;
|
|
|
|
TRACE("srcdata %p, srcdatalen %u, defines %p, include %p, flags %#x, compiler %p, parse_errors %p\n",
|
|
srcdata, srcdatalen, defines, include, flags, compiler, parse_errors);
|
|
|
|
if (!srcdata || !compiler)
|
|
{
|
|
WARN("Invalid arguments supplied\n");
|
|
return D3DERR_INVALIDCALL;
|
|
}
|
|
|
|
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
|
|
if (!object)
|
|
{
|
|
ERR("Out of memory\n");
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
hr = d3dx9_effect_compiler_init(object, srcdata, srcdatalen);
|
|
if (FAILED(hr))
|
|
{
|
|
WARN("Failed to initialize effect compiler\n");
|
|
HeapFree(GetProcessHeap(), 0, object);
|
|
return hr;
|
|
}
|
|
|
|
*compiler = &object->ID3DXEffectCompiler_iface;
|
|
|
|
TRACE("Created ID3DXEffectCompiler %p\n", object);
|
|
|
|
return D3D_OK;
|
|
}
|
|
|
|
static const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl;
|
|
|
|
struct ID3DXEffectPoolImpl
|
|
{
|
|
ID3DXEffectPool ID3DXEffectPool_iface;
|
|
LONG ref;
|
|
};
|
|
|
|
static inline struct ID3DXEffectPoolImpl *impl_from_ID3DXEffectPool(ID3DXEffectPool *iface)
|
|
{
|
|
return CONTAINING_RECORD(iface, struct ID3DXEffectPoolImpl, ID3DXEffectPool_iface);
|
|
}
|
|
|
|
/*** IUnknown methods ***/
|
|
static HRESULT WINAPI ID3DXEffectPoolImpl_QueryInterface(ID3DXEffectPool *iface, REFIID riid, void **object)
|
|
{
|
|
struct ID3DXEffectPoolImpl *This = impl_from_ID3DXEffectPool(iface);
|
|
|
|
TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), object);
|
|
|
|
if (IsEqualGUID(riid, &IID_IUnknown) ||
|
|
IsEqualGUID(riid, &IID_ID3DXEffectPool))
|
|
{
|
|
This->ID3DXEffectPool_iface.lpVtbl->AddRef(iface);
|
|
*object = This;
|
|
return S_OK;
|
|
}
|
|
|
|
WARN("Interface %s not found\n", debugstr_guid(riid));
|
|
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
static ULONG WINAPI ID3DXEffectPoolImpl_AddRef(ID3DXEffectPool *iface)
|
|
{
|
|
struct ID3DXEffectPoolImpl *This = impl_from_ID3DXEffectPool(iface);
|
|
|
|
TRACE("(%p)->(): AddRef from %u\n", This, This->ref);
|
|
|
|
return InterlockedIncrement(&This->ref);
|
|
}
|
|
|
|
static ULONG WINAPI ID3DXEffectPoolImpl_Release(ID3DXEffectPool *iface)
|
|
{
|
|
struct ID3DXEffectPoolImpl *This = impl_from_ID3DXEffectPool(iface);
|
|
ULONG ref = InterlockedDecrement(&This->ref);
|
|
|
|
TRACE("(%p)->(): Release from %u\n", This, ref + 1);
|
|
|
|
if (!ref)
|
|
HeapFree(GetProcessHeap(), 0, This);
|
|
|
|
return ref;
|
|
}
|
|
|
|
static const struct ID3DXEffectPoolVtbl ID3DXEffectPool_Vtbl =
|
|
{
|
|
/*** IUnknown methods ***/
|
|
ID3DXEffectPoolImpl_QueryInterface,
|
|
ID3DXEffectPoolImpl_AddRef,
|
|
ID3DXEffectPoolImpl_Release
|
|
};
|
|
|
|
HRESULT WINAPI D3DXCreateEffectPool(LPD3DXEFFECTPOOL *pool)
|
|
{
|
|
struct ID3DXEffectPoolImpl *object;
|
|
|
|
TRACE("(%p)\n", pool);
|
|
|
|
if (!pool)
|
|
return D3DERR_INVALIDCALL;
|
|
|
|
object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
|
|
if (!object)
|
|
{
|
|
ERR("Out of memory\n");
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
object->ID3DXEffectPool_iface.lpVtbl = &ID3DXEffectPool_Vtbl;
|
|
object->ref = 1;
|
|
|
|
*pool = &object->ID3DXEffectPool_iface;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT WINAPI D3DXCreateEffectFromFileExW(LPDIRECT3DDEVICE9 device, LPCWSTR srcfile,
|
|
const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
|
|
LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
|
|
{
|
|
LPVOID buffer;
|
|
HRESULT ret;
|
|
DWORD size;
|
|
|
|
TRACE("(%s): relay\n", debugstr_w(srcfile));
|
|
|
|
if (!device || !srcfile)
|
|
return D3DERR_INVALIDCALL;
|
|
|
|
ret = map_view_of_file(srcfile, &buffer, &size);
|
|
|
|
if (FAILED(ret))
|
|
return D3DXERR_INVALIDDATA;
|
|
|
|
ret = D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool, effect, compilationerrors);
|
|
UnmapViewOfFile(buffer);
|
|
|
|
return ret;
|
|
}
|
|
|
|
HRESULT WINAPI D3DXCreateEffectFromFileExA(LPDIRECT3DDEVICE9 device, LPCSTR srcfile,
|
|
const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
|
|
LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
|
|
{
|
|
LPWSTR srcfileW;
|
|
HRESULT ret;
|
|
DWORD len;
|
|
|
|
TRACE("(void): relay\n");
|
|
|
|
if (!srcfile)
|
|
return D3DERR_INVALIDCALL;
|
|
|
|
len = MultiByteToWideChar(CP_ACP, 0, srcfile, -1, NULL, 0);
|
|
srcfileW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(*srcfileW));
|
|
MultiByteToWideChar(CP_ACP, 0, srcfile, -1, srcfileW, len);
|
|
|
|
ret = D3DXCreateEffectFromFileExW(device, srcfileW, defines, include, skipconstants, flags, pool, effect, compilationerrors);
|
|
HeapFree(GetProcessHeap(), 0, srcfileW);
|
|
|
|
return ret;
|
|
}
|
|
|
|
HRESULT WINAPI D3DXCreateEffectFromFileW(LPDIRECT3DDEVICE9 device, LPCWSTR srcfile,
|
|
const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
|
|
LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
|
|
{
|
|
TRACE("(void): relay\n");
|
|
return D3DXCreateEffectFromFileExW(device, srcfile, defines, include, NULL, flags, pool, effect, compilationerrors);
|
|
}
|
|
|
|
HRESULT WINAPI D3DXCreateEffectFromFileA(LPDIRECT3DDEVICE9 device, LPCSTR srcfile,
|
|
const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
|
|
LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
|
|
{
|
|
TRACE("(void): relay\n");
|
|
return D3DXCreateEffectFromFileExA(device, srcfile, defines, include, NULL, flags, pool, effect, compilationerrors);
|
|
}
|
|
|
|
HRESULT WINAPI D3DXCreateEffectFromResourceExW(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCWSTR srcresource,
|
|
const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
|
|
LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
|
|
{
|
|
HRSRC resinfo;
|
|
|
|
TRACE("(%p, %s): relay\n", srcmodule, debugstr_w(srcresource));
|
|
|
|
if (!device)
|
|
return D3DERR_INVALIDCALL;
|
|
|
|
resinfo = FindResourceW(srcmodule, srcresource, (LPCWSTR) RT_RCDATA);
|
|
|
|
if (resinfo)
|
|
{
|
|
LPVOID buffer;
|
|
HRESULT ret;
|
|
DWORD size;
|
|
|
|
ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
|
|
|
|
if (FAILED(ret))
|
|
return D3DXERR_INVALIDDATA;
|
|
|
|
return D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool, effect, compilationerrors);
|
|
}
|
|
|
|
return D3DXERR_INVALIDDATA;
|
|
}
|
|
|
|
HRESULT WINAPI D3DXCreateEffectFromResourceExA(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCSTR srcresource,
|
|
const D3DXMACRO *defines, LPD3DXINCLUDE include, LPCSTR skipconstants, DWORD flags,
|
|
LPD3DXEFFECTPOOL pool, LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
|
|
{
|
|
HRSRC resinfo;
|
|
|
|
TRACE("(%p, %s): relay\n", srcmodule, debugstr_a(srcresource));
|
|
|
|
if (!device)
|
|
return D3DERR_INVALIDCALL;
|
|
|
|
resinfo = FindResourceA(srcmodule, srcresource, (LPCSTR) RT_RCDATA);
|
|
|
|
if (resinfo)
|
|
{
|
|
LPVOID buffer;
|
|
HRESULT ret;
|
|
DWORD size;
|
|
|
|
ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
|
|
|
|
if (FAILED(ret))
|
|
return D3DXERR_INVALIDDATA;
|
|
|
|
return D3DXCreateEffectEx(device, buffer, size, defines, include, skipconstants, flags, pool, effect, compilationerrors);
|
|
}
|
|
|
|
return D3DXERR_INVALIDDATA;
|
|
}
|
|
|
|
HRESULT WINAPI D3DXCreateEffectFromResourceW(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCWSTR srcresource,
|
|
const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
|
|
LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
|
|
{
|
|
TRACE("(void): relay\n");
|
|
return D3DXCreateEffectFromResourceExW(device, srcmodule, srcresource, defines, include, NULL, flags, pool, effect, compilationerrors);
|
|
}
|
|
|
|
HRESULT WINAPI D3DXCreateEffectFromResourceA(LPDIRECT3DDEVICE9 device, HMODULE srcmodule, LPCSTR srcresource,
|
|
const D3DXMACRO *defines, LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTPOOL pool,
|
|
LPD3DXEFFECT *effect, LPD3DXBUFFER *compilationerrors)
|
|
{
|
|
TRACE("(void): relay\n");
|
|
return D3DXCreateEffectFromResourceExA(device, srcmodule, srcresource, defines, include, NULL, flags, pool, effect, compilationerrors);
|
|
}
|
|
|
|
HRESULT WINAPI D3DXCreateEffectCompilerFromFileW(LPCWSTR srcfile, const D3DXMACRO *defines, LPD3DXINCLUDE include,
|
|
DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
|
|
{
|
|
LPVOID buffer;
|
|
HRESULT ret;
|
|
DWORD size;
|
|
|
|
TRACE("(%s): relay\n", debugstr_w(srcfile));
|
|
|
|
if (!srcfile)
|
|
return D3DERR_INVALIDCALL;
|
|
|
|
ret = map_view_of_file(srcfile, &buffer, &size);
|
|
|
|
if (FAILED(ret))
|
|
return D3DXERR_INVALIDDATA;
|
|
|
|
ret = D3DXCreateEffectCompiler(buffer, size, defines, include, flags, effectcompiler, parseerrors);
|
|
UnmapViewOfFile(buffer);
|
|
|
|
return ret;
|
|
}
|
|
|
|
HRESULT WINAPI D3DXCreateEffectCompilerFromFileA(LPCSTR srcfile, const D3DXMACRO *defines, LPD3DXINCLUDE include,
|
|
DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
|
|
{
|
|
LPWSTR srcfileW;
|
|
HRESULT ret;
|
|
DWORD len;
|
|
|
|
TRACE("(void): relay\n");
|
|
|
|
if (!srcfile)
|
|
return D3DERR_INVALIDCALL;
|
|
|
|
len = MultiByteToWideChar(CP_ACP, 0, srcfile, -1, NULL, 0);
|
|
srcfileW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(*srcfileW));
|
|
MultiByteToWideChar(CP_ACP, 0, srcfile, -1, srcfileW, len);
|
|
|
|
ret = D3DXCreateEffectCompilerFromFileW(srcfileW, defines, include, flags, effectcompiler, parseerrors);
|
|
HeapFree(GetProcessHeap(), 0, srcfileW);
|
|
|
|
return ret;
|
|
}
|
|
|
|
HRESULT WINAPI D3DXCreateEffectCompilerFromResourceA(HMODULE srcmodule, LPCSTR srcresource, const D3DXMACRO *defines,
|
|
LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
|
|
{
|
|
HRSRC resinfo;
|
|
|
|
TRACE("(%p, %s): relay\n", srcmodule, debugstr_a(srcresource));
|
|
|
|
resinfo = FindResourceA(srcmodule, srcresource, (LPCSTR) RT_RCDATA);
|
|
|
|
if (resinfo)
|
|
{
|
|
LPVOID buffer;
|
|
HRESULT ret;
|
|
DWORD size;
|
|
|
|
ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
|
|
|
|
if (FAILED(ret))
|
|
return D3DXERR_INVALIDDATA;
|
|
|
|
return D3DXCreateEffectCompiler(buffer, size, defines, include, flags, effectcompiler, parseerrors);
|
|
}
|
|
|
|
return D3DXERR_INVALIDDATA;
|
|
}
|
|
|
|
HRESULT WINAPI D3DXCreateEffectCompilerFromResourceW(HMODULE srcmodule, LPCWSTR srcresource, const D3DXMACRO *defines,
|
|
LPD3DXINCLUDE include, DWORD flags, LPD3DXEFFECTCOMPILER *effectcompiler, LPD3DXBUFFER *parseerrors)
|
|
{
|
|
HRSRC resinfo;
|
|
|
|
TRACE("(%p, %s): relay\n", srcmodule, debugstr_w(srcresource));
|
|
|
|
resinfo = FindResourceW(srcmodule, srcresource, (LPCWSTR) RT_RCDATA);
|
|
|
|
if (resinfo)
|
|
{
|
|
LPVOID buffer;
|
|
HRESULT ret;
|
|
DWORD size;
|
|
|
|
ret = load_resource_into_memory(srcmodule, resinfo, &buffer, &size);
|
|
|
|
if (FAILED(ret))
|
|
return D3DXERR_INVALIDDATA;
|
|
|
|
return D3DXCreateEffectCompiler(buffer, size, defines, include, flags, effectcompiler, parseerrors);
|
|
}
|
|
|
|
return D3DXERR_INVALIDDATA;
|
|
}
|