// Minimal Mandelbulb fractal shader - test version

#define MARCH_MAX_STEPS 200
#define MARCH_MAX_DISTANCE 500.0
#define DE_MAX_ITER 25
#define DE_BAILOUT 10.0

#define HIT_STATUS_HIT 1
#define HIT_STATUS_MISS_DISTANCE 2
#define HIT_STATUS_MISS_STEPS 3

struct MarchResult
{
	float distance;
	int steps;
	int hitStatus;
	int totalDEIterations;
};

struct FractalFunctions
{
	// Computes the world-space radius that a sphere must have to appear 1 pixel tall on screen at a given distance.
	static float GetPixelWorldRadius(float distance)
	{
		return distance * ResolvedView.ClipToView._22 / ResolvedView.ViewSizeAndInvSize.y;
	}

	// Mandelbulb distance estimator
	static float MandelbulbDE(float3 pos, float power, out int iterations)
	{
		float3 z = pos;
		float dr = 1.0;
		float r = 0.0;
		
		for (iterations = 0; iterations < DE_MAX_ITER; iterations++)
		{
			r = length(z);
			if (r > DE_BAILOUT)
				break;
			
			// Convert to spherical coordinates
			float theta = acos(z.z / r);
			float phi = atan2(z.y, z.x);
			dr = pow(r, power - 1.0) * power * dr + 1.0;
			
			// Scale and rotate the point
			float zr = pow(r, power);
			theta = theta * power;
			phi = phi * power;
			
			// Convert back to Cartesian coordinates
			float sinTheta = sin(theta);
			z = zr * float3(sinTheta * cos(phi), sinTheta * sin(phi), cos(theta));
			z += pos;
		}
		
		return 0.5 * log(r) * r / dr;
	}

	// Ray marching
	static MarchResult MarchFractal(float3 rayOrigin, float3 rayDir, float power)
	{
		float totalDist = 0.0;
		int steps = 0;
		int totalDEIterations = 0;

		while (totalDist < MARCH_MAX_DISTANCE && steps < MARCH_MAX_STEPS)
		{
			steps++;
			float3 pos = rayOrigin + rayDir * totalDist;
			
			int deIterations;
			float distance = MandelbulbDE(pos, power, deIterations);
			totalDEIterations += deIterations;

			float pixelSize = GetPixelWorldRadius(totalDist);

			if (distance <= pixelSize)
			{
				MarchResult result;
				result.distance = totalDist;
				result.steps = steps;
				result.hitStatus = HIT_STATUS_HIT;
				result.totalDEIterations = totalDEIterations;
				return result;
			}

			float stepSize = max(distance, pixelSize * 0.5);
			totalDist += stepSize;
		}

		MarchResult result;
		result.distance = totalDist;
		result.steps = steps;
		result.hitStatus = (totalDist >= MARCH_MAX_DISTANCE) ? HIT_STATUS_MISS_DISTANCE : HIT_STATUS_MISS_STEPS;
		result.totalDEIterations = totalDEIterations;
		return result;
	}

	static float3 RenderFractal(float2 screenUV, float3 sceneColor, float power)
	{
		// Get camera parameters
		float3 cameraOrigin = LWCHackToFloat(ResolvedView.WorldCameraOrigin);

		// Convert screen UV to clip space
		float2 clipXY = screenUV * 2.0 - 1.0;
		clipXY.y = -clipXY.y;

		float4 clipPos = float4(clipXY, 1.0, 1.0);
		float4 viewPos = mul(clipPos, ResolvedView.ClipToView);
		viewPos.xyz /= viewPos.w;

		// Transform view direction to world space
		float3 worldDir = normalize(mul(viewPos.xyz, (float3x3)ResolvedView.ViewToTranslatedWorld));

		// Scale down the camera origin for better framing
		float3 rayOrigin = cameraOrigin * 0.001;
		float3 rayDir = worldDir;

		// Ray march
		MarchResult finalResult = MarchFractal(rayOrigin, rayDir, power);

		// Calculate color based on total steps taken
		float stepFactor = saturate(finalResult.steps / float(MARCH_MAX_STEPS));
		float t = sqrt(stepFactor);
		
		// Gradient color stops
		float3 almostBlack = float3(0.0, 0.0, 0.05);
		float3 deepBlue = float3(0.05, 0.15, 0.3);
		float3 vibrantBlue = float3(0.2, 0.4, 0.8);
		float3 brightBlue = float3(0.6, 0.8, 1.0);
		
		// Blend through gradient
		float range1 = saturate(t / 0.15);
		float range2 = saturate((t - 0.15) / 0.25);
		float range3 = saturate((t - 0.4) / 0.6);
		float3 fractalColor = lerp(lerp(lerp(almostBlack, deepBlue, range1), vibrantBlue, range2), brightBlue, range3);

		// Add green tint based on total DE iterations
		float iterFactor = saturate(finalResult.totalDEIterations / float(DE_MAX_ITER * finalResult.steps));
		
		if (iterFactor > 0.1)
		{
			float greenAmount = (iterFactor - 0.1) / 0.9;
			greenAmount = pow(greenAmount, 2.0);
			fractalColor = lerp(fractalColor, float3(0.3, 0.5, 0.6), greenAmount);
		}

		if (iterFactor > 0.9)
		{
			float greenAmount = (iterFactor - 0.9) / 0.1;
			greenAmount = pow(greenAmount, 5.0);
			fractalColor = lerp(fractalColor, float3(0.3, 0.9, 0.7), greenAmount);
		}

		if (finalResult.hitStatus == HIT_STATUS_HIT)
		{
			return fractalColor;
		}
		else if (finalResult.hitStatus == HIT_STATUS_MISS_DISTANCE)
		{
			float fogAmount = pow(stepFactor, 0.1);
			return lerp(sceneColor, fractalColor, fogAmount);
		}
		else
		{
			return fractalColor;
		}
	}
};

// Usage in material custom node:
// #include "/Project/FractalMaterial.usf"
// FractalFunctions FF;
// return FF.RenderFractal(ScreenPosition, SceneColor, Power).rgb;