@3driseai/3drise-core 1.0.1

package/dist/utils/shootingStarHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shootingStarHelpers.d.ts","sourceRoot":"","sources":["../../src/utils/shootingStarHelpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAClE,MAAM,WAAW,gBAAgB;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAClB;AAqBD,eAAO,MAAM,oBAAoB,GAAI,IAAI,MAAM,EAAE,UAAU,qBAAqB,KAAG,gBAwBlF,CAAC;AACF,eAAO,MAAM,qBAAqB,GAAI,OAAO,MAAM,EAAE,UAAU,qBAAqB,KAAG,gBAAgB,EAAgF,CAAC"}

package/dist/utils/shootingStarHelpers.js

@@ -0,0 +1,44 @@
+const randomInRange = (min, max) => Math.random() * (max - min) + min;
+const generateRandomPosition = (minRadius = 50, maxRadius = 60) => {
+    const theta = Math.random() * Math.PI * 2;
+    const phi = randomInRange(Math.PI * 0.2, Math.PI * 0.8);
+    const radius = randomInRange(minRadius, maxRadius);
+    return [
+        radius * Math.sin(phi) * Math.cos(theta),
+        radius * Math.cos(phi),
+        radius * Math.sin(phi) * Math.sin(theta),
+    ];
+};
+const generateRandomDirection = () => {
+    const x = randomInRange(-1, 1);
+    const y = randomInRange(-1, -0.3);
+    const z = randomInRange(-0.5, 0.5);
+    const len = Math.sqrt(x * x + y * y + z * z);
+    return [x / len, y / len, z / len];
+};
+export const generateShootingStar = (id, settings) => {
+    if (!settings) {
+        return {
+            id,
+            position: generateRandomPosition(),
+            direction: generateRandomDirection(),
+            speed: 0.08,
+            color: '#ffffff',
+            trailLength: 30,
+            length: 10,
+        };
+    }
+    const { speedRange, lengthRange, trailLengthRange } = settings;
+    return {
+        id,
+        position: generateRandomPosition(),
+        direction: generateRandomDirection(),
+        speed: randomInRange(speedRange[0], speedRange[1]),
+        color: '#ffffff',
+        trailLength: trailLengthRange
+            ? Math.floor(randomInRange(trailLengthRange[0], trailLengthRange[1]))
+            : 30,
+        length: randomInRange(lengthRange[0], lengthRange[1]),
+    };
+};
+export const generateShootingStars = (count, settings) => Array.from({ length: count }, (_, i) => generateShootingStar(i, settings));

package/dist/utils/sunUtils.d.ts

@@ -0,0 +1,6 @@
+export declare function createSunPosition(elevation: number, azimuth: number): {
+    x: number;
+    y: number;
+    z: number;
+};
+//# sourceMappingURL=sunUtils.d.ts.map

package/dist/utils/sunUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sunUtils.d.ts","sourceRoot":"","sources":["../../src/utils/sunUtils.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG;IAC/D,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACb,CAQJ"}

package/dist/utils/sunUtils.js

@@ -0,0 +1,9 @@
+export function createSunPosition(elevation, azimuth) {
+    const phi = (90 - elevation) * (Math.PI / 180);
+    const theta = azimuth * (Math.PI / 180);
+    return {
+        x: Math.sin(phi) * Math.cos(theta),
+        y: Math.cos(phi),
+        z: Math.sin(phi) * Math.sin(theta),
+    };
+}

package/dist/utils/utils.d.ts

