mirror of
https://github.com/KhronosGroup/glslang
synced 2024-11-08 11:30:06 +00:00
321 lines
7.3 KiB
GLSL
321 lines
7.3 KiB
GLSL
#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;
|
|
}
|