entangled-worlds-orbiters-shared 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "entangled-worlds-orbiters-shared",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "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

@@ -1,38 +1,41 @@
 /**
  * Texture Configuration Loader
- * Loads texture definitions from local config file or remote endpoint
+ * Loads texture definitions from remote endpoint or uses passed config
  */
 import { resolvePublicUrl } from './env.js';
 
-const DEFAULT_CONFIG_URL = '/config/textures.json';
-const FALLBACK_CONFIG_URL = 'https://api.entangled-worlds.com/config/textures.json'; // Future endpoint
-
 let cachedConfig = null;
 let configPromise = null;
+let lastConfigUrl = null;
 
 /**
- * Load texture configuration from local file or remote endpoint
- * @param {string} configUrl - Override default config URL
+ * Load texture configuration from remote endpoint or use passed config
+ * @param {string} configUrl - Override config URL
  * @param {boolean} useCache - Whether to use cached config if available
  * @returns {Promise<Object>} Texture configuration object
  */
-export async function loadTextureConfig(configUrl = DEFAULT_CONFIG_URL, useCache = true) {
+export async function loadTextureConfig(configUrl = null, useCache = true) {
   if (useCache && cachedConfig) {
-    console.log('[TextureConfig] Using cached config');
     return cachedConfig;
   }
 
   if (configPromise) {
-    console.log('[TextureConfig] Using in-flight request');
     return configPromise;
   }
 
+  if (configUrl) {
+    lastConfigUrl = configUrl;
+  }
+
+  const targetUrl = configUrl || lastConfigUrl;
+
   configPromise = (async () => {
     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 (!targetUrl) {
+        throw new Error('No texture config URL provided');
+      }
+
+      const response = await fetch(targetUrl);
       
       if (!response.ok) {
         throw new Error(`HTTP ${response.status}: ${response.statusText}`);
@@ -46,29 +49,13 @@ 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) {
-          console.error('[TextureConfig] Fallback also failed:', fallbackError);
-        }
-      }
-
-      // Return minimal fallback configuration
+      // Return minimal fallback configuration when loading fails
       console.warn('[TextureConfig] Using hardcoded fallback config');
-      return getHardcodedFallback();
+      cachedConfig = getHardcodedFallback();
+      return cachedConfig;
     } finally {
       configPromise = null;
     }
@@ -277,10 +264,10 @@ function getHardcodedFallback() {
  * @param {string} configUrl - Override config URL
  * @returns {Promise<Object>} Fresh configuration object
  */
-export async function reloadTextureConfig(configUrl = DEFAULT_CONFIG_URL) {
+export async function reloadTextureConfig(configUrl = null) {
   cachedConfig = null;
   configPromise = null;
-  return loadTextureConfig(configUrl, false);
+  return loadTextureConfig(configUrl || lastConfigUrl, false);
 }
 
 /**

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/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) {