528 lines
17 KiB
C++
528 lines
17 KiB
C++
#pragma comment(lib, "dxgi.lib")
|
|
#pragma comment(lib, "d3d11.lib")
|
|
|
|
#include "polyvox_filament_plugin.h"
|
|
|
|
// This must be included before many other Windows headers.
|
|
#include <windows.h>
|
|
|
|
// For getPlatformVersion; remove unless needed for your plugin implementation.
|
|
#include <VersionHelpers.h>
|
|
|
|
#include <flutter/method_channel.h>
|
|
#include <flutter/plugin_registrar_windows.h>
|
|
#include <flutter/standard_method_codec.h>
|
|
#include <flutter/texture_registrar.h>
|
|
|
|
#include <codecvt>
|
|
#include <cstring>
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <locale>
|
|
#include <map>
|
|
#include <math.h>
|
|
#include <memory>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <future>
|
|
|
|
#include "PolyvoxFilamentApi.h"
|
|
#ifdef USE_ANGLE
|
|
#include "PlatformANGLE.h"
|
|
#endif
|
|
|
|
#include <Windows.h>
|
|
#include <wrl.h>
|
|
|
|
using namespace std::chrono_literals;
|
|
|
|
namespace polyvox_filament {
|
|
|
|
// static
|
|
void PolyvoxFilamentPlugin::RegisterWithRegistrar(
|
|
flutter::PluginRegistrarWindows *registrar) {
|
|
auto channel =
|
|
std::make_unique<flutter::MethodChannel<flutter::EncodableValue>>(
|
|
registrar->messenger(), "app.polyvox.filament/event",
|
|
&flutter::StandardMethodCodec::GetInstance());
|
|
|
|
auto plugin = std::make_unique<PolyvoxFilamentPlugin>(
|
|
registrar->texture_registrar(), registrar);
|
|
|
|
channel->SetMethodCallHandler(
|
|
[plugin_pointer = plugin.get()](const auto &call, auto result) {
|
|
plugin_pointer->HandleMethodCall(call, std::move(result));
|
|
});
|
|
|
|
registrar->AddPlugin(std::move(plugin));
|
|
}
|
|
|
|
PolyvoxFilamentPlugin::PolyvoxFilamentPlugin(
|
|
flutter::TextureRegistrar *textureRegistrar,
|
|
flutter::PluginRegistrarWindows *pluginRegistrar)
|
|
: _textureRegistrar(textureRegistrar), _pluginRegistrar(pluginRegistrar) {}
|
|
|
|
PolyvoxFilamentPlugin::~PolyvoxFilamentPlugin() {}
|
|
|
|
ResourceBuffer PolyvoxFilamentPlugin::loadResource(const char *name) {
|
|
|
|
std::string name_str(name);
|
|
std::filesystem::path targetFilePath;
|
|
|
|
if (name_str.rfind("file://", 0) == 0) {
|
|
targetFilePath = name_str.substr(7);
|
|
} else {
|
|
|
|
if (name_str.rfind("asset://", 0) == 0) {
|
|
name_str = name_str.substr(8);
|
|
}
|
|
|
|
TCHAR pBuf[512];
|
|
size_t len = sizeof(pBuf);
|
|
int bytes = GetModuleFileName(NULL, pBuf, len);
|
|
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
|
|
std::wstring assetPath = converter.from_bytes(name_str.c_str());
|
|
|
|
std::wstring exePathBuf(pBuf);
|
|
std::filesystem::path exePath(exePathBuf);
|
|
auto exeDir = exePath.remove_filename();
|
|
targetFilePath = exeDir.wstring() + L"data/flutter_assets/" +
|
|
assetPath;
|
|
}
|
|
std::streampos length;
|
|
|
|
std::ifstream is(targetFilePath.c_str(), std::ios::binary);
|
|
if (!is) {
|
|
std::cout << "Failed to find resource at file path " << targetFilePath << std::endl;
|
|
return ResourceBuffer(nullptr, 0, -1);
|
|
}
|
|
is.seekg(0, std::ios::end);
|
|
length = is.tellg();
|
|
|
|
char *buffer;
|
|
buffer = new char[length];
|
|
is.seekg(0, std::ios::beg);
|
|
is.read(buffer, length);
|
|
is.close();
|
|
auto id = _resources.size();
|
|
auto rb = ResourceBuffer(buffer, length, id);
|
|
_resources.emplace(id, rb);
|
|
|
|
std::wcout << "Loaded resource of length " << length << " from path " << targetFilePath << std::endl;
|
|
|
|
return rb;
|
|
}
|
|
|
|
void PolyvoxFilamentPlugin::freeResource(ResourceBuffer rbuf) {
|
|
free((void *)rbuf.data);
|
|
}
|
|
|
|
static ResourceBuffer _loadResource(const char *path, void *const plugin) {
|
|
return ((PolyvoxFilamentPlugin *)plugin)->loadResource(path);
|
|
}
|
|
|
|
static void _freeResource(ResourceBuffer rbf, void *const plugin) {
|
|
((PolyvoxFilamentPlugin *)plugin)->freeResource(rbf);
|
|
}
|
|
|
|
// this is the C-style function that will be returned via getRenderCallback
|
|
// called on every frame by the FFI API
|
|
// this is just a convenient wrapper to call RenderCallback on the actual plugin instance
|
|
void render_callback(void* owner) {
|
|
((PolyvoxFilamentPlugin*)owner)->RenderCallback();
|
|
}
|
|
|
|
// this is the method on PolyvoxFilamentPlugin that will copy between D3D textures
|
|
void PolyvoxFilamentPlugin::RenderCallback() {
|
|
|
|
std::lock_guard<std::mutex> guard(*(_renderMutex.get()));
|
|
if (_active) {
|
|
#ifdef USE_ANGLE
|
|
_active->RenderCallback();
|
|
#endif
|
|
_textureRegistrar->MarkTextureFrameAvailable(_active->flutterTextureId);
|
|
}
|
|
}
|
|
|
|
#ifdef USE_ANGLE
|
|
bool PolyvoxFilamentPlugin::CreateSharedEGLContext() {
|
|
// D3D starts here
|
|
IDXGIAdapter* adapter_ = nullptr;
|
|
|
|
// first, we need to initialize the D3D device and create the backing texture
|
|
// this has been taken from https://github.com/alexmercerind/flutter-windows-ANGLE-OpenGL-ES/blob/master/windows/angle_surface_manager.cc
|
|
auto feature_levels = {
|
|
D3D_FEATURE_LEVEL_11_0,
|
|
D3D_FEATURE_LEVEL_10_1,
|
|
D3D_FEATURE_LEVEL_10_0,
|
|
D3D_FEATURE_LEVEL_9_3,
|
|
};
|
|
// NOTE: Not enabling DirectX 12.
|
|
// |D3D11CreateDevice| crashes directly on Windows 7.
|
|
// D3D_FEATURE_LEVEL_12_2, D3D_FEATURE_LEVEL_12_1, D3D_FEATURE_LEVEL_12_0,
|
|
// D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_1,
|
|
// D3D_FEATURE_LEVEL_10_0, D3D_FEATURE_LEVEL_9_3,
|
|
IDXGIFactory* dxgi = nullptr;
|
|
::CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&dxgi);
|
|
// Manually selecting adapter. As far as my experience goes, this is the
|
|
// safest approach. Passing NULL (so-called default) seems to cause issues
|
|
// on Windows 7 or maybe some older graphics drivers.
|
|
// First adapter is the default.
|
|
// |D3D_DRIVER_TYPE_UNKNOWN| must be passed with manual adapter selection.
|
|
dxgi->EnumAdapters(0, &adapter_);
|
|
dxgi->Release();
|
|
if (!adapter_) {
|
|
std::cout << "Failed to locate default D3D adapter"<< std::endl;
|
|
return false;
|
|
}
|
|
|
|
DXGI_ADAPTER_DESC adapter_desc_;
|
|
adapter_->GetDesc(&adapter_desc_);
|
|
std::wcout << L"D3D adapter description: " << adapter_desc_.Description << std::endl;
|
|
|
|
auto hr = ::D3D11CreateDevice(
|
|
adapter_, D3D_DRIVER_TYPE_UNKNOWN, 0, 0, feature_levels.begin(),
|
|
static_cast<UINT>(feature_levels.size()), D3D11_SDK_VERSION,
|
|
&_D3D11Device, 0, &_D3D11DeviceContext);
|
|
|
|
if (FAILED(hr)) {
|
|
std::cout << "Failed to create D3D device"<< std::endl;
|
|
return false;
|
|
}
|
|
|
|
Microsoft::WRL::ComPtr<IDXGIDevice> dxgi_device = nullptr;
|
|
auto dxgi_device_success = _D3D11Device->QueryInterface(
|
|
__uuidof(IDXGIDevice), (void**)&dxgi_device);
|
|
if (SUCCEEDED(dxgi_device_success) && dxgi_device != nullptr) {
|
|
dxgi_device->SetGPUThreadPriority(5); // Must be in interval [-7, 7].
|
|
}
|
|
auto level = _D3D11Device->GetFeatureLevel();
|
|
std::cout << "media_kit: ANGLESurfaceManager: Direct3D Feature Level: "
|
|
<< (((unsigned)level) >> 12) << "_"
|
|
<< ((((unsigned)level) >> 8) & 0xf) << std::endl;
|
|
|
|
|
|
// *******************
|
|
// * *
|
|
// * *
|
|
// * EGL starts here *
|
|
// * *
|
|
// * *
|
|
// * *
|
|
// *******************
|
|
EGLBoolean bindAPI = eglBindAPI(EGL_OPENGL_ES_API);
|
|
if (UTILS_UNLIKELY(!bindAPI)) {
|
|
std::cout << "eglBindAPI EGL_OPENGL_ES_API failed" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
|
|
assert_invariant(_eglDisplay != EGL_NO_DISPLAY);
|
|
|
|
EGLint major, minor;
|
|
EGLBoolean initialized = false; // = eglInitialize(_eglDisplay, &major, &minor);
|
|
|
|
// if (!initialized) {
|
|
EGLDeviceEXT eglDevice;
|
|
EGLint numDevices;
|
|
|
|
if(auto* getPlatformDisplay = reinterpret_cast<PFNEGLGETPLATFORMDISPLAYEXTPROC>(
|
|
eglGetProcAddress("eglGetPlatformDisplayEXT"))) {
|
|
|
|
EGLint kD3D11DisplayAttributes[] = {
|
|
EGL_PLATFORM_ANGLE_TYPE_ANGLE,
|
|
EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE,
|
|
EGL_PLATFORM_ANGLE_ENABLE_AUTOMATIC_TRIM_ANGLE,
|
|
EGL_TRUE,
|
|
EGL_NONE,
|
|
};
|
|
_eglDisplay = getPlatformDisplay(EGL_PLATFORM_ANGLE_ANGLE, EGL_DEFAULT_DISPLAY, kD3D11DisplayAttributes);
|
|
initialized = eglInitialize(_eglDisplay, &major, &minor);
|
|
}
|
|
|
|
std::cout << "Got major " << major << " and minor " << minor << std::endl;
|
|
|
|
if (UTILS_UNLIKELY(!initialized)) {
|
|
std::cout << "eglInitialize failed" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
importGLESExtensionsEntryPoints();
|
|
|
|
EGLint configsCount;
|
|
|
|
EGLint configAttribs[] = {
|
|
EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8,
|
|
EGL_ALPHA_SIZE, 8, EGL_DEPTH_SIZE, 24, EGL_STENCIL_SIZE, 8, EGL_ALPHA_SIZE, 8,
|
|
EGL_NONE
|
|
};
|
|
|
|
EGLint contextAttribs[] = {
|
|
EGL_CONTEXT_CLIENT_VERSION, 3,
|
|
EGL_NONE, EGL_NONE, // reserved for EGL_CONTEXT_OPENGL_NO_ERROR_KHR below
|
|
EGL_NONE
|
|
};
|
|
|
|
// find an opaque config
|
|
if (!eglChooseConfig(_eglDisplay, configAttribs, &_eglConfig, 1, &configsCount)) {
|
|
return false;
|
|
}
|
|
|
|
_context = (void*)eglCreateContext(_eglDisplay, _eglConfig, EGL_NO_CONTEXT, contextAttribs);
|
|
|
|
if (UTILS_UNLIKELY(_context == EGL_NO_CONTEXT)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool PolyvoxFilamentPlugin::MakeD3DTexture(uint32_t width, uint32_t height,std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
|
|
importGLESExtensionsEntryPoints();
|
|
|
|
if(_active.get()) {
|
|
result->Error("ERROR", "Texture already exists. You must call destroyTexture before attempting to create a new one.");
|
|
return false;
|
|
}
|
|
|
|
_active = std::make_unique<FlutterAngleTexture>(
|
|
_pluginRegistrar,
|
|
_textureRegistrar,
|
|
std::move(result),
|
|
width,
|
|
height,
|
|
_D3D11Device,
|
|
_D3D11DeviceContext,
|
|
_eglConfig,
|
|
_eglDisplay,
|
|
_context
|
|
);
|
|
|
|
return _active->flutterTextureId != -1;
|
|
}
|
|
#else
|
|
bool PolyvoxFilamentPlugin::CreateSharedWGLContext() {
|
|
|
|
HWND hwnd = _pluginRegistrar->GetView()
|
|
->GetNativeWindow();
|
|
|
|
HDC whdc = GetDC(hwnd);
|
|
if (whdc == NULL) {
|
|
std::cout << "No device context for temporary window" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
std::cout << "No GL context exists, creating" << std::endl;
|
|
|
|
PIXELFORMATDESCRIPTOR pfd = {
|
|
sizeof(PIXELFORMATDESCRIPTOR),
|
|
1,
|
|
PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER, // Flags
|
|
PFD_TYPE_RGBA, // The kind of framebuffer. RGBA or palette.
|
|
32, // Colordepth of the framebuffer.
|
|
0, 0, 0, 0, 0, 0,
|
|
0,
|
|
0,
|
|
0,
|
|
0, 0, 0, 0,
|
|
32, // Number of bits for the depthbuffer
|
|
0, // Number of bits for the stencilbuffer
|
|
0, // Number of Aux buffers in the framebuffer.
|
|
PFD_MAIN_PLANE,
|
|
0,
|
|
0, 0, 0
|
|
};
|
|
|
|
int pixelFormat = ChoosePixelFormat(whdc, &pfd);
|
|
SetPixelFormat(whdc, pixelFormat, &pfd);
|
|
|
|
// We need a tmp context to retrieve and call wglCreateContextAttribsARB.
|
|
HGLRC tempContext = wglCreateContext(whdc);
|
|
if (!wglMakeCurrent(whdc, tempContext)) {
|
|
std::cout <<"Failed to acquire temporary context" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
GLenum err = glGetError();
|
|
|
|
if(err != GL_NO_ERROR) {
|
|
std::cout <<"GL Error @ 455 %d" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribs = nullptr;
|
|
|
|
wglCreateContextAttribs =
|
|
(PFNWGLCREATECONTEXTATTRIBSARBPROC)wglGetProcAddress(
|
|
"wglCreateContextAttribsARB");
|
|
|
|
if (!wglCreateContextAttribs) {
|
|
std::cout <<"Failed to resolve wglCreateContextAttribsARB" << std::endl;
|
|
return false;
|
|
}
|
|
|
|
for (int minor = 5; minor >= 1; minor--) {
|
|
std::vector<int> mAttribs = {WGL_CONTEXT_MAJOR_VERSION_ARB, 4,
|
|
WGL_CONTEXT_MINOR_VERSION_ARB, minor, 0};
|
|
_context = wglCreateContextAttribs(whdc, nullptr, mAttribs.data());
|
|
if (_context) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
wglMakeCurrent(NULL, NULL);
|
|
wglDeleteContext(tempContext);
|
|
|
|
if (!_context || !wglMakeCurrent(whdc, _context)) {
|
|
std::cout << "Failed to create OpenGL context." << std::endl;
|
|
return false;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
bool PolyvoxFilamentPlugin::MakeOpenGLTexture(uint32_t width, uint32_t height,std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
|
|
|
|
if(_active.get()) {
|
|
result->Error("ERROR", "Texture already exists. You must call destroyTexture before attempting to create a new one.");
|
|
return false;
|
|
}
|
|
|
|
_active = std::make_unique<OpenGLTextureBuffer>(
|
|
_pluginRegistrar,
|
|
_textureRegistrar,
|
|
std::move(result),
|
|
width,
|
|
height,
|
|
_context,
|
|
_renderMutex
|
|
);
|
|
|
|
return _active->flutterTextureId != -1;
|
|
|
|
}
|
|
#endif
|
|
|
|
|
|
void PolyvoxFilamentPlugin::CreateTexture(
|
|
const flutter::MethodCall<flutter::EncodableValue> &methodCall,
|
|
std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
|
|
|
|
|
|
if(!_renderMutex.get()) {
|
|
_renderMutex = std::make_shared<std::mutex>();
|
|
}
|
|
|
|
std::lock_guard<std::mutex> guard(*(_renderMutex.get()));
|
|
|
|
const auto *args =
|
|
std::get_if<flutter::EncodableList>(methodCall.arguments());
|
|
|
|
const auto width = (uint32_t)round(*(std::get_if<double>(&(args->at(0)))));
|
|
const auto height = (uint32_t)round(*(std::get_if<double>(&(args->at(1)))));
|
|
|
|
// create a single shared context for the life of the application
|
|
// this will be used to create a backing texture and passed to Filament
|
|
if(!_context) {
|
|
#ifdef USE_ANGLE
|
|
CreateSharedEGLContext();
|
|
#else
|
|
CreateSharedWGLContext();
|
|
#endif
|
|
}
|
|
|
|
#ifdef USE_ANGLE
|
|
bool success = MakeD3DTexture(width, height, std::move(result));
|
|
#else
|
|
bool success = MakeOpenGLTexture(width, height, std::move(result));
|
|
#endif
|
|
}
|
|
|
|
void PolyvoxFilamentPlugin::DestroyTexture(
|
|
const flutter::MethodCall<flutter::EncodableValue> &methodCall,
|
|
std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
|
|
|
|
const auto *flutterTextureId =
|
|
std::get_if<int64_t>(methodCall.arguments());
|
|
|
|
if(!flutterTextureId) {
|
|
result->Error("NOT_IMPLEMENTED", "Flutter texture ID must be provided");
|
|
return;
|
|
}
|
|
|
|
|
|
if(!_active) {
|
|
result->Success("Texture has already been detroyed, ignoring");
|
|
return;
|
|
}
|
|
|
|
if(_active->flutterTextureId != *flutterTextureId) {
|
|
result->Error("TEXTURE_MISMATCH", "Specified texture ID is not active");
|
|
return;
|
|
}
|
|
|
|
auto sh = std::make_shared<std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>>>(std::move(result));
|
|
|
|
|
|
// result->Error("NOT_IMPLEMENTED", "Method is not implemented %s", methodCall.method_name());
|
|
_textureRegistrar->UnregisterTexture(_active->flutterTextureId, [=,
|
|
sharedResult=std::move(sh)
|
|
]() {
|
|
#ifdef USE_ANGLE
|
|
this->_active = nullptr;
|
|
#else
|
|
if(this->_inactive) {
|
|
HWND hwnd = _pluginRegistrar->GetView()->GetNativeWindow();
|
|
HDC whdc = GetDC(hwnd);
|
|
|
|
if (!wglMakeCurrent(whdc, _context)) {
|
|
std::cout << "Failed to switch OpenGL context in destructor." << std::endl;
|
|
// result->Error("CONTEXT", "Failed to switch OpenGL context.", nullptr);
|
|
return;
|
|
}
|
|
glDeleteTextures(1, &this->_inactive->glTextureId);
|
|
wglMakeCurrent(NULL, NULL);
|
|
}
|
|
this->_inactive = std::move(this->_active);
|
|
#endif
|
|
auto unique = std::move(*(sharedResult.get()));
|
|
unique->Success(flutter::EncodableValue(true));
|
|
std::cout << "Unregistered/destroyed texture." << std::endl;
|
|
});
|
|
|
|
|
|
}
|
|
|
|
void PolyvoxFilamentPlugin::HandleMethodCall(
|
|
const flutter::MethodCall<flutter::EncodableValue> &methodCall,
|
|
std::unique_ptr<flutter::MethodResult<flutter::EncodableValue>> result) {
|
|
|
|
if (methodCall.method_name() == "getSharedContext") {
|
|
result->Success(flutter::EncodableValue((int64_t)_context));
|
|
} else if (methodCall.method_name() == "getResourceLoaderWrapper") {
|
|
const ResourceLoaderWrapper *const resourceLoader =
|
|
new ResourceLoaderWrapper(_loadResource, _freeResource, this);
|
|
result->Success(flutter::EncodableValue((int64_t)resourceLoader));
|
|
} else if (methodCall.method_name() == "createTexture") {
|
|
CreateTexture(methodCall, std::move(result));
|
|
} else if (methodCall.method_name() == "destroyTexture") {
|
|
DestroyTexture(methodCall, std::move(result));
|
|
} else if(methodCall.method_name() == "getRenderCallback") {
|
|
flutter::EncodableList resultList;
|
|
resultList.push_back(flutter::EncodableValue((int64_t)&render_callback));
|
|
resultList.push_back(flutter::EncodableValue((int64_t)this));
|
|
result->Success(resultList);
|
|
} else if(methodCall.method_name() == "getDriverPlatform") {
|
|
#ifdef USE_ANGLE
|
|
result->Success(flutter::EncodableValue((int64_t)_active->platform));
|
|
#else
|
|
result->Success(flutter::EncodableValue((int64_t)nullptr));
|
|
#endif
|
|
} else {
|
|
result->Error("NOT_IMPLEMENTED", "Method is not implemented %s", methodCall.method_name());
|
|
}
|
|
}
|
|
|
|
} // namespace polyvox_filament
|
|
|