sRGBAfloat cRenderWorker::VolumetricShader(
const sShaderInputData &input, sRGBAfloat oldPixel, sRGBAfloat *opacityOut)
{
sRGBAfloat output;
float totalOpacity = 0.0;
output.R = oldPixel.R;
output.G = oldPixel.G;
output.B = oldPixel.B;
output.A = oldPixel.A;
// volumetric fog init
double colourThresh = params->volFogColour1Distance;
double colourThresh2 = params->volFogColour2Distance;
double fogReduce = params->volFogDistanceFactor;
double fogIntensity = params->volFogDensity;
// visible lights init
int numberOfLights = data->lights.GetNumberOfLights();
if (numberOfLights < 4) numberOfLights = 4;
// glow init
double glow = input.stepCount * params->glowIntensity / 512.0 * params->DEFactor;
double glowN = 1.0 - glow;
if (glowN < 0.0) glowN = 0.0;
double glowR = (params->glowColor1.R * glowN + params->glowColor2.R * glow) / 65536.0;
double glowG = (params->glowColor1.G * glowN + params->glowColor2.G * glow) / 65536.0;
double glowB = (params->glowColor1.B * glowN + params->glowColor2.B * glow) / 65536.0;
double totalStep = 0.0;
// qDebug() << "Start volumetric shader &&&&&&&&&&&&&&&&&&&&";
sShaderInputData input2 = input;
for (int index = input.stepCount - 1; index > 0; index--)
{
double step = input.stepBuff[index].step;
double distance = input.stepBuff[index].distance;
CVector3 point = input.stepBuff[index].point;
totalStep += step;
input2.point = point;
input2.distThresh = input.stepBuff[index].distThresh;
// qDebug() << "i" << index << "dist" << distance << "iters" << input.stepBuff[index].iters <<
// "distThresh" << input2.distThresh << "step" << step << "point" << point.Debug();
if (totalStep < CalcDelta(point))
{
continue;
}
step = totalStep;
totalStep = 0.0;
//------------------- glow
if (params->glowEnabled)
{
double glowOpacity = glow / input.stepCount;
if (glowOpacity > 1.0) glowOpacity = 1.0;
output.R = glowOpacity * glowR + (1.0 - glowOpacity) * output.R;
output.G = glowOpacity * glowG + (1.0 - glowOpacity) * output.G;
output.B = glowOpacity * glowB + (1.0 - glowOpacity) * output.B;
output.A += glowOpacity;
}
// qDebug() << "step" << step;
//------------------ visible light
if (params->auxLightVisibility > 0)
{
double miniStep = 0.0;
double lastMiniSteps = -1.0;
for (double miniSteps = 0.0; miniSteps < step; miniSteps += miniStep)
{
double lowestLightSize = 1e10;
double lowestLightDist = 1e10;
for (int i = 0; i < numberOfLights; ++i)
{
const cLights::sLight *light = data->lights.GetLight(i);
if (light->enabled)
{
CVector3 lightDistVect = (point - input.viewVector * miniSteps) - light->position;
double lightDist = lightDistVect.Length();
double lightSize = sqrt(light->intensity) * params->auxLightVisibilitySize;
double distToLightSurface = lightDist - lightSize;
if (distToLightSurface < 0.0) distToLightSurface = 0.0;
if (distToLightSurface <= lowestLightDist)
{
if (lightSize < lowestLightSize)
{
lowestLightSize = lightSize;
}
lowestLightDist = distToLightSurface;
}
}
}
miniStep = 0.1 * (lowestLightDist + 0.1 * lowestLightSize);
if (miniStep > step - miniSteps) miniStep = step - miniSteps;
// qDebug() << "lowDist:" << lowestLightDist << "lowSize" << lowestLightSize << "miniStep"
// << miniStep;
for (int i = 0; i < numberOfLights; ++i)
{
const cLights::sLight *light = data->lights.GetLight(i);
if (light->enabled)
{
CVector3 lightDistVect = (point - input.viewVector * miniSteps) - light->position;
double lightDist = lightDistVect.Length();
double lightSize = sqrt(light->intensity) * params->auxLightVisibilitySize;
double r2 = lightDist / lightSize;
double bellFunction = 1.0 / (1.0 + pow(r2, 4.0));
double lightDensity = miniStep * bellFunction * params->auxLightVisibility / lightSize;
output.R += lightDensity * light->colour.R / 65536.0;
output.G += lightDensity * light->colour.G / 65536.0;
output.B += lightDensity * light->colour.B / 65536.0;
output.A += lightDensity;
}
}
if (miniSteps == lastMiniSteps)
{
// qWarning() << "Dead computation\n"
// << "\npoint:" << (point - input.viewVector * miniSteps).Debug();
break;
}
lastMiniSteps = miniSteps;
}
}
// fake lights (orbit trap)
if (params->fakeLightsEnabled)
{
sFractalIn fractIn(point, params->minN, params->N, params->common, -1);
sFractalOut fractOut;
Compute<fractal::calcModeOrbitTrap>(*fractal, fractIn, &fractOut);
double r = fractOut.orbitTrapR;
r = sqrt(1.0f / (r + 1.0e-30f));
double fakeLight = 1.0 / (pow(r, 10.0 / params->fakeLightsVisibilitySize)
* pow(10.0, 10.0 / params->fakeLightsVisibilitySize)
+ 1e-100);
output.R += fakeLight * step * params->fakeLightsVisibility;
output.G += fakeLight * step * params->fakeLightsVisibility;
output.B += fakeLight * step * params->fakeLightsVisibility;
output.A += fakeLight * step * params->fakeLightsVisibility;
}
//---------------------- volumetric lights with shadows in fog
for (int i = 0; i < 5; i++)
{
if (i == 0 && params->volumetricLightEnabled[0])
{
sRGBAfloat shadowOutputTemp = MainShadow(input2);
output.R += shadowOutputTemp.R * step * params->volumetricLightIntensity[0]
* params->mainLightColour.R / 65536.0;
output.G += shadowOutputTemp.G * step * params->volumetricLightIntensity[0]
* params->mainLightColour.G / 65536.0;
output.B += shadowOutputTemp.B * step * params->volumetricLightIntensity[0]
* params->mainLightColour.B / 65536.0;
output.A += (shadowOutputTemp.R + shadowOutputTemp.G + shadowOutputTemp.B) / 3.0 * step
* params->volumetricLightIntensity[0];
}
if (i > 0)
{
const cLights::sLight *light = data->lights.GetLight(i - 1);
if (light->enabled && params->volumetricLightEnabled[i])
{
CVector3 lightVectorTemp = light->position - point;
double distanceLight = lightVectorTemp.Length();
double distanceLight2 = distanceLight * distanceLight;
lightVectorTemp.Normalize();
double lightShadow = AuxShadow(input2, distanceLight, lightVectorTemp);
output.R += lightShadow * light->colour.R / 65536.0 * params->volumetricLightIntensity[i]
* step / distanceLight2;
output.G += lightShadow * light->colour.G / 65536.0 * params->volumetricLightIntensity[i]
* step / distanceLight2;
output.B += lightShadow * light->colour.B / 65536.0 * params->volumetricLightIntensity[i]
* step / distanceLight2;
output.A += lightShadow * params->volumetricLightIntensity[i] * step / distanceLight2;
}
}
}
//----------------------- basic fog
if (params->fogEnabled)
{
double fogDensity = step / params->fogVisibility;
if (fogDensity > 1.0) fogDensity = 1.0;
output.R = fogDensity * params->fogColor.R / 65536.0 + (1.0 - fogDensity) * output.R;
output.G = fogDensity * params->fogColor.G / 65536.0 + (1.0 - fogDensity) * output.G;
output.B = fogDensity * params->fogColor.B / 65536.0 + (1.0 - fogDensity) * output.B;
totalOpacity = fogDensity + (1.0 - fogDensity) * totalOpacity;
output.A = fogDensity + (1.0 - fogDensity) * output.A;
}
//-------------------- volumetric fog
if (fogIntensity > 0.0 && params->volFogEnabled)
{
double densityTemp = (step * fogReduce) / (distance * distance + fogReduce * fogReduce);
double k = distance / colourThresh;
if (k > 1) k = 1.0;
double kn = 1.0 - k;
double fogRtemp = (params->volFogColour1.R * kn + params->volFogColour2.R * k);
double fogGtemp = (params->volFogColour1.G * kn + params->volFogColour2.G * k);
double fogBtemp = (params->volFogColour1.B * kn + params->volFogColour2.B * k);
double k2 = distance / colourThresh2 * k;
if (k2 > 1) k2 = 1.0;
kn = 1.0 - k2;
fogRtemp = (fogRtemp * kn + params->volFogColour3.R * k2);
fogGtemp = (fogGtemp * kn + params->volFogColour3.G * k2);
fogBtemp = (fogBtemp * kn + params->volFogColour3.B * k2);
double fogDensity = 0.3 * fogIntensity * densityTemp / (1.0 + fogIntensity * densityTemp);
if (fogDensity > 1) fogDensity = 1.0;
output.R = fogDensity * fogRtemp / 65536.0 + (1.0 - fogDensity) * output.R;
output.G = fogDensity * fogGtemp / 65536.0 + (1.0 - fogDensity) * output.G;
output.B = fogDensity * fogBtemp / 65536.0 + (1.0 - fogDensity) * output.B;
// qDebug() << "densityTemp " << densityTemp << "k" << k << "k2" << k2 << "fogTempR" <<
// fogRtemp << "fogDensity" << fogDensity << "output.R" << output.R;
totalOpacity = fogDensity + (1.0 - fogDensity) * totalOpacity;
output.A = fogDensity + (1.0 - fogDensity) * output.A;
}
// iter fog
if (params->iterFogEnabled)
{
int L = input.stepBuff[index].iters;
double opacity =
IterOpacity(step, L, params->N, params->iterFogOpacityTrim, params->iterFogOpacity);
sRGBAfloat newColour(0.0, 0.0, 0.0, 0.0);
if (opacity > 0)
{
// fog colour
double iterFactor1 = (L - params->iterFogOpacityTrim)
/ (params->iterFogColor1Maxiter - params->iterFogOpacityTrim);
double k = iterFactor1;
if (k > 1.0) k = 1.0;
if (k < 0.0) k = 0.0;
double kn = 1.0 - k;
double fogColR = (params->iterFogColour1.R * kn + params->iterFogColour2.R * k);
double fogColG = (params->iterFogColour1.G * kn + params->iterFogColour2.G * k);
double fogColB = (params->iterFogColour1.B * kn + params->iterFogColour2.B * k);
double iterFactor2 = (L - params->iterFogColor1Maxiter)
/ (params->iterFogColor2Maxiter - params->iterFogColor1Maxiter);
double k2 = iterFactor2;
if (k2 < 0.0) k2 = 0.0;
if (k2 > 1.0) k2 = 1.0;
kn = 1.0 - k2;
fogColR = (fogColR * kn + params->iterFogColour3.R * k2);
fogColG = (fogColG * kn + params->iterFogColour3.G * k2);
fogColB = (fogColB * kn + params->iterFogColour3.B * k2);
//----
for (int i = 0; i < 5; i++)
{
if (i == 0)
{
if (params->mainLightEnable && params->mainLightIntensity > 0.0)
{
sRGBAfloat shadowOutputTemp = MainShadow(input2);
newColour.R += shadowOutputTemp.R * params->mainLightColour.R / 65536.0
* params->mainLightIntensity;
newColour.G += shadowOutputTemp.G * params->mainLightColour.G / 65536.0
* params->mainLightIntensity;
newColour.B += shadowOutputTemp.B * params->mainLightColour.B / 65536.0
* params->mainLightIntensity;
}
}
if (i > 0)
{
const cLights::sLight *light = data->lights.GetLight(i - 1);
if (light->enabled)
{
CVector3 lightVectorTemp = light->position - point;
double distanceLight = lightVectorTemp.Length();
double distanceLight2 = distanceLight * distanceLight;
lightVectorTemp.Normalize();
double lightShadow = AuxShadow(input2, distanceLight, lightVectorTemp);
double intensity = light->intensity * 100.0;
newColour.R += lightShadow * light->colour.R / 65536.0 / distanceLight2 * intensity;
newColour.G += lightShadow * light->colour.G / 65536.0 / distanceLight2 * intensity;
newColour.B += lightShadow * light->colour.B / 65536.0 / distanceLight2 * intensity;
}
}
}
if (params->ambientOcclusionEnabled
&& params->ambientOcclusionMode == params::AOmodeMultipeRays)
{
sRGBAfloat AO = AmbientOcclusion(input2);
newColour.R += AO.R * params->ambientOcclusion;
newColour.G += AO.G * params->ambientOcclusion;
newColour.B += AO.B * params->ambientOcclusion;
}
if (opacity > 1.0) opacity = 1.0;
output.R = output.R * (1.0 - opacity) + newColour.R * opacity * fogColR / 65536.0;
output.G = output.G * (1.0 - opacity) + newColour.G * opacity * fogColG / 65536.0;
output.B = output.B * (1.0 - opacity) + newColour.B * opacity * fogColB / 65536.0;
totalOpacity = opacity + (1.0 - opacity) * totalOpacity;
output.A = opacity + (1.0 - opacity) * output.A;
}
}
if (totalOpacity > 1.0) totalOpacity = 1.0;
if (output.A > 1.0) output.A = 1.0;
(*opacityOut).R = totalOpacity;
(*opacityOut).G = totalOpacity;
(*opacityOut).B = totalOpacity;
} // next stepCount
return output;
}
sRGBAfloat cRenderWorker::ObjectShader(
const sShaderInputData &_input, sRGBAfloat *surfaceColour, sRGBAfloat *specularOut)
{
sRGBAfloat output;
// normal vector
CVector3 vn = _input.normal;
sShaderInputData input = _input;
cMaterial *mat = input.material;
input.normal = vn;
// main light
sRGBAfloat mainLight;
mainLight.R = params->mainLightIntensity * params->mainLightColour.R / 65536.0;
mainLight.G = params->mainLightIntensity * params->mainLightColour.G / 65536.0;
mainLight.B = params->mainLightIntensity * params->mainLightColour.B / 65536.0;
// calculate shading based on angle of incidence
sRGBAfloat shade;
if (params->mainLightEnable)
{
shade = MainShading(input);
shade.R = params->mainLightIntensity * ((1.0 - mat->shading) + mat->shading * shade.R);
shade.G = params->mainLightIntensity * ((1.0 - mat->shading) + mat->shading * shade.G);
shade.B = params->mainLightIntensity * ((1.0 - mat->shading) + mat->shading * shade.B);
}
// calculate shadow
sRGBAfloat shadow(1.0, 1.0, 1.0, 1.0);
if (params->shadow && params->mainLightEnable) shadow = MainShadow(input);
// calculate specular highlight
sRGBAfloat specular;
if (params->mainLightEnable)
{
specular = MainSpecular(input);
specular.R *= mat->specular;
specular.G *= mat->specular;
specular.B *= mat->specular;
}
// calculate surface colour
sRGBAfloat colour = SurfaceColour(input);
double texColInt = mat->colorTextureIntensity;
double texColIntN = 1.0 - mat->colorTextureIntensity;
colour.R *= input.texColor.R * texColInt + texColIntN;
colour.G *= input.texColor.G * texColInt + texColIntN;
colour.B *= input.texColor.B * texColInt + texColIntN;
*surfaceColour = colour;
// ambient occlusion
sRGBAfloat ambient(0.0, 0.0, 0.0, 0.0);
if (params->ambientOcclusionEnabled)
{
// fast mode
if (params->ambientOcclusionMode == params::AOmodeFast)
{
ambient = FastAmbientOcclusion(input);
}
else if (params->ambientOcclusionMode == params::AOmodeMultipeRays)
{
ambient = AmbientOcclusion(input);
}
}
sRGBAfloat ambient2;
ambient2.R = ambient.R * params->ambientOcclusion;
ambient2.G = ambient.G * params->ambientOcclusion;
ambient2.B = ambient.B * params->ambientOcclusion;
// environment mapping
sRGBAfloat envMapping(0.0, 0.0, 0.0, 0.0);
if (params->envMappingEnable)
{
envMapping = EnvMapping(input);
}
envMapping.R *= mat->reflectance * input.texDiffuse.R;
envMapping.G *= mat->reflectance * input.texDiffuse.G;
envMapping.B *= mat->reflectance * input.texDiffuse.B;
// additional lights
sRGBAfloat auxLights;
sRGBAfloat auxLightsSpecular;
auxLights = AuxLightsShader(input, &auxLightsSpecular);
// fake orbit trap lights
sRGBAfloat fakeLights(0.0, 0.0, 0.0, 0.0);
sRGBAfloat fakeLightsSpecular(0.0, 0.0, 0.0, 0.0);
if (params->fakeLightsEnabled)
{
fakeLights = FakeLights(input, &fakeLightsSpecular);
}
// luminosity
sRGBAfloat luminosity;
luminosity.R = input.texLuminosity.R * mat->luminosityTextureIntensity
+ mat->luminosity * mat->luminosityColor.R / 65536.0;
luminosity.G = input.texLuminosity.G * mat->luminosityTextureIntensity
+ mat->luminosity * mat->luminosityColor.G / 65536.0;
luminosity.B = input.texLuminosity.B * mat->luminosityTextureIntensity
+ mat->luminosity * mat->luminosityColor.B / 65536.0;
// total shader
output.R = envMapping.R + (ambient2.R + mainLight.R * shade.R * shadow.R) * colour.R;
output.G = envMapping.G + (ambient2.G + mainLight.G * shade.G * shadow.G) * colour.G;
output.B = envMapping.B + (ambient2.B + mainLight.B * shade.B * shadow.B) * colour.B;
output.R += (auxLights.R + fakeLights.R) * colour.R;
output.G += (auxLights.G + fakeLights.G) * colour.G;
output.B += (auxLights.B + fakeLights.B) * colour.B;
output.R += luminosity.R;
output.G += luminosity.G;
output.B += luminosity.B;
output.A = 1.0;
specularOut->R = auxLightsSpecular.R + fakeLightsSpecular.R + mainLight.R * specular.R * shadow.R;
specularOut->G = auxLightsSpecular.G + fakeLightsSpecular.G + mainLight.G * specular.G * shadow.G;
specularOut->B = auxLightsSpecular.B + fakeLightsSpecular.B + mainLight.B * specular.B * shadow.B;
specularOut->A = output.A;
return output;
}
sRGBAfloat cRenderWorker::ObjectShader(const sShaderInputData &_input, sRGBAfloat *surfaceColour,
sRGBAfloat *specularOut)
{
sRGBAfloat output;
//normal vector
CVector3 vn = _input.normal;
sShaderInputData input = _input;
input.normal = vn;
sRGBAfloat mainLight;
mainLight.R = params->mainLightIntensity * params->mainLightColour.R / 65536.0;
mainLight.G = params->mainLightIntensity * params->mainLightColour.G / 65536.0;
mainLight.B = params->mainLightIntensity * params->mainLightColour.B / 65536.0;
//calculate shading based on angle of incidence
sRGBAfloat shade;
if (params->mainLightEnable)
{
shade = MainShading(input);
shade.R = params->mainLightIntensity * ((1.0 - params->shading) + params->shading * shade.R);
shade.G = params->mainLightIntensity * ((1.0 - params->shading) + params->shading * shade.G);
shade.B = params->mainLightIntensity * ((1.0 - params->shading) + params->shading * shade.B);
}
//calculate shadow
sRGBAfloat shadow(1.0, 1.0, 1.0, 1.0);
if (params->shadow && params->mainLightEnable) shadow = MainShadow(input);
//calculate specular highlight
sRGBAfloat specular;
if (params->mainLightEnable)
{
specular = MainSpecular(input);
specular.R *= params->specular;
specular.G *= params->specular;
specular.B *= params->specular;
}
//calculate surface colour
sRGBAfloat colour = SurfaceColour(input);
*surfaceColour = colour;
//ambient occlusion
sRGBAfloat ambient(0.0, 0.0, 0.0, 0.0);
if (params->ambientOcclusionEnabled)
{
//fast mode
if (params->ambientOcclusionMode == params::AOmodeFast)
{
ambient = FastAmbientOcclusion(input);
}
else if (params->ambientOcclusionMode == params::AOmodeMultipeRays)
{
ambient = AmbientOcclusion(input);
}
}
sRGBAfloat ambient2;
ambient2.R = ambient.R * params->ambientOcclusion;
ambient2.G = ambient.G * params->ambientOcclusion;
ambient2.B = ambient.B * params->ambientOcclusion;
//environment mapping
sRGBAfloat envMapping(0.0, 0.0, 0.0, 0.0);
if (params->envMappingEnable)
{
envMapping = EnvMapping(input);
}
envMapping.R *= params->reflect;
envMapping.G *= params->reflect;
envMapping.B *= params->reflect;
//additional lights
sRGBAfloat auxLights;
sRGBAfloat auxLightsSpecular;
auxLights = AuxLightsShader(input, &auxLightsSpecular);
//fake orbit trap lights
sRGBAfloat fakeLights(0.0, 0.0, 0.0, 0.0);
sRGBAfloat fakeLightsSpecular(0.0, 0.0, 0.0, 0.0);
if (params->fakeLightsEnabled)
{
fakeLights = FakeLights(input, &fakeLightsSpecular);
}
//total shader
output.R = envMapping.R + (ambient2.R + mainLight.R * shade.R * shadow.R) * colour.R;
output.G = envMapping.G + (ambient2.G + mainLight.G * shade.G * shadow.G) * colour.G;
output.B = envMapping.B + (ambient2.B + mainLight.B * shade.B * shadow.B) * colour.B;
output.R += (auxLights.R + fakeLights.R) * colour.R;
output.G += (auxLights.G + fakeLights.G) * colour.G;
output.B += (auxLights.B + fakeLights.B) * colour.B;
output.A = 1.0;
(*specularOut).R = auxLightsSpecular.R + fakeLightsSpecular.R
+ mainLight.R * specular.R * shadow.R;
(*specularOut).G = auxLightsSpecular.G + fakeLightsSpecular.G
+ mainLight.G * specular.G * shadow.G;
(*specularOut).B = auxLightsSpecular.B + fakeLightsSpecular.B
+ mainLight.B * specular.B * shadow.B;
(*specularOut).A = output.A;
return output;
}
