I'm not a shader artist, i just have fun fiddling with shaders, and i know that there are techniques to fix this properly and without performance hit (even applying AA across the seams) but to this day i cant wrap my head around those, so i cant modify my shader to utilize them. maybe someone else can help me there. anyway here is the code:
Shader "Custom/Interior Mapping Raytrace" {
Properties{
_Color("Color", Color) = (1,1,1,1)
_TextureAtlas("Texture Atlas(RGB)",2D) = "white"{}
}
SubShader{
Tags { "RenderType" = "Opaque" }
LOD 200
CGPROGRAM
#pragma surface surf StandardSpecular
// Use shader model 3.0 target, to get nicer looking lighting
#pragma target 3.0
sampler2D _TextureAtlas;
struct Input {
float3 viewDir;
float3 worldPos;
};
fixed4 _Color;
// Add instancing support for this shader. You need to check 'Enable Instancing' on materials that use the shader.
// See https://docs.unity3d.com/Manual/GPUInstancing.html for more information about instancing.
// #pragma instancing_options assumeuniformscaling
UNITY_INSTANCING_BUFFER_START(Props)
// put more per-instance properties here
UNITY_INSTANCING_BUFFER_END(Props)
//simplified intersection for axis aligned planes which only requires one component
float GetAxisAlignedPlaneIntersection(float lineP, float lineDir, float planeP) {
//planeP = t * lineDir + lineP
//(planeP-lineP)/lineDir = t
return (planeP - lineP) / lineDir;
}
//returns the next axis aligned plane that we are going to hit. planes are on each integer like 0, 1, 2, 3,...
float2 GetNextAxisAlignedPlane(float p, float dir) {
float signDir = sign(dir);
float planeP = floor(p) + (signDir + 1) / 2;
return float2(planeP, -signDir);
}
float2 GetUVs(float u, float v) {
return float2(u - floor(u), v - floor(v));
}
float2 MoveUvsToRight(float2 uvs) {
uvs.x /= 2;
uvs.y /= 3;
return uvs;
}
float2 MoveUvsToLeft(float2 uvs) {
uvs.x /= 2;
uvs.x += 0.5f;
uvs.y /= 3;
return uvs;
}
float2 MoveUvsToTop(float2 uvs) {
uvs.x /= 2;
uvs.y /= 3;
uvs.y += 0.33333f;
return uvs;
}
float2 MoveUvsToBottom(float2 uvs) {
uvs.x /= 2;
uvs.x += 0.5f;
uvs.y /= 3;
uvs.y += 0.33333f;
return uvs;
}
float2 MoveUvsToBack(float2 uvs) {
uvs.x /= 2;
uvs.y /= 3;
uvs.y += 0.66666f;
return uvs;
}
float2 MoveUvsToFront(float2 uvs) {
uvs.x /= 2;
uvs.x += 0.5f;
uvs.y /= 3;
uvs.y += 0.66666f;
return uvs;
}
void surf(Input IN, inout SurfaceOutputStandardSpecular o) {
float3 lineP = IN.worldPos;
float3 lineDir = -IN.viewDir; //view dir points at camera, but we need from cam to point
float2 wallX = GetNextAxisAlignedPlane(lineP.x, lineDir.x);
float2 wallY = GetNextAxisAlignedPlane(lineP.y, lineDir.y);
float2 wallZ = GetNextAxisAlignedPlane(lineP.z, lineDir.z);
float tX = GetAxisAlignedPlaneIntersection(lineP.x, lineDir.x, wallX.x);
float tY = GetAxisAlignedPlaneIntersection(lineP.y, lineDir.y, wallY.x);
float tZ = GetAxisAlignedPlaneIntersection(lineP.z, lineDir.z, wallZ.x);
float2 uvs = float2(0.02,0.02);
float3 n = float3(0, 0, 0);
if (tX < tY && tX < tZ) { //we hit x first
float3 wallP = lineP + lineDir * tX;
uvs = GetUVs(wallP.z, wallP.y);
n.x = -lineDir.x;
if (sign(lineDir.x) > 0) {
uvs = MoveUvsToRight(uvs);
}
else {
uvs = MoveUvsToLeft(uvs);
}
}
else if (tY < tX && tY < tZ) { //we hit y first
float3 wallP = lineP + lineDir * tY;
uvs = GetUVs(wallP.x, wallP.z);
n.y = -lineDir.y;
if (sign(lineDir.y) > 0) {
uvs = MoveUvsToTop(uvs);
}
else {
uvs = MoveUvsToBottom(uvs);
}
}
else if (tZ < tX && tZ < tY) { //we hit z first
float3 wallP = lineP + lineDir * tZ;
uvs = GetUVs(wallP.x, wallP.y);
n.z = -lineDir.z;
if (sign(lineDir.z) > 0) {
uvs = MoveUvsToBack(uvs);
}
else {
uvs = MoveUvsToFront(uvs);
}
}
else {
discard;
}
o.Albedo = tex2Dlod(_TextureAtlas, float4(uvs,0,0));
n = normalize(n);
//o.Normal = n;
}
ENDCG
}
FallBack "Diffuse"
}
you mightve noticed that i commented the last line, where i assign the normal. The reason for this is that unity apparently tries to do more than just lighting using the normal, and the result is subsequently completely broken when assigning the normal. people are also welcome to tell me the fix for that. also here is the texture atlas i used for the shader
The whole shader can be converted to cycles nodes for use in Blender, but its a pain in the ass because some things are just missing (e.g. floor or sign functions). so have fun to whoever wants to implement it in cycles :P
