590 lines
17 KiB
C++
590 lines
17 KiB
C++
// Copyright (C) 2002-2006 Nikolaus Gebhardt
|
|
// This file is part of the "Irrlicht Engine".
|
|
// For conditions of distribution and use, see copyright notice in irrlicht.h
|
|
|
|
#include "ISceneManager.h"
|
|
#include "NativeConverter.h"
|
|
#include "ITriangleSelector.h"
|
|
#include "ISceneNodeAnimator.h"
|
|
#include "IMetaTriangleSelector.h"
|
|
#include "ISceneCollisionManager.h"
|
|
#include "ITerrainSceneNode.h"
|
|
#include "IMeshManipulator.h"
|
|
|
|
namespace Irrlicht
|
|
{
|
|
namespace Scene
|
|
{
|
|
|
|
ISceneManager::ISceneManager(irr::scene::ISceneManager* manager)
|
|
: Manager(manager)
|
|
{
|
|
SCM = new ISceneCollisionManager(Manager->getSceneCollisionManager());
|
|
Manipulator = new IMeshManipulator(Manager->getMeshManipulator());
|
|
Root = new ISceneNode(Manager->getRootSceneNode());
|
|
}
|
|
|
|
IAnimatedMesh* ISceneManager::GetMesh(System::String* filename)
|
|
{
|
|
char* str = (char*)(void*)
|
|
System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(filename);
|
|
|
|
irr::scene::IAnimatedMesh* am = Manager->getMesh(str);
|
|
|
|
System::Runtime::InteropServices::Marshal::FreeHGlobal(str);
|
|
|
|
if (!am)
|
|
return 0;
|
|
|
|
return new IAnimatedMesh(am);
|
|
}
|
|
|
|
ISceneNode* ISceneManager::AddCubeSceneNode(float size, ISceneNode* parent, int id,
|
|
Core::Vector3D position, Core::Vector3D rotation, Core::Vector3D scale)
|
|
{
|
|
irr::scene::ISceneNode* node =
|
|
Manager->addCubeSceneNode(size, parent ? parent->get_NativeSceneNode() : 0, id,
|
|
irr::NativeConverter::getNativeVector(position),
|
|
irr::NativeConverter::getNativeVector(rotation),
|
|
irr::NativeConverter::getNativeVector(scale));
|
|
|
|
if (!node)
|
|
return 0;
|
|
|
|
return new ISceneNode(node);
|
|
}
|
|
|
|
ISceneNode* ISceneManager::AddCubeSceneNode(float size, ISceneNode* parent, int id, Core::Vector3D position)
|
|
{
|
|
return AddCubeSceneNode(size, parent, id, position,
|
|
Irrlicht::Core::Vector3D(0,0,0), Irrlicht::Core::Vector3D(1,1,1));
|
|
}
|
|
|
|
ICameraSceneNode* ISceneManager::AddCameraSceneNodeFPS()
|
|
{
|
|
return AddCameraSceneNodeFPS(0, 100, 500, -1);
|
|
}
|
|
|
|
ICameraSceneNode* ISceneManager::AddCameraSceneNodeFPS(ISceneNode* parent,
|
|
float rotateSpeed, float moveSpeed, int id)
|
|
{
|
|
irr::scene::ICameraSceneNode* node =
|
|
Manager->addCameraSceneNodeFPS(parent ? parent->get_NativeSceneNode() : 0,
|
|
rotateSpeed, moveSpeed, id);
|
|
if (!node)
|
|
return 0;
|
|
return new ICameraSceneNode(node);
|
|
}
|
|
|
|
void ISceneManager::DrawAll()
|
|
{
|
|
Manager->drawAll();
|
|
}
|
|
|
|
ISceneNode* ISceneManager::AddOctTreeSceneNode(IAnimatedMesh* mesh, ISceneNode* parent, int id)
|
|
{
|
|
return AddOctTreeSceneNode(mesh, parent, id, 128);
|
|
}
|
|
|
|
ISceneNode* ISceneManager::AddOctTreeSceneNode(IAnimatedMesh* mesh, ISceneNode* parent,
|
|
int id, int minimalPolysPerNode)
|
|
{
|
|
irr::scene::ISceneNode* node = Manager->addOctTreeSceneNode(
|
|
mesh ? mesh->get_NativeAnimatedMesh() : 0,
|
|
parent ? parent->get_NativeSceneNode() : 0,
|
|
id, minimalPolysPerNode);
|
|
if (!node)
|
|
return 0;
|
|
return new ISceneNode(node);
|
|
}
|
|
|
|
ISceneNode* ISceneManager::AddOctTreeSceneNode(IMesh* mesh, ISceneNode* parent, int id)
|
|
{
|
|
return AddOctTreeSceneNode(mesh, parent, id, 128);
|
|
}
|
|
|
|
ISceneNode* ISceneManager::AddOctTreeSceneNode(IMesh* mesh, ISceneNode* parent, int id, int minimalPolysPerNode)
|
|
{
|
|
irr::scene::ISceneNode* node = Manager->addOctTreeSceneNode(
|
|
mesh ? mesh->get_NativeMesh() : 0,
|
|
parent ? parent->get_NativeSceneNode() : 0,
|
|
id, minimalPolysPerNode);
|
|
if (!node)
|
|
return 0;
|
|
return new ISceneNode(node);
|
|
}
|
|
|
|
IAnimatedMeshSceneNode* ISceneManager::AddAnimatedMeshSceneNode(IAnimatedMesh* mesh, ISceneNode* parent, int id,
|
|
Core::Vector3D position, Core::Vector3D rotation, Core::Vector3D scale)
|
|
{
|
|
irr::scene::IAnimatedMeshSceneNode* am =
|
|
Manager->addAnimatedMeshSceneNode(
|
|
mesh ? mesh->get_NativeAnimatedMesh() : 0,
|
|
parent ? parent->get_NativeSceneNode() : 0,
|
|
id,
|
|
irr::NativeConverter::getNativeVector(position),
|
|
irr::NativeConverter::getNativeVector(rotation),
|
|
irr::NativeConverter::getNativeVector(scale));
|
|
if (!am)
|
|
return 0;
|
|
|
|
return new IAnimatedMeshSceneNode(am);
|
|
}
|
|
|
|
IAnimatedMeshSceneNode* ISceneManager::AddAnimatedMeshSceneNode(IAnimatedMesh* mesh, ISceneNode* parent, int id)
|
|
{
|
|
return AddAnimatedMeshSceneNode(mesh, parent, id,
|
|
Core::Vector3D(0,0,0), Core::Vector3D(0,0,0), Core::Vector3D(1,1,1));
|
|
}
|
|
|
|
ISceneNode* ISceneManager::AddMeshSceneNode(IMesh* mesh, ISceneNode* parent, int id)
|
|
{
|
|
return AddMeshSceneNode(mesh, parent, id,
|
|
Core::Vector3D(0,0,0), Core::Vector3D(0,0,0),
|
|
Core::Vector3D(1,1,1));
|
|
}
|
|
|
|
ISceneNode* ISceneManager::AddMeshSceneNode(IMesh* mesh, ISceneNode* parent, int id,
|
|
Core::Vector3D position, Core::Vector3D rotation, Core::Vector3D scale)
|
|
{
|
|
irr::scene::ISceneNode* node =
|
|
Manager->addMeshSceneNode(mesh ? mesh->get_NativeMesh() : 0,
|
|
parent ? parent->get_NativeSceneNode() : 0,
|
|
id,
|
|
irr::NativeConverter::getNativeVector(position),
|
|
irr::NativeConverter::getNativeVector(rotation),
|
|
irr::NativeConverter::getNativeVector(scale));
|
|
if (!node)
|
|
return 0;
|
|
return new ISceneNode(node);
|
|
}
|
|
|
|
ISceneNode* ISceneManager::AddWaterSurfaceSceneNode(IMesh* mesh,
|
|
float waveHeight, float waveSpeed, float waveLenght,
|
|
ISceneNode* parent, int id)
|
|
{
|
|
irr::scene::ISceneNode* node =
|
|
Manager->addWaterSurfaceSceneNode(
|
|
mesh? mesh->get_NativeMesh() : 0,
|
|
waveHeight, waveSpeed, waveLenght,
|
|
parent ? parent->get_NativeSceneNode() : 0,
|
|
id);
|
|
if (!node)
|
|
return 0;
|
|
return new ISceneNode(node);
|
|
}
|
|
|
|
ICameraSceneNode* ISceneManager::AddCameraSceneNode(ISceneNode* parent,
|
|
Core::Vector3D position, Core::Vector3D lookat, int id)
|
|
{
|
|
irr::scene::ICameraSceneNode* cam =
|
|
Manager->addCameraSceneNode(
|
|
parent ? parent->get_NativeSceneNode() : 0,
|
|
irr::NativeConverter::getNativeVector(position),
|
|
irr::NativeConverter::getNativeVector(lookat), id);
|
|
if (!cam)
|
|
return 0;
|
|
return new ICameraSceneNode(cam);
|
|
}
|
|
|
|
ICameraSceneNode* ISceneManager::AddCameraSceneNodeMaya(ISceneNode* parent,
|
|
float rotateSpeed, float zoomSpeed, float translationSpeed, int id)
|
|
{
|
|
irr::scene::ICameraSceneNode* cam =
|
|
Manager->addCameraSceneNodeMaya(
|
|
parent ? parent->get_NativeSceneNode() : 0,
|
|
rotateSpeed, zoomSpeed, translationSpeed, id);
|
|
if (!cam)
|
|
return 0;
|
|
return new ICameraSceneNode(cam);
|
|
}
|
|
|
|
ILightSceneNode* ISceneManager::AddLightSceneNode(ISceneNode* parent,
|
|
Core::Vector3D position, Video::Colorf color, float radius, int id)
|
|
{
|
|
irr::scene::ILightSceneNode* l =
|
|
Manager->addLightSceneNode(
|
|
parent ? parent->get_NativeSceneNode() : 0,
|
|
irr::NativeConverter::getNativeVector(position),
|
|
irr::NativeConverter::getNativeColorf(color), radius, id);
|
|
|
|
if (!l)
|
|
return 0;
|
|
return new ILightSceneNode(l);
|
|
}
|
|
|
|
|
|
ITerrainSceneNode* ISceneManager::AddTerrainSceneNode(
|
|
System::String* heightMapFileName,
|
|
ISceneNode* parent, int id,
|
|
Core::Vector3D position,
|
|
Core::Vector3D scale,
|
|
Video::Color color )
|
|
{
|
|
char* strName =
|
|
(char*)(void*)System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(heightMapFileName);
|
|
|
|
irr::scene::ITerrainSceneNode* t =
|
|
Manager->addTerrainSceneNode( strName,
|
|
parent ? parent->get_NativeSceneNode() : 0,
|
|
id,
|
|
irr::NativeConverter::getNativeVector(position),
|
|
irr::core::vector3df(0,0,0),
|
|
irr::NativeConverter::getNativeVector(scale),
|
|
color.color );
|
|
|
|
System::Runtime::InteropServices::Marshal::FreeHGlobal(strName);
|
|
|
|
return t ? new ITerrainSceneNode(t) : 0;
|
|
}
|
|
|
|
|
|
IBillboardSceneNode* ISceneManager::AddBillboardSceneNode(ISceneNode* parent,
|
|
Core::Dimension2Df size, Core::Vector3D position, int id)
|
|
{
|
|
irr::scene::IBillboardSceneNode* b =
|
|
Manager->addBillboardSceneNode(
|
|
parent ? parent->get_NativeSceneNode() : 0,
|
|
irr::NativeConverter::getNativeDim(size),
|
|
irr::NativeConverter::getNativeVector(position),
|
|
id);
|
|
if (!b)
|
|
return 0;
|
|
return new IBillboardSceneNode(b);
|
|
}
|
|
|
|
ISceneNode* ISceneManager::AddSkyBoxSceneNode(Video::ITexture* top, Video::ITexture* bottom,
|
|
Video::ITexture* left, Video::ITexture* right, Video::ITexture* front,
|
|
Video::ITexture* back, ISceneNode* parent, int id)
|
|
{
|
|
irr::scene::ISceneNode* n =
|
|
Manager->addSkyBoxSceneNode(
|
|
top ? top->get_NativeTexture() : 0,
|
|
bottom ? bottom->get_NativeTexture() : 0,
|
|
left ? left->get_NativeTexture() : 0,
|
|
right ? right->get_NativeTexture() : 0,
|
|
front ? front->get_NativeTexture() : 0,
|
|
back ? back->get_NativeTexture() : 0,
|
|
parent ? parent->get_NativeSceneNode() : 0,
|
|
id);
|
|
if (!n)
|
|
return 0;
|
|
return new ISceneNode(n);
|
|
}
|
|
|
|
IParticleSystemSceneNode* ISceneManager::AddParticleSystemSceneNode(
|
|
bool withDefaultEmitter, ISceneNode* parent, int id,
|
|
Core::Vector3D position,
|
|
Core::Vector3D rotation,
|
|
Core::Vector3D scale )
|
|
{
|
|
irr::scene::IParticleSystemSceneNode* node = Manager->addParticleSystemSceneNode(
|
|
withDefaultEmitter, parent ? parent->get_NativeSceneNode() : 0,
|
|
id, irr::NativeConverter::getNativeVector( position ),
|
|
irr::NativeConverter::getNativeVector( rotation ),
|
|
irr::NativeConverter::getNativeVector( scale ) );
|
|
|
|
if (!node)
|
|
return 0;
|
|
|
|
return new IParticleSystemSceneNode( node );
|
|
}
|
|
|
|
|
|
ISceneNode* ISceneManager::AddEmptySceneNode(ISceneNode* parent, int id)
|
|
{
|
|
irr::scene::ISceneNode* n =
|
|
Manager->addEmptySceneNode(
|
|
parent ? parent->get_NativeSceneNode() : 0,
|
|
id);
|
|
if (!n)
|
|
return 0;
|
|
return new ISceneNode(n);
|
|
}
|
|
|
|
|
|
ISceneNode* ISceneManager::AddTextSceneNode(GUI::IGUIFont* font, System::String* text,
|
|
Video::Color color, ISceneNode* parent, const Core::Vector3D position, int id)
|
|
{
|
|
char* strName =
|
|
(char*)(void*)System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(text);
|
|
|
|
irr::scene::ISceneNode* n =
|
|
Manager->addTextSceneNode(
|
|
font ? font->get_NativeFont() : 0, irr::core::stringw(strName).c_str(),
|
|
irr::NativeConverter::getNativeColor(color),
|
|
parent ? parent->get_NativeSceneNode() : 0,
|
|
irr::NativeConverter::getNativeVector(position), id);
|
|
|
|
System::Runtime::InteropServices::Marshal::FreeHGlobal(strName);
|
|
|
|
if (!n)
|
|
return 0;
|
|
|
|
return new ISceneNode(n);
|
|
}
|
|
|
|
ISceneNodeAnimator* ISceneManager::CreateRotationAnimator(Core::Vector3D rotationPerSecond)
|
|
{
|
|
irr::scene::ISceneNodeAnimator* anim =
|
|
Manager->createRotationAnimator(irr::NativeConverter::getNativeVector(rotationPerSecond));
|
|
|
|
if (!anim)
|
|
return 0;
|
|
|
|
return new ISceneNodeAnimator(anim);
|
|
}
|
|
|
|
ISceneNodeAnimator* ISceneManager::CreateFlyCircleAnimator( Core::Vector3D center,
|
|
float radius, float speed)
|
|
{
|
|
irr::scene::ISceneNodeAnimator* anim =
|
|
Manager->createFlyCircleAnimator(
|
|
irr::NativeConverter::getNativeVector(center), radius, speed);
|
|
|
|
if (!anim)
|
|
return 0;
|
|
|
|
return new ISceneNodeAnimator(anim);
|
|
}
|
|
|
|
ISceneNodeAnimator* ISceneManager::CreateFlyStraightAnimator( Core::Vector3D startPoint,
|
|
Core::Vector3D endPoint, int timeForWay, bool loop)
|
|
{
|
|
irr::scene::ISceneNodeAnimator* anim =
|
|
Manager->createFlyStraightAnimator(
|
|
irr::NativeConverter::getNativeVector(startPoint),
|
|
irr::NativeConverter::getNativeVector(endPoint),
|
|
timeForWay, loop);
|
|
|
|
if (!anim)
|
|
return 0;
|
|
|
|
return new ISceneNodeAnimator(anim);
|
|
}
|
|
|
|
ISceneNodeAnimator* ISceneManager::CreateTextureAnimator( Video::ITexture* textures[],
|
|
int timePerFrame, bool loop)
|
|
{
|
|
irr::core::array<irr::video::ITexture*> tex;
|
|
for (int i=0; i<textures->Count; ++i)
|
|
tex.push_back(textures[i] == 0 ? 0 : textures[i]->get_NativeTexture());
|
|
|
|
irr::scene::ISceneNodeAnimator* anim =
|
|
Manager->createTextureAnimator(tex, timePerFrame, loop);
|
|
|
|
if (!anim)
|
|
return 0;
|
|
|
|
return new ISceneNodeAnimator(anim);
|
|
}
|
|
|
|
ISceneNodeAnimator* ISceneManager::CreateDeleteAnimator(int timeMs)
|
|
{
|
|
irr::scene::ISceneNodeAnimator* anim =
|
|
Manager->createDeleteAnimator(timeMs);
|
|
|
|
if (!anim)
|
|
return 0;
|
|
|
|
return new ISceneNodeAnimator(anim);
|
|
}
|
|
|
|
|
|
ISceneNodeAnimator* ISceneManager::CreateCollisionResponseAnimator(
|
|
ITriangleSelector* world, ISceneNode* sceneNode,
|
|
Core::Vector3D ellipsoidRadius,
|
|
Core::Vector3D gravityPerSecond,
|
|
Core::Vector3D ellipsoidTranslation,
|
|
float slidingValue)
|
|
{
|
|
if (!world || !sceneNode)
|
|
return 0;
|
|
|
|
irr::scene::ISceneNodeAnimator* anim =
|
|
Manager->createCollisionResponseAnimator(world->get_NativeTriangleSelector(),
|
|
sceneNode->get_NativeSceneNode(),
|
|
irr::NativeConverter::getNativeVector(ellipsoidRadius),
|
|
irr::NativeConverter::getNativeVector(gravityPerSecond),
|
|
irr::NativeConverter::getNativeVector(ellipsoidTranslation),
|
|
slidingValue);
|
|
|
|
if (!anim)
|
|
return 0;
|
|
|
|
return new ISceneNodeAnimator(anim);
|
|
}
|
|
|
|
|
|
ISceneNodeAnimator* ISceneManager::CreateFollowSplineAnimator(int startTime,
|
|
Core::Vector3D points[], float speed, float tightness)
|
|
{
|
|
irr::core::array<irr::core::vector3df> pos;
|
|
for (int i=0; i<points->Count; ++i)
|
|
pos.push_back(irr::NativeConverter::getNativeVector(points[i]));
|
|
|
|
irr::scene::ISceneNodeAnimator* anim =
|
|
Manager->createFollowSplineAnimator(startTime, pos, speed, tightness);
|
|
|
|
if (!anim)
|
|
return 0;
|
|
|
|
return new ISceneNodeAnimator(anim);
|
|
}
|
|
|
|
|
|
ITriangleSelector* ISceneManager::CreateTriangleSelector(IMesh* mesh, ISceneNode* node)
|
|
{
|
|
if (!mesh || !node)
|
|
return 0;
|
|
|
|
irr::scene::ITriangleSelector* s = Manager->createTriangleSelector(mesh->get_NativeMesh(),
|
|
node->get_NativeSceneNode());
|
|
if (!s)
|
|
return 0;
|
|
|
|
return new ITriangleSelector(s);
|
|
}
|
|
|
|
ITriangleSelector* ISceneManager::CreateTriangleSelectorFromBoundingBox(ISceneNode* node)
|
|
{
|
|
if (!node)
|
|
return 0;
|
|
|
|
irr::scene::ITriangleSelector* s = Manager->createTriangleSelectorFromBoundingBox(
|
|
node->get_NativeSceneNode());
|
|
if (!s)
|
|
return 0;
|
|
|
|
return new ITriangleSelector(s);
|
|
}
|
|
|
|
ITriangleSelector* ISceneManager::CreateOctTreeTriangleSelector(IMesh* mesh,
|
|
ISceneNode* node, int minimalPolysPerNode)
|
|
{
|
|
if (!mesh || !node)
|
|
return 0;
|
|
|
|
irr::scene::ITriangleSelector* s = Manager->createOctTreeTriangleSelector(mesh->get_NativeMesh(),
|
|
node->get_NativeSceneNode(), minimalPolysPerNode);
|
|
if (!s)
|
|
return 0;
|
|
|
|
return new ITriangleSelector(s);
|
|
}
|
|
|
|
IMetaTriangleSelector* ISceneManager::CreateMetaTriangleSelector()
|
|
{
|
|
irr::scene::IMetaTriangleSelector* ms = Manager->createMetaTriangleSelector();
|
|
if (!ms)
|
|
return 0;
|
|
|
|
return new IMetaTriangleSelector(ms);
|
|
}
|
|
|
|
ITriangleSelector* ISceneManager::CreateTerrainTriangleSelector(
|
|
ITerrainSceneNode* node, int LOD)
|
|
{
|
|
irr::scene::ITriangleSelector* ms = Manager->createTerrainTriangleSelector(
|
|
node ? (irr::scene::ITerrainSceneNode*)node->get_NativeSceneNode() : 0, LOD);
|
|
|
|
if (!ms)
|
|
return 0;
|
|
|
|
return new ITriangleSelector(ms);
|
|
}
|
|
|
|
ISceneCollisionManager* ISceneManager::get_SceneCollisionManager()
|
|
{
|
|
return SCM;
|
|
}
|
|
|
|
ICameraSceneNode* ISceneManager::get_ActiveCamera()
|
|
{
|
|
irr::scene::ICameraSceneNode* active = Manager->getActiveCamera();
|
|
return active ? new ICameraSceneNode(active) : 0;
|
|
}
|
|
|
|
void ISceneManager::set_ActiveCamera(ICameraSceneNode* camera)
|
|
{
|
|
irr::scene::ICameraSceneNode* node = 0;
|
|
if (camera)
|
|
node = camera->get_NativeCameraSceneNode();
|
|
|
|
Manager->setActiveCamera(node);
|
|
}
|
|
|
|
IAnimatedMesh* ISceneManager::AddHillPlaneMesh(System::String* name,
|
|
Core::Dimension2Df tileSize, Core::Dimension2D tileCount,
|
|
Video::Material material, float hillHeight, Core::Dimension2Df countHills,
|
|
Core::Dimension2Df textureRepeatCount )
|
|
{
|
|
char* strName =
|
|
(char*)(void*)System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(name);
|
|
|
|
irr::scene::IAnimatedMesh* a =
|
|
Manager->addHillPlaneMesh(strName,
|
|
irr::NativeConverter::getNativeDim(tileSize),
|
|
irr::NativeConverter::getNativeDim(tileCount),
|
|
&irr::NativeConverter::getNativeMaterial(material),
|
|
hillHeight,
|
|
irr::NativeConverter::getNativeDim(countHills),
|
|
irr::NativeConverter::getNativeDim(textureRepeatCount));
|
|
|
|
System::Runtime::InteropServices::Marshal::FreeHGlobal(strName);
|
|
|
|
return a ? new IAnimatedMesh(a) : 0;
|
|
}
|
|
|
|
|
|
void ISceneManager::set_ShadowColor(Video::Color color)
|
|
{
|
|
Manager->setShadowColor(color.color);
|
|
}
|
|
|
|
Video::Color ISceneManager::get_ShadowColor()
|
|
{
|
|
return Video::Color(Manager->getShadowColor().color);
|
|
}
|
|
|
|
Irrlicht::Scene::IMeshManipulator* ISceneManager::get_MeshManipulator()
|
|
{
|
|
return Manipulator;
|
|
}
|
|
|
|
void ISceneManager::Clear()
|
|
{
|
|
Manager->clear();
|
|
}
|
|
|
|
ISceneNode* ISceneManager::get_RootSceneNode()
|
|
{
|
|
return Root;
|
|
}
|
|
|
|
|
|
void ISceneManager::LoadScene(System::String* filename)
|
|
{
|
|
char* str = (char*)(void*)
|
|
System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(filename);
|
|
|
|
Manager->loadScene(str);
|
|
|
|
System::Runtime::InteropServices::Marshal::FreeHGlobal(str);
|
|
}
|
|
|
|
|
|
void ISceneManager::SaveScene(System::String* filename)
|
|
{
|
|
char* str = (char*)(void*)
|
|
System::Runtime::InteropServices::Marshal::StringToHGlobalAnsi(filename);
|
|
|
|
Manager->saveScene(str);
|
|
|
|
System::Runtime::InteropServices::Marshal::FreeHGlobal(str);
|
|
}
|
|
|
|
|
|
}
|
|
}
|