fix Windows build.dart to avoid native_assets fork; add implementations for ThermionFlutterWindows

thermion_flutter/thermion_flutter/lib/src/widgets/src/thermion_widget.dart

@@ -95,7 +95,7 @@ class _ThermionWidgetState extends State<ThermionWidget> {
     }
 
     if (Platform.isWindows) {
-      return ThermionWidgetWindows(viewer: widget.viewer);
+      return ThermionWidgetWindows(viewer: widget.viewer, view: view!, initial: widget.initial, onResize: widget.onResize);
     }
 
     return ThermionTextureWidget(

thermion_flutter/thermion_flutter/lib/src/widgets/src/thermion_widget_windows.dart

@@ -1,14 +1,158 @@
+import 'dart:async';
+
+import 'package:flutter/material.dart';
 import 'package:flutter/widgets.dart';
-import 'package:thermion_flutter/thermion_flutter.dart';
+import 'package:thermion_flutter/src/widgets/src/resize_observer.dart';
+import 'package:thermion_flutter/src/widgets/src/transparent_filament_widget.dart';
+import 'package:thermion_flutter/thermion_flutter.dart' as t;
+import 'package:thermion_flutter_platform_interface/thermion_flutter_window.dart';
 
-class ThermionWidgetWindows extends StatelessWidget {
+class ThermionWidgetWindows extends StatefulWidget {
   
-  final ThermionViewer viewer;
+  final t.ThermionViewer viewer;
+
+  final t.View view;
+
+  ///
+  ///
+  ///
+  final Widget? initial;
+
+  ///
+  /// A callback that will be invoked whenever this widget (and the underlying texture is resized).
+  ///
+  final Future Function(Size size, t.View view, double pixelRatio)? onResize;
+
+  const ThermionWidgetWindows({super.key, required this.viewer, this.initial, this.onResize, required this.view});
+  
+  
+  @override
+  State<StatefulWidget> createState() => _ThermionWidgetWindowsState();
+}
+
+class _ThermionWidgetWindowsState extends State<ThermionWidgetWindows> {
+
+  ThermionFlutterWindow? _window;
+
+  @override
+  void initState() {
+    super.initState();
+
+     WidgetsBinding.instance.addPostFrameCallback((timeStamp) async {
+      await widget.viewer.initialized;
+
+      var dpr = MediaQuery.of(context).devicePixelRatio;
+
+      var size = ((context.findRenderObject()) as RenderBox).size;
+      var width = (size.width * dpr).ceil();
+      var height = (size.height * dpr).ceil();
+
+      _window = await t.ThermionFlutterPlatform.instance.createWindow(width, height, 0, 0);
+
+      await widget.view.updateViewport(_window!.width, _window!.height);
+
+      try {
+        await widget.onResize?.call(
+            Size(_window!.width.toDouble(), _window!.height.toDouble()),
+            widget.view,
+            dpr);
+      } catch (err, st) {
+        print(err);
+        print(st);
+      }
+
+      if (mounted) {
+        setState(() {});
+      }
+
+      _requestFrame();
+
+      widget.viewer.onDispose(() async {
+        var window = _window;
+        if (mounted) {
+          setState(() {});
+        }
+        await window?.destroy();
+      });
+    });
+  }
+
+  bool _rendering = false;
+
+  void _requestFrame() {
+    WidgetsBinding.instance.scheduleFrameCallback((d) async {
+      if (widget.viewer.rendering && !_rendering) {
+        _rendering = true;
+        await widget.viewer.requestFrame();
+        _rendering = false;
+      }
+      _requestFrame();
+    });
+  }
+
+  final _resizing = <Future>[];
+
+  Timer? _resizeTimer;
+
+  Future _resize(Size oldSize, Size newSize) async {
+    await Future.wait(_resizing);
+
+    _resizeTimer?.cancel();
+
+    _resizeTimer = Timer(const Duration(milliseconds: 100), () async {
+      await Future.wait(_resizing);
+      if (!mounted) {
+        return;
+      }
+
+      if (newSize.width == _window?.width &&
+          newSize.height == _window?.height) {
+        return;
+      }
+
+      final completer = Completer();
+
+      _resizing.add(completer.future);
+
+      final dpr = MediaQuery.of(context).devicePixelRatio;
+
+      newSize *= dpr;
+
+      var newWidth = newSize.width.ceil();
+      var newHeight = newSize.height.ceil();
+
+      await _window?.resize(
+        newWidth,
+        newHeight,
+        0,
+        0,
+      );
+
+      await widget.view.updateViewport(_window!.width, _window!.height);
+
+      await widget.onResize?.call(
+          Size(_window!.width.toDouble(), _window!.height.toDouble()),
+          widget.view,
+          dpr);
+
+      if (!mounted) {
+        return;
+      }
+      setState(() {});
+      completer.complete();
+      _resizing.remove(completer.future);
+    });
+  }
 
-  const ThermionWidgetWindows({super.key, required this.viewer});
   @override
   Widget build(BuildContext context) {
-    // TODO: implement build
-    throw UnimplementedError();
+    if (_window == null) {
+      return widget.initial ?? Container(color: Colors.red);
+    }
+
+    return ResizeObserver(
+        onResized: _resize,
+        child: CustomPaint(painter:TransparencyPainter()));
   }
+
 }

thermion_flutter/thermion_flutter/pubspec.yaml

@@ -23,7 +23,13 @@ dependencies:
   thermion_flutter_web: ^0.1.0+7
   logging: ^1.2.0
   web: ^1.0.0
-
+dependency_overrides:
+  thermion_dart:
+    path: ../../thermion_dart
+  thermion_flutter_platform_interface:
+    path: ../thermion_flutter_platform_interface
+  thermion_flutter_ffi:
+    path: ../thermion_flutter_ffi
 dev_dependencies:
   flutter_test:
     sdk: flutter

thermion_flutter/thermion_flutter/windows/backing_window.cpp

@@ -152,8 +152,20 @@ LRESULT CALLBACK FilamentWindowProc(HWND const window, UINT const message,
     break;
   }
   case WM_ERASEBKGND: {
-    // Prevent erasing of |window| when it is unfocused and minimized or
-    // moved out of screen etc.
+      HDC hdc = (HDC)wparam;
+      RECT rect;
+      GetClientRect(window, &rect);
+      
+      // Get the BackingWindow instance associated with this window
+      BackingWindow* backing_window = reinterpret_cast<BackingWindow*>(
+          GetWindowLongPtr(window, GWLP_USERDATA));
+      
+      if (backing_window) {
+        HBRUSH brush = CreateSolidBrush(RGB(0, 255, 0));
+        FillRect(hdc, &rect, brush);
+        DeleteObject(brush);
+      }
+    
     break;
   }
   case WM_SIZE:
@@ -346,8 +358,6 @@ void BackingWindow::Resize(int width, int height, int left, int top) {
   _top = top;
   RECT flutterViewRect;
   ::GetWindowRect(_flutterViewWindow, &flutterViewRect);
-    std::cout << "Resizing to " << _width << " x " << _height << " with LT" << _left << " " << _top << " flutter view rect" << flutterViewRect.left << " " << flutterViewRect.top  << " " << flutterViewRect.right << " " << flutterViewRect.bottom << std::endl;
-
   ::SetWindowPos(_windowHandle, _flutterRootWindow, flutterViewRect.left + _left,
                  flutterViewRect.top + _top, _width, _height,
                  SWP_NOACTIVATE);

thermion_flutter/thermion_flutter/windows/thermion_flutter_plugin.cpp

@@ -172,8 +172,6 @@ void ThermionFlutterPlugin::CreateTexture(
   auto height = (uint32_t)round(dHeight );
   auto left = (uint32_t)round(dLeft );
   auto top = (uint32_t)round(dTop );
-
-  std::cout << "Using " << width << "x" << height << std::endl;
   
   // create a single shared context for the life of the application
   // this will be used to create a backing texture and passed to Filament
@@ -182,8 +180,10 @@ void ThermionFlutterPlugin::CreateTexture(
     _context = std::make_unique<FlutterEGLContext>(_pluginRegistrar, _textureRegistrar);
 #else
     _context = std::make_unique<WGLContext>(_pluginRegistrar, _textureRegistrar);
+    std::cout << "Created WGL context" << std::endl;
 #endif
   }
+        
   _context->CreateRenderingSurface(width, height, std::move(result), left, top);
 }
 
@@ -210,7 +210,7 @@ void ThermionFlutterPlugin::DestroyTexture(
 void ThermionFlutterPlugin::HandleMethodCall(
     const flutter::MethodCall<flutter::EncodableValue> &methodCall,
     std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
-
+  std::cout << methodCall.method_name().c_str() << std::endl;
   if (methodCall.method_name() == "usesBackingWindow") {
     result->Success(flutter::EncodableValue(
       #ifdef WGL_USE_BACKING_WINDOW
@@ -243,14 +243,16 @@ void ThermionFlutterPlugin::HandleMethodCall(
       auto height = (uint32_t)round(dHeight );
       auto left = (uint32_t)round(dLeft );
       auto top = (uint32_t)round(dTop );
+      
       _context->ResizeRenderingSurface(width, height, left, top);
+      std::cout << "resized window to " << width << "x" << height << " at "  << left << "," << top << std::endl;
       result->Success();
     #else
       result->Error("ERROR", "resizeWindow is only available when using a backing window");
     #endif
-  } else if (methodCall.method_name() == "createTexture") {
+  } else if (methodCall.method_name() == "createWindow") {
     CreateTexture(methodCall, std::move(result));
-  } else if (methodCall.method_name() == "destroyTexture") {
+  } else if (methodCall.method_name() == "destroyWindow") {
     DestroyTexture(methodCall, std::move(result));
   } else if (methodCall.method_name() == "getRenderCallback") {
     flutter::EncodableList resultList;

thermion_flutter/thermion_flutter/windows/wgl_context.cpp

@@ -45,7 +45,7 @@ WGLContext::WGLContext(flutter::PluginRegistrarWindows *pluginRegistrar,
       0,
       0,
       0,
-      16, // Number of bits for the depthbuffer
+      24, // Number of bits for the depthbuffer
       0,  // Number of bits for the stencilbuffer
       0,  // Number of Aux buffers in the framebuffer.
       PFD_MAIN_PLANE,
@@ -117,6 +117,8 @@ void WGLContext::CreateRenderingSurface(
   } else { 
     ResizeRenderingSurface(width, height, left, top);
   }
+
+  std::cout << "created window size " << width << "x" << height << " at "  << left << "," << top << " with backing handle" << _backingWindow->GetHandle() << std::endl;
   std::vector<flutter::EncodableValue> resultList;
   resultList.push_back(flutter::EncodableValue()); // return null for Flutter texture ID
   resultList.push_back(flutter::EncodableValue()); // return null for hardware texture ID