Remove old and unused variables and code.

intorr · intorr · commit 27cc76e2fd12 · 2017-12-10T03:22:05.000+05:00
diff --git a/src/Layers/xrRender/R_Backend_Runtime.cpp b/src/Layers/xrRender/R_Backend_Runtime.cpp
@@ -126,7 +126,6 @@ void CBackend::Invalidate()
     // Redundant call. Just no note that we need to unmap const
     // if we create dedicated class.
     StateManager.UnmapConstants();
-    SSManager.ResetDeviceState();
     SRVSManager.ResetDeviceState();
 
     for (u32 gs_it = 0; gs_it < mtMaxGeometryShaderTextures;)
diff --git a/src/Layers/xrRenderDX10/StateManager/dx10SamplerStateCache.cpp b/src/Layers/xrRenderDX10/StateManager/dx10SamplerStateCache.cpp
@@ -10,7 +10,6 @@ dx10SamplerStateCache::dx10SamplerStateCache() : m_uiMaxAnisotropy(1)
 {
     static const int iMaxRSStates = 10;
     m_StateArray.reserve(iMaxRSStates);
-    ResetDeviceState();
 }
 
 dx10SamplerStateCache::~dx10SamplerStateCache() { ClearStateArray(); }
@@ -85,12 +84,8 @@ void dx10SamplerStateCache::ClearStateArray()
 }
 
 void dx10SamplerStateCache::PrepareSamplerStates(HArray& samplers,
-    ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT],
-    SHandle pCurrentState[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT], u32& uiMin, u32& uiMax) const
+    ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT]) const
 {
-    //	It seems that sizeof pSS is 4 wor win32!
-    ZeroMemory(pSS, sizeof(pSS[0]) * D3D_COMMONSHADER_SAMPLER_SLOT_COUNT);
-
     for (u32 i = 0; i < samplers.size(); ++i)
     {
         if (samplers[i] != hInvalidHandle)
@@ -99,64 +94,49 @@ void dx10SamplerStateCache::PrepareSamplerStates(HArray& samplers,
             pSS[i] = m_StateArray[samplers[i]].m_pState;
         }
     }
-
-    uiMin = 0;
-    uiMax = D3D_COMMONSHADER_SAMPLER_SLOT_COUNT - 1;
 }
 
 void dx10SamplerStateCache::VSApplySamplers(HArray& samplers)
 {
-    ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];
-    u32 uiMin;
-    u32 uiMax;
-    PrepareSamplerStates(samplers, pSS, m_aVSSamplers, uiMin, uiMax);
-    HW.pContext->VSSetSamplers(uiMin, uiMax - uiMin + 1, &pSS[uiMin]);
+    ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT] = { nullptr };
+    PrepareSamplerStates(samplers, pSS);
+    HW.pContext->VSSetSamplers(0, D3D_COMMONSHADER_SAMPLER_SLOT_COUNT, pSS);
 }
 
 void dx10SamplerStateCache::PSApplySamplers(HArray& samplers)
 {
-    ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];
-    u32 uiMin;
-    u32 uiMax;
-    PrepareSamplerStates(samplers, pSS, m_aPSSamplers, uiMin, uiMax);
-    HW.pContext->PSSetSamplers(uiMin, uiMax - uiMin + 1, &pSS[uiMin]);
+    ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT] = { nullptr };
+    PrepareSamplerStates(samplers, pSS);
+    HW.pContext->PSSetSamplers(0, D3D_COMMONSHADER_SAMPLER_SLOT_COUNT, pSS);
 }
 
 void dx10SamplerStateCache::GSApplySamplers(HArray& samplers)
 {
-    ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];
-    u32 uiMin;
-    u32 uiMax;
-    PrepareSamplerStates(samplers, pSS, m_aGSSamplers, uiMin, uiMax);
-    HW.pContext->GSSetSamplers(uiMin, uiMax - uiMin + 1, &pSS[uiMin]);
+    ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT] = { nullptr };
+    PrepareSamplerStates(samplers, pSS);
+    HW.pContext->GSSetSamplers(0, D3D_COMMONSHADER_SAMPLER_SLOT_COUNT, pSS);
 }
 
 #ifdef USE_DX11
 void dx10SamplerStateCache::HSApplySamplers(HArray& samplers)
 {
-    ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];
-    u32 uiMin;
-    u32 uiMax;
-    PrepareSamplerStates(samplers, pSS, m_aHSSamplers, uiMin, uiMax);
-    HW.pContext->HSSetSamplers(uiMin, uiMax - uiMin + 1, &pSS[uiMin]);
+    ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT] = { nullptr };
+    PrepareSamplerStates(samplers, pSS);
+    HW.pContext->HSSetSamplers(0, D3D_COMMONSHADER_SAMPLER_SLOT_COUNT, pSS);
 }
 
 void dx10SamplerStateCache::DSApplySamplers(HArray& samplers)
 {
-    ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];
-    u32 uiMin;
-    u32 uiMax;
-    PrepareSamplerStates(samplers, pSS, m_aDSSamplers, uiMin, uiMax);
-    HW.pContext->DSSetSamplers(uiMin, uiMax - uiMin + 1, &pSS[uiMin]);
+    ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT] = { nullptr };
+    PrepareSamplerStates(samplers, pSS);
+    HW.pContext->DSSetSamplers(0, D3D_COMMONSHADER_SAMPLER_SLOT_COUNT, pSS);
 }
 
 void dx10SamplerStateCache::CSApplySamplers(HArray& samplers)
 {
-    ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];
-    u32 uiMin;
-    u32 uiMax;
-    PrepareSamplerStates(samplers, pSS, m_aCSSamplers, uiMin, uiMax);
-    HW.pContext->CSSetSamplers(uiMin, uiMax - uiMin + 1, &pSS[uiMin]);
+    ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT] = { nullptr };
+    PrepareSamplerStates(samplers, pSS);
+    HW.pContext->CSSetSamplers(0, D3D_COMMONSHADER_SAMPLER_SLOT_COUNT, pSS);
 }
 #endif
 
