@dcl/playground-assets 7.1.2-4415683908.commit-0a210fd → 7.1.2-4426178080.commit-9504360

package/dist/index.js

@@ -12939,6 +12939,38 @@
     /** @public */  const UiTransform$1 = engine => engine.defineComponentFromSchema("core::UiTransform", UiTransformSchema);
     /** @public */  const VideoPlayer$1 = engine => engine.defineComponentFromSchema("core::VideoPlayer", VideoPlayerSchema);
     /** @public */  const VisibilityComponent$1 = engine => engine.defineComponentFromSchema("core::VisibilityComponent", VisibilityComponentSchema);
+    /** public */ 
+    const componentDefinitionByName = {
+        "core::Animator": Animator$2,
+        "core::AudioSource": AudioSource$1,
+        "core::AudioStream": AudioStream$1,
+        "core::AvatarAttach": AvatarAttach$1,
+        "core::AvatarModifierArea": AvatarModifierArea$1,
+        "core::AvatarShape": AvatarShape$1,
+        "core::Billboard": Billboard$1,
+        "core::CameraMode": CameraMode$1,
+        "core::CameraModeArea": CameraModeArea$1,
+        "core::GltfContainer": GltfContainer$1,
+        "core::Material": Material$2,
+        "core::MeshCollider": MeshCollider$2,
+        "core::MeshRenderer": MeshRenderer$2,
+        "core::NftShape": NftShape$1,
+        "core::PointerEvents": PointerEvents$1,
+        "core::PointerEventsResult": PointerEventsResult$1,
+        "core::PointerLock": PointerLock$1,
+        "core::Raycast": Raycast$1,
+        "core::RaycastResult": RaycastResult$1,
+        "core::TextShape": TextShape$1,
+        "core::UiBackground": UiBackground$1,
+        "core::UiDropdown": UiDropdown$1,
+        "core::UiDropdownResult": UiDropdownResult$1,
+        "core::UiInput": UiInput$1,
+        "core::UiInputResult": UiInputResult$1,
+        "core::UiText": UiText$1,
+        "core::UiTransform": UiTransform$1,
+        "core::VideoPlayer": VideoPlayer$1,
+        "core::VisibilityComponent": VisibilityComponent$1,
+    };
 
     function defineAnimatorComponent(engine) {
         const theComponent = Animator$2(engine);
@@ -13322,7 +13354,8 @@
         get YGOverflow () { return exports.YGOverflow; },
         get YGPositionType () { return exports.YGPositionType; },
         get YGUnit () { return exports.YGUnit; },
-        get YGWrap () { return exports.YGWrap; }
+        get YGWrap () { return exports.YGWrap; },
+        componentDefinitionByName: componentDefinitionByName
     });
 
     /**
@@ -13931,6 +13964,57 @@
         };
     };
 
+    const primitiveSchemas = {
+        [Bool.jsonSchema.serializationType]: Bool,
+        [EcsString.jsonSchema.serializationType]: EcsString,
+        [Float32.jsonSchema.serializationType]: Float32,
+        [Float64.jsonSchema.serializationType]: Float64,
+        [Int8.jsonSchema.serializationType]: Int8,
+        [Int16.jsonSchema.serializationType]: Int16,
+        [Int32.jsonSchema.serializationType]: Int32,
+        [Int64.jsonSchema.serializationType]: Int64,
+        [Vector3Schema.jsonSchema.serializationType]: Vector3Schema,
+        [QuaternionSchema.jsonSchema.serializationType]: QuaternionSchema,
+        [Color3Schema.jsonSchema.serializationType]: Color3Schema,
+        [Color4Schema.jsonSchema.serializationType]: Color4Schema,
+        [EntitySchema.jsonSchema.serializationType]: EntitySchema
+    };
+    /**
+     * Create an ISchema object from the json-schema
+     * @param jsonSchema
+     * @returns a ISchema or fail for unsupported json-schema
+     */
+    function jsonSchemaToSchema(jsonSchema) {
+        if (primitiveSchemas[jsonSchema.serializationType]) {
+            return primitiveSchemas[jsonSchema.serializationType];
+        }
+        if (jsonSchema.serializationType === 'map') {
+            const mapJsonSchema = jsonSchema;
+            const spec = {};
+            for (const key in mapJsonSchema.properties) {
+                spec[key] = jsonSchemaToSchema(mapJsonSchema.properties[key]);
+            }
+            return IMap(spec);
+        }
+        if (jsonSchema.serializationType === 'optional') {
+            const withItemsJsonSchema = jsonSchema;
+            return IOptional(jsonSchemaToSchema(withItemsJsonSchema.optionalJsonSchema));
+        }
+        if (jsonSchema.serializationType === 'array') {
+            const withItemsJsonSchema = jsonSchema;
+            return IArray(jsonSchemaToSchema(withItemsJsonSchema.items));
+        }
+        if (jsonSchema.serializationType === 'enum-int') {
+            const enumJsonSchema = jsonSchema;
+            return IntEnum(enumJsonSchema.enumObject, enumJsonSchema.default);
+        }
+        if (jsonSchema.serializationType === 'enum-string') {
+            const enumJsonSchema = jsonSchema;
+            return StringEnum(enumJsonSchema.enumObject, enumJsonSchema.default);
+        }
+        throw new Error(`${jsonSchema.serializationType} is not supported as reverse schema generation.`);
+    }
+
     /**
      * @public
      */
