cvr-props/Assets/test/RayMarchLib.cginc

1045 lines
25 KiB
HLSL
Raw Normal View History

//double include guard
#ifndef RAY_MARCH_LIB_INCLUDED
#define RAY_MARCH_LIB_INCLUDED
#include "UnityCG.cginc"
// Multi compile stuff
#define V_X float3(1, 0, 0)
#define V_Y float3(0, 1, 0)
#define V_Z float3(0, 0, 1)
#define V_XZ float3(1, 0, 1)
#define V_XY float3(1, 1, 0)
#define V_YZ float3(0, 1, 1)
//ambient occlusion quality
#ifndef AO_STEPS
#define AO_STEPS 5
#endif
//normals for lighting
#ifndef NORMAL_DELTA
#define NORMAL_DELTA 0.001
#endif
//normals for reflection angles
#ifndef REFL_NORMAL_DELTA
#define REFL_NORMAL_DELTA 0.001
#endif
#ifndef MAX_REFLECTIONS
#define MAX_REFLECTIONS 2
#endif
#ifdef USE_DYNAMIC_QUALITY//quality settings as unity material properties
int _MaxSteps = 100;
float _MaxDist = 100;
float _SurfDist = 0.00001;
#else//pre compile quality settings
#ifndef MAX_STEPS
#define MAX_STEPS 256
//256
#endif
#ifndef MAX_DIST
#define MAX_DIST 128
#endif
#ifndef SURF_DIST
#define SURF_DIST 0.0001
//#define SURF_DIST 0.00001
#endif
#endif
#define col(r, g, b) fixed4(r, g, b, 1)
struct appdata
{
float4 vertex : POSITION;
};
struct v2f
{
float4 vertex : SV_POSITION;
float3 vCamPos : TEXCOORD1;
float3 vHitPos : TEXCOORD2;
};
struct fragOut
{
fixed4 col : SV_Target;
float depth : SV_Depth;
};
typedef struct material
{
fixed4 col;
fixed fRough;
} material_t;
#define DEFMAT {fixed4(.2,.2,.2,1), 1}
#define M_RED {fixed4(0.2, 0.001, 0.001, 1), 1}
#define M_ORANGE {fixed4(0.2, 0.1, 0.001, 1), 1}
#define M_YELLOW {fixed4(0.2, 0.2, 0.001, 1), 1}
#define M_GREEN {fixed4(0.001, 0.2, 0.001, 1), 1}
#define M_BLUE {fixed4(0.001, 0.001, 0.2, 1), 1}
#define M_LIGHT_BLUE{fixed4(0.001, 0.05, 0.2, 1), 1}
#define M_MAGENTA {fixed4(0.2, 0.001, 0.2, 1), 1}
#define M_PURPLE {fixed4(0.05, 0.001, 0.2, 1), 1}
#define M_WHITE {fixed4(0.5, 0.5, 0.5, 1), 1}
#define M_MIRROR {fixed4(0.1, 0.1, 0.1, 1), 0}
inline material mat(float r, float g, float b, float fRough = 1)
{
material m = {fixed4(r, g, b, 1), fRough};
return m;
}
inline material mat(float3 rgb, float fRough = 1)
{
material m = {fixed4(rgb, 1), fRough};
return m;
}
//used for lighting a point
struct rayData
{
float dist;
int iSteps;
material mat;
float3 vRayStart;
float3 vRayDir;
float3 vHit;
fixed3 vNorm;
bool bMissed;
float minDist;
float distToMinDist;
};
//returned from distance functions, including main scene
struct sdfData
{
float dist;
material mat;
};
sdfData scene(float3 p);
fixed4 lightPoint(rayData r);
fixed4 rayMarch(float3 p, float3 d);
rayData castRay(float3 p, float3 d, float startDist = 0);
v2f vert (appdata v)
{
v2f o;
o.vertex = UnityObjectToClipPos(v.vertex);
#ifdef USE_WORLD_SPACE
o.vCamPos = _WorldSpaceCameraPos;
o.vHitPos = mul(unity_ObjectToWorld, v.vertex);
#else
o.vCamPos = mul(unity_WorldToObject, float4(_WorldSpaceCameraPos, 1));
o.vHitPos = v.vertex;
#endif
return o;
}
#ifdef USE_REFLECTIONS
#define CALC_NORM
fragOut frag (v2f i)
{
float fRayLen = 0;//since last bounce
#ifdef CONSTRAIN_TO_MESH
float3 vLastBounce = i.vHitPos;
fRayLen += length(i.vHitPos - i.vCamPos);
#else
float3 vLastBounce = i.vCamPos;
#endif
float3 vRayDir = normalize(i.vHitPos - i.vCamPos);//current direction
sdfData point_data;
rayData ray;
fixed4 col;
float colUsed = 0;// what amount of the final colour has been calculated
float prevRough = 0;
float3 vFirstHit;
for (int i = 0; i < MAX_REFLECTIONS+1; i++)
{
ray = castRay(vLastBounce, vRayDir);
if (i == 0)
{//before any bounces
col = lightPoint(ray);
vFirstHit = ray.vHit;
}
else
{
float colAmt = colUsed + (prevRough * (1-colUsed));
col = lerp(lightPoint(ray), col, colAmt);
colUsed = colAmt;
}
if (ray.bMissed || ray.mat.fRough > 0.99)
{
break;
}
prevRough = ray.mat.fRough;
vRayDir = reflect(vRayDir, ray.vNorm);
vLastBounce = ray.vHit + vRayDir * 0.01;
}
#ifdef DISCARD_ON_MISS
if (ray.bMissed && i == 0) discard;
#endif
fragOut o;
o.col = col;
#ifdef USE_WORLD_SPACE
float4 vClipPos = mul(UNITY_MATRIX_VP, float4(vFirstHit, 1));
#else
float4 vClipPos = mul(UNITY_MATRIX_VP, mul(unity_ObjectToWorld, float4(vFirstHit, 1)));
#endif
o.depth = vClipPos.z / vClipPos.w;
#if !defined(UNITY_REVERSED_Z) // basically only OpenGL (unity editor on linux)
o.depth = o.depth * 0.5 + 0.5; // remap -1 to 1 range to 0.0 to 1.0
#endif
return o;
}
#else
fragOut frag (v2f i)
{
float3 vRayDir = normalize(i.vHitPos - i.vCamPos);
#ifdef CONSTRAIN_TO_MESH
//rayData ray = castRay(i.vHitPos, vRayDir, length(i.vHitPos-i.vCamPos));
rayData ray = castRay(i.vCamPos, vRayDir, length(i.vHitPos-i.vCamPos));
//rayData ray = castRay(i.vCamPos, vRayDir, 1);
//rayData ray = castRay(i.vCamPos, vRayDir, 0);
#else
rayData ray = castRay(i.vCamPos, vRayDir);
#endif
#ifdef DISCARD_ON_MISS
if (ray.bMissed) discard;
#endif
fragOut o;
o.col = lightPoint(ray);
// writing to depth buffer costs about 1-2 frames at 4k
#ifdef USE_WORLD_SPACE
float4 vClipPos = mul(UNITY_MATRIX_VP, float4(ray.vHit, 1));
#else
float4 vClipPos = mul(UNITY_MATRIX_VP, mul(unity_ObjectToWorld, float4(ray.vHit, 1)));
#endif
o.depth = (vClipPos.z / vClipPos.w + 1.0) * 0.5;
return o;
}
#endif
//gets normal of a point
inline float3 getNormFull(float3 vPos, float fEpsilon = 0.001)
{
//if epsilon is smaller than 0.001, there are often artifacts
const float2 e = float2(fEpsilon, 0);
float3 n = scene(vPos).dist - float3(
scene(vPos - e.xyy).dist,
scene(vPos - e.yxy).dist,
scene(vPos - e.yyx).dist);
return normalize(n);
}
//gets normal, provided you have the distance for pos (1 less call to scene())
inline float3 getNorm(float3 vPos, float fPointDist, float fEpsilon = 0.001)
{
////if epilon is smaller than 0.001, there are often artifacts
const float2 e = float2(fEpsilon, 0);
float3 n = fPointDist - float3(
scene(vPos - e.xyy).dist,
scene(vPos - e.yxy).dist,
scene(vPos - e.yyx).dist);
return normalize(n);
}
//marches a ray through the scene once
rayData castRay(float3 vRayStart, float3 vRayDir, float startDist)
{
float fRayLen = startDist;//startDist;// total distance marched / distance from camera
float3 vPos;
sdfData sdf_data;
rayData ray;
ray.vRayDir = vRayDir;
ray.vRayStart = vRayStart;
ray.minDist = 30000.0;// budget "infinity"
ray.distToMinDist = 0;
#ifdef USE_DYNAMIC_QUALITY
for (int i = 0; i < _MaxSteps; i++)
#else
for (int i = 0; i < MAX_STEPS; i++)
#endif
{
vPos = vRayStart + fRayLen * vRayDir;
sdf_data = scene(vPos);
#ifdef USE_DYNAMIC_QUALITY
if (abs(sdf_data.dist) < _SurfDist) break;
#else
if (abs(sdf_data.dist) < SURF_DIST) break;
#endif
fRayLen += sdf_data.dist;// move forward
if (ray.minDist>sdf_data.dist)
{
ray.minDist = sdf_data.dist;
ray.distToMinDist = fRayLen;
}
#ifdef USE_DYNAMIC_QUALITY
if (fRayLen > _MaxDist) {ray.bMissed = true; break;}//flag this as transparent/sky
#else
if (fRayLen > MAX_DIST) {ray.bMissed = true; break;}//flag this as transparent/sky
#endif
}
ray.dist = fRayLen;
ray.iSteps = i;
ray.mat = sdf_data.mat;
ray.vHit = vPos;
#ifdef CALC_NORM
ray.vNorm = getNorm(vPos, sdf_data.dist);
#endif
return ray;
}
//////////////////////////////////////////////////////////////////////
//
// Lighting
//
//////////////////////////////////////////////////////////////////////
//generates a skybox, use when ray didn't hit anything (ray_data.bMissed)
inline fixed4 sky(float3 vRayDir)
{
float4 cRenderedSun = max(0, pow(dot(vRayDir, normalize(float3(8,4,2))) + 0.4, 10)-28) * float4(.8,.4,0,1);
return fixed4(0.7, 0.75, 0.8, 1) - abs(vRayDir.y) * 0.5 + cRenderedSun;
}
//calculate sun light based on normal
fixed4 lightSun(float3 vNorm, float3 vSunDir = float3(8, 4, 2), fixed4 cSunCol = fixed4(7.0, 5.5, 3.0, 1))
{
float fSunLight = max(dot(vNorm, vSunDir), 0);
return fSunLight * cSunCol;
}
//calculate shadow from sun
float lightShadow(float3 vPos, float3 vSunDir, float fSharpness = 8)
{
float fShadow = 1;
#ifdef USE_DYNAMIC_QUALITY
for (float fRayLen = 0.001; fRayLen < _MaxDist/2.0;)
#else
for (float fRayLen = 0.001; fRayLen < MAX_DIST/2.0;)
#endif
{
float dist = scene(vPos + vSunDir * fRayLen).dist;
#ifdef USE_DYNAMIC_QUALITY
if (dist < _SurfDist) return 0;
#else
if (dist < SURF_DIST) return 0;
#endif
fShadow = min(fShadow, fSharpness * dist/fRayLen);
fRayLen += dist;
}
return fShadow;
}
//calculate sky light
inline fixed4 lightSky(float3 vNorm, fixed4 cSkyCol = fixed4(0.5, 0.8, 0.9, 1))
{
return cSkyCol * (0.5 + 0.5 * vNorm.y);
}
//bad ambient occlusion (screen space) based on steps
float lightSSAO(rayData ray_data, float fDarkenFactor = 2)
{
#ifdef USE_DYNAMIC_QUALITY
return pow(1 - float(ray_data.iSteps) / _MaxSteps, fDarkenFactor);
#else
return pow(1 - float(ray_data.iSteps) / MAX_STEPS, fDarkenFactor);
#endif
}
//ambient occlusion
float lightAO(float3 vPos, float3 vNorm, float fEpsilon = 0.05)
{
float ao = 0;
for (int i = 0; i < AO_STEPS; i++)
{
float fOffset = i * fEpsilon;
float fDist = scene(vPos + vNorm * fOffset).dist;
ao += 1/pow(2, i) * (fOffset - fDist);
}
ao = 1 - AO_STEPS * ao;
return ao;
}
inline fixed4 lightFog(fixed4 col, fixed4 cFog, float fDist, float fStart=16, float fFull=32)
{
if (fDist < 0) return cFog;
return lerp(col, cFog, smoothstep(fStart, fFull, fDist));
}
//a light pass for debugging
fixed4 lightOnly(float3 vPos, float3 vNorm, float3 vSunDir)
{
float fLight = lightSun(vNorm, vSunDir, 1);
float fAO = lightAO(vPos, vNorm);
float fShadow = lightShadow(vPos, vSunDir);
return fLight * fAO * fShadow;
}
//////////////////////////////////////////////////////////////////////
//
// Interpolation and Math
//
//////////////////////////////////////////////////////////////////////
//soft min of a and b with smoothing factor k
inline float smin(float a, float b, float k)
{
float h = max(k - abs(a-b), 0) / k;
return min(a, b) - h*h*h*k * 1/6.0;
}
//soft max of a and b with smoothing factor k
inline float smax(float a, float b, float k)
{
float h = max(k - abs(a - b), 0) / k;
return max(a, b) + h*h*h*k * 1/6.0;
}
//interpolate between the colours of 2 SDFs
inline material mixMat(sdfData sdfA, sdfData sdfB)
{
material m;
float fac = clamp(sdfA.dist/(sdfA.dist + sdfB.dist), 0, 1);
m.col = lerp(sdfA.mat.col, sdfB.mat.col, fac);
m.fRough = lerp(sdfA.mat.fRough, sdfB.mat.fRough, fac);
return m;
}
//interpolate between the colours of 2 SDFs
inline material mixMat(material a, material b, float fac)
{
material m;
m.col = lerp(a.col, b.col, fac);
m.fRough = lerp(a.fRough, b.fRough, fac);
return m;
}
// from: https://github.com/michaldrobot/ShaderFastLibs/blob/master/ShaderFastMathLib.h
// modified to be more "optimized" (WAY worse approximations)
static const float fsl_PI = 3.1415926535897932384626433f;
static const float fsl_PI_half = fsl_PI/2;
inline float acosFast4(float inX)
{
return 1.57-inX;
float x1 = abs(inX);
//float x2 = x1 * x1;
//float x3 = x2 * x1;
float s;
s = -0.2121144f * x1 + 1.5707288f;
//s = 0.0742610f * x2 + s;
//s = -0.0187293f * x3 + s;
s = sqrt(1.0f - x1) * s;
// acos function mirroring
// check per platform if compiles to a selector - no branch neeeded
return s;
//return inX >= 0.0f ? s : fsl_PI - s;
}
// polynomial degree 2
// Tune for positive input [0, infinity] and provide output [0, PI/2]
inline float ATanPos(float x)
{
const float C1 = 1.01991;
const float C2 = -0.218891;
float t0 = (x < 1.0f) ? x : 1.0f / x;
float t1 = (C2 * t0 + C1) * t0; // p(x)
return t1;//return (x < 1.0f) ? t1: fsl_PI_half - t1; // undo range reduction
}
// Common function, ATanPos is implemented below
// input [-infinity, infinity] and output [-PI/2, PI/2]
inline float ATan(float x)
{
float t0 = ATanPos(abs(x));
return t0;//(x < 0.0f) ? -t0: t0; // undo range reduction
}
inline float atanFast4(float inX)
{
//return atan(inX);
return ATan(inX);
float x = inX;
return x*(-0.1784f * abs(x) - 0.0663f * x * x + 1.0301f);
}
// https://en.wikipedia.org/wiki/Atan2#Definition_and_computation
inline float atanFast4_2(float y, float x)
{
//return sign(x)*sign(x)*atanFast4(y/x)+((1-sign(x))/2)*(1-sign(y)-sign(y)*sign(y))*fsl_PI;
return atanFast4(y/x)+(1-sign(x))*(sign(y))*fsl_PI/2;
}
//////////////////////////////////////////////////////////////////////
//
// SDF operations
//
//////////////////////////////////////////////////////////////////////
//union of SDF A and B
sdfData sdfAdd(float3 p, sdfData sA, sdfData sB)
{
sdfData sC;
sC.dist = min(sA.dist, sB.dist);
sC.mat = mixMat(sA, sB);
return sC;
}
//union of SDF A and B, with smoothing
sdfData sdfAdd(float3 p, sdfData sA, sdfData sB, float fSmooth)
{
sdfData sC;
sC.dist = smin(sA.dist, sB.dist, fSmooth);
sC.mat = mixMat(sA, sB);
return sC;
}
//remove the SDF B from A (colour is from A)
sdfData sdfSub(float3 p, sdfData sA, sdfData sB)
{
sdfData sC;
sC.dist = max(sA.dist, -sB.dist);
sC.mat = sA.mat;
return sC;
}
//remove the SDF B from A (colour is from A), with smoothing
sdfData sdfSub(float3 p, sdfData sA, sdfData sB, float fSmooth)
{
sdfData sC;
sC.dist = smax(sA.dist, -sB.dist, fSmooth);
sC.mat = sA.mat;
return sC;
}
//intersection of SDF A and B
sdfData sdfInter(float3 p, sdfData sA, sdfData sB)
{
sdfData sC;
sC.dist = max(sA.dist, sB.dist);
sC.mat = mixMat(sA, sB);
return sC;
}
//intersection of SDF A and B, with smoothing
sdfData sdfInter(float3 p, sdfData sA, sdfData sB, float fSmooth)
{
sdfData sC;
sC.dist = smax(sA.dist, sB.dist, fSmooth);
sC.mat = mixMat(sA, sB);
return sC;
}
//round edges of an SDF
sdfData sdfRound(float3 p, sdfData sdfIn, float fRadius)
{
sdfData sdfOut = sdfIn;
sdfOut.dist -= fRadius;
return sdfOut;
}
//////////////////////////////////////////////////////////////////////
//
// SDF shapes
//
//////////////////////////////////////////////////////////////////////
//create sphere
sdfData sdfSphere(float3 p, float fRadius, material mat = DEFMAT)
{
sdfData sdf;
sdf.dist = length(p) - fRadius;
sdf.mat = mat;
return sdf;
}
//create plane pointing to positive Y
sdfData sdfPlane(float3 p, float fHeight, material mat = DEFMAT)
{
sdfData sdf;
sdf.dist = p.y - fHeight;
sdf.mat = mat;
return sdf;
}
//create plane with normal
sdfData sdfPlane(float3 p, float3 vNorm, float fHeight, material mat = DEFMAT)
{
sdfData sdf;
sdf.dist = dot(p, normalize(vNorm)) - fHeight;
sdf.mat = mat;
return sdf;
}
//create cuboid
sdfData sdfBox(float3 p, float3 vDim, material mat = DEFMAT)
{
sdfData sdf;
float3 q = abs(p) - vDim/2.0;
sdf.dist = length(max(q, 0)) + min(max(q.x, max(q.y, q.z)), 0);
sdf.mat = mat;
return sdf;
}
//create cuboid
sdfData sdfBox(float3 p, float3 vDim, float fRound, material mat = DEFMAT)
{
sdfData sdf;
float3 q = abs(p) - vDim/2.0;
sdf.dist = length(max(q, 0)) + min(max(q.x, max(q.y, q.z)), 0) - fRound;
sdf.mat = mat;
return sdf;
}
//create line segment
sdfData sdfLine(float3 p, float3 vStart, float3 vEnd, float fRadius, material mat = DEFMAT)
{
sdfData sdf;
float h = min(1, max(0, dot(p-vStart, vEnd-vStart) / dot(vEnd-vStart, vEnd-vStart)));
sdf.dist = length(p-vStart-(vEnd-vStart)*h)-fRadius;
sdf.mat = mat;
return sdf;
}
//create cylinder
sdfData sdfCylinder(float3 p, float fRadius, float fHeight, material mat = DEFMAT)
{
sdfData sdf;
sdf.dist = max(abs(p.y) - fHeight/2.0, length(p.xz) - fRadius);
sdf.mat = mat;
return sdf;
}
//create cylinder
sdfData sdfCylinder(float3 p, float fRadius, float fHeight, float fRound, material mat = DEFMAT)
{
sdfData sdf;
sdf.dist = max(abs(p.y) - fHeight/2.0, length(p.xz) - fRadius) - fRound;
sdf.mat = mat;
return sdf;
}
//create torus
sdfData sdfTorus(float3 p, float fRadius, float fThickness, material mat = DEFMAT)
{
sdfData sdf;
float2 q = float2(length(p.xz) - fRadius, p.y);
sdf.dist = length(q) - fThickness;
sdf.mat = mat;
return sdf;
}
//triangular prism (BOUND)
sdfData sdfTriPrism(float3 p, float fSide, float fDepth, material mat = DEFMAT)
{
float3 q = abs(p);
sdfData sdf;
sdf.dist = max(q.z - fDepth, max(q.x * 0.866025 + p.y * 0.5, -p.y) - fSide * 0.5);
sdf.mat = mat;
return sdf;
}
//////////////////////////////////////////////////////////////////////
//
// Fractals, complex shapes and scenes (frac prefix)
//
//////////////////////////////////////////////////////////////////////
//TODO:
// complex :julia,
// simple sierpinsky, menger
// Mandelbolb - OPTIMIZED AF, still a fractal but visually diffrent.
sdfData fracMandelbolb(float3 p, material mat = DEFMAT)
{
// http://blog.hvidtfeldts.net/index.php/2011/09/distance-estimated-3d-fractals-v-the-mandelbulb-different-de-approximations/
float3 pos;
pos.x = p.x;
pos.y = p.y;
pos.z = p.z;
float dr = 1.0;
float r = 0;
const int iterations = 4;
const float maxRThreshold = 2;//2;
const float Power = 16;
for (int i = 0; i < iterations; i++)
{
r = length(p);
if (r>maxRThreshold) break;
// xyz -> polar
//float theta = acos( p.z / r );
float theta = acosFast4( p.z / r );
//float phi = atan2( p.y, p.x );
float phi = atanFast4_2( p.y, p.x );
dr = pow( r, Power-1.0)*Power*dr + 1.0;
// transform point
float zr = pow( r, Power );
theta = theta * Power;
phi = phi * Power;
// polar -> xyz
p = zr*float3(sin(theta)*cos(phi), sin(phi)*sin(theta), cos(theta));
p += pos;
}
sdfData sdf;
sdf.mat = mat;
sdf.dist = 0.5*log(r)*r/dr;
return sdf;
}
// Mandelbulb
sdfData fracMandelbulb(float3 p, material mat = DEFMAT)
{
// http://blog.hvidtfeldts.net/index.php/2011/09/distance-estimated-3d-fractals-v-the-mandelbulb-different-de-approximations/
float3 pos;
pos.x = p.x;
pos.y = p.y;
pos.z = p.z;
float dr = 1.0;
float r = 0;
// Lowest number of iterations without loosing a significant amount of detail
// Depends on maxRThreshold
//int iterations = 1;
//int iterations = 8;
const int iterations = 5;
//float maxRThreshold = 2;
const float maxRThreshold = 2;
// Z_(n+1) = Z(n)^?
// float Power = 8 + 6 * sin(_Time.x);
float Power = 8;
for (int i = 0; i < iterations; i++)
{
r = length(p);
if (r>maxRThreshold) break;
// xyz -> polar
float theta = acos( p.z / r );
float phi = atan2( p.y, p.x );
dr = pow( r, Power-1.0)*Power*dr + 1.0;
// transform point
float zr = pow( r, Power );
theta = theta * Power;
phi = phi * Power;
// polar -> xyz
p = zr*float3(sin(theta)*cos(phi), sin(phi)*sin(theta), cos(theta));
p += pos;
}
sdfData sdf;
sdf.mat = mat;
//sdf.mat.col.y = sin(p.x);
//sdf.dist = sdfSphere(pos, 10).dist;
//sdf.mat = mat;
sdf.dist = 0.5*log(r)*r/dr;
//sdf.mat = mat;
return sdf;
}
void sphereFold(inout float3 p, inout float dz, float minRadius, float fixedRadius);
void boxFold(inout float3 p, float dz, float foldingLimit);
// Mandelbox
sdfData fracMandelbox(float3 p, float scaleFactor, material mat = DEFMAT)
{
// http://blog.hvidtfeldts.net/index.php/2011/11/distance-estimated-3d-fractals-vi-the-mandelbox/
float3 offset = p;
float dr = 0;
// Parameters
int iterations = 8;//20;//14;
//scaleFactor = -2 + (_SinTime.x*4+2);
float fixedRadius = 1.0;
float minRadius = 0.5;
/*float foldingLimit = 0.2 + _SinTime.x/4 + 0.25;
float minRadius = 0.07;
float fixedRadius = 0.2;*/
//float scaleFactor = -0.8;
/*float foldingLimit = _FoldingLimit;
float minRadius = _MinRadius;
float fixedRadius = _FixedRadius;*/
for(int i=0; i<iterations; i++)
{
boxFold(p, dr, 1);
sphereFold(p, dr, minRadius, fixedRadius);
p = scaleFactor*p + offset;
//dr = dr*abs(scaleFactor)+1.0;
dr = dr*abs(scaleFactor)+1;
}
sdfData sdf;
sdf.mat = mat;
float r = length(p);
sdf.dist = r/abs(dr);
return sdf;
}
// Mandelbox alternate implementation, possibly faster
sdfData fracMandelbox2(float3 p, float foldingLimit, float minRadius, float fixedRadius, float scaleFactor, material mat = DEFMAT)
{
// http://www.fractalforums.com/3d-fractal-generation/a-mandelbox-distance-estimate-formula/
float scale = -2;
int iterations = 10;
float DEfactor;
for (int i = 0; i<iterations; i++)
{
DEfactor = scale;
fixedRadius = 1.0;
float fR2 = fixedRadius*fixedRadius;
minRadius = 0.5;
float mR2 = minRadius*minRadius;
// Box fold?
if (p.x > 1.0)
p.x = 2.0 - p.x;
else if (p.x < -1.0) p.x = -2.0 - p.x;
if (p.y > 1.0)
p.y = 2.0 - p.y;
else if (p.y < -1.0) p.y = -2.0 - p.y;
if (p.z > 1.0)
p.z = 2.0 - p.z;
else if (p.z < -1.0) p.z = -2.0 - p.z;
// radius squared
float r2 = dot(p,p);
if (r2 < mR2)
{
p*=(fR2/mR2);
DEfactor*=(fR2/mR2);
}
else if (r2 < fR2)
{
p*=(fR2/r2);
DEfactor*=(fR2/r2);
}
p=p*scale+1;
DEfactor*=scale;
}
sdfData sdf;
sdf.mat = mat;
sdf.dist = length(p)/abs(DEfactor);
return sdf;
}
// Feather
sdfData fracFeather(float3 p, float cx = 2.0, float cy = 2.7, float cz = 1.4, material mat=DEFMAT)
{
// https://fractalforums.org/index.php?action=gallery;sa=view;id=5732
int iterations = 5;
//float cx = 2.0;
//float cy = 2.7;
//float cz = 1.4;
float cw = 0.1;
float dx = 1.5;// + _FoldingLimit-0.5;
float lp,r2,s = 1;
float icy = 1.0 / cy;
float3 p2,cy3 = float3(cy,cy,cy);
for (int i=0; i<iterations; i++) {
p -= cx * round(p / cx);
p2 = pow(abs(p),cy3);
lp = pow(p2.x + p2.y + p2.z, icy);
r2 = dx / max( pow(lp,cz), cw);
p *= r2;
s *= r2;
}
sdfData o;
o.mat = mat;
o.dist = length(p)/s-.001;
return o;
}
//////////////////////////////////////////////////////////////////////
//
// Transforms
//
//////////////////////////////////////////////////////////////////////
// rotate point p around origin, a radians
float3 rotX(float3 p, float a)
{
return mul(float3x3(1, 0, 0, 0, cos(a), -sin(a), 0, sin(a), cos(a)), p);
}
// rotate point p around origin, a radians
float3 rotY(float3 p, float a)
{
return mul(float3x3(cos(a), 0, sin(a), 0, 1, 0, -sin(a), 0, cos(a)), p);
}
// rotate point p around origin, a radians
float3 rotZ(float3 p, float a)
{
return mul(float3x3(cos(a), -sin(a), 0, sin(a), cos(a), 0, 0, 0, 1), p);
}
// repeats space every r units, centered on the origin
inline float3 repXYZ(float3 p, float3 r)
{
float3 o = p;
o = fmod(abs(p + r/2.0), r) - r/2.0;
o *= sign(o);
return o;
}
// repeats space every r units, centered on the origin, no sign
inline float3 repXYZUnsigned(float3 p, float3 r)
{
return fmod(abs(p + r/2.0), r) - r/2.0;
}
// repeats space every r units, centered on the origin
inline float3 repXZ(float3 p, float x, float z)
{
float3 o = p;
o.x = fmod(abs(p.x) + x/2.0, x) - x/2.0;
o.x *= sign(p.x);
o.z = fmod(abs(p.z) + z/2.0, z) - z/2.0;
o.z *= sign(p.z);
return o;
}
// Reflect point if inside/outside sphere
void sphereFold(
inout float3 p,
inout float dz,
float minRadius,
float fixedRadius)
{
float r2 = dot(p,p);
float r = length(p);
if (r<minRadius)
{
// Inner scaling linear
float factor = fixedRadius/minRadius;
p *= factor;
dz *= factor;
}
else if (r2<fixedRadius)
{
// Sphere inversion
float factor = fixedRadius/r2;
p *= factor;
dz *= factor;
}
// else no transform
}
// Reflect if outside box
void boxFold(inout float3 p,
float dz,
float foldingLimit)
{
p = clamp(p, -foldingLimit, foldingLimit) * 2.0 - p;
//p = clamp(p, -foldingLimit, foldingLimit) * 2.0 - p;
}
//////////////////////////////////////////////////////////////////////
//
// Color transform
//
//////////////////////////////////////////////////////////////////////
fixed4 HSV (fixed h, fixed s, fixed v)
{
h *= 6;
fixed c = s * v;
float x = c * (1 - abs(fmod(h, 2) - 1));
float m = v-c;
c += m;
x += m;
fixed4 colors[6] = {
fixed4(c, x, m, 1),
fixed4(x, c, m, 1),
fixed4(m, c, x, 1),
fixed4(m, x, c, 1),
fixed4(x, m, c, 1),
fixed4(c, m, x, 1)};
return colors[int(h)];
}
#endif //RAY_MARCH_LIB_INCLUDED