renaming to Thermion

thermion_flutter/thermion_flutter/linux/CMakeLists.txt

@@ -0,0 +1,168 @@
+# The Flutter tooling requires that developers have CMake 3.10 or later
+# installed. You should not increase this version, as doing so will cause
+# the plugin to fail to compile for some customers of the plugin.
+cmake_minimum_required(VERSION 3.10)
+
+# Project-level configuration.
+set(PROJECT_NAME "thermion_flutter")
+project(${PROJECT_NAME})
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++ -fPIC -Wno-unused-variable -Wno-unused-function")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC -Wno-unused-variable -Wno-unused-function")
+
+# This value is used when generating builds using this plugin, so it must
+# not be changed.
+set(PLUGIN_NAME "thermion_flutter_plugin")
+
+link_directories("${CMAKE_CURRENT_SOURCE_DIR}/lib") 
+
+add_library(FILAMENT_SHADERS SHARED 
+ "${CMAKE_CURRENT_SOURCE_DIR}/../ios/include/material/image.c"
+ "${CMAKE_CURRENT_SOURCE_DIR}/../ios/include/material/unlit_opaque.c" 
+)
+
+# Define the plugin library target. Its name must not be changed (see comment
+# on PLUGIN_NAME above).
+#
+# Any new source files that you add to the plugin should be added here.
+add_library(${PLUGIN_NAME} SHARED
+ "thermion_flutter_plugin.cc"
+ "filament_texture.cc"
+ "filament_pb_texture.cc"
+ "${CMAKE_CURRENT_SOURCE_DIR}/../ios/src/SceneManager.cpp"
+ "${CMAKE_CURRENT_SOURCE_DIR}/../ios/src/FilamentViewer.cpp"
+ "${CMAKE_CURRENT_SOURCE_DIR}/../ios/src/ThermionFlutterApi.cpp"
+ "${CMAKE_CURRENT_SOURCE_DIR}/../ios/src/StreamBufferAdapter.cpp"
+ "${CMAKE_CURRENT_SOURCE_DIR}/../ios/src/TimeIt.cpp"
+)
+
+# Apply a standard set of build settings that are configured in the
+# application-level CMakeLists.txt. This can be removed for plugins that want
+# full control over build settings.
+apply_standard_settings(${PLUGIN_NAME})
+
+# Symbols are hidden by default to reduce the chance of accidental conflicts
+# between plugins. This should not be removed; any symbols that should be
+# exported should be explicitly exported with the FLUTTER_PLUGIN_EXPORT macro.
+set_target_properties(${PLUGIN_NAME} PROPERTIES
+ CXX_VISIBILITY_PRESET hidden)
+target_compile_definitions(${PLUGIN_NAME} PRIVATE FLUTTER_PLUGIN_IMPL)
+
+target_compile_features(${PLUGIN_NAME} PRIVATE cxx_std_17)
+
+add_compile_definitions(IS_DLL)
+
+
+# Source include directories and library dependencies. Add any plugin-specific
+# dependencies here.
+target_include_directories(${PLUGIN_NAME} INTERFACE
+ "${CMAKE_CURRENT_SOURCE_DIR}/include")
+
+include_directories(../ios/src)
+include_directories(../ios/include)
+include_directories(../example/linux)
+
+target_link_libraries(${PLUGIN_NAME} PRIVATE flutter)
+target_link_libraries(${PLUGIN_NAME} PRIVATE PkgConfig::GTK)
+
+add_library(geometry STATIC IMPORTED)
+set_property(TARGET geometry PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libgeometry.a")
+add_library(filament STATIC IMPORTED)
+set_property(TARGET filament PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libfilament.a")
+add_library(backend STATIC IMPORTED)
+set_property(TARGET backend PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libbackend.a")
+add_library(filameshio STATIC IMPORTED)
+set_property(TARGET filameshio PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libfilameshio.a")
+add_library(filament_viewer STATIC IMPORTED)
+set_property(TARGET filament_viewer PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libviewer.a")
+add_library(filamat STATIC IMPORTED)
+set_property(TARGET filamat PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libfilamat.a")
+add_library(utils STATIC IMPORTED)
+set_property(TARGET utils PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libutils.a")
+add_library(filabridge STATIC IMPORTED)
+set_property(TARGET filabridge PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libfilabridge.a")
+add_library(gltfio_core STATIC IMPORTED)
+set_property(TARGET gltfio_core PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libgltfio_core.a")
+add_library(filament-iblprefilter STATIC IMPORTED)
+set_property(TARGET filament-iblprefilter PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libfilament-iblprefilter.a")
+add_library(image STATIC IMPORTED)
+set_property(TARGET image PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libimage.a")
+add_library(camutils STATIC IMPORTED)
+set_property(TARGET camutils PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libcamutils.a")
+add_library(filaflat STATIC IMPORTED)
+set_property(TARGET filaflat PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libfilaflat.a")
+add_library(dracodec STATIC IMPORTED)
+set_property(TARGET dracodec PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libdracodec.a")
+add_library(ibl STATIC IMPORTED)
+set_property(TARGET ibl PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libibl.a")
+add_library(ktxreader STATIC IMPORTED)
+set_property(TARGET ktxreader PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libktxreader.a")
+add_library(imageio STATIC IMPORTED)
+set_property(TARGET imageio PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libimageio.a")
+add_library(tinyexr STATIC IMPORTED)
+set_property(TARGET tinyexr PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libtinyexr.a")
+add_library(stb  STATIC IMPORTED)
+set_property(TARGET stb  PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libstb.a")
+add_library(bluevk STATIC IMPORTED)
+set_property(TARGET bluevk PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libbluevk.a")
+add_library(vkshaders STATIC IMPORTED)
+set_property(TARGET vkshaders PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libvkshaders.a")
+add_library(bluegl STATIC IMPORTED)
+set_property(TARGET bluegl PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libbluegl.a")
+add_library(uberzlib STATIC IMPORTED)
+set_property(TARGET uberzlib PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libuberzlib.a")
+add_library(smol-v STATIC IMPORTED)
+set_property(TARGET smol-v PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libsmol-v.a")
+add_library(uberarchive STATIC IMPORTED)
+set_property(TARGET uberarchive PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libuberarchive.a")
+add_library(meshoptimizer STATIC IMPORTED)
+set_property(TARGET meshoptimizer PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libmeshoptimizer.a")
+add_library(mathio STATIC IMPORTED)
+set_property(TARGET mathio PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libmathio.a")
+add_library(math STATIC IMPORTED)
+set_property(TARGET math PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libmath.a")
+add_library(basis_transcoder STATIC IMPORTED)
+set_property(TARGET basis_transcoder PROPERTY IMPORTED_LOCATION "${CMAKE_CURRENT_SOURCE_DIR}/lib/libbasis_transcoder.a")
+
+target_link_libraries(${PLUGIN_NAME} PRIVATE
+ FILAMENT_SHADERS
+ gltfio_core 
+ filament 
+ backend 
+ geometry 
+ filameshio 
+ filament_viewer 
+ filamat 
+ filabridge 
+ filament-iblprefilter 
+ camutils 
+ filaflat 
+ dracodec 
+ ibl 
+ ktxreader 
+ imageio
+ image
+ utils 
+ tinyexr
+ stb 
+ bluevk 
+ vkshaders 
+ bluegl 
+ uberzlib 
+ smol-v 
+ uberarchive 
+ meshoptimizer
+ mathio
+ math
+ geometry
+ basis_transcoder
+)
+
+# List of absolute paths to libraries that should be bundled with the plugin.
+# This list could contain prebuilt libraries, or libraries created by an
+# external build triggered from this build file.
+set(thermion_flutter_bundled_libraries
+ ""
+ PARENT_SCOPE
+ lib/libgeometry.a
+)

thermion_flutter/thermion_flutter/linux/filament_pb_texture.cc

@@ -0,0 +1,67 @@
+#include <flutter_linux/flutter_linux.h>
+#include <flutter_linux/fl_texture_registrar.h>
+#include <flutter_linux/fl_texture.h>
+#include <flutter_linux/fl_pixel_buffer_texture.h>
+#include <flutter_linux/fl_texture_gl.h>
+#include <gtk/gtk.h>
+#include <sys/utsname.h>
+
+#include <epoxy/gl.h>
+#include "include/thermion_flutter/filament_pb_texture.h"
+
+#include <iostream>
+#include <vector>
+
+// This was just an experiment for copying pixel buffers to Flutter. This won't actually render anything from Filament.
+G_DEFINE_TYPE(FilamentPBTexture,
+              filament_pb_texture,
+              fl_pixel_buffer_texture_get_type())
+
+
+static gboolean video_texture_copy_pixels (FlPixelBufferTexture* texture,
+                               const uint8_t** out_buffer,
+                               uint32_t* width,
+                               uint32_t* height,
+                               GError** error) {
+
+    auto buffer = new std::vector<uint8_t>(width*height*4);
+    for (int i = 0; i < width*height*4; i++)
+    {
+      if(i%4 == 1 || i % 4 == 3) {
+        buffer->at(i) = (uint8_t)255;
+      } else {
+        buffer->at(i) = (uint8_t)0;
+      }
+    }
+  *width = width;
+  *height = height;
+  *out_buffer = buffer->data();
+  std::cout << "COPYING PIXEL BUFFER" << std::endl;
+  return TRUE;
+}
+
+void filament_pb_texture_dispose(GObject* object) {
+    G_OBJECT_CLASS(filament_pb_texture_parent_class)->dispose(object);
+}
+
+void filament_pb_texture_class_init(FilamentPBTextureClass* klass) {
+  G_OBJECT_CLASS(klass)->dispose = filament_pb_texture_dispose;
+  FL_PIXEL_BUFFER_TEXTURE_CLASS(klass)->copy_pixels = video_texture_copy_pixels;
+}
+
+void filament_pb_texture_init(FilamentPBTexture* self) { }
+
+FLUTTER_PLUGIN_EXPORT FlTexture* create_filament_pb_texture(uint32_t width, uint32_t height, FlTextureRegistrar* registrar) {
+
+    auto pbTexture = FILAMENT_PB_TEXTURE(g_object_new(filament_pb_texture_get_type(), nullptr));
+
+    g_autoptr(FlTexture) texture = FL_TEXTURE(pbTexture);
+   
+    if(fl_texture_registrar_register_texture(registrar, texture) == TRUE) { 
+       if(fl_texture_registrar_mark_texture_frame_available(registrar,
+                                                       texture) != TRUE) {
+         std::cout << "FAILED" << std::endl;
+       } 
+    }
+    return texture;
+}

thermion_flutter/thermion_flutter/linux/filament_texture.cc

@@ -0,0 +1,80 @@
+#include <flutter_linux/flutter_linux.h>
+#include <flutter_linux/fl_texture_registrar.h>
+#include <flutter_linux/fl_texture.h>
+#include <flutter_linux/fl_texture_gl.h>
+#include <gtk/gtk.h>
+#include <sys/utsname.h>
+
+#include <epoxy/gl.h>
+#include "include/thermion_flutter/filament_texture.h"
+
+#include <iostream>
+#include <vector>
+
+
+G_DEFINE_TYPE(FilamentTextureGL,
+              filament_texture_gl,
+              fl_texture_gl_get_type())
+
+static gboolean
+filament_texture_populate (FlTextureGL *texture,
+                        uint32_t *target,
+                        uint32_t *name,
+                        uint32_t *width,
+                        uint32_t *height,
+                        GError **error) {
+  FilamentTextureGL *self = FILAMENT_TEXTURE_GL (texture);
+  *target = GL_TEXTURE_2D;
+  *name = self->texture_id;
+  *width = self->width;
+  *height = self->height;
+  return TRUE;
+}
+
+void filament_texture_gl_dispose(GObject* object) {
+  auto filamentTextureGL = FILAMENT_TEXTURE_GL(object);
+  glDeleteTextures(1, &(filamentTextureGL->texture_id));
+  filamentTextureGL->texture_id = 0;
+}
+
+void filament_texture_gl_class_init(FilamentTextureGLClass* klass) {
+  G_OBJECT_CLASS(klass)->dispose = filament_texture_gl_dispose;
+  FL_TEXTURE_GL_CLASS(klass)->populate = filament_texture_populate;
+}
+
+void filament_texture_gl_init(FilamentTextureGL* self) { }
+
+void destroy_filament_texture(FlTexture* texture, FlTextureRegistrar* registrar) { 
+  fl_texture_registrar_unregister_texture(registrar, texture);
+}
+
+FlTexture* create_filament_texture(uint32_t width, uint32_t height, FlTextureRegistrar* registrar) {   
+  auto textureGL = FILAMENT_TEXTURE_GL(g_object_new(filament_texture_gl_get_type(), nullptr));
+  textureGL->width = width;
+  textureGL->height = height;
+  textureGL->registrar = registrar;
+
+  g_autoptr(FlTexture) texture = FL_TEXTURE(textureGL);
+
+  glGenTextures(1, &textureGL->texture_id);
+
+  glBindTexture(GL_TEXTURE_2D, textureGL->texture_id);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+  glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, textureGL->width, textureGL->height, 0, GL_RGBA,
+                  GL_UNSIGNED_BYTE, 0);
+   
+  if(fl_texture_registrar_register_texture(registrar, texture) == TRUE) { 
+
+    if(fl_texture_registrar_mark_texture_frame_available(registrar,
+                                                    texture) != TRUE) {
+      std::cout << "FAILED" << std::endl;
+      return nullptr;
+    } 
+  }
+  return texture;
+}

thermion_flutter/thermion_flutter/linux/include/thermion_flutter/filament_pb_texture.h

@@ -0,0 +1,44 @@
+#ifndef FILAMENT_PB_TEXTURE_H
+#define FILAMENT_PB_TEXTURE_H
+#include <gtk/gtk.h>
+#include <glib-object.h>
+#include <flutter_linux/flutter_linux.h>
+#include <flutter_linux/fl_texture_gl.h>
+#include <flutter_linux/fl_texture.h>
+#include <flutter_linux/fl_pixel_buffer_texture.h>
+#include <flutter_linux/fl_texture_registrar.h>
+
+
+#ifdef FLUTTER_PLUGIN_IMPL
+#define FLUTTER_PLUGIN_EXPORT __attribute__((visibility("default")))
+#else
+#define FLUTTER_PLUGIN_EXPORT
+#endif
+
+
+G_BEGIN_DECLS
+
+#define FILAMENT_PB_TEXTURE(obj) \
+   (G_TYPE_CHECK_INSTANCE_CAST((obj), filament_pb_texture_get_type(), \
+                               FilamentPBTexture))
+
+struct _FilamentPBTexture {
+    FlPixelBufferTexture parent_instance;
+};
+
+typedef struct _FilamentPBTexture FilamentPBTexture;
+typedef struct {
+  FlPixelBufferTextureClass parent_instance;
+  gboolean (*copy_pixels)(FlPixelBufferTexture* texture,
+                          const uint8_t** buffer,
+                          uint32_t* width,
+                          uint32_t* height,
+                          GError** error);
+
+} FilamentPBTextureClass;
+
+G_END_DECLS
+
+FLUTTER_PLUGIN_EXPORT FlTexture* create_filament_pb_texture(uint32_t width, uint32_t height, FlTextureRegistrar* registrar);
+
+#endif 

thermion_flutter/thermion_flutter/linux/include/thermion_flutter/filament_texture.h

@@ -0,0 +1,49 @@
+#ifndef FILAMENT_TEXTURE_H
+#define FILAMENT_TEXTURE_H
+#include <gtk/gtk.h>
+#include <glib-object.h>
+#include <flutter_linux/flutter_linux.h>
+#include <flutter_linux/fl_texture_gl.h>
+#include <flutter_linux/fl_texture.h>
+#include <flutter_linux/fl_texture_registrar.h>
+
+
+#ifdef FLUTTER_PLUGIN_IMPL
+#define FLUTTER_PLUGIN_EXPORT __attribute__((visibility("default")))
+#else
+#define FLUTTER_PLUGIN_EXPORT
+#endif
+
+
+G_BEGIN_DECLS
+
+#define FILAMENT_TEXTURE_GL(obj) \
+   (G_TYPE_CHECK_INSTANCE_CAST((obj), filament_texture_gl_get_type(), \
+                               FilamentTextureGL))
+
+struct _FilamentTextureGL {
+    FlTextureGL parent_instance;
+    GLuint texture_id;
+    uint32_t width;
+    uint32_t height;
+    FlTextureRegistrar* registrar;
+};
+
+typedef struct _FilamentTextureGL FilamentTextureGL;
+typedef struct {
+  FlTextureGLClass parent_instance;
+  gboolean (*populate)(FlTextureGL* texture,
+                       uint32_t* target,
+                       uint32_t* name,
+                       uint32_t* width,
+                       uint32_t* height,
+                       GError** error);
+  GLuint texture_id;
+} FilamentTextureGLClass;
+
+G_END_DECLS
+
+FLUTTER_PLUGIN_EXPORT FlTexture* create_filament_texture(uint32_t width, uint32_t height, FlTextureRegistrar* registrar);
+FLUTTER_PLUGIN_EXPORT void destroy_filament_texture(FlTexture* texture, FlTextureRegistrar* registrar);
+
+#endif 

thermion_flutter/thermion_flutter/linux/include/thermion_flutter/resource_loader.hpp

@@ -0,0 +1,70 @@
+#ifndef FLUTTER_FILAMENT_LINUX_RESOURCE_LOADER_H
+#define FLUTTER_FILAMENT_LINUX_RESOURCE_LOADER_H
+
+#include <math.h>
+#include <iostream>
+#include <fstream>
+#include <cstring>
+#include <vector>
+#include <string> 
+#include <map>
+#include <unistd.h>
+
+#include "ResourceBuffer.hpp"
+
+
+static std::map<uint32_t, void*> _file_assets;
+static uint32_t _i = 0;
+
+ResourceBuffer loadResource(const char* name) {
+
+    std::cout << "LOADING RESOURCE" << std::endl;
+
+    char cwd[PATH_MAX];
+    if (getcwd(cwd, sizeof(cwd)) != NULL) {
+       std::cout << "Current working dir: " << cwd  << std::endl;
+    }
+
+    string name_str(name);
+    auto id = _i++;
+    
+    // this functions accepts URIs, so  
+    // - file:// points to a file on the filesystem
+    // - asset:// points to an asset, usually resolved relative to the current working directory
+    // - no prefix is presumed to be an asset
+    if (name_str.rfind("file://", 0) == 0) {
+      name_str = name_str.substr(7);
+    } else if(name_str.rfind("asset://", 0) == 0) {
+      name_str = name_str.substr(7);
+      name_str = string(cwd) + string("/") + name_str;
+    } else {
+      name_str = string(cwd) + string("/build/linux/x64/debug/bundle/data/flutter_assets/") + name_str;
+    }
+
+    std::cout << "Loading resource at " << name_str.c_str() << std::endl;
+
+    streampos length;
+    ifstream is(name_str, ios::binary);
+    if(!is) {
+      std::cout << "Failed to find resource at file path " << name_str.c_str() << std::endl;
+      return ResourceBuffer(nullptr, 0, -1);
+    }
+    is.seekg (0, ios::end);
+    length = is.tellg();
+    char * buffer;
+    buffer = new char [length];
+    is.seekg (0, ios::beg);
+    is.read (buffer, length);
+    is.close();      
+    _file_assets[id] = buffer;
+    return ResourceBuffer(buffer, length, id);
+}
+
+void freeResource(ResourceBuffer rbuf) {
+  auto it = _file_assets.find(rbuf.id);
+  if (it != _file_assets.end()) {
+    free(it->second);
+  }
+}
+
+#endif

thermion_flutter/thermion_flutter/linux/include/thermion_flutter/thermion_flutter_plugin.h

@@ -0,0 +1,27 @@
+#ifndef FLUTTER_PLUGIN_FLUTTER_FILAMENT_PLUGIN_H_
+#define FLUTTER_PLUGIN_FLUTTER_FILAMENT_PLUGIN_H_
+
+#include <flutter_linux/flutter_linux.h>
+#include <epoxy/gl.h>
+
+G_BEGIN_DECLS
+
+#ifdef FLUTTER_PLUGIN_IMPL
+#define FLUTTER_PLUGIN_EXPORT __attribute__((visibility("default")))
+#else
+#define FLUTTER_PLUGIN_EXPORT
+#endif
+
+typedef struct _ThermionFlutterPlugin ThermionFlutterPlugin;
+typedef struct {
+  GObjectClass parent_class;
+} ThermionFlutterPluginClass;
+
+FLUTTER_PLUGIN_EXPORT GType thermion_flutter_plugin_get_type();
+
+FLUTTER_PLUGIN_EXPORT void thermion_flutter_plugin_register_with_registrar(
+    FlPluginRegistrar* registrar);
+
+G_END_DECLS
+
+#endif  // FLUTTER_PLUGIN_FLUTTER_FILAMENT_PLUGIN_H_

thermion_flutter/thermion_flutter/linux/thermion_flutter_plugin.cc

@@ -0,0 +1,889 @@
+#include "include/thermion_flutter/thermion_flutter_plugin.h"
+
+#include <flutter_linux/flutter_linux.h>
+#include <flutter_linux/fl_texture_registrar.h>
+#include <flutter_linux/fl_texture_gl.h>
+#include <gtk/gtk.h>
+#include <gdk/gdk.h>
+#include <thread>
+#include <sys/utsname.h>
+
+#include <math.h>
+#include <iostream>
+#include <cstring>
+#include <vector>
+#include <string> 
+#include <map>
+#include <unistd.h>
+
+#include "include/thermion_flutter/filament_texture.h"
+#include "include/thermion_flutter/filament_pb_texture.h"
+#include "include/thermion_flutter/resource_loader.hpp"
+
+#include "FilamentViewer.hpp"
+#include "Log.hpp"
+
+extern "C" {
+#include "ThermionFlutterApi.h"
+}
+
+#include <epoxy/gl.h>
+#include <epoxy/glx.h>
+
+#define FLUTTER_FILAMENT_PLUGIN(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj), thermion_flutter_plugin_get_type(), \
+                              ThermionFlutterPlugin))
+
+
+struct _ThermionFlutterPlugin {
+  GObject parent_instance;
+  FlTextureRegistrar* texture_registrar;
+  FlView* fl_view;
+  FlTexture* texture;
+  double width = 0;
+  double height = 0;
+  bool rendering = false;
+  thermion_flutter::FilamentViewer* viewer;
+};
+
+G_DEFINE_TYPE(ThermionFlutterPlugin, thermion_flutter_plugin, g_object_get_type())
+
+static gboolean on_frame_tick(GtkWidget* widget, GdkFrameClock* frame_clock, gpointer self) {
+  ThermionFlutterPlugin* plugin = (ThermionFlutterPlugin*)self;
+  
+ if(plugin->rendering) {
+    render(plugin->viewer, 0);
+    fl_texture_registrar_mark_texture_frame_available(plugin->texture_registrar,
+                                                        plugin->texture);
+  }
+  return TRUE; 
+}
+
+static FlMethodResponse* _create_filament_viewer(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  auto callback = new ResourceLoaderWrapper(loadResource, freeResource);
+
+  FlValue* args = fl_method_call_get_args(method_call);
+
+  const double width = fl_value_get_float(fl_value_get_list_value(args, 0));
+  const double height = fl_value_get_float(fl_value_get_list_value(args, 1));
+
+  self->width = width;
+  self->height = height;
+
+  auto context = glXGetCurrentContext();   
+  self->viewer = (thermion_flutter::FilamentViewer*)create_filament_viewer(
+    (void*)context,
+    callback
+  );
+
+  GtkWidget *w = gtk_widget_get_toplevel (GTK_WIDGET(self->fl_view));
+  gtk_widget_add_tick_callback(w, on_frame_tick, self,NULL);
+
+  // don't pass a surface to the SwapChain as we are effectively creating a headless SwapChain that will render into a RenderTarget associated with a texture
+  create_swap_chain(self->viewer, nullptr, width, height);
+  create_render_target(self->viewer, ((FilamentTextureGL*)self->texture)->texture_id,width,height);   
+  update_viewport_and_camera_projection(self->viewer, width, height, 1.0f); 
+
+  g_autoptr(FlValue) result =   
+         fl_value_new_int(reinterpret_cast<int64_t>(self->viewer));   
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));
+}
+
+static FlMethodResponse* _create_texture(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+   if(self->texture) {
+      Log("Error - create_texture called when texture exists.");
+    } 
+
+    FlValue* args = fl_method_call_get_args(method_call);
+
+    const double width = fl_value_get_float(fl_value_get_list_value(args, 0));
+    const double height = fl_value_get_float(fl_value_get_list_value(args, 1));
+
+    self->width = width;
+    self->height = height;
+
+    auto texture = create_filament_texture(uint32_t(width), uint32_t(height), self->texture_registrar);
+    //auto texture = create_filament_pb_texture(uint32_t(width), uint32_t(height), self->texture_registrar);
+    self->texture = texture;
+
+    g_autoptr(FlValue) result =   
+         fl_value_new_int(reinterpret_cast<int64_t>(texture));   
+
+    Log("Successfully created texture.");
+    
+    return FL_METHOD_RESPONSE(fl_method_success_response_new(result));
+}
+
+
+static FlMethodResponse* _update_viewport_and_camera_projection(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+    FlValue* args = fl_method_call_get_args(method_call);
+
+    auto width = fl_value_get_int(fl_value_get_list_value(args, 0));
+    auto height = fl_value_get_int(fl_value_get_list_value(args, 1));
+    auto scaleFactor = fl_value_get_float(fl_value_get_list_value(args, 2));
+
+    update_viewport_and_camera_projection(self->viewer, width, height, scaleFactor);
+    
+    return FL_METHOD_RESPONSE(fl_method_success_response_new(fl_value_new_bool(true)));
+}
+
+
+static FlMethodResponse* _get_asset_manager(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+    auto assetManager = get_asset_manager(self->viewer);
+    return FL_METHOD_RESPONSE(fl_method_success_response_new(fl_value_new_int(reinterpret_cast<int64_t>(assetManager))));
+}
+
+static FlMethodResponse* _resize(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  
+  const double width = fl_value_get_float(fl_value_get_list_value(args, 0));
+  const double height = fl_value_get_float(fl_value_get_list_value(args, 1));
+
+  destroy_filament_texture(self->texture, self->texture_registrar);
+
+  self->texture = create_filament_texture(uint32_t(width), uint32_t(height), self->texture_registrar);
+
+  create_swap_chain(self->viewer, nullptr, width, height);
+  create_render_target(self->viewer, ((FilamentTextureGL*)self->texture)->texture_id,width,height);
+
+  update_viewport_and_camera_projection(self->viewer, width, height, 1.0f);
+  
+  g_autoptr(FlValue) result =   
+         fl_value_new_int(reinterpret_cast<int64_t>(self->texture));   
+      
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _loadSkybox(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+
+  const gchar* path = fl_value_get_string(args);
+
+  load_skybox(self->viewer, path);
+                                       
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));
+}
+
+static FlMethodResponse* _remove_ibl(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  remove_ibl(self->viewer);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));
+}
+
+static FlMethodResponse* _loadIbl(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+
+  auto path = fl_value_get_string(fl_value_get_list_value(args, 0));
+  auto intensity = fl_value_get_float(fl_value_get_list_value(args, 1));
+
+  load_ibl(self->viewer, path, intensity);
+                                       
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));
+}
+
+static FlMethodResponse* _removeSkybox(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  std::cout << "Removing skybox" << std::endl;
+  remove_skybox(self->viewer);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _set_background_image(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+
+  FlValue* args = fl_method_call_get_args(method_call);
+
+  const gchar* path = fl_value_get_string(args);
+
+  set_background_image(self->viewer, path);
+  
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _set_background_color(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  const float r = fl_value_get_float(fl_value_get_list_value(args, 0));
+  const float g = fl_value_get_float(fl_value_get_list_value(args, 1));
+  const float b = fl_value_get_float(fl_value_get_list_value(args, 2));
+  const float a = fl_value_get_float(fl_value_get_list_value(args, 3));
+  set_background_color(self->viewer, r,g,b,a);
+  
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _add_light(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+
+  FlValue* args = fl_method_call_get_args(method_call);
+  
+  auto type = (uint8_t)fl_value_get_int(fl_value_get_list_value(args, 0));
+  auto color = (float)fl_value_get_float(fl_value_get_list_value(args, 1));
+  auto intensity = float(fl_value_get_float(fl_value_get_list_value(args, 2)));
+  auto posX = (float)fl_value_get_float(fl_value_get_list_value(args, 3));
+  auto posY = (float)fl_value_get_float(fl_value_get_list_value(args, 4));
+  auto posZ = (float)fl_value_get_float(fl_value_get_list_value(args, 5));
+  auto dirX = (float)fl_value_get_float(fl_value_get_list_value(args, 6));
+  auto dirY = (float)fl_value_get_float(fl_value_get_list_value(args, 7));
+  auto dirZ = (float)fl_value_get_float(fl_value_get_list_value(args, 8));
+  auto shadows = fl_value_get_bool(fl_value_get_list_value(args, 9));
+
+  auto entityId = add_light(self->viewer, type, color, intensity, posX, posY, posZ, dirX, dirY, dirZ, shadows);
+  g_autoptr(FlValue) result = fl_value_new_int(entityId);
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+
+}
+
+static FlMethodResponse* _load_glb(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+    FlValue* args = fl_method_call_get_args(method_call);
+    auto assetManager = (void*)fl_value_get_int(fl_value_get_list_value(args, 0));
+    auto path = fl_value_get_string(fl_value_get_list_value(args, 1));
+    auto unlit = fl_value_get_bool(fl_value_get_list_value(args, 2));
+    auto entityId = load_glb(assetManager, path, unlit);
+    g_autoptr(FlValue) result = fl_value_new_int((int64_t)entityId);
+    return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _get_animation_names(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto assetManager = (void*)fl_value_get_int(fl_value_get_list_value(args, 0));
+  auto asset = (EntityId)fl_value_get_int(fl_value_get_list_value(args, 1));
+  g_autoptr(FlValue) result = fl_value_new_list();
+
+  auto numNames = get_animation_count(assetManager, asset);
+
+  for(int i = 0; i < numNames; i++) {
+    gchar out[255];
+    get_animation_name(assetManager, asset, out, i);
+    fl_value_append_take (result, fl_value_new_string (out));
+  }
+      
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _remove_asset(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto asset = (EntityId)fl_value_get_int(fl_value_get_list_value(args, 1));
+  remove_asset(self->viewer, asset);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _transform_to_unit_cube(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto assetManager = (void*)fl_value_get_int(fl_value_get_list_value(args, 0));
+  auto asset = (EntityId)fl_value_get_int(fl_value_get_list_value(args, 1));
+  transform_to_unit_cube(assetManager, asset);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _rotate_start(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  
+  auto x = (float)fl_value_get_float(fl_value_get_list_value(args, 0));
+  auto y = (float)fl_value_get_float(fl_value_get_list_value(args, 1));
+
+  grab_begin(self->viewer, x,y, false);
+
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _rotate_end(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  grab_end(self->viewer);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _rotate_update(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto x = (float)fl_value_get_float(fl_value_get_list_value(args, 0));
+  auto y = (float)fl_value_get_float(fl_value_get_list_value(args, 1));
+
+  grab_update(self->viewer, x,y);
+
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _pan_start(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+
+  FlValue* args = fl_method_call_get_args(method_call);
+
+  auto x = (float)fl_value_get_float(fl_value_get_list_value(args, 0));
+  auto y = (float)fl_value_get_float(fl_value_get_list_value(args, 1));
+
+  grab_begin(self->viewer, x,y, true);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _pan_update(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto x = (float)fl_value_get_float(fl_value_get_list_value(args, 0));
+  auto y = (float)fl_value_get_float(fl_value_get_list_value(args, 1));
+
+  grab_update(self->viewer, x,y);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _pan_end(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  grab_end(self->viewer);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _set_position(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto assetManager = (void*)fl_value_get_int(fl_value_get_list_value(args, 0));
+  auto asset = (EntityId)fl_value_get_int(fl_value_get_list_value(args, 1));
+
+  set_position(
+    assetManager,
+    asset, 
+    (float)fl_value_get_float(fl_value_get_list_value(args, 2)), // x
+    (float)fl_value_get_float(fl_value_get_list_value(args, 3)), // y
+    (float)fl_value_get_float(fl_value_get_list_value(args, 4)) // z
+  );
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _set_rotation(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto assetManager = (void*)fl_value_get_int(fl_value_get_list_value(args, 0));
+
+  auto asset = (EntityId)fl_value_get_int(fl_value_get_list_value(args, 1));
+
+  set_rotation(
+    assetManager,
+    asset, 
+    (float)fl_value_get_float(fl_value_get_list_value(args, 2)), // rads
+    (float)fl_value_get_float(fl_value_get_list_value(args, 3)), // x
+    (float)fl_value_get_float(fl_value_get_list_value(args, 4)), // y
+  (float)fl_value_get_float(fl_value_get_list_value(args, 5 )) // z
+  );
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+
+
+static FlMethodResponse* _set_bone_transform(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+   throw std::invalid_argument( "received negative value" );
+  // FlValue* args = fl_method_call_get_args(method_call);
+  // auto assetPtr = (void*)fl_value_get_int(fl_value_get_list_value(args, 0));
+  // auto boneName = fl_value_get_string(fl_value_get_list_value(args, 1));
+  // auto meshName = fl_value_get_string(fl_value_get_list_value(args, 2));
+
+  // set_bone_transform(
+  //   assetPtr, 
+  //   boneName,
+  //   meshName,
+  //   (float)fl_value_get_float(fl_value_get_list_value(args, 3)), // transX
+  //   (float)fl_value_get_float(fl_value_get_list_value(args, 4)), // transY
+  //   (float)fl_value_get_float(fl_value_get_list_value(args, 5)), // transZ
+  //   (float)fl_value_get_float(fl_value_get_list_value(args, 6)), // quatX
+  //   (float)fl_value_get_float(fl_value_get_list_value(args, 7)), // quatY
+  //   (float)fl_value_get_float(fl_value_get_list_value(args, 8)), // quatZ
+  //   (float)fl_value_get_float(fl_value_get_list_value(args, 9)) // quatW
+  // );
+  // g_autoptr(FlValue) result = fl_value_new_string("OK");
+  // return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _set_camera(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto asset = (EntityId)fl_value_get_int(fl_value_get_list_value(args, 0));
+  auto cameraName = fl_value_get_string(fl_value_get_list_value(args, 1)) ;
+  
+  set_camera(self->viewer, asset, cameraName);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _set_camera_model_matrix(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  set_camera_model_matrix(self->viewer, fl_value_get_float32_list(args));
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _set_camera_exposure(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto aperture = (float)fl_value_get_float(fl_value_get_list_value(args, 0));
+  auto shutter_speed = (float)fl_value_get_float(fl_value_get_list_value(args, 1));
+  auto sensitivity = (float)fl_value_get_float(fl_value_get_list_value(args, 2));
+  set_camera_exposure(self->viewer, aperture, shutter_speed, sensitivity);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _set_camera_position(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto x = (float)fl_value_get_float(fl_value_get_list_value(args, 0));
+  auto y = (float)fl_value_get_float(fl_value_get_list_value(args, 1));
+  auto z = (float)fl_value_get_float(fl_value_get_list_value(args, 2));
+  set_camera_position(self->viewer, x,y, z);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _set_camera_rotation(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto rads = (float)fl_value_get_float(fl_value_get_list_value(args,0 ));
+  auto x = (float)fl_value_get_float(fl_value_get_list_value(args, 1));
+  auto y = (float)fl_value_get_float(fl_value_get_list_value(args, 2));
+  auto z = (float)fl_value_get_float(fl_value_get_list_value(args, 3));
+  
+  set_camera_rotation(self->viewer, rads, x,y, z);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _set_rendering(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  self->rendering = (bool)fl_value_get_bool(args);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _set_frame_interval(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto val = (float) fl_value_get_float(args);
+  set_frame_interval(self->viewer, val);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _grab_begin(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto x = (float)fl_value_get_float(fl_value_get_list_value(args, 0));
+  auto y = (float)fl_value_get_float(fl_value_get_list_value(args, 1));
+  auto pan = (bool)fl_value_get_bool(fl_value_get_list_value(args, 2));
+  grab_begin(self->viewer, x, y, pan);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _grab_end(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  grab_end(self->viewer);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _grab_update(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto x = (float)fl_value_get_float(fl_value_get_list_value(args, 0));
+  auto y = (float)fl_value_get_float(fl_value_get_list_value(args, 1));
+  
+  grab_update(self->viewer, x,y);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _scroll_begin(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  scroll_begin(self->viewer);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _scroll_end(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  scroll_end(self->viewer);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _scroll_update(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto x = (float)fl_value_get_float(fl_value_get_list_value(args, 0));
+  auto y = (float)fl_value_get_float(fl_value_get_list_value(args, 1));
+  auto z = (float)fl_value_get_float(fl_value_get_list_value(args, 2));
+  
+  scroll_update(self->viewer, x,y, z);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _play_animation(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto assetManager = (void*)fl_value_get_int(fl_value_get_list_value(args, 0));
+  auto asset = (EntityId)fl_value_get_int(fl_value_get_list_value(args, 1));
+  auto animationId = (int)fl_value_get_int(fl_value_get_list_value(args, 2));  
+  auto loop = (bool)fl_value_get_bool(fl_value_get_list_value(args, 3));  
+  auto reverse = (bool)fl_value_get_bool(fl_value_get_list_value(args, 4));  
+  auto replaceActive = (bool)fl_value_get_bool(fl_value_get_list_value(args, 5));  
+  auto crossfade = (bool)fl_value_get_float(fl_value_get_list_value(args, 6));  
+  play_animation(assetManager, asset, animationId, loop, reverse, replaceActive, crossfade);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+
+static FlMethodResponse* _stop_animation(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto assetManager = (void*)fl_value_get_int(fl_value_get_list_value(args, 0));
+  auto asset = (EntityId)fl_value_get_int(fl_value_get_list_value(args, 1));
+  auto animationId = (int)fl_value_get_int(fl_value_get_list_value(args, 2));  
+  stop_animation(assetManager, asset, animationId);
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+
+static FlMethodResponse* _set_morph_target_weights(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto assetManager = (void*)fl_value_get_int(fl_value_get_list_value(args, 0));
+  auto asset = (EntityId)fl_value_get_int(fl_value_get_list_value(args, 1));
+  auto entityName = fl_value_get_string(fl_value_get_list_value(args, 2));
+  auto flWeights = fl_value_get_list_value(args, 3);
+  size_t numWeights = fl_value_get_length(flWeights);
+
+  std::vector<float> weights(numWeights);
+  for(int i =0; i < numWeights; i++) {
+      float val = fl_value_get_float(fl_value_get_list_value(flWeights, i));
+      weights[i] = val;
+  }
+    
+  set_morph_target_weights(assetManager, asset, entityName, weights.data(), (int)numWeights);
+  
+  g_autoptr(FlValue) result = fl_value_new_string("OK");
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+template class std::vector<int>;
+
+static FlMethodResponse* _set_morph_animation(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto assetManager = (void*)fl_value_get_int(fl_value_get_list_value(args, 0));
+  auto asset = (EntityId)fl_value_get_int(fl_value_get_list_value(args, 1));
+  auto entityName = fl_value_get_string(fl_value_get_list_value(args, 2));
+  
+  auto morphDataList = fl_value_get_list_value(args, 3);
+  auto morphDataListLength = fl_value_get_length(morphDataList);
+  auto morphData = std::vector<float>(morphDataListLength);
+  
+  for(int i =0; i < morphDataListLength; i++) {
+    morphData[i] = fl_value_get_float(fl_value_get_list_value(morphDataList, i));
+  }
+
+  auto morphIndicesList = fl_value_get_list_value(args, 4);
+  auto morphIndicesListLength =  fl_value_get_length(morphIndicesList);
+  auto indices = std::vector<int32_t>(morphIndicesListLength);
+  
+  for(int i =0; i < morphIndicesListLength; i++) {
+    FlValue* flMorphIndex = fl_value_get_list_value(morphIndicesList, i);
+    indices[i] = static_cast<int32_t>(fl_value_get_int(flMorphIndex));
+  }
+  
+  int64_t numMorphTargets = fl_value_get_int(fl_value_get_list_value(args, 5));
+  int64_t numFrames = fl_value_get_int(fl_value_get_list_value(args, 6));
+  float frameLengthInMs = fl_value_get_float(fl_value_get_list_value(args, 7));
+
+  bool success = set_morph_animation(
+      assetManager, 
+      asset, 
+      (const char *const)entityName, 
+      (const float *const)morphData.data(), 
+      (const int* const)indices.data(), 
+      static_cast<int>(numMorphTargets), 
+      static_cast<int>(numFrames), 
+      frameLengthInMs
+  );  
+  g_autoptr(FlValue) result = fl_value_new_bool(success);
+
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _set_animation(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+   throw std::invalid_argument( "received negative value" );
+  // FlValue* args = fl_method_call_get_args(method_call);
+  // auto assetPtr = (void*)fl_value_get_int(fl_value_get_list_value(args, 0));
+
+  // const char* entityName = fl_value_get_string(fl_value_get_list_value(args, 1));  
+  
+  // float* const morphData = (float* const) fl_value_get_float32_list(fl_value_get_list_value(args, 2));  
+  
+  // int64_t numMorphWeights = fl_value_get_int(fl_value_get_list_value(args, 3));
+
+  // FlValue* flBoneAnimations = fl_value_get_list_value(args, 4);
+
+  // size_t numBoneAnimations = fl_value_get_length(flBoneAnimations);
+
+  // vector<BoneAnimation> boneAnimations;
+
+  // for(int i = 0; i < numBoneAnimations; i++) {  
+    
+  //   FlValue* flBoneAnimation = fl_value_get_list_value(flBoneAnimations, i);
+
+  //   FlValue* flBoneNames = fl_value_get_list_value(flBoneAnimation, 0);  
+  //   FlValue* flMeshNames = fl_value_get_list_value(flBoneAnimation, 1);  
+  //   float* const frameData = (float* const) fl_value_get_float32_list(fl_value_get_list_value(flBoneAnimation, 2));  
+
+  //   Log("Framedata %f", frameData);
+
+  //   vector<const char*> boneNames;
+  //   boneNames.resize(fl_value_get_length(flBoneNames));
+
+  //   for(int i=0; i < boneNames.size(); i++) {
+  //     boneNames[i] = fl_value_get_string(fl_value_get_list_value(flBoneNames, i)) ;
+  //   }
+
+  //   vector<const char*> meshNames;
+  //   meshNames.resize(fl_value_get_length(flMeshNames));
+  //   for(int i=0; i < meshNames.size(); i++) {
+  //     meshNames[i] = fl_value_get_string(fl_value_get_list_value(flMeshNames, i));
+  //   }
+  
+  //   const char** boneNamesPtr = (const char**)malloc(boneNames.size() * sizeof(char*));
+  //   memcpy((void*)boneNamesPtr, (void*)boneNames.data(), boneNames.size() * sizeof(char*));
+  //   auto meshNamesPtr = (const char**)malloc(meshNames.size() * sizeof(char*));
+  //   memcpy((void*)meshNamesPtr, (void*)meshNames.data(), meshNames.size() * sizeof(char*));
+
+  //   BoneAnimation animation {
+  //     .boneNames = boneNamesPtr,
+  //     .meshNames = meshNamesPtr,
+  //     .data = frameData,
+  //     .numBones = boneNames.size(),
+  //     .numMeshTargets = meshNames.size()
+  //   };
+
+  //   boneAnimations.push_back(animation);
+
+  // }
+
+  // int64_t numFrames = fl_value_get_int(fl_value_get_list_value(args, 5));
+  
+  // float frameLengthInMs = fl_value_get_float(fl_value_get_list_value(args, 6));
+
+  // auto boneAnimationsPointer = boneAnimations.data();
+  // auto boneAnimationsSize = boneAnimations.size();
+  
+  // set_animation(
+  //   assetPtr, 
+  //   entityName,
+  //   morphData, 
+  //   numMorphWeights, 
+  //   boneAnimationsPointer,
+  //   boneAnimationsSize,
+  //   numFrames, 
+  //   frameLengthInMs);
+
+  // g_autoptr(FlValue) result = fl_value_new_string("OK");
+  // return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _get_morph_target_names(ThermionFlutterPlugin* self, FlMethodCall* method_call) { 
+  FlValue* args = fl_method_call_get_args(method_call);
+  auto assetManager = (void*)fl_value_get_int(fl_value_get_list_value(args, 0));
+  auto asset = (EntityId)fl_value_get_int(fl_value_get_list_value(args, 1));
+  auto meshName = fl_value_get_string(fl_value_get_list_value(args, 2));
+  
+  g_autoptr(FlValue) result = fl_value_new_list();
+
+  auto numNames = get_morph_target_name_count(assetManager, asset, meshName);
+
+  for(int i = 0; i < numNames; i++) {
+    gchar out[255];
+    get_morph_target_name(assetManager, asset, meshName, out, i);
+    fl_value_append_take (result, fl_value_new_string (out));
+  }
+      
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+}
+
+static FlMethodResponse* _set_tone_mapping(ThermionFlutterPlugin* self, FlMethodCall* method_call) {
+  FlValue* args = fl_method_call_get_args(method_call);
+  thermion_flutter::ToneMapping toneMapping = static_cast<thermion_flutter::ToneMapping>(fl_value_get_int(args)); 
+  set_tone_mapping(self->viewer, toneMapping);
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(fl_value_new_bool(true)));      
+}
+
+static FlMethodResponse* _set_bloom(ThermionFlutterPlugin* self, FlMethodCall* method_call) {
+  FlValue* args = fl_method_call_get_args(method_call);
+  set_bloom(self->viewer, fl_value_get_float(args));
+  return FL_METHOD_RESPONSE(fl_method_success_response_new(fl_value_new_bool(true)));      
+}
+
+// Called when a method call is received from Flutter.
+static void thermion_flutter_plugin_handle_method_call(
+    ThermionFlutterPlugin* self,
+    FlMethodCall* method_call) {
+
+  g_autoptr(FlMethodResponse) response = nullptr;
+
+  const gchar* method = fl_method_call_get_name(method_call);
+
+  if(strcmp(method, "createFilamentViewer") == 0) {
+    response = _create_filament_viewer(self, method_call);
+  } else if(strcmp(method, "createTexture") == 0) {
+    response = _create_texture(self, method_call);    
+  } else if(strcmp(method, "updateViewportAndCameraProjection")==0){ 
+    response = _update_viewport_and_camera_projection(self, method_call);
+  } else if(strcmp(method, "getAssetManager") ==0){ 
+    response = _get_asset_manager(self, method_call);
+  } else if(strcmp(method, "setToneMapping") == 0) {
+    response = _set_tone_mapping(self, method_call);
+  } else if(strcmp(method, "setBloom") == 0) {
+    response = _set_bloom(self, method_call);
+  } else if(strcmp(method, "resize") == 0) {
+    response = _resize(self, method_call);
+  } else if(strcmp(method, "getContext") == 0) {
+    g_autoptr(FlValue) result =   
+         fl_value_new_int(reinterpret_cast<int64_t>(glXGetCurrentContext()));   
+    response = FL_METHOD_RESPONSE(fl_method_success_response_new(result));
+  } else if(strcmp(method, "getGlTextureId") == 0) {
+    g_autoptr(FlValue) result =   
+         fl_value_new_int(reinterpret_cast<unsigned int>(((FilamentTextureGL*)self->texture)->texture_id));   
+    response = FL_METHOD_RESPONSE(fl_method_success_response_new(result));
+  } else if(strcmp(method, "getResourceLoader") == 0) {
+    ResourceLoaderWrapper* resourceLoader = new ResourceLoaderWrapper(loadResource, freeResource);
+    g_autoptr(FlValue) result =   
+         fl_value_new_int(reinterpret_cast<int64_t>(resourceLoader));   
+    response = FL_METHOD_RESPONSE(fl_method_success_response_new(result));
+  } else if(strcmp(method, "setRendering") == 0) {
+    self->rendering =  fl_value_get_bool(fl_method_call_get_args(method_call));
+    response = FL_METHOD_RESPONSE(fl_method_success_response_new(fl_value_new_string("OK")));
+  } else if(strcmp(method, "loadSkybox") == 0) {
+    response = _loadSkybox(self, method_call);
+  } else if(strcmp(method, "loadIbl") == 0) {
+    response = _loadIbl(self, method_call);
+  } else if(strcmp(method, "removeIbl") ==0) { 
+    response = _remove_ibl(self, method_call);
+  } else if(strcmp(method, "removeSkybox") == 0) {
+    response = _removeSkybox(self, method_call);    
+  } else if(strcmp(method, "render") == 0) {
+    render(self->viewer, 0);
+    g_autoptr(FlValue) result = fl_value_new_string("OK");
+    response = FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+  } else if(strcmp(method, "setBackgroundColor") == 0) {
+    response = _set_background_color(self, method_call);
+  } else if(strcmp(method, "setBackgroundImage") == 0) {
+    response = _set_background_image(self, method_call);
+  } else if(strcmp(method, "addLight") == 0) {
+    response = _add_light(self, method_call);  
+  } else if(strcmp(method, "loadGlb") == 0) {
+    response = _load_glb(self, method_call);
+  } else if(strcmp(method, "getAnimationNames") == 0) {
+    response = _get_animation_names(self, method_call);
+  } else if(strcmp(method, "clearAssets") == 0) {
+    clear_assets(self->viewer);
+    g_autoptr(FlValue) result = fl_value_new_string("OK");
+    response = FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+  } else if(strcmp(method, "removeAsset") == 0) {
+    response = _remove_asset(self, method_call);
+  } else if(strcmp(method, "transformToUnitCube") == 0) {
+    response = _transform_to_unit_cube(self, method_call);
+  } else if(strcmp(method, "clearLights") == 0) {
+    clear_lights(self->viewer);
+    g_autoptr(FlValue) result = fl_value_new_string("OK");
+    response = FL_METHOD_RESPONSE(fl_method_success_response_new(result));    
+  } else if(strcmp(method, "panStart") == 0) {
+    response = _pan_start(self, method_call);
+  } else if(strcmp(method, "panEnd") == 0) {
+    response = _pan_end(self, method_call);
+  } else if(strcmp(method, "panUpdate") == 0) {
+    response = _pan_update(self, method_call);
+  } else if(strcmp(method, "rotateStart") == 0) {
+    response = _rotate_start(self, method_call);
+  } else if(strcmp(method, "rotateEnd") == 0) {
+    response = _rotate_end(self, method_call);
+  } else if(strcmp(method, "rotateUpdate") == 0) {
+    response = _rotate_update(self, method_call);
+  } else if(strcmp(method, "setRotation") == 0) {
+    response = _set_rotation(self, method_call);
+  } else if(strcmp(method, "setCamera") == 0) {
+    response = _set_camera(self, method_call);
+  } else if(strcmp(method, "setCameraModelMatrix") == 0) {
+    response = _set_camera_model_matrix(self, method_call);
+  } else if(strcmp(method, "setCameraExposure") == 0) {
+    response = _set_camera_exposure(self, method_call);
+  } else if(strcmp(method, "setCameraPosition") == 0) {
+    response = _set_camera_position(self, method_call);
+  } else if(strcmp(method, "setCameraRotation") == 0) {
+    response = _set_camera_rotation(self, method_call);
+  } else if(strcmp(method, "setFrameInterval") == 0) {
+    response = _set_frame_interval(self, method_call);
+  } else if(strcmp(method, "scrollBegin") == 0) {
+    response = _scroll_begin(self, method_call);
+  } else if(strcmp(method, "scrollEnd") == 0) {
+    response = _scroll_end(self, method_call);
+  } else if(strcmp(method, "scrollUpdate") == 0) {
+    response = _scroll_update(self, method_call);
+  } else if(strcmp(method, "grabBegin") == 0) {
+    response = _grab_begin(self, method_call);
+  } else if(strcmp(method, "grabEnd") == 0) {
+    response = _grab_end(self, method_call);
+  } else if(strcmp(method, "grabUpdate") == 0) {
+    response = _grab_update(self, method_call);
+  } else if(strcmp(method, "playAnimation") == 0) {
+    response = _play_animation(self, method_call);
+  } else if(strcmp(method, "stopAnimation") == 0) {
+    response = _stop_animation(self, method_call);
+  } else if(strcmp(method, "setMorphTargetWeights") == 0) {
+    response = _set_morph_target_weights(self, method_call);
+  } else if(strcmp(method, "setMorphAnimation") == 0) {
+    response = _set_morph_animation(self, method_call);
+  } else if(strcmp(method, "getMorphTargetNames") == 0) {
+    response = _get_morph_target_names(self, method_call);
+  } else if(strcmp(method, "setPosition") == 0) {
+    response = _set_position(self, method_call);
+  } else if(strcmp(method, "setBoneTransform") == 0) {
+    response = _set_bone_transform(self, method_call);
+  } else {
+    response = FL_METHOD_RESPONSE(fl_method_not_implemented_response_new());
+  }
+
+  fl_method_call_respond(method_call, response, nullptr);
+
+}
+
+static void thermion_flutter_plugin_dispose(GObject* object) {
+  G_OBJECT_CLASS(thermion_flutter_plugin_parent_class)->dispose(object);
+}
+
+static void thermion_flutter_plugin_class_init(ThermionFlutterPluginClass* klass) {
+  G_OBJECT_CLASS(klass)->dispose = thermion_flutter_plugin_dispose;
+}
+
+static void thermion_flutter_plugin_init(ThermionFlutterPlugin* self) {}
+
+static void method_call_cb(FlMethodChannel* channel, FlMethodCall* method_call,
+                           gpointer user_data) {
+  ThermionFlutterPlugin* plugin = FLUTTER_FILAMENT_PLUGIN(user_data);
+  thermion_flutter_plugin_handle_method_call(plugin, method_call);
+}
+
+void thermion_flutter_plugin_register_with_registrar(FlPluginRegistrar* registrar) {
+  ThermionFlutterPlugin* plugin = FLUTTER_FILAMENT_PLUGIN(
+      g_object_new(thermion_flutter_plugin_get_type(), nullptr));
+
+  FlView* fl_view = fl_plugin_registrar_get_view(registrar);
+  plugin->fl_view = fl_view;
+
+  plugin->texture_registrar =
+      fl_plugin_registrar_get_texture_registrar(registrar);
+
+  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
+  g_autoptr(FlMethodChannel) channel =
+      fl_method_channel_new(fl_plugin_registrar_get_messenger(registrar),
+                            "app.polyvox.filament/event",
+                            FL_METHOD_CODEC(codec));
+  fl_method_channel_set_method_call_handler(channel, method_call_cb,
+                                            g_object_ref(plugin),
+                                            g_object_unref);
+
+  g_object_unref(plugin);
+}
+
+
+
+
+
+
+
+  

thermion_flutter/thermion_flutter/linux/thermion_flutter_plugin_private.h

@@ -0,0 +1,10 @@
+#include <flutter_linux/flutter_linux.h>
+
+#include "include/thermion_flutter/thermion_flutter_plugin.h"
+
+// This file exposes some plugin internals for unit testing. See
+// https://github.com/flutter/flutter/issues/88724 for current limitations
+// in the unit-testable API.
+
+// Handles the getPlatformVersion method call.
+FlMethodResponse *get_platform_version();