[2236] | 1 | ///////////////////////////////////////////////////////////////////////////////
|
---|
| 2 | //
|
---|
| 3 | // ## ######
|
---|
| 4 | // ###### ###
|
---|
| 5 | // ## ############### Shark 3D Engine (www.shark3d.com)
|
---|
| 6 | // ########## # # #
|
---|
| 7 | // ######## Copyright (c) 1996-2006 Spinor GmbH.
|
---|
| 8 | // ######### # # # All rights reserved.
|
---|
| 9 | // ## ##########
|
---|
| 10 | // ##
|
---|
| 11 | //
|
---|
| 12 | ///////////////////////////////////////////////////////////////////////////////
|
---|
| 13 |
|
---|
| 14 | //@cpp
|
---|
| 15 |
|
---|
| 16 | #include "drv_d3d9_proghlsl.h"
|
---|
| 17 | #include "drv_d3d9_progutil.h"
|
---|
| 18 | #include "drv_d3d9_progincmgr.h"
|
---|
| 19 | #include "drv_d3d9_progreport.h"
|
---|
| 20 | #include "drv_d3d9_util.h"
|
---|
| 21 | #include "drv/interf/drv_vartypes.h"
|
---|
| 22 | #include "drv/util/drv_util_varutil.h"
|
---|
| 23 | #include "drv/util/drv_util_varfetch.h"
|
---|
| 24 | #include "drv/util/drv_util_gfxprog.h"
|
---|
| 25 | #include "util/os/util_filesystem.h"
|
---|
| 26 | #include "util/snk/util_snk_extractutil.h"
|
---|
| 27 | #include "util/notif/util_multinotif.h"
|
---|
| 28 | #include "util/cont/util_arrayalgo.h"
|
---|
| 29 |
|
---|
| 30 | ///////////////////////////////////////////////////////////////////////////////
|
---|
| 31 | /*@{
|
---|
| 32 |
|
---|
| 33 | @declare{shaderprog.param}{<d3d9_hlsl_shader>}{$ [chunk]}
|
---|
| 34 |
|
---|
| 35 | Parameters for d3d HLSL @ident{shaderprog}{d3d9.hlsl_vertshader}
|
---|
| 36 | and @ident{shaderprog}{d3d9.hlsl_pixshader}.
|
---|
| 37 | This is a pseudo chunk name.
|
---|
| 38 |
|
---|
| 39 | @}*/
|
---|
| 40 | ///////////////////////////////////////////////////////////////////////////////
|
---|
| 41 |
|
---|
| 42 | #define S3D_DRV_D3D9_RESOLVEVAR(Var, VarInfo, VarName)\
|
---|
| 43 | s3d_CDrvD3d9ProgHLSLUtil::ResolveVar(\
|
---|
| 44 | ProgCtx, VarInfo, CodeName, ConstTab, Var, VarName, VarSet);
|
---|
| 45 |
|
---|
| 46 | ///////////////////////////////////////////////////////////////////////////////
|
---|
| 47 |
|
---|
| 48 | s3d_CDrvD3d9ProgHLSL::s3d_CDrvD3d9ProgHLSL(
|
---|
| 49 | s3d_CUtilNotifGather *NotifGather, s3d_CUtilStr_cr Info,
|
---|
| 50 | s3d_CDrvD3d9ProgCtx *ProgCtx,
|
---|
| 51 | s3d_CUtilSnkChunk *ParamVert, s3d_CUtilSnkChunk *ParamPix)
|
---|
| 52 | {
|
---|
| 53 | m_ProgCtx = ProgCtx;
|
---|
| 54 | m_Info = Info;
|
---|
| 55 | s3d_CUtilMemPoolFrm MemPoolFrm(ProgCtx->m_MemPool);
|
---|
| 56 |
|
---|
| 57 | const s3d_CDrvD3d9Param *D3dParam = ProgCtx->m_D3dParam;
|
---|
| 58 | if(D3dParam->m_ReportProg)
|
---|
| 59 | m_ReportMsgHandler = ProgCtx->m_MsgHandler;
|
---|
| 60 |
|
---|
| 61 | if(ParamVert)
|
---|
| 62 | {
|
---|
| 63 | s3d_CDrvD3d9ProgHLSLUtil::CreateShader(
|
---|
| 64 | NotifGather, ParamVert, ProgCtx,
|
---|
| 65 | true, this, m_VertTrackBlk);
|
---|
| 66 | }
|
---|
| 67 |
|
---|
| 68 | if(ParamPix)
|
---|
| 69 | {
|
---|
| 70 | s3d_CDrvD3d9ProgHLSLUtil::CreateShader(
|
---|
| 71 | NotifGather, ParamPix, ProgCtx, false, this, m_PixTrackBlk);
|
---|
| 72 | }
|
---|
| 73 | }
|
---|
| 74 |
|
---|
| 75 | void s3d_CDrvD3d9ProgHLSL::TrackParams(
|
---|
| 76 | s3d_CDrvGfxParam_cr GfxParam,
|
---|
| 77 | const s3d_CDrvD3d9ParamBlk &ParamBlk,
|
---|
| 78 | const s3d_CDrvD3d9ParamBlkState &ParamBlkState)
|
---|
| 79 | {
|
---|
| 80 | TrackParams(GfxParam, ParamBlk, ParamBlkState, m_VertTrackBlk);
|
---|
| 81 | TrackParams(GfxParam, ParamBlk, ParamBlkState, m_PixTrackBlk);
|
---|
| 82 | }
|
---|
| 83 |
|
---|
| 84 | void s3d_CDrvD3d9ProgHLSL::TrackTransfBone(
|
---|
| 85 | s3d_CSysIntps BoneIdxCnt, const s3d_CSysInt32u *BoneIdxData,
|
---|
| 86 | s3d_CSysIntps MatBoneCnt, const D3DXMATRIXA16 *MatBoneArray)
|
---|
| 87 | {
|
---|
| 88 | TrackTransfBone(
|
---|
| 89 | BoneIdxCnt, BoneIdxData, MatBoneCnt, MatBoneArray,
|
---|
| 90 | m_VertTrackBlk);
|
---|
| 91 | TrackTransfBone(
|
---|
| 92 | BoneIdxCnt, BoneIdxData, MatBoneCnt, MatBoneArray,
|
---|
| 93 | m_PixTrackBlk);
|
---|
| 94 | }
|
---|
| 95 |
|
---|
| 96 | void s3d_CDrvD3d9ProgHLSL::CalcVertBufDesc(
|
---|
| 97 | const s3d_CDrvGfxCharge *Charge,
|
---|
| 98 | s3d_CDrvD3d9VertBufDesc &VertBufDesc) const
|
---|
| 99 | {
|
---|
| 100 | s3d_CDrvD3d9ProgUtil::CalcVertBufDesc(
|
---|
| 101 | m_ProgCtx, Charge, m_VertProgDecl.m_ProgUsage,
|
---|
| 102 | m_VertComprFmt, VertBufDesc);
|
---|
| 103 | }
|
---|
| 104 |
|
---|
| 105 | bool s3d_CDrvD3d9ProgHLSL::IsValid()
|
---|
| 106 | {
|
---|
| 107 | if(!m_VertTrackBlk.m_CodeName.IsEmpty() && !m_VertShader)
|
---|
| 108 | return false;
|
---|
| 109 | if(!m_PixTrackBlk.m_CodeName.IsEmpty() && !m_PixShader)
|
---|
| 110 | return false;
|
---|
| 111 | return true;
|
---|
| 112 | }
|
---|
| 113 |
|
---|
| 114 | void s3d_CDrvD3d9ProgHLSL::GetVertProgCodeInfoName(
|
---|
| 115 | s3d_CUtilStr &CodeInfo, s3d_CUtilStr &CodeName) const
|
---|
| 116 | {
|
---|
| 117 | CodeInfo = m_VertTrackBlk.m_CodeInfo;
|
---|
| 118 | CodeName = m_VertTrackBlk.m_CodeName;
|
---|
| 119 | }
|
---|
| 120 |
|
---|
| 121 | void s3d_CDrvD3d9ProgHLSL::GetPixProgCodeInfoName(
|
---|
| 122 | s3d_CUtilStr &CodeInfo, s3d_CUtilStr &CodeName) const
|
---|
| 123 | {
|
---|
| 124 | CodeInfo = m_PixTrackBlk.m_CodeInfo;
|
---|
| 125 | CodeName = m_PixTrackBlk.m_CodeName;
|
---|
| 126 | }
|
---|
| 127 |
|
---|
| 128 | ///////////////////////////////////////////////////////////////////////////////
|
---|
| 129 |
|
---|
| 130 | void s3d_CDrvD3d9ProgHLSL::TrackMatTrans(
|
---|
| 131 | const D3DXHANDLE &Var, int Trans,
|
---|
| 132 | const D3DXMATRIXA16 *Mat, s3d_CSysIntps Cnt,
|
---|
| 133 | const LPD3DXCONSTANTTABLE ConstTab, LPDIRECT3DDEVICE9 D3dDev)
|
---|
| 134 | {
|
---|
| 135 | switch(Trans)
|
---|
| 136 | {
|
---|
| 137 | case s3d_CDrvUtilGfxProg::TrackTrans_Identity:
|
---|
| 138 | {
|
---|
| 139 | S3D_DRV_D3D9_CHECK(
|
---|
| 140 | m_ProgCtx->m_Env, ConstTab->SetMatrixTransposeArray(
|
---|
| 141 | D3dDev, Var, Mat, UINT(Cnt)));
|
---|
| 142 | break;
|
---|
| 143 | }
|
---|
| 144 | case s3d_CDrvUtilGfxProg::TrackTrans_Inv:
|
---|
| 145 | {
|
---|
| 146 | if(Cnt > 1)
|
---|
| 147 | {
|
---|
| 148 | D3DXMATRIXA16 *InvMat
|
---|
| 149 | = reinterpret_cast<D3DXMATRIXA16 *>
|
---|
| 150 | (alloca(Cnt * S3D_SYS_SIZEOFS(D3DXMATRIXA16)));
|
---|
| 151 | s3d_CSysIntps i;
|
---|
| 152 | for(i = 0; i < Cnt; i++)
|
---|
| 153 | D3DXMatrixInverse(&InvMat[i], 0, Mat);
|
---|
| 154 | S3D_DRV_D3D9_CHECK(
|
---|
| 155 | m_ProgCtx->m_Env, ConstTab->SetMatrixTransposeArray(
|
---|
| 156 | D3dDev, Var, InvMat, UINT(Cnt)));
|
---|
| 157 | }
|
---|
| 158 | else
|
---|
| 159 | {
|
---|
| 160 | D3DXMATRIXA16 InvMat;
|
---|
| 161 | D3DXMatrixInverse(&InvMat, 0, Mat);
|
---|
| 162 | S3D_DRV_D3D9_CHECK(
|
---|
| 163 | m_ProgCtx->m_Env,
|
---|
| 164 | ConstTab->SetMatrixTranspose(D3dDev, Var, &InvMat));
|
---|
| 165 | }
|
---|
| 166 | break;
|
---|
| 167 | }
|
---|
| 168 | case s3d_CDrvUtilGfxProg::TrackTrans_Transp:
|
---|
| 169 | {
|
---|
| 170 | S3D_DRV_D3D9_CHECK(
|
---|
| 171 | m_ProgCtx->m_Env, ConstTab->SetMatrixArray(
|
---|
| 172 | D3dDev, Var, Mat, UINT(Cnt)));
|
---|
| 173 | break;
|
---|
| 174 | }
|
---|
| 175 | case s3d_CDrvUtilGfxProg::TrackTrans_InvTransp:
|
---|
| 176 | {
|
---|
| 177 | if(Cnt > 1)
|
---|
| 178 | {
|
---|
| 179 | D3DXMATRIXA16 *InvMat
|
---|
| 180 | = reinterpret_cast<D3DXMATRIXA16 *>
|
---|
| 181 | (alloca(Cnt * S3D_SYS_SIZEOFS(D3DXMATRIXA16)));
|
---|
| 182 | s3d_CSysIntps i;
|
---|
| 183 | for(i = 0; i < Cnt; i++)
|
---|
| 184 | D3DXMatrixInverse(&InvMat[i], 0, Mat);
|
---|
| 185 | S3D_DRV_D3D9_CHECK(
|
---|
| 186 | m_ProgCtx->m_Env, ConstTab->SetMatrixArray(
|
---|
| 187 | D3dDev, Var, InvMat, UINT(Cnt)));
|
---|
| 188 | }
|
---|
| 189 | else
|
---|
| 190 | {
|
---|
| 191 | D3DXMATRIXA16 InvMat;
|
---|
| 192 | D3DXMatrixInverse(&InvMat, 0, Mat);
|
---|
| 193 | S3D_DRV_D3D9_CHECK(
|
---|
| 194 | m_ProgCtx->m_Env, ConstTab->SetMatrix(
|
---|
| 195 | D3dDev, Var, &InvMat));
|
---|
| 196 | }
|
---|
| 197 | break;
|
---|
| 198 | }
|
---|
| 199 | default:
|
---|
| 200 | S3D_SYS_ASSERT(0);
|
---|
| 201 | break;
|
---|
| 202 | }
|
---|
| 203 | }
|
---|
| 204 |
|
---|
| 205 | void s3d_CDrvD3d9ProgHLSL::TrackParams(
|
---|
| 206 | s3d_CDrvGfxParam_cr GfxParam,
|
---|
| 207 | const s3d_CDrvD3d9ParamBlk &ParamBlk,
|
---|
| 208 | const s3d_CDrvD3d9ParamBlkState &ParamBlkState,
|
---|
| 209 | s3d_CDrvD3d9ProgHLSLTrackBlk &TrackBlk)
|
---|
| 210 | {
|
---|
| 211 | LPDIRECT3DDEVICE9 D3dDev = m_ProgCtx->m_D3dDev;
|
---|
| 212 | if(!D3dDev)
|
---|
| 213 | return;
|
---|
| 214 | LPD3DXCONSTANTTABLE ConstTab = TrackBlk.m_ConstTab;
|
---|
| 215 | if(!ConstTab)
|
---|
| 216 | return;
|
---|
| 217 |
|
---|
| 218 | S3D_DRV_D3D9_CHECK(
|
---|
| 219 | m_ProgCtx->m_Env, ConstTab->SetDefaults(D3dDev));
|
---|
| 220 |
|
---|
| 221 | const s3d_CSysChar *Info = TrackBlk.m_CodeInfo.GetChars();
|
---|
| 222 |
|
---|
| 223 | const s3d_CDrvD3d9ProgHLSLTrackMatArray *TrackMatArray
|
---|
| 224 | = &TrackBlk.m_MatTrackArray;
|
---|
| 225 | s3d_CSysIntps nTrackMat = TrackMatArray->GetCnt();
|
---|
| 226 | s3d_CSysIntps iTrackMat;
|
---|
| 227 | for(iTrackMat = 0; iTrackMat < nTrackMat; iTrackMat++)
|
---|
| 228 | {
|
---|
| 229 | const s3d_CDrvD3d9ProgHLSLTrackMat *TrackMat
|
---|
| 230 | = &TrackMatArray->RefAtRaw(iTrackMat);
|
---|
| 231 | D3DXHANDLE Var = TrackMat->m_Var;
|
---|
| 232 | if(!Var)
|
---|
| 233 | continue;
|
---|
| 234 |
|
---|
| 235 | int Trans = TrackMat->m_Trans;
|
---|
| 236 | switch(TrackMat->m_Chan)
|
---|
| 237 | {
|
---|
| 238 | case s3d_CDrvUtilGfxProg::TrackChan_View:
|
---|
| 239 | {
|
---|
| 240 | if(ParamBlkState.m_DirtyMask
|
---|
| 241 | & s3d_CDrvD3d9ParamBlkState::Dirty_MatView)
|
---|
| 242 | {
|
---|
| 243 | TrackMatTrans(
|
---|
| 244 | Var, Trans, &ParamBlk.m_MatView,
|
---|
| 245 | 1, ConstTab, D3dDev);
|
---|
| 246 | }
|
---|
| 247 | break;
|
---|
| 248 | }
|
---|
| 249 | case s3d_CDrvUtilGfxProg::TrackChan_Proj:
|
---|
| 250 | {
|
---|
| 251 | if(ParamBlkState.m_DirtyMask
|
---|
| 252 | & s3d_CDrvD3d9ParamBlkState::Dirty_MatProj)
|
---|
| 253 | {
|
---|
| 254 | TrackMatTrans(
|
---|
| 255 | Var, Trans, &ParamBlk.m_MatProj, 1,
|
---|
| 256 | ConstTab, D3dDev);
|
---|
| 257 | }
|
---|
| 258 | break;
|
---|
| 259 | }
|
---|
| 260 | case s3d_CDrvUtilGfxProg::TrackChan_ProjView:
|
---|
| 261 | {
|
---|
| 262 | if((ParamBlkState.m_DirtyMask
|
---|
| 263 | & s3d_CDrvD3d9ParamBlkState::Dirty_MatView)
|
---|
| 264 | || (ParamBlkState.m_DirtyMask
|
---|
| 265 | & s3d_CDrvD3d9ParamBlkState::Dirty_MatProj))
|
---|
| 266 | {
|
---|
| 267 | D3DXMATRIXA16 ProjView;
|
---|
| 268 | D3DXMatrixMultiply(
|
---|
| 269 | &ProjView, &ParamBlk.m_MatProj,
|
---|
| 270 | &ParamBlk.m_MatView);
|
---|
| 271 | TrackMatTrans(
|
---|
| 272 | Var, Trans, &ProjView, 1, ConstTab, D3dDev);
|
---|
| 273 | }
|
---|
| 274 | break;
|
---|
| 275 | }
|
---|
| 276 | case s3d_CDrvUtilGfxProg::TrackChan_Attr:
|
---|
| 277 | {
|
---|
| 278 | if(ParamBlkState.m_DirtyMask
|
---|
| 279 | & s3d_CDrvD3d9ParamBlkState::Dirty_MatGen)
|
---|
| 280 | {
|
---|
| 281 | int Slot = TrackMat->m_Slot;
|
---|
| 282 | const D3DXMATRIXA16 *Mat
|
---|
| 283 | = &ParamBlk.m_MatGenArray[Slot];
|
---|
| 284 | TrackMatTrans(
|
---|
| 285 | Var, Trans, Mat, 1, ConstTab, D3dDev);
|
---|
| 286 | }
|
---|
| 287 | break;
|
---|
| 288 | }
|
---|
| 289 | default:
|
---|
| 290 | break;
|
---|
| 291 | }
|
---|
| 292 | }
|
---|
| 293 |
|
---|
| 294 | if(ParamBlk.m_UseConstColorAlpha)
|
---|
| 295 | TrackNoLighting(ParamBlk, ParamBlkState, TrackBlk);
|
---|
| 296 | else
|
---|
| 297 | TrackLighting(ParamBlk, ParamBlkState, TrackBlk);
|
---|
| 298 |
|
---|
| 299 | D3DXHANDLE Var = TrackBlk.m_FogVar;
|
---|
| 300 | if(Var && (ParamBlkState.m_DirtyMask
|
---|
| 301 | & s3d_CDrvD3d9ParamBlkState::Dirty_Fog))
|
---|
| 302 | {
|
---|
| 303 | S3D_DRV_D3D9_CHECK(
|
---|
| 304 | m_ProgCtx->m_Env, ConstTab->SetVector(
|
---|
| 305 | D3dDev, Var, &ParamBlk.m_FogColDensity));
|
---|
| 306 | }
|
---|
| 307 |
|
---|
| 308 | const s3d_CDrvD3d9TexObjBasePtr *SampTexArray = ParamBlk.m_SampTexArray;
|
---|
| 309 | const s3d_CDrvD3d9ProgHLSLVarArray *TexSizeArray
|
---|
| 310 | = &TrackBlk.m_TexSizeArray;
|
---|
| 311 | s3d_CSysIntps nTex = TexSizeArray->GetCnt();
|
---|
| 312 | s3d_CSysIntps iTex;
|
---|
| 313 | for(iTex = 0; iTex < nTex; iTex++)
|
---|
| 314 | {
|
---|
| 315 | D3DXHANDLE Var = TexSizeArray->GetAtRaw(iTex);
|
---|
| 316 | if(Var)
|
---|
| 317 | {
|
---|
| 318 | D3DXVECTOR4 Val(0, 0, 0, 0);
|
---|
| 319 | s3d_CDrvD3d9TexObjBase *Tex = 0;
|
---|
| 320 | if(iTex < m_ProgCtx->m_MaxSampCnt)
|
---|
| 321 | Tex = SampTexArray[iTex];
|
---|
| 322 | if(Tex)
|
---|
| 323 | {
|
---|
| 324 | Val.x = s3d_SysFloatOfInt<float>(Tex->m_Width);
|
---|
| 325 | Val.y = s3d_SysFloatOfInt<float>(Tex->m_Height);
|
---|
| 326 | Val.z = s3d_SysFloatOfInt<float>(Tex->m_Depth);
|
---|
| 327 | Val.w = 0;
|
---|
| 328 | }
|
---|
| 329 | S3D_DRV_D3D9_CHECK(
|
---|
| 330 | m_ProgCtx->m_Env, ConstTab->SetVector(D3dDev, Var, &Val));
|
---|
| 331 | }
|
---|
| 332 | }
|
---|
| 333 |
|
---|
| 334 | const s3d_CDrvD3d9ProgHLSLVarArray *TexRcpSizeArray
|
---|
| 335 | = &TrackBlk.m_TexRcpSizeArray;
|
---|
| 336 | nTex = TexRcpSizeArray->GetCnt();
|
---|
| 337 | for(iTex = 0; iTex < nTex; iTex++)
|
---|
| 338 | {
|
---|
| 339 | D3DXHANDLE Var = TexRcpSizeArray->GetAtRaw(iTex);
|
---|
| 340 | if(Var)
|
---|
| 341 | {
|
---|
| 342 | D3DXVECTOR4 Val(0, 0, 0, 0);
|
---|
| 343 | s3d_CDrvD3d9TexObjBase *Tex = 0;
|
---|
| 344 | if(iTex < m_ProgCtx->m_MaxSampCnt)
|
---|
| 345 | Tex = SampTexArray[iTex];
|
---|
| 346 | if(Tex)
|
---|
| 347 | {
|
---|
| 348 | Val.x = 1 / s3d_SysFloatOfInt<float>(Tex->m_Width);
|
---|
| 349 | Val.y = 1 / s3d_SysFloatOfInt<float>(Tex->m_Height);
|
---|
| 350 | Val.z = 1 / s3d_SysFloatOfInt<float>(Tex->m_Depth);
|
---|
| 351 | Val.w = 0;
|
---|
| 352 | }
|
---|
| 353 | S3D_DRV_D3D9_CHECK(
|
---|
| 354 | m_ProgCtx->m_Env, ConstTab->SetVector(D3dDev, Var, &Val));
|
---|
| 355 | }
|
---|
| 356 | }
|
---|
| 357 |
|
---|
| 358 | s3d_CDrvUtilVarFetch VarFetch(
|
---|
| 359 | m_ProgCtx->m_MsgHandler, GfxParam.m_Blk);
|
---|
| 360 |
|
---|
| 361 | s3d_CDrvD3d9ProgHLSLParamEntry *ParamArray
|
---|
| 362 | = TrackBlk.m_ParamArray.GetPtrRaw();
|
---|
| 363 | s3d_CSysIntps nParam = TrackBlk.m_ParamArray.GetCnt();
|
---|
| 364 | s3d_CSysIntps iParam;
|
---|
| 365 | for(iParam = 0; iParam < nParam; iParam++)
|
---|
| 366 | {
|
---|
| 367 | s3d_CDrvD3d9ProgHLSLParamEntry *Param = &ParamArray[iParam];
|
---|
| 368 | s3d_CDrvVarSlot *VarSlot
|
---|
| 369 | = VarFetch.FetchNextSlot(
|
---|
| 370 | Param->m_Val.m_Info.GetChars(), Param->m_Key,
|
---|
| 371 | Param->m_Val.m_HadError,
|
---|
| 372 | Param->m_Val.m_HadError);
|
---|
| 373 | s3d_CUtilRecogBase *VarRecog
|
---|
| 374 | = s3d_DrvVarFetchWary(m_ProgCtx->m_MsgHandler, Info,
|
---|
| 375 | GfxParam.m_Blk, *VarSlot);
|
---|
| 376 |
|
---|
| 377 | if(!VarRecog)
|
---|
| 378 | continue;
|
---|
| 379 |
|
---|
| 380 | const s3d_CDrvD3d9ProgHLSLParam *ParamEntry = &Param->m_Val;
|
---|
| 381 | D3DXHANDLE ParamVar = ParamEntry->m_Var;
|
---|
| 382 | if(!ParamVar)
|
---|
| 383 | continue;
|
---|
| 384 | const s3d_CSysChar *ParamInfo = ParamEntry->m_Info.GetChars();
|
---|
| 385 | switch(ParamEntry->m_Type)
|
---|
| 386 | {
|
---|
| 387 | case s3d_CDrvUtilGfxProg::ParamType_Float4:
|
---|
| 388 | {
|
---|
| 389 | const s3d_CDrvVarVec4f *DrvVar
|
---|
| 390 | = s3d_DrvVarCast<s3d_CDrvVarVec4f>(
|
---|
| 391 | m_ProgCtx->m_MsgHandler,
|
---|
| 392 | ParamInfo, GfxParam.m_Blk,
|
---|
| 393 | *VarSlot, VarRecog);
|
---|
| 394 | if(DrvVar)
|
---|
| 395 | {
|
---|
| 396 | const float *fD3dVal
|
---|
| 397 | = reinterpret_cast<const float*>(&DrvVar->m_Val);
|
---|
| 398 | S3D_DRV_D3D9_CHECK(
|
---|
| 399 | m_ProgCtx->m_Env, ConstTab->SetFloatArray(
|
---|
| 400 | D3dDev, ParamVar, fD3dVal, 4));
|
---|
| 401 | }
|
---|
| 402 | break;
|
---|
| 403 | }
|
---|
| 404 |
|
---|
| 405 | case s3d_CDrvUtilGfxProg::ParamType_Float4x4:
|
---|
| 406 | case s3d_CDrvUtilGfxProg::ParamType_Float4x4_Transp:
|
---|
| 407 | case s3d_CDrvUtilGfxProg::ParamType_Float4x4_Inv:
|
---|
| 408 | case s3d_CDrvUtilGfxProg::ParamType_Float4x4_InvTransp:
|
---|
| 409 | {
|
---|
| 410 | const s3d_CDrvVarMat4x4f *DrvVar;
|
---|
| 411 | DrvVar = s3d_DrvVarCast<s3d_CDrvVarMat4x4f>(
|
---|
| 412 | m_ProgCtx->m_MsgHandler, ParamInfo, GfxParam.m_Blk,
|
---|
| 413 | *VarSlot, VarRecog);
|
---|
| 414 | if(DrvVar)
|
---|
| 415 | {
|
---|
| 416 | D3DXMATRIXA16 Mat;
|
---|
| 417 | const s3d_CUtilMat4x4f *EngMat = &DrvVar->m_Val;
|
---|
| 418 | Mat._11 = EngMat->m_xx;
|
---|
| 419 | Mat._21 = EngMat->m_yx;
|
---|
| 420 | Mat._31 = EngMat->m_zx;
|
---|
| 421 | Mat._41 = EngMat->m_wx;
|
---|
| 422 | Mat._12 = EngMat->m_xy;
|
---|
| 423 | Mat._22 = EngMat->m_yy;
|
---|
| 424 | Mat._32 = EngMat->m_zy;
|
---|
| 425 | Mat._42 = EngMat->m_wy;
|
---|
| 426 | Mat._13 = EngMat->m_xz;
|
---|
| 427 | Mat._23 = EngMat->m_yz;
|
---|
| 428 | Mat._33 = EngMat->m_zz;
|
---|
| 429 | Mat._43 = EngMat->m_wz;
|
---|
| 430 | Mat._14 = EngMat->m_xw;
|
---|
| 431 | Mat._24 = EngMat->m_yw;
|
---|
| 432 | Mat._34 = EngMat->m_zw;
|
---|
| 433 | Mat._44 = EngMat->m_ww;
|
---|
| 434 | int Trans = ParamEntry->m_Type; /*s3d_CDrvUtilGfxProg::TransOfParamType(
|
---|
| 435 | ParamEntry->m_Type);*/
|
---|
| 436 | TrackMatTrans(
|
---|
| 437 | ParamVar, Trans, &Mat, 1, ConstTab, D3dDev);
|
---|
| 438 | }
|
---|
| 439 | break;
|
---|
| 440 | }
|
---|
| 441 | default:
|
---|
| 442 | S3D_SYS_ASSERT(0);
|
---|
| 443 | break;
|
---|
| 444 | }
|
---|
| 445 | }
|
---|
| 446 | }
|
---|
| 447 |
|
---|
| 448 | void s3d_CDrvD3d9ProgHLSL::TrackNoLighting(
|
---|
| 449 | const s3d_CDrvD3d9ParamBlk &ParamBlk,
|
---|
| 450 | const s3d_CDrvD3d9ParamBlkState &ParamBlkState,
|
---|
| 451 | s3d_CDrvD3d9ProgHLSLTrackBlk &TrackBlk)
|
---|
| 452 | {
|
---|
| 453 | LPDIRECT3DDEVICE9 D3dDev = m_ProgCtx->m_D3dDev;
|
---|
| 454 | LPD3DXCONSTANTTABLE ConstTab = TrackBlk.m_ConstTab;
|
---|
| 455 |
|
---|
| 456 | D3DXHANDLE Var = TrackBlk.m_Mtl.m_EmissiveVar;
|
---|
| 457 | if(Var)
|
---|
| 458 | {
|
---|
| 459 | const D3DXVECTOR4 *Vec4 = reinterpret_cast<const D3DXVECTOR4*>(
|
---|
| 460 | &ParamBlk.m_ColorAlphaVal);
|
---|
| 461 | S3D_DRV_D3D9_CHECK(
|
---|
| 462 | m_ProgCtx->m_Env, ConstTab->SetVector(D3dDev, Var, Vec4));
|
---|
| 463 | }
|
---|
| 464 |
|
---|
| 465 | Var = TrackBlk.m_ActiveLightCntVar;
|
---|
| 466 | if(Var)
|
---|
| 467 | {
|
---|
| 468 | S3D_DRV_D3D9_CHECK(
|
---|
| 469 | m_ProgCtx->m_Env, ConstTab->SetInt(
|
---|
| 470 | D3dDev, Var, 0));
|
---|
| 471 | }
|
---|
| 472 |
|
---|
| 473 | s3d_CSysIntps FromLight = 0;
|
---|
| 474 | TrackLightingBlack(ParamBlk, ParamBlkState, TrackBlk, FromLight);
|
---|
| 475 | }
|
---|
| 476 |
|
---|
| 477 | void s3d_CDrvD3d9ProgHLSL::TrackLighting(
|
---|
| 478 | const s3d_CDrvD3d9ParamBlk &ParamBlk,
|
---|
| 479 | const s3d_CDrvD3d9ParamBlkState &ParamBlkState,
|
---|
| 480 | s3d_CDrvD3d9ProgHLSLTrackBlk &TrackBlk)
|
---|
| 481 | {
|
---|
| 482 | LPDIRECT3DDEVICE9 D3dDev = m_ProgCtx->m_D3dDev;
|
---|
| 483 | LPD3DXCONSTANTTABLE ConstTab = TrackBlk.m_ConstTab;
|
---|
| 484 |
|
---|
| 485 | if(ParamBlkState.m_DirtyMask
|
---|
| 486 | & s3d_CDrvD3d9ParamBlkState::Dirty_Mtl)
|
---|
| 487 | {
|
---|
| 488 | D3DXHANDLE Var = TrackBlk.m_Mtl.m_EmissiveVar;
|
---|
| 489 | if(Var)
|
---|
| 490 | {
|
---|
| 491 | const D3DXVECTOR4 *Vec4 = reinterpret_cast<const D3DXVECTOR4*>(
|
---|
| 492 | &ParamBlk.m_Mtl.Emissive);
|
---|
| 493 | S3D_DRV_D3D9_CHECK(
|
---|
| 494 | m_ProgCtx->m_Env, ConstTab->SetVector(D3dDev, Var, Vec4));
|
---|
| 495 | }
|
---|
| 496 | Var = TrackBlk.m_Mtl.m_PowerVar;
|
---|
| 497 | if(Var)
|
---|
| 498 | {
|
---|
| 499 | D3DXVECTOR4 Vec4;
|
---|
| 500 | Vec4.x = ParamBlk.m_Mtl.Power;
|
---|
| 501 | Vec4.y = ParamBlk.m_Mtl.Power;
|
---|
| 502 | Vec4.z = ParamBlk.m_Mtl.Power;
|
---|
| 503 | Vec4.w = ParamBlk.m_Mtl.Power;
|
---|
| 504 | S3D_DRV_D3D9_CHECK(
|
---|
| 505 | m_ProgCtx->m_Env, ConstTab->SetVector(D3dDev, Var, &Vec4));
|
---|
| 506 | }
|
---|
| 507 | }
|
---|
| 508 |
|
---|
| 509 | if(ParamBlkState.m_DirtyMask
|
---|
| 510 | & s3d_CDrvD3d9ParamBlkState::Dirty_Light)
|
---|
| 511 | {
|
---|
| 512 | const s3d_CDrvD3d9ProgHLSLLightArray *LightTrackArray
|
---|
| 513 | = &TrackBlk.m_LightTrackArray;
|
---|
| 514 | s3d_CSysIntps MaxProgLightCnt = LightTrackArray->GetCnt();
|
---|
| 515 |
|
---|
| 516 | s3d_CSysIntps nLightCnt = ParamBlk.m_CurLightCnt;
|
---|
| 517 | const D3DLIGHT9 *Light = ParamBlk.m_LightArray;
|
---|
| 518 |
|
---|
| 519 | if(nLightCnt > MaxProgLightCnt)
|
---|
| 520 | nLightCnt = MaxProgLightCnt;
|
---|
| 521 |
|
---|
| 522 | const s3d_CDrvD3d9ProgHLSLLight *ProgLight
|
---|
| 523 | = LightTrackArray->GetPtrRaw();
|
---|
| 524 | s3d_CSysIntps iLight;
|
---|
| 525 | for(iLight = 0; iLight < nLightCnt; iLight++)
|
---|
| 526 | {
|
---|
| 527 | D3DXHANDLE Var = ProgLight->m_AmbientVar;
|
---|
| 528 | if(Var)
|
---|
| 529 | {
|
---|
| 530 | const D3DXVECTOR4 *Vec4
|
---|
| 531 | = reinterpret_cast<const D3DXVECTOR4 *>(
|
---|
| 532 | &Light->Ambient);
|
---|
| 533 | S3D_DRV_D3D9_CHECK(
|
---|
| 534 | m_ProgCtx->m_Env, ConstTab->SetVector(
|
---|
| 535 | D3dDev, Var, Vec4));
|
---|
| 536 | }
|
---|
| 537 | Var = ProgLight->m_DiffuseVar;
|
---|
| 538 | if(Var)
|
---|
| 539 | {
|
---|
| 540 | const D3DXVECTOR4 *Vec4
|
---|
| 541 | = reinterpret_cast<const D3DXVECTOR4 *>(
|
---|
| 542 | &Light->Diffuse);
|
---|
| 543 | S3D_DRV_D3D9_CHECK(
|
---|
| 544 | m_ProgCtx->m_Env, ConstTab->SetVector(
|
---|
| 545 | D3dDev, Var, Vec4));
|
---|
| 546 | }
|
---|
| 547 | Var = ProgLight->m_SpecularVar;
|
---|
| 548 | if(Var)
|
---|
| 549 | {
|
---|
| 550 | const D3DXVECTOR4 *Vec4
|
---|
| 551 | = reinterpret_cast<const D3DXVECTOR4 *>(
|
---|
| 552 | &Light->Specular);
|
---|
| 553 | S3D_DRV_D3D9_CHECK(
|
---|
| 554 | m_ProgCtx->m_Env, ConstTab->SetVector(
|
---|
| 555 | D3dDev, Var, Vec4));
|
---|
| 556 | }
|
---|
| 557 | Var = ProgLight->m_PosVar;
|
---|
| 558 | if(Var)
|
---|
| 559 | {
|
---|
| 560 | const D3DXVECTOR4 *Vec4
|
---|
| 561 | = reinterpret_cast<const D3DXVECTOR4 *>(
|
---|
| 562 | &Light->Position);
|
---|
| 563 | S3D_DRV_D3D9_CHECK(
|
---|
| 564 | m_ProgCtx->m_Env, ConstTab->SetVector(
|
---|
| 565 | D3dDev, Var, Vec4));
|
---|
| 566 | }
|
---|
| 567 | Var = ProgLight->m_DirVar;
|
---|
| 568 | if(Var)
|
---|
| 569 | {
|
---|
| 570 | const D3DXVECTOR4 *Vec4
|
---|
| 571 | = reinterpret_cast<const D3DXVECTOR4 *>(
|
---|
| 572 | &Light->Direction);
|
---|
| 573 | S3D_DRV_D3D9_CHECK(
|
---|
| 574 | m_ProgCtx->m_Env, ConstTab->SetVector(
|
---|
| 575 | D3dDev, Var, Vec4));
|
---|
| 576 | }
|
---|
| 577 | Var = ProgLight->m_AttenVar;
|
---|
| 578 | if(Var)
|
---|
| 579 | {
|
---|
| 580 | float Atten[4];
|
---|
| 581 | Atten[0] = Light->Attenuation0; //AttenConst
|
---|
| 582 | Atten[1] = Light->Attenuation1; //AttenLinear
|
---|
| 583 | Atten[2] = Light->Attenuation2; //AttenQuadr
|
---|
| 584 | Atten[3] = Light->Range;
|
---|
| 585 | S3D_DRV_D3D9_CHECK(
|
---|
| 586 | m_ProgCtx->m_Env, ConstTab->SetFloatArray(
|
---|
| 587 | D3dDev, Var, Atten, 4));
|
---|
| 588 | }
|
---|
| 589 | Light++;
|
---|
| 590 | ProgLight++;
|
---|
| 591 | }
|
---|
| 592 |
|
---|
| 593 | D3DXHANDLE Var = TrackBlk.m_ActiveLightCntVar;
|
---|
| 594 | if(Var)
|
---|
| 595 | {
|
---|
| 596 | S3D_DRV_D3D9_CHECK(
|
---|
| 597 | m_ProgCtx->m_Env, ConstTab->SetInt(
|
---|
| 598 | D3dDev, Var, INT(nLightCnt)));
|
---|
| 599 | }
|
---|
| 600 |
|
---|
| 601 | if(nLightCnt < MaxProgLightCnt)
|
---|
| 602 | {
|
---|
| 603 | TrackLightingBlack(
|
---|
| 604 | ParamBlk, ParamBlkState, TrackBlk, nLightCnt);
|
---|
| 605 | }
|
---|
| 606 | }
|
---|
| 607 | }
|
---|
| 608 |
|
---|
| 609 | void s3d_CDrvD3d9ProgHLSL::TrackLightingBlack(
|
---|
| 610 | const s3d_CDrvD3d9ParamBlk &ParamBlk,
|
---|
| 611 | const s3d_CDrvD3d9ParamBlkState &ParamBlkState,
|
---|
| 612 | s3d_CDrvD3d9ProgHLSLTrackBlk &TrackBlk,
|
---|
| 613 | s3d_CSysIntps FromLight)
|
---|
| 614 | {
|
---|
| 615 | LPDIRECT3DDEVICE9 D3dDev = m_ProgCtx->m_D3dDev;
|
---|
| 616 | LPD3DXCONSTANTTABLE ConstTab = TrackBlk.m_ConstTab;
|
---|
| 617 |
|
---|
| 618 | const s3d_CDrvD3d9ProgHLSLLightArray *LightArray
|
---|
| 619 | = &TrackBlk.m_LightTrackArray;
|
---|
| 620 | s3d_CSysIntps nLightCnt = LightArray->GetCnt();
|
---|
| 621 | s3d_CSysIntps iLight;
|
---|
| 622 | for(iLight = FromLight; iLight < nLightCnt; iLight++)
|
---|
| 623 | {
|
---|
| 624 | const s3d_CDrvD3d9ProgHLSLLight *ProgLight
|
---|
| 625 | = &LightArray->RefAtRaw(iLight);
|
---|
| 626 | const D3DXVECTOR4 Vec4(0, 0, 0, 0);
|
---|
| 627 | D3DXHANDLE Var = ProgLight->m_AmbientVar;
|
---|
| 628 | if(Var)
|
---|
| 629 | {
|
---|
| 630 | S3D_DRV_D3D9_CHECK(
|
---|
| 631 | m_ProgCtx->m_Env, ConstTab->SetVector(
|
---|
| 632 | D3dDev, Var, &Vec4));
|
---|
| 633 | }
|
---|
| 634 | Var = ProgLight->m_DiffuseVar;
|
---|
| 635 | if(Var)
|
---|
| 636 | {
|
---|
| 637 | S3D_DRV_D3D9_CHECK(
|
---|
| 638 | m_ProgCtx->m_Env, ConstTab->SetVector(
|
---|
| 639 | D3dDev, Var, &Vec4));
|
---|
| 640 | }
|
---|
| 641 | Var = ProgLight->m_SpecularVar;
|
---|
| 642 | if(Var)
|
---|
| 643 | {
|
---|
| 644 | S3D_DRV_D3D9_CHECK(
|
---|
| 645 | m_ProgCtx->m_Env, ConstTab->SetVector(
|
---|
| 646 | D3dDev, Var, &Vec4));
|
---|
| 647 | }
|
---|
| 648 | Var = ProgLight->m_PosVar;
|
---|
| 649 | if(Var)
|
---|
| 650 | {
|
---|
| 651 | S3D_DRV_D3D9_CHECK(
|
---|
| 652 | m_ProgCtx->m_Env, ConstTab->SetVector(
|
---|
| 653 | D3dDev, Var, &Vec4));
|
---|
| 654 | }
|
---|
| 655 | Var = ProgLight->m_DirVar;
|
---|
| 656 | if(Var)
|
---|
| 657 | {
|
---|
| 658 | S3D_DRV_D3D9_CHECK(
|
---|
| 659 | m_ProgCtx->m_Env, ConstTab->SetVector(
|
---|
| 660 | D3dDev, Var, &Vec4));
|
---|
| 661 | }
|
---|
| 662 | Var = ProgLight->m_AttenVar;
|
---|
| 663 | if(Var)
|
---|
| 664 | {
|
---|
| 665 | S3D_DRV_D3D9_CHECK(
|
---|
| 666 | m_ProgCtx->m_Env, ConstTab->SetVector(
|
---|
| 667 | D3dDev, Var, &Vec4));
|
---|
| 668 | }
|
---|
| 669 | }
|
---|
| 670 | }
|
---|
| 671 |
|
---|
| 672 | void s3d_CDrvD3d9ProgHLSL::TrackTransfBone(
|
---|
| 673 | s3d_CSysIntps BoneIdxCnt, const s3d_CSysInt32u *BoneIdxData,
|
---|
| 674 | s3d_CSysIntps MatBoneCnt, const D3DXMATRIXA16 *MatBoneArray,
|
---|
| 675 | s3d_CDrvD3d9ProgHLSLTrackBlk &TrackBlk)
|
---|
| 676 | {
|
---|
| 677 | if(!BoneIdxData)
|
---|
| 678 | return;
|
---|
| 679 | if(!MatBoneArray)
|
---|
| 680 | return;
|
---|
| 681 |
|
---|
| 682 | LPDIRECT3DDEVICE9 D3dDev = m_ProgCtx->m_D3dDev;
|
---|
| 683 | LPD3DXCONSTANTTABLE ConstTab = TrackBlk.m_ConstTab;
|
---|
| 684 | if(!ConstTab)
|
---|
| 685 | return;
|
---|
| 686 |
|
---|
| 687 | const s3d_CSysChar *Info = TrackBlk.m_CodeInfo.GetChars();
|
---|
| 688 |
|
---|
| 689 | const s3d_CDrvD3d9ProgHLSLTrackMatArray *TrackMatArray
|
---|
| 690 | = &TrackBlk.m_BoneTrackArray;
|
---|
| 691 |
|
---|
| 692 | LPD3DXMATRIXA16 BoneMatData
|
---|
| 693 | = reinterpret_cast<LPD3DXMATRIXA16>(
|
---|
| 694 | alloca(S3D_SYS_SIZEOFS(D3DXMATRIXA16) * BoneIdxCnt));
|
---|
| 695 | s3d_CSysIntps iBoneIdx;
|
---|
| 696 | for(iBoneIdx = 0; iBoneIdx < BoneIdxCnt; iBoneIdx++)
|
---|
| 697 | {
|
---|
| 698 | s3d_CSysIntps MatBoneIdx = BoneIdxData[iBoneIdx];
|
---|
| 699 | if(MatBoneIdx >= MatBoneCnt)
|
---|
| 700 | D3DXMatrixIdentity(&BoneMatData[iBoneIdx]);
|
---|
| 701 | else
|
---|
| 702 | BoneMatData[iBoneIdx] = MatBoneArray[MatBoneIdx];
|
---|
| 703 | }
|
---|
| 704 |
|
---|
| 705 | const s3d_CDrvD3d9ProgHLSLTrackMat *TrackMat = TrackMatArray->GetPtrRaw();
|
---|
| 706 | s3d_CSysIntps nTrackMat = TrackMatArray->GetCnt();
|
---|
| 707 | s3d_CSysIntps iTrackMat;
|
---|
| 708 | for(iTrackMat = 0; iTrackMat < nTrackMat; iTrackMat++)
|
---|
| 709 | {
|
---|
| 710 | D3DXHANDLE Var = TrackMat->m_Var;
|
---|
| 711 | if(!Var)
|
---|
| 712 | continue;
|
---|
| 713 |
|
---|
| 714 | int Trans = TrackMat->m_Trans;
|
---|
| 715 | switch(TrackMat->m_Chan)
|
---|
| 716 | {
|
---|
| 717 | case s3d_CDrvUtilGfxProg::TrackChan_Bone:
|
---|
| 718 | {
|
---|
| 719 | int TrackCnt = TrackMat->m_Cnt;
|
---|
| 720 | if(BoneIdxCnt < TrackCnt)
|
---|
| 721 | TrackCnt = BoneIdxCnt;
|
---|
| 722 | TrackMatTrans(
|
---|
| 723 | Var, Trans, BoneMatData, TrackCnt, ConstTab, D3dDev);
|
---|
| 724 | break;
|
---|
| 725 | }
|
---|
| 726 | default:
|
---|
| 727 | {
|
---|
| 728 | S3D_SYS_ASSERT(0);
|
---|
| 729 | }
|
---|
| 730 | }
|
---|
| 731 | TrackMat++;
|
---|
| 732 | }
|
---|
| 733 | }
|
---|
| 734 |
|
---|
| 735 | ///////////////////////////////////////////////////////////////////////////////
|
---|
| 736 |
|
---|
| 737 | void s3d_CDrvD3d9ProgHLSLUtil::CreateShader(
|
---|
| 738 | s3d_CUtilNotifGather *NotifGather, s3d_CUtilSnkChunk *Param,
|
---|
| 739 | s3d_CDrvD3d9ProgCtx *ProgCtx, bool VertShader, s3d_CDrvD3d9Prog *Prog,
|
---|
| 740 | s3d_CDrvD3d9ProgHLSLTrackBlk &TrackBlk)
|
---|
| 741 | {
|
---|
| 742 | if(!ProgCtx)
|
---|
| 743 | return;
|
---|
| 744 |
|
---|
| 745 | s3d_CUtilMsgHandler *MsgHandler = ProgCtx->m_MsgHandler;
|
---|
| 746 |
|
---|
| 747 | s3d_CUtilSnkExtract SnkExtract;
|
---|
| 748 | SnkExtract.Assign(MsgHandler, Param);
|
---|
| 749 |
|
---|
| 750 | s3d_CLibStreamPreproStatePtr PreproState
|
---|
| 751 | = S3D_SYS_NEW s3d_CLibStreamPreproState;
|
---|
| 752 | s3d_CDrvD3d9ProgHLSLUtil::ExtractPredefine(
|
---|
| 753 | ProgCtx, PreproState, SnkExtract);
|
---|
| 754 |
|
---|
| 755 | /*@{ @declare{shaderprog.param}{<d3d9_hlsl_shader>.code_variant_array}
|
---|
| 756 | {$ [chunk]...[chunk]}
|
---|
| 757 | Each chunk specifies a D3D HLSL shader source code file for a
|
---|
| 758 | specific shader version.
|
---|
| 759 | If there is more than one @code{code_variant} the one that first
|
---|
| 760 | successfully compiles is taken.
|
---|
| 761 | @}*/
|
---|
| 762 | s3d_CUtilSnkChunkArray CodeArray;
|
---|
| 763 | s3d_CUtilStr CodeArrayInfo;
|
---|
| 764 | SnkExtract.ExtractChunkArray(
|
---|
| 765 | CodeArrayInfo, CodeArray, "code_variant_array", true);
|
---|
| 766 |
|
---|
| 767 | s3d_CUtilStr CodeName, CodeInfo;
|
---|
| 768 | s3d_CSysIntps nCode = CodeArray.GetCnt();
|
---|
| 769 | s3d_CSysIntps iCode;
|
---|
| 770 | for(iCode = 0; iCode < nCode; iCode++)
|
---|
| 771 | {
|
---|
| 772 | s3d_CUtilSnkExtract CodeSnkExtract;
|
---|
| 773 | s3d_CUtilSnkChunk *CodeChunk = CodeArray.GetAt(iCode);
|
---|
| 774 | CodeSnkExtract.Assign(MsgHandler, CodeChunk);
|
---|
| 775 |
|
---|
| 776 | /*@{ @declare{shaderprog.param}
|
---|
| 777 | {<d3d9_hlsl_shader>.code_variant_array.profile}{$ [str]}
|
---|
| 778 | Shader profile which should be used to compile shader program.
|
---|
| 779 | Use empty string for highest profile supported by gfx hardware.
|
---|
| 780 | @}*/
|
---|
| 781 | s3d_CUtilStr ReqVer = CodeSnkExtract.ExtractStr("profile", false);
|
---|
| 782 | /*
|
---|
| 783 | if(!s3d_CDrvD3d9ProgUtil::IsVersAllowed(MaxMajor, MaxMinor, ReqVer))
|
---|
| 784 | continue;
|
---|
| 785 | */
|
---|
| 786 | /*@{ @declare{shaderprog.param}
|
---|
| 787 | {<d3d9_hlsl_shader>.code_variant_array.code}{$ [str]}
|
---|
| 788 | Specifies the D3D HLSL shader source code file.
|
---|
| 789 | @}*/
|
---|
| 790 | CodeSnkExtract.ExtractStr(CodeInfo, CodeName, "code", true);
|
---|
| 791 |
|
---|
| 792 | /*@{ @declare{shaderprog.param}
|
---|
| 793 | {<d3d9_hlsl_shader>.code_variant_array.debug_code_file}
|
---|
| 794 | {$ [str]}
|
---|
| 795 | Specifies the shader source file that is used for debugging.
|
---|
| 796 | @}*/
|
---|
| 797 | s3d_CUtilStr DbgCodeName
|
---|
| 798 | = CodeSnkExtract.ExtractStr("debug_code_file", false);
|
---|
| 799 |
|
---|
| 800 | /*@{ @declare{shaderprog.param}
|
---|
| 801 | {<d3d9_hlsl_shader>.code_variant_array.entry_point}
|
---|
| 802 | {$ [str]}
|
---|
| 803 | Function name which is executed,
|
---|
| 804 | usually something like main_vs_2x0 or main_fs_2x0.
|
---|
| 805 | @}*/
|
---|
| 806 | s3d_CUtilStr EntryPoint
|
---|
| 807 | = CodeSnkExtract.ExtractStr("entry_point", true);
|
---|
| 808 |
|
---|
| 809 | s3d_CUtilStr Profile;
|
---|
| 810 | if(VertShader)
|
---|
| 811 | {
|
---|
| 812 | if(ReqVer.IsEmpty())
|
---|
| 813 | Profile = D3DXGetVertexShaderProfile(ProgCtx->m_D3dDev);
|
---|
| 814 | else
|
---|
| 815 | Profile = s3d_CDrvD3d9ProgUtil::GenProfileString(ReqVer, "vs");
|
---|
| 816 | }
|
---|
| 817 | else
|
---|
| 818 | {
|
---|
| 819 | if(ReqVer.IsEmpty())
|
---|
| 820 | Profile = D3DXGetPixelShaderProfile(ProgCtx->m_D3dDev);
|
---|
| 821 | else
|
---|
| 822 | Profile = s3d_CDrvD3d9ProgUtil::GenProfileString(ReqVer, "ps");
|
---|
| 823 | }
|
---|
| 824 |
|
---|
| 825 | CodeSnkExtract.CheckForUnknown();
|
---|
| 826 |
|
---|
| 827 | s3d_CDrvD3d9Buf CodeBuf;
|
---|
| 828 | if(ProgCtx->m_D3dParam->m_ShaderDebug && !DbgCodeName.IsEmpty())
|
---|
| 829 | {
|
---|
| 830 | s3d_CDrvD3d9ProgHLSLUtil::CompileFromFile(
|
---|
| 831 | NotifGather, ProgCtx,
|
---|
| 832 | CodeInfo, DbgCodeName, EntryPoint, Profile,
|
---|
| 833 | PreproState, CodeBuf, TrackBlk.m_ConstTab);
|
---|
| 834 | }
|
---|
| 835 | else
|
---|
| 836 | {
|
---|
| 837 | s3d_CDrvD3d9ProgHLSLUtil::CompileFromRes(
|
---|
| 838 | NotifGather, ProgCtx,
|
---|
| 839 | CodeInfo, CodeName, EntryPoint, Profile,
|
---|
| 840 | PreproState, CodeBuf, TrackBlk.m_ConstTab);
|
---|
| 841 | }
|
---|
| 842 | if(!CodeBuf)
|
---|
| 843 | continue;
|
---|
| 844 |
|
---|
| 845 | const DWORD *Function
|
---|
| 846 | = reinterpret_cast<const DWORD *>(
|
---|
| 847 | CodeBuf->GetBufferPointer());
|
---|
| 848 | DWORD ShaderVers = D3DXGetShaderVersion(Function);
|
---|
| 849 |
|
---|
| 850 | HRESULT Result = D3DERR_INVALIDCALL;
|
---|
| 851 | LPDIRECT3DDEVICE9 D3dDev = ProgCtx->m_D3dDev;
|
---|
| 852 | if(VertShader)
|
---|
| 853 | {
|
---|
| 854 | if(ShaderVers <= ProgCtx->m_MaxVS)
|
---|
| 855 | {
|
---|
| 856 | S3D_DRV_D3D9_CALLCHECK(
|
---|
| 857 | ProgCtx->m_Env, Result, D3dDev->CreateVertexShader(
|
---|
| 858 | Function, &Prog->m_VertShader.EmptyRef()));
|
---|
| 859 | }
|
---|
| 860 | else
|
---|
| 861 | {
|
---|
| 862 | s3d_CUtilMsg m;
|
---|
| 863 | m.m_Code = "drv/imp/directx/d3d9/drv_d3d9_proghlsl.vsvers";
|
---|
| 864 | m.m_StdTempl = "D3D: "
|
---|
| 865 | "HLSL program '[1]' requires GPU with vertex shader "
|
---|
| 866 | "version '[2]' but GPU has only '[3]'.";
|
---|
| 867 | m.AddInfo(CodeInfo);
|
---|
| 868 | m.AddInfo(CodeName);
|
---|
| 869 | m.AddInfo(s3d_CDrvD3d9ProgUtil::StrOfVers(ShaderVers));
|
---|
| 870 | m.AddInfo(s3d_CDrvD3d9ProgUtil::StrOfVers(ProgCtx->m_MaxVS));
|
---|
| 871 | s3d_UtilMsgReportNote(ProgCtx->m_MsgHandler, m);
|
---|
| 872 | }
|
---|
| 873 | }
|
---|
| 874 | else
|
---|
| 875 | {
|
---|
| 876 | if(ShaderVers <= ProgCtx->m_MaxPS)
|
---|
| 877 | {
|
---|
| 878 | S3D_DRV_D3D9_CALLCHECK(
|
---|
| 879 | ProgCtx->m_Env, Result, D3dDev->CreatePixelShader(
|
---|
| 880 | Function, &Prog->m_PixShader.EmptyRef()));
|
---|
| 881 | }
|
---|
| 882 | else
|
---|
| 883 | {
|
---|
| 884 | s3d_CUtilMsg m;
|
---|
| 885 | m.m_Code = "drv/imp/directx/d3d9/drv_d3d9_proghlsl.psvers";
|
---|
| 886 | m.m_StdTempl = "D3D: "
|
---|
| 887 | "HLSL program '[1]' requires GPU with pixel shader "
|
---|
| 888 | "version '[2]' but GPU has only '[3]'.";
|
---|
| 889 | m.AddInfo(CodeInfo);
|
---|
| 890 | m.AddInfo(CodeName);
|
---|
| 891 | m.AddInfo(s3d_CDrvD3d9ProgUtil::StrOfVers(ShaderVers));
|
---|
| 892 | m.AddInfo(s3d_CDrvD3d9ProgUtil::StrOfVers(ProgCtx->m_MaxPS));
|
---|
| 893 | s3d_UtilMsgReportNote(ProgCtx->m_MsgHandler, m);
|
---|
| 894 | }
|
---|
| 895 | }
|
---|
| 896 |
|
---|
| 897 | if(FAILED(Result))
|
---|
| 898 | {
|
---|
| 899 | TrackBlk.m_ConstTab.Reset();
|
---|
| 900 | continue;
|
---|
| 901 | }
|
---|
| 902 |
|
---|
| 903 | if(VertShader)
|
---|
| 904 | {
|
---|
| 905 | s3d_CDrvD3d9ProgUtil::GetProgDecl(
|
---|
| 906 | ProgCtx, Prog->m_VertProgDecl,
|
---|
| 907 | CodeBuf->GetBufferSize(), Function);
|
---|
| 908 |
|
---|
| 909 | s3d_CDrvD3d9ProgUtil::ExtractComprFmt(
|
---|
| 910 | ProgCtx, CodeInfo, CodeName, Prog, SnkExtract);
|
---|
| 911 | }
|
---|
| 912 |
|
---|
| 913 | s3d_CDrvD3d9ProgHLSLUtil::InitTrackBlk(
|
---|
| 914 | ProgCtx, CodeInfo, CodeName, TrackBlk, SnkExtract);
|
---|
| 915 |
|
---|
| 916 | SnkExtract.CheckForUnknown();
|
---|
| 917 |
|
---|
| 918 | break;
|
---|
| 919 | }
|
---|
| 920 | }
|
---|
| 921 |
|
---|
| 922 | void s3d_CDrvD3d9ProgHLSLUtil::ExtractPredefine(
|
---|
| 923 | const s3d_CDrvD3d9ProgCtx *ProgCtx,
|
---|
| 924 | s3d_CLibStreamPreproState *PreproState,
|
---|
| 925 | s3d_CUtilSnkExtract &SnkExtract)
|
---|
| 926 | {
|
---|
| 927 | /*@{ @declare{shaderprog.param}
|
---|
| 928 | {<d3d9_hlsl_shader>.predefine_array}{$ [chunk]...[chunk]}
|
---|
| 929 | Array of chunks defining macros used at compile time.
|
---|
| 930 | @listing
|
---|
| 931 | {
|
---|
| 932 | @sident{shaderprog}{<d3d9_hlsl_shader>.predefine_array}
|
---|
| 933 | {
|
---|
| 934 | @sident{shaderprog}{<d3d9_hlsl_shader>.predefine_array@$
|
---|
| 935 | .name} "S3D_FEATURE_MF"
|
---|
| 936 | }
|
---|
| 937 | {
|
---|
| 938 | @sident{shaderprog}{<d3d9_hlsl_shader>.predefine_array@$
|
---|
| 939 | .name} "S3D_FEATURE_MF_CNT"
|
---|
| 940 | @sident{shaderprog}{<d3d9_hlsl_shader>.predefine_array@$
|
---|
| 941 | .val} "5"
|
---|
| 942 | }
|
---|
| 943 | }
|
---|
| 944 | @}*/
|
---|
| 945 | s3d_CUtilSnkChunkArray ChunkArray;
|
---|
| 946 | SnkExtract.ExtractChunkArray(ChunkArray, "predefine_array", false);
|
---|
| 947 | int i;
|
---|
| 948 | for(i = 0; i < ChunkArray.GetCntInt(); i++)
|
---|
| 949 | {
|
---|
| 950 | s3d_CUtilSnkExtract SnkExtract;
|
---|
| 951 | s3d_CUtilSnkChunk *Chunk = ChunkArray.GetAt(i);
|
---|
| 952 | SnkExtract.Assign(ProgCtx->m_MsgHandler, Chunk);
|
---|
| 953 |
|
---|
| 954 | /*@{ @declare{shaderprog.param}
|
---|
| 955 | {<d3d9_hlsl_shader>.predefine_array.name}{$ [str]}
|
---|
| 956 | Name of macro.
|
---|
| 957 | @}*/
|
---|
| 958 | s3d_CUtilStr Name, NameInfo;
|
---|
| 959 | SnkExtract.ExtractStr(NameInfo, Name, "name", true);
|
---|
| 960 |
|
---|
| 961 | /*@{ @declare{shaderprog.param}
|
---|
| 962 | {<d3d9_hlsl_shader>.predefine_array.val}{$ [str]}
|
---|
| 963 | Value of macro.
|
---|
| 964 | @}*/
|
---|
| 965 | s3d_CUtilStr Def = SnkExtract.ExtractStr("val", false);
|
---|
| 966 |
|
---|
| 967 | PreproState->DefineSimple(ProgCtx->m_MsgHandler, NameInfo, Name, Def);
|
---|
| 968 | SnkExtract.CheckForUnknown();
|
---|
| 969 | }
|
---|
| 970 | }
|
---|
| 971 |
|
---|
| 972 | void s3d_CDrvD3d9ProgHLSLUtil::ExtractParamArray(
|
---|
| 973 | const s3d_CDrvD3d9ProgCtx *ProgCtx,
|
---|
| 974 | s3d_CUtilStr_cr CodeInfo, s3d_CUtilStr_cr CodeName,
|
---|
| 975 | const LPD3DXCONSTANTTABLE ConstTab,
|
---|
| 976 | s3d_CDrvD3d9ProgHLSLParamArray &ParamArray,
|
---|
| 977 | s3d_CDrvD3d9ProgHLSLVarSet &VarSet,
|
---|
| 978 | s3d_CUtilSnkExtract &SnkExtract)
|
---|
| 979 | {
|
---|
| 980 | ParamArray.Reset();
|
---|
| 981 |
|
---|
| 982 | /*@{ @declare{shaderprog.param}
|
---|
| 983 | {<d3d9_hlsl_shader>.param_array}{$ [chunk]...[chunk]}
|
---|
| 984 | Each entry maps @ident{comp}{<shaderprog.map_prog_array>.dest_progvar}
|
---|
| 985 | to shader code variable.
|
---|
| 986 | See also @ident{comp}{<shaderprog.map_prog_array>}.
|
---|
| 987 | @listing
|
---|
| 988 | {
|
---|
| 989 | @sident{shaderprog}{<d3d9_hlsl_shader>.param_array}
|
---|
| 990 | {
|
---|
| 991 | @sident{shaderprog}{<d3d9_hlsl_shader>.param_array@$
|
---|
| 992 | .src_progvar} "prog_cenrange"
|
---|
| 993 | @sident{shaderprog}{<d3d9_hlsl_shader>.param_array@$
|
---|
| 994 | .dest_codevar} "lightCenRange"
|
---|
| 995 | @sident{shaderprog}{<d3d9_hlsl_shader>.param_array@$
|
---|
| 996 | .type} "float4"
|
---|
| 997 | }
|
---|
| 998 | }
|
---|
| 999 | @}*/
|
---|
| 1000 | s3d_CUtilSnkChunkArray ParamChunkArray;
|
---|
| 1001 | SnkExtract.ExtractChunkArray(ParamChunkArray, "param_array", false);
|
---|
| 1002 | s3d_CSysIntps nParamChunk = ParamChunkArray.GetCnt();
|
---|
| 1003 | s3d_CSysIntps iParamChunk;
|
---|
| 1004 | for(iParamChunk = 0; iParamChunk < nParamChunk; iParamChunk++)
|
---|
| 1005 | {
|
---|
| 1006 | s3d_CUtilSnkExtract SnkExtract;
|
---|
| 1007 | SnkExtract.Assign(ProgCtx->m_MsgHandler, ParamChunkArray[iParamChunk]);
|
---|
| 1008 |
|
---|
| 1009 | s3d_CUtilStr ParamInfo;
|
---|
| 1010 | s3d_CUtilAtomPtr ParamAtom;
|
---|
| 1011 |
|
---|
| 1012 | /*@{ @declare{shaderprog.param}
|
---|
| 1013 | {<d3d9_hlsl_shader>.param_array.src_progvar}{$ [str]}
|
---|
| 1014 | Shader source variable.
|
---|
| 1015 | See @ident{comp}{<shaderprog.map_prog_array>.dest_progvar}.
|
---|
| 1016 | @}*/
|
---|
| 1017 | s3d_CUtilSnkExtractUtil::ExtractAtom(
|
---|
| 1018 | ParamInfo, ParamAtom, ProgCtx->m_AtomMgr,
|
---|
| 1019 | SnkExtract, "src_progvar", true);
|
---|
| 1020 |
|
---|
| 1021 | /*@{ @declare{shaderprog.param}
|
---|
| 1022 | {<d3d9_hlsl_shader>.param_array.dest_codevar}{$ [str]}
|
---|
| 1023 | Shader code destination variable.
|
---|
| 1024 | @}*/
|
---|
| 1025 | s3d_CUtilStr ParamDestVar
|
---|
| 1026 | = SnkExtract.ExtractStr("dest_codevar", true);
|
---|
| 1027 |
|
---|
| 1028 | /*@{ @declare{shaderprog.param}
|
---|
| 1029 | {<d3d9_hlsl_shader>.param_array.type}{$ [str]}
|
---|
| 1030 | Type of shader code variable. Can be one of @code{float4},
|
---|
| 1031 | @code{float4x4[_transp|_inv|_invtransp]}.
|
---|
| 1032 | @}*/
|
---|
| 1033 | s3d_CUtilStr TypeStr;
|
---|
| 1034 | s3d_CUtilStr TypeInfo;
|
---|
| 1035 | SnkExtract.ExtractStr(TypeInfo, TypeStr, "type", true);
|
---|
| 1036 | s3d_CUtilSnkExtractEnum SnkExtractEnum;
|
---|
| 1037 | SnkExtractEnum.Assign(ProgCtx->m_MsgHandler, TypeInfo, TypeStr);
|
---|
| 1038 | int Type = -1;
|
---|
| 1039 | if(SnkExtractEnum.Check("float4"))
|
---|
| 1040 | Type = s3d_CDrvUtilGfxProg::ParamType_Float4;
|
---|
| 1041 | else if(SnkExtractEnum.Check("float4x4"))
|
---|
| 1042 | Type = s3d_CDrvUtilGfxProg::ParamType_Float4x4;
|
---|
| 1043 | else if(SnkExtractEnum.Check("float4x4_transp"))
|
---|
| 1044 | Type = s3d_CDrvUtilGfxProg::ParamType_Float4x4_Transp;
|
---|
| 1045 | else if(SnkExtractEnum.Check("float4x4_inv"))
|
---|
| 1046 | Type = s3d_CDrvUtilGfxProg::ParamType_Float4x4_Inv;
|
---|
| 1047 | else if(SnkExtractEnum.Check("float4x4_invtransp"))
|
---|
| 1048 | Type = s3d_CDrvUtilGfxProg::ParamType_Float4x4_InvTransp;
|
---|
| 1049 | else
|
---|
| 1050 | SnkExtractEnum.ErrorUnknown();
|
---|
| 1051 |
|
---|
| 1052 | SnkExtract.CheckForUnknown();
|
---|
| 1053 |
|
---|
| 1054 | s3d_CDrvD3d9ProgHLSLParam Param;
|
---|
| 1055 | Param.m_Info = ParamInfo;
|
---|
| 1056 | S3D_DRV_D3D9_RESOLVEVAR(Param.m_Var, ParamInfo, ParamDestVar);
|
---|
| 1057 | Param.m_Type = Type;
|
---|
| 1058 | ParamArray.InsertBack(
|
---|
| 1059 | s3d_CDrvD3d9ProgHLSLParamEntry(ParamAtom, Param));
|
---|
| 1060 | }
|
---|
| 1061 |
|
---|
| 1062 | s3d_UtilArraySortDefault(ParamArray);
|
---|
| 1063 |
|
---|
| 1064 | ParamArray.Compactify();
|
---|
| 1065 | }
|
---|
| 1066 |
|
---|
| 1067 | void s3d_CDrvD3d9ProgHLSLUtil::ExtractTexSize(
|
---|
| 1068 | const s3d_CDrvD3d9ProgCtx *ProgCtx,
|
---|
| 1069 | s3d_CUtilStr_cr CodeInfo, s3d_CUtilStr_cr CodeName,
|
---|
| 1070 | const LPD3DXCONSTANTTABLE ConstTab,
|
---|
| 1071 | s3d_CDrvD3d9ProgHLSLVarArray &TexSizeArray,
|
---|
| 1072 | s3d_CDrvD3d9ProgHLSLVarArray &TexRcpSizeArray,
|
---|
| 1073 | s3d_CDrvD3d9ProgHLSLVarSet &VarSet,
|
---|
| 1074 | s3d_CUtilSnkExtract &SnkExtract)
|
---|
| 1075 | {
|
---|
| 1076 | /*@{ @declare{shaderprog.param}
|
---|
| 1077 | {<d3d9_hlsl_shader>.tex_size_codevar_array}{$ [str]...[str]}
|
---|
| 1078 | Array of shader code variables to upload texture dimensions to.
|
---|
| 1079 | @table
|
---|
| 1080 | {
|
---|
| 1081 | { @code{texsize_codevar.x} } { Width }
|
---|
| 1082 | }
|
---|
| 1083 | {
|
---|
| 1084 | { @code{texsize_codevar.y} } { Height }
|
---|
| 1085 | }
|
---|
| 1086 | {
|
---|
| 1087 | { @code{texsize_codevar.z} } { Depth }
|
---|
| 1088 | }
|
---|
| 1089 | {
|
---|
| 1090 | { @code{texsize_codevar.w} } { <undefined> }
|
---|
| 1091 | }
|
---|
| 1092 | For example:
|
---|
| 1093 | @listing
|
---|
| 1094 | {
|
---|
| 1095 | @sident{shaderprog}{<d3d9_hlsl_shader>@$
|
---|
| 1096 | .tex_size_codevar_array} "tex00_size" "" "tex02_size"
|
---|
| 1097 | }
|
---|
| 1098 | Uploads size of texture currently bound to sampler 0 and 2, @it{""}
|
---|
| 1099 | disables upload of texture bound to sampler 1.
|
---|
| 1100 |
|
---|
| 1101 | @}*/
|
---|
| 1102 | s3d_CUtilStrArray TexSizeStrArray;
|
---|
| 1103 | s3d_CUtilStr TexSizeInfo;
|
---|
| 1104 | SnkExtract.ExtractStrArray(
|
---|
| 1105 | TexSizeInfo, TexSizeStrArray, "tex_size_codevar_array", false);
|
---|
| 1106 |
|
---|
| 1107 | /*@{ @declare{shaderprog.param}
|
---|
| 1108 | {<d3d9_hlsl_shader>.tex_rcpsize_codevar_array}{$ [str]...[str]}
|
---|
| 1109 | Array of shader code variables to upload reciprocal texture
|
---|
| 1110 | dimensions to.
|
---|
| 1111 |
|
---|
| 1112 | See also
|
---|
| 1113 | @ident{shaderprog}{<d3d9_hlsl_shader>.tex_size_codevar_array}.
|
---|
| 1114 | @table
|
---|
| 1115 | {
|
---|
| 1116 | { @code{texrcpsize_codevar.x} } { 1 / Width }
|
---|
| 1117 | }
|
---|
| 1118 | {
|
---|
| 1119 | { @code{texrcpsize_codevar.y} } { 1 / Height }
|
---|
| 1120 | }
|
---|
| 1121 | {
|
---|
| 1122 | { @code{texrcpsize_codevar.z} } { 1 / Depth }
|
---|
| 1123 | }
|
---|
| 1124 | {
|
---|
| 1125 | { @code{texrcpsize_codevar.w} } { <undefined> }
|
---|
| 1126 | }
|
---|
| 1127 | @}*/
|
---|
| 1128 | s3d_CUtilStrArray TexRcpStrSizeArray;
|
---|
| 1129 | s3d_CUtilStr TexRcpSizeInfo;
|
---|
| 1130 | SnkExtract.ExtractStrArray(
|
---|
| 1131 | TexRcpSizeInfo, TexRcpStrSizeArray,
|
---|
| 1132 | "tex_rcpsize_codevar_array", false);
|
---|
| 1133 |
|
---|
| 1134 | TexSizeArray.Reset();
|
---|
| 1135 | s3d_CSysIntps nTexSize = TexSizeStrArray.GetCnt();
|
---|
| 1136 | if(nTexSize >= ProgCtx->m_MaxSampCnt)
|
---|
| 1137 | {
|
---|
| 1138 | s3d_CDrvDxError e;
|
---|
| 1139 | e.m_Code =
|
---|
| 1140 | "drv/imp/directx/d3d9/drv_d3d9_proghlsl.invalid_tex_size_cnt.";
|
---|
| 1141 | e.m_StdTempl = "Too many HLSL tex_size_codevar_array entries '[1]'."
|
---|
| 1142 | " Must be less than or equal to [2].";
|
---|
| 1143 | e.AddInfo(TexSizeInfo);
|
---|
| 1144 | e.AddInfo(s3d_CUtilStrUtil::StrOfInt(nTexSize));
|
---|
| 1145 | e.AddInfo(s3d_CUtilStrUtil::StrOfInt(ProgCtx->m_MaxSampCnt));
|
---|
| 1146 | s3d_UtilMsgReportError(ProgCtx->m_MsgHandler, e);
|
---|
| 1147 | }
|
---|
| 1148 | int iTexSize;
|
---|
| 1149 | for(iTexSize = 0; iTexSize < nTexSize; iTexSize++)
|
---|
| 1150 | {
|
---|
| 1151 | s3d_CUtilStr VarName = TexSizeStrArray.GetAt(iTexSize);
|
---|
| 1152 | D3DXHANDLE TexSizeVar = 0;
|
---|
| 1153 | S3D_DRV_D3D9_RESOLVEVAR(TexSizeVar, TexSizeInfo, VarName);
|
---|
| 1154 | TexSizeArray.InsertBack(TexSizeVar);
|
---|
| 1155 | }
|
---|
| 1156 |
|
---|
| 1157 | TexRcpSizeArray.Reset();
|
---|
| 1158 | s3d_CSysIntps nRcpTexSize = TexRcpStrSizeArray.GetCnt();
|
---|
| 1159 | if(nRcpTexSize >= ProgCtx->m_MaxSampCnt)
|
---|
| 1160 | {
|
---|
| 1161 | s3d_CDrvDxError e;
|
---|
| 1162 | e.m_Code = "drv/imp/directx/d3d9/drv_d3d9_proghlsl"
|
---|
| 1163 | ".invalid_tex_rcpsize_cnt.";
|
---|
| 1164 | e.m_StdTempl = "Too many HLSL tex_rcpsize_codevar_array entries '[1]'."
|
---|
| 1165 | " Must be less than or equal to [2].";
|
---|
| 1166 | e.AddInfo(TexSizeInfo);
|
---|
| 1167 | e.AddInfo(s3d_CUtilStrUtil::StrOfInt(nRcpTexSize));
|
---|
| 1168 | e.AddInfo(s3d_CUtilStrUtil::StrOfInt(ProgCtx->m_MaxSampCnt));
|
---|
| 1169 | s3d_UtilMsgReportError(ProgCtx->m_MsgHandler, e);
|
---|
| 1170 | }
|
---|
| 1171 | int iRcpTexSize;
|
---|
| 1172 | for(iRcpTexSize = 0; iRcpTexSize < nRcpTexSize; iRcpTexSize++)
|
---|
| 1173 | {
|
---|
| 1174 | s3d_CUtilStr VarName = TexRcpStrSizeArray.GetAt(iRcpTexSize);
|
---|
| 1175 | D3DXHANDLE TexRcpSizeVar = 0;
|
---|
| 1176 | S3D_DRV_D3D9_RESOLVEVAR(TexRcpSizeVar, TexRcpSizeInfo, VarName);
|
---|
| 1177 | TexRcpSizeArray.InsertBack(TexRcpSizeVar);
|
---|
| 1178 | }
|
---|
| 1179 |
|
---|
| 1180 | TexSizeArray.Compactify();
|
---|
| 1181 | TexRcpSizeArray.Compactify();
|
---|
| 1182 | }
|
---|
| 1183 |
|
---|
| 1184 | void s3d_CDrvD3d9ProgHLSLUtil::ExtractTrackArray(
|
---|
| 1185 | const s3d_CDrvD3d9ProgCtx *ProgCtx,
|
---|
| 1186 | s3d_CUtilStr_cr CodeInfo, s3d_CUtilStr_cr CodeName,
|
---|
| 1187 | const LPD3DXCONSTANTTABLE ConstTab,
|
---|
| 1188 | s3d_CDrvD3d9ProgHLSLTrackMatArray &MatTrackArray,
|
---|
| 1189 | s3d_CDrvD3d9ProgHLSLTrackMatArray &BoneTrackArray,
|
---|
| 1190 | s3d_CDrvD3d9ProgHLSLVarSet &VarSet,
|
---|
| 1191 | s3d_CUtilSnkExtract &SnkExtract)
|
---|
| 1192 | {
|
---|
| 1193 | /*@{ @declare{shaderprog.param}
|
---|
| 1194 | {<d3d9_hlsl_shader>.tracking}{$ [chunk]...[chunk]}
|
---|
| 1195 | Track matrices to shader code variables.
|
---|
| 1196 | @listing
|
---|
| 1197 | {
|
---|
| 1198 | @sident{shaderprog}{<d3d9_hlsl_shader>.tracking}
|
---|
| 1199 | {
|
---|
| 1200 | @sident{shaderprog}{<d3d9_hlsl_shader>.tracking@$
|
---|
| 1201 | .codevar} "matProj"
|
---|
| 1202 | @sident{shaderprog}{<d3d9_hlsl_shader>.tracking@$
|
---|
| 1203 | .slot} 0
|
---|
| 1204 | @sident{shaderprog}{<d3d9_hlsl_shader>.tracking@$
|
---|
| 1205 | .chan} "proj"
|
---|
| 1206 | @sident{shaderprog}{<d3d9_hlsl_shader>.tracking@$
|
---|
| 1207 | .trans} "identity"
|
---|
| 1208 | }
|
---|
| 1209 | }
|
---|
| 1210 | @}*/
|
---|
| 1211 | s3d_CUtilSnkChunkArray TrackArray;
|
---|
| 1212 | s3d_CUtilStr TrackInfo;
|
---|
| 1213 | SnkExtract.ExtractChunkArray(
|
---|
| 1214 | TrackInfo, TrackArray, "tracking", false);
|
---|
| 1215 |
|
---|
| 1216 | MatTrackArray.Reset();
|
---|
| 1217 | BoneTrackArray.Reset();
|
---|
| 1218 |
|
---|
| 1219 | int iTrack;
|
---|
| 1220 | for(iTrack = 0; iTrack < TrackArray.GetCnt(); iTrack++)
|
---|
| 1221 | {
|
---|
| 1222 | s3d_CUtilSnkChunk *TrackChunk = TrackArray.GetAt(iTrack);
|
---|
| 1223 | s3d_CUtilSnkExtractEnum SnkExtractEnum;
|
---|
| 1224 | s3d_CUtilSnkExtract SnkExtract;
|
---|
| 1225 | SnkExtract.Assign(ProgCtx->m_MsgHandler, TrackChunk);
|
---|
| 1226 |
|
---|
| 1227 | s3d_CDrvD3d9ProgHLSLTrackMat Track;
|
---|
| 1228 |
|
---|
| 1229 | /*@{ @declare{shaderprog.param}
|
---|
| 1230 | {<d3d9_hlsl_shader>.tracking.chan}{$ [str]}
|
---|
| 1231 | chan can be one of:
|
---|
| 1232 | @table
|
---|
| 1233 | {
|
---|
| 1234 | { [ identity | proj | view | projview | tex | bone ] }
|
---|
| 1235 | }
|
---|
| 1236 | @}*/
|
---|
| 1237 | s3d_CUtilStr ChanName, ChanInfo;
|
---|
| 1238 | SnkExtract.ExtractStr(ChanInfo, ChanName, "chan", true, "");
|
---|
| 1239 | SnkExtractEnum.Assign(ProgCtx->m_MsgHandler, ChanInfo, ChanName);
|
---|
| 1240 | Track.m_Chan = s3d_CDrvUtilGfxProg::TrackChan_Identity;
|
---|
| 1241 | if(SnkExtractEnum.Check("view"))
|
---|
| 1242 | Track.m_Chan = s3d_CDrvUtilGfxProg::TrackChan_View;
|
---|
| 1243 | else if(SnkExtractEnum.Check("proj"))
|
---|
| 1244 | Track.m_Chan = s3d_CDrvUtilGfxProg::TrackChan_Proj;
|
---|
| 1245 | else if(SnkExtractEnum.Check("projview"))
|
---|
| 1246 | Track.m_Chan = s3d_CDrvUtilGfxProg::TrackChan_ProjView;
|
---|
| 1247 | else if(SnkExtractEnum.Check("identity"))
|
---|
| 1248 | Track.m_Chan = s3d_CDrvUtilGfxProg::TrackChan_Identity;
|
---|
| 1249 | else if(SnkExtractEnum.Check("attr"))
|
---|
| 1250 | Track.m_Chan = s3d_CDrvUtilGfxProg::TrackChan_Attr;
|
---|
| 1251 | else if(SnkExtractEnum.Check("bone"))
|
---|
| 1252 | Track.m_Chan = s3d_CDrvUtilGfxProg::TrackChan_Bone;
|
---|
| 1253 | else
|
---|
| 1254 | SnkExtractEnum.ErrorUnknown();
|
---|
| 1255 |
|
---|
| 1256 | /*@{ @declare{shaderprog.param}
|
---|
| 1257 | {<d3d9_hlsl_shader>.tracking.slot}{$ [int]}
|
---|
| 1258 | Used for selecting texture matrix for the texture that is bound to
|
---|
| 1259 | sampler @it{slot}. Has no effect on matrices other than texture or
|
---|
| 1260 | bone. Default is 0.
|
---|
| 1261 | @}*/
|
---|
| 1262 | s3d_CUtilStr TrackSlotInfo;
|
---|
| 1263 | SnkExtract.ExtractInt(TrackSlotInfo, Track.m_Slot, "slot", false, 0);
|
---|
| 1264 | if(Track.m_Slot < 0 || Track.m_Slot >= ProgCtx->m_MaxAttrCnt)
|
---|
| 1265 | {
|
---|
| 1266 | s3d_CDrvDxError e;
|
---|
| 1267 | e.m_Code = "drv/imp/directx/d3d9/drv_d3d9_proghlsl.invalid_slot.";
|
---|
| 1268 | e.m_StdTempl = "Invalid HLSL tracking slot value '[1]'. "
|
---|
| 1269 | "Must be greater or equal 0 and less than [2].";
|
---|
| 1270 | e.AddInfo(TrackSlotInfo);
|
---|
| 1271 | e.AddInfo(s3d_CUtilStrUtil::StrOfInt(Track.m_Slot));
|
---|
| 1272 | e.AddInfo(s3d_CUtilStrUtil::StrOfInt(ProgCtx->m_MaxAttrCnt));
|
---|
| 1273 | s3d_UtilMsgReportError(ProgCtx->m_MsgHandler, e);
|
---|
| 1274 |
|
---|
| 1275 | Track.m_Slot = 0;
|
---|
| 1276 | }
|
---|
| 1277 |
|
---|
| 1278 | /*@{ @declare{shaderprog.param}
|
---|
| 1279 | {<d3d9_hlsl_shader>.tracking.trans}{$ [str]}
|
---|
| 1280 | trans can be one of:
|
---|
| 1281 | @table
|
---|
| 1282 | {
|
---|
| 1283 | { [ identity | inv | transp | invtransp ] }
|
---|
| 1284 | }
|
---|
| 1285 | @}*/
|
---|
| 1286 | s3d_CUtilStr TransName, TransInfo;
|
---|
| 1287 | SnkExtract.ExtractStr(TransInfo, TransName, "trans", true, "");
|
---|
| 1288 |
|
---|
| 1289 | SnkExtractEnum.Assign(
|
---|
| 1290 | ProgCtx->m_MsgHandler, TransInfo, TransName);
|
---|
| 1291 | if(SnkExtractEnum.Check("identity"))
|
---|
| 1292 | Track.m_Trans = s3d_CDrvUtilGfxProg::TrackTrans_Identity;
|
---|
| 1293 | else if(SnkExtractEnum.Check("inv"))
|
---|
| 1294 | Track.m_Trans = s3d_CDrvUtilGfxProg::TrackTrans_Inv;
|
---|
| 1295 | else if(SnkExtractEnum.Check("transp"))
|
---|
| 1296 | Track.m_Trans = s3d_CDrvUtilGfxProg::TrackTrans_Transp;
|
---|
| 1297 | else if(SnkExtractEnum.Check("invtransp"))
|
---|
| 1298 | Track.m_Trans = s3d_CDrvUtilGfxProg::TrackTrans_InvTransp;
|
---|
| 1299 | else
|
---|
| 1300 | {
|
---|
| 1301 | Track.m_Trans = s3d_CDrvUtilGfxProg::TrackTrans_Identity;
|
---|
| 1302 | SnkExtractEnum.ErrorUnknown();
|
---|
| 1303 | }
|
---|
| 1304 |
|
---|
| 1305 | /*@{ @declare{shaderprog.param}
|
---|
| 1306 | {<d3d9_hlsl_shader>.tracking.codevar}{$ [str]}
|
---|
| 1307 | Shader code variable where matrix is uploaded to.
|
---|
| 1308 | @}*/
|
---|
| 1309 | s3d_CUtilStr VarName, VarInfo;
|
---|
| 1310 | SnkExtract.ExtractStr(VarInfo, VarName, "codevar", true);
|
---|
| 1311 | S3D_DRV_D3D9_RESOLVEVAR(Track.m_Var, VarInfo, VarName);
|
---|
| 1312 | if(Track.m_Var)
|
---|
| 1313 | {
|
---|
| 1314 | D3DXCONSTANT_DESC ConstDesc;
|
---|
| 1315 | s3d_SysMemset(&ConstDesc, 0, S3D_SYS_SIZEOFS(ConstDesc));
|
---|
| 1316 | UINT ConstDescCnt = 1;
|
---|
| 1317 | S3D_DRV_D3D9_CHECK(
|
---|
| 1318 | ProgCtx->m_Env, ConstTab->GetConstantDesc(
|
---|
| 1319 | Track.m_Var, &ConstDesc, &ConstDescCnt));
|
---|
| 1320 | Track.m_Cnt = s3d_SysMax(UINT(1), ConstDesc.Elements);
|
---|
| 1321 |
|
---|
| 1322 | if(Track.m_Chan == s3d_CDrvUtilGfxProg::TrackChan_Bone)
|
---|
| 1323 | BoneTrackArray.InsertBack(Track);
|
---|
| 1324 | else
|
---|
| 1325 | MatTrackArray.InsertBack(Track);
|
---|
| 1326 | }
|
---|
| 1327 |
|
---|
| 1328 | SnkExtract.CheckForUnknown();
|
---|
| 1329 | }
|
---|
| 1330 |
|
---|
| 1331 | MatTrackArray.Compactify();
|
---|
| 1332 | BoneTrackArray.Compactify();
|
---|
| 1333 | }
|
---|
| 1334 |
|
---|
| 1335 |
|
---|
| 1336 | void s3d_CDrvD3d9ProgHLSLUtil::ExtractLightArray(
|
---|
| 1337 | const s3d_CDrvD3d9ProgCtx *ProgCtx,
|
---|
| 1338 | s3d_CUtilStr_cr CodeInfo, s3d_CUtilStr_cr CodeName,
|
---|
| 1339 | const LPD3DXCONSTANTTABLE ConstTab,
|
---|
| 1340 | D3DXHANDLE &ActiveLightCntVar,
|
---|
| 1341 | s3d_CDrvD3d9ProgHLSLLightArray &LightTrackArray,
|
---|
| 1342 | s3d_CDrvD3d9ProgHLSLVarSet &VarSet,
|
---|
| 1343 | s3d_CUtilSnkExtract &SnkExtract)
|
---|
| 1344 | {
|
---|
| 1345 | /*@{ @declare{shaderprog.param}
|
---|
| 1346 | {<d3d9_hlsl_shader>.light_array}{$ [chunk]...[chunk]}
|
---|
| 1347 | Specifies how many lights a shader can handle and the shader code
|
---|
| 1348 | variable names where to upload light values.
|
---|
| 1349 | Typical @ident{shaderprog}{<d3d9_hlsl_shader>.light_array} entry.
|
---|
| 1350 | @listing
|
---|
| 1351 | {
|
---|
| 1352 | @sident{shaderprog}{<d3d9_hlsl_shader>.light_array}
|
---|
| 1353 | {
|
---|
| 1354 | @sident{shaderprog}{<d3d9_hlsl_shader>.light_array@$
|
---|
| 1355 | .cnt} 2
|
---|
| 1356 | @sident{shaderprog}{<d3d9_hlsl_shader>.light_array@$
|
---|
| 1357 | .pos_codevar} "lightArray[$].pos"
|
---|
| 1358 | @sident{shaderprog}{<d3d9_hlsl_shader>.light_array@$
|
---|
| 1359 | .dir_codevar} "lightArray[$].dir"
|
---|
| 1360 | @sident{shaderprog}{<d3d9_hlsl_shader>.light_array@$
|
---|
| 1361 | .ambient_codevar} "lightArray[$].ambient"
|
---|
| 1362 | @sident{shaderprog}{<d3d9_hlsl_shader>.light_array@$
|
---|
| 1363 | .diffuse_codevar} "lightArray[$].diffuse"
|
---|
| 1364 | @sident{shaderprog}{<d3d9_hlsl_shader>.light_array@$
|
---|
| 1365 | .specular_codevar} "lightArray[$].specular"
|
---|
| 1366 | @sident{shaderprog}{<d3d9_hlsl_shader>.light_array@$
|
---|
| 1367 | .atten_codevar} "lightArray[$].atten"
|
---|
| 1368 | }
|
---|
| 1369 | }
|
---|
| 1370 | This chunk e.g. will be 2 (cnt) times replicated. '$' is a placeholder,
|
---|
| 1371 | which is replaced in this case with index 0 and 1 so it can be used
|
---|
| 1372 | in the shader as lightArray[0].pos and lightArray[1].pos.
|
---|
| 1373 | @}*/
|
---|
| 1374 | s3d_CUtilSnkChunkPtr LightChunk;
|
---|
| 1375 | s3d_CUtilStr LightInfo;
|
---|
| 1376 | SnkExtract.ExtractChunk(
|
---|
| 1377 | LightInfo, LightChunk, "light_array", false);
|
---|
| 1378 |
|
---|
| 1379 | /*@{ @declare{shaderprog.param}
|
---|
| 1380 | {<d3d9_hlsl_shader>.light_activecnt_codevar}{$ [str]}
|
---|
| 1381 | In D3D shader version >= 2.0. this var is used for uploading
|
---|
| 1382 | the currently active light count.
|
---|
| 1383 | @}*/
|
---|
| 1384 | s3d_CUtilStr VarName, VarInfo;
|
---|
| 1385 | SnkExtract.ExtractStr(VarInfo, VarName, "light_activecnt_codevar", false);
|
---|
| 1386 | ActiveLightCntVar = 0;
|
---|
| 1387 | if(!VarName.IsEmpty())
|
---|
| 1388 | {
|
---|
| 1389 | S3D_DRV_D3D9_RESOLVEVAR(ActiveLightCntVar, VarInfo, VarName);
|
---|
| 1390 | }
|
---|
| 1391 |
|
---|
| 1392 | LightTrackArray.Reset();
|
---|
| 1393 | if(!LightChunk)
|
---|
| 1394 | return;
|
---|
| 1395 |
|
---|
| 1396 | s3d_CUtilSnkExtract SnkLightExtract;
|
---|
| 1397 | SnkLightExtract.Assign(ProgCtx->m_MsgHandler, LightChunk);
|
---|
| 1398 |
|
---|
| 1399 | /*@{ @declare{shaderprog.param}
|
---|
| 1400 | {<d3d9_hlsl_shader>.light_array.cnt}{$ [int]}
|
---|
| 1401 | Number of lights supported by this shader program.
|
---|
| 1402 | @}*/
|
---|
| 1403 | s3d_CUtilStr LightCntInfo;
|
---|
| 1404 | int LightCnt;
|
---|
| 1405 | SnkLightExtract.ExtractInt(LightCntInfo, LightCnt, "cnt", true, 0);
|
---|
| 1406 | if(LightCnt > ProgCtx->m_MaxLightCnt)
|
---|
| 1407 | {
|
---|
| 1408 | s3d_CDrvDxError e;
|
---|
| 1409 | e.m_Code = "drv/imp/directx/d3d9/drv_d3d9_proghlsl.invalid_lightcnt.";
|
---|
| 1410 | e.m_StdTempl = "Invalid HLSL tracking light count value '[1]'. "
|
---|
| 1411 | "Must be greater or equal 0 and less than [2].";
|
---|
| 1412 | e.AddInfo(LightCntInfo);
|
---|
| 1413 | e.AddInfo(s3d_CUtilStrUtil::StrOfInt(LightCnt));
|
---|
| 1414 | e.AddInfo(s3d_CUtilStrUtil::StrOfInt(ProgCtx->m_MaxLightCnt));
|
---|
| 1415 | s3d_UtilMsgReportError(ProgCtx->m_MsgHandler, e);
|
---|
| 1416 |
|
---|
| 1417 | LightCnt = ProgCtx->m_MaxLightCnt;
|
---|
| 1418 | }
|
---|
| 1419 |
|
---|
| 1420 | /*@{ @declare{shaderprog.param}
|
---|
| 1421 | {<d3d9_hlsl_shader>.light_array.pos_codevar}{$ [str]}
|
---|
| 1422 | Light position (in viewspace) shader code variable.
|
---|
| 1423 | @}*/
|
---|
| 1424 | s3d_CUtilStr Pos, PosInfo;
|
---|
| 1425 | SnkLightExtract.ExtractStr(PosInfo, Pos, "pos_codevar", true);
|
---|
| 1426 |
|
---|
| 1427 | /*@{ @declare{shaderprog.param}
|
---|
| 1428 | {<d3d9_hlsl_shader>.light_array.dir_codevar}{$ [str]}
|
---|
| 1429 | Light direction (in viewspace) shader code variable.
|
---|
| 1430 | @}*/
|
---|
| 1431 | s3d_CUtilStr Dir, DirInfo;
|
---|
| 1432 | SnkLightExtract.ExtractStr(DirInfo, Dir, "dir_codevar", true);
|
---|
| 1433 |
|
---|
| 1434 | /*@{ @declare{shaderprog.param}
|
---|
| 1435 | {<d3d9_hlsl_shader>.light_array.ambient_codevar}{$ [str]}
|
---|
| 1436 | Light ambient color shader code variable.
|
---|
| 1437 | @}*/
|
---|
| 1438 | s3d_CUtilStr Ambient, AmbientInfo;
|
---|
| 1439 | SnkLightExtract.ExtractStr(AmbientInfo, Ambient, "ambient_codevar", true);
|
---|
| 1440 |
|
---|
| 1441 | /*@{ @declare{shaderprog.param}
|
---|
| 1442 | {<d3d9_hlsl_shader>.light_array.diffuse_codevar}{$ [str]}
|
---|
| 1443 | Light diffuse color shader code variable.
|
---|
| 1444 | @}*/
|
---|
| 1445 | s3d_CUtilStr Diffuse, DiffuseInfo;
|
---|
| 1446 | SnkLightExtract.ExtractStr(
|
---|
| 1447 | DiffuseInfo, Diffuse, "diffuse_codevar", true);
|
---|
| 1448 |
|
---|
| 1449 | /*@{ @declare{shaderprog.param}
|
---|
| 1450 | {<d3d9_hlsl_shader>.light_array.specular_codevar}{$ [str]}
|
---|
| 1451 | Light specular color shader code variable.
|
---|
| 1452 | @}*/
|
---|
| 1453 | s3d_CUtilStr Specular, SpecularInfo;
|
---|
| 1454 | SnkLightExtract.ExtractStr(
|
---|
| 1455 | SpecularInfo, Specular, "specular_codevar", true);
|
---|
| 1456 |
|
---|
| 1457 | /*@{ @declare{shaderprog.param}
|
---|
| 1458 | {<d3d9_hlsl_shader>.light_array.atten_codevar}{$ [str]}
|
---|
| 1459 | Light attenuation shader code variable.
|
---|
| 1460 | @table
|
---|
| 1461 | {
|
---|
| 1462 | { @code{atten_codevar.x} } { AttenConst }
|
---|
| 1463 | }
|
---|
| 1464 | {
|
---|
| 1465 | { @code{atten_codevar.y} } { AttenLinear }
|
---|
| 1466 | }
|
---|
| 1467 | {
|
---|
| 1468 | { @code{atten_codevar.z} } { AttenQuadr }
|
---|
| 1469 | }
|
---|
| 1470 | {
|
---|
| 1471 | { @code{atten_codevar.w} } { Range }
|
---|
| 1472 | }
|
---|
| 1473 | @}*/
|
---|
| 1474 | s3d_CUtilStr Atten, AttenInfo;
|
---|
| 1475 | SnkLightExtract.ExtractStr(
|
---|
| 1476 | AttenInfo, Atten, "atten_codevar", true);
|
---|
| 1477 |
|
---|
| 1478 | SnkLightExtract.CheckForUnknown();
|
---|
| 1479 | s3d_CUtilStrBuf ParamName;
|
---|
| 1480 | s3d_CUtilStrBuf StrIdx;
|
---|
| 1481 | int iLightParam;
|
---|
| 1482 | for(iLightParam = 0; iLightParam < LightCnt; iLightParam++)
|
---|
| 1483 | {
|
---|
| 1484 | s3d_CDrvD3d9ProgHLSLLight Light;
|
---|
| 1485 | StrIdx.Clear();
|
---|
| 1486 | StrIdx.AppendInt(iLightParam);
|
---|
| 1487 |
|
---|
| 1488 | ParamName.Assign(Pos);
|
---|
| 1489 | ParamName.Replace("$", StrIdx.GetChars());
|
---|
| 1490 | S3D_DRV_D3D9_RESOLVEVAR(Light.m_PosVar, PosInfo, ParamName);
|
---|
| 1491 |
|
---|
| 1492 | ParamName.Assign(Dir);
|
---|
| 1493 | ParamName.Replace("$", StrIdx.GetChars());
|
---|
| 1494 | S3D_DRV_D3D9_RESOLVEVAR(Light.m_DirVar, DirInfo, ParamName);
|
---|
| 1495 |
|
---|
| 1496 | ParamName.Assign(Ambient);
|
---|
| 1497 | ParamName.Replace("$", StrIdx.GetChars());
|
---|
| 1498 | S3D_DRV_D3D9_RESOLVEVAR(Light.m_AmbientVar, AmbientInfo, ParamName);
|
---|
| 1499 |
|
---|
| 1500 | ParamName.Assign(Diffuse);
|
---|
| 1501 | ParamName.Replace("$", StrIdx.GetChars());
|
---|
| 1502 | S3D_DRV_D3D9_RESOLVEVAR(Light.m_DiffuseVar, DiffuseInfo, ParamName);
|
---|
| 1503 |
|
---|
| 1504 | ParamName.Assign(Specular);
|
---|
| 1505 | ParamName.Replace("$", StrIdx.GetChars());
|
---|
| 1506 | S3D_DRV_D3D9_RESOLVEVAR(Light.m_SpecularVar, SpecularInfo, ParamName);
|
---|
| 1507 |
|
---|
| 1508 | ParamName.Assign(Atten);
|
---|
| 1509 | ParamName.Replace("$", StrIdx.GetChars());
|
---|
| 1510 | S3D_DRV_D3D9_RESOLVEVAR(Light.m_AttenVar, AttenInfo, ParamName);
|
---|
| 1511 |
|
---|
| 1512 | LightTrackArray.InsertBack(Light);
|
---|
| 1513 | }
|
---|
| 1514 |
|
---|
| 1515 | LightTrackArray.Compactify();
|
---|
| 1516 | }
|
---|
| 1517 |
|
---|
| 1518 | void s3d_CDrvD3d9ProgHLSLUtil::ExtractMtl(
|
---|
| 1519 | const s3d_CDrvD3d9ProgCtx *ProgCtx,
|
---|
| 1520 | s3d_CUtilStr_cr CodeInfo, s3d_CUtilStr_cr CodeName,
|
---|
| 1521 | const LPD3DXCONSTANTTABLE ConstTab,
|
---|
| 1522 | s3d_CDrvD3d9ProgHLSLTrackMtrl &Mtl,
|
---|
| 1523 | s3d_CDrvD3d9ProgHLSLVarSet &VarSet,
|
---|
| 1524 | s3d_CUtilSnkExtract &SnkExtract)
|
---|
| 1525 | {
|
---|
| 1526 | /*@{ @declare{shaderprog.param}
|
---|
| 1527 | {<d3d9_hlsl_shader>.mtl}{$ [chunk]}
|
---|
| 1528 | @}*/
|
---|
| 1529 | s3d_CUtilSnkChunkPtr MtlChunk;
|
---|
| 1530 | MtlChunk = SnkExtract.ExtractChunk("mtl", false);
|
---|
| 1531 |
|
---|
| 1532 | s3d_CUtilSnkExtract MtrlSnkExtract;
|
---|
| 1533 | MtrlSnkExtract.Assign(ProgCtx->m_MsgHandler, MtlChunk);
|
---|
| 1534 |
|
---|
| 1535 | /*@{ @declare{shaderprog.param}
|
---|
| 1536 | {<d3d9_hlsl_shader>.mtl.power_codevar}{$ [str]}
|
---|
| 1537 | Mtl power variable.
|
---|
| 1538 | @table
|
---|
| 1539 | {
|
---|
| 1540 | { @code{power_codevar.x} } { MtlPower }
|
---|
| 1541 | }
|
---|
| 1542 | {
|
---|
| 1543 | { @code{power_codevar.y} } { MtlPower }
|
---|
| 1544 | }
|
---|
| 1545 | {
|
---|
| 1546 | { @code{power_codevar.z} } { MtlPower }
|
---|
| 1547 | }
|
---|
| 1548 | {
|
---|
| 1549 | { @code{power_codevar.w} } { MtlPower }
|
---|
| 1550 | }
|
---|
| 1551 | @}*/
|
---|
| 1552 | s3d_CUtilStr VarName, VarInfo;
|
---|
| 1553 | MtrlSnkExtract.ExtractStr(VarInfo, VarName, "power_codevar", false);
|
---|
| 1554 | D3DXHANDLE PowerVar = 0;
|
---|
| 1555 | if(!VarName.IsEmpty())
|
---|
| 1556 | {
|
---|
| 1557 | S3D_DRV_D3D9_RESOLVEVAR(PowerVar, VarInfo, VarName);
|
---|
| 1558 | }
|
---|
| 1559 |
|
---|
| 1560 | /*@{ @declare{shaderprog.param}
|
---|
| 1561 | {<d3d9_hlsl_shader>.mtl.emissive_codevar}{$ [str]}
|
---|
| 1562 | Mtl emissive color variable.
|
---|
| 1563 | @table
|
---|
| 1564 | {
|
---|
| 1565 | { @code{emissive_codevar.x} } { MtlEmissive.r }
|
---|
| 1566 | }
|
---|
| 1567 | {
|
---|
| 1568 | { @code{emissive_codevar.y} } { MtlEmissive.g }
|
---|
| 1569 | }
|
---|
| 1570 | {
|
---|
| 1571 | { @code{emissive_codevar.z} } { MtlEmissive.b }
|
---|
| 1572 | }
|
---|
| 1573 | {
|
---|
| 1574 | { @code{emissive_codevar.w} } { MtlEmissive.a }
|
---|
| 1575 | }
|
---|
| 1576 | @}*/
|
---|
| 1577 | MtrlSnkExtract.ExtractStr(
|
---|
| 1578 | VarInfo, VarName, "emissive_codevar", false);
|
---|
| 1579 | D3DXHANDLE EmissiveVar = 0;
|
---|
| 1580 | if(!VarName.IsEmpty())
|
---|
| 1581 | {
|
---|
| 1582 | S3D_DRV_D3D9_RESOLVEVAR(EmissiveVar, VarInfo, VarName);
|
---|
| 1583 | }
|
---|
| 1584 |
|
---|
| 1585 | Mtl.m_PowerVar = PowerVar;
|
---|
| 1586 | Mtl.m_EmissiveVar = EmissiveVar;
|
---|
| 1587 | MtrlSnkExtract.CheckForUnknown();
|
---|
| 1588 | }
|
---|
| 1589 |
|
---|
| 1590 | void s3d_CDrvD3d9ProgHLSLUtil::ExtractFog(
|
---|
| 1591 | const s3d_CDrvD3d9ProgCtx *ProgCtx,
|
---|
| 1592 | s3d_CUtilStr_cr CodeInfo, s3d_CUtilStr_cr CodeName,
|
---|
| 1593 | const LPD3DXCONSTANTTABLE ConstTab,
|
---|
| 1594 | D3DXHANDLE &FogVar,
|
---|
| 1595 | s3d_CDrvD3d9ProgHLSLVarSet &VarSet,
|
---|
| 1596 | s3d_CUtilSnkExtract &SnkExtract)
|
---|
| 1597 | {
|
---|
| 1598 | /*@{ @declare{shaderprog.param}
|
---|
| 1599 | {<d3d9_hlsl_shader>.fog_codevar}{$ [str]}
|
---|
| 1600 | Fog color and denisity variable.
|
---|
| 1601 | @table
|
---|
| 1602 | {
|
---|
| 1603 | { @code{fog_codevar.x} } { FogColor.r }
|
---|
| 1604 | }
|
---|
| 1605 | {
|
---|
| 1606 | { @code{fog_codevar.y} } { FogColor.g }
|
---|
| 1607 | }
|
---|
| 1608 | {
|
---|
| 1609 | { @code{fog_codevar.z} } { FogColor.b }
|
---|
| 1610 | }
|
---|
| 1611 | {
|
---|
| 1612 | { @code{fog_codevar.w} } { FogDensity }
|
---|
| 1613 | }
|
---|
| 1614 | @}*/
|
---|
| 1615 | s3d_CUtilStr VarName, VarInfo;
|
---|
| 1616 | SnkExtract.ExtractStr(VarInfo, VarName, "fog_codevar", false);
|
---|
| 1617 | FogVar = 0;
|
---|
| 1618 | if(!VarName.IsEmpty())
|
---|
| 1619 | {
|
---|
| 1620 | S3D_DRV_D3D9_RESOLVEVAR(FogVar, VarInfo, VarName);
|
---|
| 1621 | }
|
---|
| 1622 | }
|
---|
| 1623 |
|
---|
| 1624 | void s3d_CDrvD3d9ProgHLSLUtil::InitTrackBlk(
|
---|
| 1625 | const s3d_CDrvD3d9ProgCtx *ProgCtx,
|
---|
| 1626 | s3d_CUtilStr_cr CodeInfo, s3d_CUtilStr_cr CodeName,
|
---|
| 1627 | s3d_CDrvD3d9ProgHLSLTrackBlk &TrackBlk,
|
---|
| 1628 | s3d_CUtilSnkExtract &SnkExtract)
|
---|
| 1629 | {
|
---|
| 1630 | TrackBlk.m_CodeInfo = CodeInfo;
|
---|
| 1631 | TrackBlk.m_CodeName = CodeName;
|
---|
| 1632 |
|
---|
| 1633 | const LPD3DXCONSTANTTABLE ConstTab = TrackBlk.m_ConstTab;
|
---|
| 1634 | s3d_CDrvD3d9ProgHLSLVarSet VarSet;
|
---|
| 1635 | s3d_CDrvD3d9ProgHLSLUtil::ExtractParamArray(
|
---|
| 1636 | ProgCtx, CodeInfo, CodeName, ConstTab,
|
---|
| 1637 | TrackBlk.m_ParamArray, VarSet, SnkExtract);
|
---|
| 1638 | s3d_CDrvD3d9ProgHLSLUtil::ExtractTexSize(
|
---|
| 1639 | ProgCtx, CodeInfo, CodeName, ConstTab,
|
---|
| 1640 | TrackBlk.m_TexSizeArray, TrackBlk.m_TexRcpSizeArray,
|
---|
| 1641 | VarSet, SnkExtract);
|
---|
| 1642 | s3d_CDrvD3d9ProgHLSLUtil::ExtractTrackArray(
|
---|
| 1643 | ProgCtx, CodeInfo, CodeName, ConstTab,
|
---|
| 1644 | TrackBlk.m_MatTrackArray, TrackBlk.m_BoneTrackArray,
|
---|
| 1645 | VarSet, SnkExtract);
|
---|
| 1646 | s3d_CDrvD3d9ProgHLSLUtil::ExtractLightArray(
|
---|
| 1647 | ProgCtx, CodeInfo, CodeName, ConstTab,
|
---|
| 1648 | TrackBlk.m_ActiveLightCntVar, TrackBlk.m_LightTrackArray,
|
---|
| 1649 | VarSet, SnkExtract);
|
---|
| 1650 | s3d_CDrvD3d9ProgHLSLUtil::ExtractMtl(
|
---|
| 1651 | ProgCtx, CodeInfo, CodeName, ConstTab,
|
---|
| 1652 | TrackBlk.m_Mtl, VarSet, SnkExtract);
|
---|
| 1653 | s3d_CDrvD3d9ProgHLSLUtil::ExtractFog(
|
---|
| 1654 | ProgCtx, CodeInfo, CodeName, ConstTab,
|
---|
| 1655 | TrackBlk.m_FogVar, VarSet, SnkExtract);
|
---|
| 1656 |
|
---|
| 1657 | s3d_CDrvD3d9ProgHLSLUtil::EnumAllVars(
|
---|
| 1658 | ProgCtx, CodeInfo, CodeName, ConstTab, VarSet);
|
---|
| 1659 | }
|
---|
| 1660 |
|
---|
| 1661 | bool s3d_CDrvD3d9ProgHLSLUtil::CompileFromRes(
|
---|
| 1662 | s3d_CUtilNotifGather *NotifGather,
|
---|
| 1663 | const s3d_CDrvD3d9ProgCtx *ProgCtx,
|
---|
| 1664 | s3d_CUtilStr_cr CodeInfo, s3d_CUtilStr_cr CodeName,
|
---|
| 1665 | s3d_CUtilStr_cr EntryPoint, s3d_CUtilStr_cr Profile,
|
---|
| 1666 | s3d_CLibStreamPreproState *PreproState,
|
---|
| 1667 | s3d_CDrvD3d9Buf &CodeBuf, s3d_CDrvD3d9ConstTable &ConstTab)
|
---|
| 1668 | {
|
---|
| 1669 | if(!ProgCtx)
|
---|
| 1670 | return false;
|
---|
| 1671 |
|
---|
| 1672 | s3d_CUtilMsgHandler *MsgHandler = ProgCtx->m_MsgHandler;
|
---|
| 1673 | s3d_CCompResMgr *ResMgr = ProgCtx->m_ResMgr;
|
---|
| 1674 | s3d_CUtilMemPool *MemPool = ProgCtx->m_MemPool;
|
---|
| 1675 | s3d_CUtilMemPoolFrm MemPoolFrm(MemPool);
|
---|
| 1676 |
|
---|
| 1677 | int Generosity = s3d_CCompResMgr::Generosity_AllowMissing;
|
---|
| 1678 | s3d_CUtilStr ResInfo;
|
---|
| 1679 | s3d_CUtilStreamPtr ResStream;
|
---|
| 1680 | bool Final = false;
|
---|
| 1681 | s3d_CUtilNotifEntryPtr NotifEntry = S3D_SYS_NEW s3d_CUtilNotifEntry;
|
---|
| 1682 | ResMgr->GetResource(
|
---|
| 1683 | CodeInfo, CodeName, true, Generosity,
|
---|
| 1684 | ResInfo, ResStream, Final, NotifEntry);
|
---|
| 1685 | if(NotifGather)
|
---|
| 1686 | NotifGather->AddNotifEntry(NotifEntry);
|
---|
| 1687 | if(!ResStream)
|
---|
| 1688 | return false;
|
---|
| 1689 |
|
---|
| 1690 | s3d_CUtilStreamPos ResSize = ResStream->GetSize();
|
---|
| 1691 | if(ResSize == 0)
|
---|
| 1692 | return false;
|
---|
| 1693 |
|
---|
| 1694 | UINT D3dStreamLen = UINT(ResSize);
|
---|
| 1695 | s3d_CSysIntm *ResData = new(MemPool) s3d_CSysIntm[D3dStreamLen + 1];
|
---|
| 1696 | ResStream->Read(D3dStreamLen, ResData);
|
---|
| 1697 | ResData[ResSize] = 0;
|
---|
| 1698 |
|
---|
| 1699 | if(s3d_CDrvD3d9ProgUtil::CreateCodeBufOfBinData(
|
---|
| 1700 | ProgCtx, CodeBuf, D3dStreamLen, ResData))
|
---|
| 1701 | return true;
|
---|
| 1702 |
|
---|
| 1703 | s3d_CUtilMap<s3d_CUtilStr, s3d_CUtilStr> StreamNameMap;
|
---|
| 1704 | // Errors contain no filename for the main file:
|
---|
| 1705 | StreamNameMap.SetAt("", ResInfo);
|
---|
| 1706 |
|
---|
| 1707 | s3d_CDrvD3d9ProgIncMgr ProgIncMgr(
|
---|
| 1708 | MsgHandler, CodeInfo, MemPool, ResMgr,
|
---|
| 1709 | NotifGather, &StreamNameMap);
|
---|
| 1710 |
|
---|
| 1711 | s3d_CUtilOwnArray<D3DXMACRO> D3dMacroArray;
|
---|
| 1712 | s3d_CDrvD3d9ProgUtil::D3dMarcoArrayOfPreprocArray(
|
---|
| 1713 | D3dMacroArray, PreproState);
|
---|
| 1714 |
|
---|
| 1715 | s3d_CDrvD3d9Buf ErrBuf;
|
---|
| 1716 | const char *D3dStream = reinterpret_cast<char*>(ResData);
|
---|
| 1717 | DWORD Flags = 0;
|
---|
| 1718 | int DxResult = D3DXCompileShader(
|
---|
| 1719 | D3dStream, D3dStreamLen, D3dMacroArray.Get(), &ProgIncMgr,
|
---|
| 1720 | EntryPoint.GetChars(), Profile.GetChars(), Flags,
|
---|
| 1721 | &CodeBuf.EmptyRef(), &ErrBuf.EmptyRef(), &ConstTab.EmptyRef());
|
---|
| 1722 |
|
---|
| 1723 | // ErrBuf can be valid even if assembling was successful, e.g. warnings.
|
---|
| 1724 | s3d_CDrvD3d9ProgReportMap Report(0, 0, &StreamNameMap);
|
---|
| 1725 | if(!Report.ReportCompilingBuffer(
|
---|
| 1726 | ProgCtx->m_Env, CodeInfo, ErrBuf, DxResult))
|
---|
| 1727 | return false;
|
---|
| 1728 |
|
---|
| 1729 | return true;
|
---|
| 1730 | }
|
---|
| 1731 |
|
---|
| 1732 | bool s3d_CDrvD3d9ProgHLSLUtil::CompileFromFile(
|
---|
| 1733 | s3d_CUtilNotifGather *NotifGather,
|
---|
| 1734 | const s3d_CDrvD3d9ProgCtx *ProgCtx,
|
---|
| 1735 | s3d_CUtilStr_cr CodeInfo, s3d_CUtilStr_cr CodeName,
|
---|
| 1736 | s3d_CUtilStr_cr EntryPoint, s3d_CUtilStr_cr Profile,
|
---|
| 1737 | s3d_CLibStreamPreproState *PreproState,
|
---|
| 1738 | s3d_CDrvD3d9Buf &CodeBuf, s3d_CDrvD3d9ConstTable &ConstTab)
|
---|
| 1739 | {
|
---|
| 1740 | if(!ProgCtx)
|
---|
| 1741 | return false;
|
---|
| 1742 |
|
---|
| 1743 | s3d_CUtilMsgHandler *MsgHandler = ProgCtx->m_MsgHandler;
|
---|
| 1744 | s3d_CCompResMgr *ResMgr = ProgCtx->m_ResMgr;
|
---|
| 1745 | s3d_CUtilMemPool *MemPool = ProgCtx->m_MemPool;
|
---|
| 1746 |
|
---|
| 1747 | s3d_CDrvD3d9Buf ErrBuf;
|
---|
| 1748 | s3d_CUtilMap<s3d_CUtilStr, s3d_CUtilStr> StreamNameMap;
|
---|
| 1749 | // Errors contain no filename for the main file:
|
---|
| 1750 | StreamNameMap.SetAt("", CodeName);
|
---|
| 1751 |
|
---|
| 1752 | int DxResult = 0;
|
---|
| 1753 | // Own scope for MemPoolFrm, used by ProgIncMgr
|
---|
| 1754 | {
|
---|
| 1755 | s3d_CUtilMemPoolFrm MemPoolFrm(ProgCtx->m_MemPool);
|
---|
| 1756 | s3d_CDrvD3d9ProgIncMgr ProgIncMgr(
|
---|
| 1757 | MsgHandler, CodeInfo, MemPool, ResMgr,
|
---|
| 1758 | NotifGather, &StreamNameMap);
|
---|
| 1759 |
|
---|
| 1760 | s3d_CUtilOwnArray<D3DXMACRO> D3dMacroArray;
|
---|
| 1761 | s3d_CDrvD3d9ProgUtil::D3dMarcoArrayOfPreprocArray(
|
---|
| 1762 | D3dMacroArray, PreproState);
|
---|
| 1763 |
|
---|
| 1764 | DWORD Flags = D3DXSHADER_DEBUG;
|
---|
| 1765 | DxResult = D3DXCompileShaderFromFile(
|
---|
| 1766 | CodeName.GetChars(), D3dMacroArray.Get(), &ProgIncMgr,
|
---|
| 1767 | EntryPoint.GetChars(), Profile.GetChars(), Flags,
|
---|
| 1768 | &CodeBuf.EmptyRef(), &ErrBuf.EmptyRef(), 0);
|
---|
| 1769 | }
|
---|
| 1770 | // ErrBuf can be valid even if assembling was successful, e.g. warnings.
|
---|
| 1771 | s3d_CDrvD3d9ProgReportMap Report(0, 0, &StreamNameMap);
|
---|
| 1772 | if(!Report.ReportCompilingBuffer(
|
---|
| 1773 | ProgCtx->m_Env, CodeInfo, ErrBuf, DxResult))
|
---|
| 1774 | return false;
|
---|
| 1775 |
|
---|
| 1776 | return true;
|
---|
| 1777 | }
|
---|
| 1778 |
|
---|
| 1779 | void s3d_CDrvD3d9ProgHLSLUtil::ResolveVar(
|
---|
| 1780 | const s3d_CDrvD3d9ProgCtx *ProgCtx,
|
---|
| 1781 | s3d_CUtilStr_cr Info, s3d_CUtilStr_cr CodeName,
|
---|
| 1782 | LPD3DXCONSTANTTABLE ConstTab,
|
---|
| 1783 | D3DXHANDLE &Var, s3d_CUtilStr_cr VarName,
|
---|
| 1784 | s3d_CDrvD3d9ProgHLSLVarSet &VarSet)
|
---|
| 1785 | {
|
---|
| 1786 | Var = 0;
|
---|
| 1787 | if(!ProgCtx)
|
---|
| 1788 | return;
|
---|
| 1789 | if(VarName.IsEmpty())
|
---|
| 1790 | return;
|
---|
| 1791 |
|
---|
| 1792 | if(ConstTab)
|
---|
| 1793 | Var = ConstTab->GetConstantByName(0, VarName.GetChars());
|
---|
| 1794 |
|
---|
| 1795 | if(!Var)
|
---|
| 1796 | {
|
---|
| 1797 | /*
|
---|
| 1798 | s3d_CDrvDxError e;
|
---|
| 1799 | e.m_Code = "drv/imp/directx/d3d9/drv_d3d9_proghlsl.unused_codevar.";
|
---|
| 1800 | e.m_StdTempl = "Unused tracking variable '[1]' for "
|
---|
| 1801 | "D3D HLSL shader \"[2]\" ";
|
---|
| 1802 | e.AddInfo(Info);
|
---|
| 1803 | e.AddInfo(VarName);
|
---|
| 1804 | e.AddInfo(CodeName);
|
---|
| 1805 | s3d_UtilMsgReportError(ProgCtx->m_MsgHandler, e);
|
---|
| 1806 | */
|
---|
| 1807 | return;
|
---|
| 1808 | }
|
---|
| 1809 |
|
---|
| 1810 | bool AlreadyDefined = VarSet.DefineAt(Var);
|
---|
| 1811 | if(AlreadyDefined)
|
---|
| 1812 | {
|
---|
| 1813 | s3d_CDrvDxError e;
|
---|
| 1814 | e.m_Code = "drv/imp/directx/d3d9/drv_d3d9_proghlsl.multiple_tracked.";
|
---|
| 1815 | e.m_StdTempl = "Variable '[1]' is tracked more than once in"
|
---|
| 1816 | "D3D HLSL shader \"[2]\" ";
|
---|
| 1817 | e.AddInfo(Info);
|
---|
| 1818 | e.AddInfo(VarName);
|
---|
| 1819 | e.AddInfo(CodeName);
|
---|
| 1820 | s3d_UtilMsgReportError(ProgCtx->m_MsgHandler, e);
|
---|
| 1821 | }
|
---|
| 1822 | }
|
---|
| 1823 |
|
---|
| 1824 | void s3d_CDrvD3d9ProgHLSLUtil::EnumAllVars(
|
---|
| 1825 | const s3d_CDrvD3d9ProgCtx *ProgCtx,
|
---|
| 1826 | s3d_CUtilStr_cr CodeInfo, s3d_CUtilStr_cr CodeName,
|
---|
| 1827 | LPD3DXCONSTANTTABLE ConstTab,
|
---|
| 1828 | const s3d_CDrvD3d9ProgHLSLVarSet &VarSet)
|
---|
| 1829 | {
|
---|
| 1830 | D3DXCONSTANTTABLE_DESC ConstTabDesc;
|
---|
| 1831 | S3D_DRV_D3D9_CHECK(
|
---|
| 1832 | ProgCtx->m_Env, ConstTab->GetDesc(&ConstTabDesc));
|
---|
| 1833 | UINT nConst = ConstTabDesc.Constants;
|
---|
| 1834 | UINT iConst;
|
---|
| 1835 | for(iConst = 0; iConst < nConst; iConst++)
|
---|
| 1836 | {
|
---|
| 1837 | D3DXHANDLE Var = 0;
|
---|
| 1838 | S3D_DRV_D3D9_HRESCALL(
|
---|
| 1839 | ProgCtx->m_Env, Var, ConstTab->GetConstant(
|
---|
| 1840 | 0, iConst));
|
---|
| 1841 | EnumVar(
|
---|
| 1842 | ProgCtx, CodeInfo, CodeName, ConstTab, Var, 0, VarSet);
|
---|
| 1843 | }
|
---|
| 1844 | }
|
---|
| 1845 |
|
---|
| 1846 | void s3d_CDrvD3d9ProgHLSLUtil::EnumVar(
|
---|
| 1847 | const s3d_CDrvD3d9ProgCtx *ProgCtx,
|
---|
| 1848 | s3d_CUtilStr_cr CodeInfo, s3d_CUtilStr_cr CodeName,
|
---|
| 1849 | LPD3DXCONSTANTTABLE ConstTab,
|
---|
| 1850 | D3DXHANDLE Var, s3d_CUtilStr_cr VarName,
|
---|
| 1851 | const s3d_CDrvD3d9ProgHLSLVarSet &VarSet)
|
---|
| 1852 | {
|
---|
| 1853 | if(!ProgCtx)
|
---|
| 1854 | return;
|
---|
| 1855 | if(!ConstTab)
|
---|
| 1856 | return;
|
---|
| 1857 |
|
---|
| 1858 | D3DXCONSTANT_DESC ConstDesc;
|
---|
| 1859 | s3d_SysMemset(&ConstDesc, 0, S3D_SYS_SIZEOFS(ConstDesc));
|
---|
| 1860 | UINT ConstDescCnt = 1;
|
---|
| 1861 | S3D_DRV_D3D9_CHECK(
|
---|
| 1862 | ProgCtx->m_Env, ConstTab->GetConstantDesc(
|
---|
| 1863 | Var, &ConstDesc, &ConstDescCnt));
|
---|
| 1864 |
|
---|
| 1865 | s3d_CUtilStrBuf VarNameBuf;
|
---|
| 1866 | VarNameBuf.Append(VarName);
|
---|
| 1867 | VarNameBuf.Append(ConstDesc.Name);
|
---|
| 1868 |
|
---|
| 1869 | s3d_CDrvD3d9ProgHLSLUtil::CheckVarInitialized(
|
---|
| 1870 | ProgCtx, CodeInfo, CodeName, Var, VarNameBuf, ConstDesc, VarSet);
|
---|
| 1871 |
|
---|
| 1872 | UINT nElem = ConstDesc.Elements;
|
---|
| 1873 | UINT iElem;
|
---|
| 1874 | for(iElem = 0; iElem < nElem; iElem++)
|
---|
| 1875 | {
|
---|
| 1876 | D3DXHANDLE ElemVar = 0;
|
---|
| 1877 | S3D_DRV_D3D9_HRESCALL(
|
---|
| 1878 | ProgCtx->m_Env, ElemVar, ConstTab->GetConstantElement(
|
---|
| 1879 | Var, iElem));
|
---|
| 1880 |
|
---|
| 1881 | UINT nStruct = ConstDesc.StructMembers;
|
---|
| 1882 | UINT iStruct;
|
---|
| 1883 | for(iStruct = 0; iStruct < nStruct; iStruct++)
|
---|
| 1884 | {
|
---|
| 1885 | D3DXHANDLE StructVar = 0;
|
---|
| 1886 | S3D_DRV_D3D9_HRESCALL(
|
---|
| 1887 | ProgCtx->m_Env, StructVar, ConstTab->GetConstant(
|
---|
| 1888 | ElemVar, iStruct));
|
---|
| 1889 |
|
---|
| 1890 | D3DXCONSTANT_DESC ElemConstDesc;
|
---|
| 1891 | s3d_SysMemset(&ElemConstDesc, 0, S3D_SYS_SIZEOFS(ElemConstDesc));
|
---|
| 1892 | UINT ElemConstDescCnt = 1;
|
---|
| 1893 | S3D_DRV_D3D9_CHECK(
|
---|
| 1894 | ProgCtx->m_Env, ConstTab->GetConstantDesc(
|
---|
| 1895 | StructVar, &ElemConstDesc, &ElemConstDescCnt));
|
---|
| 1896 |
|
---|
| 1897 | VarNameBuf.Reset();
|
---|
| 1898 | VarNameBuf = VarName;
|
---|
| 1899 | VarNameBuf.Append(ConstDesc.Name);
|
---|
| 1900 | VarNameBuf.Append("[");
|
---|
| 1901 | VarNameBuf.Append(s3d_CUtilStrUtil::StrOfInt(iElem));
|
---|
| 1902 | VarNameBuf.Append("].");
|
---|
| 1903 |
|
---|
| 1904 | EnumVar(
|
---|
| 1905 | ProgCtx, CodeInfo, CodeName, ConstTab,
|
---|
| 1906 | StructVar, VarNameBuf, VarSet);
|
---|
| 1907 | }
|
---|
| 1908 |
|
---|
| 1909 | D3DXCONSTANT_DESC ElemConstDesc;
|
---|
| 1910 | s3d_SysMemset(&ElemConstDesc, 0, S3D_SYS_SIZEOFS(ElemConstDesc));
|
---|
| 1911 | UINT ElemConstDescCnt = 1;
|
---|
| 1912 | S3D_DRV_D3D9_CHECK(
|
---|
| 1913 | ProgCtx->m_Env, ConstTab->GetConstantDesc(
|
---|
| 1914 | ElemVar, &ElemConstDesc, &ElemConstDescCnt));
|
---|
| 1915 |
|
---|
| 1916 | VarNameBuf.Reset();
|
---|
| 1917 | VarNameBuf = VarName;
|
---|
| 1918 | VarNameBuf.Append(ElemConstDesc.Name);
|
---|
| 1919 | VarNameBuf.Append("[");
|
---|
| 1920 | VarNameBuf.Append(s3d_CUtilStrUtil::StrOfInt(iElem));
|
---|
| 1921 | VarNameBuf.Append("]");
|
---|
| 1922 |
|
---|
| 1923 | s3d_CDrvD3d9ProgHLSLUtil::CheckVarInitialized(
|
---|
| 1924 | ProgCtx, CodeInfo, CodeName,
|
---|
| 1925 | Var, VarNameBuf, ElemConstDesc, VarSet);
|
---|
| 1926 | }
|
---|
| 1927 | }
|
---|
| 1928 |
|
---|
| 1929 | void s3d_CDrvD3d9ProgHLSLUtil::CheckVarInitialized(
|
---|
| 1930 | const s3d_CDrvD3d9ProgCtx *ProgCtx,
|
---|
| 1931 | s3d_CUtilStr_cr CodeInfo, s3d_CUtilStr_cr CodeName,
|
---|
| 1932 | D3DXHANDLE Var, s3d_CUtilStr_cr VarName,
|
---|
| 1933 | const D3DXCONSTANT_DESC &VarDesc,
|
---|
| 1934 | const s3d_CDrvD3d9ProgHLSLVarSet &VarSet)
|
---|
| 1935 | {
|
---|
| 1936 | if(!VarDesc.DefaultValue && !VarSet.IsDefined(Var))
|
---|
| 1937 | {
|
---|
| 1938 | if(VarDesc.RegisterSet != D3DXRS_SAMPLER
|
---|
| 1939 | && VarDesc.Class != D3DXPC_STRUCT)
|
---|
| 1940 | {
|
---|
| 1941 | s3d_CDrvD3d9Error e;
|
---|
| 1942 | e.m_Code = "drv/imp/directx/d3d9/drv_d3d9_proghlsl.undef_codevar.";
|
---|
| 1943 | e.m_StdTempl = "Uninitialized code variable '[1]' for "
|
---|
| 1944 | "D3D HLSL shader \"[2]\" ";
|
---|
| 1945 | e.AddInfo(CodeInfo);
|
---|
| 1946 | e.AddInfo(VarName);
|
---|
| 1947 | e.AddInfo(CodeName);
|
---|
| 1948 | s3d_UtilMsgReportError(ProgCtx->m_MsgHandler, e);
|
---|
| 1949 | }
|
---|
| 1950 | }
|
---|
| 1951 | }
|
---|
| 1952 |
|
---|
| 1953 | ///////////////////////////////////////////////////////////////////////////////
|
---|