feat: add <BackgroundImage /> component (#200)

Author: hannojg

package/.eslintrc.js

@@ -16,7 +16,7 @@ module.exports = {
     'react-hooks/exhaustive-deps': [
       'error',
       {
-        additionalHooks: '(useDerivedValue|useAnimatedStyle|useAnimatedProps|useWorkletEffect|useRenderCallback|useDisposableResource)',
+        additionalHooks: '(useDerivedValue|useAnimatedStyle|useAnimatedProps|useWorkletEffect|useDisposableResource|useWorkletMemo)',
       },
     ],
   },

package/cpp/RNFReferences.h

@@ -46,6 +46,13 @@ template <typename T> struct References {
   static std::shared_ptr<T> adoptEngineRef(std::shared_ptr<filament::Engine> engine, T* value, CleanupEngineRefFunction&& cleanup) {
     return adoptRef(value, [engine = engine, cleanup = std::move(cleanup)](T* ref) { cleanup(engine, ref); });
   }
+
+  /**
+   * Same as `adoptEngineRef` but with an automatic cleanup function that calls `Engine::destroy` on the reference.
+   */
+  static std::shared_ptr<T> adoptEngineRefAuto(std::shared_ptr<filament::Engine> engine, T* value) {
+    return adoptEngineRef(engine, value, [](std::shared_ptr<filament::Engine> engine, T* ref) { engine->destroy(ref); });
+  }
 };
 
 } // namespace margelo

package/cpp/core/RNFEngineImpl.cpp