@@ -188,18 +168,3 @@ void dx10SamplerStateCache::SetMaxAnisotropy(UINT uiMaxAniso)
         CreateState(desc, &rec.m_pState);
     }
 }
-
-void dx10SamplerStateCache::ResetDeviceState()
-{
-    for (int i = 0; i < sizeof(m_aPSSamplers) / sizeof(m_aPSSamplers[0]); ++i)
-    {
-        m_aPSSamplers[i] = (SHandle)hInvalidHandle;
-        m_aVSSamplers[i] = (SHandle)hInvalidHandle;
-        m_aGSSamplers[i] = (SHandle)hInvalidHandle;
-#ifdef USE_DX11
-        m_aHSSamplers[i] = (SHandle)hInvalidHandle;
-        m_aDSSamplers[i] = (SHandle)hInvalidHandle;
-        m_aCSSamplers[i] = (SHandle)hInvalidHandle;
-#endif
-    }
-}
diff --git a/src/Layers/xrRenderDX10/StateManager/dx10SamplerStateCache.h b/src/Layers/xrRenderDX10/StateManager/dx10SamplerStateCache.h
@@ -33,10 +33,6 @@ class dx10SamplerStateCache
 
     void SetMaxAnisotropy(UINT uiMaxAniso);
 
-    //	Marks all device sample as unused
-    void ResetDeviceState();
-
-    //	Private declarations
 private:
     typedef ID3DSamplerState IDeviceState;
     typedef D3D_SAMPLER_DESC StateDecs;
@@ -51,23 +47,13 @@ class dx10SamplerStateCache
     void CreateState(StateDecs desc, IDeviceState** ppIState);
     SHandle FindState(const StateDecs& desc, u32 StateCRC);
 
-    void PrepareSamplerStates(HArray& samplers, ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT],
-        SHandle pCurrentState[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT], u32& uiMin, u32& uiMax) const;
+    void PrepareSamplerStates(HArray& samplers, ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT]) const;
 
     //	Private data
 private:
     //	This must be cleared on device destroy
     xr_vector<StateRecord> m_StateArray;
 
