Update app.py

app.py

@@ -125,11 +125,9 @@ EDITOR_TEMPLATE = '''
         button:hover { background: #0099ff; }
         button.play-button { background: #22aa22; }
         button.play-button:hover { background: #33cc33; }
-        button.danger-button { background: #cc2222; }
-        button.danger-button:hover { background: #ff3333; }
         .slider-container { margin-top: 10px; }
         input[type="range"] { width: 100%; }
-        .radio-group label { display: inline-block; margin-right: 10px; cursor: pointer; font-size: 0.9em; }
+        .radio-group label { display: inline-block; margin-right: 10px; cursor: pointer; }
         .radio-group input { margin-right: 5px; }
 
         #loading-spinner {
@@ -204,16 +202,10 @@ EDITOR_TEMPLATE = '''
                 <div class="radio-group">
                     <label><input type="radio" name="brush-mode" value="raise" checked> Поднять</label>
                     <label><input type="radio" name="brush-mode" value="lower"> Опустить</label>
+                    <label><input type="radio" name="brush-mode" value="roughen"> Шум</label>
                     <label><input type="radio" name="brush-mode" value="smooth"> Сгладить</label>
                     <label><input type="radio" name="brush-mode" value="flatten"> Выровнять</label>
-                    <br>
-                    <label><input type="radio" name="brush-mode" value="roughen"> Шум</label>
-                    <label><input type="radio" name="brush-mode" value="erode"> Эрозия</label>
-                    <label><input type="radio" name="brush-mode" value="terrace"> Терраса</label>
-                    <label><input type="radio" name="brush-mode" value="pinch"> Щипок</label>
-                    <br>
                     <label><input type="radio" name="brush-mode" value="paint"> Текстура</label>
-                    <label><input type="radio" name="brush-mode" value="foliage"> Растительность</label>
                     <label><input type="radio" name="brush-mode" value="place"> Объект</label>
                 </div>
                 <div class="slider-container">
@@ -221,7 +213,7 @@ EDITOR_TEMPLATE = '''
                     <input type="range" id="brush-size" min="1" max="50" value="10">
                 </div>
                 <div class="slider-container">
-                    <label for="brush-strength">Сила/Плотность: <span id="brush-strength-value">0.5</span></label>
+                    <label for="brush-strength">Сила: <span id="brush-strength-value">0.5</span></label>
                     <input type="range" id="brush-strength" min="0.1" max="2" step="0.1" value="0.5">
                 </div>
             </div>
@@ -234,14 +226,6 @@ EDITOR_TEMPLATE = '''
                     <label><input type="radio" name="texture-type" value="snow"> Снег</label>
                     <label><input type="radio" name="texture-type" value="sand"> Песок</label>
                 </div>
-            </div>
-            <div class="ui-group">
-                <h3>Авто-текстурирование</h3>
-                <label for="snow-height">Высота снега: <span id="snow-height-value">30</span></label>
-                <input type="range" id="snow-height" min="0" max="100" value="30">
-                <label for="rock-slope">Угол скал: <span id="rock-slope-value">0.6</span></label>
-                <input type="range" id="rock-slope" min="0.1" max="0.9" step="0.05" value="0.6">
-                <button id="apply-auto-texture">Применить ко всему ландшафту</button>
             </div>
              <div class="ui-group" id="texture-management-group">
                 <h3>Управление текстурами</h3>
@@ -253,7 +237,7 @@ EDITOR_TEMPLATE = '''
                     <option value="snow">Снег</option>
                     <option value="sand">Песок</option>
                 </select>
-                <label for="custom-texture-file">Выберите файл текстуры (Albedo):</label>
+                <label for="custom-texture-file">Выберите файл текстуры:</label>
                 <input type="file" id="custom-texture-file" accept="image/*">
                 <button id="update-texture-btn">Обновить текстуру</button>
                 <label for="texture-slot-name">Новое имя для слота:</label>
@@ -261,19 +245,11 @@ EDITOR_TEMPLATE = '''
                 <button id="rename-texture-slot-btn">Переименовать</button>
             </div>
             <div class="ui-group">
-                <h3>Размещение объектов</h3>
-                <p style="font-size:0.8em; color: #aaa;">Режим "Объект" в кистях. Выберите модель и рисуйте ей на карте.</p>
-                <label for="object-select">Модель для размещения:</label>
-                <select id="object-select">
-                    <option value="tree">Дерево</option>
-                    <option value="rock">Камень</option>
-                </select>
-                <button id="clear-placed-objects" class="danger-button">Очистить размещенные объекты</button>
-            </div>
-             <div class="ui-group">
-                <h3>Растительность</h3>
-                <p style="font-size:0.8em; color: #aaa;">Режим "Растительность" в кистях.</p>
-                <button id="clear-foliage" class="danger-button">Очистить растительность</button>
+                <h3>Объекты</h3>
+                <div class="radio-group" id="object-selector">
+                    <label><input type="radio" name="object-type" value="grass" checked> Трава</label>
+                </div>
+                <button id="clear-objects">Очистить объекты</button>
             </div>
         </div>
     </div>