@@ -0,0 +1,21 @@
+import type { Object3D } from 'three';
+import type { ModelData } from "../types/mesh";
+import type { CreatedRef } from "../types/scene3d";
+import { EffectState } from "../types";
+export declare const createDefaultEffectState: (object: Object3D) => EffectState;
+export declare const calculateAutoScale: (model: Object3D, maxSize?: number) => number;
+export declare const createModelFromUrl: (model: ModelData) => Promise<CreatedRef | null>;
+export declare const buildQueryString: (params: Record<string, any>) => string;
+export declare const loadModels: (models: ModelData[]) => Promise<CreatedRef[]>;
+export declare const dontAnimate: (key: string) => boolean;
+export declare const loadAssets: (models: ModelData[]) => Promise<CreatedRef[]>;
+export declare const createUniformsText: (uniforms: any[]) => string;
+/**
+ * Compile shaders by prepending uniform declarations to vertex and fragment shader code.
+ * Use this in components via useMemo to derive compiled shaders from raw state.
+ */
+export declare const compileShaders: (uniforms: any[], vertexShader: string, fragmentShader: string) => {
+    vertex: string;
+    fragment: string;
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAGtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEvC,eAAO,MAAM,wBAAwB,GAAI,QAAQ,QAAQ,KAAG,WAY3D,CAAC;AACF,eAAO,MAAM,kBAAkB,GAAI,OAAO,QAAQ,EAAE,UAAS,MAAU,KAAG,MAWzE,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,OAAO,SAAS,KAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CA8BpF,CAAC;AACF,eAAO,MAAM,gBAAgB,GAAI,QAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAG,MAQ9D,CAAC;AACF,eAAO,MAAM,UAAU,GAAU,QAAQ,SAAS,EAAE,KAAG,OAAO,CAAC,UAAU,EAAE,CA0C1E,CAAC;AACF,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,KAAG,OAGzC,CAAC;AACF,eAAO,MAAM,UAAU,GAAU,QAAQ,SAAS,EAAE,KAAG,OAAO,CAAC,UAAU,EAAE,CAqB1E,CAAC;AACF,eAAO,MAAM,kBAAkB,GAAI,UAAU,GAAG,EAAE,KAAG,MAQpD,CAAC;AACF;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU,GAAG,EAAE,EAAE,cAAc,MAAM,EAAE,gBAAgB,MAAM,KAAG;IACvF,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAOxB,CAAC"}

package/dist/utils/utils.js

@@ -0,0 +1,158 @@
+import { Box3, Vector3 } from "three";
+import { loadModelGLTF } from "./loadingManager.js";
+import ObjectManager from "../services/ObjectManager.js";
+export const createDefaultEffectState = (object) => {
+    const material = object.material;
+    const opacity = material && 'opacity' in material ? material.opacity : 1;
+    return {
+        originalPosition: { x: object.position.x, y: object.position.y, z: object.position.z },
+        originalScale: { x: object.scale.x, y: object.scale.y, z: object.scale.z },
+        originalRotation: { x: object.rotation.x, y: object.rotation.y, z: object.rotation.z },
+        originalOpacity: opacity,
+        originalColors: {},
+        time: 0,
+        isTriggered: false,
+    };
+};
+export const calculateAutoScale = (model, maxSize = 5) => {
+    // Create a bounding box for the model
+    const box = new Box3().setFromObject(model);
+    const size = box.getSize(new Vector3());
+    // Find the largest dimension
+    const maxDimension = Math.max(size.x, size.y, size.z);
+    // Calculate scale factor to fit within maxSize
+    const scaleFactor = maxSize / maxDimension;
+    console.log(`Model dimensions: ${size.x.toFixed(2)} x ${size.y.toFixed(2)} x ${size.z.toFixed(2)}`);
+    console.log(`Max dimension: ${maxDimension.toFixed(2)}, Scale factor: ${scaleFactor.toFixed(2)}`);
+    return scaleFactor;
+};
+// Load model from URL
+export const createModelFromUrl = async (model) => {
+    try {
+        console.log(`Loading model from model: `, model);
+        const loadedModel = await loadModelGLTF(model.url);
+        // console.log("Model loaded from URL:", loadedModel);
+        if (loadedModel) {
+            loadedModel.name = model.name || `model_${Date.now()}`;
+            loadedModel.scale.set(...(model.scale || [1, 1, 1]));
+            loadedModel.rotation.set(...(model.rotation || [0, 0, 0]));
+            loadedModel.position.set(...(model.position || [0, 0, 0]));
+            loadedModel.traverse((child) => {
+                if (child.isMesh) {
+                    child.castShadow = model.castShadow !== undefined ? model.castShadow : true;
+                    child.receiveShadow = model.receiveShadow !== undefined ? model.receiveShadow : true;
+                }
+            });
+            const managedModel = {
+                id: model.id || `model_${Date.now()}`,
+                name: loadedModel.name,
+                object: loadedModel,
+            };
+            ObjectManager.addObject(managedModel);
+            return managedModel;
+        }
+    }
+    catch (error) {
+        console.error("Error loading model from URL:", error);
+        return null;
+    }
+    return null;
+};
+export const buildQueryString = (params) => {
+    const searchParams = new URLSearchParams();
+    Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined && value !== null) {
+            searchParams.append(key, value.toString());
+        }
+    });
+    return searchParams.toString();
+};
+export const loadModels = async (models) => {
+    const loadedModels = [];
+    const failedModels = [];
+    for (const model of models) {
+        try {
+            const loadedModel = await createModelFromUrl(model);
+            if (loadedModel) {
+                loadedModels.push(loadedModel);
+            }
+            else {
+                console.warn(`[loadModels] Model returned null:`, {
+                    id: model.id,
+                    name: model.name,
+                    url: model.url
+                });
+                failedModels.push({ model, error: new Error('createModelFromUrl returned null') });
+            }
+        }
+        catch (error) {
+            console.error(`[loadModels] Failed to load model:`, {
+                id: model.id,
+                name: model.name,
+                url: model.url,
+                error: error instanceof Error ? error.message : error
+            });
+            failedModels.push({ model, error });
+        }
+    }
+    // Summary logging
+    if (failedModels.length > 0) {
+        console.warn(`[loadModels] Loading complete. Success: ${loadedModels.length}, Failed: ${failedModels.length}`);
+        console.warn(`[loadModels] Failed models:`, failedModels.map(f => ({
+            id: f.model.id,
+            name: f.model.name,
+            url: f.model.url,
+            error: f.error instanceof Error ? f.error.message : String(f.error)
+        })));
+    }
+    else {
+        console.log(`[loadModels] All ${loadedModels.length} models loaded successfully`);
+    }
+    return loadedModels;
+};
+export const dontAnimate = (key) => {
+    return key.toLowerCase().includes('texture') ||
+        key.toLowerCase().includes('noise');
+};
+export const loadAssets = async (models) => {
+    console.log(`[loadAssets] Starting to load ${models.length} models`);
+    if (models.length === 0) {
+        console.log('[loadAssets] No models to load');
+        return [];
+    }
+    const cleanedModels = models.filter(model => {
+        if (!model.url) {
+            console.warn(`[loadAssets] Skipping model with missing URL:`, { id: model.id, name: model.name });
+            return false;
+        }
+        if (model.url.includes('blob:')) {
+            console.warn(`[loadAssets] Skipping blob URL model:`, { id: model.id, name: model.name });
+            return false;
+        }
+        return true;
+    });
+    console.log(`[loadAssets] Loading ${cleanedModels.length} valid models (filtered ${models.length - cleanedModels.length})`);
+    const createdObjects = await loadModels(cleanedModels);
+    console.log(`[loadAssets] Completed. Loaded ${createdObjects.length}/${cleanedModels.length} models`);
+    return createdObjects;
+};
+export const createUniformsText = (uniforms) => {
+    if (!uniforms || uniforms.length === 0)
+        return '';
+    let uniformText = '';
+    uniforms.forEach((uniform) => {
+        uniformText += `uniform ${uniform.type} ${uniform.name};\n`;
+    });
+    return uniformText;
+};
+/**
+ * Compile shaders by prepending uniform declarations to vertex and fragment shader code.
+ * Use this in components via useMemo to derive compiled shaders from raw state.
+ */
+export const compileShaders = (uniforms, vertexShader, fragmentShader) => {
+    const uniformsText = createUniformsText(uniforms);
+    return {
+        vertex: uniformsText + '\n' + vertexShader,
+        fragment: uniformsText + '\n' + fragmentShader,
+    };
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@3driseai/3drise-core",
+  "version": "1.0.1",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc --build --force && node add-js-extensions.mjs",
+    "dev": "tsc --build --watch",
+    "clean": "rimraf dist",
+    "bump": "npm version patch",
+    "pub": "npm run build && npm publish --access public"
+  },
+  "dependencies": {
+    "@3driseai/3drise-common": "^1.0.1",
+    "@react-three/drei": "^10.7.7",
+    "@react-three/fiber": "^9.6.1",
+    "@react-three/rapier": "^2.2.0",
+    "gsap": "^3.12.0",
+    "lodash": "^4.17.21",
+    "maath": "^0.10.8"
+  },
+  "peerDependencies": {
+    "three": "^0.170"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.0",
+    "@types/react": "^19.0.0",
+    "react": "^19.0.0",
+    "three": "^0.170.0",
+    "typescript": "^5.9.3"
+  }
+}