Pixelated sphere DE?

[DarkBeam]

I wanted to realize a sphere that looks like pixelated (Minecraft like)...
Without slow methods like "place one cube then another one ..." and a smooth distance estimation. Possible? Knighty if you have some time

[lycium]

Just about to head to bed, but had an idea - is it maybe possible to find the closest cube (pretty easy), and use the DE for that?

[Patryk Kizny]

I would try to use modulo for that so just modulo something small (your pixel) and limit it with the sphere volume (length(v) < R)

[zebastian]

@Patryck: i think a modulo on the view vector will cubify not to the global grid, but only quantify length in view direction.
Anyway, if we map every found point on the sphere surface to the rasterized grid (find nearest cube) we could calculate the distance to this cube.
This will have the upside, that this method will work on different kinds of surfaces (but surfaces will need to be smooth)
What do you think?

Here some pseudo code:

double distToSphere = getDistanceToSphere(cameraPosition ...);
CVector3 hitSphere = cameraPosition + normalizedViewVector * dist;
CVector3 centerHitCube = hitSphere - (hitSphere.mod(cubeDimension));
double distToCube = getDistanceToCube(centerHitCube...);
return distToCube;

[lycium]

is it maybe possible to find the closest cube (pretty easy), and use the DE for that?

Anyway, if we map every found point on the sphere surface to the rasterized grid (find nearest cube) we could calculate the distance to this cube.

 

[zebastian]

  oh yeah, thats pretty much it
i just wanted to give an example, how to integrate this into the calculation.

A more interesting question is:
Can we find a way to get a cube which is constant for all view vectors hitting the cube (for arbitrary surfaces).
If the surface is disturbed two view vectors close to each other should hit the same cube, but one may be more than boxSize away, so the boxes will have holes

[lycium]

might be necessarily to check the neighbour blocks (also ensuring that their centre is still < radius).

[Aexion]

You can just simulate low resolution coordinates:

Code:

double Sphere(double x,double y,double z){
x*=45;
y*=45;
z*=45;
x=int(x);
y=int(y);
z=int(z);
x/=45;//just for clarification
y/=45;
z/=45;
const double a=sqrt(x*x+y*y+z*z)-1;
return (a);
}

[Buddhi]

Nice. I have also looked for it. Thanks for sharing this function.

[DarkBeam]

Wow interesting solution Ramiro! It is not the correct one (no discontinuity) I was looking for but should work! Still if someone has the smooth solution please post ok.

[zebastian]

great idea aexion, this works quite good on all kinds of primite objects.
i did some tests in mandelbulber, see screenshot attached.
only change was adding this to modify the position of the surface point, before calculation of the distance:

point.x = ((int)(point.x * 10)) / 10.0;
point.y = ((int)(point.y * 10)) / 10.0;
point.z = ((int)(point.z * 10)) / 10.0;

@buddhi, what do you think about adding another modifier for this?

[knighty]

interesting!
If it is just for a sphere, it should be possible. Something like what lycium suggested.
The only general solution I could think about is exactly the one you want to avoid. No miracle!
Anyway! One can still use DDA when close to the surface.
There is a very cool shadertoy toy out there with a voxelized pac man that mainly uses DE.

[knighty]

Ok! here is my attempt.
It comes with a sphere but it can be used for any DE. The method is general and costly: more than 27 evaluations of the base DE.
It can be optimized for convex objects: If one have the gradient of the base DE then it is not necessary to check for 27 cells, only 8.

... And of course use the base DE when far from the object...

[knighty]

BTW!
A little bit off topic but related. This excellent shader by eiffie: https://www.shadertoy.com/view/llf3z8
also: https://www.shadertoy.com/view/Xlf3zf

[Aexion]

If anyone is interested, here's the hexagonal (honeycomb) version:

It basically transforms the (x,z) coordinates into the hexagonal (q,r) coordinates, then transforms it again to (x,z).
This wasn't easy to guess at first, I tried a lot of formulas and combinations until I comes with this solution.
Is not perfect, but its a good start. The code is unoptimized, but that's because I want to make it very clear.

Code:

double HexSphere(double x,double y,double z){
x*=0.6;//scaling.. don't ask..
x*=45;//45 hexagons by unit
y*=45;
z*=45;
y=int(y);
//converts (x,z) to (r,q)
const double temp = floor(x + z);
const double r = floor((floor(z - x) + temp) / 3.0);  
const double q = floor((floor(2 * x + 1) + temp) / 3.0) - r;
x = 3.0/2.0 * r;  //turns back, r q to x z
z = sqrt(3.0) * (q + r/2.0);
x/=45.0;//just for clarification
y/=45.0;
z/=45.0;
const double a=sqrt(x*x+y*y+z*z)-1;
return (a);
}

For more info on hexagonal coordinates, this is a good source: http://www.redblobgames.com/grids/hexagons/

Hope you like it..