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; }