Here’s a chunk of my code for compute.

DX11 stuff has far too much cludge I have to clean up (it’s really really bad cludge), and OpenGL is still an SSBO land and it’s just a mess (spoiler: you can have compute but no SSBO with OGL drivers - and I have 2 of those machines). I legitimately would feel like poo if I put those out.

OpenCL on the other-hand is dandy!

For some reason, I can’t find my CMake scripts that dealt with finding OpenCL and setting all this up, once I find them I’ll add them into the repo (and as patch-files in another Patch folder).

Do not count on me to fulfill anything with this one, write your own DX11 or OGL versions of the common interface, refine it, w/e.

The OpenCL code has shipped, several times - though this exact incarnation (ported to Urho3D) has not. It’s been a traveling thing following me everywhere I go.

If you need a hand being horrified away from compute, here’s some density functions I use for SDFs in compute (not just bytecode, but implied bytecode):

#define MATRIX_SIZE 3
#define SprueMin(a, b) (((a) < (b)) ? (a) : (b))
#define SprueMax(a, b) (((a) > (b)) ? (a) : (b))
#define MaxElem(a) (max(a.x, max(a.y, a.z)))

float3 MatrixMul(float3 pos, const global float4* transforms, int* shapeIndex)
{
float4 f4 = { pos.x, pos.y, pos.z, 1.0f };
int idx = (*shapeIndex)++;
return (float3) { dot(transforms[idx * 3], f4), dot(transforms[idx * 3 + 1], f4), dot(transforms[idx * 3 + 2], f4) };
}

float length2(float3 a)
{
return a.x * a.x + a.y * a.y + a.z * a.z;
}

float3 ClosestPoint(float3 a, float3 b, float3 point)
{
float3 dir = b - a;
return a + clamp(dot(point - a, dir) / length2(dir), 0.0f, 1.0f) * dir;
}

float SphereDensity(float3 pos, const global float* data, const global float4* transforms, int* paramIndex, int* shapeIndex)
{
pos = MatrixMul(pos, transforms, shapeIndex);
(*paramIndex) = (*paramIndex) + 1;
// TODO
}

float BoxDensity(float3 pos, const global float* data, const global float4* transforms, int* paramIndex, int* shapeIndex)
{
pos = MatrixMul(pos, transforms, shapeIndex);
const float xDim = data[(*paramIndex)++]/2.0f;
const float yDim = data[(*paramIndex)++]/2.0f;
const float zDim = data[(*paramIndex)++]/2.0f;

float3 d = fabs(pos) - (float3){ xDim, yDim, zDim };
//d -= float3 { xDim, yDim, zDim };
return SprueMin(MaxElem(d), 0.0f) + length(max(d, (float3){ 0,0,0 }));
}

float RoundedBoxDensity(float3 pos, const global float* data, const global float4* transforms, int* paramIndex, int* shapeIndex)
{
pos = MatrixMul(pos, transforms, shapeIndex);
const float xDim = data[(*paramIndex)++]/4.0f;
const float yDim = data[(*paramIndex)++]/4.0f;
const float zDim = data[(*paramIndex)++]/4.0f;
const float rounding = data[(*paramIndex)++];

float3 d = fabs(pos) - (float3){ xDim, yDim, zDim };
return SprueMin(MaxElem(d), 0.0f) + length(max(d, (float3){0,0,0})) - rounding;
}

float ConeDensity(float3 p, const global float* data, const global float4* transforms, int* paramIndex, int* shapeIndex)
{
p = MatrixMul(p, transforms, shapeIndex);
const float c = data[*paramIndex];// / 2.0f;
*paramIndex = *paramIndex + 1;

const float r = data[*paramIndex];
*paramIndex = *paramIndex + 1;

float d = length((float2)(p.x, p.z)) - r * (1.0f - (c + p.y) / (c + c));
d = max(d, -p.y - c);
d = max(d, p.y - c);
return d;
}

float EllipsoidDensity(float3 p, const global float* data, const global float4* transforms, int* paramIndex, int* shapeIndex)
{
p = MatrixMul(p, transforms, shapeIndex);
const float paramX = data[(*paramIndex)++];
const float paramY = data[(*paramIndex)++];
const float paramZ = data[(*paramIndex)++];
return (length(p / (float3){paramX,paramY, paramZ}) - 1.0f) * min(min(paramX,paramY),paramZ);
}

float CylinderDensity(float3 p, const global float* data, const global float4* transforms, int* paramIndex, int* shapeIndex)
{
p = MatrixMul(p, transforms, shapeIndex);
const float height = data[(*paramIndex)++];

float4 pt = { p.x, p.z, 0, 0 };
float d = length(pt) - radius;
return max(d, fabs(p.y) - height * 0.5f);
}

float CapsuleDensity(float3 p, const global float* data, const global float4* transforms, int* paramIndex, int* shapeIndex)
{
p = MatrixMul(p, transforms, shapeIndex);
float p1 = data[(*paramIndex)++];
float p2 = data[(*paramIndex)++];
float3 a = { 0.0f, 0.0f, p2 / 2.0f };
float3 b = { 0.0f, 0.0f, -a.z };
float3 nearest = ClosestPoint(a, b, p);
return length(p - nearest) - p1;
}

float PlaneDensity(float3 p, const global float* data, const global float4* transforms, int* paramIndex, int* shapeIndex)
{
p = MatrixMul(p, transforms, shapeIndex);
return dot(p, (float3){ data[(*paramIndex)++], data[(*paramIndex)++], data[(*paramIndex)++] }) + data[(*paramIndex)++];
}

