diff options
Diffstat (limited to 'Test/vk.relaxed.stagelink.0.2.vert')
| -rwxr-xr-x | Test/vk.relaxed.stagelink.0.2.vert | 320 |
1 files changed, 320 insertions, 0 deletions
diff --git a/Test/vk.relaxed.stagelink.0.2.vert b/Test/vk.relaxed.stagelink.0.2.vert new file mode 100755 index 00000000..69c0b21b --- /dev/null +++ b/Test/vk.relaxed.stagelink.0.2.vert @@ -0,0 +1,320 @@ +#version 460
+uniform int uTDInstanceIDOffset;
+uniform int uTDNumInstances;
+uniform float uTDAlphaTestVal;
+#define TD_NUM_COLOR_BUFFERS 1
+#define TD_NUM_LIGHTS 0
+#define TD_NUM_SHADOWED_LIGHTS 0
+#define TD_NUM_ENV_LIGHTS 0
+#define TD_LIGHTS_ARRAY_SIZE 1
+#define TD_ENV_LIGHTS_ARRAY_SIZE 1
+#define TD_NUM_CAMERAS 1
+struct TDLight
+{
+ vec4 position;
+ vec3 direction;
+ vec3 diffuse;
+ vec4 nearFar;
+ vec4 lightSize;
+ vec4 misc;
+ vec4 coneLookupScaleBias;
+ vec4 attenScaleBiasRoll;
+ mat4 shadowMapMatrix;
+ mat4 shadowMapCamMatrix;
+ vec4 shadowMapRes;
+ mat4 projMapMatrix;
+};
+struct TDEnvLight
+{
+ vec3 color;
+ mat3 rotate;
+};
+layout(std140) uniform TDLightBlock
+{
+ TDLight uTDLights[TD_LIGHTS_ARRAY_SIZE];
+};
+layout(std140) uniform TDEnvLightBlock
+{
+ TDEnvLight uTDEnvLights[TD_ENV_LIGHTS_ARRAY_SIZE];
+};
+layout(std430) readonly restrict buffer TDEnvLightBuffer
+{
+ vec3 shCoeffs[9];
+} uTDEnvLightBuffers[TD_ENV_LIGHTS_ARRAY_SIZE];
+struct TDPhongResult
+{
+ vec3 diffuse;
+ vec3 specular;
+ vec3 specular2;
+ float shadowStrength;
+};
+struct TDPBRResult
+{
+ vec3 diffuse;
+ vec3 specular;
+ float shadowStrength;
+};
+struct TDMatrix
+{
+ mat4 world;
+ mat4 worldInverse;
+ mat4 worldCam;
+ mat4 worldCamInverse;
+ mat4 cam;
+ mat4 camInverse;
+ mat4 camProj;
+ mat4 camProjInverse;
+ mat4 proj;
+ mat4 projInverse;
+ mat4 worldCamProj;
+ mat4 worldCamProjInverse;
+ mat4 quadReproject;
+ mat3 worldForNormals;
+ mat3 camForNormals;
+ mat3 worldCamForNormals;
+};
+layout(std140) uniform TDMatricesBlock {
+ TDMatrix uTDMats[TD_NUM_CAMERAS];
+};
+struct TDCameraInfo
+{
+ vec4 nearFar;
+ vec4 fog;
+ vec4 fogColor;
+ int renderTOPCameraIndex;
+};
+layout(std140) uniform TDCameraInfoBlock {
+ TDCameraInfo uTDCamInfos[TD_NUM_CAMERAS];
+};
+struct TDGeneral
+{
+ vec4 ambientColor;
+ vec4 nearFar;
+ vec4 viewport;
+ vec4 viewportRes;
+ vec4 fog;
+ vec4 fogColor;
+};
+layout(std140) uniform TDGeneralBlock {
+ TDGeneral uTDGeneral;
+};
+
+layout(binding = 15) uniform samplerBuffer sTDInstanceT;
+layout(binding = 16) uniform samplerBuffer sTDInstanceTexCoord;
+layout(binding = 17) uniform samplerBuffer sTDInstanceColor;
+#define TD_NUM_BONES 0
+vec4 TDWorldToProj(vec4 v);
+vec4 TDWorldToProj(vec3 v);
+vec4 TDWorldToProj(vec4 v, vec3 uv);
+vec4 TDWorldToProj(vec3 v, vec3 uv);
+int TDPickID();
+int TDInstanceID();
+int TDCameraIndex();
+vec3 TDUVUnwrapCoord();
+vec3 TDInstanceTexCoord(int index, vec3 t) {
+ vec3 v;
+ int coord = index;
+ vec4 samp = texelFetch(sTDInstanceTexCoord, coord);
+ v[0] = t.s;
+ v[1] = t.t;
+ v[2] = samp[0];
+ t.stp = v.stp;
+ return t;
+}
+bool TDInstanceActive(int index) {
+ index -= uTDInstanceIDOffset;
+ float v;
+ int coord = index;
+ vec4 samp = texelFetch(sTDInstanceT, coord);
+ v = samp[0];
+ return v != 0.0;
+}
+vec3 iTDInstanceTranslate(int index, out bool instanceActive) {
+ int origIndex = index;
+ index -= uTDInstanceIDOffset;
+ vec3 v;
+ int coord = index;
+ vec4 samp = texelFetch(sTDInstanceT, coord);
+ v[0] = samp[1];
+ v[1] = samp[2];
+ v[2] = samp[3];
+ instanceActive = samp[0] != 0.0;
+ return v;
+}
+vec3 TDInstanceTranslate(int index) {
+ index -= uTDInstanceIDOffset;
+ vec3 v;
+ int coord = index;
+ vec4 samp = texelFetch(sTDInstanceT, coord);
+ v[0] = samp[1];
+ v[1] = samp[2];
+ v[2] = samp[3];
+ return v;
+}
+mat3 TDInstanceRotateMat(int index) {
+ index -= uTDInstanceIDOffset;
+ vec3 v = vec3(0.0, 0.0, 0.0);
+ mat3 m = mat3(1.0);
+{
+ mat3 r;
+}
+ return m;
+}
+vec3 TDInstanceScale(int index) {
+ index -= uTDInstanceIDOffset;
+ vec3 v = vec3(1.0, 1.0, 1.0);
+ return v;
+}
+vec3 TDInstancePivot(int index) {
+ index -= uTDInstanceIDOffset;
+ vec3 v = vec3(0.0, 0.0, 0.0);
+ return v;
+}
+vec3 TDInstanceRotTo(int index) {
+ index -= uTDInstanceIDOffset;
+ vec3 v = vec3(0.0, 0.0, 1.0);
+ return v;
+}
+vec3 TDInstanceRotUp(int index) {
+ index -= uTDInstanceIDOffset;
+ vec3 v = vec3(0.0, 1.0, 0.0);
+ return v;
+}
+mat4 TDInstanceMat(int id) {
+ bool instanceActive = true;
+ vec3 t = iTDInstanceTranslate(id, instanceActive);
+ if (!instanceActive)
+ {
+ return mat4(0.0);
+ }
+ mat4 m = mat4(1.0);
+ {
+ vec3 tt = t;
+ m[3][0] += m[0][0]*tt.x;
+ m[3][1] += m[0][1]*tt.x;
+ m[3][2] += m[0][2]*tt.x;
+ m[3][3] += m[0][3]*tt.x;
+ m[3][0] += m[1][0]*tt.y;
+ m[3][1] += m[1][1]*tt.y;
+ m[3][2] += m[1][2]*tt.y;
+ m[3][3] += m[1][3]*tt.y;
+ m[3][0] += m[2][0]*tt.z;
+ m[3][1] += m[2][1]*tt.z;
+ m[3][2] += m[2][2]*tt.z;
+ m[3][3] += m[2][3]*tt.z;
+ }
+ return m;
+}
+mat3 TDInstanceMat3(int id) {
+ mat3 m = mat3(1.0);
+ return m;
+}
+mat3 TDInstanceMat3ForNorm(int id) {
+ mat3 m = TDInstanceMat3(id);
+ return m;
+}
+vec4 TDInstanceColor(int index, vec4 curColor) {
+ index -= uTDInstanceIDOffset;
+ vec4 v;
+ int coord = index;
+ vec4 samp = texelFetch(sTDInstanceColor, coord);
+ v[0] = samp[0];
+ v[1] = samp[1];
+ v[2] = samp[2];
+ v[3] = 1.0;
+ curColor[0] = v[0];
+;
+ curColor[1] = v[1];
+;
+ curColor[2] = v[2];
+;
+ return curColor;
+}
+vec4 TDInstanceDeform(int id, vec4 pos) {
+ pos = TDInstanceMat(id) * pos;
+ return uTDMats[TDCameraIndex()].world * pos;
+}
+
+vec3 TDInstanceDeformVec(int id, vec3 vec)
+{
+ mat3 m = TDInstanceMat3(id);
+ return mat3(uTDMats[TDCameraIndex()].world) * (m * vec);
+}
+vec3 TDInstanceDeformNorm(int id, vec3 vec)
+{
+ mat3 m = TDInstanceMat3ForNorm(id);
+ return mat3(uTDMats[TDCameraIndex()].worldForNormals) * (m * vec);
+}
+vec4 TDInstanceDeform(vec4 pos) {
+ return TDInstanceDeform(TDInstanceID(), pos);
+}
+vec3 TDInstanceDeformVec(vec3 vec) {
+ return TDInstanceDeformVec(TDInstanceID(), vec);
+}
+vec3 TDInstanceDeformNorm(vec3 vec) {
+ return TDInstanceDeformNorm(TDInstanceID(), vec);
+}
+bool TDInstanceActive() { return TDInstanceActive(TDInstanceID()); }
+vec3 TDInstanceTranslate() { return TDInstanceTranslate(TDInstanceID()); }
+mat3 TDInstanceRotateMat() { return TDInstanceRotateMat(TDInstanceID()); }
+vec3 TDInstanceScale() { return TDInstanceScale(TDInstanceID()); }
+mat4 TDInstanceMat() { return TDInstanceMat(TDInstanceID());
+ }
+mat3 TDInstanceMat3() { return TDInstanceMat3(TDInstanceID());
+}
+vec3 TDInstanceTexCoord(vec3 t) {
+ return TDInstanceTexCoord(TDInstanceID(), t);
+}
+vec4 TDInstanceColor(vec4 curColor) {
+ return TDInstanceColor(TDInstanceID(), curColor);
+}
+vec4 TDSkinnedDeform(vec4 pos) { return pos; }
+
+vec3 TDSkinnedDeformVec(vec3 vec) { return vec; }
+
+vec3 TDFastDeformTangent(vec3 oldNorm, vec4 oldTangent, vec3 deformedNorm)
+{ return oldTangent.xyz; }
+mat4 TDBoneMat(int index) {
+ return mat4(1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1);
+}
+vec4 TDDeform(vec4 pos) {
+ pos = TDSkinnedDeform(pos);
+ pos = TDInstanceDeform(pos);
+ return pos;
+}
+
+vec4 TDDeform(int instanceID, vec3 p) {
+ vec4 pos = vec4(p, 1.0);
+ pos = TDSkinnedDeform(pos);
+ pos = TDInstanceDeform(instanceID, pos);
+ return pos;
+}
+
+vec4 TDDeform(vec3 pos) {
+ return TDDeform(TDInstanceID(), pos);
+}
+
+vec3 TDDeformVec(int instanceID, vec3 vec) {
+ vec = TDSkinnedDeformVec(vec);
+ vec = TDInstanceDeformVec(instanceID, vec);
+ return vec;
+}
+
+vec3 TDDeformVec(vec3 vec) {
+ return TDDeformVec(TDInstanceID(), vec);
+}
+
+vec3 TDDeformNorm(int instanceID, vec3 vec) {
+ vec = TDSkinnedDeformVec(vec);
+ vec = TDInstanceDeformNorm(instanceID, vec);
+ return vec;
+}
+
+vec3 TDDeformNorm(vec3 vec) {
+ return TDDeformNorm(TDInstanceID(), vec);
+}
+
+vec3 TDSkinnedDeformNorm(vec3 vec) {
+ vec = TDSkinnedDeformVec(vec);
+ return vec;
+}
|