Update app.py

app.py

@@ -129,7 +129,7 @@ EDITOR_TEMPLATE = '''
         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 {
@@ -253,16 +253,16 @@ 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>
-                <p style="font-size:0.8em; color: #aaa;">Для PBR (Normal, Roughness и т.д.) требуется изменение кода.</p>
                 <label for="texture-slot-name">Новое имя для слота:</label>
                 <input type="text" id="texture-slot-name" placeholder="например, Лава">
                 <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>
@@ -272,6 +272,7 @@ EDITOR_TEMPLATE = '''
             </div>
              <div class="ui-group">
                 <h3>Растительность</h3>
+                <p style="font-size:0.8em; color: #aaa;">Режим "Растительность" в кистях.</p>
                 <button id="clear-foliage" class="danger-button">Очистить растительность</button>
             </div>
         </div>
@@ -306,6 +307,7 @@ EDITOR_TEMPLATE = '''
         import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
         import { PointerLockControls } from 'three/addons/controls/PointerLockControls.js';
         import { Sky } from 'three/addons/objects/Sky.js';
+        import { RGBELoader } from 'three/addons/loaders/RGBELoader.js';
         import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js';
         import { RenderPass } from 'three/addons/postprocessing/RenderPass.js';
         import { SSAOPass } from 'three/addons/postprocessing/SSAOPass.js';
@@ -347,227 +349,176 @@ EDITOR_TEMPLATE = '''
             return tex;
         };
         
