Matteo De Carlo
370 lines
17 KiB
C++
370 lines
17 KiB
C++
#include "wiArchive.h"
|
|
#include "wiResourceManager.h"
|
|
#include "wiScene.h"
|
|
#include "wiInitializer.h"
|
|
#include "wiApplication.h"
|
|
#include "wiECS.h"
|
|
#include "wiRenderer.h"
|
|
|
|
#include <pybind11/pybind11.h>
|
|
#include <pybind11/stl.h>
|
|
#include <pybind11/stl_bind.h>
|
|
#include <wiScene_Components.h>
|
|
#include <string>
|
|
|
|
namespace py = pybind11;
|
|
|
|
PYBIND11_MAKE_OPAQUE(wi::vector<XMFLOAT2>);
|
|
PYBIND11_MAKE_OPAQUE(wi::vector<XMFLOAT3>);
|
|
PYBIND11_MAKE_OPAQUE(wi::vector<XMFLOAT4>);
|
|
PYBIND11_MAKE_OPAQUE(wi::vector<XMUINT4>);
|
|
PYBIND11_MAKE_OPAQUE(wi::vector<uint8_t>);
|
|
PYBIND11_MAKE_OPAQUE(wi::vector<uint32_t>);
|
|
PYBIND11_MAKE_OPAQUE(wi::vector<wi::scene::MeshComponent::MeshSubset>);
|
|
PYBIND11_MAKE_OPAQUE(wi::scene::NameComponent);
|
|
PYBIND11_MAKE_OPAQUE(wi::scene::MeshComponent);
|
|
PYBIND11_MAKE_OPAQUE(wi::scene::MaterialComponent);
|
|
PYBIND11_MAKE_OPAQUE(wi::scene::TransformComponent);
|
|
PYBIND11_MAKE_OPAQUE(wi::scene::ObjectComponent);
|
|
|
|
static wi::Application app;
|
|
static sdl2::sdlsystem_ptr_t sdl_system { nullptr, nullptr };
|
|
static sdl2::window_ptr_t sdl_window { nullptr, nullptr };
|
|
|
|
void init_wicked(py::module_& mod)
|
|
{
|
|
static bool INIT_DONE = false;
|
|
|
|
mod.def("init", []()
|
|
{
|
|
return;
|
|
if (INIT_DONE) return;
|
|
INIT_DONE = true;
|
|
|
|
//TODO we can probably initialize less stuff
|
|
sdl_system = sdl2::make_sdlsystem(SDL_INIT_VIDEO);
|
|
|
|
if (!sdl_system) {
|
|
throw sdl2::SDLError("Error creating SDL2 system");
|
|
}
|
|
|
|
sdl_window = sdl2::make_window("WickedBlenderExporter",
|
|
SDL_WINDOWPOS_CENTERED,
|
|
SDL_WINDOWPOS_CENTERED,
|
|
50, 50,
|
|
SDL_WINDOW_HIDDEN | SDL_WINDOW_VULKAN);
|
|
if (!sdl_window) {
|
|
throw sdl2::SDLError("Error creating window");
|
|
}
|
|
|
|
app.SetWindow(sdl_window.get());
|
|
wi::renderer::SetShaderSourcePath(std::string{WICKED_ROOT_DIR"/WickedEngine/shaders/"});
|
|
wi::renderer::SetShaderPath(std::string{WICKED_ROOT_DIR"/build/BlenderExporter/shaders/"});
|
|
|
|
//wi::initializer::InitializeComponentsImmediate();
|
|
app.Initialize();
|
|
});
|
|
|
|
mod.def("deinit", [](){
|
|
//TODO INIT_DONE = false;
|
|
});
|
|
}
|
|
|
|
void export_primitives(py::module_& mod)
|
|
{
|
|
py::class_<XMFLOAT2>(mod, "XMFLOAT2")
|
|
.def(py::init<>())
|
|
.def(py::init<float, float>())
|
|
;
|
|
py::class_<XMFLOAT3>(mod, "XMFLOAT3")
|
|
.def(py::init<>())
|
|
.def(py::init<float, float, float>())
|
|
;
|
|
py::class_<XMFLOAT4>(mod, "XMFLOAT4")
|
|
.def(py::init<>())
|
|
.def(py::init<float, float, float, float>())
|
|
;
|
|
py::class_<XMUINT4>(mod, "XMUINT4")
|
|
.def(py::init<>())
|
|
.def(py::init<uint32_t, uint32_t, uint32_t, uint32_t>())
|
|
;
|
|
|
|
py::bind_vector<wi::vector<XMFLOAT2>>(mod, "VectorXMFLOAT2");
|
|
py::bind_vector<wi::vector<XMFLOAT3>>(mod, "VectorXMFLOAT3");
|
|
py::bind_vector<wi::vector<XMFLOAT4>>(mod, "VectorXMFLOAT4");
|
|
py::bind_vector<wi::vector<XMUINT4 >>(mod, "VectorXMUINT4");
|
|
py::bind_vector<wi::vector<uint8_t >>(mod, "VectorU8");
|
|
py::bind_vector<wi::vector<uint32_t>>(mod, "VectorU32");
|
|
py::bind_vector<wi::vector<wi::scene::MeshComponent::MeshSubset>>(mod, "VectorMeshSubset");
|
|
|
|
}
|
|
|
|
void export_resourcemanager(py::module_& mod)
|
|
{
|
|
py::enum_<wi::resourcemanager::Mode>(mod, "ResourceManagerMode")
|
|
.value("DISCARD_FILEDATA_AFTER_LOAD", wi::resourcemanager::Mode::DISCARD_FILEDATA_AFTER_LOAD)
|
|
.value("ALLOW_RETAIN_FILEDATA", wi::resourcemanager::Mode::ALLOW_RETAIN_FILEDATA)
|
|
.value("ALLOW_RETAIN_FILEDATA_BUT_DISABLE_EMBEDDING", wi::resourcemanager::Mode::ALLOW_RETAIN_FILEDATA_BUT_DISABLE_EMBEDDING)
|
|
.export_values();
|
|
|
|
mod.def("resourcemanager_SetMode", &wi::resourcemanager::SetMode);
|
|
}
|
|
|
|
void export_Archive(py::module_& mod)
|
|
{
|
|
py::class_<wi::Archive>(mod, "Archive")
|
|
.def(py::init<>())
|
|
.def(py::init<const std::string&, bool>())
|
|
.def("IsOpen", &wi::Archive::IsOpen)
|
|
.def("Close", &wi::Archive::Close)
|
|
.def("SaveFile", &wi::Archive::SaveFile)
|
|
.def("SaveHeaderFile", &wi::Archive::SaveHeaderFile)
|
|
;
|
|
}
|
|
|
|
void export_Scene(py::module_& mod)
|
|
{
|
|
py::class_<wi::scene::Scene>(mod, "Scene")
|
|
.def(py::init<>())
|
|
//.def_readwrite("componentLibrary", &wi::scene::Scene::componentLibrary)
|
|
.def("names", [](const wi::scene::Scene &_this){ return &_this.names; })
|
|
.def("meshes", [](const wi::scene::Scene &_this){ return &_this.meshes; })
|
|
.def("transforms", [](const wi::scene::Scene &_this){ return &_this.transforms; })
|
|
.def("materials", [](const wi::scene::Scene &_this){ return &_this.materials; })
|
|
.def("objects", [](const wi::scene::Scene &_this){ return &_this.objects; })
|
|
.def("Serialize", &wi::scene::Scene::Serialize)
|
|
.def("Entity_CreateTransform", &wi::scene::Scene::Entity_CreateTransform)
|
|
.def("Entity_CreateMaterial", &wi::scene::Scene::Entity_CreateMaterial)
|
|
.def("Entity_CreateObject", &wi::scene::Scene::Entity_CreateObject)
|
|
.def("Entity_CreateMesh", &wi::scene::Scene::Entity_CreateMesh)
|
|
.def("Entity_CreateLight", &wi::scene::Scene::Entity_CreateLight)
|
|
.def("Entity_CreateForce", &wi::scene::Scene::Entity_CreateForce)
|
|
.def("Entity_CreateEnvironmentProbe", &wi::scene::Scene::Entity_CreateEnvironmentProbe)
|
|
.def("Entity_CreateDecal", &wi::scene::Scene::Entity_CreateDecal)
|
|
.def("Entity_CreateCamera", &wi::scene::Scene::Entity_CreateCamera)
|
|
.def("Entity_CreateEmitter", &wi::scene::Scene::Entity_CreateEmitter)
|
|
.def("Entity_CreateHair", &wi::scene::Scene::Entity_CreateHair)
|
|
.def("Entity_CreateSound", &wi::scene::Scene::Entity_CreateSound)
|
|
.def("Entity_CreateVideo", &wi::scene::Scene::Entity_CreateVideo)
|
|
.def("Entity_CreateCube", &wi::scene::Scene::Entity_CreateCube)
|
|
.def("Entity_CreatePlane", &wi::scene::Scene::Entity_CreatePlane)
|
|
.def("Entity_CreateSphere", &wi::scene::Scene::Entity_CreateSphere)
|
|
.def("Component_Attach", &wi::scene::Scene::Component_Attach)
|
|
.def("Component_Attach", [](wi::scene::Scene& _this, wi::ecs::Entity entity, wi::ecs::Entity parent) { return _this.Component_Attach(entity, parent); })
|
|
.def("Component_Detach", &wi::scene::Scene::Component_Detach)
|
|
.def("Component_DetachChildren", &wi::scene::Scene::Component_DetachChildren)
|
|
.def("RunAnimationUpdateSystem", &wi::scene::Scene::RunAnimationUpdateSystem)
|
|
.def("RunTransformUpdateSystem", &wi::scene::Scene::RunTransformUpdateSystem)
|
|
.def("RunHierarchyUpdateSystem", &wi::scene::Scene::RunHierarchyUpdateSystem)
|
|
.def("RunExpressionUpdateSystem", &wi::scene::Scene::RunExpressionUpdateSystem)
|
|
.def("RunProceduralAnimationUpdateSystem", &wi::scene::Scene::RunProceduralAnimationUpdateSystem)
|
|
.def("RunArmatureUpdateSystem", &wi::scene::Scene::RunArmatureUpdateSystem)
|
|
.def("RunMeshUpdateSystem", &wi::scene::Scene::RunMeshUpdateSystem)
|
|
.def("RunMaterialUpdateSystem", &wi::scene::Scene::RunMaterialUpdateSystem)
|
|
.def("RunImpostorUpdateSystem", &wi::scene::Scene::RunImpostorUpdateSystem)
|
|
.def("RunObjectUpdateSystem", &wi::scene::Scene::RunObjectUpdateSystem)
|
|
.def("RunCameraUpdateSystem", &wi::scene::Scene::RunCameraUpdateSystem)
|
|
.def("RunDecalUpdateSystem", &wi::scene::Scene::RunDecalUpdateSystem)
|
|
.def("RunProbeUpdateSystem", &wi::scene::Scene::RunProbeUpdateSystem)
|
|
.def("RunForceUpdateSystem", &wi::scene::Scene::RunForceUpdateSystem)
|
|
.def("RunLightUpdateSystem", &wi::scene::Scene::RunLightUpdateSystem)
|
|
.def("RunParticleUpdateSystem", &wi::scene::Scene::RunParticleUpdateSystem)
|
|
.def("RunWeatherUpdateSystem", &wi::scene::Scene::RunWeatherUpdateSystem)
|
|
.def("RunSoundUpdateSystem", &wi::scene::Scene::RunSoundUpdateSystem)
|
|
.def("RunVideoUpdateSystem", &wi::scene::Scene::RunVideoUpdateSystem)
|
|
.def("RunScriptUpdateSystem", &wi::scene::Scene::RunScriptUpdateSystem)
|
|
.def("RunSpriteUpdateSystem", &wi::scene::Scene::RunSpriteUpdateSystem)
|
|
.def("RunFontUpdateSystem", &wi::scene::Scene::RunFontUpdateSystem)
|
|
;
|
|
}
|
|
|
|
template<typename T>
|
|
void register_component_manager(py::module_& mod, const char* name)
|
|
{
|
|
typedef wi::ecs::ComponentManager<T> Manager;
|
|
py::class_<Manager, std::unique_ptr<Manager, py::nodelete>>(mod, name)
|
|
.def("Clear", &Manager::Clear)
|
|
// .def("Copy", &Manager::Copy)
|
|
// .def("Merge", &Manager::Merge)
|
|
.def("Create", &Manager::Create)
|
|
.def("Remove", &Manager::Remove)
|
|
.def("MoveItem", &Manager::MoveItem)
|
|
.def("Contains", &Manager::Contains)
|
|
.def("GetComponent", [](Manager* _this, wi::ecs::Entity entity) { return static_cast<T*>(_this->GetComponent(entity)); })
|
|
.def("GetIndex", &Manager::GetIndex)
|
|
.def("GetCount", [](const Manager* _this) { return _this->GetCount(); })
|
|
.def("GetEntity", &Manager::GetEntity)
|
|
.def("GetEntityArray", &Manager::GetEntityArray)
|
|
.def("GetComponentArray", &Manager::GetComponentArray)
|
|
;
|
|
}
|
|
|
|
void export_ECS(py::module_& mod)
|
|
{
|
|
using namespace wi::ecs;
|
|
using namespace wi::scene;
|
|
// py::class_<ComponentLibrary>(mod, "ComponentLibrary");
|
|
|
|
py::class_<Entity>(mod, "Entity");
|
|
|
|
mod.def("CreateEntity", &CreateEntity);
|
|
|
|
//maybe Components need to not handle memory by python
|
|
// `std::unique_ptr<TComponent, py::nodelete>`
|
|
py::class_<MeshComponent::MeshSubset>(mod, "MeshComponent_MeshSubset")
|
|
.def(py::init<>())
|
|
.def_readwrite("materialID", &MeshComponent::MeshSubset::materialID)
|
|
.def_readwrite("indexOffset", &MeshComponent::MeshSubset::indexOffset)
|
|
.def_readwrite("indexCount", &MeshComponent::MeshSubset::indexCount)
|
|
.def_readwrite("materialIndex", &MeshComponent::MeshSubset::materialIndex)
|
|
;
|
|
|
|
py::class_<NameComponent, std::unique_ptr<NameComponent, py::nodelete>>(mod, "NameComponent")
|
|
.def_readwrite("name", &NameComponent::name)
|
|
;
|
|
|
|
py::class_<MeshComponent, std::unique_ptr<MeshComponent, py::nodelete>>(mod, "MeshComponent")
|
|
.def_readwrite("vertex_positions", &MeshComponent::vertex_positions)
|
|
.def_readwrite("vertex_normals", &MeshComponent::vertex_normals)
|
|
.def_readwrite("vertex_tangents", &MeshComponent::vertex_tangents)
|
|
.def_readwrite("vertex_uvset_0", &MeshComponent::vertex_uvset_0)
|
|
.def_readwrite("vertex_uvset_1", &MeshComponent::vertex_uvset_1)
|
|
.def_readwrite("vertex_boneindices", &MeshComponent::vertex_boneindices)
|
|
.def_readwrite("vertex_boneweights", &MeshComponent::vertex_boneweights)
|
|
.def_readwrite("vertex_atlas", &MeshComponent::vertex_atlas)
|
|
.def_readwrite("vertex_colors", &MeshComponent::vertex_colors)
|
|
.def_readwrite("vertex_windweights", &MeshComponent::vertex_windweights)
|
|
.def_readwrite("indices", &MeshComponent::indices)
|
|
.def_readwrite("subsets", &MeshComponent::subsets)
|
|
.def_readwrite("tessellationFactor", &MeshComponent::tessellationFactor)
|
|
.def_readwrite("armatureID", &MeshComponent::armatureID)
|
|
.def("ComputeNormals", &MeshComponent::ComputeNormals)
|
|
.def("ComputeNormals", &MeshComponent::CreateRenderData)
|
|
;
|
|
|
|
py::enum_<MeshComponent::COMPUTE_NORMALS>(mod, "MeshComponentComputeNormals")
|
|
.value("HARD", MeshComponent::COMPUTE_NORMALS::COMPUTE_NORMALS_HARD)
|
|
.value("SMOOTH", MeshComponent::COMPUTE_NORMALS::COMPUTE_NORMALS_SMOOTH)
|
|
.value("SMOOTH_FAST", MeshComponent::COMPUTE_NORMALS::COMPUTE_NORMALS_SMOOTH_FAST)
|
|
.export_values()
|
|
;
|
|
|
|
py::class_<TransformComponent>(mod, "TransformComponent")
|
|
.def(py::init<>())
|
|
.def_readwrite("scale_local", &TransformComponent::scale_local)
|
|
.def_readwrite("rotation_local", &TransformComponent::rotation_local)
|
|
.def_readwrite("translation_local", &TransformComponent::translation_local)
|
|
.def_readwrite("world", &TransformComponent::world)
|
|
.def("GetPosition", &TransformComponent::GetPosition)
|
|
.def("GetRotation", &TransformComponent::GetRotation)
|
|
.def("GetScale", &TransformComponent::GetScale)
|
|
.def("GetPositionV", &TransformComponent::GetPositionV)
|
|
.def("GetRotationV", &TransformComponent::GetRotationV)
|
|
.def("GetScaleV", &TransformComponent::GetScaleV)
|
|
.def("GetLocalMatrix", &TransformComponent::GetLocalMatrix)
|
|
.def("UpdateTransform", &TransformComponent::UpdateTransform)
|
|
.def("UpdateTransform_Parented", &TransformComponent::UpdateTransform_Parented)
|
|
.def("ApplyTransform", &TransformComponent::ApplyTransform)
|
|
.def("ClearTransform", &TransformComponent::ClearTransform)
|
|
// .def("Translate", &TransformComponent::Translate)
|
|
// .def("Translate", &TransformComponent::Translate)
|
|
.def("RotateRollPitchYaw", &TransformComponent::RotateRollPitchYaw)
|
|
// .def("Rotate", &TransformComponent::Rotate)
|
|
// .def("Rotate", &TransformComponent::Rotate)
|
|
// .def("Scale", &TransformComponent::Scale)
|
|
// .def("Scale", &TransformComponent::Scale)
|
|
// .def("MatrixTransform", &TransformComponent::MatrixTransform)
|
|
// .def("MatrixTransform", &TransformComponent::MatrixTransform)
|
|
.def("Lerp", &TransformComponent::Lerp)
|
|
.def("CatmullRom", &TransformComponent::CatmullRom)
|
|
;
|
|
|
|
|
|
py::enum_<MaterialComponent::SHADERTYPE>(mod, "MaterialComponent_SHADERTYPE")
|
|
.value("PBR", MaterialComponent::SHADERTYPE::SHADERTYPE_PBR)
|
|
.value("PBR_PLANARREFLECTION", MaterialComponent::SHADERTYPE_PBR_PLANARREFLECTION)
|
|
.value("PBR_PARALLAXOCCLUSIONMAPPING", MaterialComponent::SHADERTYPE_PBR_PARALLAXOCCLUSIONMAPPING)
|
|
.value("PBR_ANISOTROPIC", MaterialComponent::SHADERTYPE_PBR_ANISOTROPIC)
|
|
.value("WATER", MaterialComponent::SHADERTYPE_WATER)
|
|
.value("CARTOON", MaterialComponent::SHADERTYPE_CARTOON)
|
|
.value("UNLIT", MaterialComponent::SHADERTYPE_UNLIT)
|
|
.value("PBR_CLOTH", MaterialComponent::SHADERTYPE_PBR_CLOTH)
|
|
.value("PBR_CLEARCOAT", MaterialComponent::SHADERTYPE_PBR_CLEARCOAT)
|
|
.value("PBR_CLOTH_CLEARCOAT", MaterialComponent::SHADERTYPE_PBR_CLOTH_CLEARCOAT)
|
|
//.value("COUNT", MaterialComponent::SHADERTYPE_COUNT)
|
|
.export_values()
|
|
;
|
|
|
|
py::class_<MaterialComponent, std::unique_ptr<MaterialComponent, py::nodelete>>(mod, "MaterialComponent")
|
|
.def_readwrite("shaderType", &MaterialComponent::shaderType)
|
|
//wi::enums::STENCILREF engineStencilRef = wi::enums::STENCILREF_DEFAULT;
|
|
//uint8_t userStencilRef = 0;
|
|
//wi::enums::BLENDMODE userBlendMode = wi::enums::BLENDMODE_OPAQUE;
|
|
.def_readwrite("baseColor", &MaterialComponent::baseColor)
|
|
.def_readwrite("specularColor", &MaterialComponent::specularColor)
|
|
.def_readwrite("emissiveColor", &MaterialComponent::emissiveColor)
|
|
.def_readwrite("subsurfaceScattering", &MaterialComponent::subsurfaceScattering)
|
|
.def_readwrite("texMulAdd", &MaterialComponent::texMulAdd)
|
|
.def_readwrite("roughness", &MaterialComponent::roughness)
|
|
.def_readwrite("reflectance", &MaterialComponent::reflectance)
|
|
.def_readwrite("metalness", &MaterialComponent::metalness)
|
|
.def_readwrite("normalMapStrength", &MaterialComponent::normalMapStrength)
|
|
.def_readwrite("parallaxOcclusionMapping", &MaterialComponent::parallaxOcclusionMapping)
|
|
.def_readwrite("displacementMapping", &MaterialComponent::displacementMapping)
|
|
.def_readwrite("refraction", &MaterialComponent::refraction)
|
|
.def_readwrite("transmission", &MaterialComponent::transmission)
|
|
.def_readwrite("alphaRef", &MaterialComponent::alphaRef)
|
|
.def_readwrite("anisotropy_strength", &MaterialComponent::anisotropy_strength)
|
|
.def_readwrite("anisotropy_rotation", &MaterialComponent::anisotropy_rotation)
|
|
.def_readwrite("sheenColor", &MaterialComponent::sheenColor)
|
|
.def_readwrite("sheenRoughness", &MaterialComponent::sheenRoughness)
|
|
.def_readwrite("clearcoat", &MaterialComponent::clearcoat)
|
|
.def_readwrite("clearcoatRoughness", &MaterialComponent::clearcoatRoughness)
|
|
//.def_readwrite("shadingRate", &MaterialComponent::shadingRate) //wi::graphics::ShadingRate
|
|
.def_readwrite("texAnimDirection", &MaterialComponent::texAnimDirection)
|
|
.def_readwrite("texAnimFrameRate", &MaterialComponent::texAnimFrameRate)
|
|
.def_readwrite("texAnimElapsedTime", &MaterialComponent::texAnimElapsedTime)
|
|
;
|
|
|
|
py::class_<ObjectComponent, std::unique_ptr<ObjectComponent, py::nodelete>>(mod, "ObjectComponent")
|
|
.def_readwrite("meshID", &ObjectComponent::meshID)
|
|
.def_readwrite("cascadeMask", &ObjectComponent::cascadeMask)
|
|
.def_readwrite("filterMask", &ObjectComponent::filterMask)
|
|
.def_readwrite("color", &ObjectComponent::color)
|
|
.def_readwrite("emissiveColor", &ObjectComponent::emissiveColor)
|
|
.def_readwrite("userStencilRef", &ObjectComponent::userStencilRef)
|
|
.def_readwrite("lod_distance_multiplier", &ObjectComponent::lod_distance_multiplier)
|
|
.def_readwrite("draw_distance", &ObjectComponent::draw_distance)
|
|
.def_readwrite("lightmapWidth", &ObjectComponent::lightmapWidth)
|
|
.def_readwrite("lightmapHeight", &ObjectComponent::lightmapHeight)
|
|
.def_readwrite("lightmapTextureData", &ObjectComponent::lightmapTextureData)
|
|
.def_readwrite("sort_priority", &ObjectComponent::sort_priority)
|
|
.def_readwrite("filterMaskDynamic", &ObjectComponent::filterMaskDynamic)
|
|
.def_readwrite("lightmap", &ObjectComponent::lightmap)
|
|
.def_readwrite("lightmapIterationCount", &ObjectComponent::lightmapIterationCount)
|
|
.def_readwrite("center", &ObjectComponent::center)
|
|
.def_readwrite("radius", &ObjectComponent::radius)
|
|
.def_readwrite("fadeDistance", &ObjectComponent::fadeDistance)
|
|
.def_readwrite("lod", &ObjectComponent::lod)
|
|
.def_readwrite("mesh_index", &ObjectComponent::mesh_index)
|
|
.def_readwrite("sort_bits", &ObjectComponent::sort_bits)
|
|
;
|
|
|
|
// MANAGERS -------------------------------------------
|
|
register_component_manager<NameComponent>(mod, "NameComponentManager");
|
|
register_component_manager<TransformComponent>(mod, "TransformComponentManager");
|
|
register_component_manager<MeshComponent>(mod, "MeshComponentManager");
|
|
register_component_manager<MaterialComponent>(mod, "MaterialComponentManager");
|
|
register_component_manager<ObjectComponent>(mod, "ObjectComponentManager");
|
|
}
|
|
|
|
PYBIND11_MODULE(pywickedengine, mod)
|
|
{
|
|
init_wicked(mod);
|
|
export_primitives(mod);
|
|
export_resourcemanager(mod);
|
|
export_ECS(mod);
|
|
export_Archive(mod);
|
|
export_Scene(mod);
|
|
}
|