@@ -13974,6 +14058,12 @@
         Schemas.Map = IMap;
         /** @public */
         Schemas.Optional = IOptional;
+        /**
+         * @public Create an ISchema object from the json-schema
+         * @param jsonSchema
+         * @returns a ISchema or fail for unsupported json-schema
+         */
+        Schemas.fromJson = jsonSchemaToSchema;
     })(exports.Schemas || (exports.Schemas = {}));
 
     /**
@@ -15756,14 +15846,16 @@
             componentsDefinition.set(componentId, newComponent);
             return newComponent;
         }
-        function getComponent(componentId) {
+        function getComponent(componentIdOrName) {
+            const componentId = typeof componentIdOrName === 'number' ? componentIdOrName : componentNumberFromName(componentIdOrName);
             const component = componentsDefinition.get(componentId);
             if (!component) {
                 throw new Error(`Component ${componentId} not found. You need to declare the components at the beginnig of the engine declaration`);
             }
             return component;
         }
-        function getComponentOrNull(componentId) {
+        function getComponentOrNull(componentIdOrName) {
+            const componentId = typeof componentIdOrName === 'number' ? componentIdOrName : componentNumberFromName(componentIdOrName);
             return (componentsDefinition.get(componentId) ??
                 /* istanbul ignore next */
                 null);
@@ -15794,7 +15886,10 @@
         function componentsIter() {
             return componentsDefinition.values();
         }
-        function removeComponentDefinition(componentId) {
+        function removeComponentDefinition(componentIdOrName) {
+            if (sealed)
+                throw new Error('Engine is already sealed. No components can be removed at this stage');
+            const componentId = typeof componentIdOrName === 'number' ? componentIdOrName : componentNumberFromName(componentIdOrName);
             componentsDefinition.delete(componentId);
         }
         const Transform = Transform$1({ defineComponentFromSchema });
@@ -16182,6 +16277,176 @@
         Font[Font["F_MONOSPACE"] = 2] = "F_MONOSPACE";
     })(exports.Font || (exports.Font = {}));
 
