feat: clean repository without any huge files

src/components/UnifiedMappingMaterial.tsx

@@ -0,0 +1,176 @@
+import React, { useMemo, useRef, useEffect } from 'react';
+import * as THREE from 'three';
+import { useTexture } from '@react-three/drei';
+
+// Mapping Types Enum
+export const MAPPING_TYPES = {
+  UV: 0,
+  PLANAR: 1,
+  CYLINDER: 2,
+  SPHERE: 3,
+  BOX: 4,
+};
+
+const vertexShader = `
+  varying vec2 vUv;
+  varying vec3 vLocalPos;
+  varying vec3 vNormal;
+  varying vec3 vWorldPos;
+
+  void main() {
+    vUv = uv;
+    vLocalPos = position;
+    vNormal = normalize(normal);
+    vWorldPos = (modelMatrix * vec4(position, 1.0)).xyz;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+
+const fragmentShader = `
+  uniform sampler2D uTexture;
+  uniform int uMappingType;
+  uniform float uScale;
+  uniform vec2 uTiling;
+  uniform vec2 uOffset;
+  uniform float uRotation;
+  uniform vec3 uBBoxMin;
+  uniform vec3 uBBoxMax;
+
+  varying vec2 vUv;
+  varying vec3 vLocalPos;
+  varying vec3 vNormal;
+
+  #ifndef PI
+  #define PI 3.14159265359
+  #endif
+
+  vec2 rotateUV(vec2 uv, float rotation) {
+    float mid = 0.5;
+    float cosAngle = cos(rotation);
+    float sinAngle = sin(rotation);
+    float dx = uv.x - mid;
+    float dy = uv.y - mid;
+    return vec2(
+      cosAngle * dx - sinAngle * dy + mid,
+      sinAngle * dx + cosAngle * dy + mid
+    );
+  }
+
+  void main() {
+    vec2 finalUv = vec2(0.0);
+
+    // Bounding box calculations for dynamic projections
+    vec3 boundsSize = uBBoxMax - uBBoxMin;
+    vec3 boundsPos = (vLocalPos - uBBoxMin) / (boundsSize + 0.00001);
+    vec3 center = (uBBoxMax + uBBoxMin) * 0.5;
+    vec3 dir = vLocalPos - center;
+    vec3 normDir = normalize(dir + 0.00001);
+
+    if (uMappingType == 0) {
+      // UV: Applies native geometry vUv
+      finalUv = vUv;
+    } else if (uMappingType == 1) {
+      // PLANAR (XZ / Top-Down)
+      finalUv = boundsPos.xz;
+    } else if (uMappingType == 2) {
+      // CYLINDER: u = angle around Y, v = normalized height
+      vec3 localRel = vLocalPos - center;
+      float u = (atan(localRel.z, localRel.x) / (2.0 * PI)) + 0.5;
+      float v = boundsPos.y; 
+      finalUv = vec2(u, v);
+    } else if (uMappingType == 3) {
+      // SPHERE
+      float u = (atan(normDir.z, normDir.x) / (2.0 * PI)) + 0.5;
+      float v = (asin(clamp(normDir.y, -1.0, 1.0)) / PI) + 0.5;
+      finalUv = vec2(u, v);
+    } else if (uMappingType == 4) {
+      // BOX (Triplanar)
+      vec3 absNormal = abs(vNormal);
+      if (absNormal.x > absNormal.y && absNormal.x > absNormal.z) {
+        finalUv = boundsPos.zy;
+      } else if (absNormal.y > absNormal.x && absNormal.y > absNormal.z) {
+        finalUv = boundsPos.xz;
+      } else {
+        finalUv = boundsPos.xy;
+      }
+    }
+
+    // Apply Tiling, Scale, and Offset
+    finalUv = finalUv * uTiling * uScale + uOffset;
+    
+    // Apply Rotation
+    if (uRotation != 0.0) {
+      finalUv = rotateUV(finalUv, uRotation);
+    }
+
+    vec4 texColor = texture2D(uTexture, finalUv);
+    gl_FragColor = texColor;
+  }
+`;
+
+export const UnifiedMappingMaterial = ({ 
+  textureUrl, 
+  mappingType = 'UV', 
+  uvScale = 1.0,
+  uvTiling = [1, 1],
+  uvOffset = [0, 0],
+  uvRotation = 0,
+  geometry
+}) => {
+  const materialRef = useRef<THREE.ShaderMaterial>(null);
+  
+  // Load texture
+  const texture = useTexture(textureUrl) as THREE.Texture;
+  
+  useEffect(() => {
+    if (texture) {
+      texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
+      texture.needsUpdate = true;
+    }
+  }, [texture]);
+
+  // Initialize Uniforms
+  const uniforms = useMemo(() => ({
+    uTexture: { value: texture },
+    uMappingType: { value: MAPPING_TYPES[mappingType as keyof typeof MAPPING_TYPES] || 0 },
+    uScale: { value: uvScale },
+    uTiling: { value: new THREE.Vector2(uvTiling[0], uvTiling[1]) },
+    uOffset: { value: new THREE.Vector2(uvOffset[0], uvOffset[1]) },
+    uRotation: { value: uvRotation * (Math.PI / 180) },
+    uBBoxMin: { value: new THREE.Vector3(-1, -1, -1) },
+    uBBoxMax: { value: new THREE.Vector3(1, 1, 1) }
+  }), [texture]);
+
+  // Real-time Uniform Updates
+  useEffect(() => {
+    if (materialRef.current) {
+      const u = materialRef.current.uniforms;
+      u.uMappingType.value = MAPPING_TYPES[mappingType as keyof typeof MAPPING_TYPES] || 0;
+      u.uScale.value = uvScale;
+      u.uTiling.value.set(uvTiling[0], uvTiling[1]);
+      u.uOffset.value.set(uvOffset[0], uvOffset[1]);
+      u.uRotation.value = uvRotation * (Math.PI / 180);
+    }
+  }, [mappingType, uvScale, uvTiling, uvOffset, uvRotation]);
+
+  // Bounding Box Update
+  useEffect(() => {
+    if (geometry && materialRef.current) {
+      geometry.computeBoundingBox();
+      const box = geometry.boundingBox || new THREE.Box3().setFromObject(new THREE.Mesh(geometry));
+      materialRef.current.uniforms.uBBoxMin.value.copy(box.min);
+      materialRef.current.uniforms.uBBoxMax.value.copy(box.max);
+    }
+  }, [geometry]);
+
+  return (
+    <shaderMaterial
+      ref={materialRef}
+      uniforms={uniforms}
+      vertexShader={vertexShader}
+      fragmentShader={fragmentShader}
+      side={THREE.DoubleSide}
+      transparent={true}
+    />
+  );
+};