entangled-worlds-orbiters-shared 1.0.4 → 1.0.6

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.4",
+  "version": "1.0.6",
   "description": "Shared library for entangled worlds orbiters - contains core world rendering, moons system, and UI components",
   "type": "module",
   "main": "src/index.js",

package/src/moons/moonsGeneration.js

@@ -1,10 +1,10 @@
 import * as THREE from 'three';
 import { loadTexture } from '../loaders/bodyTextureLoader.js';
-import { getPublicBase } from '../config/env.js';
+import { resolvePublicUrl } from '../config/env.js';
 
-// Resolve public herbarium base (strip trailing slash)
-const HERBARIUM_BASE = getPublicBase();
-function moonTexPath(file) { return `${HERBARIUM_BASE}/default/textures/moons/${file}`; }
+function moonTexPath(file) {
+  return resolvePublicUrl(`default/textures/moons/${file}`);
+}
 export const DEFAULT_MOON_TEX_KTX2 = moonTexPath('moon-equirectangular.ktx2');
 export const DEFAULT_MOON_TEX_PNG = moonTexPath('moon-equirectangular.png');
 
@@ -90,16 +90,9 @@ export async function generateMoons({
     try { sharedTexture = await buildUvGridTexture(); usedUvGrid = true; } catch(_) {}
   } else if (useTexture) {
     // Use textureKey if provided, otherwise fall back to default textures
-    let primaryTexture = textureKey || textureKTX2;
+    let primaryTexture = textureKey ? resolvePublicUrl(textureKey) : textureKTX2;
     const fallbackTexture = texturePNG;
     
-    // Resolve textureKey to absolute URL if it's relative
-    if (textureKey && textureKey.startsWith('/')) {
-      primaryTexture = `${HERBARIUM_BASE}${textureKey}`;
-    } else if (textureKey) {
-      primaryTexture = textureKey; // already absolute
-    }
-    
     try {
       sharedTexture = await loadTexture(primaryTexture);
     } catch (eKTX) {

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