SamplerState samp[8] : register(s0);
Texture2DArray Tex[16] : register(t0);

int4 CHK_O_U8(int4 x)
{
	return x & 255;
}
#define BOR(x, n) ((x) | (n))
#define BSHR(x, n) ((x) >> (n))
int2 BSH(int2 x, int n)
{
	if(n >= 0)
	{
		return x >> n;
	}
	else
	{
		return x << (-n);
	}
}
int remainder(int x, int y)
{
	return x % y;
}
// dot product for integer vectors
int idot(int3 x, int3 y)
{
	int3 tmp = x * y;
	return tmp.x + tmp.y + tmp.z;
}
int idot(int4 x, int4 y)
{
	int4 tmp = x * y;
	return tmp.x + tmp.y + tmp.z + tmp.w;
}
// rounding + casting to integer at once in a single function
int  wuround(float  x) { return int(round(x)); }
int2 wuround(float2 x) { return int2(round(x)); }
int3 wuround(float3 x) { return int3(round(x)); }
int4 wuround(float4 x) { return int4(round(x)); }
cbuffer TSBlock : register(b0) {
	float4 ctess;
	int4 ccullp;
};
cbuffer VSBlock : register(b1) {
	float4 cproj[4];
	float4 cDepth;
	float4 cViewport;
};
cbuffer PSBlock : register(b2) {
	int4 color[4];
	int4 knst[4];
	int4 alphaRef;
	float4 texdim[8];
	int4 czbias[2];
	int4 cindscale[2];
	int4 cindmtx[6];
	int4 cfogcolor;
	int4 cfogi;
	float4 cfogf[2];
	float4 czslope;
	int4 cflags;
	float4 cefbscale;
};
struct VS_OUTPUT {
	float4 pos : SV_Position;
	float4 colors_0 : COLOR0;
	float4 colors_1 : COLOR1;
	float4 clipPos : TEXCOORD0;
	float4 Normal : TEXCOORD1;
	float2 clipDist : SV_ClipDistance0;
};
struct ConstantOutput
{
float EFactor[3] : SV_TessFactor;
float InsideFactor : SV_InsideTessFactor;
float4 edgesize : TEXCOORD0;
float4 Normal[3]: TEXCOORD1;
};

struct HSOutput
{
	float4 pos: BEZIERPOS;
	float4 colors_0: COLOR0;
	float4 colors_1: COLOR1;
	float2 clipDist: TANGENT;
};

[domain("tri")]
[partitioning("fractional_even")]
[outputtopology("triangle_cw")]
[outputcontrolpoints(3)]
[patchconstantfunc("TConstFunc")]
HSOutput HS_TFO(InputPatch<VS_OUTPUT, 3> patch, uint id : SV_OutputControlPointID,uint patchID : SV_PrimitiveID)
{
HSOutput result = (HSOutput)0;
result.pos = float4(patch[id].clipPos.x,patch[id].clipPos.y,patch[id].Normal.w, 1.0);
result.colors_0 = patch[id].colors_0;
result.colors_1 = patch[id].colors_1;
result.clipDist = patch[id].clipDist;
return result;
}


float GetScreenSize(float3 Origin, float Diameter)
{
    float w = dot(cproj[3], float4( Origin, 1.0 ));
    return abs(Diameter * cproj[1].y / w);
}

float CalcTessFactor(float3 Origin, float Diameter)
{
	float distance = 1.0 - saturate(length(Origin) * ctess.x);
	distance = distance * distance;
	return round(max(4.0,ctess.y * GetScreenSize(Origin,Diameter) * distance));
}
ConstantOutput TConstFunc(InputPatch<VS_OUTPUT, 3> patch)
{
ConstantOutput result = (ConstantOutput)0;
if (ccullp.y != 0) {
float3 spos0 = patch[0].pos.xyz / patch[0].pos.w;
float3 spos1 = patch[1].pos.xyz / patch[1].pos.w;
float3 spos2 = patch[2].pos.xyz / patch[2].pos.w;
float3 posmax = max(max(spos0, spos1), spos2);
float3 posmin = min(min(spos0, spos1), spos2);
if (
(posmin.x > 1.5 || posmax.x < -1.5 || posmin.y > 1.5 || posmax.y < -1.5 || posmin.z > 1.5 || posmax.z < -0.5))
{
result.EFactor[0] = 0;
result.EFactor[1] = 0;
result.EFactor[2] = 0;
result.InsideFactor = 0;
return result; // culled, so no further processing
}
}
float4 pos[3];
[unroll]
for(int i = 0; i < 3; i++)
{
pos[i] = float4(patch[i].clipPos.x,patch[i].clipPos.y,patch[i].Normal.w, 1.0);
result.Normal[i] = patch[i].Normal;
}
float3 edge0 = pos[1].xyz - pos[0].xyz;
float3 edge2 = pos[2].xyz - pos[0].xyz;
float3 faceNormal = normalize(cross(edge2, edge0));
if (ccullp.x != 0) {
float3 view = normalize(-pos[0].xyz);
float visibility = dot(view, faceNormal);
bool notvisible = ccullp.x < 0 ? (visibility < -0.25) : (visibility > 0.25);
if (notvisible) {
result.EFactor[0] = 0;
result.EFactor[1] = 0;
result.EFactor[2] = 0;
result.InsideFactor = 0;
return result; // culled, so no further processing
}
}
float l0 = distance(pos[1].xyz,pos[2].xyz);
float l1 = distance(pos[2].xyz,pos[0].xyz);
float l2 = distance(pos[0].xyz,pos[1].xyz);
result.edgesize = float4(l0, l1, l2, 1.0);
result.EFactor[0] = CalcTessFactor((pos[1].xyz+pos[2].xyz) * 0.5, l0);
result.EFactor[1] = CalcTessFactor((pos[2].xyz+pos[0].xyz) * 0.5, l1);
result.EFactor[2] = CalcTessFactor((pos[0].xyz+pos[1].xyz) * 0.5, l2);
result.InsideFactor = (result.EFactor[0] + result.EFactor[1] + result.EFactor[2]) / 3;
return result;
};