@@ -366,6 +366,7 @@ std::shared_ptr<MaterialWrapper> EngineImpl::createMaterial(std::shared_ptr<Fila
           for (auto& materialInstanceWrapper : pMaterialImpl->getInstances()) {
             std::unique_lock lock(sharedThis->_mutex);
             MaterialInstance* materialInstance = materialInstanceWrapper->getMaterialInstance();
+            // Note: we should only destroy a material instance when no-one is using it anymore
             engine->destroy(materialInstance);
           }
 

package/cpp/core/RNFMaterialImpl.cpp

@@ -2,6 +2,7 @@
 #include "RNFMaterialImpl.h"
 #include <filament/Engine.h>
 #include <filament/TextureSampler.h>
+#include <math/mat3.h>
 
 namespace margelo {
 
@@ -18,9 +19,11 @@ std::shared_ptr<MaterialInstanceWrapper> MaterialImpl::getDefaultInstance() {
   std::unique_lock lock(_mutex);
 
   MaterialInstance* materialInstance = _material->getDefaultInstance();
-  auto instance = std::make_shared<MaterialInstanceWrapper>(materialInstance);
-  _instances.push_back(instance);
-  return instance;
+  // Note: the default material instance isn't added to the list of instances.
+  // We only keep track of that list to destroy a material correctly (ie. all
+  // its instances have to be destroyed first). However, the default instance
+  // is not destroyable, so it can be ignored.
+  return std::make_shared<MaterialInstanceWrapper>(materialInstance);
 }
 
 void MaterialImpl::setDefaultFloatParameter(std::string name, double value) {
@@ -33,6 +36,16 @@ void MaterialImpl::setDefaultFloatParameter(std::string name, double value) {
   _material->setDefaultParameter(name.c_str(), (float)value);
 }
 
+void MaterialImpl::setDefaultIntParameter(std::string name, int value) {
+  std::unique_lock lock(_mutex);
+
+  if (!_material->hasParameter(name.c_str())) {
+    throw std::runtime_error("MaterialWrapper::setDefaultIntParameter: Material does not have parameter \"" + name + "\"!");
+  }
+
+  _material->setDefaultParameter(name.c_str(), value);
+}
+
 void MaterialImpl::setDefaultTextureParameter(std::string name, Texture* texture, TextureSampler sampler) {
   std::unique_lock lock(_mutex);
 
@@ -43,22 +56,59 @@ void MaterialImpl::setDefaultTextureParameter(std::string name, Texture* texture
   _material->setDefaultParameter(name.c_str(), texture, sampler);
 }
 
-void MaterialImpl::setBaseColorSRGB(std::vector<double> rgba) {
+void MaterialImpl::setDefaultFloat3Parameter(std::string name, std::vector<double> vector) {
   std::unique_lock lock(_mutex);
-  if (rgba.size() != 4) {
-    throw std::runtime_error("MaterialInstanceWrapper::setBaseColorSRGB: RGBA vector must have 4 elements!");
+  if (vector.size() != 3) {
+    throw std::runtime_error("setDefaultFloat3Parameter: RGB vector must have 3 elements!");
+  }
+
+  if (!_material->hasParameter(name.c_str())) {
+    throw std::runtime_error("setDefaultFloat3Parameter: Material does not have parameter \"" + name + "\"!");
   }
 
-  double r = rgba[0];
-  double g = rgba[1];
-  double b = rgba[2];
-  double a = rgba[3];
+  float x = vector[0];
+  float y = vector[1];
+  float z = vector[2];
 
-  _material->setDefaultParameter("baseColorFactor", math::float4({r, g, b, a}));
+  _material->setDefaultParameter(name.c_str(), math::float3({x, y, z}));
+}
+
+void MaterialImpl::setDefaultFloat4Parameter(std::string name, std::vector<double> vector) {
+  std::unique_lock lock(_mutex);
+  if (vector.size() != 4) {
+    throw std::runtime_error("setDefaultFloat4Parameter: RGBA vector must have 4 elements!");
+  }
+
+  if (!_material->hasParameter(name.c_str())) {
+    throw std::runtime_error("setDefaultFloat4Parameter: Material does not have parameter \"" + name + "\"!");
+  }
+
+  double r = vector[0];
+  double g = vector[1];
+  double b = vector[2];
+  double a = vector[3];
+
+  _material->setDefaultParameter(name.c_str(), math::float4({r, g, b, a}));
 }
 std::string MaterialImpl::getName() {
   std::unique_lock lock(_mutex);
   return _material->getName();
 }
 
+void MaterialImpl::setDefaultMat3fParameter(std::string name, std::vector<double> value) {
+  std::unique_lock lock(_mutex);
+
+  if (!_material->hasParameter(name.c_str())) {
+    throw std::runtime_error("MaterialWrapper::setDefaultMat3fParameter: Material does not have parameter \"" + name + "\"!");
+  }
+
+  if (value.size() != 9) {
+    throw std::runtime_error("MaterialWrapper::setDefaultMat3fParameter: Value vector must have 9 elements!");
+  }
+
+  math::mat3f matrix = math::mat3f((float)value[0], (float)value[1], (float)value[2], (float)value[3], (float)value[4], (float)value[5],
+                                   (float)value[6], (float)value[7], (float)value[8]);
+  _material->setDefaultParameter(name.c_str(), matrix);
+}
+
 } // namespace margelo

package/cpp/core/RNFMaterialImpl.h

@@ -29,8 +29,11 @@ class MaterialImpl {
   std::shared_ptr<MaterialInstanceWrapper> createInstance();
   std::shared_ptr<MaterialInstanceWrapper> getDefaultInstance();
   void setDefaultFloatParameter(std::string name, double value);
+  void setDefaultIntParameter(std::string name, int value);
   void setDefaultTextureParameter(std::string name, Texture* texture, TextureSampler sampler);
-  void setBaseColorSRGB(std::vector<double> rgba);
+  void setDefaultFloat3Parameter(std::string name, std::vector<double> vector);
+  void setDefaultFloat4Parameter(std::string name, std::vector<double> vector);
+  void setDefaultMat3fParameter(std::string name, std::vector<double> value);
   std::string getName();
 
 private:

package/cpp/core/RNFMaterialInstanceWrapper.cpp

@@ -13,7 +13,7 @@ void MaterialInstanceWrapper::loadHybridMethods() {
   registerHybridMethod("setTransparencyMode", &MaterialInstanceWrapper::setTransparencyMode, this);
   registerHybridMethod("changeAlpha", &MaterialInstanceWrapper::changeAlpha, this);
   registerHybridMethod("setParameter", &MaterialInstanceWrapper::setParameter, this);
-  registerHybridMethod("setBaseColorSRGB", &MaterialInstanceWrapper::setBaseColorSRGB, this);
+  registerHybridMethod("setDefaultFloat4Parameter", &MaterialInstanceWrapper::setBaseColorSRGB, this);
   registerHybridGetter("getName", &MaterialInstanceWrapper::getName, this);
 }
 
@@ -66,7 +66,7 @@ void MaterialInstanceWrapper::setBaseColorSRGB(std::vector<double> rgba) {
   std::unique_lock lock(_mutex);
 
   if (rgba.size() != 4) {
-    throw std::runtime_error("MaterialInstanceWrapper::setBaseColorSRGB: RGBA vector must have 4 elements!");
+    throw std::runtime_error("MaterialInstanceWrapper::setDefaultFloat4Parameter: RGBA vector must have 4 elements!");
   }
 
   double r = rgba[0];

package/cpp/core/RNFMaterialWrapper.cpp

@@ -5,13 +5,18 @@
 #include "RNFMaterialWrapper.h"
 #include "RNFRenderableManagerWrapper.h"
 
+#include <filament/Texture.h>
+
 namespace margelo {
 void MaterialWrapper::loadHybridMethods() {
   registerHybridMethod("createInstance", &MaterialWrapper::createInstance, this);
   registerHybridMethod("setDefaultFloatParameter", &MaterialWrapper::setDefaultFloatParameter, this);
   registerHybridMethod("setDefaultTextureParameter", &MaterialWrapper::setDefaultTextureParameter, this);
   registerHybridMethod("getDefaultInstance", &MaterialWrapper::getDefaultInstance, this);
-  registerHybridMethod("setBaseColorSRGB", &MaterialWrapper::setBaseColorSRGB, this);
+  registerHybridMethod("setDefaultMat3fParameter", &MaterialWrapper::setDefaultMat3fParameter, this);
+  registerHybridMethod("setDefaultFloat3Parameter", &MaterialWrapper::setDefaultFloat3Parameter, this);
+  registerHybridMethod("setDefaultFloat4Parameter", &MaterialWrapper::setDefaultFloat4Parameter, this);
+  registerHybridMethod("setDefaultIntParameter", &MaterialWrapper::setDefaultIntParameter, this);
 }
 std::shared_ptr<MaterialInstanceWrapper> MaterialWrapper::createInstance() {
   return pointee()->createInstance();
@@ -22,8 +27,9 @@ std::shared_ptr<MaterialInstanceWrapper> MaterialWrapper::getDefaultInstance() {
 void MaterialWrapper::setDefaultFloatParameter(std::string name, double value) {
   pointee()->setDefaultFloatParameter(name, value);
 }
-void MaterialWrapper::setDefaultTextureParameter(std::shared_ptr<RenderableManagerWrapper> renderableManager, std::string name,
-                                                 std::shared_ptr<FilamentBuffer> buffer, const std::string& textureFlags) {
+std::unordered_map<std::string, int>
+MaterialWrapper::setDefaultTextureParameter(std::shared_ptr<RenderableManagerWrapper> renderableManager, std::string name,
+                                            std::shared_ptr<FilamentBuffer> buffer, const std::string& textureFlags) {
 
   // Create a texture from the buffer using the renderable manager:
   Texture* texture = renderableManager->createTextureFromBuffer(buffer, textureFlags);
@@ -32,9 +38,26 @@ void MaterialWrapper::setDefaultTextureParameter(std::shared_ptr<RenderableManag
 
   // Set the texture
   pointee()->setDefaultTextureParameter(name, texture, sampler);
+
+  // Return the texture size
+  std::unordered_map<std::string, int> textureSize;
+  textureSize["width"] = texture->getWidth();
+  textureSize["height"] = texture->getHeight();
+  return textureSize;
+}
+
+void MaterialWrapper::setDefaultIntParameter(std::string name, int value) {
+  pointee()->setDefaultIntParameter(name, value);
 }
-void MaterialWrapper::setBaseColorSRGB(std::vector<double> rgba) {
-  pointee()->setBaseColorSRGB(rgba);
+void MaterialWrapper::setDefaultFloat3Parameter(std::string name, std::vector<double> vector) {
+  pointee()->setDefaultFloat3Parameter(name, vector);
+}
+void MaterialWrapper::setDefaultFloat4Parameter(std::string name, std::vector<double> vector) {
+  pointee()->setDefaultFloat4Parameter(name, vector);
+}
+
+void MaterialWrapper::setDefaultMat3fParameter(std::string name, std::vector<double> value) {
+  pointee()->setDefaultMat3fParameter(name, value);
 }
 std::string MaterialWrapper::getName() {
   return pointee()->getName();

package/cpp/core/RNFMaterialWrapper.h

@@ -22,9 +22,13 @@ class MaterialWrapper : public PointerHolder<MaterialImpl> {
   std::shared_ptr<MaterialInstanceWrapper> createInstance();
   std::shared_ptr<MaterialInstanceWrapper> getDefaultInstance();
   void setDefaultFloatParameter(std::string name, double value);
-  void setDefaultTextureParameter(std::shared_ptr<RenderableManagerWrapper> renderableManager, std::string name,
-                                  std::shared_ptr<FilamentBuffer> buffer, const std::string& textureFlags);
-  void setBaseColorSRGB(std::vector<double> rgba);
+  std::unordered_map<std::string, int> setDefaultTextureParameter(std::shared_ptr<RenderableManagerWrapper> renderableManager,
+                                                                  std::string name, std::shared_ptr<FilamentBuffer> buffer,
+                                                                  const std::string& textureFlags);
+  void setDefaultIntParameter(std::string name, int value);
+  void setDefaultFloat3Parameter(std::string name, std::vector<double> vector);
+  void setDefaultFloat4Parameter(std::string name, std::vector<double> vector);
+  void setDefaultMat3fParameter(std::string name, std::vector<double> value);
   std::string getName();
 };
 

package/cpp/core/RNFRenderableManagerImpl.cpp

@@ -4,12 +4,15 @@
 
 #include "RNFRenderableManagerImpl.h"
 #include "RNFEngineWrapper.h"
+#include "RNFReferences.h"
 #include "RNFTextureFlagsEnum.h"
+#include "VertexEntity.h"
 #include "core/RNFFilamentInstanceWrapper.h"
 
 #include <cmath>
 
 #include <filament/IndexBuffer.h>
+#include <filament/MaterialInstance.h>
 #include <gltfio/TextureProvider.h>
 #include <math/norm.h>
 
@@ -230,6 +233,41 @@ std::shared_ptr<EntityWrapper> RenderableManagerImpl::createPlane(std::shared_pt
   return std::make_shared<EntityWrapper>(renderable);
 }
 
+static constexpr float4 sFullScreenTriangleVertices[3] = {{-1.0f, -1.0f, 1.0f, 1.0f}, {3.0f, -1.0f, 1.0f, 1.0f}, {-1.0f, 3.0f, 1.0f, 1.0f}};
+
+static const uint16_t sFullScreenTriangleIndices[3] = {0, 1, 2};
+
+VertexEntity RenderableManagerImpl::createImageBackground(MaterialInstance* materialInstance) {
+  VertexBuffer* vertexBuffer = VertexBuffer::Builder()
+                                   .vertexCount(3)
+                                   .bufferCount(1)
+                                   .attribute(VertexAttribute::POSITION, 0, VertexBuffer::AttributeType::FLOAT4, 0)
+                                   .build(*_engine);
+  vertexBuffer->setBufferAt(*_engine, 0, {sFullScreenTriangleVertices, sizeof(sFullScreenTriangleVertices)});
+
+  IndexBuffer* indexBuffer = IndexBuffer::Builder().indexCount(3).bufferType(IndexBuffer::IndexType::USHORT).build(*_engine);
+  indexBuffer->setBuffer(*_engine, {sFullScreenTriangleIndices, sizeof(sFullScreenTriangleIndices)});
+
+  auto& em = utils::EntityManager::get();
+  Entity imageEntity = em.create();
+  RenderableManager::Builder(1)
+      .boundingBox({{}, {1.0f, 1.0f, 1.0f}})
+      .material(0, materialInstance)
+      .geometry(0, RenderableManager::PrimitiveType::TRIANGLES, vertexBuffer, indexBuffer, 0, 3)
+      .culling(false)
+      .build(*_engine, imageEntity);
+
+  // TODO: enable this pattern once EntityWrappers are PointerHolders!
+  //  std::shared_ptr<VertexBuffer> sharedVertexBuffer = References<VertexBuffer>::adoptEngineRefAuto(_engine, vertexBuffer);
+  //  std::shared_ptr<IndexBuffer> sharedIndexBuffer = References<IndexBuffer>::adoptEngineRefAuto(_engine, indexBuffer);
+
+  return {
+      .entity = imageEntity,
+      .vertexBuffer = nullptr,
+      .indexBuffer = nullptr,
+  };
+}
+
 void RenderableManagerImpl::scaleBoundingBox(std::shared_ptr<FilamentAssetWrapper> assetWrapper, double scaleFactor) {
   if (assetWrapper == nullptr) {
     throw std::invalid_argument("Asset is null");

package/cpp/core/RNFRenderableManagerImpl.h

@@ -8,6 +8,7 @@
 #include "RNFFilamentBuffer.h"
 #include "RNFMaterialInstanceWrapper.h"
 #include "RNFMaterialWrapper.h"
+#include "VertexEntity.h"
 #include "core/utils/RNFEntityWrapper.h"
 #include "jsi/RNFPointerHolder.h"
 
@@ -61,6 +62,7 @@ class RenderableManagerImpl {
 
   std::shared_ptr<EntityWrapper> createPlane(std::shared_ptr<MaterialWrapper> materialWrapper, double halfExtendX, double halfExtendY,
                                              double halfExtendZ);
+  VertexEntity createImageBackground(MaterialInstance* materialInstance);
   std::shared_ptr<EntityWrapper> createDebugCubeWireframe(float halfExtentX, float halfExtentY, float halfExtentZ,
                                                           std::optional<std::shared_ptr<MaterialWrapper>> materialWrapper,
                                                           std::optional<double> colorHexCode);
@@ -73,6 +75,10 @@ class RenderableManagerImpl {
 
   Box getAxisAlignedBoundingBox(std::shared_ptr<EntityWrapper> entityWrapper);
 
+  std::shared_ptr<Engine> getEngine() {
+    return _engine;
+  }
+
 private:
   // Calls the TextureProvider to start loading the resource
   void startUpdateResourceLoading();