+    /**
+     * @public
+     * @deprecated composite is not being supported so far, please do not use this feature
+     */
+    function compositeFromJson(jsonComposite) {
+        if (!jsonComposite)
+            throw new Error('Composite is not well defined');
+        if (!jsonComposite.id || typeof jsonComposite.id !== 'string')
+            throw new Error("Composite doesn't have a valid `id` field");
+        const compositeId = jsonComposite.id;
+        // TODO: Should be there a .version to identify the schema version?
+        if (!Array.isArray(jsonComposite.components))
+            throw new Error(`Composite '${compositeId}' fields 'components' is not an array`);
+        const composite = {
+            id: compositeId,
+            components: []
+        };
+        for (const component of jsonComposite.components) {
+            if (!component.name || typeof component.name !== 'string')
+                throw new Error(`Composite '${compositeId}': The component doesn't have a valid name`);
+            const componentName = component.name;
+            const componentData = new Map();
+            if (typeof component.data !== 'object' || Array.isArray(component.data))
+                throw new Error(`Composite '${compositeId}': Invalid data in component '${component.name}'`);
+            for (const [entityStr, data] of Object.entries(component.data)) {
+                const entity = parseInt(entityStr);
+                componentData.set(entity, data);
+            }
+            composite.components.push({
+                name: componentName,
+                data: componentData,
+                schema: component.schema
+            });
+        }
+        return composite;
+    }
+
+    /**
+     * @public
+     * @deprecated composite is not being supported so far, please do not use this feature
+     */
+    function getCompositeRootComponent(engine) {
+        const component = engine.getComponentOrNull('composite::root');
+        if (component) {
+            return component;
+        }
+        return engine.defineComponent('composite::root', {
+            id: exports.Schemas.String,
+            entities: exports.Schemas.Array(exports.Schemas.Map({
+                src: exports.Schemas.Entity,
+                dest: exports.Schemas.Entity
+            }))
+        });
+    }
+
+    /**
+     * Return the entity mapping or fail if there is no more
+     */
+    function getEntityMapping(compositeEntity, mappedEntities, getNextAvailableEntity) {
+        const existingEntity = mappedEntities.get(compositeEntity);
+        if (existingEntity) {
+            return existingEntity;
+        }
+        // This function in runtime can be just `engine.addEntity()`
+        const newEntity = getNextAvailableEntity();
+        if (newEntity === null) {
+            throw new Error('There is no more entities to allocate');
+        }
+        mappedEntities.set(compositeEntity, newEntity);
+        return newEntity;
+    }
+    /**
+     * Instance a composite and returns its root entity
+     * @param compositeData state serialized by the CRDT protocol
+     * @param getNextAvailableEntity function that gives unused entities
+     * @param rootEntity (optional) suggested mapped rootEntity for the composite
+     *
+     * @public
+     * @deprecated composite is not being supported so far, please do not use this feature
+     *
+     */
+
+    function instanceComposite(engine, compositeData, getNextAvailableEntity, compositeProvider, rootEntity, alreadyRequestedId = new Set()) {
+        const TransformComponentNumber = componentNumberFromName('core::Transform');
+        const CompositeRootComponent = getCompositeRootComponent(engine);
+        // Key => EntityNumber from the composite
+        // Value => EntityNumber in current engine
+        const mappedEntities = new Map();
+        const getCompositeEntity = (compositeEntity) => getEntityMapping(compositeEntity, mappedEntities, getNextAvailableEntity);
+        // ## 1 ##
+        // First entity that I want to map, the root entity from the composite to the target entity in the engine
+        // If there is no `rootEntity` passed, we assign one from `getNextAvailableEntity`
+        const compositeRootEntity = rootEntity ?? getCompositeEntity(0);
+        if (rootEntity) {
+            mappedEntities.set(0, rootEntity);
+        }
+        // ## 2 ##
+        // If there are more composite inside this one, we instance first.
+        // => This is not only a copy, we need to instance. Otherwise, we'd be missing that branches
+        // => TODO: in the future, the instanciation is first, then the overides (to parameterize Composite, e.g. house with different wall colors)
+        const childrenComposite = compositeData.components.find((item) => item.name === CompositeRootComponent.componentName);
+        if (childrenComposite) {
+            for (const [entity, childComposite] of childrenComposite.data) {
+                const compositeRoot = childComposite;
+                const composite = compositeProvider.getCompositeOrNull(compositeRoot.id);
+                if (composite) {
+                    if (alreadyRequestedId.has(compositeRoot.id) || compositeRoot.id === compositeData.id) {
+                        throw new Error(`Composite ${compositeRoot.id} has a recursive instanciation while try to instance ${compositeData.id}. Previous instances: ${alreadyRequestedId.toString()}`);
+                    }
+                    instanceComposite(engine, composite, getNextAvailableEntity, compositeProvider, entity, new Set(alreadyRequestedId).add(compositeData.id));
+                }
+            }
+        }
+        // ## 3 ##
+        // Then, we copy the all rest of the components (skipping the Composite ones)
+        for (const component of compositeData.components) {
+            // We already instanced the composite
+            if (component.name === CompositeRootComponent.componentName)
+                continue;
+            // ## 3a ##
+            // We find the component definition
+            let componentDefinition;
+            const existingComponentDefinition = engine.getComponentOrNull(component.name);
+            if (!existingComponentDefinition) {
+                if (component.schema) {
+                    componentDefinition = engine.defineComponentFromSchema(component.name, exports.Schemas.fromJson(component.schema));
+                }
+                else if (component.name.startsWith('core::')) {
+                    if (component.name in componentDefinitionByName) {
+                        componentDefinition = componentDefinitionByName[component.name](engine);
+                    }
+                    else {
+                        throw new Error(`The core component ${component.name} was not found.`);
+                    }
+                }
+                else {
+                    throw new Error(`${component.name} is not defined and there is no schema to define it.`);
+                }
+            }
+            else {
+                componentDefinition = existingComponentDefinition;
+            }
+            // ## 3b ##
+            // Iterating over all the entities with this component and create the replica
+            for (const [entity, compositeComponentValue] of component.data) {
+                const targetEntity = getCompositeEntity(entity);
+                const componentValue = componentDefinition.create(targetEntity, compositeComponentValue);
+                // ## 3c ##
+                // All entities referenced in the composite probably has a different resolved EntityNumber
+                // We'll know with the mappedEntityes
+                if (componentDefinition.componentId === TransformComponentNumber) {
+                    const transform = componentValue;
+                    if (transform.parent) {
+                        transform.parent = getCompositeEntity(transform.parent);
+                    }
+                    // TODO: is it going to be necessary to remap assets? e.g. src param from AudioSource and GltfContainer
+                }
+            }
+        }
+        const composite = CompositeRootComponent.getMutableOrNull(compositeRootEntity) || CompositeRootComponent.create(compositeRootEntity);
+        for (const [entitySource, targetEntity] of mappedEntities) {
+            composite.entities.push({
+                src: entitySource,
+                dest: targetEntity
+            });
+        }
+        composite.id = compositeData.id;
+        return compositeRootEntity;
+    }
+
     // The order of the following imports matters. Please do not auto-sort
     // export components for global engine
      const Transform = Transform$1(engine);
@@ -42935,7 +43200,9 @@
     exports.VideoPlayer = VideoPlayer;
     exports.VideoTexture = VideoTexture;
     exports.VisibilityComponent = VisibilityComponent;
+    exports.componentDefinitionByName = componentDefinitionByName;
     exports.components = index;
+    exports.compositeFromJson = compositeFromJson;
     exports.createEthereumProvider = createEthereumProvider;
     exports.createInputSystem = createInputSystem;
     exports.createPointerEventSystem = createPointerEventSystem;
@@ -42946,6 +43213,7 @@
     exports.engine = engine;
     exports.executeTask = executeTask;
     exports.inputSystem = inputSystem;
+    exports.instanceComposite = instanceComposite;
     exports.isListener = isListener;
     exports.onCommsMessage = onCommsMessage;
     exports.onEnterScene = onEnterScene;