unsigned int CBspMapMeshProvider::FindLeaf(const CVector3& searchPosition) const
{
int32 index = 0;
const Bsp::NodeArray& nodes(m_bspFile->GetNodes());
const Bsp::PlaneArray& planes(m_bspFile->GetPlanes());
while(index >= 0)
{
const Bsp::NODE& node = nodes[index];
const Bsp::PLANE& plane = planes[node.plane];
CVector3 planeNormal = Bsp::ConvertToAthenaCoord(plane.normal);
float distance = planeNormal.Dot(searchPosition) - plane.distance;
if(distance >= 0)
{
index = node.children[0];
}
else
{
index = node.children[1];
}
}
return -index - 1;
}
CVector3 CVector3::RotateAroundVectorByAngle(CVector3 axis, double angle)
{
CVector3 vector = *this * cos(angle);
vector += (axis.Cross(*this)) * sin(angle);
vector += axis * axis.Dot(*this) * (1 - cos(angle));
return vector;
}
void AABox::SupportMapping( const CVector3& v, CVector3& result ) const
{
//Vector3.Dot(ref this.corners[0], ref v, out num3);
float num3 = v.Dot( Corner(0) );
int index = 0;
for (int i = 1; i < 8; i++)
{
float num2 = v.Dot( Corner(i) );
if (num2 > num3)
{
index = i;
num3 = num2;
}
}
result = Corner(index);
}
void
Moose::Math::CPlane::Calculate( CVector3<float> vNormal, const CVector3<float> & vPoint )
{
vNormal.Normalize();
m_aValues[0] = vNormal[0];
m_aValues[1] = vNormal[1];
m_aValues[2] = vNormal[2];
m_aValues[3] = -(vNormal.Dot(vPoint));
}
CVector3 RefractVector(const CVector3 &normal, const CVector3 &incident, double n1, double n2)
{
const double n = n1 / n2;
const double cosI = -normal.Dot(incident);
const double sinT2 = n * n * (1.0 - cosI * cosI);
if (sinT2 > 1.0) return CVector3(0.0, 0.0, 0.0); // total internal reflection
const double cosT = sqrt(1.0 - sinT2);
return incident * n + normal * (n * cosI - cosT);
}
double Reflectance(const CVector3 &normal, const CVector3 &incident, double n1, double n2)
{
const double n = n1 / n2;
const double cosI = -normal.Dot(incident);
const double sinT2 = n * n * (1.0 - cosI * cosI);
if (sinT2 > 1.0) return 1.0; // total internal reflection
const double cosT = sqrt(1.0 - sinT2);
const double r0rth = (n1 * cosI - n2 * cosT) / (n1 * cosI + n2 * cosT);
const double rPar = (n2 * cosI - n1 * cosT) / (n2 * cosI + n1 * cosT);
return (r0rth * r0rth + rPar * rPar) / 2.0;
}
void KaleidoscopicIFSIteration(CVector3 &z, const cFractal *fractal, sIFSAux &aux)
{
if (fractal->IFS.absX) z.x = fabs(z.x);
if (fractal->IFS.absY) z.y = fabs(z.y);
if (fractal->IFS.absZ) z.z = fabs(z.z);
for (int i = 0; i < IFS_VECTOR_COUNT; i++)
{
if (fractal->IFS.enabled[i])
{
z = fractal->IFS.rot[i].RotateVector(z);
double length = z.Dot(fractal->IFS.direction[i]);
if (length < fractal->IFS.distance[i])
{
z -= fractal->IFS.direction[i] * (2.0 * (length - fractal->IFS.distance[i]) * fractal->IFS.intensity[i]);
}
}
}
z = fractal->IFS.mainRot.RotateVector(z - fractal->IFS.offset) + fractal->IFS.offset;
if (fractal->IFS.edge.x > 0) z.x = fractal->IFS.edge.x - fabs(fractal->IFS.edge.x - z.x);
if (fractal->IFS.edge.y > 0) z.y = fractal->IFS.edge.y - fabs(fractal->IFS.edge.y - z.y);
if (fractal->IFS.edge.z > 0) z.z = fractal->IFS.edge.z - fabs(fractal->IFS.edge.z - z.z);
z *= fractal->IFS.scale;
if (fractal->IFS.mengerSpongeMode)
{
z.x -= fractal->IFS.offset.x * (fractal->IFS.scale - 1.0);
z.y -= fractal->IFS.offset.y * (fractal->IFS.scale - 1.0);
if (z.z > 0.5 * fractal->IFS.offset.z * (fractal->IFS.scale - 1.0)) z.z -= fractal->IFS.offset.z * (fractal->IFS.scale - 1.0);
}
else
{
z -= fractal->IFS.offset * (fractal->IFS.scale - 1.0);
}
aux.ifsDE *= fractal->IFS.scale;
}
sRGBAfloat cRenderWorker::BackgroundShader(const sShaderInputData &input)
{
sRGBAfloat pixel2;
if (params->texturedBackground)
{
switch (params->texturedBackgroundMapType)
{
case params::mapDoubleHemisphere:
{
double alphaTexture = input.viewVector.GetAlpha();
double betaTexture = input.viewVector.GetBeta();
int texWidth = data->textures.backgroundTexture.Width() * 0.5;
int texHeight = data->textures.backgroundTexture.Height();
int offset = 0;
if (betaTexture < 0)
{
betaTexture = -betaTexture;
alphaTexture = M_PI - alphaTexture;
offset = texWidth;
}
double texX = 0.5 * texWidth
+ cos(alphaTexture) * (1.0 - betaTexture / (0.5 * M_PI)) * texWidth * 0.5
+ offset;
double texY = 0.5 * texHeight
+ sin(alphaTexture) * (1.0 - betaTexture / (0.5 * M_PI)) * texHeight * 0.5;
sRGBfloat pixel = data->textures.backgroundTexture.Pixel(texX, texY);
pixel2.R = pixel.R;
pixel2.G = pixel.G;
pixel2.B = pixel.B;
break;
}
case params::mapEquirectangular:
{
double alphaTexture = fmod(-input.viewVector.GetAlpha() + 3.5 * M_PI, 2 * M_PI);
double betaTexture = -input.viewVector.GetBeta();
if (betaTexture > 0.5 * M_PI) betaTexture = 0.5 * M_PI - betaTexture;
if (betaTexture < -0.5 * M_PI) betaTexture = -0.5 * M_PI + betaTexture;
double texX = alphaTexture / (2.0 * M_PI) * data->textures.backgroundTexture.Width();
double texY = (betaTexture / (M_PI) + 0.5) * data->textures.backgroundTexture.Height();
sRGBfloat pixel = data->textures.backgroundTexture.Pixel(texX, texY);
pixel2.R = pixel.R;
pixel2.G = pixel.G;
pixel2.B = pixel.B;
break;
}
case params::mapFlat:
{
CVector3 vect = mRotInv.RotateVector(input.viewVector);
double texX = vect.x / vect.y / params->fov * params->imageHeight / params->imageWidth;
double texY = -vect.z / vect.y / params->fov;
texX = (texX + 0.5);
texY = (texY + 0.5);
sRGBfloat pixel = data->textures.backgroundTexture.Pixel(CVector2<double>(texX, texY));
pixel2.R = pixel.R;
pixel2.G = pixel.G;
pixel2.B = pixel.B;
break;
}
}
pixel2.R *= params->background_brightness;
pixel2.G *= params->background_brightness;
pixel2.B *= params->background_brightness;
}
else
{
CVector3 vector(0.0, 0.0, 1.0);
vector.Normalize();
CVector3 viewVectorNorm = input.viewVector;
viewVectorNorm.Normalize();
double grad = (viewVectorNorm.Dot(vector) + 1.0);
sRGB16 pixel;
if (grad < 1)
{
double Ngrad = 1.0 - grad;
pixel.R = (params->background_color3.R * Ngrad + params->background_color2.R * grad);
pixel.G = (params->background_color3.G * Ngrad + params->background_color2.G * grad);
pixel.B = (params->background_color3.B * Ngrad + params->background_color2.B * grad);
}
else
{
grad = grad - 1;
double Ngrad = 1.0 - grad;
pixel.R = (params->background_color2.R * Ngrad + params->background_color1.R * grad);
pixel.G = (params->background_color2.G * Ngrad + params->background_color1.G * grad);
pixel.B = (params->background_color2.B * Ngrad + params->background_color1.B * grad);
}
pixel2.R = pixel.R / 65536.0;
pixel2.G = pixel.G / 65536.0;
pixel2.B = pixel.B / 65536.0;
pixel2.A = 0.0;
}
CVector3 viewVectorNorm = input.viewVector;
viewVectorNorm.Normalize();
double light =
(viewVectorNorm.Dot(input.lightVect) - 1.0) * 360.0 / params->mainLightVisibilitySize;
light = 1.0 / (1.0 + pow(light, 6.0)) * params->mainLightVisibility * params->mainLightIntensity;
pixel2.R += light * params->mainLightColour.R / 65536.0;
pixel2.G += light * params->mainLightColour.G / 65536.0;
pixel2.B += light * params->mainLightColour.B / 65536.0;
return pixel2;
}
/*!
* @brief 衝突検出と解決。
*@param[in] nextPosition 次の座標。
*/
void EnemyTest::CollisionDetectAndResolve(CVector3 nextPosition)
{
//XZ平面を調べる。
{
int loopCount = 0;
while (true) {
CVector3 addPos;
addPos.Subtract(nextPosition, position);
CVector3 posTmp = position;
posTmp.y += radius + 0.2f;
btTransform start, end;
start.setIdentity();
end.setIdentity();
start.setOrigin(*(btVector3*)(&posTmp));
CVector3 newPos;
SweepResultWall callback;
callback.startPos = position;
CVector3 addPosXZ = addPos;
addPosXZ.y = 0.0f;
if (addPosXZ.Length() > 0.0001f) {
newPos.Add(posTmp, addPosXZ);
end.setOrigin(btVector3(newPos.x, newPos.y, newPos.z));
PhysicsWorld().ConvexSweepTest((const btConvexShape*)collider.GetBody(), start, end, callback);
}
if (callback.isHit) {
//当たった。
float t = fabsf(acosf(callback.hitNormal.Dot(CVector3::Up)));
if (t >= CMath::PI * 0.3f) {
//壁。
nextPosition.x = callback.hitPos.x;
nextPosition.z = callback.hitPos.z;
//半径分押し戻す。
CVector3 hitNormalXZ = callback.hitNormal;
hitNormalXZ.y = 0.0f;
hitNormalXZ.Normalize();
CVector3 t = hitNormalXZ;
t.Scale(radius);
nextPosition.Add(t);
//続いて壁に沿って滑らせる。
t.Cross(hitNormalXZ, CVector3::Up);
t.Normalize();
//押し戻しで動いた分は減算する。
CVector3 t2;
t2.Subtract(nextPosition, position);
t2.y = 0.0f;
addPosXZ.Subtract(t2);
t.Scale(t.Dot(addPosXZ));
nextPosition.Add(t);
}
}
else {
//どことも当たらないので終わり。
break;
}
loopCount++;
if (loopCount == 5) {
break;
}
}
}
//下方向を調べる。
{
CVector3 addPos;
addPos.Subtract(nextPosition, position);
btTransform start, end;
start.setIdentity();
end.setIdentity();
start.setOrigin(btVector3(position.x, position.y + radius, position.z));
CVector3 newPos;
SweepResultGround callback;
callback.startPos = position;
if (addPos.y < 0.0f) {
newPos = (*(CVector3*)&start.getOrigin());
newPos.y += addPos.y;
end.setOrigin(btVector3(newPos.x, newPos.y, newPos.z));
PhysicsWorld().ConvexSweepTest((const btConvexShape*)collider.GetBody(), start, end, callback);
}
if (callback.isHit) {
//当たった。
float t = fabsf(acosf(callback.hitNormal.Dot(CVector3::Up)));
if (t < CMath::PI * 0.3f) {
//地面。
CVector3 Circle;
float x = 0.0f;
float offset = 0.0f; //押し戻す量。
Circle = CVector3::Zero;
Circle = position;
Circle.y = callback.hitPos.y;//円の中心
CVector3 v;
v.Subtract(Circle, callback.hitPos);
x = v.Length();//物体の角とプレイヤーの間の横幅の距離が求まる。
offset = sqrt(max(0.0f, radius*radius - x*x));//yの平方根を求める。
moveSpeed.y = 0.0f;
isJump = false;
nextPosition.y = callback.hitPos.y + offset - radius;
}
}
}
position = nextPosition;
}
void Compute(const cNineFractals &fractals, const sFractalIn &in, sFractalOut *out)
{
//QTextStream outStream(stdout);
//clock_t tim;
//tim = rdtsc();
//repeat, move and rotate
CVector3 point2 = in.point.mod(in.common.repeat) - in.common.fractalPosition;
point2 = in.common.mRotFractalRotation.RotateVector(point2);
CVector3 z = point2;
double r = z.Length();
CVector3 c = z;
double minimumR = 100.0;
double w = 0.0;
double orbitTrapTotal = 0.0;
enumFractalFormula formula = fractal::none;
out->maxiter = true;
int fractalIndex = 0;
if (in.forcedFormulaIndex >= 0) fractalIndex = in.forcedFormulaIndex;
const cFractal *defaultFractal = fractals.GetFractal(fractalIndex);
sExtendedAux extendedAux[NUMBER_OF_FRACTALS];
int maxFractal = (in.forcedFormulaIndex >= 0) ? in.forcedFormulaIndex : fractals.GetMaxFractalIndex();
int minFractal = (in.forcedFormulaIndex >= 0) ? in.forcedFormulaIndex : 0;
for (int i = minFractal; i <= maxFractal; i++)
{
extendedAux[i].r_dz = 1.0;
extendedAux[i].r = r;
extendedAux[i].color = 1.0;
extendedAux[i].actualScale = fractals.GetFractal(i)->mandelbox.scale;
extendedAux[i].DE = 1.0;
extendedAux[i].c = c;
extendedAux[i].cw = 0;
extendedAux[i].newR = 1e+20;
extendedAux[i].axisBias = 1e+20;
extendedAux[i].orbitTraps = 1e+20;
extendedAux[i].transformSampling = 1e+20;
}
//main iteration loop
int i;
int sequence = 0;
int lastSequnce = 0;
for (i = 0; i < in.maxN; i++)
{
//hybrid fractal sequence
if (in.forcedFormulaIndex >= 0)
{
sequence = in.forcedFormulaIndex;
}
else
{
sequence = fractals.GetSequence(i);
}
//for optimized DE calculation
if(fractals.UseOptimizedDE())
{
extendedAux[sequence] = extendedAux[lastSequnce];
lastSequnce = sequence;
}
//foldings
if (in.common.foldings.boxEnable)
{
BoxFolding(z, &in.common.foldings, extendedAux[sequence]);
r = z.Length();
}
if (in.common.foldings.sphericalEnable)
{
extendedAux[sequence].r = r;
SphericalFolding(z, &in.common.foldings, extendedAux[sequence]);
r = z.Length();
}
const cFractal *fractal = fractals.GetFractal(sequence);
formula = fractal->formula;
//temporary vector for weight function
CVector3 tempZ = z;
extendedAux[sequence].r = r;
if (!fractals.IsHybrid() || fractals.GetWeight(sequence) > 0.0)
{
//calls for fractal formulas
switch (formula)
{
case mandelbulb:
{
MandelbulbIteration(z, fractal, extendedAux[sequence]);
break;
}
case mandelbulb2:
{
Mandelbulb2Iteration(z, extendedAux[sequence]);
break;
}
case mandelbulb3:
{
Mandelbulb3Iteration(z, extendedAux[sequence]);
break;
}
case mandelbulb4:
{
Mandelbulb4Iteration(z, fractal, extendedAux[sequence]);
break;
}
case fast_mandelbulb_power2:
{
MandelbulbPower2Iteration(z, extendedAux[sequence]);
break;
}
case xenodreambuie:
{
XenodreambuieIteration(z, fractal, extendedAux[sequence]);
break;
}
case mandelbox:
{
MandelboxIteration(z, fractal, extendedAux[sequence]);
break;
}
case smoothMandelbox:
{
SmoothMandelboxIteration(z, fractal, extendedAux[sequence]);
break;
}
case boxFoldBulbPow2:
{
BoxFoldBulbPow2Iteration(z, fractal);
break;
}
case menger_sponge:
{
MengerSpongeIteration(z, extendedAux[sequence]);
break;
}
case kaleidoscopicIFS:
{
KaleidoscopicIFSIteration(z, fractal, extendedAux[sequence]);
break;
}
case aexion:
{
AexionIteration(z, w, i, fractal, extendedAux[sequence]);
break;
}
case hypercomplex:
{
HypercomplexIteration(z, w, extendedAux[sequence]);
break;
}
case quaternion:
{
QuaternionIteration(z, w, extendedAux[sequence]);
break;
}
case benesi:
{
BenesiIteration(z, c, extendedAux[sequence]);
break;
}
case bristorbrot:
{
BristorbrotIteration(z, extendedAux[sequence]);
break;
}
case ides:
{
IdesIteration(z, fractal);
break;
}
case ides2:
{
Ides2Iteration(z, fractal);
break;
}
case buffalo:
{
BuffaloIteration(z, fractal, extendedAux[sequence]);
break;
}
case quickdudley:
{
QuickDudleyIteration(z);
break;
}
case quickDudleyMod:
{
QuickDudleyModIteration(z, fractal);
break;
}
case lkmitch:
{
LkmitchIteration(z);
break;
}
case makin3d2:
{
Makin3D2Iteration(z);
break;
}
case msltoeDonut:
{
MsltoeDonutIteration(z, fractal, extendedAux[sequence]);
break;
}
case msltoesym2Mod:
{
MsltoeSym2ModIteration(z, c, fractal, extendedAux[sequence]);
break;
}
case msltoesym3Mod:
{
MsltoeSym3ModIteration(z, c, i, fractal, extendedAux[sequence]);
break;
}
case msltoesym3Mod2:
{
MsltoeSym3Mod2Iteration(z, c, fractal, extendedAux[sequence]);
break;
}
case msltoesym3Mod3:
{
MsltoeSym3Mod3Iteration(z, c, i, fractal, extendedAux[sequence]);
break;
}
case msltoesym4Mod:
{
MsltoeSym4ModIteration(z, c, fractal, extendedAux[sequence]);
break;
}
case generalizedFoldBox:
{
GeneralizedFoldBoxIteration(z, fractal, extendedAux[sequence]);
break;
}
case mandelbulb5:
{
Mandelbulb5Iteration(z, c, minimumR, i, fractal, extendedAux[sequence]);
break;
}
case mandelbox103:
{
Mandelbox103Iteration(z, c, minimumR, i, fractal, extendedAux[sequence]);
break;
}
case quaternion104:
{
CVector4 z4D(z, w);
Quaternion104Iteration(z4D, CVector4(c, 0.0), i, fractal, extendedAux[sequence]);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
case mengerSponge105:
{
MengerSponge105Iteration(z, c, minimumR, i, fractal, extendedAux[sequence]);
break;
}
case mandelbulb6Beta:
{
Mandelbulb6BetaIteration(z, c, minimumR, i, fractal, extendedAux[sequence]);
break;
}
case benesiTransforms:
{
BenesiTransformsIteration(z, c, minimumR, i, fractal, extendedAux[sequence]);
break;
}
case aboxMod1:
{
AboxMod1Iteration(z, fractal, extendedAux[sequence]);
break;
}
case aboxMod2:
{
AboxMod2Iteration(z, fractal, extendedAux[sequence]);
break;
}
case aboxModKali:
{
AboxModKaliIteration(z, fractal, extendedAux[sequence]);
break;
}
case aboxVSIcen1:
{
AboxVSIcen1Iteration(z, c, fractal, extendedAux[sequence]);
break;
}
case aexionOctopusMod:
{
AexionOctopusModIteration(z, c, fractal);
break;
}
case amazingSurf:
{
AmazingSurfIteration(z, fractal, extendedAux[sequence]);
break;
}
case amazingSurfMod1:
{
AmazingSurfMod1Iteration(z, fractal, extendedAux[sequence]);
break;
}
case benesiPineTree:
{
BenesiPineTreeIteration(z, c, fractal, extendedAux[sequence]);
break;
}
case benesiT1PineTree:
{
BenesiT1PineTreeIteration(z, c, i, fractal, extendedAux[sequence]);
break;
}
case eiffieMsltoe:
{
EiffieMsltoeIteration(z, c, fractal, extendedAux[sequence]);
break;
}
case foldBoxMod1:
{
FoldBoxMod1Iteration(z, i, fractal, extendedAux[sequence]);
break;
}
case iqBulb:
{
IQbulbIteration(z, fractal, extendedAux[sequence]);
break;
}
case kalisets1:
{
Kalisets1Iteration(z, c, fractal, extendedAux[sequence]);
break;
}
case mandelbulbMulti:
{
MandelbulbMultiIteration(z, fractal, extendedAux[sequence]);
break;
}
case mandelbulbVaryPowerV1:
{
MandelbulbVaryPowerV1Iteration(z, i, fractal, extendedAux[sequence]);
break;
}
case mengerMod1:
{
MengerMod1Iteration(z, i, fractal, extendedAux[sequence]);
break;
}
case riemannSphereMsltoe:
{
RiemannSphereMsltoeIteration(z, fractal);
break;
}
case riemannSphereMsltoeV1:
{
RiemannSphereMsltoeV1Iteration(z, fractal);
break;
}
case quaternion3D:
{
Quaternion3DIteration(z, fractal, extendedAux[sequence]);
break;
}
//transforms ------------------------------------------------------------------------------------------
case transfAdditionConstant:
{
TransformAdditionConstantIteration(z, fractal);
break;
}
case transfAdditionConstantVaryV1:
{
TransformAdditionConstantVaryV1Iteration(z, i, fractal);
break;
}
case transfAddCpixel:
{
TransformAddCpixelIteration(z, c, fractal);
break;
}
case transfAddCpixelAxisSwap:
{
TransformAddCpixelAxisSwapIteration(z, c, fractal);
break;
}
case transfAddCpixelCxCyAxisSwap:
{
TransformAddCpixelCxCyAxisSwapIteration(z, c, fractal);
break;
}
case transfAddCpixelPosNeg:
{
TransformAddCpixelPosNegIteration(z, c, fractal);
break;
}
case transfAddCpixelVaryV1:
{
TransformAddCpixelVaryV1Iteration(z, c, i, fractal);
break;
}
case transfBenesiT1:
{
TransformBenesiT1Iteration(z, fractal, extendedAux[sequence]);
break;
}
case transfBenesiT1Mod:
{
TransformBenesiT1ModIteration(z, fractal, extendedAux[sequence]);
break;
}
case transfBenesiT2:
{
TransformBenesiT2Iteration(z, fractal, extendedAux[sequence]);
break;
}
case transfBenesiT3:
{
TransformBenesiT3Iteration(z, fractal);
break;
}
case transfBenesiT4:
{
TransformBenesiT4Iteration(z, fractal);
break;
}
case transfBenesiT5b:
{
TransformBenesiT5bIteration(z, fractal);
break;
}
case transfBenesiMagForward:
{
TransformBenesiMagForwardIteration(z);
break;
}
case transfBenesiMagBackward:
{
TransformBenesiMagBackwardIteration(z);
break;
}
case transfBenesiCubeSphere:
{
TransformBenesiCubeSphereIteration(z);
break;
}
case transfBenesiSphereCube:
{
TransformBenesiSphereCubeIteration(z);
break;
}
case transfBoxFold:
{
TransformBoxFoldIteration(z, fractal, extendedAux[sequence]);
break;
}
case transfBoxFoldXYZ:
{
TransformBoxFoldXYZIteration(z, fractal, extendedAux[sequence]);
break;
}
case transfBoxOffset:
{
TransformBoxOffsetIteration(z, fractal, extendedAux[sequence]);
break;
}
case transfFabsAddConstant:
{
TransformFabsAddConstantIteration(z, fractal);
break;
}
case transfFabsAddConstantV2:
{
TransformFabsAddConstantV2Iteration(z, fractal);
break;
}
case transfFabsAddMulti:
{
TransformFabsAddMultiIteration(z, fractal);
break;
}
case transfIterationWeight:
{
TransformIterationWeightIteration(z, i, fractal);
break;
}
case transfLinCombineCxyz:
{
TransformLinCombineCxyz(c, fractal);
break;
}
case transfMultipleAngle:
{
TransformMultipleAngle(z, fractal, extendedAux[sequence]);
break;
}
case transfNegFabsAddConstant:
{
TransformNegFabsAddConstantIteration(z, fractal);
break;
}
case transfRotation:
{
TransformRotationIteration(z, fractal);
break;
}
case transfRotationVaryV1:
{
TransformRotationVaryV1Iteration(z, i, fractal);
break;
}
case transfScale:
{
TransformScaleIteration(z, fractal, extendedAux[sequence]);
break;
}
case transfScaleVaryV1:
{
TransformScaleVaryV1Iteration(z, i, fractal, extendedAux[sequence]);
break;
}
case transfScale3D:
{
TransformScale3DIteration(z, fractal, extendedAux[sequence]);
break;
}
case platonicSolid:
{
TransformPlatonicSolidIteration(z, fractal);
break;
}
case transfRPower:
{
TransformPowerR(z, fractal, extendedAux[sequence]);
break;
}
case transfSphereInvC:
{
TransformSphereInvCIteration(z, c, fractal);
break;
}
case transfSphericalOffset:
{
TransformSphericalOffsetIteration(z, fractal, extendedAux[sequence]);
break;
}
case transfSphericalFold:
{
TransformSphericalFoldIteration(z, fractal, extendedAux[sequence]);
break;
}
case transfSphericalPwrFold:
{
TransformSphericalPwrFoldIteration(z, fractal, extendedAux[sequence]);
break;
}
case transfZvectorAxisSwap:
{
TransformZvectorAxisSwapIteration(z, fractal );
break;
}
// 4D ---------------------------------------------------------------------------
case quaternion4D:
{
CVector4 z4D(z, w);
Quaternion4DIteration(z4D, i, fractal);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
case mandelboxVaryScale4D:
{
CVector4 z4D(z, w);
MandelboxVaryScale4DIteration(z4D, i, fractal, extendedAux[sequence]);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
case transfAdditionConstant4D:
{
CVector4 z4D(z, w);
TransformAdditionConstant4DIteration(z4D, fractal);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
case transfBoxFold4D:
{
CVector4 z4D(z, w);
TransformBoxFold4DIteration(z4D, fractal, extendedAux[sequence]);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
case transfFabsAddConstant4D:
{
CVector4 z4D(z, w);
TransformFabsAddConstant4DIteration(z4D, fractal);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
case transfFabsAddConstantV24D:
{
CVector4 z4D(z, w);
TransformFabsAddConstantV24DIteration(z4D, fractal);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
case transfIterationWeight4D:
{
CVector4 z4D(z, w);
TransformIterationWeight4DIteration(z4D, i, fractal);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
case transfScale4D:
{
CVector4 z4D(z, w);
TransformScale4DIteration(z4D, fractal, extendedAux[sequence]);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
case transfSphericalFold4D:
{
CVector4 z4D(z, w);
TransformSphericalFold4DIteration(z4D, fractal, extendedAux[sequence]);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
default:
z = CVector3(0.0, 0.0, 0.0);
break;
}
}
//addition of constant
if (fractals.IsAddCConstant(sequence))
{
switch (formula)
{
case aboxMod1:
case amazingSurf:
//case amazingSurfMod1:
{
if (fractals.IsJuliaEnabled(sequence))
{
CVector3 juliaC = fractals.GetJuliaConstant(sequence) * fractals.GetConstantMultiplier(sequence);
z += CVector3(juliaC.y, juliaC.x, juliaC.z);
}
else
{
z += CVector3(c.y, c.x, c.z) * fractals.GetConstantMultiplier(sequence);
}
break;
}
default:
{
if (fractals.IsJuliaEnabled(sequence))
{
z += fractals.GetJuliaConstant(sequence) * fractals.GetConstantMultiplier(sequence);
}
else
{
z += c * fractals.GetConstantMultiplier(sequence);
}
break;
}
}
}
if (fractals.IsHybrid())
{
z = SmoothCVector(tempZ, z, fractals.GetWeight(sequence));
}
//r calculation
r = sqrt(z.x * z.x + z.y * z.y + z.z * z.z + w * w);
//escape conditions
if (fractals.IsCheckForBailout(sequence))
{
if (Mode == calcModeNormal)
{
if (r > fractals.GetBailout(sequence))
{
out->maxiter = false;
break;
}
}
else if (Mode == calcModeDeltaDE1)
{
if (r > fractals.GetBailout(sequence))
{
out->maxiter = false;
break;
}
}
else if (Mode == calcModeDeltaDE2)
{
if (i == in.maxN) break;
}
else if (Mode == calcModeColouring)
{
double len = 0.0;
switch (in.common.fractalColoringAlgorithm)
{
case fractalColoringStandard:
{
len = r;
break;
}
case fractalColoringZDotPoint:
{
len = fabs(z.Dot(in.point));
break;
}
case fractalColoringSphere:
{
len = fabs((z - in.point).Length() - in.common.fractalColoringSphereRadius);
break;
}
case fractalColoringCross:
{
len = dMin(fabs(z.x), fabs(z.y), fabs(z.z));
break;
}
case fractalColoringLine:
{
len = fabs(z.Dot(in.common.fractalColoringLineDirection));
break;
}
}
if (fractal->formula != mandelbox || in.common.fractalColoringAlgorithm != fractalColoringStandard)
{
if (len < minimumR) minimumR = len;
}
if (r > 1e15) break;
}
else if (Mode == calcModeOrbitTrap)
{
CVector3 delta = z - in.common.fakeLightsOrbitTrap;
double distance = delta.Length();
if (i >= in.common.fakeLightsMinIter && i <= in.common.fakeLightsMaxIter) orbitTrapTotal +=
(1.0f / (distance * distance));
if (distance > 1000)
{
out->orbitTrapR = orbitTrapTotal;
break;
}
}
}
}
//final calculations
if (Mode == calcModeNormal)
{
if (fractals.IsHybrid())
{
if(extendedAux[sequence].r_dz > 0)
{
if (fractals.GetDEFunctionType(0) == fractal::linearDEFunction)
{
out->distance = r / fabs(extendedAux[sequence].DE);
}
else if (fractals.GetDEFunctionType(0) == fractal::logarithmicDEFunction)
{
out->distance = 0.5 * r * log(r) / extendedAux[sequence].r_dz;
}
}
else
{
out->distance = r;
}
}
else
{
switch (formula)
{
case benesi:
case benesiPineTree:
case benesiT1PineTree:
case bristorbrot:
case buffalo:
case eiffieMsltoe:
case fast_mandelbulb_power2:
case hypercomplex:
case iqBulb:
case mandelbulb:
case mandelbulb2:
case mandelbulb3:
case mandelbulb4:
case mandelbulb5:
case mandelbulb6Beta:
case mandelbulbMulti:
case mandelbulbVaryPowerV1:
case msltoesym2Mod:
case msltoesym3Mod:
case msltoesym3Mod2:
case msltoesym3Mod3:
case msltoesym4Mod:
case quaternion:
case quaternion3D:
case xenodreambuie:
{
if(extendedAux[sequence].r_dz > 0)
out->distance = 0.5 * r * log(r) / extendedAux[sequence].r_dz;
else
out->distance = r;
break;
}
case mandelbox:
case smoothMandelbox:
case mandelboxVaryScale4D:
case generalizedFoldBox:
case mandelbox103:
case mengerSponge105:
case foldBoxMod1:
case aboxModKali:
case mengerMod1:
case aboxMod1:
case aboxMod2:
case amazingSurf:
case amazingSurfMod1:
case kalisets1:
case aboxVSIcen1:
{
if(extendedAux[sequence].r_dz > 0)
out->distance = r / fabs(extendedAux[sequence].DE);
else
out->distance = r;
break;
}
case kaleidoscopicIFS:
case menger_sponge:
{
if(extendedAux[sequence].r_dz > 0)
out->distance = (r - 2.0) / (extendedAux[sequence].DE);
else
out->distance = r;
break;
}
default:
out->distance = -1.0;
break;
}
}
}
//color calculation
else if (Mode == calcModeColouring)
{
if (fractals.IsHybrid())
{
if (minimumR > 100) minimumR = 100;
double mboxColor = 0.0;
double mboxDE = 1.0;
for (int h = minFractal; h <= maxFractal; h++)
{
mboxColor += extendedAux[h].color;
mboxDE *= extendedAux[h].DE; //mboxDE *= mandelboxAux[h].mboxDE + extendedAux[h].color;
}
double r2 = r / fabs(mboxDE);
if (r2 > 20) r2 = 20;
if (mboxColor > 1000) mboxColor = 1000;
out->colorIndex = minimumR * 1000.0 + mboxColor * 100 + r2 * 5000.0;
}
else
{
switch (formula)
{
case mandelbox:
case smoothMandelbox:
case mandelboxVaryScale4D:
case generalizedFoldBox:
case foldBoxMod1:
out->colorIndex = extendedAux[fractalIndex].color * 100.0
+ r * defaultFractal->mandelbox.color.factorR
+ ((in.common.fractalColoringAlgorithm != fractalColoringStandard) ? minimumR
* 1000.0 :
0.0);
break;
case mandelbulb5:
case mandelbox103:
case mandelbulb6Beta:
case benesiTransforms:
case mengerSponge105:
out->colorIndex = extendedAux[fractalIndex].newR
+ ((in.common.fractalColoringAlgorithm != fractalColoringStandard) ? minimumR
* 1000.0 :
0.0);
break;
case mengerMod1:
case aboxModKali:
case aboxMod1:
case menger_sponge:
case kaleidoscopicIFS:
out->colorIndex = minimumR * 1000.0;
break;
case amazingSurf:
case amazingSurfMod1:
out->colorIndex = minimumR * 200.0;
break;
case msltoeDonut:
out->colorIndex = extendedAux[fractalIndex].color * 2000.0 / i;
break;
default:
out->colorIndex = minimumR * 5000.0;
break;
}
}
}
else
{
out->distance = 0.0;
}
out->iters = i + 1;
out->z = z; // CVector3( z.x, z.y, w);
//tim = rdtsc() - tim; perf+= tim; perfCount++; outStream << (double)perf/perfCount - 560.0 << endl;
//------------- 3249 ns for all calculation ----------------
}
CVector3 ReflectionVector(const CVector3 &normal, const CVector3 &incident)
{
return incident - normal * incident.Dot(normal) * 2.0;
}
void Compute(const cNineFractals &fractals, const sFractalIn &in, sFractalOut *out)
{
// QTextStream outStream(stdout);
// clock_t tim;
// tim = rdtsc();
// repeat, move and rotate
CVector3 point2 = in.point.mod(in.common.repeat) - in.common.fractalPosition;
point2 = in.common.mRotFractalRotation.RotateVector(point2);
CVector3 z = point2;
double r = z.Length();
CVector3 c = z;
double minimumR = 100.0;
double w = 0.0;
double orbitTrapTotal = 0.0;
enumFractalFormula formula = fractal::none;
out->maxiter = true;
int fractalIndex = 0;
if (in.forcedFormulaIndex >= 0) fractalIndex = in.forcedFormulaIndex;
const cFractal *defaultFractal = fractals.GetFractal(fractalIndex);
sExtendedAux extendedAux;
extendedAux.r_dz = 1.0;
extendedAux.r = r;
extendedAux.color = 1.0;
extendedAux.actualScale = fractals.GetFractal(fractalIndex)->mandelbox.scale;
extendedAux.DE = 1.0;
extendedAux.c = c;
extendedAux.cw = 0;
extendedAux.foldFactor = 0.0;
extendedAux.minRFactor = 0.0;
extendedAux.scaleFactor = 0.0;
// extendedAux.newR = 1e+20;
// extendedAux.axisBias = 1e+20;
// extendedAux.orbitTraps = 1e+20;
// extendedAux.transformSampling = 1e+20;
// main iteration loop
int i;
int sequence = 0;
CVector3 lastGoodZ;
CVector3 lastZ;
for (i = 0; i < in.maxN; i++)
{
lastGoodZ = lastZ;
lastZ = z;
// hybrid fractal sequence
if (in.forcedFormulaIndex >= 0)
{
sequence = in.forcedFormulaIndex;
}
else
{
sequence = fractals.GetSequence(i);
}
// foldings
if (in.common.foldings.boxEnable)
{
BoxFolding(z, &in.common.foldings, extendedAux);
r = z.Length();
}
if (in.common.foldings.sphericalEnable)
{
extendedAux.r = r;
SphericalFolding(z, &in.common.foldings, extendedAux);
r = z.Length();
}
const cFractal *fractal = fractals.GetFractal(sequence);
formula = fractal->formula;
// temporary vector for weight function
CVector3 tempZ = z;
extendedAux.r = r;
if (!fractals.IsHybrid() || fractals.GetWeight(sequence) > 0.0)
{
// calls for fractal formulas
switch (formula)
{
case mandelbulb:
{
MandelbulbIteration(z, fractal, extendedAux);
break;
}
case mandelbulb2:
{
Mandelbulb2Iteration(z, extendedAux);
break;
}
case mandelbulb3:
{
Mandelbulb3Iteration(z, extendedAux);
break;
}
case mandelbulb4:
{
Mandelbulb4Iteration(z, fractal, extendedAux);
break;
}
case fast_mandelbulb_power2:
{
MandelbulbPower2Iteration(z, extendedAux);
break;
}
case xenodreambuie:
{
XenodreambuieIteration(z, fractal, extendedAux);
break;
}
case mandelbox:
{
MandelboxIteration(z, fractal, extendedAux);
break;
}
case smoothMandelbox:
{
SmoothMandelboxIteration(z, fractal, extendedAux);
break;
}
case boxFoldBulbPow2:
{
BoxFoldBulbPow2Iteration(z, fractal);
break;
}
case menger_sponge:
{
MengerSpongeIteration(z, extendedAux);
break;
}
case kaleidoscopicIFS:
{
KaleidoscopicIFSIteration(z, fractal, extendedAux);
break;
}
case aexion:
{
AexionIteration(z, w, i, fractal, extendedAux);
break;
}
case hypercomplex:
{
HypercomplexIteration(z, w, extendedAux);
break;
}
case quaternion:
{
QuaternionIteration(z, w, extendedAux);
break;
}
case benesi:
{
BenesiIteration(z, c, extendedAux);
break;
}
case bristorbrot:
{
BristorbrotIteration(z, extendedAux);
break;
}
case ides:
{
IdesIteration(z, fractal);
break;
}
case ides2:
{
Ides2Iteration(z, fractal);
break;
}
case buffalo:
{
BuffaloIteration(z, fractal, extendedAux);
break;
}
case quickdudley:
{
QuickDudleyIteration(z);
break;
}
case quickDudleyMod:
{
QuickDudleyModIteration(z, fractal);
break;
}
case lkmitch:
{
LkmitchIteration(z);
break;
}
case makin3d2:
{
Makin3D2Iteration(z);
break;
}
case msltoeDonut:
{
MsltoeDonutIteration(z, fractal, extendedAux);
break;
}
case msltoesym2Mod:
{
MsltoeSym2ModIteration(z, c, fractal, extendedAux);
break;
}
case msltoesym3Mod:
{
MsltoeSym3ModIteration(z, c, i, fractal, extendedAux);
break;
}
case msltoesym3Mod2:
{
MsltoeSym3Mod2Iteration(z, c, fractal, extendedAux);
break;
}
case msltoesym3Mod3:
{
MsltoeSym3Mod3Iteration(z, c, i, fractal, extendedAux);
break;
}
case msltoesym4Mod:
{
MsltoeSym4ModIteration(z, c, fractal, extendedAux);
break;
}
case msltoeToroidal:
{
MsltoeToroidalIteration(z, fractal, extendedAux);
break;
}
case msltoeToroidalMulti:
{
MsltoeToroidalMultiIteration(z, fractal, extendedAux);
break;
}
case generalizedFoldBox:
{
GeneralizedFoldBoxIteration(z, fractal, extendedAux);
break;
}
case aboxMod1:
{
AboxMod1Iteration(z, fractal, extendedAux);
break;
}
case aboxMod2:
{
AboxMod2Iteration(z, fractal, extendedAux);
break;
}
case aboxModKali:
{
AboxModKaliIteration(z, fractal, extendedAux);
break;
}
case aboxModKaliEiffie:
{
AboxModKaliEiffieIteration(z, c, i, fractal, extendedAux);
break;
}
case aboxVSIcen1:
{
AboxVSIcen1Iteration(z, c, fractal, extendedAux);
break;
}
case aexionOctopusMod:
{
AexionOctopusModIteration(z, c, fractal);
break;
}
case amazingSurf:
{
AmazingSurfIteration(z, fractal, extendedAux);
break;
}
case amazingSurfMod1:
{
AmazingSurfMod1Iteration(z, fractal, extendedAux);
break;
}
case amazingSurfMulti:
{
AmazingSurfMultiIteration(z, i, fractal, extendedAux);
break;
}
case benesiPineTree:
{
BenesiPineTreeIteration(z, c, fractal, extendedAux);
break;
}
case benesiT1PineTree:
{
BenesiT1PineTreeIteration(z, c, i, fractal, extendedAux);
break;
}
case benesiMagTransforms:
{
BenesiMagTransformsIteration(z, c, i, fractal, extendedAux);
break;
}
case collatz:
{
CollatzIteration(z, extendedAux);
break;
}
case collatzMod:
{
CollatzModIteration(z, c, fractal, extendedAux);
break;
}
case eiffieMsltoe:
{
EiffieMsltoeIteration(z, c, fractal, extendedAux);
break;
}
case foldBoxMod1:
{
FoldBoxMod1Iteration(z, i, fractal, extendedAux);
break;
}
case iqBulb:
{
IQbulbIteration(z, fractal, extendedAux);
break;
}
case kalisets1:
{
Kalisets1Iteration(z, c, fractal, extendedAux);
break;
}
case mandelboxMenger:
{
MandelboxMengerIteration(z, c, i, fractal, extendedAux);
break;
}
case mandelbulbBermarte:
{
MandelbulbBermarteIteration(z, fractal, extendedAux);
break;
}
case mandelbulbKali:
{
MandelbulbKaliIteration(z, fractal, extendedAux);
break;
}
case mandelbulbKaliMulti:
{
MandelbulbKaliMultiIteration(z, c, fractal, extendedAux);
break;
}
case mandelbulbMulti:
{
MandelbulbMultiIteration(z, c, fractal, extendedAux);
break;
}
case mandelbulbVaryPowerV1:
{
MandelbulbVaryPowerV1Iteration(z, i, fractal, extendedAux);
break;
}
case mengerMod1:
{
MengerMod1Iteration(z, i, fractal, extendedAux);
break;
}
case mengerMiddleMod:
{
MengerMiddleModIteration(z, c, i, fractal, extendedAux);
break;
}
case mengerPrismShape:
{
MengerPrismShapeIteration(z, i, fractal, extendedAux);
break;
}
case mengerPwr2Poly:
{
MengerPwr2PolyIteration(z, c, i, fractal, extendedAux);
break;
}
case riemannSphereMsltoe:
{
RiemannSphereMsltoeIteration(z, fractal);
break;
}
case riemannSphereMsltoeV1:
{
RiemannSphereMsltoeV1Iteration(z, fractal);
break;
}
case riemannBulbMsltoeMod2:
{
RiemannBulbMsltoeMod2Iteration(z, fractal);
break;
}
case quaternion3D:
{
Quaternion3DIteration(z, fractal, extendedAux);
break;
}
case fastImagscaPower2:
{
FastImagscaPower2Iteration(z);
break;
}
case crossMenger:
{
CrossMengerIteration(z, c, i, fractal, extendedAux);
break;
}
// transforms
// ------------------------------------------------------------------------------------------
case transfAdditionConstant:
{
TransformAdditionConstantIteration(z, fractal);
break;
}
case transfAdditionConstantVaryV1:
{
TransformAdditionConstantVaryV1Iteration(z, i, fractal);
break;
}
case transfAddCpixel:
{
TransformAddCpixelIteration(z, c, fractal);
break;
}
case transfAddCpixelAxisSwap:
{
TransformAddCpixelAxisSwapIteration(z, c, fractal);
break;
}
case transfAddCpixelCxCyAxisSwap:
{
TransformAddCpixelCxCyAxisSwapIteration(z, c, fractal);
break;
}
case transfAddCpixelPosNeg:
{
TransformAddCpixelPosNegIteration(z, c, fractal);
break;
}
case transfAddCpixelVaryV1:
{
TransformAddCpixelVaryV1Iteration(z, c, i, fractal);
break;
}
case transfBenesiT1:
{
TransformBenesiT1Iteration(z, fractal, extendedAux);
break;
}
case transfBenesiT1Mod:
{
TransformBenesiT1ModIteration(z, fractal, extendedAux);
break;
}
case transfBenesiT2:
{
TransformBenesiT2Iteration(z, fractal, extendedAux);
break;
}
case transfBenesiT3:
{
TransformBenesiT3Iteration(z, fractal);
break;
}
case transfBenesiT4:
{
TransformBenesiT4Iteration(z, fractal);
break;
}
case transfBenesiT5b:
{
TransformBenesiT5bIteration(z, fractal);
break;
}
case transfBenesiMagForward:
{
TransformBenesiMagForwardIteration(z);
break;
}
case transfBenesiMagBackward:
{
TransformBenesiMagBackwardIteration(z);
break;
}
case transfBenesiCubeSphere:
{
TransformBenesiCubeSphereIteration(z);
break;
}
case transfBenesiSphereCube:
{
TransformBenesiSphereCubeIteration(z);
break;
}
case transfBoxFold:
{
TransformBoxFoldIteration(z, fractal, extendedAux);
break;
}
case transfBoxFoldXYZ:
{
TransformBoxFoldXYZIteration(z, fractal, extendedAux);
break;
}
case transfBoxOffset:
{
TransformBoxOffsetIteration(z, fractal, extendedAux);
break;
}
case transfFabsAddConstant:
{
TransformFabsAddConstantIteration(z, fractal);
break;
}
case transfFabsAddConstantV2:
{
TransformFabsAddConstantV2Iteration(z, fractal);
break;
}
case transfFabsAddMulti:
{
TransformFabsAddMultiIteration(z, fractal);
break;
}
case transfFoldingTetra3D:
{
TransformFoldingTetra3DIteration(z, fractal);
break;
}
case transfIterationWeight:
{
TransformIterationWeightIteration(z, i, fractal);
break;
}
case transfInvCylindrical:
{
TransformInvCylindricalIteration(z, fractal, extendedAux);
break;
}
case transfLinCombineCxyz:
{
TransformLinCombineCxyz(c, fractal);
break;
}
case transfMultipleAngle:
{
TransformMultipleAngle(z, fractal, extendedAux);
break;
}
case transfNegFabsAddConstant:
{
TransformNegFabsAddConstantIteration(z, fractal);
break;
}
case transfPwr2Polynomial:
{
TransformPwr2PolynomialIteration(z, fractal, extendedAux);
break;
}
case transfRotation:
{
TransformRotationIteration(z, fractal);
break;
}
case transfRotationVaryV1:
{
TransformRotationVaryV1Iteration(z, i, fractal);
break;
}
case transfRpow3:
{
TransformRpow3Iteration(z, fractal, extendedAux);
break;
}
case transfScale:
{
TransformScaleIteration(z, fractal, extendedAux);
break;
}
case transfScaleVaryV1:
{
TransformScaleVaryV1Iteration(z, i, fractal, extendedAux);
break;
}
case transfScale3D:
{
TransformScale3DIteration(z, fractal, extendedAux);
break;
}
case platonicSolid:
{
TransformPlatonicSolidIteration(z, fractal);
break;
}
case transfRPower:
{
TransformPowerR(z, fractal, extendedAux);
break;
}
case transfSphereInvC:
{
TransformSphereInvCIteration(z, c, fractal);
break;
}
case transfSphereInv:
{
TransformSphereInvIteration(z, fractal, extendedAux);
break;
}
case transfSphericalOffset:
{
TransformSphericalOffsetIteration(z, fractal, extendedAux);
break;
}
case transfSphericalFold:
{
TransformSphericalFoldIteration(z, fractal, extendedAux);
break;
}
case transfSphericalFoldAbox:
{
TransformSphericalFoldAboxIteration(z, fractal, extendedAux);
break;
}
case transfSphericalFoldVaryV1:
{
TransformSphericalFoldVaryV1Iteration(z, i, fractal, extendedAux);
break;
}
case transfSphericalPwrFold:
{
TransformSphericalPwrFoldIteration(z, fractal, extendedAux);
break;
}
case transfSurfFoldMulti:
{
TransformSurfFoldMultiIteration(z, fractal, extendedAux);
break;
}
case transfZvectorAxisSwap:
{
TransformZvectorAxisSwapIteration(z, fractal);
break;
}
case transfRotationFoldingPlane:
{
TransformRotationFoldingPlane(z, fractal, extendedAux);
break;
}
case transfQuaternionFold:
{
TransformQuaternionFoldIteration(z, c, fractal, extendedAux);
break;
}
case transfMengerFold:
{
TransformMengerFoldIteration(z, fractal, extendedAux);
break;
}
// 4D ---------------------------------------------------------------------------
case quaternion4D:
{
CVector4 z4D(z, w);
Quaternion4DIteration(z4D, i, fractal);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
case mandelboxVaryScale4D:
{
CVector4 z4D(z, w);
MandelboxVaryScale4DIteration(z4D, i, fractal, extendedAux);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
case transfAdditionConstant4D:
{
CVector4 z4D(z, w);
TransformAdditionConstant4DIteration(z4D, fractal);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
case transfBoxFold4D:
{
CVector4 z4D(z, w);
TransformBoxFold4DIteration(z4D, fractal, extendedAux);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
case transfFabsAddConstant4D:
{
CVector4 z4D(z, w);
TransformFabsAddConstant4DIteration(z4D, fractal);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
case transfFabsAddConstantV24D:
{
CVector4 z4D(z, w);
TransformFabsAddConstantV24DIteration(z4D, fractal);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
case transfIterationWeight4D:
{
CVector4 z4D(z, w);
TransformIterationWeight4DIteration(z4D, i, fractal);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
case transfScale4D:
{
CVector4 z4D(z, w);
TransformScale4DIteration(z4D, fractal, extendedAux);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
case transfSphericalFold4D:
{
CVector4 z4D(z, w);
TransformSphericalFold4DIteration(z4D, fractal, extendedAux);
z = z4D.GetXYZ();
w = z4D.w;
break;
}
default:
double high = fractals.GetBailout(sequence) * 10.0;
z = CVector3(high, high, high);
break;
}
}
// addition of constant
if (fractals.IsAddCConstant(sequence))
{
switch (formula)
{
case aboxMod1:
case amazingSurf:
// case amazingSurfMod1:
{
if (fractals.IsJuliaEnabled(sequence))
{
CVector3 juliaC =
fractals.GetJuliaConstant(sequence) * fractals.GetConstantMultiplier(sequence);
z += CVector3(juliaC.y, juliaC.x, juliaC.z);
}
else
{
z += CVector3(c.y, c.x, c.z) * fractals.GetConstantMultiplier(sequence);
}
break;
}
default:
{
if (fractals.IsJuliaEnabled(sequence))
{
z += fractals.GetJuliaConstant(sequence) * fractals.GetConstantMultiplier(sequence);
}
else
{
z += c * fractals.GetConstantMultiplier(sequence);
}
break;
}
}
}
if (fractals.IsHybrid())
{
z = SmoothCVector(tempZ, z, fractals.GetWeight(sequence));
}
// r calculation
// r = sqrt(z.x * z.x + z.y * z.y + z.z * z.z + w * w);
switch (fractal->formula)
{
case fastImagscaPower2:
{
CVector3 z2 = z * z;
r = sqrt(z2.x + z2.y + z2.z) + (z2.y * z2.z) / (z2.x);
break;
}
// scator magnitudes
// magnitude in imaginary scator algebra
default:
{
r = sqrt(z.x * z.x + z.y * z.y + z.z * z.z + w * w);
break;
}
}
if (z.IsNotANumber())
{
z = lastZ;
r = z.Length();
w = 0.0;
out->maxiter = true;
break;
}
// escape conditions
if (fractals.IsCheckForBailout(sequence))
{
if (Mode == calcModeNormal)
{
if (r > fractals.GetBailout(sequence))
{
out->maxiter = false;
break;
}
}
else if (Mode == calcModeDeltaDE1)
{
if (r > fractals.GetBailout(sequence))
{
out->maxiter = false;
break;
}
}
else if (Mode == calcModeDeltaDE2)
{
if (i == in.maxN) break;
}
else if (Mode == calcModeColouring)
{
double len = 0.0;
switch (in.fractalColoring.coloringAlgorithm)
{
case sFractalColoring::fractalColoringStandard:
{
len = r;
break;
}
case sFractalColoring::fractalColoringZDotPoint:
{
len = fabs(z.Dot(in.point));
break;
}
case sFractalColoring::fractalColoringSphere:
{
len = fabs((z - in.point).Length() - in.fractalColoring.sphereRadius);
break;
}
case sFractalColoring::fractalColoringCross:
{
len = dMin(fabs(z.x), fabs(z.y), fabs(z.z));
break;
}
case sFractalColoring::fractalColoringLine:
{
len = fabs(z.Dot(in.fractalColoring.lineDirection));
break;
}
case sFractalColoring::fractalColoringNone:
{
len = r;
break;
}
}
if (fractal->formula != mandelbox
|| in.fractalColoring.coloringAlgorithm != sFractalColoring::fractalColoringStandard)
{
if (len < minimumR) minimumR = len;
}
if (r > 1e15) break;
}
else if (Mode == calcModeOrbitTrap)
{
CVector3 delta = z - in.common.fakeLightsOrbitTrap;
double distance = delta.Length();
if (i >= in.common.fakeLightsMinIter && i <= in.common.fakeLightsMaxIter)
orbitTrapTotal += (1.0f / (distance * distance));
if (distance > 1000)
{
out->orbitTrapR = orbitTrapTotal;
break;
}
}
}
if (z.IsNotANumber()) // detection of dead computation
{
// if(Mode != calcModeColouring)
// qWarning() << "Dead computation\n"
// << "iteration: " << i << "Formula:" << formula << "Sequence:" << sequence
// << "\nPoint:" << in.point.Debug()
// << "\nLast good z:" << lastGoodZ.Debug()
// << "\nPrevious z:" << lastZ.Debug();
z = lastGoodZ;
break;
}
}
// final calculations
if (Mode == calcModeNormal)
{
if (fractals.IsHybrid())
{
if (extendedAux.r_dz > 0)
{
if (fractals.GetDEFunctionType(0) == fractal::linearDEFunction)
{
out->distance = r / fabs(extendedAux.DE);
}
else if (fractals.GetDEFunctionType(0) == fractal::logarithmicDEFunction)
{
out->distance = 0.5 * r * log(r) / extendedAux.r_dz;
}
}
else
{
out->distance = r;
}
}
else
{
switch (formula)
{
case benesi:
case benesiPineTree:
case benesiT1PineTree:
case bristorbrot:
case buffalo:
case eiffieMsltoe:
case fast_mandelbulb_power2:
case hypercomplex:
case iqBulb:
case mandelbulb:
case mandelbulb2:
case mandelbulb3:
case mandelbulb4:
case mandelbulbBermarte:
case mandelbulbKali:
case mandelbulbKaliMulti:
case mandelbulbMulti:
case mandelbulbVaryPowerV1:
case msltoesym2Mod:
case msltoesym3Mod:
case msltoesym3Mod2:
case msltoesym3Mod3:
case msltoesym4Mod:
case msltoeToroidal: // TODO fix??
case msltoeToroidalMulti: // TODO fix??
case quaternion:
case transfQuaternionFold: // hmmm, this issue again
case quaternion3D:
case xenodreambuie:
{
if (extendedAux.r_dz > 0)
out->distance = 0.5 * r * log(r) / extendedAux.r_dz;
else
out->distance = r;
break;
}
case mandelbox:
case mandelboxMenger:
case smoothMandelbox:
case mandelboxVaryScale4D:
case generalizedFoldBox:
case foldBoxMod1:
case aboxModKali:
case aboxModKaliEiffie:
case aboxMod1:
case aboxMod2:
case amazingSurf:
case amazingSurfMod1:
case amazingSurfMulti:
case kalisets1:
case aboxVSIcen1:
{
if (extendedAux.DE > 0)
out->distance = r / fabs(extendedAux.DE);
else
out->distance = r;
break;
}
case kaleidoscopicIFS:
case menger_sponge:
case crossMenger:
case mengerPrismShape:
case collatz:
case collatzMod:
case mengerMod1:
case mengerMiddleMod:
case transfMengerFold: // hmmm, this issue again
case mengerPwr2Poly:
{
if (extendedAux.DE > 0)
out->distance = (r - 2.0) / (extendedAux.DE);
else
out->distance = r;
break;
}
default: out->distance = -1.0; break;
}
}
}
// color calculation
else if (Mode == calcModeColouring)
{
double mboxDE = 1.0;
mboxDE = extendedAux.DE;
double r2 = r / fabs(mboxDE);
if (r2 > 20) r2 = 20;
if (fractals.IsHybrid())
{
if (minimumR > 100) minimumR = 100;
double mboxColor = 0.0;
mboxColor = extendedAux.color;
if (mboxColor > 1000) mboxColor = 1000;
out->colorIndex = minimumR * 1000.0 + mboxColor * 100 + r2 * 5000.0;
/*out->colorIndex =
extendedAux.color * 100.0 * extendedAux.foldFactor // folds part
+ r * defaultFractal->mandelbox.color.factorR / 1e13 // abs z part
+ 1.0 * r2 * 5000.0 // for backwards compatability
+ extendedAux.scaleFactor * r * i / 1e15 // scale part conditional on i & r
+ ((in.fractalColoring.coloringAlgorithm != sFractalColoring::fractalColoringStandard)
? minimumR * extendedAux.minRFactor * 1000.0
: 0.0);*/
}
else
{
switch (formula)
{
case mandelbox:
case smoothMandelbox:
case mandelboxVaryScale4D:
case generalizedFoldBox:
case amazingSurfMod1:
case foldBoxMod1:
out->colorIndex =
extendedAux.color * 100.0 // folds part
+ r * defaultFractal->mandelbox.color.factorR / 1e13 // abs z part
+ ((in.fractalColoring.coloringAlgorithm != sFractalColoring::fractalColoringStandard)
? minimumR * 1000.0
: 0.0);
break;
case mengerMod1:
case aboxModKali:
case aboxMod1:
case menger_sponge:
case collatz:
case collatzMod:
case kaleidoscopicIFS:
case mengerPwr2Poly:
case mengerMiddleMod: out->colorIndex = minimumR * 1000.0; break;
case amazingSurf: out->colorIndex = minimumR * 200.0; break;
case amazingSurfMulti:
case mandelboxMenger:
// case amazingSurfMod1:
out->colorIndex =
extendedAux.color * 100.0 * extendedAux.foldFactor // folds part
+ r * defaultFractal->mandelbox.color.factorR / 1e13 // abs z part
+ extendedAux.scaleFactor * r2 * 5000.0 // for backwards compatability
//+ extendedAux.scaleFactor * r * i / 1e15 // scale part conditional on i & r
+ ((in.fractalColoring.coloringAlgorithm != sFractalColoring::fractalColoringStandard)
? minimumR * extendedAux.minRFactor * 1000.0
: 0.0);
break;
case msltoeDonut: out->colorIndex = extendedAux.color * 2000.0 / i; break;
default: out->colorIndex = minimumR * 5000.0; break;
}
}
}
else
{
out->distance = 0.0;
}
out->iters = i + 1;
out->z = z; // CVector3( z.x, z.y, w);
// tim = rdtsc() - tim; perf+= tim; perfCount++; outStream << (double)perf/perfCount - 560.0 <<
// endl;
//------------- 3249 ns for all calculation ----------------
}
void CCamera::LookAt(const CVector3& eye, const CVector3& target, const CVector3& up, HANDEDNESS handedness)
{
CMatrix4 view;
view.Clear();
if(handedness == HANDEDNESS_LEFTHANDED)
{
//zaxis = normal(At - Eye)
//xaxis = normal(cross(Up, zaxis))
//yaxis = cross(zaxis, xaxis)
CVector3 axisZ = (target - eye).Normalize();
CVector3 axisX = (up.Cross(axisZ)).Normalize();
CVector3 axisY = axisZ.Cross(axisX);
view(0, 0) = axisX.x;
view(1, 0) = axisX.y;
view(2, 0) = axisX.z;
view(3, 0) = -axisX.Dot(eye);
view(0, 1) = axisY.x;
view(1, 1) = axisY.y;
view(2, 1) = axisY.z;
view(3, 1) = -axisY.Dot(eye);
view(0, 2) = axisZ.x;
view(1, 2) = axisZ.y;
view(2, 2) = axisZ.z;
view(3, 2) = -axisZ.Dot(eye);
view(3, 3) = 1;
}
else
{
//zaxis = normal(Eye - At)
//xaxis = normal(cross(Up, zaxis))
//yaxis = cross(zaxis, xaxis)
CVector3 axisZ = (eye - target).Normalize();
CVector3 axisX = (up.Cross(axisZ)).Normalize();
CVector3 axisY = axisZ.Cross(axisX);
view(0, 0) = axisX.x;
view(1, 0) = axisX.y;
view(2, 0) = axisX.z;
view(3, 0) = -axisX.Dot(eye);
view(0, 1) = axisY.x;
view(1, 1) = axisY.y;
view(2, 1) = axisY.z;
view(3, 1) = -axisY.Dot(eye);
view(0, 2) = axisZ.x;
view(1, 2) = axisZ.y;
view(2, 2) = axisZ.z;
view(3, 2) = -axisZ.Dot(eye);
view(3, 3) = 1;
}
m_viewMatrix = view;
}
void MandelboxIteration(CVector3 &z, const cFractal *fractal, sMandelboxAux &aux)
{
if (fractal->mandelbox.rotationsEnabled)
{
bool lockout = false;
z = fractal->mandelbox.rot[0][0].RotateVector(z);
if (z.x > fractal->mandelbox.foldingLimit)
{
z.x = fractal->mandelbox.foldingValue - z.x;
aux.mboxColor += fractal->mandelbox.colorFactor.x;
lockout = true;
}
z = fractal->mandelbox.rotinv[0][0].RotateVector(z);
z = fractal->mandelbox.rot[1][0].RotateVector(z);
if (!lockout && z.x < -fractal->mandelbox.foldingLimit)
{
z.x = -fractal->mandelbox.foldingValue - z.x;
aux.mboxColor += fractal->mandelbox.colorFactor.x;
}
z = fractal->mandelbox.rotinv[1][0].RotateVector(z);
lockout = false;
z = fractal->mandelbox.rot[0][1].RotateVector(z);
if (z.y > fractal->mandelbox.foldingLimit)
{
z.y = fractal->mandelbox.foldingValue - z.y;
aux.mboxColor += fractal->mandelbox.colorFactor.y;
lockout = true;
}
z = fractal->mandelbox.rotinv[0][1].RotateVector(z);
z = fractal->mandelbox.rot[1][1].RotateVector(z);
if (!lockout && z.y < -fractal->mandelbox.foldingLimit)
{
z.y = -fractal->mandelbox.foldingValue - z.y;
aux.mboxColor += fractal->mandelbox.colorFactor.y;
}
z = fractal->mandelbox.rotinv[1][1].RotateVector(z);
lockout = false;
z = fractal->mandelbox.rot[0][2].RotateVector(z);
if (z.z > fractal->mandelbox.foldingLimit)
{
z.z = fractal->mandelbox.foldingValue - z.z;
aux.mboxColor += fractal->mandelbox.colorFactor.z;
lockout = true;
}
z = fractal->mandelbox.rotinv[0][2].RotateVector(z);
z = fractal->mandelbox.rot[1][2].RotateVector(z);
if (!lockout && z.z < -fractal->mandelbox.foldingLimit)
{
z.z = -fractal->mandelbox.foldingValue - z.z;
aux.mboxColor += fractal->mandelbox.colorFactor.z;
}
z = fractal->mandelbox.rotinv[1][2].RotateVector(z);
}
else
{
if (z.x > fractal->mandelbox.foldingLimit)
{
z.x = fractal->mandelbox.foldingValue - z.x;
aux.mboxColor += fractal->mandelbox.colorFactor.x;
}
else if (z.x < -fractal->mandelbox.foldingLimit)
{
z.x = -fractal->mandelbox.foldingValue - z.x;
aux.mboxColor += fractal->mandelbox.colorFactor.x;
}
if (z.y > fractal->mandelbox.foldingLimit)
{
z.y = fractal->mandelbox.foldingValue - z.y;
aux.mboxColor += fractal->mandelbox.colorFactor.y;
}
else if (z.y < -fractal->mandelbox.foldingLimit)
{
z.y = -fractal->mandelbox.foldingValue - z.y;
aux.mboxColor += fractal->mandelbox.colorFactor.y;
}
if (z.z > fractal->mandelbox.foldingLimit)
{
z.z = fractal->mandelbox.foldingValue - z.z;
aux.mboxColor += fractal->mandelbox.colorFactor.z;
}
else if (z.z < -fractal->mandelbox.foldingLimit)
{
z.z = -fractal->mandelbox.foldingValue - z.z;
aux.mboxColor += fractal->mandelbox.colorFactor.z;
}
}
double r2 = z.Dot(z);
z += fractal->mandelbox.offset;
if (r2 < fractal->mandelbox.mR2)
{
z *= fractal->mandelbox.mboxFactor1;
aux.mboxDE *= fractal->mandelbox.mboxFactor1;
aux.mboxColor += fractal->mandelbox.colorFactorSp1;
}
else if (r2 < fractal->mandelbox.fR2)
{
double tglad_factor2 = fractal->mandelbox.fR2 / r2;
z *= tglad_factor2;
aux.mboxDE *= tglad_factor2;
aux.mboxColor += fractal->mandelbox.colorFactorSp2;
}
z -= fractal->mandelbox.offset;
if(fractal->mandelbox.mainRotationEnabled)
{
z = fractal->mandelbox.mainRot.RotateVector(z);
}
z = z * fractal->mandelbox.scale;
aux.mboxDE = aux.mboxDE * fabs(fractal->mandelbox.scale) + 1.0;
}