+        const textureBaseUrl = 'https://cdn.jsdelivr.net/gh/pmndrs/drei-assets@master/textures/pbr/';
         const textures = {
             grass: {
-                map: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/grasslight-big.jpg'),
-                normal: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/grasslight-big-nm.jpg'),
-                roughness: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/roughness_map.jpg'),
-                ao: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/grasslight-big-ao.jpg'),
+                map: loadTexture(textureBaseUrl + 'grass/color.jpg'),
+                normalMap: loadTexture(textureBaseUrl + 'grass/normal.jpg'),
+                roughnessMap: loadTexture(textureBaseUrl + 'grass/roughness.jpg'),
+                aoMap: loadTexture(textureBaseUrl + 'grass/ao.jpg'),
             },
             rock: {
-                map: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/rock.jpg'),
-                normal: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/rock-nm.jpg'),
-                roughness: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/rock-roughness.jpg'),
-                ao: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/rock-ao.jpg'),
+                map: loadTexture(textureBaseUrl + 'rock_02/color.jpg'),
+                normalMap: loadTexture(textureBaseUrl + 'rock_02/normal.jpg'),
+                roughnessMap: loadTexture(textureBaseUrl + 'rock_02/roughness.jpg'),
+                aoMap: loadTexture(textureBaseUrl + 'rock_02/ao.jpg'),
             },
             dirt: {
-                map: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/sand-512.jpg'),
-                normal: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/water/Water_1_M_Normal.jpg'),
-                roughness: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/rock-roughness.jpg'),
-                ao: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/rock-ao.jpg'),
+                map: loadTexture(textureBaseUrl + 'dirt_path/color.jpg'),
+                normalMap: loadTexture(textureBaseUrl + 'dirt_path/normal.jpg'),
+                roughnessMap: loadTexture(textureBaseUrl + 'dirt_path/roughness.jpg'),
+                aoMap: loadTexture(textureBaseUrl + 'dirt_path/ao.jpg'),
             },
             snow: {
-                map: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/snow.jpg'),
-                normal: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/water/Water_1_M_Normal.jpg'),
-                roughness: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/roughness_map.jpg'),
-                ao: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/rock-ao.jpg'),
+                map: loadTexture(textureBaseUrl + 'snow_02/color.jpg'),
+                normalMap: loadTexture(textureBaseUrl + 'snow_02/normal.jpg'),
+                roughnessMap: loadTexture(textureBaseUrl + 'snow_02/roughness.jpg'),
+                aoMap: loadTexture(textureBaseUrl + 'snow_02/ao.jpg'),
             },
-             sand: {
-                map: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/sand-512.jpg'),
-                normal: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/water/Water_1_M_Normal.jpg'),
-                roughness: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/rock-roughness.jpg'),
-                ao: loadTexture('https://cdn.jsdelivr.net/gh/mrdoob/three.js/examples/textures/terrain/rock-ao.jpg'),
+            sand: {
+                map: loadTexture(textureBaseUrl + 'sand_01/color.jpg'),
+                normalMap: loadTexture(textureBaseUrl + 'sand_01/normal.jpg'),
+                roughnessMap: loadTexture(textureBaseUrl + 'sand_01/roughness.jpg'),
+                aoMap: loadTexture(textureBaseUrl + 'sand_01/ao.jpg'),
             }
         };
         
         const terrainMaterial = new THREE.ShaderMaterial({
             uniforms: {
-                textureScale: { value: 30.0 },
-                blendSharpness: { value: 1.5 },
-                
                 grassMap: { value: textures.grass.map },
-                grassNormalMap: { value: textures.grass.normal },
-                grassRoughnessMap: { value: textures.grass.roughness },
-                grassAOMap: { value: textures.grass.ao },
-                
+                grassNormalMap: { value: textures.grass.normalMap },
+                grassRoughnessMap: { value: textures.grass.roughnessMap },
+                grassAoMap: { value: textures.grass.aoMap },
+
                 rockMap: { value: textures.rock.map },
-                rockNormalMap: { value: textures.rock.normal },
-                rockRoughnessMap: { value: textures.rock.roughness },
-                rockAOMap: { value: textures.rock.ao },
+                rockNormalMap: { value: textures.rock.normalMap },
+                rockRoughnessMap: { value: textures.rock.roughnessMap },
+                rockAoMap: { value: textures.rock.aoMap },
 
                 dirtMap: { value: textures.dirt.map },
-                dirtNormalMap: { value: textures.dirt.normal },
-                dirtRoughnessMap: { value: textures.dirt.roughness },
-                dirtAOMap: { value: textures.dirt.ao },
+                dirtNormalMap: { value: textures.dirt.normalMap },
+                dirtRoughnessMap: { value: textures.dirt.roughnessMap },
+                dirtAoMap: { value: textures.dirt.aoMap },
 
                 snowMap: { value: textures.snow.map },
-                snowNormalMap: { value: textures.snow.normal },
-                snowRoughnessMap: { value: textures.snow.roughness },
-                snowAOMap: { value: textures.snow.ao },
+                snowNormalMap: { value: textures.snow.normalMap },
+                snowRoughnessMap: { value: textures.snow.roughnessMap },
+                snowAoMap: { value: textures.snow.aoMap },
 
                 sandMap: { value: textures.sand.map },
-                sandNormalMap: { value: textures.sand.normal },
-                sandRoughnessMap: { value: textures.sand.roughness },
-                sandAOMap: { value: textures.sand.ao },
+                sandNormalMap: { value: textures.sand.normalMap },
+                sandRoughnessMap: { value: textures.sand.roughnessMap },
+                sandAoMap: { value: textures.sand.aoMap },
 
-                sunDirection: { value: new THREE.Vector3() },
-                ambientLightColor: { value: new THREE.Color() }
+                lightDirection: { value: new THREE.Vector3(0.5, 0.5, 0.5).normalize() }
             },
             vertexShader: `
                 varying vec2 vUv;
                 varying vec3 vNormal;
                 varying vec3 vViewPosition;
                 attribute vec4 color;
-                varying vec4 vSplat;
+                varying vec4 vColor;
                 attribute vec4 tangent;
-                varying mat3 vTBN;
+                varying vec3 vTangent;
+                varying vec3 vBitangent;
 
                 void main() {
                     vUv = uv;
-                    vSplat = color;
+                    vColor = color;
                     vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
                     vViewPosition = -mvPosition.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: `
-                uniform float textureScale;
-                uniform float blendSharpness;
-                
-                uniform sampler2D grassMap, grassNormalMap, grassRoughnessMap, grassAOMap;
-                uniform sampler2D rockMap, rockNormalMap, rockRoughnessMap, rockAOMap;
-                uniform sampler2D dirtMap, dirtNormalMap, dirtRoughnessMap, dirtAOMap;
-                uniform sampler2D snowMap, snowNormalMap, snowRoughnessMap, snowAOMap;
-                uniform sampler2D sandMap, sandNormalMap, sandRoughnessMap, sandAOMap;
+                uniform sampler2D grassMap;
+                uniform sampler2D grassNormalMap;
+                uniform sampler2D grassRoughnessMap;
+                uniform sampler2D grassAoMap;
                 
-                uniform vec3 sunDirection;
-                uniform vec3 ambientLightColor;
-
-                varying vec2 vUv;
-                varying vec4 vSplat;
-                varying vec3 vNormal;
-                varying vec3 vViewPosition;
-                varying mat3 vTBN;
-
-                const float M_PI = 3.141592653589793;
+                uniform sampler2D rockMap;
+                uniform sampler2D rockNormalMap;
+                uniform sampler2D rockRoughnessMap;
+                uniform sampler2D rockAoMap;
 
-                float blend_overlay(float base, float blend) {
-                    return base < 0.5 ? (2.0 * base * blend) : (1.0 - 2.0 * (1.0 - base) * (1.0 - blend));
-                }
-
-                vec3 blend_height(vec3 tex1, vec3 tex2, float blend_factor, float h1, float h2) {
-                    float blend = pow(smoothstep(0.0, 1.0, blend_factor), blendSharpness);
-                    float h_blend = clamp((blend + h1 - h2) * blend, 0.0, 1.0);
-                    return mix(tex1, tex2, h_blend);
-                }
+                uniform sampler2D dirtMap;
+                uniform sampler2D dirtNormalMap;
+                uniform sampler2D dirtRoughnessMap;
+                uniform sampler2D dirtAoMap;
 
-                vec3 getNormalFromMap(sampler2D normalMap, vec2 uv) {
-                    vec3 normal = texture(normalMap, uv).rgb * 2.0 - 1.0;
-                    return normalize(vTBN * normal);
-                }
+                uniform sampler2D snowMap;
+                uniform sampler2D snowNormalMap;
+                uniform sampler2D snowRoughnessMap;
+                uniform sampler2D snowAoMap;
 
-                float D_GGX(float dotNH, float roughness) {
-                    float a = roughness * roughness;
-                    float a2 = a * a;
-                    float NdotH = max(dotNH, 0.0);
-                    float NdotH2 = NdotH * NdotH;
-                    float nom = a2;
-                    float den = (NdotH2 * (a2 - 1.0) + 1.0);
-                    den = M_PI * den * den;
-                    return nom / den;
-                }
+                uniform sampler2D sandMap;
+                uniform sampler2D sandNormalMap;
+                uniform sampler2D sandRoughnessMap;
+                uniform sampler2D sandAoMap;
 
-                float G_Smith(float dotNV, float dotNL, float roughness) {
-                    float r = (roughness + 1.0);
-                    float k = (r * r) / 8.0;
-                    float ggx2 = dotNV / (dotNV * (1.0 - k) + k);
-                    float ggx1 = dotNL / (dotNL * (1.0 - k) + k);
-                    return ggx1 * ggx2;
-                }
+                uniform vec3 lightDirection;
 
-                vec3 F_Schlick(float cosTheta, vec3 F0) {
-                    return F0 + (1.0 - F0) * pow(clamp(1.0 - cosTheta, 0.0, 1.0), 5.0);
-                }
+                varying vec2 vUv;
+                varying vec4 vColor;
+                varying vec3 vNormal;
+                varying vec3 vViewPosition;
+                varying vec3 vTangent;
+                varying vec3 vBitangent;
 
                 void main() {
-                    vec2 uv = vUv * textureScale;
-
-                    float grass_h = texture(grassMap, uv).r;
-                    float rock_h = texture(rockMap, uv).r;
-                    float dirt_h = texture(dirtMap, uv).r;
-                    float snow_h = texture(snowMap, uv).r;
-                    float sand_h = texture(sandMap, uv).r;
-
-                    vec3 grass_col = texture(grassMap, uv).rgb;
-                    vec3 rock_col = texture(rockMap, uv).rgb;
-                    vec3 dirt_col = texture(dirtMap, uv).rgb;
-                    vec3 snow_col = texture(snowMap, uv).rgb;
-                    vec3 sand_col = texture(sandMap, uv).rgb;
-
-                    vec3 albedo = grass_col;
-                    albedo = blend_height(albedo, rock_col, vSplat.r, grass_h, rock_h);
-                    albedo = blend_height(albedo, dirt_col, vSplat.g, grass_h, dirt_h);
-                    albedo = blend_height(albedo, snow_col, vSplat.b, grass_h, snow_h);
-                    albedo = blend_height(albedo, sand_col, vSplat.a, grass_h, sand_h);
+                    float TILING = 30.0;
+                    vec2 uv_scaled = vUv * TILING;
                     
-                    float totalSplat = max(0.001, vSplat.r + vSplat.g + vSplat.b + vSplat.a);
-                    vec4 mixFactors = vSplat / totalSplat;
-                    mixFactors.x = 1.0 - mixFactors.y - mixFactors.z - mixFactors.w;
-
-                    vec3 normal = mix(getNormalFromMap(grassNormalMap, uv), getNormalFromMap(rockNormalMap, uv), mixFactors.r);
-                    normal = mix(normal, getNormalFromMap(dirtNormalMap, uv), mixFactors.g);
-                    normal = mix(normal, getNormalFromMap(snowNormalMap, uv), mixFactors.b);
-                    normal = mix(normal, getNormalFromMap(sandNormalMap, uv), mixFactors.a);
+                    vec3 grassAlbedo = texture2D(grassMap, uv_scaled).rgb;
+                    vec3 rockAlbedo = texture2D(rockMap, uv_scaled).rgb;
+                    vec3 dirtAlbedo = texture2D(dirtMap, uv_scaled).rgb;
+                    vec3 snowAlbedo = texture2D(snowMap, uv_scaled).rgb;
+                    vec3 sandAlbedo = texture2D(sandMap, uv_scaled).rgb;
+
+                    float grassRoughness = texture2D(grassRoughnessMap, uv_scaled).r;
+                    float rockRoughness = texture2D(rockRoughnessMap, uv_scaled).r;
+                    float dirtRoughness = texture2D(dirtRoughnessMap, uv_scaled).r;
+                    float snowRoughness = texture2D(snowRoughnessMap, uv_scaled).r;
+                    float sandRoughness = texture2D(sandRoughnessMap, uv_scaled).r;
+
+                    float grassAO = texture2D(grassAoMap, uv_scaled).r;
+                    float rockAO = texture2D(rockAoMap, uv_scaled).r;
+                    float dirtAO = texture2D(dirtAoMap, uv_scaled).r;
+                    float snowAO = texture2D(snowAoMap, uv_scaled).r;
+                    float sandAO = texture2D(sandAoMap, uv_scaled).r;
+
+                    vec3 grassNormal = texture2D(grassNormalMap, uv_scaled).xyz * 2.0 - 1.0;
+                    vec3 rockNormal = texture2D(rockNormalMap, uv_scaled).xyz * 2.0 - 1.0;
+                    vec3 dirtNormal = texture2D(dirtNormalMap, uv_scaled).xyz * 2.0 - 1.0;
+                    vec3 snowNormal = texture2D(snowNormalMap, uv_scaled).xyz * 2.0 - 1.0;
+                    vec3 sandNormal = texture2D(sandNormalMap, uv_scaled).xyz * 2.0 - 1.0;
+
+                    vec3 blendedAlbedo = grassAlbedo;
+                    blendedAlbedo = mix(blendedAlbedo, rockAlbedo, vColor.r);
+                    blendedAlbedo = mix(blendedAlbedo, dirtAlbedo, vColor.g);
+                    blendedAlbedo = mix(blendedAlbedo, snowAlbedo, vColor.b);
+                    blendedAlbedo = mix(blendedAlbedo, sandAlbedo, vColor.a);
                     
-                    float roughness = mix(texture(grassRoughnessMap, uv).g, texture(rockRoughnessMap, uv).g, mixFactors.r);
-                    roughness = mix(roughness, texture(dirtRoughnessMap, uv).g, mixFactors.g);
-                    roughness = mix(roughness, texture(snowRoughnessMap, uv).g, mixFactors.b);
-                    roughness = mix(roughness, texture(sandRoughnessMap, uv).g, mixFactors.a);
-
-                    float ao = mix(texture(grassAOMap, uv).r, texture(rockAOMap, uv).r, mixFactors.r);
-                    ao = mix(ao, texture(dirtAOMap, uv).r, mixFactors.g);
-                    ao = mix(ao, texture(snowAOMap, uv).r, mixFactors.b);
-                    ao = mix(ao, texture(sandAOMap, uv).r, mixFactors.a);
+                    float blendedAO = grassAO;
+                    blendedAO = mix(blendedAO, rockAO, vColor.r);
+                    blendedAO = mix(blendedAO, dirtAO, vColor.g);
+                    blendedAO = mix(blendedAO, snowAO, vColor.b);
+                    blendedAO = mix(blendedAO, sandAO, vColor.a);
                     
-                    vec3 N = normalize(normal);
-                    vec3 V = normalize(vViewPosition);
-                    vec3 L = normalize(sunDirection);
-                    vec3 H = normalize(V + L);
-
-                    float dotNL = max(dot(N, L), 0.0);
-                    float dotNH = max(dot(N, H), 0.0);
-                    float dotVH = max(dot(V, H), 0.0);
+                    vec3 blendedNormal = grassNormal;
+                    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 F0 = vec3(0.04);
-                    float metallic = 0.0;
-                    
-                    float NDF = D_GGX(dotNH, roughness);
-                    float G = G_Smith(dot(N, V), dot(N, L), roughness);
-                    vec3 F = F_Schlick(dotVH, F0);
-                    
-                    vec3 kS = F;
-                    vec3 kD = vec3(1.0) - kS;
-                    kD *= 1.0 - metallic;
-                    
-                    vec3 numerator = NDF * G * F;
-                    float denominator = 4.0 * max(dot(N, V), 0.0) * max(dot(N, L), 0.0) + 0.0001;
-                    vec3 specular = numerator / denominator;
-                    
-                    vec3 Lo = (kD * albedo / M_PI + specular) * dotNL;
-                    
-                    vec3 ambient = ambientLightColor * albedo * ao;
-                    vec3 finalColor = ambient + Lo;
-
-                    finalColor = finalColor / (finalColor + vec3(1.0));
-                    finalColor = pow(finalColor, vec3(1.0/2.2));
+                    mat3 tbn = mat3(vTangent, vBitangent, vNormal);
+                    vec3 normal = normalize(tbn * blendedNormal);
 
-                    gl_FragColor = vec4(finalColor, 1.0);
+                    float lighting = dot(normal, lightDirection) * 0.6 + 0.4;
+                    gl_FragColor = vec4(blendedAlbedo * lighting * blendedAO, 1.0);
                 }
             `
         });
@@ -586,40 +537,40 @@ EDITOR_TEMPLATE = '''
             renderer.toneMapping = THREE.ACESFilmicToneMapping;
             renderer.outputColorSpace = THREE.SRGBColorSpace;
             document.body.appendChild(renderer.domElement);
+            
+            new RGBELoader().load('https://unpkg.com/three@0.160.0/examples/textures/equirectangular/venice_sunset_1k.hdr', function (texture) {
+                texture.mapping = THREE.EquirectangularReflectionMapping;
+                scene.background = texture;
+                scene.environment = texture;
+            });
 
             orbitControls = new OrbitControls(camera, renderer.domElement);
             orbitControls.enableDamping = true;
             orbitControls.maxPolarAngle = Math.PI / 2.1;
 
-            const ambientLight = new THREE.AmbientLight(0xcccccc, 0.2);
-            scene.add(ambientLight);
-            
-            const hemiLight = new THREE.HemisphereLight(0xffffff, 0x444444, 0.5);
-            scene.add(hemiLight);
-            terrainMaterial.uniforms.ambientLightColor.value = new THREE.Color(0xffffff).multiplyScalar(0.2);
-
-            const dirLight = new THREE.DirectionalLight(0xffffff, 1.5);
+            const dirLight = new THREE.DirectionalLight(0xffffff, 2.0);
             dirLight.position.set(100, 100, 50);
             dirLight.castShadow = true;
-            dirLight.shadow.mapSize.width = 2048;
-            dirLight.shadow.mapSize.height = 2048;
+            dirLight.shadow.mapSize.width = 4096;
+            dirLight.shadow.mapSize.height = 4096;
             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,
+                turbidity: 2,
+                rayleigh: 1,
                 mieCoefficient: 0.005,
-                mieDirectionalG: 0.7,
-                elevation: 4,
+                mieDirectionalG: 0.8,
+                elevation: 6,
                 azimuth: 180,
             };
             const uniforms = sky.material.uniforms;
@@ -632,9 +583,6 @@ EDITOR_TEMPLATE = '''
             sun.setFromSphericalCoords( 1, phi, theta );
             uniforms[ 'sunPosition' ].value.copy( sun );
             dirLight.position.copy(sun).multiplyScalar(100);
-            terrainMaterial.uniforms.sunDirection.value = sun;
-
-            scene.fog = new THREE.FogExp2(0x9db2c9, 0.005);
 
             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 });
@@ -661,35 +609,26 @@ EDITOR_TEMPLATE = '''
         }
         
         function initModels() {
-            const treeMaterial = new THREE.MeshStandardMaterial({ color: 0x228B22, roughness: 0.8 });
-            const trunkMaterial = new THREE.MeshStandardMaterial({ color: 0x8B4513, roughness: 0.9 });
-            const rockMaterial = new THREE.MeshStandardMaterial({ color: 0x808080, roughness: 0.6 });
-
+            const treeMaterial = new THREE.MeshStandardMaterial({ color: 0x2C5234, roughness: 0.8 });
+            const trunkMaterial = new THREE.MeshStandardMaterial({ color: 0x5C3D2E, roughness: 0.9 });
+            const rockMaterial = new THREE.MeshStandardMaterial({ color: 0x5E6061, roughness: 0.7 });
+            
+            const treeCrown = new THREE.ConeGeometry(2, 4, 8);
+            treeCrown.translate(0, 3, 0);
+            const treeTrunk = new THREE.CylinderGeometry(0.5, 0.5, 2, 8);
+            const treeCrownMesh = new THREE.Mesh(treeCrown, treeMaterial);
+            const treeTrunkMesh = new THREE.Mesh(treeTrunk, trunkMaterial);
             const treeModel = new THREE.Group();
-            const trunk = new THREE.Mesh(new THREE.CylinderGeometry(0.3, 0.4, 3, 8), trunkMaterial);
-            trunk.position.y = 1.5;
-            treeModel.add(trunk);
-
-            const crownLevels = 3;
-            for(let i=0; i<crownLevels; i++) {
-                const size = 2.0 - i * 0.5;
-                const crown = new THREE.Mesh(new THREE.ConeGeometry(size, 2.5, 8), treeMaterial);
-                crown.position.y = 3 + i * 1.2;
-                treeModel.add(crown);
-            }
-            treeModel.traverse(child => { if(child.isMesh) child.castShadow = true; });
+            treeModel.add(treeCrownMesh);
+            treeModel.add(treeTrunkMesh);
+            treeModel.castShadow = true;
+            treeModel.traverse(node => { if(node.isMesh) node.receiveShadow = true; });
             models['tree'] = treeModel;
 
-            const rockGeom = new THREE.DodecahedronGeometry(1.5, 1);
-            const pos = rockGeom.attributes.position;
-            for(let i=0; i<pos.count; i++){
-                const v = new THREE.Vector3().fromBufferAttribute(pos, i);
-                v.multiplyScalar(0.8 + Math.random() * 0.4);
-                pos.setXYZ(i, v.x, v.y, v.z);
-            }
-            rockGeom.computeVertexNormals();
+            const rockGeom = new THREE.DodecahedronGeometry(1.5, 0);
             const rockModel = new THREE.Mesh(rockGeom, rockMaterial);
             rockModel.castShadow = true;
+            rockModel.receiveShadow = true;
             models['rock'] = rockModel;
         }
 
@@ -704,7 +643,7 @@ EDITOR_TEMPLATE = '''
             ssaoPass.maxDistance = 0.1;
             composer.addPass(ssaoPass);
 
-            const bloomPass = new UnrealBloomPass(new THREE.Vector2(window.innerWidth, window.innerHeight), 0.3, 0.4, 0.85);
+            const bloomPass = new UnrealBloomPass(new THREE.Vector2(window.innerWidth, window.innerHeight), 0.3, 0.4, 0.9);
             composer.addPass(bloomPass);
         }
 
@@ -712,7 +651,7 @@ EDITOR_TEMPLATE = '''
             if (grassInstances) {
                 scene.remove(grassInstances);
                 grassInstances.geometry.dispose();
-                if(grassMaterial) grassMaterial.dispose();
+                grassMaterial.dispose();
             }
             const grassTexture = textureLoader.load('https://threejs.org/examples/textures/sprites/grass.png');
             grassMaterial = new THREE.ShaderMaterial({
@@ -747,7 +686,7 @@ EDITOR_TEMPLATE = '''
                     varying vec2 vUv;
 
                     void main() {
-                        vec4 texColor = texture(map, vUv);
+                        vec4 texColor = texture2D(map, vUv);
                         if (texColor.a < 0.5) discard;
                         gl_FragColor = texColor;
                     }
@@ -760,7 +699,6 @@ EDITOR_TEMPLATE = '''
             grassBlade.translate(0, 0.9, 0);
             grassInstances = new THREE.InstancedMesh(grassBlade, grassMaterial, MAX_GRASS_COUNT);
             grassInstances.castShadow = true;
-            grassInstances.receiveShadow = true;
             grassInstances.count = 0;
             scene.add(grassInstances);
         }
@@ -838,35 +776,7 @@ EDITOR_TEMPLATE = '''
         }
         
         function updateCustomTexture() {
-            const fileInput = document.getElementById('custom-texture-file');
-            const textureSlot = document.getElementById('texture-slot-select').value;
-            
-            if (fileInput.files.length === 0) {
-                alert('Пожалуйста, выберите файл изображения.');
-                return;
-            }
-            
-            const file = fileInput.files[0];
-            const reader = new FileReader();
-            
-            reader.onload = (event) => {
-                const dataUrl = event.target.result;
-                customTextures[textureSlot] = dataUrl;
-                
-                const newTexture = loadTexture(dataUrl);
-                const uniformName = textureSlot + 'Map';
-                
-                if (terrainMaterial.uniforms[uniformName]) {
-                    if (terrainMaterial.uniforms[uniformName].value) {
-                        terrainMaterial.uniforms[uniformName].value.dispose();
-                    }
-                    terrainMaterial.uniforms[uniformName].value = newTexture;
-                    terrainMaterial.needsUpdate = true;
-                    alert(`Текстура для слота "${textureSlot}" успешно обновлена.`);
-                }
-            };
-            
-            reader.readAsDataURL(file);
+            alert("Замена PBR текстур через UI не поддерживается в этой версии.");
         }
 
         function renameTextureSlot() {
@@ -998,20 +908,6 @@ EDITOR_TEMPLATE = '''
                         }
                     });
                 }
-                if (terrainData.customTextures) {
-                    customTextures = terrainData.customTextures;
-                    Object.entries(customTextures).forEach(([slot, dataUrl]) => {
-                        const newTexture = loadTexture(dataUrl);
-                        const uniformName = slot + 'Map';
-                        if (terrainMaterial.uniforms[uniformName]) {
-                             if (terrainMaterial.uniforms[uniformName].value) {
-                                terrainMaterial.uniforms[uniformName].value.dispose();
-                            }
-                            terrainMaterial.uniforms[uniformName].value = newTexture;
-                        }
-                    });
-                    terrainMaterial.needsUpdate = true;
-                }
                 updateTextureUIAfterLoad(terrainData);
             }
             
@@ -1389,7 +1285,7 @@ EDITOR_TEMPLATE = '''
             newObject.rotation.y = Math.random() * Math.PI * 2;
             const scale = Math.random() * 0.5 + 0.75;
             newObject.scale.set(scale, scale, scale);
-
+            newObject.traverse(node => { if(node.isMesh) { node.castShadow = true; node.receiveShadow = true; }});
             placedObjectsGroup.add(newObject);
         }
 
@@ -1411,11 +1307,12 @@ EDITOR_TEMPLATE = '''
 
                     let rock = 0, dirt = 0, snow = 0, sand = 0;
 
-                    if (yPos > snowHeight + (Math.random() - 0.5) * 5) {
+                    if (yPos > snowHeight) {
                         snow = 1.0;
                     } else if (yNorm < rockSlopeThreshold) {
                         rock = 1.0;
-                    } else { }
+                    } else {
+                    }
                     colors.setXYZW(i, rock, dirt, snow, sand);
                 }
                 colors.needsUpdate = true;
@@ -1446,10 +1343,11 @@ EDITOR_TEMPLATE = '''
             });
             
             const serializedObjects = placedObjectsGroup.children.map(obj => {
+                const type = Object.keys(models).find(key => {
+                    return obj.geometry === models[key].geometry || (obj.children.length > 0 && models[key].children.length > 0 && obj.children[0].geometry === models[key].children[0].geometry)
+                });
                 return {
-                    type: Object.keys(models).find(key => {
-                        return obj.children.length > 0 && models[key].children.length > 0 && obj.children[0].geometry === models[key].children[0].geometry
-                    }) || Object.keys(models).find(key => obj.geometry === models[key].geometry),
+                    type: type,
                     position: obj.position,
                     quaternion: obj.quaternion,
                     scale: obj.scale
@@ -1466,7 +1364,6 @@ EDITOR_TEMPLATE = '''
                     grass: grassMatrices
                 },
                 placedObjects: serializedObjects,
-                customTextures: customTextures,
                 textureNames: textureNames
             };