updating of DE-Raytracer

[3dickulus]

Use large tiles 2x2 or 3x3 (960x540 or 1280x720) and you will get approximately the same picture like from GUI.

so a 1x1 tile with the same settings should get the same image as GUI ?

I modified Fragmentarium sourcecode to allow tile render to use 1920x1080 and the image produced (scaled for display here) tells me that smaller tile size does not mean smaller bloom size, it is overall image size that has impact.

even if I exceed max intensity x2 or x20 I still get image not like the GUI image in http://www.fractalforums.com/index.php?topic=20680.msg91937#msg91937

can Bloom be scaled or factored by image size?

re:Radeon I won't be able to help until I can see what happens in debugger or run with some console output to find where it hangs

[Crist-JRoger]

so a 1x1 tile with the same settings should get the same image as GUI ?

Yes one to one.
I quickly tested now... And see that bloom size depends from image size, not tile. Thank you for explanations.
When i prepared for large final render i increase bloom more and more to see result like viewing from GUI 

I modified Fragmentarium sourcecode to allow tile render to use 1920x1080 and the image produced (scaled for display here) tells me that smaller tile size does not mean smaller bloom size, it is overall image size that has impact.

Small tiles = more padding, and there is a chance to get something like this:

[3dickulus]

yes, tile size must be big enough to cover the extent of bloom coverage
I think it's BloomTaps that needs to get scaled...

GUI view = 512x288
final image = 3840x2160

scale BloomTaps by 7.5x

so if BloomTaps = 20 in GUI view it needs to be 150 for final render
with tile size = GUI view and 100% padding

testing now ETA 1hr , scaling BloomTaps increases render time by 3x

[3dickulus]

yeah! nailed it!

here is the result of scaling BloomTaps only
BloomPower and BloomIntensity remain the same

the left image is the GUI the right image is the final render 

edit: yes, I see tiles need to be just a little bigger for this image or back off intensity a bit.

[Crist-JRoger]

scaling BloomTaps? did you mean increse? How many BloomTaps?

[3dickulus]

GUI view = 512x288               BloomTaps = 20

final image = 3840x2160       BloomTaps = 150

sqrt ((3840*2160) / (512*288)) = 7.5

BloomTaps *= 7.5; 

increase BloomTaps by 7.5 times for final render

http://www.fractalforums.com/images-showcase-%28rate-my-fractal%29/bloom-test-t23544/

[Crist-JRoger]