float3 PrjToPlane(float3 planeNormal, float3 planePoint, float3 pointToProject)
{
return pointToProject - dot(pointToProject-planePoint, planeNormal) * planeNormal;
}

float BInterpolate(float v0, float v1, float v2, float3 barycentric)
{
return barycentric.z * v0 + barycentric.x * v1 + barycentric.y * v2;
}

float2 BInterpolate(float2 v0, float2 v1, float2 v2, float3 barycentric)
{
return barycentric.z * v0 + barycentric.x * v1 + barycentric.y * v2;
}

float2 BInterpolate(float2 v[3], float3 barycentric)
{
return BInterpolate(v[0], v[1], v[2], barycentric);
}

float3 BInterpolate(float3 v0, float3 v1, float3 v2, float3 barycentric)
{
return barycentric.z * v0 + barycentric.x * v1 + barycentric.y * v2;
}

float3 BInterpolate(float3 v[3], float3 barycentric)
{
return BInterpolate(v[0], v[1], v[2], barycentric);
}

float4 BInterpolate(float4 v0, float4 v1, float4 v2, float3 barycentric)
{
return barycentric.z * v0 + barycentric.x * v1 + barycentric.y * v2;
}

float4 BInterpolate(float4 v[3], float3 barycentric)
{
return BInterpolate(v[0], v[1], v[2], barycentric);
}

[domain("tri")]
VS_OUTPUT DS_TFO(ConstantOutput pconstans, const OutputPatch<HSOutput, 3> patch, float3 bCoords : SV_DomainLocation )
{
VS_OUTPUT result = (VS_OUTPUT)0;
float displacement = 0.0, displacementcount = 0.0, borderdistance = bCoords.x * bCoords.y * bCoords.z;
int3 tevcoord=int3(0,0,0);
int2 wrappedcoord = int2(0, 0);
if(cflags.x != 0)
{
float4 uv[0];
int2 t_coord;

{
}
}
float3 pos0 = patch[0].pos.xyz;
float3 pos1 = patch[1].pos.xyz;
float3 pos2 = patch[2].pos.xyz;
float3 position = BInterpolate(pos0, pos1, pos2, bCoords);
float3 norm0 = pconstans.Normal[0].xyz;
float3 norm1 = pconstans.Normal[1].xyz;
float3 norm2 = pconstans.Normal[2].xyz;
float3 normal = normalize(BInterpolate(norm0, norm1, norm2, bCoords));
pos0 = PrjToPlane(norm0, pos0, position);
pos1 = PrjToPlane(norm1, pos1, position);
pos2 = PrjToPlane(norm2, pos2, position);
position = lerp(position, BInterpolate(pos0, pos1, pos2, bCoords),saturate(ctess.zzz * borderdistance * 16.0));
position += displacement * normal * ctess.w;
float4 pos = float4(position, 1.0);
result.pos = float4(dot(cproj[0], pos), dot(cproj[1], pos), dot(cproj[2], pos), dot(cproj[3], pos));
result.pos.xy = result.pos.xy + result.pos.w * cDepth.zw;
result.colors_0 = BInterpolate(patch[0].colors_0, patch[1].colors_0, patch[2].colors_0, bCoords);
result.colors_1 = BInterpolate(patch[0].colors_1, patch[1].colors_1, patch[2].colors_1, bCoords);
result.clipDist = BInterpolate(patch[0].clipDist, patch[1].clipDist, patch[2].clipDist, bCoords);
result.clipPos = float4(position.xy, result.pos.zw);
result.Normal = float4(normal.xyz, position.z);
result.pos.z = result.pos.w * cDepth.x - result.pos.z * cDepth.y;
return result;
}C:\Users\HenrikoMagnifico\Documents\Ishiiruka Dolphin\Shader@0x000002CCB111D1C0(218,8-12): error X3059: array dimension must be between 1 and 65536