@@ -311,8 +287,6 @@ EDITOR_TEMPLATE = '''
         import { RenderPass } from 'three/addons/postprocessing/RenderPass.js';
         import { SSAOPass } from 'three/addons/postprocessing/SSAOPass.js';
         import { UnrealBloomPass } from 'three/addons/postprocessing/UnrealBloomPass.js';
-        import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js';
-        import { RGBELoader } from 'three/addons/loaders/RGBELoader.js';
         import { createNoise2D } from 'simplex-noise';
 
         let scene, camera, renderer, orbitControls, pointerLockControls, composer, brushHelper, terrainMesh, sky, sun;
@@ -325,9 +299,6 @@ EDITOR_TEMPLATE = '''
         const MAX_GRASS_COUNT = 100000;
         const terrainDimensions = { width: 100, height: 100, segmentsX: 100, segmentsY: 100 };
         
-        let placedObjectsGroup;
-        let models = {};
-
         let isPlayMode = false;
         let player, playerVelocity = new THREE.Vector3(), playerOnGround = false;
         const playerHeight = 1.8;
@@ -341,231 +312,99 @@ EDITOR_TEMPLATE = '''
         const textureLoader = new THREE.TextureLoader();
         let customTextures = {};
         let flattenHeight = null;
-        
-        const TEXTURE_ASSET_BASE = 'https://raw.githubusercontent.com/dream-dev-ar/3D-Designer-Assets/main/textures/';
-        const MODEL_ASSET_BASE = 'https://raw.githubusercontent.com/dream-dev-ar/3D-Designer-Assets/main/models/';
-        const ENV_MAP_ASSET = 'https://raw.githubusercontent.com/dream-dev-ar/3D-Designer-Assets/main/env/kloofendal_48d_partly_cloudy_puresky_2k.hdr';
 
-        const loadTexture = (path) => {
-            const tex = textureLoader.load(TEXTURE_ASSET_BASE + path);
+        const loadTexture = (url) => {
+            const tex = textureLoader.load(url);
             tex.wrapS = THREE.RepeatWrapping;
             tex.wrapT = THREE.RepeatWrapping;
             tex.anisotropy = 16;
-            tex.colorSpace = THREE.SRGBColorSpace;
             return tex;
         };
         
-        const pbrTextures = {
-            grass: {
-                map: loadTexture('grass/color.jpg'),
-                normalMap: loadTexture('grass/normal.jpg'),
-                roughnessMap: loadTexture('grass/roughness.jpg'),
-                aoMap: loadTexture('grass/ao.jpg'),
-            },
-            rock: {
-                map: loadTexture('rock/color.jpg'),
-                normalMap: loadTexture('rock/normal.jpg'),
-                roughnessMap: loadTexture('rock/roughness.jpg'),
-                aoMap: loadTexture('rock/ao.jpg'),
-            },
-            dirt: {
-                map: loadTexture('dirt/color.jpg'),
-                normalMap: loadTexture('dirt/normal.jpg'),
-                roughnessMap: loadTexture('dirt/roughness.jpg'),
-                aoMap: loadTexture('dirt/ao.jpg'),
-            },
-            snow: {
-                map: loadTexture('snow/color.jpg'),
-                normalMap: loadTexture('snow/normal.jpg'),
-                roughnessMap: loadTexture('snow/roughness.jpg'),
-                aoMap: loadTexture('snow/ao.jpg'),
-            },
-            sand: {
-                map: loadTexture('sand/color.jpg'),
-                normalMap: loadTexture('sand/normal.jpg'),
-                roughnessMap: loadTexture('sand/roughness.jpg'),
-                aoMap: loadTexture('sand/ao.jpg'),
-            },
+        const textures = {
+            grass: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/grasslight-big.jpg'),
+            rock: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/rock.jpg'),
+            dirt: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/sand-512.jpg'),
+            snow: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/snow.jpg'),
+            sand: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/sand-512.jpg'),
+            grassNormal: loadTexture('https://raw.githubusercontent.com/mrdoob/three.js/master/examples/textures/terrain/grasslight-big-nm.jpg'),
+            rockNormal: loadTexture('https://raw.githubusercontent.com/mrdoob/three.js/master/examples/textures/terrain/rock-nm.jpg')
         };
         
         const terrainMaterial = new THREE.ShaderMaterial({
-            lights: true,
             uniforms: {
-                ...THREE.UniformsLib.lights,
-                ...THREE.UniformsLib.fog,
-                
-                uvScale: { value: 30.0 },
-                
-                grass_map: { value: pbrTextures.grass.map },
-                grass_normalMap: { value: pbrTextures.grass.normalMap },
-                grass_roughnessMap: { value: pbrTextures.grass.roughnessMap },
-                grass_aoMap: { value: pbrTextures.grass.aoMap },
-                
-                rock_map: { value: pbrTextures.rock.map },
-                rock_normalMap: { value: pbrTextures.rock.normalMap },
-                rock_roughnessMap: { value: pbrTextures.rock.roughnessMap },
-                rock_aoMap: { value: pbrTextures.rock.aoMap },
-                
-                dirt_map: { value: pbrTextures.dirt.map },
-                dirt_normalMap: { value: pbrTextures.dirt.normalMap },
-                dirt_roughnessMap: { value: pbrTextures.dirt.roughnessMap },
-                dirt_aoMap: { value: pbrTextures.dirt.aoMap },
-                
-                snow_map: { value: pbrTextures.snow.map },
-                snow_normalMap: { value: pbrTextures.snow.normalMap },
-                snow_roughnessMap: { value: pbrTextures.snow.roughnessMap },
-                snow_aoMap: { value: pbrTextures.snow.aoMap },
-
-                sand_map: { value: pbrTextures.sand.map },
-                sand_normalMap: { value: pbrTextures.sand.normalMap },
-                sand_roughnessMap: { value: pbrTextures.sand.roughnessMap },
-                sand_aoMap: { value: pbrTextures.sand.aoMap },
+                grassTexture: { value: textures.grass },
+                rockTexture: { value: textures.rock },
+                dirtTexture: { value: textures.dirt },
+                snowTexture: { value: textures.snow },
+                sandTexture: { value: textures.sand },
+                grassNormalMap: { value: textures.grassNormal },
+                rockNormalMap: { value: textures.rockNormal },
+                lightDirection: { value: new THREE.Vector3(0.5, 0.5, 0.5).normalize() }
             },
             vertexShader: `
-                attribute vec4 color;
-                attribute vec4 tangent;
-
                 varying vec2 vUv;
                 varying vec3 vNormal;
                 varying vec3 vViewPosition;
+                attribute vec4 color;
                 varying vec4 vColor;
-                varying mat3 vTBN;
-                varying vec3 vWorldPosition;
+                attribute vec4 tangent;
+                varying vec3 vTangent;
+                varying vec3 vBitangent;
 
                 void main() {
                     vUv = uv;
                     vColor = color;
-                    
                     vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
                     vViewPosition = -mvPosition.xyz;
-                    vWorldPosition = (modelMatrix * vec4(position, 1.0)).xyz;
                     vNormal = normalize(normalMatrix * normal);
-                    
-                    vec3 t = normalize(normalMatrix * tangent.xyz);
-                    vec3 b = normalize(cross(vNormal, t) * tangent.w);
-                    vTBN = mat3(t, b, vNormal);
-
+                    vTangent = normalize(normalMatrix * tangent.xyz);
+                    vBitangent = normalize(cross(vNormal, vTangent) * tangent.w);
                     gl_Position = projectionMatrix * mvPosition;
                 }
             `,
             fragmentShader: `
-                #include <common>
-                #include <packing>
-                #include <lights_pars_begin>
-                #include <fog_pars_fragment>
-
-                uniform float uvScale;
-
-                uniform sampler2D grass_map;
-                uniform sampler2D grass_normalMap;
-                uniform sampler2D grass_roughnessMap;
-                uniform sampler2D grass_aoMap;
-
-                uniform sampler2D rock_map;
-                uniform sampler2D rock_normalMap;
-                uniform sampler2D rock_roughnessMap;
-                uniform sampler2D rock_aoMap;
-
-                uniform sampler2D dirt_map;
-                uniform sampler2D dirt_normalMap;
-                uniform sampler2D dirt_roughnessMap;
-                uniform sampler2D dirt_aoMap;
-
-                uniform sampler2D snow_map;
-                uniform sampler2D snow_normalMap;
-                uniform sampler2D snow_roughnessMap;
-                uniform sampler2D snow_aoMap;
-                
-                uniform sampler2D sand_map;
-                uniform sampler2D sand_normalMap;
-                uniform sampler2D sand_roughnessMap;
-                uniform sampler2D sand_aoMap;
+                uniform sampler2D grassTexture;
+                uniform sampler2D rockTexture;
+                uniform sampler2D dirtTexture;
+                uniform sampler2D snowTexture;
+                uniform sampler2D sandTexture;
+                uniform sampler2D grassNormalMap;
+                uniform sampler2D rockNormalMap;
+                uniform vec3 lightDirection;
 
                 varying vec2 vUv;
+                varying vec4 vColor;
                 varying vec3 vNormal;
                 varying vec3 vViewPosition;
-                varying vec4 vColor;
-                varying mat3 vTBN;
-                varying vec3 vWorldPosition;
+                varying vec3 vTangent;
+                varying vec3 vBitangent;
 
                 void main() {
-                    vec2 scaledUv = vUv * uvScale;
-
-                    vec4 grassColor = texture2D(grass_map, scaledUv);
-                    vec4 rockColor = texture2D(rock_map, scaledUv);
-                    vec4 dirtColor = texture2D(dirt_map, scaledUv);
-                    vec4 snowColor = texture2D(snow_map, scaledUv);
-                    vec4 sandColor = texture2D(sand_map, scaledUv);
+                    vec2 uv_scaled = vUv * 30.0;
                     
-                    float grassAmount = 1.0 - vColor.r - vColor.g - vColor.b - vColor.a;
-
-                    vec3 albedo = grassColor.rgb * grassAmount;
-                    albedo = mix(albedo, rockColor.rgb, vColor.r);
-                    albedo = mix(albedo, dirtColor.rgb, vColor.g);
-                    albedo = mix(albedo, snowColor.rgb, vColor.b);
-                    albedo = mix(albedo, sandColor.rgb, vColor.a);
+                    vec4 grass = texture2D(grassTexture, uv_scaled);
+                    vec4 rock = texture2D(rockTexture, uv_scaled);
+                    vec4 dirt = texture2D(dirtTexture, uv_scaled);
+                    vec4 snow = texture2D(snowTexture, uv_scaled);
+                    vec4 sand = texture2D(sandTexture, uv_scaled);
+
+                    vec3 finalColor = grass.rgb;
+                    finalColor = mix(finalColor, rock.rgb, vColor.r);
+                    finalColor = mix(finalColor, dirt.rgb, vColor.g);
+                    finalColor = mix(finalColor, snow.rgb, vColor.b);
+                    finalColor = mix(finalColor, sand.rgb, vColor.a);
                     
-                    vec3 grassNormal = texture2D(grass_normalMap, scaledUv).xyz * 2.0 - 1.0;
-                    vec3 rockNormal = texture2D(rock_normalMap, scaledUv).xyz * 2.0 - 1.0;
-                    vec3 dirtNormal = texture2D(dirt_normalMap, scaledUv).xyz * 2.0 - 1.0;
-                    vec3 snowNormal = texture2D(snow_normalMap, scaledUv).xyz * 2.0 - 1.0;
-                    vec3 sandNormal = texture2D(sand_normalMap, scaledUv).xyz * 2.0 - 1.0;
-
-                    vec3 blendedNormal = grassNormal * grassAmount;
-                    blendedNormal = mix(blendedNormal, rockNormal, vColor.r);
-                    blendedNormal = mix(blendedNormal, dirtNormal, vColor.g);
-                    blendedNormal = mix(blendedNormal, snowNormal, vColor.b);
-                    blendedNormal = mix(blendedNormal, sandNormal, vColor.a);
-
-                    vec3 normal = normalize(vTBN * normalize(blendedNormal));
-                    
-                    float grassRoughness = texture2D(grass_roughnessMap, scaledUv).r;
-                    float rockRoughness = texture2D(rock_roughnessMap, scaledUv).r;
-                    float dirtRoughness = texture2D(dirt_roughnessMap, scaledUv).r;
-                    float snowRoughness = texture2D(snow_roughnessMap, scaledUv).r;
-                    float sandRoughness = texture2D(sand_roughnessMap, scaledUv).r;
-
-                    float roughness = grassRoughness * grassAmount;
-                    roughness = mix(roughness, rockRoughness, vColor.r);
-                    roughness = mix(roughness, dirtRoughness, vColor.g);
-                    roughness = mix(roughness, snowRoughness, vColor.b);
-                    roughness = mix(roughness, sandRoughness, vColor.a);
-
-                    float grassAo = texture2D(grass_aoMap, scaledUv).r;
-                    float rockAo = texture2D(rock_aoMap, scaledUv).r;
-                    float dirtAo = texture2D(dirt_aoMap, scaledUv).r;
-                    float snowAo = texture2D(snow_aoMap, scaledUv).r;
-                    float sandAo = texture2D(sand_aoMap, scaledUv).r;
-
-                    float ao = grassAo * grassAmount;
-                    ao = mix(ao, rockAo, vColor.r);
-                    ao = mix(ao, dirtAo, vColor.g);
-                    ao = mix(ao, snowAo, vColor.b);
-                    ao = mix(ao, sandAo, vColor.a);
-
-                    float metalness = 0.0;
-                    
-                    ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
-                    
-                    vec3 viewDir = normalize(vViewPosition);
-                    float dotNV = saturate( dot( normal, viewDir ) );
-                    vec3 F0 = vec3(0.04);
-                    vec3 specular = vec3(0.0);
-
-                    #if NUM_DIR_LIGHTS > 0 
-                        for( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
-                            vec3 lightDirection = directionalLights[i].direction;
-                            vec3 lightColor = directionalLights[i].color;
-                            reflectedLight.directDiffuse += BRDF_Lambert( lightColor ) * albedo;
-                        }
-                    #endif
+                    mat3 tbn = mat3(vTangent, vBitangent, vNormal);
 
-                    vec3 outgoingLight = reflectedLight.directDiffuse * ao + reflectedLight.indirectDiffuse * ao + reflectedLight.directSpecular + reflectedLight.indirectSpecular;
-                    gl_FragColor = vec4( outgoingLight, 1.0 );
+                    vec3 grassNormal = texture2D(grassNormalMap, uv_scaled).xyz * 2.0 - 1.0;
+                    vec3 rockNormal = texture2D(rockNormalMap, uv_scaled).xyz * 2.0 - 1.0;
+                    
+                    vec3 blendedNormal = normalize(mix(grassNormal, rockNormal, vColor.r));
+                    vec3 normal = normalize(tbn * blendedNormal);
 
-                    #include <tonemapping_fragment>
-	                #include <colorspace_fragment>
-                    #include <fog_fragment>
+                    float lighting = dot(normal, lightDirection) * 0.5 + 0.5;
+                    gl_FragColor = vec4(finalColor * lighting, 1.0);
                 }
             `
         });
@@ -584,32 +423,49 @@ EDITOR_TEMPLATE = '''
             renderer.toneMapping = THREE.ACESFilmicToneMapping;
             renderer.outputColorSpace = THREE.SRGBColorSpace;
             document.body.appendChild(renderer.domElement);
