zakeke-configurator-react 0.0.50 → 0.0.51

package/dist/declarations/composer/Module/src/environment.d.ts

@@ -125,6 +125,7 @@ export declare class ZakekeEnvironment {
     setItemColor: (guid: string, color: string) => void;
     setItemFontFamily: (guid: string, fontFamily: string) => Promise<void>;
     createImage: (file: File, progress?: ((percentage: number) => void) | undefined) => Promise<Image>;
+    createImageFromUrl: (url: string) => Promise<Image>;
     addItemImage: (id: number, areaId: number) => Promise<void>;
     setItemImageFromFile: (guid: string, file: File, progress?: ((percentage: number) => void) | undefined) => Promise<void>;
     setItemImageFromBase64: (guid: string, base64: any) => Promise<void>;

package/dist/declarations/composer/Module/src/state/providerValue.d.ts

@@ -41,6 +41,7 @@ export interface ProviderValue {
     setItemImageFromFile: (guid: string, file: File) => Promise<void>;
     addItemImage: (id: number, areaId: number) => Promise<void>;
     createImage: (file: File, progress?: (percentage: number) => void) => Promise<Image>;
+    createImageFromUrl: (url: string) => Promise<Image>;
     setItemImage: (guid: string, imageId: number) => Promise<void>;
     setItemFontFamily: (guid: string, fontFamily: string) => void;
     setItemColor: (guid: string, color: string) => void;

package/dist/index.js

@@ -6526,6 +6526,7 @@ var EnvironmentManager = /** @class */ (function () {
     };
     EnvironmentManager.prototype.update = function () {
         this.configureScene();
+        this.configureCamera();
         this.configureSkybox();
     };
     EnvironmentManager.prototype.configureSkybox = function () {
@@ -7556,6 +7557,11 @@ var MakeIncremental = /** @class */ (function () {
                     meshOrGeometry.hasColors = true;
                     meshOrGeometry.colors = null;
                 }
+                // Added tangents
+                if (meshOrGeometry.tangents) {
+                    meshOrGeometry.hasTangents = true;
+                    meshOrGeometry.tangents = null;
+                }
                 if (meshOrGeometry.matricesIndices) {
                     meshOrGeometry.hasMatricesIndices = true;
                     meshOrGeometry.matricesIndices = null;
@@ -7581,7 +7587,7 @@ var MakeIncremental = /** @class */ (function () {
         // e se la geometria ha un solo canale per le texture
         //var dracoEncode = dracoOptions.useDraco && !isMesh && !meshOrGeometry.uv2s && !(meshOrGeometry.matricesIndices || meshOrGeometry.matricesWeights);
         var dracoEncode = dracoOptions.useDraco && !isMesh &&
-            !(meshOrGeometry.matricesIndices || meshOrGeometry.matricesWeights) &&
+            !(meshOrGeometry.matricesIndices || meshOrGeometry.matricesWeights || meshOrGeometry.tangents) &&
             meshOrGeometry.indices.length > 0 &&
             meshOrGeometry.positions.length > 0 &&
             meshOrGeometry.normals.length > 0;
@@ -7610,6 +7616,9 @@ var MakeIncremental = /** @class */ (function () {
         if (meshOrGeometry.colors) {
             result.colors = meshOrGeometry.colors;
         }
+        if (meshOrGeometry.tangents) {
+            result.tangents = meshOrGeometry.tangents;
+        }
         if (meshOrGeometry.matricesIndices) {
             result.matricesIndices = meshOrGeometry.matricesIndices;
         }
@@ -12164,7 +12173,7 @@ var SceneHelper = /** @class */ (function () {
     };
     SceneHelper.prototype.takeContentScreenshotAsync = function (width, height) {
         return __awaiter(this, void 0, void 0, function () {
-            var oldClearColor, size, data;
+            var oldClearColor, size, promise, data;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -12174,7 +12183,10 @@ var SceneHelper = /** @class */ (function () {
                         this._scene.clearColor = new BABYLON.Color4(0, 0, 0, 0);
                         this._scene.render(); // Forzo il ridisegno
                         size = { width: width, height: height };
-                        return [4 /*yield*/, BABYLON.Tools.CreateScreenshotAsync(this._engine, this._camera, size, "image/png")];
+                        promise = BABYLON.Tools.CreateScreenshotAsync(this._engine, this._camera, size, "image/png");
+                        this._scene.render(); // Forzo il ridisegno
+                        this._scene.getEngine().endFrame();
+                        return [4 /*yield*/, promise];
                     case 1:
                         data = _a.sent();
                         this._scene.clearColor = oldClearColor;
@@ -14385,6 +14397,84 @@ var SceneHelper = /** @class */ (function () {
             });
         });
     };
+    SceneHelper.prototype.reloadAllLoadingErrorTexturesAsync = function (rootUrl) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, _a, texture;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _i = 0, _a = this._scene.textures;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        texture = _a[_i];
+                        return [4 /*yield*/, this.reloadLoadingErrorTextureAsync(rootUrl, texture)];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SceneHelper.prototype.reloadMaterialLoadingErrorTexturesAsync = function (rootUrl, material) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, _a, texture;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _i = 0, _a = material.getActiveTextures();
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        texture = _a[_i];
+                        return [4 /*yield*/, this.reloadLoadingErrorTextureAsync(rootUrl, texture)];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SceneHelper.prototype.reloadLoadingErrorTextureAsync = function (rootUrl, texture) {
+        if (texture instanceof BABYLON.Texture && texture.url) {
+            var internalTexture = texture.getInternalTexture();
+            if (texture.loadingError || (internalTexture && internalTexture.loadingError)) {
+                var originalUrl_1 = texture.url;
+                var isAbsolute = /^(?:\/|[a-z]+:\/\/)/.test(texture.url);
+                var absoluteUrl = texture.url;
+                if (!isAbsolute)
+                    absoluteUrl = rootUrl + texture.url;
+                return new Promise(function (resolve, reject) {
+                    texture.updateURL(absoluteUrl, null, function () {
+                        texture.url = originalUrl_1;
+                        resolve();
+                    }, function () {
+                        texture.url = originalUrl_1;
+                        reject();
+                    });
+                });
+            }
+        }
+        return Promise.resolve();
+    };
+    SceneHelper.prototype.isTextureLoadingError = function (texture) {
+        if (texture.loadingError)
+            return true;
+        var internalTexture = texture.getInternalTexture();
+        return internalTexture !== null && internalTexture.loadingError;
+    };
+    SceneHelper.prototype.materialHasLoadingErrorTextues = function (material) {
+        var _this = this;
+        return material.getActiveTextures().some(function (t) { return _this.isTextureLoadingError(t); });
+    };
     return SceneHelper;
 }());
 
@@ -24999,7 +25089,7 @@ var SceneViewer = /** @class */ (function () {
     // textureUrl = rootUrl + texture.name
     SceneViewer.prototype.loadSceneFromRemoteFilesAsync = function (rootUrl, sceneFileName, onProgress) {
         return __awaiter(this, void 0, void 0, function () {
-            var newScene_1, requireDelayLoading, i, texture, skyboxTexture;
+            var newScene_1, requireDelayLoading, i, texture, e_1, skyboxTexture;
             var _this_1 = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -25008,7 +25098,7 @@ var SceneViewer = /** @class */ (function () {
                             throw new Error("Unable to load scene when the 3D engine is null");
                         _a.label = 1;
                     case 1:
-                        _a.trys.push([1, , 11, 12]);
+                        _a.trys.push([1, , 14, 15]);
                         this.preSceneFileLoading();
                         this.pauseRendering();
                         // Per problema useDelayedTextureLoading
@@ -25053,7 +25143,7 @@ var SceneViewer = /** @class */ (function () {
                         return [4 /*yield*/, this.setupSceneAsync()];
                     case 5:
                         _a.sent();
-                        if (!this._sceneHelper) return [3 /*break*/, 8];
+                        if (!this._sceneHelper) return [3 /*break*/, 11];
                         if (!(this._configPreview && this._scene.metadata && this._scene.metadata.delayedMaterials)) return [3 /*break*/, 7];
                         return [4 /*yield*/, this._sceneHelper.loadAllDelayedMaterialsAsync(rootUrl)];
                     case 6:
@@ -25071,19 +25161,29 @@ var SceneViewer = /** @class */ (function () {
                         this._sceneHelper.setupShaderMaterialsCameraPosition();
                         _a.label = 8;
                     case 8:
-                        if (!this._environmentManager) return [3 /*break*/, 10];
-                        skyboxTexture = this._environmentManager.getSkyboxTexture();
-                        if (!skyboxTexture) return [3 /*break*/, 10];
-                        return [4 /*yield*/, _Components_SceneHelper__WEBPACK_IMPORTED_MODULE_1__["SceneHelper"].whenTextureIsReadyAsync(skyboxTexture)];
+                        _a.trys.push([8, 10, , 11]);
+                        return [4 /*yield*/, this.reloadAllLoadingErrorTexturesAsync()];
                     case 9:
                         _a.sent();
-                        _a.label = 10;
-                    case 10: return [3 /*break*/, 12];
+                        return [3 /*break*/, 11];
+                    case 10:
+                        e_1 = _a.sent();
+                        console.error(e_1);
+                        return [3 /*break*/, 11];
                     case 11:
+                        if (!this._environmentManager) return [3 /*break*/, 13];
+                        skyboxTexture = this._environmentManager.getSkyboxTexture();
+                        if (!skyboxTexture) return [3 /*break*/, 13];
+                        return [4 /*yield*/, _Components_SceneHelper__WEBPACK_IMPORTED_MODULE_1__["SceneHelper"].whenTextureIsReadyAsync(skyboxTexture)];
+                    case 12:
+                        _a.sent();
+                        _a.label = 13;
+                    case 13: return [3 /*break*/, 15];
+                    case 14:
                         this.resumeRendering();
                         this.postSceneFileLoading();
                         return [7 /*endfinally*/];
-                    case 12: return [2 /*return*/];
+                    case 15: return [2 /*return*/];
                 }
             });
         });
@@ -26548,6 +26648,71 @@ var SceneViewer = /** @class */ (function () {
             this.setRenderingNeeded();
         }
     };
+    // try to reload all textures with loading errors
+    SceneViewer.prototype.reloadAllLoadingErrorTexturesAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var rootUrl;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this._zkScene && this._sceneHelper)) return [3 /*break*/, 2];
+                        rootUrl = this._zkScene.get("rootUrl");
+                        if (!rootUrl) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this._sceneHelper.reloadAllLoadingErrorTexturesAsync(rootUrl)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // try to reload the material textures with loading errors
+    SceneViewer.prototype.reloadMaterialLoadingErrorTexturesAsync = function (material) {
+        return __awaiter(this, void 0, void 0, function () {
+            var rootUrl;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this._zkScene && this._sceneHelper)) return [3 /*break*/, 2];
+                        rootUrl = this._zkScene.get("rootUrl");
+                        if (!rootUrl) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this._sceneHelper.reloadMaterialLoadingErrorTexturesAsync(rootUrl, material)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // try to reload the texture having loading errors
+    SceneViewer.prototype.reloadLoadingErrorTextureAsync = function (texture) {
+        return __awaiter(this, void 0, void 0, function () {
+            var rootUrl;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this._zkScene && this._sceneHelper)) return [3 /*break*/, 2];
+                        rootUrl = this._zkScene.get("rootUrl");
+                        if (!rootUrl) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this._sceneHelper.reloadLoadingErrorTextureAsync(rootUrl, texture)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    // were there any loading errors for the texture?
+    SceneViewer.prototype.isTextureLoadingError = function (texture) {
+        return this._sceneHelper ? this._sceneHelper.isTextureLoadingError(texture) : false;
+    };
+    // the material has some texture with loading errors
+    SceneViewer.prototype.materialHasLoadingErrorTextues = function (material) {
+        return this._sceneHelper ? this._sceneHelper.materialHasLoadingErrorTextues(material) : false;
+    };
     return SceneViewer;
 }());
 
@@ -42051,6 +42216,22 @@ var ZakekeEnvironment = /** @class */ (function () {
                 }
             });
         }); };
+        this.createImageFromUrl = function (url) { return __awaiter(_this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.viewer) return [3 /*break*/, 2];
+                        return [4 /*yield*/, _api__WEBPACK_IMPORTED_MODULE_6__["axiosApi"].post(Zakeke.config.baseApiUrl + "images/import/url", {
+                                url: url
+                            })];
+                    case 1:
+                        result = (_a.sent()).data;
+                        return [2 /*return*/, result];
+                    case 2: throw "Called create image from url but no viewer or viewer not ready";
+                }
+            });
+        }); };
         this.addItemImage = function (id, areaId) { return __awaiter(_this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -44014,6 +44195,7 @@ var createProviderValue = function (state, dispatch) {
             return [2 /*return*/, dispatch({ type: 'ADD_ITEM_IMAGE', imageId: imageId, areaId: areaId })];
         }); }); },
         createImage: state.environment.createImage.bind(state.environment),
+        createImageFromUrl: state.environment.createImageFromUrl.bind(state.environment),
         setItemImage: function (guid, imageId) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
             return [2 /*return*/, dispatch({ type: 'SET_ITEM_IMAGE', guid: guid, imageId: imageId })];
         }); }); },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zakeke-configurator-react",
-  "version": "0.0.50",
+  "version": "0.0.51",
   "main": "dist/index.js",
   "module": "dist/index.js",
   "types": "dist/declarations/composer/Module/src/index.d.ts",