yum-mirror/glslang

git clone https://git.yummers.dev/yum-mirror/glslang

Arcady Goldmints-OrlovRemove execute permissions from source files.5398d55e2024-08-06

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