-            
-            const rgbeLoader = new RGBELoader();
-            rgbeLoader.load(ENV_MAP_ASSET, function (texture) {
-                texture.mapping = THREE.EquirectangularReflectionMapping;
-                scene.environment = texture;
-                scene.background = texture;
-            });
 
             orbitControls = new OrbitControls(camera, renderer.domElement);
             orbitControls.enableDamping = true;
             orbitControls.maxPolarAngle = Math.PI / 2.1;
 
-            const hemiLight = new THREE.HemisphereLight(0xffffff, 0x444444, 0.1);
+            const hemiLight = new THREE.HemisphereLight(0xffffff, 0x444444, 0.5);
             scene.add(hemiLight);
 
-            const dirLight = new THREE.DirectionalLight(0xffffff, 4.0);
+            const dirLight = new THREE.DirectionalLight(0xffffff, 1.5);
             dirLight.position.set(100, 100, 50);
             dirLight.castShadow = true;
-            dirLight.shadow.mapSize.width = 4096;
-            dirLight.shadow.mapSize.height = 4096;
-            dirLight.shadow.camera.top = 150;
-            dirLight.shadow.camera.bottom = -150;
-            dirLight.shadow.camera.left = -150;
-            dirLight.shadow.camera.right = 150;
+            dirLight.shadow.mapSize.width = 2048;
+            dirLight.shadow.mapSize.height = 2048;
+            dirLight.shadow.camera.top = 100;
+            dirLight.shadow.camera.bottom = -100;
+            dirLight.shadow.camera.left = -100;
+            dirLight.shadow.camera.right = 100;
             dirLight.shadow.bias = -0.001;
             scene.add(dirLight);