150???    it`s crazy

so i Tested fullscreen render on extremely hard settings (for me... on radeon hd7850) And i got artifacts!     
BloomTaps = 39, Detail = -3.9, HF_FogIter = 4, HF_Scatter = 172, ReflectionsNumber = 2, 1700 subframes

[3dickulus]

the image (linked above) was rendered with only 32 subframes

 Tile size 768x432
 100% padding

 BloomTaps = 150
 Detail = -3
 HF_FogIter = 16
 HF_Scatter = 10
 ReflectionsNumber = 0

render takes the same time using original version or latest version and both look identical

tiled render not full screen, I am also using wang hash function for RNG seed

will post you the frags later if you would like to test on radeon

[Crist-JRoger]

Ok, thank you!
I always set a lot of subframes for total decrease all dither noise 

[Crist-JRoger]

Try add Kali's particles for DE-Kn2. Unfortunately my knowledge of GLSL language is not enough. So i added Kaliset3D.frag, and this code mainly copied from Volumetric.frag

Code:

#group KalisetLight
uniform float VolumetricRayStep;slider[0.01,0.1,1.];
uniform float VolumetricDither;slider[0,.01,.2];
uniform int MinDistance;  slider[0,5,50]

uniform float LightRad; slider[0.0,0.0,5.0]
uniform float LightExp; slider[0.0,1.0,5.0]
uniform float LightGlowIntensity; slider[0.0,0.0,1.0]
uniform float LightGlowClear; slider[0.0,0.0,10.0]
uniform float VolumetricShadow; slider[0,0,5] 
uniform float MinLight; slider[0.0,0.0,1.0]

vec3 ptLightGlowK(vec3 from, vec3 pos){
	SRay Ray;
	from+=((rand(dir.xy+vec2(subframe,subframe*1.12358))-.5)*VolumetricDither);
	float kglow=0;	
	int c=0;
	float lf=0;
	float sh=0;
	vec3 col = vec3(0.0);
	if (!lighthit && LightGlowIntensity>0.) {
		for (float r=MinDistance; r<MaxDistance; r+=VolumetricRayStep) {
			vec3 p=from+r*dir;
			//vec3 p = SRCurrentPt(Ray);
			vec3 spotDir1 = normalize(LightPos-Ray.Pos);
			//vec3 lightdir=-lightnormal(p,.01);
			vec3 lightdir=spotDir1;
			float ep=exp(-(LightGlowClear*.01)*r*r);
			float k=max(MinLight,Kaliset(p)*KFinalScale);
			sh=shadow(p,lightdir,minDist*10);
			lf+=k*ep*clamp((1-sh),VolumetricShadow,1.);
			c++;
		}
	}
	lf=max(0,lf);
	lf*=VolumetricRayStep;
	lf*=LightGlowIntensity*5;	
	float glow1=exp(-pow(1/LightRad,4)*pow(kglow,LightExp));
	float glow2=exp(-10*pow(kglow,1));
	col=SpotLight.xyz*glow1*SpotLight.w*lf+SpotLight.xyz*glow2*SpotLight.w*2;
	return col;
}

And than called in vec3 color

Code:

col0+=ptLightGlowK(prevPos,curPos);

I wrote at random, so please correct.

[Crist-JRoger]

Testing renderer. Use #define USE_HMAP for enable height-mapping. Still has artifacts... and aliasing (need help for better height-mapping code)
Added floor/terrain texturing.

Code:

if (floorHit) {
			hitColor = FloorColor;
			if(EnableFloorPic) {			
				vec3 p = SRCurrentPt(Ray);
				p=rotFloor*p;
				p+=MovTer;
				hitColor += FloorColor+FPicBright*texture2D(tex, p*htexturespeed+htextoff);			
			}
		}

I think it`s right code 
Testing texture with renderer in attach.

<sub>Nodither, FudgeFactor=0.5


Dither, FudgeFactor=0.1


Nodither, FudgeFactor=0.1


Dither, FudgeFactor=0.1</sub>

[Patryk Kizny]

The problems you're having have to do with how height maps are working with DE - it's inherent.
DE should be returning the minimum distance to an isosurface or object. While using height mapping in the form of

float DE = function(vec3 p) {
return p.z + myheightmap;
}

It's inaccurate. And it's becoming more and more inaccurate the higher the height value.
So within DE raytracer you can't expect it to be precise. You'd have to go bruteforce.

[Crist-JRoger]

float DE = function(vec3 p) {
return p.z + myheightmap;
}

It's inaccurate. And it's becoming more and more inaccurate the higher the height value.

Maybe there's another function?
Or some smooth method for heightmap?


_{upd. Another one heightmap test}


used this texture

[Crist-JRoger]

Played a little with terrain for creating better ocean ripples effect 

_{Just quick renders on intel GPU}

Code:

#include "Classic-Noise.frag"
uniform int FloorIter1;  slider[0,3,50]
uniform float FreqMul1; slider[1,2,10]
uniform float AmpMul1; slider[0,0.3,1]
uniform float Offset1; slider[0,0.4,1]

uniform int FloorIter2;  slider[0,3,50]
uniform float FreqMul2; slider[1,2,10]
uniform float AmpMul2; slider[0,0.3,1]
uniform float Offset2; slider[0,0.4,1]

uniform vec2 Period; slider[(0,0),(1,1),(1,1)]
uniform vec3 off1; slider[(-10,-10,-10),(1,1,1),(10,10,10)]

float water(vec3 pos) {
	float A = 1.0;
	float B = 1.0;
	float C = 1.0;
	float D = 1.0;
	float r = 0.0;
	for (int i = 0; i < FloorIter1; i++) {
		r+= B*cnoise(A*(pos.xy)+Offset1);
		A*=FreqMul1;
		B*=AmpMul1;
	}
	for (int j = 0; j < FloorIter2; j++) {
		r+= D*pnoise(C*(pos.xy)+Offset2, Period);
		C*=FreqMul2;
		D*=AmpMul2;
	}
	return r;
}

float height(vec3 pos) {
pos*=off1;
return water(pos);
}

[Crist-JRoger]

Added second floor. Used here for water surface: