entangled-worlds-orbiters-shared 1.0.1 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "entangled-worlds-orbiters-shared",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Shared library for entangled worlds orbiters - contains core world rendering, moons system, and UI components",
   "type": "module",
   "main": "src/index.js",

package/src/config/textureConfig.js

@@ -18,12 +18,10 @@ let configPromise = null;
  */
 export async function loadTextureConfig(configUrl = DEFAULT_CONFIG_URL, useCache = true) {
   if (useCache && cachedConfig) {
-    console.log('[TextureConfig] Using cached config');
     return cachedConfig;
   }
 
   if (configPromise) {
-    console.log('[TextureConfig] Using in-flight request');
     return configPromise;
   }
 
@@ -31,7 +29,6 @@ export async function loadTextureConfig(configUrl = DEFAULT_CONFIG_URL, useCache
     try {
       // Resolve config URL against public base if it's a relative path
       const resolvedConfigUrl = /^https?:\/\//i.test(configUrl) ? configUrl : resolvePublicUrl(configUrl);
-      console.log('[TextureConfig] Loading from:', resolvedConfigUrl);
       const response = await fetch(resolvedConfigUrl);
       
       if (!response.ok) {
@@ -46,19 +43,12 @@ export async function loadTextureConfig(configUrl = DEFAULT_CONFIG_URL, useCache
       }
 
       cachedConfig = config;
-      console.log('[TextureConfig] Loaded successfully:', {
-        version: config.version,
-        categories: Object.keys(config.textures),
-        lastUpdated: config.lastUpdated
-      });
-
       return config;
     } catch (error) {
       console.error('[TextureConfig] Failed to load config:', error);
       
       // If primary URL fails and it's not already the fallback, try fallback
       if (configUrl !== FALLBACK_CONFIG_URL) {
-        console.log('[TextureConfig] Trying fallback endpoint...');
         try {
           return await loadTextureConfig(FALLBACK_CONFIG_URL, false);
         } catch (fallbackError) {

package/src/loaders/glbLoader.js

@@ -51,7 +51,6 @@ export async function loadGLB(url, { retries = 3, signal, onProgress, applyFlags
             child.material.emissive.setHex(0x888888);
             child.material.emissiveMap = child.material.map;
             child.material.emissiveIntensity = 1.0;
-            console.log('✅ KTX2 texture loaded:', child.material.map.constructor.name, `${child.material.map.image.width}x${child.material.map.image.height}`);
           }
           child.material.needsUpdate = true;
           child.castShadow = false;

package/src/moons/moonsGeneration.js

@@ -64,16 +64,6 @@ export async function generateMoons({
     return Math.random(); // Use regular random if no seed
   };
 
-  // Log the seed being used for debugging
-  if (debug) {
-    console.log('[Moons] Using seed for deterministic positioning:', {
-      originalSeed: seed,
-      seedValue: seedValue,
-      seedType: typeof seed,
-      isSeeded: seedValue !== null
-    });
-  }
-
   const moonGeometry = new THREE.SphereGeometry(0.1, geometryWidthSegments, geometryHeightSegments);
 
   // Optional UV grid override
@@ -106,20 +96,16 @@ export async function generateMoons({
     // Resolve textureKey to absolute URL if it's relative
     if (textureKey && textureKey.startsWith('/')) {
       primaryTexture = `${HERBARIUM_BASE}${textureKey}`;
-      if (debug) console.log('[Moons] Using custom texture key:', textureKey, '-> resolved:', primaryTexture);
     } else if (textureKey) {
       primaryTexture = textureKey; // already absolute
-      if (debug) console.log('[Moons] Using absolute texture URL:', primaryTexture);
     }
     
     try {
       sharedTexture = await loadTexture(primaryTexture);
-      if (debug) console.log('[Moons] Loaded texture from:', primaryTexture);
     } catch (eKTX) {
       if (debug) console.warn('[Moons] Primary texture failed, trying fallback:', eKTX);
       try {
         sharedTexture = await loadTexture(fallbackTexture);
-        if (debug) console.log('[Moons] Fallback texture loaded from:', fallbackTexture);
       } catch (ePNG) {
         if (debug) console.warn('[Moons] Both primary and fallback texture loading failed');
       }

package/src/world/worldManager.js

@@ -16,13 +16,11 @@ export class WorldManager {
   }
 
   setFlags(flags) {
-    console.log('[WorldManager] setFlags:', flags);
     this.flags = { ...this.flags, ...flags };
   }
 
   disposeCurrent() {
     if (this.current) {
-      console.log('[WorldManager] disposeCurrent:', this.current?.name || this.current);
       disposeObject3D(this.current);
       this.scene.remove(this.current);
       this.current = null;
@@ -36,39 +34,31 @@ export class WorldManager {
 
   async setMode(mode, args = {}) {
     const myToken = ++this.token;
-    console.log('[WorldManager] setMode request:', { mode, args });
     this.onLoadStart?.();
     try {
       let obj;
       
       // Check for custom creators first
       if (this.customCreators.has(mode)) {
-        console.log(`[WorldManager] -> custom creator for mode ${mode}`);
         obj = await this.customCreators.get(mode)({ flags: this.flags, ...args });
       } else if (mode === 2) {
-        console.log('[WorldManager] -> makeGLB');
         obj = await makeGLB({ modelUrl: args.modelUrl, flags: this.flags });
       } else if (mode === 3) {
-        console.log('[WorldManager] -> makeNormalSphere');
         obj = await makeNormalSphere({ flags: this.flags, ...args });
       } else {
-        console.log('[WorldManager] -> makeSphere (textured)');
         obj = await makeSphere({ textureUrl: args.textureUrl, flags: this.flags, ...args });
       }
 
       if (this.token !== myToken) {
-        console.log('[WorldManager] setMode superseded, abandoning result');
         return;
       }
       this.disposeCurrent();
       this.scene.add(obj);
       this.current = obj;
-      console.log('[WorldManager] setMode applied. current:', obj?.name || obj);
 
       // If the object exposes a frame updater, run a render-time loop
       if (obj && obj.userData && typeof obj.userData.update === 'function' && window.__EW_RENDERER) {
         const updater = obj.userData.update;
-        console.log('[WorldManager] update loop started for', obj.name || obj);
         const tick = () => {
           if (this.current === obj) {
             try {
@@ -77,8 +67,6 @@ export class WorldManager {
               console.warn('[WorldManager] update loop error:', e);
             }
             requestAnimationFrame(tick);
-          } else {
-            console.log('[WorldManager] update loop stopped (object replaced)');
           }
         };
         requestAnimationFrame(tick);

package/src/world/worldNormal.js

@@ -2,6 +2,9 @@
 import * as THREE from 'three';
 import { EARTH_RADIUS_UNITS } from './worldTexture.js';
 import { applyFlagsToMaterial } from '../utils/materials.js';
+import { getLightFresnel } from '../core/lightFresnel.js';
+import { createCloudShell } from './cloudShell.js';
+import { resolvePublicUrl } from '../config/env.js';
 
 /**
  * Create a simple sphere using THREE.MeshNormalMaterial.
@@ -12,6 +15,18 @@ export async function makeNormalSphere({
   sphereWidthSegments,
   sphereHeightSegments,
   flags,
+  glow,           // halo (glow) enabled
+  glowScale = 1.18,
+  glowRimHex = 0x66ccff,
+  glowFacingHex = 0x000000,
+  glowBias = 0.02,
+  glowFresnelScale = 1.0,
+  glowPower = 3.5,
+  cloudsEnabled,
+  cloudsTextureUrl = '/assets/texture/2k_earth_clouds.jpg',
+  cloudsColor = 0xffffff,
+  cloudsOpacity = 0.6,
+  cloudsSpeed = 0.015,
 } = {}) {
   const radius = typeof sphereRadius === 'number' ? Math.max(0.0001, sphereRadius) : EARTH_RADIUS_UNITS;
   const widthSegs = Number.isFinite(sphereWidthSegments) ? Math.max(3, Math.floor(sphereWidthSegments)) : 64;
@@ -21,5 +36,36 @@ export async function makeNormalSphere({
   if (flags) applyFlagsToMaterial(material, flags);
   const mesh = new THREE.Mesh(geometry, material);
   mesh.name = 'worldNormalSphere';
+
+  // Attach halo (glow) effect if enabled
+  if (glow) {
+    const fresnelMat = getLightFresnel({ rimHex: glowRimHex, facingHex: glowFacingHex });
+    fresnelMat.uniforms.fresnelBias.value = glowBias;
+    fresnelMat.uniforms.fresnelScale.value = glowFresnelScale;
+    fresnelMat.uniforms.fresnelPower.value = glowPower;
+
+    const glowGeom = geometry.clone();
+    const fresnelMesh = new THREE.Mesh(glowGeom, fresnelMat);
+    fresnelMesh.scale.set(glowScale, glowScale, glowScale);
+    fresnelMesh.renderOrder = 999;
+    fresnelMesh.name = 'worldNormalGlow';
+    mesh.add(fresnelMesh);
+  }
+
+  // Attach clouds effect if enabled
+  if (cloudsEnabled) {
+    const cloudMesh = await createCloudShell({
+      baseGeometry: geometry,
+      baseRadius: radius,
+      widthSegments: widthSegs,
+      heightSegments: heightSegs,
+      textureUrl: resolvePublicUrl(cloudsTextureUrl),
+      color: cloudsColor,
+      opacity: cloudsOpacity,
+      speed: cloudsSpeed,
+    });
+    mesh.add(cloudMesh);
+  }
+
   return mesh;
 }

package/src/world/worldTexture.js

@@ -109,10 +109,15 @@ export async function makeSphere({
     try {
       const tex = await loadTexture(chosenTexture);
       tex.colorSpace = THREE.SRGBColorSpace;
-      tex.generateMipmaps = true;
       tex.anisotropy = 8;
       if (typeof flipY === 'boolean') tex.flipY = flipY;
 
+      // Only enable mipmaps for non-compressed, power-of-two textures
+      const isCompressed = tex.isCompressedTexture;
+      const img = tex.image;
+      const isPowerOfTwo = img && ((img.width & (img.width - 1)) === 0) && ((img.height & (img.height - 1)) === 0);
+      tex.generateMipmaps = !isCompressed && isPowerOfTwo;
+
       // Decide mapping approach
       let shouldMirrorDuplicate = mirrorDuplicateX;
       if (tex.image) {