+            terrainMaterial.uniforms.lightDirection.value = dirLight.position.clone().normalize();
+
+            sky = new Sky();
+            sky.scale.setScalar(450000);
+            scene.add(sky);
+            sun = new THREE.Vector3();
+            const effectController = {
+                turbidity: 10,
+                rayleigh: 3,
+                mieCoefficient: 0.005,
+                mieDirectionalG: 0.7,
+                elevation: 4,
+                azimuth: 180,
+            };
+            const uniforms = sky.material.uniforms;
+            uniforms[ 'turbidity' ].value = effectController.turbidity;
+            uniforms[ 'rayleigh' ].value = effectController.rayleigh;
+            uniforms[ 'mieCoefficient' ].value = effectController.mieCoefficient;
+            uniforms[ 'mieDirectionalG' ].value = effectController.mieDirectionalG;
+            const phi = THREE.MathUtils.degToRad( 90 - effectController.elevation );
+            const theta = THREE.MathUtils.degToRad( effectController.azimuth );
+            sun.setFromSphericalCoords( 1, phi, theta );
+            uniforms[ 'sunPosition' ].value.copy( sun );
+            dirLight.position.copy(sun).multiplyScalar(100);
 
             const brushGeometry = new THREE.CylinderGeometry(1, 1, 100, 32, 1, true);
             const brushMaterial = new THREE.MeshBasicMaterial({ color: 0xffff00, wireframe: true, transparent: true, opacity: 0.5 });
@@ -617,11 +473,7 @@ EDITOR_TEMPLATE = '''
             brushHelper.visible = false;
             scene.add(brushHelper);
 
-            placedObjectsGroup = new THREE.Group();
-            scene.add(placedObjectsGroup);
-
             initFoliage();
-            initModels();
             initPostprocessing();
             initPlayer();
 
@@ -634,31 +486,6 @@ EDITOR_TEMPLATE = '''
             setupUIListeners();
             animate();
         }
-        
-        function initModels() {
-            const gltfLoader = new GLTFLoader();
-            gltfLoader.load(MODEL_ASSET_BASE + 'tree.glb', (gltf) => {
-                const model = gltf.scene;
-                model.traverse(node => {
-                    if (node.isMesh) {
-                        node.castShadow = true;
-                        node.receiveShadow = true;
-                    }
-                });
-                models['tree'] = model;
-            });
-            gltfLoader.load(MODEL_ASSET_BASE + 'rock.glb', (gltf) => {
-                const model = gltf.scene;
-                model.traverse(node => {
-                    if (node.isMesh) {
-                        node.castShadow = true;
-                         node.receiveShadow = true;
-                    }
-                });
-                models['rock'] = model;
-            });
-        }
-
 
         function initPostprocessing() {
             composer = new EffectComposer(renderer);
@@ -671,7 +498,7 @@ EDITOR_TEMPLATE = '''
             ssaoPass.maxDistance = 0.1;
             composer.addPass(ssaoPass);
 
-            const bloomPass = new UnrealBloomPass(new THREE.Vector2(window.innerWidth, window.innerHeight), 0.4, 0.4, 0.85);
+            const bloomPass = new UnrealBloomPass(new THREE.Vector2(window.innerWidth, window.innerHeight), 0.5, 0.4, 0.85);
             composer.addPass(bloomPass);
         }
 
@@ -681,7 +508,7 @@ EDITOR_TEMPLATE = '''
                 grassInstances.geometry.dispose();
                 grassMaterial.dispose();
             }
-            const grassTexture = textureLoader.load(TEXTURE_ASSET_BASE + 'foliage/grass.png');
+            const grassTexture = textureLoader.load('https://threejs.org/examples/textures/sprites/grass.png');
             grassMaterial = new THREE.ShaderMaterial({
                 uniforms: {
                     time: { value: 0 },
@@ -766,32 +593,18 @@ EDITOR_TEMPLATE = '''
             document.getElementById('brush-strength').addEventListener('input', (e) => {
                 document.getElementById('brush-strength-value').textContent = e.target.value;
             });
-            document.getElementById('snow-height').addEventListener('input', e => {
-                 document.getElementById('snow-height-value').textContent = e.target.value;
-            });
-            document.getElementById('rock-slope').addEventListener('input', e => {
-                 document.getElementById('rock-slope-value').textContent = e.target.value;
-            });
-            document.getElementById('apply-auto-texture').addEventListener('click', applyAutoTexturing);
             document.getElementById('project-list').addEventListener('change', (e) => {
                 document.getElementById('project-name').value = e.target.value;
             });
             document.getElementById('burger-menu').addEventListener('click', () => {
                 document.getElementById('ui-panel').classList.toggle('open');
             });
-            document.getElementById('clear-foliage').addEventListener('click', () => {
-                if (confirm('Вы уверены, что хотите удалить всю растительность?')) {
+            document.getElementById('clear-objects').addEventListener('click', () => {
+                if (confirm('Вы уверены, что хотите удалить все объекты?')) {
                     grassInstances.count = 0;
                     grassInstances.instanceMatrix.needsUpdate = true;
                 }
             });
-            document.getElementById('clear-placed-objects').addEventListener('click', () => {
-                if (confirm('Вы уверены, что хотите удалить все размещенные объекты?')) {
-                    while (placedObjectsGroup.children.length > 0) {
-                        placedObjectsGroup.remove(placedObjectsGroup.children[0]);
-                    }
-                }
-            });
             document.getElementById('play-mode-toggle').addEventListener('click', togglePlayMode);
             document.getElementById('update-texture-btn').addEventListener('click', updateCustomTexture);
             document.getElementById('rename-texture-slot-btn').addEventListener('click', renameTextureSlot);
@@ -808,7 +621,7 @@ EDITOR_TEMPLATE = '''
             const textureSlot = document.getElementById('texture-slot-select').value;
             
             if (fileInput.files.length === 0) {
-                alert('Пожалуйста, выберите файл изображения. Обновятся все PBR карты, если найдутся файлы с именами color, normal, roughness, ao.');
+                alert('Пожалуйста, выберите файл изображения.');
                 return;
             }
             
@@ -817,13 +630,11 @@ EDITOR_TEMPLATE = '''
             
             reader.onload = (event) => {
                 const dataUrl = event.target.result;
-                const newTexture = textureLoader.load(dataUrl);
-                newTexture.wrapS = THREE.RepeatWrapping;
-                newTexture.wrapT = THREE.RepeatWrapping;
-                newTexture.anisotropy = 16;
-                newTexture.colorSpace = THREE.SRGBColorSpace;
+                customTextures[textureSlot] = dataUrl;
+                
+                const newTexture = loadTexture(dataUrl);
+                const uniformName = textureSlot + 'Texture';
                 
-                const uniformName = textureSlot + '_map';
                 if (terrainMaterial.uniforms[uniformName]) {
                     if (terrainMaterial.uniforms[uniformName].value) {
                         terrainMaterial.uniforms[uniformName].value.dispose();
@@ -875,6 +686,7 @@ EDITOR_TEMPLATE = '''
             });
         }
 
