Begin work on `custom30` world

Add vertex colors

7 files changed, 216 insertions, 18 deletions

diff --git a/2ner.cginc b/2ner.cginc
index bac9ee6..ba8b6c8 100644
--- a/2ner.cginc
+++ b/2ner.cginc
@@ -4,6 +4,7 @@
 #include "UnityCG.cginc"

 #include "UnityLightingCommon.cginc"

 

+#include "custom30.cginc"

 #include "eyes.cginc"

 #include "face_me.cginc"

 #include "false_color_visualization.cginc"

@@ -159,11 +160,14 @@ v2f vert(appdata v) {
 #if defined(SHADOW_CASTER_PASS)

 	TRANSFER_SHADOW_CASTER_NORMALOFFSET(o);

 #endif

+

+  // Vertex color

+  o.color = v.color;

   return o;

 }

 

 float4 frag(v2f i, uint facing : SV_IsFrontFace

-#if defined(_HARNACK_TRACING) || defined(_SHATTER_WAVE) || defined(_VERTEX_DOMAIN_WARPING)

+#if defined(_HARNACK_TRACING) || defined(_SHATTER_WAVE) || defined(_VERTEX_DOMAIN_WARPING) || defined(_CUSTOM30)

   , out float depth : SV_DepthLessEqual

 #endif

 ) : SV_Target {

@@ -213,6 +217,20 @@ float4 frag(v2f i, uint facing : SV_IsFrontFace
   i.uv01.xy = eye_effect_00.uv;

 #endif

 

+#if defined(_CUSTOM30_BASICCUBE)

+  Custom30Output basic_cube_output = BasicCube(i);

+  i.pos = UnityObjectToClipPos(basic_cube_output.objPos);

+  i.normal = basic_cube_output.normal;

+  depth = basic_cube_output.depth;

+#endif

+

+#if defined(_CUSTOM30_BASICWEDGE)

+  Custom30Output basic_wedge_output = BasicWedge(i);

+  i.pos = UnityObjectToClipPos(basic_wedge_output.objPos);

+  i.normal = basic_wedge_output.normal;

+  depth = basic_wedge_output.depth;

+#endif

+

   YumPbr pbr = GetYumPbr(i);

 

 #if defined(_HARNACK_TRACING)

diff --git a/2ner.shader b/2ner.shader
index bb45042..8e75585 100644
--- a/2ner.shader
+++ b/2ner.shader
@@ -104,6 +104,25 @@ Shader "yum_food/2ner"
         [HideInInspector] m_end_Outlines("Outlines", Float) = 0
         //endex
 
+        //ifex _Custom30_Enabled==0
+        [HideInInspector] m_start_Custom30("Custom 30", Float) = 0
+        [ThryToggle(_CUSTOM30)]_Custom30_Enabled("Enable", Float) = 0
+
+        //ifex _Custom30_BasicCube_Enabled==0
+        [HideInInspector] m_start_Custom30_BasicCube("Basic cube", Float) = 0
+        [ThryToggle(_CUSTOM30_BASICCUBE)]_Custom30_BasicCube_Enabled("Enable", Float) = 0
+        [HideInInspector] m_end_Custom30_BasicCube("Basic cube", Float) = 0
+        //endex
+
+        //ifex _Custom30_BasicWedge_Enabled==0
+        [HideInInspector] m_start_Custom30_BasicWedge("Basic wedge", Float) = 0
+        [ThryToggle(_CUSTOM30_BASICWEDGE)]_Custom30_BasicWedge_Enabled("Enable", Float) = 0
+        [HideInInspector] m_end_Custom30_BasicWedge("Basic wedge", Float) = 0
+        //endex
+
+        [HideInInspector] m_end_Custom30("Custom 30", Float) = 0
+        //endex
+
         [HideInInspector] m_start_Matcaps("Matcaps", Float) = 0
           //ifex _Matcap0_Enabled==0
           [HideInInspector] m_start_Matcap0("Matcap 0", Float) = 0
diff --git a/custom30.cginc b/custom30.cginc
new file mode 100644
index 0000000..38fe2c2
--- /dev/null
+++ b/custom30.cginc
@@ -0,0 +1,157 @@
+#ifndef __CUSTOM30_INC
+#define __CUSTOM30_INC
+
+#include "globals.cginc"
+#include "quilez.cginc"
+#include "interpolators.cginc"
+
+#if defined(_CUSTOM30)
+
+#define CUSTOM30_MAX_STEPS 30
+
+struct Custom30Output {
+  float3 objPos;
+  float3 normal;
+  float depth;
+};
+
+float3 GetFragToOrigin(v2f i) {
+  // Vector from fragment to origin
+  return float3(-1, 1, 1) * (i.color * 2.0f - 1.0f) / i.color.a;
+}
+
+float cut_with_box(float3 p, float d, float3 box_size) {
+  float2 pp_xy = p.xy;
+  float2 pp_xz = p.xz;
+  float2 pp_yz = p.yz;
+
+  // Rotate by 45 degrees
+  float c = 0.70710678;
+  float s = 0.70710678;
+  pp_xy = float2(c * p.x - s * p.y, s * p.x + c * p.y);
+  d = max(d, distance_from_box(float3(pp_xy, p.z), box_size));
+
+  pp_xz = float2(c * p.x - s * p.z, s * p.x + c * p.z);
+  d = max(d, distance_from_box(float3(pp_xz, p.y), box_size));
+
+  pp_yz = float2(c * p.y - s * p.z, s * p.y + c * p.z);
+  d = max(d, distance_from_box(float3(pp_yz, p.x), box_size));
+
+  return d;
+}
+
+#if defined(_CUSTOM30_BASICCUBE)
+float BasicCube_map(float3 p) {
+  float box_d = distance_from_box_frame(p, .995, .15);
+  float core_d = distance_from_box(p, 0.95);
+  float d = min(box_d, core_d);
+
+  d = cut_with_box(p, d, 1.3);
+
+  return d;
+}
+
+float3 BasicCube_normal(float3 p) {
+  float epsilon = 1E-3;
+  float center_d = BasicCube_map(p);
+  float3 n = float3(
+    BasicCube_map(p + float3(epsilon, 0, 0)) - center_d,
+    BasicCube_map(p + float3(0, epsilon, 0)) - center_d,
+    BasicCube_map(p + float3(0, 0, epsilon)) - center_d);
+  return normalize(n);
+}
+
+Custom30Output BasicCube(v2f i) {
+  float3 objSpaceCameraPos = mul(unity_WorldToObject, float4(_WorldSpaceCameraPos, 1.0));
+
+  float3 frag_to_origin = GetFragToOrigin(i);
+
+  float3 ro = -frag_to_origin;
+  float3 rd = normalize(i.objPos - objSpaceCameraPos);
+
+  float d;
+  float d_acc = 0;
+  float epsilon = 5E-3;
+  // 1.73... = sqrt(3)
+  // our cube has an edge length of 2, so mult by 2
+  float max_d = 1.73205081f * 2.0f;
+  [loop]
+  for (uint ii = 0; ii < CUSTOM30_MAX_STEPS; ++ii) {
+    float3 p = ro + rd * d_acc;
+    d = BasicCube_map(p);
+    d_acc += d;
+    if (d < epsilon) break;
+    if (d_acc > max_d) break;
+  }
+
+  Custom30Output o;
+  clip(epsilon - d);
+  float3 objPos = ro + rd * d_acc;
+  o.objPos = objPos;
+  // Transform from SDF space back to object space
+  float3 objSpacePos = objPos + (i.objPos + frag_to_origin);
+  float4 clipPos = UnityObjectToClipPos(objSpacePos);
+  o.depth = clipPos.z / clipPos.w;
+  o.normal = BasicCube_normal(objPos);
+  return o;
+}
+#endif
+
+#if defined(_CUSTOM30_BASICWEDGE)
+float BasicWedge_map(float3 p) {
+  float box_d = distance_from_box(p, float3(1, 1, 1));
+  float cut_plane_d = distance_from_plane(p - float3(0, 0, 0), -normalize(float3(1, 0, 1)), 0);
+
+  float d = op_sub(box_d, cut_plane_d);
+  //d = cut_with_box(p, d, 1.3);
+  return d;
+}
+
+float3 BasicWedge_normal(float3 p) {
+  float epsilon = 1E-3;
+  float center_d = BasicWedge_map(p);
+  float3 n = float3(
+    BasicWedge_map(p + float3(epsilon, 0, 0)) - center_d,
+    BasicWedge_map(p + float3(0, epsilon, 0)) - center_d,
+    BasicWedge_map(p + float3(0, 0, epsilon)) - center_d);
+  return normalize(n);
+}
+
+Custom30Output BasicWedge(v2f i) {
+  float3 objSpaceCameraPos = mul(unity_WorldToObject, float4(_WorldSpaceCameraPos, 1.0));
+
+  float3 frag_to_origin = GetFragToOrigin(i);
+
+  float3 ro = -frag_to_origin;
+  float3 rd = normalize(i.objPos - objSpaceCameraPos);
+
+  float d;
+  float d_acc = 0;
+  float epsilon = 5E-3;
+  // 1.73... = sqrt(3)
+  // our cube has an edge length of 2, so mult by 2
+  float max_d = 1.73205081f * 2.0f;
+  [loop]
+  for (uint ii = 0; ii < CUSTOM30_MAX_STEPS; ++ii) {
+    float3 p = ro + rd * d_acc;
+    d = BasicWedge_map(p);
+    d_acc += d;
+    if (d < epsilon) break;
+    if (d_acc > max_d) break;
+  }
+
+  Custom30Output o;
+  clip(epsilon - d);
+  float3 objPos = ro + rd * d_acc;
+  o.objPos = objPos;
+  // Transform from SDF space back to object space
+  float3 objSpacePos = objPos + (i.objPos + frag_to_origin);
+  float4 clipPos = UnityObjectToClipPos(objSpacePos);
+  o.depth = clipPos.z / clipPos.w;
+  o.normal = BasicWedge_normal(objPos);
+  return o;
+}
+#endif
+
+#endif  // _CUSTOM30
+#endif  // __CUSTOM30_INC
diff --git a/features.cginc b/features.cginc
index e29471f..31ad8fd 100644
--- a/features.cginc
+++ b/features.cginc
@@ -291,5 +291,11 @@
 #pragma shader_feature_local _SPHERIZE
 //endex
 
+//ifex _Custom30_Enabled==0
+#pragma shader_feature_local _CUSTOM30
+#pragma shader_feature_local _CUSTOM30_BASICCUBE
+#pragma shader_feature_local _CUSTOM30_BASICWEDGE
+//endex
+
 #endif  // __FEATURES_INC
 
diff --git a/interpolators.cginc b/interpolators.cginc
index aaca5fb..3a776df 100644
--- a/interpolators.cginc
+++ b/interpolators.cginc
@@ -4,13 +4,14 @@
 #include "AutoLight.cginc"

 

 struct appdata {

-  float4 vertex  : POSITION;

-  float2 uv0    : TEXCOORD0;

-  float2 uv1    : TEXCOORD1;

-  float2 uv2    : TEXCOORD2;

-  float2 uv3    : TEXCOORD3;

-  float3 normal  : NORMAL;

-  float4 tangent : TANGENT;

+  float4 vertex   : POSITION;

+  float2 uv0      : TEXCOORD0;

+  float2 uv1      : TEXCOORD1;

+  float2 uv2      : TEXCOORD2;

+  float2 uv3      : TEXCOORD3;

+  float3 normal   : NORMAL;

+  float4 tangent  : TANGENT;

+  float4 color    : COLOR;  // vertex color

 

   UNITY_VERTEX_INPUT_INSTANCE_ID

 };

@@ -19,7 +20,7 @@ struct v2f {
 #if defined(_TESSELLATION)

 	float4 tpos         : INTERNALTESSPOS;

 #endif

-	linear noperspective centroid float4 pos         : SV_POSITION;

+  linear noperspective centroid float4 pos         : SV_POSITION;

 	float4 uv01        : TEXCOORD0;

 	float4 uv23        : TEXCOORD1;  // just one more uv slot bro please

 	float4 objPos      : TEXCOORD2;

@@ -28,7 +29,8 @@ struct v2f {
 	float3 tangent     : TEXCOORD5;

 	float3 binormal    : TEXCOORD6;

   float4 eyeVec      : TEXCOORD7; // eyeVec.xyz | fogCoord

-  UNITY_LIGHTING_COORDS(8,9)

+  float4 color       : TEXCOORD8;

+  UNITY_LIGHTING_COORDS(9,10)

 

   UNITY_VERTEX_INPUT_INSTANCE_ID

   UNITY_VERTEX_OUTPUT_STEREO

diff --git a/quilez.cginc b/quilez.cginc
index c9ac477..8deb61a 100644
--- a/quilez.cginc
+++ b/quilez.cginc
@@ -86,7 +86,7 @@ float distance_from_box_frame(float3 p, float3 b, float e)
       length(max(float3(q.x,q.y,p.z),0.0))+min(max(q.x,max(q.y,p.z)),0.0));

 }

 

-float distance_from_pyramid(float3 p, float h, bool invert)

+float distance_from_pyramid(float3 p, float h)

 {

   float m2 = h*h + 0.25;

 

@@ -155,20 +155,15 @@ float distance_from_ellipsoid(float3 p, float3 r)
     return k1*(k1-1.0)/k2;

 }

 

-/*

-float sdHexPrism( vec3 p, vec2 h )

-{

-}

-*/

-

 float3 op_rep(in float3 p, in float3 c)

 {

   return glsl_mod(p+0.5*c,c)-0.5*c;

 }

 

+// compute d1 - d2

 float op_sub(float d1, float d2)

 {

-  return max(-d1,d2);

+  return max(d1,-d2);

 }

 

 // End licensed section

diff --git a/tessellation.cginc b/tessellation.cginc
index 3df57b1..526d2e3 100644
--- a/tessellation.cginc
+++ b/tessellation.cginc
@@ -109,6 +109,7 @@ v2f domain(
   o.binormal = DOMAIN_INTERP(binormal);
   o.uv01     = DOMAIN_INTERP(uv01);
   o.uv23     = DOMAIN_INTERP(uv23);
+  o.color     = DOMAIN_INTERP(color);
 
 #if defined(_TESSELLATION) && defined(_SHATTER_WAVE)
 #if defined(OUTLINE_PASS)