From 0b8acb451d219c5a4cdc78ddade97f15ddf62bfa Mon Sep 17 00:00:00 2001 From: Mathias Agopian Date: Mon, 25 Mar 2019 18:23:11 -0700 Subject: [PATCH] attempt to fix filament-js --- web/filament-js/jsbindings.cpp | 30 +++--- web/filament-js/jsenums.cpp | 164 ++++++++++++++++----------------- 2 files changed, 97 insertions(+), 97 deletions(-) diff --git a/web/filament-js/jsbindings.cpp b/web/filament-js/jsbindings.cpp index 27ffc4423e..323f402f44 100644 --- a/web/filament-js/jsbindings.cpp +++ b/web/filament-js/jsbindings.cpp @@ -128,7 +128,7 @@ using IblBuilder = IndirectLight::Builder; using SkyBuilder = Skybox::Builder; using SurfaceBuilder = SurfaceOrientation::Builder; -// We avoid directly exposing driver::BufferDescriptor because embind does not support move +// We avoid directly exposing backend::BufferDescriptor because embind does not support move // semantics and void* doesn't make sense to JavaScript anyway. This little wrapper class is exposed // to JavaScript as "driver$BufferDescriptor", but clients will normally use our "Filament.Buffer" // helper function (implemented in utilities.js) @@ -137,12 +137,12 @@ struct BufferDescriptor { // This form is used when JavaScript sends a buffer into WASM. BufferDescriptor(val arrdata) { auto byteLength = arrdata["byteLength"].as(); - this->bd.reset(new driver::BufferDescriptor(malloc(byteLength), byteLength, + this->bd.reset(new backend::BufferDescriptor(malloc(byteLength), byteLength, [](void* buffer, size_t size, void* user) { free(buffer); })); } // This form is used when WASM needs to return a buffer to JavaScript. BufferDescriptor(uint8_t* data, uint32_t size) { - this->bd.reset(new driver::BufferDescriptor(data, size)); + this->bd.reset(new backend::BufferDescriptor(data, size)); } val getBytes() { unsigned char *byteBuffer = (unsigned char*) bd->buffer; @@ -151,26 +151,26 @@ struct BufferDescriptor { } // In order to match its JavaScript counterpart, the Buffer wrapper needs to use reference // counting, and the easiest way to achieve that is with shared_ptr. - std::shared_ptr bd; + std::shared_ptr bd; }; // Exposed to JavaScript as "driver$PixelBufferDescriptor", but clients will normally use the // PixelBuffer or CompressedPixelBuffer helper functions (implemented in utilities.js) struct PixelBufferDescriptor { - PixelBufferDescriptor(val arrdata, driver::PixelDataFormat fmt, driver::PixelDataType dtype) { + PixelBufferDescriptor(val arrdata, backend::PixelDataFormat fmt, backend::PixelDataType dtype) { auto byteLength = arrdata["byteLength"].as(); - this->pbd.reset(new driver::PixelBufferDescriptor(malloc(byteLength), byteLength, + this->pbd.reset(new backend::PixelBufferDescriptor(malloc(byteLength), byteLength, fmt, dtype, [](void* buffer, size_t size, void* user) { free(buffer); })); } // Note that embind allows overloading based on number of arguments, but not on types. // It's fine to have two constructors but they can't both have the same number of arguments. - PixelBufferDescriptor(val arrdata, driver::CompressedPixelDataType cdtype, int imageSize, + PixelBufferDescriptor(val arrdata, backend::CompressedPixelDataType cdtype, int imageSize, bool compressed) { auto byteLength = arrdata["byteLength"].as(); assert(compressed == true); // For compressed cubemaps, the image size should be one-sixth the size of the entire blob. assert(imageSize == byteLength || imageSize == byteLength / 6); - this->pbd.reset(new driver::PixelBufferDescriptor(malloc(byteLength), byteLength, + this->pbd.reset(new backend::PixelBufferDescriptor(malloc(byteLength), byteLength, cdtype, imageSize, [](void* buffer, size_t size, void* user) { free(buffer); })); } val getBytes() { @@ -180,7 +180,7 @@ struct PixelBufferDescriptor { }; // In order to match its JavaScript counterpart, the Buffer wrapper needs to use reference // counting, and the easiest way to achieve that is with shared_ptr. - std::shared_ptr pbd; + std::shared_ptr pbd; }; // Small structure whose sole purpose is to return decoded image data to JavaScript. @@ -820,7 +820,7 @@ class_("MaterialInstance") .function("setPolygonOffset", &MaterialInstance::setPolygonOffset); class_("TextureSampler") - .constructor(); + .constructor(); /// Texture ::core class:: 2D image or cubemap that can be sampled by the GPU, possibly mipmapped. class_("Texture") @@ -935,8 +935,8 @@ class_("driver$BufferDescriptor") /// PixelBufferDescriptor ::class:: Low level pixel buffer wrapper. /// Clients should use the [PixelBuffer] helper function to contruct PixelBufferDescriptor objects. class_("driver$PixelBufferDescriptor") - .constructor() - .constructor() + .constructor() + .constructor() /// getBytes ::method:: Gets a view of the WASM heap referenced by the buffer descriptor. /// ::retval:: Uint8Array .function("getBytes", &PixelBufferDescriptor::getBytes); @@ -983,7 +983,7 @@ class_("KtxBundle") /// ::retval:: [PixelDataFormat] /// Returns "undefined" if no valid Filament enumerant exists. .function("getPixelDataFormat", - EMBIND_LAMBDA(driver::PixelDataFormat, (KtxBundle* self, bool rgbm), { + EMBIND_LAMBDA(backend::PixelDataFormat, (KtxBundle* self, bool rgbm), { return KtxUtility::toPixelDataFormat(self->getInfo(), rgbm); }), allow_raw_pointers()) @@ -991,7 +991,7 @@ class_("KtxBundle") /// ::retval:: [PixelDataType] /// Returns "undefined" if no valid Filament enumerant exists. .function("getPixelDataType", - EMBIND_LAMBDA(driver::PixelDataType, (KtxBundle* self), { + EMBIND_LAMBDA(backend::PixelDataType, (KtxBundle* self), { return KtxUtility::toPixelDataType(self->getInfo()); }), allow_raw_pointers()) @@ -999,7 +999,7 @@ class_("KtxBundle") /// ::retval:: [CompressedPixelDataType] /// Returns "undefined" if no valid Filament enumerant exists. .function("getCompressedPixelDataType", - EMBIND_LAMBDA(driver::CompressedPixelDataType, (KtxBundle* self), { + EMBIND_LAMBDA(backend::CompressedPixelDataType, (KtxBundle* self), { return KtxUtility::toCompressedPixelDataType(self->getInfo()); }), allow_raw_pointers()) diff --git a/web/filament-js/jsenums.cpp b/web/filament-js/jsenums.cpp index 0801206ca3..13282e5f51 100644 --- a/web/filament-js/jsenums.cpp +++ b/web/filament-js/jsenums.cpp @@ -120,12 +120,12 @@ enum_("Frustum$Plane") .value("FAR", Frustum::Plane::FAR) .value("NEAR", Frustum::Plane::NEAR); -enum_("Texture$Sampler") // aka driver::SamplerType +enum_("Texture$Sampler") // aka backend::SamplerType .value("SAMPLER_2D", Texture::Sampler::SAMPLER_2D) .value("SAMPLER_CUBEMAP", Texture::Sampler::SAMPLER_CUBEMAP) .value("SAMPLER_EXTERNAL", Texture::Sampler::SAMPLER_EXTERNAL); -enum_("Texture$InternalFormat") // aka driver::TextureFormat +enum_("Texture$InternalFormat") // aka backend::TextureFormat .value("R8", Texture::InternalFormat::R8) .value("R8_SNORM", Texture::InternalFormat::R8_SNORM) .value("R8UI", Texture::InternalFormat::R8UI) @@ -224,94 +224,94 @@ enum_("Texture$InternalFormat") // aka driver::TextureF .value("SRGB8_ALPHA8_ASTC_12x10", Texture::InternalFormat::SRGB8_ALPHA8_ASTC_12x10) .value("SRGB8_ALPHA8_ASTC_12x12", Texture::InternalFormat::SRGB8_ALPHA8_ASTC_12x12); -enum_("Texture$Usage") // aka driver::TextureUsage +enum_("Texture$Usage") // aka backend::TextureUsage .value("DEFAULT", Texture::Usage::DEFAULT) .value("COLOR_ATTACHMENT", Texture::Usage::COLOR_ATTACHMENT) .value("DEPTH_ATTACHMENT", Texture::Usage::DEPTH_ATTACHMENT); -enum_("PixelDataFormat") - .value("R", driver::PixelDataFormat::R) - .value("R_INTEGER", driver::PixelDataFormat::R_INTEGER) - .value("RG", driver::PixelDataFormat::RG) - .value("RG_INTEGER", driver::PixelDataFormat::RG_INTEGER) - .value("RGB", driver::PixelDataFormat::RGB) - .value("RGB_INTEGER", driver::PixelDataFormat::RGB_INTEGER) - .value("RGBA", driver::PixelDataFormat::RGBA) - .value("RGBA_INTEGER", driver::PixelDataFormat::RGBA_INTEGER) - .value("RGBM", driver::PixelDataFormat::RGBM) - .value("DEPTH_COMPONENT", driver::PixelDataFormat::DEPTH_COMPONENT) - .value("DEPTH_STENCIL", driver::PixelDataFormat::DEPTH_STENCIL) - .value("ALPHA", driver::PixelDataFormat::ALPHA); +enum_("PixelDataFormat") + .value("R", backend::PixelDataFormat::R) + .value("R_INTEGER", backend::PixelDataFormat::R_INTEGER) + .value("RG", backend::PixelDataFormat::RG) + .value("RG_INTEGER", backend::PixelDataFormat::RG_INTEGER) + .value("RGB", backend::PixelDataFormat::RGB) + .value("RGB_INTEGER", backend::PixelDataFormat::RGB_INTEGER) + .value("RGBA", backend::PixelDataFormat::RGBA) + .value("RGBA_INTEGER", backend::PixelDataFormat::RGBA_INTEGER) + .value("RGBM", backend::PixelDataFormat::RGBM) + .value("DEPTH_COMPONENT", backend::PixelDataFormat::DEPTH_COMPONENT) + .value("DEPTH_STENCIL", backend::PixelDataFormat::DEPTH_STENCIL) + .value("ALPHA", backend::PixelDataFormat::ALPHA); -enum_("PixelDataType") - .value("UBYTE", driver::PixelDataType::UBYTE) - .value("BYTE", driver::PixelDataType::BYTE) - .value("USHORT", driver::PixelDataType::USHORT) - .value("SHORT", driver::PixelDataType::SHORT) - .value("UINT", driver::PixelDataType::UINT) - .value("INT", driver::PixelDataType::INT) - .value("HALF", driver::PixelDataType::HALF) - .value("FLOAT", driver::PixelDataType::FLOAT); +enum_("PixelDataType") + .value("UBYTE", backend::PixelDataType::UBYTE) + .value("BYTE", backend::PixelDataType::BYTE) + .value("USHORT", backend::PixelDataType::USHORT) + .value("SHORT", backend::PixelDataType::SHORT) + .value("UINT", backend::PixelDataType::UINT) + .value("INT", backend::PixelDataType::INT) + .value("HALF", backend::PixelDataType::HALF) + .value("FLOAT", backend::PixelDataType::FLOAT); -enum_("CompressedPixelDataType") - .value("EAC_R11", driver::CompressedPixelDataType::EAC_R11) - .value("EAC_R11_SIGNED", driver::CompressedPixelDataType::EAC_R11_SIGNED) - .value("EAC_RG11", driver::CompressedPixelDataType::EAC_RG11) - .value("EAC_RG11_SIGNED", driver::CompressedPixelDataType::EAC_RG11_SIGNED) - .value("ETC2_RGB8", driver::CompressedPixelDataType::ETC2_RGB8) - .value("ETC2_SRGB8", driver::CompressedPixelDataType::ETC2_SRGB8) - .value("ETC2_RGB8_A1", driver::CompressedPixelDataType::ETC2_RGB8_A1) - .value("ETC2_SRGB8_A1", driver::CompressedPixelDataType::ETC2_SRGB8_A1) - .value("ETC2_EAC_RGBA8", driver::CompressedPixelDataType::ETC2_EAC_RGBA8) - .value("ETC2_EAC_SRGBA8", driver::CompressedPixelDataType::ETC2_EAC_SRGBA8) - .value("DXT1_RGB", driver::CompressedPixelDataType::DXT1_RGB) - .value("DXT1_RGBA", driver::CompressedPixelDataType::DXT1_RGBA) - .value("DXT3_RGBA", driver::CompressedPixelDataType::DXT3_RGBA) - .value("DXT5_RGBA", driver::CompressedPixelDataType::DXT5_RGBA) - .value("RGBA_ASTC_4x4", driver::CompressedPixelDataType::RGBA_ASTC_4x4) - .value("RGBA_ASTC_5x4", driver::CompressedPixelDataType::RGBA_ASTC_5x4) - .value("RGBA_ASTC_5x5", driver::CompressedPixelDataType::RGBA_ASTC_5x5) - .value("RGBA_ASTC_6x5", driver::CompressedPixelDataType::RGBA_ASTC_6x5) - .value("RGBA_ASTC_6x6", driver::CompressedPixelDataType::RGBA_ASTC_6x6) - .value("RGBA_ASTC_8x5", driver::CompressedPixelDataType::RGBA_ASTC_8x5) - .value("RGBA_ASTC_8x6", driver::CompressedPixelDataType::RGBA_ASTC_8x6) - .value("RGBA_ASTC_8x8", driver::CompressedPixelDataType::RGBA_ASTC_8x8) - .value("RGBA_ASTC_10x5", driver::CompressedPixelDataType::RGBA_ASTC_10x5) - .value("RGBA_ASTC_10x6", driver::CompressedPixelDataType::RGBA_ASTC_10x6) - .value("RGBA_ASTC_10x8", driver::CompressedPixelDataType::RGBA_ASTC_10x8) - .value("RGBA_ASTC_10x10", driver::CompressedPixelDataType::RGBA_ASTC_10x10) - .value("RGBA_ASTC_12x10", driver::CompressedPixelDataType::RGBA_ASTC_12x10) - .value("RGBA_ASTC_12x12", driver::CompressedPixelDataType::RGBA_ASTC_12x12) - .value("SRGB8_ALPHA8_ASTC_4x4", driver::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_4x4) - .value("SRGB8_ALPHA8_ASTC_5x4", driver::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_5x4) - .value("SRGB8_ALPHA8_ASTC_5x5", driver::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_5x5) - .value("SRGB8_ALPHA8_ASTC_6x5", driver::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_6x5) - .value("SRGB8_ALPHA8_ASTC_6x6", driver::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_6x6) - .value("SRGB8_ALPHA8_ASTC_8x5", driver::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_8x5) - .value("SRGB8_ALPHA8_ASTC_8x6", driver::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_8x6) - .value("SRGB8_ALPHA8_ASTC_8x8", driver::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_8x8) - .value("SRGB8_ALPHA8_ASTC_10x5", driver::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_10x5) - .value("SRGB8_ALPHA8_ASTC_10x6", driver::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_10x6) - .value("SRGB8_ALPHA8_ASTC_10x8", driver::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_10x8) - .value("SRGB8_ALPHA8_ASTC_10x10", driver::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_10x10) - .value("SRGB8_ALPHA8_ASTC_12x10", driver::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_12x10) - .value("SRGB8_ALPHA8_ASTC_12x12", driver::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_12x12); +enum_("CompressedPixelDataType") + .value("EAC_R11", backend::CompressedPixelDataType::EAC_R11) + .value("EAC_R11_SIGNED", backend::CompressedPixelDataType::EAC_R11_SIGNED) + .value("EAC_RG11", backend::CompressedPixelDataType::EAC_RG11) + .value("EAC_RG11_SIGNED", backend::CompressedPixelDataType::EAC_RG11_SIGNED) + .value("ETC2_RGB8", backend::CompressedPixelDataType::ETC2_RGB8) + .value("ETC2_SRGB8", backend::CompressedPixelDataType::ETC2_SRGB8) + .value("ETC2_RGB8_A1", backend::CompressedPixelDataType::ETC2_RGB8_A1) + .value("ETC2_SRGB8_A1", backend::CompressedPixelDataType::ETC2_SRGB8_A1) + .value("ETC2_EAC_RGBA8", backend::CompressedPixelDataType::ETC2_EAC_RGBA8) + .value("ETC2_EAC_SRGBA8", backend::CompressedPixelDataType::ETC2_EAC_SRGBA8) + .value("DXT1_RGB", backend::CompressedPixelDataType::DXT1_RGB) + .value("DXT1_RGBA", backend::CompressedPixelDataType::DXT1_RGBA) + .value("DXT3_RGBA", backend::CompressedPixelDataType::DXT3_RGBA) + .value("DXT5_RGBA", backend::CompressedPixelDataType::DXT5_RGBA) + .value("RGBA_ASTC_4x4", backend::CompressedPixelDataType::RGBA_ASTC_4x4) + .value("RGBA_ASTC_5x4", backend::CompressedPixelDataType::RGBA_ASTC_5x4) + .value("RGBA_ASTC_5x5", backend::CompressedPixelDataType::RGBA_ASTC_5x5) + .value("RGBA_ASTC_6x5", backend::CompressedPixelDataType::RGBA_ASTC_6x5) + .value("RGBA_ASTC_6x6", backend::CompressedPixelDataType::RGBA_ASTC_6x6) + .value("RGBA_ASTC_8x5", backend::CompressedPixelDataType::RGBA_ASTC_8x5) + .value("RGBA_ASTC_8x6", backend::CompressedPixelDataType::RGBA_ASTC_8x6) + .value("RGBA_ASTC_8x8", backend::CompressedPixelDataType::RGBA_ASTC_8x8) + .value("RGBA_ASTC_10x5", backend::CompressedPixelDataType::RGBA_ASTC_10x5) + .value("RGBA_ASTC_10x6", backend::CompressedPixelDataType::RGBA_ASTC_10x6) + .value("RGBA_ASTC_10x8", backend::CompressedPixelDataType::RGBA_ASTC_10x8) + .value("RGBA_ASTC_10x10", backend::CompressedPixelDataType::RGBA_ASTC_10x10) + .value("RGBA_ASTC_12x10", backend::CompressedPixelDataType::RGBA_ASTC_12x10) + .value("RGBA_ASTC_12x12", backend::CompressedPixelDataType::RGBA_ASTC_12x12) + .value("SRGB8_ALPHA8_ASTC_4x4", backend::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_4x4) + .value("SRGB8_ALPHA8_ASTC_5x4", backend::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_5x4) + .value("SRGB8_ALPHA8_ASTC_5x5", backend::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_5x5) + .value("SRGB8_ALPHA8_ASTC_6x5", backend::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_6x5) + .value("SRGB8_ALPHA8_ASTC_6x6", backend::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_6x6) + .value("SRGB8_ALPHA8_ASTC_8x5", backend::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_8x5) + .value("SRGB8_ALPHA8_ASTC_8x6", backend::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_8x6) + .value("SRGB8_ALPHA8_ASTC_8x8", backend::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_8x8) + .value("SRGB8_ALPHA8_ASTC_10x5", backend::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_10x5) + .value("SRGB8_ALPHA8_ASTC_10x6", backend::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_10x6) + .value("SRGB8_ALPHA8_ASTC_10x8", backend::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_10x8) + .value("SRGB8_ALPHA8_ASTC_10x10", backend::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_10x10) + .value("SRGB8_ALPHA8_ASTC_12x10", backend::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_12x10) + .value("SRGB8_ALPHA8_ASTC_12x12", backend::CompressedPixelDataType::SRGB8_ALPHA8_ASTC_12x12); -enum_("WrapMode") - .value("CLAMP_TO_EDGE", driver::SamplerWrapMode::CLAMP_TO_EDGE) - .value("REPEAT", driver::SamplerWrapMode::REPEAT) - .value("MIRRORED_REPEAT", driver::SamplerWrapMode::MIRRORED_REPEAT); +enum_("WrapMode") + .value("CLAMP_TO_EDGE", backend::SamplerWrapMode::CLAMP_TO_EDGE) + .value("REPEAT", backend::SamplerWrapMode::REPEAT) + .value("MIRRORED_REPEAT", backend::SamplerWrapMode::MIRRORED_REPEAT); -enum_("MinFilter") - .value("NEAREST", driver::SamplerMinFilter::NEAREST) - .value("LINEAR", driver::SamplerMinFilter::LINEAR) - .value("NEAREST_MIPMAP_NEAREST", driver::SamplerMinFilter::NEAREST_MIPMAP_NEAREST) - .value("LINEAR_MIPMAP_NEAREST", driver::SamplerMinFilter::LINEAR_MIPMAP_NEAREST) - .value("NEAREST_MIPMAP_LINEAR", driver::SamplerMinFilter::NEAREST_MIPMAP_LINEAR) - .value("LINEAR_MIPMAP_LINEAR", driver::SamplerMinFilter::LINEAR_MIPMAP_LINEAR); +enum_("MinFilter") + .value("NEAREST", backend::SamplerMinFilter::NEAREST) + .value("LINEAR", backend::SamplerMinFilter::LINEAR) + .value("NEAREST_MIPMAP_NEAREST", backend::SamplerMinFilter::NEAREST_MIPMAP_NEAREST) + .value("LINEAR_MIPMAP_NEAREST", backend::SamplerMinFilter::LINEAR_MIPMAP_NEAREST) + .value("NEAREST_MIPMAP_LINEAR", backend::SamplerMinFilter::NEAREST_MIPMAP_LINEAR) + .value("LINEAR_MIPMAP_LINEAR", backend::SamplerMinFilter::LINEAR_MIPMAP_LINEAR); -enum_("MagFilter") - .value("NEAREST", driver::SamplerMagFilter::NEAREST) - .value("LINEAR", driver::SamplerMagFilter::LINEAR); +enum_("MagFilter") + .value("NEAREST", backend::SamplerMagFilter::NEAREST) + .value("LINEAR", backend::SamplerMagFilter::LINEAR); }