float TorusDensity(float3 p, const global float* data, const global float4* transforms, int* paramindex, int* shapeIndex)
{
p = MatrixMul(p, transforms, shapeIndex);
float4 q = { length((float4){ p.x, p.z, 0, 0 }) - data[(*paramindex)++], p.y, 0, 0 };
return length(q) - data[(*paramindex)++];
}

float Segment(float3 p, const global float* data, const global float4* transforms, int* paramIndex, int* shapeIndex)
{
p = MatrixMul(p, transforms, shapeIndex);
float segmentCount = data[(*paramIndex)++];
float currentDistance = 100000.0f;
for (float i = 0.0; i < segmentCount - 1; i += 1.0)
{
float sx  = data[(*paramIndex)++];
float sy  = data[(*paramIndex)++];
float sz  = data[(*paramIndex)++];
float sdx = data[(*paramIndex)++];
float sdy = data[(*paramIndex)++];
float sdz = data[(*paramIndex)++];

float3 startPos = { sx,sy,sz };
float3 startDim = { sdx, sdy, sdz };

float ex  = data[(*paramIndex)++];
float ey  = data[(*paramIndex)++];
float ez  = data[(*paramIndex)++];
float edx = data[(*paramIndex)++];
float edy = data[(*paramIndex)++];
float edz = data[(*paramIndex)++];

float3 endPos = { ex, ey, ez };
float3 endDim = { edx, edy, edz };

float3 pa = p - startPos;
float3 ba = endPos - startPos;
float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0f, 1.0f);

// Calculate an ellipsoid distance at the given point
float3 interpRad = mix(startDim, endDim, h);

currentDistance = min(currentDistance, distance);
}
return currentDistance;
}

float2 octahedron(float3 p, float r) {
float3 o = (fabs(p)/sqrt(3.f));
float s = (o.x+o.y+o.z);
return (float2)((s-(r*(2.f/sqrt(3.f)))),1.f);
}

float3 opTwist(float3 p) {
float t = 3.f;
float c = cos((t*p.y));
float s = sin((t*p.y));
float2 mp = { c * p.x - s * p.z, s * p.x + c * p.z };
float3 q = (float3)(mp.x, mp.y, p.y);
return q;
}

float PaniqQDensity(float3 p) {
p = opTwist(p);
//p = p * 0.1f;
float2 o = octahedron(p,15.0f);
float m = min(o.x, o.y);
return m;
//return max(m, (10.0f-length(p)));
}

float tangle(float3 p)
{
p = p * 0.1f;
float a = p.x * p.x * p.x * p.x;
float b = -5.f * (p.x * p.x);
float c = p.y * p.y * p.y * p.y;
float d = -5.f * (p.y * p.y);
float e = p.z * p.z * p.z * p.z;
float f = -5.f * (p.z * p.z);
float g = 11.8f;
return a + b + c + d + e + f + g;
}

{
return min(lhs, rhs);
}

float CSGSubtract(float lhs, float rhs)
{
return max(lhs, -rhs);
}

float CSGIntersect(float lhs, float rhs)
{
return max(lhs, rhs);
}

float EvaluateShape(float3 p, const global float* data, const global float4* transforms, int* paramIndex, int* shapeIndex)
{
uint shapeID = data[*paramIndex];
(*paramIndex)++;

switch (shapeID)
{
case 0: // Sphere
return SphereDensity(p, data, transforms, paramIndex, shapeIndex);
case 1: // Box
return BoxDensity(p, data, transforms, paramIndex, shapeIndex);
case 2: // rounded box
break;
case 3: // Capsule
return CapsuleDensity(p, data, transforms, paramIndex, shapeIndex);
case 4: // Cylinder
return CylinderDensity(p, data, transforms, paramIndex, shapeIndex);
case 5: // Cone
return ConeDensity(p, data, transforms, paramIndex, shapeIndex);
case 6: // Plane
return PlaneDensity(p, data, transforms, paramIndex, shapeIndex);
case 7: // Ellipsoid
return EllipsoidDensity(p, data, transforms, paramIndex, shapeIndex);
case 8: // Torus
case 9: // Reserved space for super ellipsoid ... if the patent ever goes away
return 1000.0f;
case 10: // Reserved space for Segment
break;
case 11: // Reserved space for Catmul-Rom spline
break;
}
return 1000.0f;
}

float EvaluateGraph(float curDensity, float3 p, const global float* data, const global float4* transforms, int* paramIndex, int* shapeIndex)
{
uint command = data[*paramIndex];
(*paramIndex)++;

// Todo: consider a stack, Blist won't actually work
while (command != 0)
{
float density = EvaluateShape(p, data, transforms, paramIndex, shapeIndex);

switch (command)
{
case 0:
return curDensity;
case 1:
break;
case 2:
curDensity = CSGSubtract(curDensity, density);
break;
case 3:
curDensity = CSGIntersect(curDensity, density);
break;
}

command = data[*paramIndex];
}

return curDensity;
}

float EvaluateDensity(float3 p, const global float* data, const global float4* transforms, int* paramIndex, int* shapeIndex)
{
float density = EvaluateShape(p, data, transforms, paramIndex, shapeIndex);
return EvaluateGraph(density, p, data, transforms, paramIndex, shapeIndex);
}
1 Like