+
         function togglePlayMode() {
             isPlayMode = !isPlayMode;
             const toggleButton = document.getElementById('play-mode-toggle');
@@ -918,9 +730,6 @@ EDITOR_TEMPLATE = '''
                 terrainMesh.geometry.dispose();
             }
             initFoliage();
-            while (placedObjectsGroup.children.length > 0) {
-                placedObjectsGroup.remove(placedObjectsGroup.children[0]);
-            }
 
             terrainDimensions.width = width;
             terrainDimensions.height = height;
@@ -954,17 +763,19 @@ EDITOR_TEMPLATE = '''
                     }
                     grassInstances.instanceMatrix.needsUpdate = true;
                 }
-                 if(terrainData.placedObjects) {
-                    terrainData.placedObjects.forEach(objData => {
-                        const model = models[objData.type];
-                        if (model) {
-                            const newObj = model.clone();
-                            newObj.position.copy(objData.position);
-                            newObj.quaternion.copy(objData.quaternion);
-                            newObj.scale.copy(objData.scale);
-                            placedObjectsGroup.add(newObj);
+                if (terrainData.customTextures) {
+                    customTextures = terrainData.customTextures;
+                    Object.entries(customTextures).forEach(([slot, dataUrl]) => {
+                        const newTexture = loadTexture(dataUrl);
+                        const uniformName = slot + 'Texture';
+                        if (terrainMaterial.uniforms[uniformName]) {
+                             if (terrainMaterial.uniforms[uniformName].value) {
+                                terrainMaterial.uniforms[uniformName].value.dispose();
+                            }
+                            terrainMaterial.uniforms[uniformName].value = newTexture;
                         }
                     });
+                    terrainMaterial.needsUpdate = true;
                 }
                 updateTextureUIAfterLoad(terrainData);
             }
@@ -1057,11 +868,7 @@ EDITOR_TEMPLATE = '''
                 case 'roughen': roughenTerrain(intersection.point); break;
                 case 'smooth': smoothTerrain(intersection.point); break;
                 case 'flatten': flattenTerrain(intersection.point); break;
-                case 'erode': erodeTerrain(intersection.point); break;
-                case 'terrace': terraceTerrain(intersection.point); break;
-                case 'pinch': pinchTerrain(intersection.point); break;
                 case 'paint': paintTexture(intersection.point); break;
-                case 'foliage': placeFoliage(intersection); break;
                 case 'place': placeObject(intersection); break;
             }
         }
@@ -1166,91 +973,6 @@ EDITOR_TEMPLATE = '''
             terrainMesh.geometry.computeVertexNormals();
             terrainMesh.geometry.computeTangents();
         }
-
-        function erodeTerrain(center) {
-            const positions = terrainMesh.geometry.attributes.position;
-            const brushSize = parseFloat(document.getElementById('brush-size').value);
-            const brushStrength = parseFloat(document.getElementById('brush-strength').value) * 0.05;
-            const vertex = new THREE.Vector3();
-
-            for (let i = 0; i < positions.count; i++) {
-                vertex.fromBufferAttribute(positions, i);
-                const distance = vertex.distanceTo(center);
-                if (distance < brushSize) {
-                    const falloff = Math.pow(1 - (distance / brushSize), 2);
-                    const currentY = positions.getY(i);
-                    
-                    let neighborHeightSum = 0;
-                    let neighborCount = 0;
-                    
-                    if (i > terrainDimensions.segmentsX + 1) { 
-                        neighborHeightSum += positions.getY(i - terrainDimensions.segmentsX - 1); neighborCount++;
-                    }
-                    if (i < positions.count - terrainDimensions.segmentsX - 1) { 
-                        neighborHeightSum += positions.getY(i + terrainDimensions.segmentsX + 1); neighborCount++;
-                    }
-                    if (i % (terrainDimensions.segmentsX + 1) !== 0) { 
-                         neighborHeightSum += positions.getY(i - 1); neighborCount++;
-                    }
-                     if (i % (terrainDimensions.segmentsX + 1) !== terrainDimensions.segmentsX) { 
-                         neighborHeightSum += positions.getY(i + 1); neighborCount++;
-                    }
-
-                    if(neighborCount > 0) {
-                        const avgNeighborHeight = neighborHeightSum / neighborCount;
-                        if(currentY > avgNeighborHeight) {
-                            positions.setY(i, THREE.MathUtils.lerp(currentY, avgNeighborHeight, falloff * brushStrength));
-                        }
-                    }
-                }
-            }
-            positions.needsUpdate = true;
-            terrainMesh.geometry.computeVertexNormals();
-            terrainMesh.geometry.computeTangents();
-        }
-
-        function terraceTerrain(center) {
-            const positions = terrainMesh.geometry.attributes.position;
-            const brushSize = parseFloat(document.getElementById('brush-size').value);
-            const brushStrength = parseFloat(document.getElementById('brush-strength').value);
-            const vertex = new THREE.Vector3();
-
-            for (let i = 0; i < positions.count; i++) {
-                vertex.fromBufferAttribute(positions, i);
-                const distance = vertex.distanceTo(center);
-                if (distance < brushSize) {
-                    const falloff = Math.pow(1 - (distance / brushSize), 2);
-                    const currentY = positions.getY(i);
-                    const steppedY = Math.round(currentY / brushStrength) * brushStrength;
-                    const newY = THREE.MathUtils.lerp(currentY, steppedY, falloff * 0.5);
-                    positions.setY(i, newY);
-                }
-            }
-            positions.needsUpdate = true;
-            terrainMesh.geometry.computeVertexNormals();
-            terrainMesh.geometry.computeTangents();
-        }
-
-        function pinchTerrain(center) {
-            const positions = terrainMesh.geometry.attributes.position;
-            const brushSize = parseFloat(document.getElementById('brush-size').value);
-            const brushStrength = parseFloat(document.getElementById('brush-strength').value);
-            const vertex = new THREE.Vector3();
-
-            for (let i = 0; i < positions.count; i++) {
-                vertex.fromBufferAttribute(positions, i);
-                const distance = vertex.distanceTo(center);
-                if (distance < brushSize) {
-                    const falloff = Math.pow(1 - (distance / brushSize), 4);
-                    let currentY = positions.getY(i);
-                    let newY = currentY + falloff * brushStrength * 2;
-                    positions.setY(i, newY);
-                }
-            }
-            positions.needsUpdate = true;
-            terrainMesh.geometry.computeVertexNormals();
-            terrainMesh.geometry.computeTangents();
-        }
         
         function paintTexture(center) {
             const colors = terrainMesh.geometry.attributes.color;
@@ -1294,7 +1016,7 @@ EDITOR_TEMPLATE = '''
             colors.needsUpdate = true;
         }
 
-        function placeFoliage(intersection) {
+        function placeObject(intersection) {
             const brushSize = parseFloat(document.getElementById('brush-size').value);
             const density = parseFloat(document.getElementById('brush-strength').value) * 2;
             const dummy = new THREE.Object3D();
@@ -1330,54 +1052,6 @@ EDITOR_TEMPLATE = '''
              grassInstances.instanceMatrix.needsUpdate = true;
         }
 
-        function placeObject(intersection) {
-            const density = parseFloat(document.getElementById('brush-strength').value) * 0.2;
-            if(Math.random() > density) return;
-
-            const objectType = document.getElementById('object-select').value;
-            const model = models[objectType];
-            if (!model) return;
-
-            const newObject = model.clone();
-            newObject.position.copy(intersection.point);
-            newObject.rotation.y = Math.random() * Math.PI * 2;
-            const scale = Math.random() * 0.5 + 0.75;
-            newObject.scale.set(scale, scale, scale);
-
-            placedObjectsGroup.add(newObject);
-        }
-
-        function applyAutoTexturing() {
-            if (!terrainMesh) return;
-            showSpinner(true);
-            
-            setTimeout(() => {
-                const snowHeight = parseFloat(document.getElementById('snow-height').value);
-                const rockSlopeThreshold = 1.0 - parseFloat(document.getElementById('rock-slope').value);
-                
-                const positions = terrainMesh.geometry.attributes.position;
-                const normals = terrainMesh.geometry.attributes.normal;
-                const colors = terrainMesh.geometry.attributes.color;
-
-                for (let i = 0; i < positions.count; i++) {
-                    const yPos = positions.getY(i);
-                    const yNorm = normals.getY(i);
-
-                    let rock = 0, dirt = 0, snow = 0, sand = 0;
-
-                    if (yPos > snowHeight) {
-                        snow = 1.0;
-                    } else if (yNorm < rockSlopeThreshold) {
-                        rock = 1.0;
-                    }
-                    colors.setXYZW(i, rock, dirt, snow, sand);
-                }
-                colors.needsUpdate = true;
-                showSpinner(false);
-                alert('Авто-текстурирование применено.');
-            }, 50);
-        }
-
         async function saveProject() {
             const projectName = document.getElementById('project-name').value.trim();
             if (!projectName) { alert("Пожалуйста, введите имя проекта."); return; }
@@ -1399,16 +1073,6 @@ EDITOR_TEMPLATE = '''
                 textureNames[slotValue] = name;
             });
             
-            const serializedObjects = placedObjectsGroup.children.map(obj => {
-                const modelName = Object.keys(models).find(key => obj.uuid.startsWith(models[key].uuid));
-                 return {
-                    type: modelName || 'rock',
-                    position: obj.position,
-                    quaternion: obj.quaternion,
-                    scale: obj.scale
-                }
-            });
-            
             const projectData = {
                 name: projectName,
                 width: terrainDimensions.width,
@@ -1418,7 +1082,7 @@ EDITOR_TEMPLATE = '''
                 foliage: {
                     grass: grassMatrices
                 },
-                placedObjects: serializedObjects,
+                customTextures: customTextures,
                 textureNames: textureNames
             };
             
@@ -1513,6 +1177,7 @@ EDITOR_TEMPLATE = '''
             camera.position.copy(player.position);
         }
 
+
         function animate() {
             requestAnimationFrame(animate);
             const deltaTime = clock.getDelta();