Skip to content

Commit 2f5bb62

Browse files
dnblank123dnblank123
committed
add more shaders
1 parent 3d86231 commit 2f5bb62

7 files changed

+673
-145
lines changed

‎.github/workflows/msbuild.yml

+1-1
Original file line numberDiff line numberDiff line change
@@ -39,6 +39,6 @@ jobs:
3939
- name: Upload a Build Artifact
4040
uses: actions/upload-artifact@v4
4141
with:
42-
name: ${{ matrix.configuration }}.dll
42+
name: ${{ matrix.configuration }}
4343
retention-days: 90
4444
path: .\x64\${{ matrix.configuration }}\d3d11.dll

‎Shaderbool.h

+2
Original file line numberDiff line numberDiff line change
@@ -9,3 +9,5 @@ bool Particle2B = false;
99
bool ShadowPlayerB = false;
1010
bool ShadowPropB = false;
1111
bool FragmentShadowB = false;
12+
bool TerrainB = false;
13+
bool DefaultB = false;

‎Shaders/Default.h

+277
Large diffs are not rendered by default.

‎Shaders/Terrain.h

+277
Large diffs are not rendered by default.

‎atelier-sync-fix.vcxproj

+2
Original file line numberDiff line numberDiff line change
@@ -110,10 +110,12 @@
110110
<ClInclude Include="impl.h" />
111111
<ClInclude Include="log.h" />
112112
<ClInclude Include="Shaderbool.h" />
113+
<ClInclude Include="Shaders\Default.h" />
113114
<ClInclude Include="Shaders\Grass.h" />
114115
<ClInclude Include="Shaders\Particle1.h" />
115116
<ClInclude Include="Shaders\RadialBlur.h" />
116117
<ClInclude Include="Shaders\Shadow.h" />
118+
<ClInclude Include="Shaders\Terrain.h" />
117119
<ClInclude Include="Shaders\Tex.h" />
118120
<ClInclude Include="Shaders\VolumeFog.h" />
119121
<ClInclude Include="util.h" />

‎atelier-sync-fix.vcxproj.filters

+6
Original file line numberDiff line numberDiff line change
@@ -39,6 +39,12 @@
3939
<Filter>Shaders</Filter>
4040
</ClInclude>
4141
<ClInclude Include="Shaderbool.h" />
42+
<ClInclude Include="Shaders\Default.h">
43+
<Filter>Shaders</Filter>
44+
</ClInclude>
45+
<ClInclude Include="Shaders\Terrain.h">
46+
<Filter>Shaders</Filter>
47+
</ClInclude>
4248
</ItemGroup>
4349
<ItemGroup>
4450
<None Include=".gitignore" />

‎impl.cpp

+108-144
Original file line numberDiff line numberDiff line change
@@ -4,10 +4,12 @@
44

