Help with errors..

[eq]

Sorry for not replying earlier but as I said previously the time I allow myself to work on this is limited

Thanks for you solution David, unfortunately for me I can't use array's in my HLSL code which makes your solution very hard to implement.

The problem I have right now is so weird I'm going crazy.
In essence: better quality (i.e less "misses") equals smaller step distances, right?

I.e stepping DE * 0.1 should always gives at least as good results as stepping DE?

This is what I get:



The ray marching code I use is:

bool
hitTest(out float rayDist, float3 rayOrigin, float3 rayDir, float solidThreshold, float intersectionFailDistance)
{
   rayDist = 0.0f;
   [loop] while (rayDist <= intersectionFailDistance){
      float3 testPoint = rayOrigin + rayDir * rayDist;
      float solidDist = estimateMandelbulbDistance(testPoint);
      if (solidDist <= solidThreshold)
         break;
//      solidDist *= 0.1f;
      rayDist += solidDist;
   }
   return rayDist < intersectionFailDistance;
}

Scaling the solidDistance as shown above gives me the problem displayed.

How could that be?
Am I chasing some sort of precision problem here?

[Jesse]

Have you thresholded the upper and lower limit of the DE function?

Something like:
...
return r * log(r) * 0.5f / (dr + maxThreshold) + solidThreshold * 0.2;

and:
maxThreshold = bailoutR * solidThreshold * 0.01

Or try out better values, but thresholding is essentially, otherwise you are stepping in flat regions, for example beside the star,
direct to infinity!

Correction:
dr is never below 1.0, so maxThreshold should not be necessary.
Your method differs from the ones i knew:
Accumulating dr should result in accumulating inaccuracies in each iteration?
Wondering if this is still working in different areas and with higher iteration counts.

Anyway: Bailout R of 2.0 is too low, i have artefacts just between the minibulbs in the 2D view, i would go
up to 3.0 or more.

[David Makin]

How could that be?
Am I chasing some sort of precision problem here?

I would think that is the problem - compared to my implimentation your code is missing an important step, in English:

If new step distance<minimum allowed step distance then new step distance = minimum allowed step distance

The minimum allowed step distance to use depends on the resolution/magnification/threshold but generally if using 0.1*DE as the step distance then using 0.1*threshold for the minimum step should work - provided of course that 0.1*threshold is not out of accuracy and actually zero

[hobold]

Clipping the step distance to a lower bound is not the only alternative. For GPUs and other SIMD machines, you can do:

position += DE + minimum_step;

and save the conditional branch. Or if your renderer is voxel based, you know that there is a lower size limit on the visible details, hence some minimal step size is guaranteed not to introduce arbitrarily large errors (those were introduced already when you sampled the volume).

[David Makin]

Thanks for you solution David, unfortunately for me I can't use array's in my HLSL code which makes your solution very hard to implement.

Is it not possible to use a texture as a modifiable array ? Or are textures read only ?
My knowledge of GPU programming is currently limited - so far all I've done is a 2D Mandelbrot renderer in shader 2 (just as a test on the iPhone).