| #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; | |
| } |