-    SHandle m_aPSSamplers[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];
-    SHandle m_aVSSamplers[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];
-    SHandle m_aGSSamplers[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];
-#ifdef USE_DX11
-    SHandle m_aHSSamplers[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];
-    SHandle m_aDSSamplers[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];
-    SHandle m_aCSSamplers[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];
-#endif
-
     u32 m_uiMaxAnisotropy;
 };
 

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,6 @@ dx10SamplerStateCache::dx10SamplerStateCache() : m_uiMaxAnisotropy(1)`
`10`	`10`	`{`
`11`	`11`	`static const int iMaxRSStates = 10;`
`12`	`12`	`m_StateArray.reserve(iMaxRSStates);`
`13`		`- ResetDeviceState();`
`14`	`13`	`}`
`15`	`14`
`16`	`15`	`dx10SamplerStateCache::~dx10SamplerStateCache() { ClearStateArray(); }`
`@@ -85,12 +84,8 @@ void dx10SamplerStateCache::ClearStateArray()`
`85`	`84`	`}`
`86`	`85`
`87`	`86`	`void dx10SamplerStateCache::PrepareSamplerStates(HArray& samplers,`
`88`		`- ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT],`
`89`		`- SHandle pCurrentState[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT], u32& uiMin, u32& uiMax) const`
	`87`	`+ ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT]) const`
`90`	`88`	`{`
`91`		`- // It seems that sizeof pSS is 4 wor win32!`
`92`		`- ZeroMemory(pSS, sizeof(pSS[0]) * D3D_COMMONSHADER_SAMPLER_SLOT_COUNT);`
`93`		`-`
`94`	`89`	`for (u32 i = 0; i < samplers.size(); ++i)`
`95`	`90`	`{`
`96`	`91`	`if (samplers[i] != hInvalidHandle)`
`@@ -99,64 +94,49 @@ void dx10SamplerStateCache::PrepareSamplerStates(HArray& samplers,`
`99`	`94`	`pSS[i] = m_StateArray[samplers[i]].m_pState;`
`100`	`95`	`}`
`101`	`96`	`}`
`102`		`-`
`103`		`- uiMin = 0;`
`104`		`- uiMax = D3D_COMMONSHADER_SAMPLER_SLOT_COUNT - 1;`
`105`	`97`	`}`
`106`	`98`
`107`	`99`	`void dx10SamplerStateCache::VSApplySamplers(HArray& samplers)`
`108`	`100`	`{`
`109`		`- ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];`
`110`		`- u32 uiMin;`
`111`		`- u32 uiMax;`
`112`		`- PrepareSamplerStates(samplers, pSS, m_aVSSamplers, uiMin, uiMax);`
`113`		`- HW.pContext->VSSetSamplers(uiMin, uiMax - uiMin + 1, &pSS[uiMin]);`
	`101`	`+ ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT] = { nullptr };`
	`102`	`+ PrepareSamplerStates(samplers, pSS);`
	`103`	`+ HW.pContext->VSSetSamplers(0, D3D_COMMONSHADER_SAMPLER_SLOT_COUNT, pSS);`
`114`	`104`	`}`
`115`	`105`
`116`	`106`	`void dx10SamplerStateCache::PSApplySamplers(HArray& samplers)`
`117`	`107`	`{`
`118`		`- ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];`
`119`		`- u32 uiMin;`
`120`		`- u32 uiMax;`
`121`		`- PrepareSamplerStates(samplers, pSS, m_aPSSamplers, uiMin, uiMax);`
`122`		`- HW.pContext->PSSetSamplers(uiMin, uiMax - uiMin + 1, &pSS[uiMin]);`
	`108`	`+ ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT] = { nullptr };`
	`109`	`+ PrepareSamplerStates(samplers, pSS);`
	`110`	`+ HW.pContext->PSSetSamplers(0, D3D_COMMONSHADER_SAMPLER_SLOT_COUNT, pSS);`
`123`	`111`	`}`
`124`	`112`
`125`	`113`	`void dx10SamplerStateCache::GSApplySamplers(HArray& samplers)`
`126`	`114`	`{`
`127`		`- ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];`
`128`		`- u32 uiMin;`
`129`		`- u32 uiMax;`
`130`		`- PrepareSamplerStates(samplers, pSS, m_aGSSamplers, uiMin, uiMax);`
`131`		`- HW.pContext->GSSetSamplers(uiMin, uiMax - uiMin + 1, &pSS[uiMin]);`
	`115`	`+ ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT] = { nullptr };`
	`116`	`+ PrepareSamplerStates(samplers, pSS);`
	`117`	`+ HW.pContext->GSSetSamplers(0, D3D_COMMONSHADER_SAMPLER_SLOT_COUNT, pSS);`
`132`	`118`	`}`
`133`	`119`
`134`	`120`	`#ifdef USE_DX11`
`135`	`121`	`void dx10SamplerStateCache::HSApplySamplers(HArray& samplers)`
`136`	`122`	`{`
`137`		`- ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];`
`138`		`- u32 uiMin;`
`139`		`- u32 uiMax;`
`140`		`- PrepareSamplerStates(samplers, pSS, m_aHSSamplers, uiMin, uiMax);`
`141`		`- HW.pContext->HSSetSamplers(uiMin, uiMax - uiMin + 1, &pSS[uiMin]);`
	`123`	`+ ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT] = { nullptr };`
	`124`	`+ PrepareSamplerStates(samplers, pSS);`
	`125`	`+ HW.pContext->HSSetSamplers(0, D3D_COMMONSHADER_SAMPLER_SLOT_COUNT, pSS);`
`142`	`126`	`}`
`143`	`127`
`144`	`128`	`void dx10SamplerStateCache::DSApplySamplers(HArray& samplers)`
`145`	`129`	`{`
`146`		`- ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];`
`147`		`- u32 uiMin;`
`148`		`- u32 uiMax;`
`149`		`- PrepareSamplerStates(samplers, pSS, m_aDSSamplers, uiMin, uiMax);`
`150`		`- HW.pContext->DSSetSamplers(uiMin, uiMax - uiMin + 1, &pSS[uiMin]);`
	`130`	`+ ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT] = { nullptr };`
	`131`	`+ PrepareSamplerStates(samplers, pSS);`
	`132`	`+ HW.pContext->DSSetSamplers(0, D3D_COMMONSHADER_SAMPLER_SLOT_COUNT, pSS);`
`151`	`133`	`}`
`152`	`134`
`153`	`135`	`void dx10SamplerStateCache::CSApplySamplers(HArray& samplers)`
`154`	`136`	`{`
`155`		`- ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT];`
`156`		`- u32 uiMin;`
`157`		`- u32 uiMax;`
`158`		`- PrepareSamplerStates(samplers, pSS, m_aCSSamplers, uiMin, uiMax);`
`159`		`- HW.pContext->CSSetSamplers(uiMin, uiMax - uiMin + 1, &pSS[uiMin]);`
	`137`	`+ ID3DSamplerState* pSS[D3D_COMMONSHADER_SAMPLER_SLOT_COUNT] = { nullptr };`
	`138`	`+ PrepareSamplerStates(samplers, pSS);`
	`139`	`+ HW.pContext->CSSetSamplers(0, D3D_COMMONSHADER_SAMPLER_SLOT_COUNT, pSS);`
`160`	`140`	`}`
`161`	`141`	`#endif`
`162`	`142`
`@@ -188,18 +168,3 @@ void dx10SamplerStateCache::SetMaxAnisotropy(UINT uiMaxAniso)`
`188`	`168`	`CreateState(desc, &rec.m_pState);`
`189`	`169`	`}`
`190`	`170`	`}`
`191`		`-`
`192`		`-void dx10SamplerStateCache::ResetDeviceState()`
`193`		`-{`
`194`		`- for (int i = 0; i < sizeof(m_aPSSamplers) / sizeof(m_aPSSamplers[0]); ++i)`
`195`		`- {`
`196`		`- m_aPSSamplers[i] = (SHandle)hInvalidHandle;`
`197`		`- m_aVSSamplers[i] = (SHandle)hInvalidHandle;`
`198`		`- m_aGSSamplers[i] = (SHandle)hInvalidHandle;`
`199`		`-#ifdef USE_DX11`
`200`		`- m_aHSSamplers[i] = (SHandle)hInvalidHandle;`
`201`		`- m_aDSSamplers[i] = (SHandle)hInvalidHandle;`
`202`		`- m_aCSSamplers[i] = (SHandle)hInvalidHandle;`
`203`		`-#endif`
`204`		`- }`
`205`		`-}`