55
#include "impl.h"
66
#include "Shaderbool.h"
7+
#include "Shaders/Default.h"
78
#include "Shaders/Grass.h"
89
#include "Shaders/Particle1.h"
910
#include "Shaders/RadialBlur.h"
1011
#include "Shaders/Shadow.h"
12+
#include "Shaders/Terrain.h"
1113
#include "Shaders/Tex.h"
1214
#include "Shaders/VolumeFog.h"
1315
#include "util.h"
@@ -48,72 +50,84 @@ HRESULT STDMETHODCALLTYPE ID3D11Device_CreateVertexShader(
4850
static constexpr std::array<uint32_t, 4> ParticleShader2 = { 0x003ca944, 0x7fb09127, 0xed8e5b6e, 0x4cbdd6e9 };
4951
static constexpr std::array<uint32_t, 4> VolumeFogShader = { 0xdf94514a, 0xbe2cf252, 0xf86fcdba, 0x640e1563 };
5052
static constexpr std::array<uint32_t, 4> GrassShader = { 0x5272db3c, 0xdc7a397a, 0xb7bf11d5, 0x078d9485 };
51-
static constexpr std::array<uint32_t, 4> ShadowPlayerShader = { 0xefbe9f94, 0x5c300015, 0x29ab6626, 0xb640836c };
52-
static constexpr std::array<uint32_t, 4> ShadowPropShader = { 0xe4c7cd57, 0xbc029e48, 0xabcb38c1, 0xeae68c10 };
53+
static constexpr std::array<uint32_t, 4> ShadowPlayerShader = { 0xe4c7cd57, 0xbc029e48, 0xabcb38c1, 0xeae68c10 };
54+
static constexpr std::array<uint32_t, 4> ShadowPropShader = { 0xefbe9f94, 0x5c300015, 0x29ab6626, 0xb640836c };
55+
static constexpr std::array<uint32_t, 4> TerrainShader = { 0xe0dfec90, 0xc8480b86, 0x20262b5d, 0xf0ace17e };
56+
static constexpr std::array<uint32_t, 4> DefaultShader = { 0x49d8396e, 0x5b9dfd57, 0xb4f45dba, 0xe6d8b741 };
5357

5458
const uint32_t* hash = reinterpret_cast<const uint32_t*>(reinterpret_cast<const uint8_t*>(pShaderBytecode) + 4);
5559

56-
__m128i hashVec = _mm_loadu_si128(reinterpret_cast<const __m128i*>(hash));
57-
58-
const __m128i Particle1 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(ParticleShader1.data()));
59-
const __m128i Particle2 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(ParticleShader2.data()));
60-
const __m128i VolumeFog = _mm_loadu_si128(reinterpret_cast<const __m128i*>(VolumeFogShader.data()));
61-
const __m128i Grass = _mm_loadu_si128(reinterpret_cast<const __m128i*>(GrassShader.data()));
62-
const __m128i Shadow1 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(ShadowPlayerShader.data()));
63-
const __m128i Shadow2 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(ShadowPropShader.data()));
64-
65-
__m128i cmp1 = _mm_cmpeq_epi32(hashVec, Particle1);
66-
__m128i cmp2 = _mm_cmpeq_epi32(hashVec, Particle2);
67-
__m128i cmp3 = _mm_cmpeq_epi32(hashVec, VolumeFog);
68-
__m128i cmp4 = _mm_cmpeq_epi32(hashVec, Grass);
69-
__m128i cmp5 = _mm_cmpeq_epi32(hashVec, Grass);
70-
__m128i cmp6 = _mm_cmpeq_epi32(hashVec, Grass);
71-
72-
int mask1 = _mm_movemask_ps(_mm_castsi128_ps(cmp1));
73-
int mask2 = _mm_movemask_ps(_mm_castsi128_ps(cmp2));
74-
int mask3 = _mm_movemask_ps(_mm_castsi128_ps(cmp3));
75-
int mask4 = _mm_movemask_ps(_mm_castsi128_ps(cmp4));
76-
int mask5 = _mm_movemask_ps(_mm_castsi128_ps(cmp5));
77-
int mask6 = _mm_movemask_ps(_mm_castsi128_ps(cmp6));
78-
79-
if (!Particle1B) {
80-
Particle1B = true;
81-
log("Particle found");
82-
} else if (!Particle2B) {
83-
Particle2B = true;
84-
log("Particle Iterate found");
85-
} else if (!VolumeFogB) {
86-
VolumeFogB = true;
87-
log("Volumefog found");
88-
} else if (!GrassB) {
89-
GrassB = true;
90-
log("Grass found");
91-
} else if (!ShadowPlayerB) {
92-
ShadowPlayerB = true;
93-
log("Shadow Player found");
94-
} else if (!ShadowPropB) {
95-
ShadowPropB = true;
96-
log("Shadow Prop found");
97-
}
60+
if (std::equal(ParticleShader1.begin(), ParticleShader1.end(), hash)) {
9861

99-
if (mask1) {
62+
if (!Particle1B) {
63+
Particle1B = true;
64+
log("Particle found");
65+
}
10066
return procs->CreateVertexShader(pDevice, FIXED_PARTICLE_SHADER1, sizeof(FIXED_PARTICLE_SHADER1), pClassLinkage, ppVertexShader);
101-
} else if (mask2) {
67+
68+
} else if (std::equal(ParticleShader2.begin(), ParticleShader2.end(), hash)) {
69+
70+
if (!Particle2B) {
71+
Particle2B = true;
72+
log("Particle Iterate found");
73+
}
10274
return procs->CreateVertexShader(pDevice, FIXED_PARTICLE_SHADER2, sizeof(FIXED_PARTICLE_SHADER2), pClassLinkage, ppVertexShader);
103-
} else if (mask3) {
75+
76+
}
77+
#ifndef RELEASELOW
78+
else if (std::equal(VolumeFogShader.begin(), VolumeFogShader.end(), hash)) {
79+
80+
if (!VolumeFogB) {
81+
VolumeFogB = true;
82+
log("Volumefog found");
83+
}
10484
return procs->CreateVertexShader(pDevice, NO_VOLUMEFOG_SHADER, sizeof(NO_VOLUMEFOG_SHADER), pClassLinkage, ppVertexShader);
105-
} else if (mask4) {
85+
86+
} else if (std::equal(GrassShader.begin(), GrassShader.end(), hash)) {
87+
88+
if (!GrassB) {
89+
GrassB = true;
90+
log("Grass found");
91+
}
10692
return procs->CreateVertexShader(pDevice, SIMPLIFIED_VS_GRASS_SHADER, sizeof(SIMPLIFIED_VS_GRASS_SHADER), pClassLinkage, ppVertexShader);
107-
} else if (mask5) {
108-
#ifndef RELEASELOW
109-
return procs->CreateVertexShader(pDevice, FIXED_PLAYER_SHADOW_SHADER, sizeof(FIXED_PLAYER_SHADOW_SHADER), pClassLinkage, ppVertexShader);
110-
#else
93+
94+
} else if (std::equal(ShadowPlayerShader.begin(), ShadowPlayerShader.end(), hash)) {
95+
96+
if (!ShadowPlayerB) {
97+
ShadowPlayerB = true;
98+
log("Shadow Player found");
99+
}
111100
return procs->CreateVertexShader(pDevice, FIXED_PLAYER_SHADOW_SHADER, sizeof(FIXED_PLAYER_SHADOW_SHADER), pClassLinkage, ppVertexShader);
112-
#endif
113-
} else if (mask6) {
101+
102+
} else if (std::equal(ShadowPropShader.begin(), ShadowPropShader.end(), hash)) {
103+
104+
if (!ShadowPropB) {
105+
ShadowPropB = true;
106+
log("Shadow Prop found");
107+
}
114108
return procs->CreateVertexShader(pDevice, FIXED_PROP_SHADOW_SHADER, sizeof(FIXED_PROP_SHADOW_SHADER), pClassLinkage, ppVertexShader);
115-
}
116109

110+
}
111+
#else
112+
else if (std::equal(TerrainShader.begin(), TerrainShader.end(), hash)) {
113+
114+
if (!TerrainB) {
115+
TerrainB = true;
116+
log("Terrain found");
117+
}
118+
return procs->CreateVertexShader(pDevice, FIXED_PROP_SHADOW_SHADER, sizeof(FIXED_PROP_SHADOW_SHADER), pClassLinkage, ppVertexShader);
119+
120+
}
121+
else if (std::equal(DefaultShader.begin(), DefaultShader.end(), hash)) {
122+
123+
if (!DefaultB) {
124+
DefaultB = true;
125+
log("Default found");
126+
}
127+
return procs->CreateVertexShader(pDevice, SIMPLIFIED_VS_DEFAULT_SHADER, sizeof(SIMPLIFIED_VS_DEFAULT_SHADER), pClassLinkage, ppVertexShader);
128+
129+
}
130+
#endif
117131
return procs->CreateVertexShader(pDevice, pShaderBytecode, BytecodeLength, pClassLinkage, ppVertexShader);
118132
}
119133

