entangled-worlds-orbiters-shared 1.0.3 → 1.0.5

package/README.md

@@ -16,6 +16,16 @@ A shared library containing core components for 3D world rendering, moons system
 ```bash
 npm install entangled-worlds-orbiters-shared
 ```
+## Test locally 
+
+In /entangled-worlds-orbiters-shared:
+npm install 
+npm link
+
+In /entangled-worlds-preview or /orbiters:
+
+npm link entangled-worlds-orbiters-shared
+
 
 ## Usage
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "entangled-worlds-orbiters-shared",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "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,22 +1,20 @@
 /**
  * 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) {
     return cachedConfig;
   }
@@ -25,11 +23,19 @@ export async function loadTextureConfig(configUrl = DEFAULT_CONFIG_URL, useCache
     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);
-      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,19 +52,10 @@ export async function loadTextureConfig(configUrl = DEFAULT_CONFIG_URL, useCache
       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) {
-        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;
     }
@@ -267,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/world/worldTexture.js

@@ -5,6 +5,25 @@ import { getLightFresnel } from '../core/lightFresnel.js';
 import { createCloudShell } from './cloudShell.js';
 import { resolvePublicUrl } from '../config/env.js';
 
+// Debug tag so you can verify the loaded file version in console
+export const WORLD_TEXTURE_DEBUG_TAG = 'WT:vFlipGeom-r3@2025-10-28T17:22:00Z';
+
+// Enable debug if query/localStorage says so; expose tag
+if (typeof window !== 'undefined') {
+  const q = (window.location && window.location.search) || '';
+  const qsDebug = /(?:[?&])debugTextures=1(?:&|$)/.test(q);
+  const lsDebug = (window.localStorage && window.localStorage.DEBUG_TEXTURE_FLIP === '1') || false;
+  if (!window.DEBUG_TEXTURE_FLIP && (qsDebug || lsDebug)) {
+    window.DEBUG_TEXTURE_FLIP = true;
+  }
+  window.EW_WT_DEBUG_TAG = WORLD_TEXTURE_DEBUG_TAG;
+  if (window.DEBUG_TEXTURE_FLIP) {
+    console.info('[worldTexture] loaded', WORLD_TEXTURE_DEBUG_TAG);
+  }
+}
+
+let WT_LOGGED_FIRST_CALL = false;
+
 export const EARTH_RADIUS_UNITS = 0.5; // scene units
 
 /**
@@ -75,6 +94,7 @@ export async function makeSphere({
   const widthSegs = Number.isFinite(sphereWidthSegments) ? Math.max(3, Math.floor(sphereWidthSegments)) : 64;
   const heightSegs = Number.isFinite(sphereHeightSegments) ? Math.max(2, Math.floor(sphereHeightSegments)) : 64;
   const geometry = new THREE.SphereGeometry(radius, widthSegs, heightSegs);
+  let meshGeometry = geometry; // may clone/flip UVs for compressed textures
 
   const rough = (typeof materialRoughness === 'number') ? THREE.MathUtils.clamp(materialRoughness, 0, 1) : 0.7;
   const metal = (typeof materialMetalness === 'number') ? THREE.MathUtils.clamp(materialMetalness, 0, 1) : 0.0;
@@ -86,6 +106,48 @@ export async function makeSphere({
     mirror: THREE.MirroredRepeatWrapping,
   };
 
+  // For compressed textures (e.g., KTX2) WebGL cannot apply UNPACK_FLIP_Y at upload.
+  // To normalize orientation across loaders, emulate vertical flip in UV sampling:
+  // v' = 1 - v  => repeat.y = -repeat.y, offset.y = 1 - offset.y
+  const normalizeCompressedFlip = (t) => {
+    if (!t || !t.isCompressedTexture) return;
+    const wantFlip = (typeof flipY === 'boolean') ? flipY : true; // match uncompressed default
+    if (!wantFlip) return;
+    const rY = (t.repeat && typeof t.repeat.y === 'number') ? t.repeat.y : 1;
+    const oY = (t.offset && typeof t.offset.y === 'number') ? t.offset.y : 0;
+    t.repeat.y = -rY;
+    t.offset.y = 1 - oY;
+    t.needsUpdate = true;
+  };
+
+  // Emulate vertical flip for compressed textures (e.g., KTX2) using UV transform
+  const normalizeCompressedFlipY = (t, desired) => {
+    if (!t || !t.isCompressedTexture) return;
+    const wantFlip = (typeof desired === 'boolean') ? desired : true; // default to match uncompressed loader
+    const rY = t.repeat?.y ?? 1;
+    const oY = t.offset?.y ?? 0;
+    if (wantFlip) {
+      t.repeat.y = -Math.abs(rY);
+      t.offset.y = 1 - oY;
+    } else {
+      t.repeat.y = Math.abs(rY);
+      t.offset.y = 0;
+    }
+    t.needsUpdate = true;
+  };
+
+  // Flip UV.y on a cloned geometry (keeps other layers safe)
+  const flipGeometryUVY = (geom) => {
+    if (!geom || !geom.attributes || !geom.attributes.uv) return 0;
+    const uv = geom.attributes.uv;
+    const arr = uv.array;
+    for (let i = 1; i < arr.length; i += 2) {
+      arr[i] = 1 - arr[i]; // v = 1 - v
+    }
+    uv.needsUpdate = true;
+    return uv.count;
+  };
+
   // Attach a Fresnel glow mesh as a child of the sphere mesh
   function createGlow(rimHex, facingHex) {
     const fresnelMat = getLightFresnel({ rimHex, facingHex });
@@ -153,6 +215,11 @@ export async function makeSphere({
       const applyWrapOptions = (t) => {
         t.wrapS = WRAP[wrapS] ?? THREE.RepeatWrapping;
         t.wrapT = WRAP[wrapT] ?? THREE.ClampToEdgeWrapping;
+        // Compressed textures + NPOT prefer clamp to avoid artifacts
+        if (isCompressed) {
+          t.wrapS = THREE.ClampToEdgeWrapping;
+          t.wrapT = THREE.ClampToEdgeWrapping;
+        }
         if (Array.isArray(center) && center.length === 2) t.center.set(center[0], center[1]);
         if (typeof rotationDeg === 'number') t.rotation = (rotationDeg * Math.PI) / 180;
         if (typeof repeatX === 'number' || typeof repeatY === 'number') {
@@ -201,12 +268,23 @@ export async function makeSphere({
           tex.wrapT = WRAP[wrapT] ?? THREE.ClampToEdgeWrapping;
           tex.repeat.x = Math.max(2, typeof repeatX === 'number' ? repeatX : 2);
           applyWrapOptions(tex);
+          // If compressed (e.g., KTX2), normalize vertical orientation using sampling transform
+          normalizeCompressedFlip(tex);
           material.map = tex;
           material.needsUpdate = true;
         }
       } else {
-        // Equirectangular or no canvas: just use original texture without any edge processing
+        // Equirectangular or no canvas: just use original texture
         applyWrapOptions(tex);
+        const wantFlip = (typeof flipY === 'boolean') ? flipY : true;
+        if (isCompressed && wantFlip) {
+          meshGeometry = geometry.clone();
+          flipGeometryUVY(meshGeometry);
+        } else if (isCompressed) {
+          tex.repeat.y = Math.abs(tex.repeat?.y ?? 1);
+          tex.offset.y = 0;
+          tex.needsUpdate = true;
+        }
         material.map = tex;
         material.needsUpdate = true;
       }
@@ -216,7 +294,7 @@ export async function makeSphere({
   }
 
   if (flags) applyFlagsToMaterial(material, flags);
-  const mesh = new THREE.Mesh(geometry, material);
+  const mesh = new THREE.Mesh(meshGeometry, material);
   mesh.position.set(0, 0, 0);
 
   // NEW: add cloud shell before glow