ReactOS Fundraising Campaign 2012
 
€ 4,410 / € 30,000

Information | Donate

Home | Info | Community | Development | myReactOS | Contact Us

  1. Home
  2. Community
  3. Development
  4. myReactOS
  5. Fundraiser 2012

  1. Main Page
  2. Alphabetical List
  3. Data Structures
  4. Directories
  5. File List
  6. Data Fields
  7. Globals
  8. Related Pages

ReactOS Development > Doxygen

d3dx9shader.h
Go to the documentation of this file.
00001 /*
00002  * Copyright 2008 Luis Busquets
00003  *
00004  * This library is free software; you can redistribute it and/or
00005  * modify it under the terms of the GNU Lesser General Public
00006  * License as published by the Free Software Foundation; either
00007  * version 2.1 of the License, or (at your option) any later version.
00008  *
00009  * This library is distributed in the hope that it will be useful,
00010  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012  * Lesser General Public License for more details.
00013  *
00014  * You should have received a copy of the GNU Lesser General Public
00015  * License along with this library; if not, write to the Free Software
00016  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
00017  */
00018 
00019 #include "d3dx9.h"
00020 
00021 #ifndef __D3DX9SHADER_H__
00022 #define __D3DX9SHADER_H__
00023 
00024 #define D3DXSHADER_DEBUG                          0x1
00025 #define D3DXSHADER_SKIPVALIDATION                 0x2
00026 #define D3DXSHADER_SKIPOPTIMIZATION               0x4
00027 #define D3DXSHADER_PACKMATRIX_ROWMAJOR            0x8
00028 #define D3DXSHADER_PACKMATRIX_COLUMNMAJOR         0x10
00029 #define D3DXSHADER_PARTIALPRECISION               0x20
00030 #define D3DXSHADER_FORCE_VS_SOFTWARE_NOOPT        0x40
00031 #define D3DXSHADER_FORCE_PS_SOFTWARE_NOOPT        0x80
00032 #define D3DXSHADER_NO_PRESHADER                   0x100
00033 #define D3DXSHADER_AVOID_FLOW_CONTROL             0x200
00034 #define D3DXSHADER_PREFER_FLOW_CONTROL            0x400
00035 #define D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY 0x1000
00036 #define D3DXSHADER_IEEE_STRICTNESS                0x2000
00037 
00038 #define D3DXSHADER_OPTIMIZATION_LEVEL0            0x4000
00039 #define D3DXSHADER_OPTIMIZATION_LEVEL1            0x0
00040 #define D3DXSHADER_OPTIMIZATION_LEVEL2            0xC000
00041 #define D3DXSHADER_OPTIMIZATION_LEVEL3            0x8000
00042 
00043 #define D3DXSHADER_USE_LEGACY_D3DX9_31_DLL        0x10000
00044 
00045 typedef LPCSTR D3DXHANDLE;
00046 
00047 typedef enum _D3DXREGISTER_SET
00048 {
00049     D3DXRS_BOOL,
00050     D3DXRS_INT4,
00051     D3DXRS_FLOAT4,
00052     D3DXRS_SAMPLER,
00053     D3DXRS_FORCE_DWORD = 0x7fffffff
00054 } D3DXREGISTER_SET, *LPD3DXREGISTER_SET;
00055 
00056 typedef enum D3DXPARAMETER_CLASS
00057 {
00058     D3DXPC_SCALAR,
00059     D3DXPC_VECTOR,
00060     D3DXPC_MATRIX_ROWS,
00061     D3DXPC_MATRIX_COLUMNS,
00062     D3DXPC_OBJECT,
00063     D3DXPC_STRUCT,
00064     D3DXPC_FORCE_DWORD = 0x7fffffff,
00065 } D3DXPARAMETER_CLASS, *LPD3DXPARAMETER_CLASS;
00066 
00067 typedef enum D3DXPARAMETER_TYPE
00068 {
00069     D3DXPT_VOID,
00070     D3DXPT_BOOL,
00071     D3DXPT_INT,
00072     D3DXPT_FLOAT,
00073     D3DXPT_STRING,
00074     D3DXPT_TEXTURE,
00075     D3DXPT_TEXTURE1D,
00076     D3DXPT_TEXTURE2D,
00077     D3DXPT_TEXTURE3D,
00078     D3DXPT_TEXTURECUBE,
00079     D3DXPT_SAMPLER,
00080     D3DXPT_SAMPLER1D,
00081     D3DXPT_SAMPLER2D,
00082     D3DXPT_SAMPLER3D,
00083     D3DXPT_SAMPLERCUBE,
00084     D3DXPT_PIXELSHADER,
00085     D3DXPT_VERTEXSHADER,
00086     D3DXPT_PIXELFRAGMENT,
00087     D3DXPT_VERTEXFRAGMENT,
00088     D3DXPT_UNSUPPORTED,
00089     D3DXPT_FORCE_DWORD = 0x7fffffff,
00090 } D3DXPARAMETER_TYPE, *LPD3DXPARAMETER_TYPE;
00091 
00092 typedef struct _D3DXCONSTANTTABLE_DESC
00093 {
00094     LPCSTR Creator;
00095     DWORD Version;
00096     UINT Constants;
00097 } D3DXCONSTANTTABLE_DESC, *LPD3DXCONSTANTTABLE_DESC;
00098 
00099 typedef struct _D3DXCONSTANT_DESC
00100 {
00101     LPCSTR Name;
00102     D3DXREGISTER_SET RegisterSet;
00103     UINT RegisterIndex;
00104     UINT RegisterCount;
00105     D3DXPARAMETER_CLASS Class;
00106     D3DXPARAMETER_TYPE Type;
00107     UINT Rows;
00108     UINT Columns;
00109     UINT Elements;
00110     UINT StructMembers;
00111     UINT Bytes;
00112     LPCVOID DefaultValue;
00113 } D3DXCONSTANT_DESC, *LPD3DXCONSTANT_DESC;
00114 
00115 DEFINE_GUID(IID_ID3DXConstantTable, 0x9dca3190, 0x38b9, 0x4fc3, 0x92, 0xe3, 0x39, 0xc6, 0xdd, 0xfb, 0x35, 0x8b);
00116 
00117 #undef INTERFACE
00118 #define INTERFACE ID3DXConstantTable
00119 
00120 DECLARE_INTERFACE_(ID3DXConstantTable, ID3DXBuffer)
00121 {
00122     /*** IUnknown methods ***/
00123     STDMETHOD(QueryInterface)(THIS_ REFIID iid, LPVOID *ppv) PURE;
00124     STDMETHOD_(ULONG, AddRef)(THIS) PURE;
00125     STDMETHOD_(ULONG, Release)(THIS) PURE;
00126     /*** ID3DXBuffer methods ***/
00127     STDMETHOD_(LPVOID, GetBufferPointer)(THIS) PURE;
00128     STDMETHOD_(DWORD, GetBufferSize)(THIS) PURE;
00129     /*** ID3DXConstantTable methods ***/
00130     STDMETHOD(GetDesc)(THIS_ D3DXCONSTANTTABLE_DESC *pDesc) PURE;
00131     STDMETHOD(GetConstantDesc)(THIS_ D3DXHANDLE hConstant, D3DXCONSTANT_DESC *pConstantDesc, UINT *pCount) PURE;
00132     STDMETHOD_(D3DXHANDLE, GetConstant)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE;
00133     STDMETHOD_(D3DXHANDLE, GetConstantByName)(THIS_ D3DXHANDLE hConstant, LPCSTR pName) PURE;
00134     STDMETHOD_(D3DXHANDLE, GetConstantElement)(THIS_ D3DXHANDLE hConstant, UINT Index) PURE;
00135     STDMETHOD(SetDefaults)(THIS_ LPDIRECT3DDEVICE9 pDevice) PURE;
00136     STDMETHOD(SetValue)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, LPCVOID pData, UINT Bytes) PURE;
00137     STDMETHOD(SetBool)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, BOOL b) PURE;
00138     STDMETHOD(SetBoolArray)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST BOOL* pb, UINT Count) PURE;
00139     STDMETHOD(SetInt)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, INT n) PURE;
00140     STDMETHOD(SetIntArray)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST INT* pn, UINT Count) PURE;
00141     STDMETHOD(SetFloat)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, FLOAT f) PURE;
00142     STDMETHOD(SetFloatArray)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST FLOAT* pf, UINT Count) PURE;
00143     STDMETHOD(SetVector)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST D3DXVECTOR4* pVector) PURE;
00144     STDMETHOD(SetVectorArray)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST D3DXVECTOR4* pVector, UINT Count) PURE;
00145     STDMETHOD(SetMatrix)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST D3DXMATRIX* pMatrix) PURE;
00146     STDMETHOD(SetMatrixArray)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST D3DXMATRIX* pMatrix, UINT Count) PURE;
00147     STDMETHOD(SetMatrixPointerArray)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST D3DXMATRIX** ppMatrix, UINT Count) PURE;
00148     STDMETHOD(SetMatrixTranspose)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST D3DXMATRIX* pMatrix) PURE;
00149     STDMETHOD(SetMatrixTransposeArray)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST D3DXMATRIX* pMatrix, UINT Count) PURE;
00150     STDMETHOD(SetMatrixTransposePointerArray)(THIS_ LPDIRECT3DDEVICE9 pDevice, D3DXHANDLE hConstant, CONST D3DXMATRIX** ppMatrix, UINT Count) PURE;
00151 };
00152 
00153 #if !defined(__cplusplus) || defined(CINTERFACE)
00154 /*** IUnknown methods ***/
00155 #define ID3DXConstantTable_QueryInterface(p,a,b)                      (p)->lpVtbl->QueryInterface(p,a,b)
00156 #define ID3DXConstantTable_AddRef(p)                                  (p)->lpVtbl->AddRef(p)
00157 #define ID3DXConstantTable_Release(p)                                 (p)->lpVtbl->Release(p)
00158 /*** ID3DXBuffer methods ***/
00159 #define ID3DXConstantTable_GetBufferPointer(p)                        (p)->lpVtbl->GetBufferPointer(p)
00160 #define ID3DXConstantTable_GetBufferSize(p)                           (p)->lpVtbl->GetBufferSize(p)
00161 /*** ID3DXConstantTable methods ***/
00162 #define ID3DXConstantTable_GetDesc(p,a)                               (p)->lpVtbl->GetDesc(p,a)
00163 #define ID3DXConstantTable_GetConstantDesc(p,a,b,c)                   (p)->lpVtbl->GetConstantDesc(p,a,b,c)
00164 #define ID3DXConstantTable_GetConstant(p,a,b)                         (p)->lpVtbl->GetConstant(p,a,b)
00165 #define ID3DXConstantTable_GetConstantByName(p,a,b)                   (p)->lpVtbl->GetConstantByName(p,a,b)
00166 #define ID3DXConstantTable_GetConstantElement(p,a,b)                  (p)->lpVtbl->GetConstantElement(p,a,b)
00167 #define ID3DXConstantTable_SetDefaults(p,a)                           (p)->lpVtbl->SetDefaults(p,a)
00168 #define ID3DXConstantTable_SetValue(p,a,b,c,d)                        (p)->lpVtbl->SetValue(p,a,b,c,d)
00169 #define ID3DXConstantTable_SetBool(p,a,b,c)                           (p)->lpVtbl->SetBool(p,a,b,c)
00170 #define ID3DXConstantTable_SetBoolArray(p,a,b,c,d)                    (p)->lpVtbl->SetBoolArray(p,a,b,c,d)
00171 #define ID3DXConstantTable_SetInt(p,a,b,c)                            (p)->lpVtbl->SetInt(p,a,b,c)
00172 #define ID3DXConstantTable_SetIntArray(p,a,b,c,d)                     (p)->lpVtbl->SetIntArray(p,a,b,c,d)
00173 #define ID3DXConstantTable_SetFloat(p,a,b,c)                          (p)->lpVtbl->SetFloat(p,a,b,c)
00174 #define ID3DXConstantTable_SetFloatArray(p,a,b,c,d)                   (p)->lpVtbl->SetFloatArray(p,a,b,c,d)
00175 #define ID3DXConstantTable_SetVector(p,a,b,c)                         (p)->lpVtbl->SetVector(p,a,b,c)
00176 #define ID3DXConstantTable_SetVectorArray(p,a,b,c,d)                  (p)->lpVtbl->SetVectorArray(p,a,b,c,d)
00177 #define ID3DXConstantTable_SetMatrix(p,a,b,c)                         (p)->lpVtbl->SetMatrix(p,a,b,c)
00178 #define ID3DXConstantTable_SetMatrixArray(p,a,b,c,d)                  (p)->lpVtbl->SetMatrixArray(p,a,b,c,d)
00179 #define ID3DXConstantTable_SetMatrixPointerArray(p,a,b,c,d)           (p)->lpVtbl->SetMatrixPointerArray(p,a,b,c,d)
00180 #define ID3DXConstantTable_SetMatrixTranspose(p,a,b,c)                (p)->lpVtbl->SetMatrixTranspose(p,a,b,c)
00181 #define ID3DXConstantTable_SetMatrixTransposeArray(p,a,b,c,d)         (p)->lpVtbl->SetMatrixTransposeArray(p,a,b,c,d)
00182 #define ID3DXConstantTable_SetMatrixTransposePointerArray(p,a,b,c,d)  (p)->lpVtbl->SetMatrixTransposePointerArray(p,a,b,c,d)
00183 #else
00184 /*** IUnknown methods ***/
00185 #define ID3DXConstantTable_QueryInterface(p,a,b)                      (p)->QueryInterface(a,b)
00186 #define ID3DXConstantTable_AddRef(p)                                  (p)->AddRef()
00187 #define ID3DXConstantTable_Release(p)                                 (p)->Release()
00188 /*** ID3DXBuffer methods ***/
00189 #define ID3DXConstantTable_GetBufferPointer(p)                        (p)->GetBufferPointer()
00190 #define ID3DXConstantTable_GetBufferSize(p)                           (p)->GetBufferSize()
00191 /*** ID3DXConstantTable methods ***/
00192 #define ID3DXConstantTable_GetDesc(p,a)                               (p)->GetDesc(a)
00193 #define ID3DXConstantTable_GetConstantDesc(p,a,b,c)                   (p)->GetConstantDesc(a,b,c)
00194 #define ID3DXConstantTable_GetConstant(p,a,b)                         (p)->GetConstant(a,b)
00195 #define ID3DXConstantTable_GetConstantByName(p,a,b)                   (p)->GetConstantByName(a,b)
00196 #define ID3DXConstantTable_GetConstantElement(p,a,b)                  (p)->GetConstantElement(a,b)
00197 #define ID3DXConstantTable_SetDefaults(p,a)                           (p)->SetDefaults(a)
00198 #define ID3DXConstantTable_SetValue(p,a,b,c,d)                        (p)->SetValue(a,b,c,d)
00199 #define ID3DXConstantTable_SetBool(p,a,b,c)                           (p)->SetBool(a,b,c)
00200 #define ID3DXConstantTable_SetBoolArray(p,a,b,c,d)                    (p)->SetBoolArray(a,b,c,d)
00201 #define ID3DXConstantTable_SetInt(p,a,b,c)                            (p)->SetInt(a,b,c)
00202 #define ID3DXConstantTable_SetIntArray(p,a,b,c,d)                     (p)->SetIntArray(a,b,c,d)
00203 #define ID3DXConstantTable_SetFloat(p,a,b,c)                          (p)->SetFloat(a,b,c)
00204 #define ID3DXConstantTable_SetFloatArray(p,a,b,c,d)                   (p)->SetFloatArray(a,b,c,d)
00205 #define ID3DXConstantTable_SetVector(p,a,b,c)                         (p)->SetVector(a,b,c)
00206 #define ID3DXConstantTable_SetVectorArray(p,a,b,c,d)                  (p)->SetVectorArray(a,b,c,d)
00207 #define ID3DXConstantTable_SetMatrix(p,a,b,c)                         (p)->SetMatrix(a,b,c)
00208 #define ID3DXConstantTable_SetMatrixArray(p,a,b,c,d)                  (p)->SetMatrixArray(a,b,c,d)
00209 #define ID3DXConstantTable_SetMatrixPointerArray(p,a,b,c,d)           (p)->SetMatrixPointerArray(a,b,c,d)
00210 #define ID3DXConstantTable_SetMatrixTranspose(p,a,b,c)                (p)->>SetMatrixTranspose(a,b,c)
00211 #define ID3DXConstantTable_SetMatrixTransposeArray(p,a,b,c,d)         (p)->SetMatrixTransposeArray(a,b,c,d)
00212 #define ID3DXConstantTable_SetMatrixTransposePointerArray(p,a,b,c,d)  (p)->SetMatrixTransposePointerArray(a,b,c,d)
00213 #endif
00214 
00215 typedef struct ID3DXConstantTable *LPD3DXCONSTANTTABLE;
00216 
00217 typedef struct _D3DXMACRO {
00218     LPCSTR Name;
00219     LPCSTR Definition;
00220 } D3DXMACRO, *LPD3DXMACRO;
00221 
00222 typedef enum _D3DXINCLUDE_TYPE
00223 {
00224     D3DXINC_LOCAL,
00225     D3DXINC_SYSTEM,
00226     D3DXINC_FORCE_DWORD = 0x7fffffff,
00227 } D3DXINCLUDE_TYPE, *LPD3DXINCLUDE_TYPE;
00228 
00229 #undef INTERFACE
00230 #define INTERFACE ID3DXInclude
00231 
00232 DECLARE_INTERFACE(ID3DXInclude)
00233 {
00234     STDMETHOD(Open)(THIS_ D3DXINCLUDE_TYPE include_type, LPCSTR filename, LPCVOID parent_data, LPCVOID *data, UINT *bytes) PURE;
00235     STDMETHOD(Close)(THIS_ LPCVOID data) PURE;
00236 };
00237 
00238 #define ID3DXInclude_Open(p,a,b,c,d,e)  (p)->lpVtbl->Open(p,a,b,c,d,e)
00239 #define ID3DXInclude_Close(p,a)         (p)->lpVtbl->Close(p,a)
00240 
00241 typedef struct ID3DXInclude *LPD3DXINCLUDE;
00242 
00243 #ifdef __cplusplus
00244 extern "C" {
00245 #endif
00246 
00247 LPCSTR WINAPI D3DXGetPixelShaderProfile(LPDIRECT3DDEVICE9 device);
00248 UINT WINAPI D3DXGetShaderSize(const DWORD *byte_code);
00249 DWORD WINAPI D3DXGetShaderVersion(const DWORD *byte_code);
00250 LPCSTR WINAPI D3DXGetVertexShaderProfile(LPDIRECT3DDEVICE9 device);
00251 HRESULT WINAPI D3DXFindShaderComment(CONST DWORD* byte_code, DWORD fourcc, LPCVOID* data, UINT* size);
00252 
00253 HRESULT WINAPI D3DXAssembleShaderFromFileA(LPCSTR filename,
00254                                            CONST D3DXMACRO* defines,
00255                                            LPD3DXINCLUDE include,
00256                                            DWORD flags,
00257                                            LPD3DXBUFFER* shader,
00258                                            LPD3DXBUFFER* error_messages);
00259 
00260 HRESULT WINAPI D3DXAssembleShaderFromFileW(LPCWSTR filename,
00261                                            CONST D3DXMACRO* defines,
00262                                            LPD3DXINCLUDE include,
00263                                            DWORD flags,
00264                                            LPD3DXBUFFER* shader,
00265                                            LPD3DXBUFFER* error_messages);
00266 
00267 HRESULT WINAPI D3DXAssembleShaderFromResourceA(HMODULE module,
00268                                                LPCSTR resource,
00269                                                CONST D3DXMACRO* defines,
00270                                                LPD3DXINCLUDE include,
00271                                                DWORD flags,
00272                                                LPD3DXBUFFER* shader,
00273                                                LPD3DXBUFFER* error_messages);
00274 
00275 HRESULT WINAPI D3DXAssembleShaderFromResourceW(HMODULE module,
00276                                                LPCWSTR resource,
00277                                                CONST D3DXMACRO* defines,
00278                                                LPD3DXINCLUDE include,
00279                                                DWORD flags,
00280                                                LPD3DXBUFFER* shader,
00281                                                LPD3DXBUFFER* error_messages);
00282 
00283 HRESULT WINAPI D3DXAssembleShader(LPCSTR data,
00284                                   UINT data_len,
00285                                   CONST D3DXMACRO* defines,
00286                                   LPD3DXINCLUDE include,
00287                                   DWORD flags,
00288                                   LPD3DXBUFFER* shader,
00289                                   LPD3DXBUFFER* error_messages);
00290 
00291 HRESULT WINAPI D3DXGetShaderConstantTableEx(CONST DWORD* byte_code,
00292                                             DWORD flags,
00293                                             LPD3DXCONSTANTTABLE* constant_table);
00294 
00295 HRESULT WINAPI D3DXGetShaderConstantTable(CONST DWORD* byte_code,
00296                                           LPD3DXCONSTANTTABLE* constant_table);
00297 
00298 #ifdef __cplusplus
00299 }
00300 #endif
00301 
00302 #endif /* __D3DX9SHADER_H__ */

Generated on Sun May 27 2012 04:30:37 for ReactOS by doxygen 1.7.6.1

ReactOS is a registered trademark or a trademark of ReactOS Foundation in the United States and other countries.