@@ -129,47 +143,49 @@ HRESULT STDMETHODCALLTYPE ID3D11Device_CreatePixelShader(
129143
static constexpr std::array<uint32_t, 4> RadialShader = { 0xcf3dfb4b, 0x6c82c337, 0xec6459ee, 0x0a2b4c01 };
130144
static constexpr std::array<uint32_t, 4> GrassShader = { 0xb2f29488, 0x210994ca, 0x07510660, 0x301d1575 };
131145
static constexpr std::array<uint32_t, 4> ShadowShader = { 0xbb5a2d0a, 0x29d139b7, 0x40992005, 0xf3b46588 };
146+
static constexpr std::array<uint32_t, 4> TerrainShader = { 0x74a9f538, 0x75cb0ce6, 0x3da09498, 0x7bc641bd };
147+
static constexpr std::array<uint32_t, 4> DefaultShader = { 0x5cbbb737, 0x265384da, 0x36d6d037, 0x1b052f54d };
132148

133149
const uint32_t* hash = reinterpret_cast<const uint32_t*>(reinterpret_cast<const uint8_t*>(pShaderBytecode) + 4);
134150

135-
__m128i hashVec = _mm_loadu_si128(reinterpret_cast<const __m128i*>(hash));
136-
137-
const __m128i Tex = _mm_loadu_si128(reinterpret_cast<const __m128i*>(TexShader.data()));
138-
const __m128i Radial = _mm_loadu_si128(reinterpret_cast<const __m128i*>(RadialShader.data()));
139-
const __m128i Grass = _mm_loadu_si128(reinterpret_cast<const __m128i*>(GrassShader.data()));
140-
const __m128i ShadowFrag = _mm_loadu_si128(reinterpret_cast<const __m128i*>(ShadowShader.data()));
141-
142-
__m128i cmp1 = _mm_cmpeq_epi32(hashVec, Tex);
143-
__m128i cmp2 = _mm_cmpeq_epi32(hashVec, Radial);
144-
__m128i cmp3 = _mm_cmpeq_epi32(hashVec, Grass);
145-
__m128i cmp4 = _mm_cmpeq_epi32(hashVec, ShadowFrag);
146-
147-
int mask1 = _mm_movemask_ps(_mm_castsi128_ps(cmp1));
148-
int mask2 = _mm_movemask_ps(_mm_castsi128_ps(cmp2));
149-
int mask3 = _mm_movemask_ps(_mm_castsi128_ps(cmp3));
150-
int mask4 = _mm_movemask_ps(_mm_castsi128_ps(cmp4));
151-
152-
if (!DiffVolTexB) {
153-
DiffVolTexB = true;
154-
log("DiffVolTex found");
155-
} else if (!RadialBlurB) {
156-
RadialBlurB = true;
157-
log("RadialBlur found");
158-
} else if (!FragmentShadowB) {
159-
FragmentShadowB = true;
160-
log("Fragment Shadow found");
161-
}
162151

163-
if (mask1) {
152+
if (std::equal(TexShader.begin(), TexShader.end(), hash)) {
153+
154+
if (!DiffVolTexB) {
155+
DiffVolTexB = true;
156+
log("DiffVolTex found");
157+
}
164158
return procs->CreatePixelShader(pDevice, SIMPLIFIED_TEX_SHADER, sizeof(SIMPLIFIED_TEX_SHADER), pClassLinkage, ppPixelShader);
165-
} else if (mask2) {
159+
160+
}
161+
#ifndef RELEASELOW
162+
else if (std::equal(RadialShader.begin(), RadialShader.end(), hash)) {
163+
164+
if (!RadialBlurB) {
165+
RadialBlurB = true;
166+
log("RadialBlur found");
167+
}
166168
return procs->CreatePixelShader(pDevice, NO_RADIALBLUR_SHADER, sizeof(NO_RADIALBLUR_SHADER), pClassLinkage, ppPixelShader);
167-
} else if (mask3) {
169+
170+
} else if (std::equal(GrassShader.begin(), GrassShader.end(), hash)) {
171+
168172
return procs->CreatePixelShader(pDevice, SIMPLIFIED_FS_GRASS_SHADER, sizeof(SIMPLIFIED_FS_GRASS_SHADER), pClassLinkage, ppPixelShader);
169-
} else if (mask4) {
173+
174+
} else if (std::equal(ShadowShader.begin(), ShadowShader.end(), hash)) {
175+
176+
if (!FragmentShadowB) {
177+
FragmentShadowB = true;
178+
log("Fragment Shadow found");
179+
}
170180
return procs->CreatePixelShader(pDevice, SIMPLIFIED_FS_SHADOW_SHADER, sizeof(SIMPLIFIED_FS_SHADOW_SHADER), pClassLinkage, ppPixelShader);
181+
171182
}
183+
#else
184+
else if (std::equal(DefaultShader.begin(), DefaultShader.end(), hash)) {
172185

186+
return procs->CreatePixelShader(pDevice, SIMPLIFIED_FS_DEFAULT_SHADER, sizeof(SIMPLIFIED_FS_DEFAULT_SHADER), pClassLinkage, ppPixelShader);
187+
}
188+
#endif
173189
return procs->CreatePixelShader(pDevice, pShaderBytecode, BytecodeLength, pClassLinkage, ppPixelShader);
174190
}
175191

@@ -365,64 +381,12 @@ class ContextWrapper final : public ID3D11DeviceContext {
365381
void ClearUnorderedAccessViewFloat(ID3D11UnorderedAccessView* pUAV, const FLOAT pColor[4]) override { ctx->ClearUnorderedAccessViewFloat(pUAV, pColor); }
366382
void ClearUnorderedAccessViewUint(ID3D11UnorderedAccessView* pUAV, const UINT pColor[4]) override { ctx->ClearUnorderedAccessViewUint(pUAV, pColor); }
367383
void CopyResource(ID3D11Resource* pDstResource, ID3D11Resource* pSrcResource) override { ctx->CopyResource(pDstResource, pSrcResource); }
368-
void CopySubresourceRegion(
369-
ID3D11Resource* pDstResource,
370-
UINT DstSubresource,
371-
UINT DstX,
372-
UINT DstY,
373-
UINT DstZ,
374-
ID3D11Resource* pSrcResource,
375-
UINT SrcSubresource,
376-
const D3D11_BOX* pSrcBox) override {
377-
378-
ctx->CopySubresourceRegion(
379-
pDstResource, DstSubresource, DstX, DstY, DstZ,
380-
pSrcResource, SrcSubresource, pSrcBox);
381-
}
382-
383-
void Dispatch(
384-
UINT X,
385-
UINT Y,
386-
UINT Z) override {
387-
ctx->Dispatch(X, Y, Z);
388-
}
389-
390-
void DispatchIndirect(
391-
ID3D11Buffer* pParameterBuffer,
392-
UINT pParameterOffset) override {
393-
ctx->DispatchIndirect(pParameterBuffer, pParameterOffset);
394-
}
395-
396-
void OMSetRenderTargets(
397-
UINT RTVCount,
398-
ID3D11RenderTargetView* const* ppRTVs,
399-
ID3D11DepthStencilView* pDSV) override {
400-
ctx->OMSetRenderTargets(RTVCount, ppRTVs, pDSV);
401-
}
402-
403-
void OMSetRenderTargetsAndUnorderedAccessViews(
404-
UINT RTVCount,
405-
ID3D11RenderTargetView* const* ppRTVs,
406-
ID3D11DepthStencilView* pDSV,
407-
UINT UAVIndex,
408-
UINT UAVCount,
409-
ID3D11UnorderedAccessView* const* ppUAVs,
410-
const UINT* pUAVClearValues) override {
411-
ctx->OMSetRenderTargetsAndUnorderedAccessViews(
412-
RTVCount, ppRTVs, pDSV, UAVIndex, UAVCount, ppUAVs, pUAVClearValues);
413-
}
414-
415-
void UpdateSubresource(
416-
ID3D11Resource* pResource,
417-
UINT Subresource,
418-
const D3D11_BOX* pBox,
419-
const void* pData,
420-
UINT RowPitch,
421-
UINT SlicePitch) override {
422-
ctx->UpdateSubresource(
423-
pResource, Subresource, pBox, pData, RowPitch, SlicePitch);
424-
425-
}
384+
void CopySubresourceRegion(ID3D11Resource* pDstResource, UINT DstSubresource, UINT DstX, UINT DstY, UINT DstZ, ID3D11Resource* pSrcResource, UINT SrcSubresource, const D3D11_BOX* pSrcBox) override { ctx->CopySubresourceRegion(pDstResource, DstSubresource, DstX, DstY, DstZ, pSrcResource, SrcSubresource, pSrcBox); }
385+
void Dispatch(UINT X, UINT Y, UINT Z) override { ctx->Dispatch(X, Y, Z); }
386+
void DispatchIndirect(ID3D11Buffer* pParameterBuffer, UINT pParameterOffset) override { ctx->DispatchIndirect(pParameterBuffer, pParameterOffset); }
387+
void OMSetRenderTargets(UINT RTVCount, ID3D11RenderTargetView* const* ppRTVs, ID3D11DepthStencilView* pDSV) override { ctx->OMSetRenderTargets(RTVCount, ppRTVs, pDSV); }
388+
void OMSetRenderTargetsAndUnorderedAccessViews(UINT RTVCount, ID3D11RenderTargetView* const* ppRTVs, ID3D11DepthStencilView* pDSV, UINT UAVIndex, UINT UAVCount, ID3D11UnorderedAccessView* const* ppUAVs, const UINT* pUAVClearValues) override { ctx->OMSetRenderTargetsAndUnorderedAccessViews( RTVCount, ppRTVs, pDSV, UAVIndex, UAVCount, ppUAVs, pUAVClearValues); }
389+
void UpdateSubresource(ID3D11Resource* pResource, UINT Subresource, const D3D11_BOX* pBox, const void* pData, UINT RowPitch, UINT SlicePitch) override { ctx->UpdateSubresource( pResource, Subresource, pBox, pData, RowPitch, SlicePitch); }
426390
};
427391

428392
ID3D11DeviceContext* hookContext(ID3D11DeviceContext* pContext) {

0 commit comments

Comments
 (0)