void ArMoveProperty::UpdateRotation(ArGameEntity* srcEntity, const DiK2Pos& targetPos, float dt, int turnRate)
{
DiK2RenderObject* renderObj = srcEntity->GetRenderObj();
auto newPos = renderObj->GetPosition();
DiVec3 direction = DiVec3(targetPos.x, 0, targetPos.z) - DiVec3(newPos.x, 0, newPos.z);
direction.y = 0;
direction.normalise();
float yawToGoal;
DiVec3 srcVec = renderObj->GetRotQuat() * DiVec3::UNIT_Z;
if ((1.0f + srcVec.dotProduct(direction)) < 0.0001f)
yawToGoal = 180;
else
{
DiQuat toGoal = renderObj->GetRotQuat().zAxis().getRotationTo(direction);
yawToGoal = toGoal.getYaw().valueDegrees();
}
float yawAtSpeed = yawToGoal / DiMath::Abs(yawToGoal) * dt * ((float)turnRate);
if (yawToGoal < 0)
yawToGoal = std::min<float>(0, std::max<float>(yawToGoal, yawAtSpeed));
else if (yawToGoal > 0)
yawToGoal = std::max<float>(0, std::min<float>(yawToGoal, yawAtSpeed));
DiQuat actorOrientation = renderObj->GetRotQuat();
actorOrientation = DiQuat(DiDegree(yawToGoal), DiVec3::UNIT_Y) * actorOrientation;
float rotrad = actorOrientation.getYaw().valueRadians();
renderObj->SetRotation(rotrad);
}
DiVec3 DiFocusedShadowPolicy::getNearCameraPoint_ws(const DiMat4& viewMatrix,
const PointListBody& bodyLVS) const
{
if (bodyLVS.getPointCount() == 0)
return DiVec3(0,0,0);
DiVec3 nearEye = viewMatrix * bodyLVS.getPoint(0), // for comparison
nearWorld = bodyLVS.getPoint(0); // represents the final point
// store the vertex with the highest z-value which is the nearest point
for (size_t i = 1; i < bodyLVS.getPointCount(); ++i)
{
const DiVec3& vWorld = bodyLVS.getPoint(i);
// comparison is done from the viewer
DiVec3 vEye = viewMatrix * vWorld;
if (vEye.z > nearEye.z)
{
nearEye = vEye;
nearWorld = vWorld;
}
}
return nearWorld;
}
void DiCircleEmitter::InitParticlePosition(DiParticle* particle)
{
float angle = 0;
if (mRandom)
{
angle = DiMath::RangeRandom(0, DiMath::TWO_PI);
}
else
{
mCircleAngle += mStep;
mCircleAngle = mCircleAngle > DiMath::TWO_PI ? mCircleAngle - DiMath::TWO_PI : mCircleAngle;
angle = mCircleAngle;
}
mX = DiMath::Cos(angle);
mZ = DiMath::Sin(angle);
DiParticleSystem* sys = mParentElement->GetParentSystem();
if (sys)
{
particle->position = GetDerivedPosition() +
sys->GetDerivedOrientation() * mOrientation * (mEmitterScale * DiVec3(mX * mRadius, 0, mZ * mRadius));
}
else
{
particle->position = GetDerivedPosition() + mEmitterScale * ( mOrientation * DiVec3(mX * mRadius, 0, mZ * mRadius) );
}
particle->originalPosition = particle->position;
}
void DiCameraHelper::SetYawPitchDist( DiRadian yaw, DiRadian pitch, float dist )
{
mCamera->SetPosition(mTarget);
mCamera->SetOrientation(DiQuat::IDENTITY);
mCamera->Yaw(yaw);
mCamera->Pitch(-pitch);
mCamera->MoveRelative(DiVec3(0, 0, dist));
}
void DiCameraHelper::OnMouseMove(const OIS::MouseEvent& evt)
{
if (!mEnabled)
return;
mMousePos.x = evt.state.X.abs;
mMousePos.y = evt.state.Y.abs;
if (mStyle == CS_ORBIT)
{
float dist = (mCamera->GetPosition() - mTarget).length();
if (mOrbiting)
{
mCamera->SetPosition(mTarget);
mCamera->Yaw(DiDegree(-evt.state.X.rel * 0.25f));
mCamera->Pitch(DiDegree(-evt.state.Y.rel * 0.25f));
mCamera->MoveRelative(DiVec3(0, 0, dist));
}
else if (mZooming)
{
mCamera->MoveRelative(DiVec3(0, 0, evt.state.Y.rel * 0.004f * dist));
}
else if (evt.state.Z.rel != 0)
{
mCamera->MoveRelative(DiVec3(0, 0, -evt.state.Z.rel * 0.0008f * dist));
}
else if (mMoving)
{
DiVec3 vec = DiVec3((float)-evt.state.X.rel, (float)evt.state.Y.rel, 0.0f);
mCamera->MoveRelative(vec);
DiVec3 trans = mCamera->GetOrientation() * vec;
mTarget += trans;
}
}
else if (mStyle == CS_FREELOOK)
{
mCamera->Yaw(DiDegree(-evt.state.X.rel * 0.15f));
mCamera->Pitch(DiDegree(-evt.state.Y.rel * 0.15f));
}
}
void DiCircleEmitter::InitParticleDirection(DiParticle* particle)
{
if (mAutoDirection)
{
DiRadian angle;
GenerateAngle(angle);
if (angle != DiRadian(0))
{
particle->direction = (mOrientation * DiVec3(mX, 0, mZ) ).randomDeviant(angle, mUpVector);
particle->originalDirection = particle->direction;
}
else
{
particle->direction = DiVec3(mX, 0, mZ);
particle->direction = mOrientation * DiVec3(mX, 0, mZ);
}
}
else
{
DiParticleEmitter::InitParticleDirection(particle);
}
}
void InitScene()
{
DiSceneManager* sm = DiBase::Driver->GetSceneManager();
sm->SetAmbientColor(DiColor(0.1f,0.1f,0.1f,0.1f));
DiDirLight* dirlight = sm->CreateDirLight();
dirlight->SetColor(DiColor());
dirlight->SetDirection(DiVec3(1,1,2).normalisedCopy());
AddMeshes();
SetupPostEffects();
}
//-----------------------------------------------------------------------
void DiMat4::decomposition(DiVec3& position, DiVec3& scale, DiQuat& orientation) const
{
DI_ASSERT(isAffine());
DiMat3 m3x3;
extract3x3Matrix(m3x3);
DiMat3 matQ;
DiVec3 vecU;
m3x3.QDUDecomposition( matQ, scale, vecU );
orientation = DiQuat( matQ );
position = DiVec3( m[0][3], m[1][3], m[2][3] );
}
void CurveEditor::RefreshCurve()
{
std::vector<MyGUI::FloatPoint> linepoints;
// line
if (!mSplineButton->getStateSelected())
{
for (auto btn : mButtons)
{
auto pos = btn->getPosition();
linepoints.push_back(MyGUI::FloatPoint(pos.left + 7, pos.top + 7));
}
}
else
{
int nums = 100;
float step = 1.0f / nums;
DiSpline spline;
for (auto btn : mButtons)
{
auto pos = btn->getPosition();
spline.AddPoint(DiVec3(pos.left + 7, pos.top + 7, 0));
}
for (int i = 0; i < nums; i++)
{
auto v = spline.Interpolate(i*step);
linepoints.push_back(MyGUI::FloatPoint(v.x, v.y));
}
}
mCurveCanvas->setPoints(linepoints);
RefreshDynAttribute();
}
void InitScene()
{
DiSceneManager* sm = DiBase::Driver->GetSceneManager();
sm->SetAmbientColor(DiColor(0.6f, 0.6f, 0.6f));
float scale = 0.5f;
DiDirLightPtr dirlight;
dirlight = make_shared<DiDirLight>();
DiCullNode* dirNode = sm->GetRootNode()->CreateChild();
dirNode->AttachObject(dirlight);
dirlight->SetColor(DiColor(0.8f,0.8f,0.8f));
dirlight->SetDirection(DiVec3(0.3f,-0.7f,0.4).normalisedCopy());
//dirlight->InitForShadowCasting(sm, ShadowTextureConfig(1024,1024,PF_A32B32G32R32F));
auto pos = DiVec3(150,275,130)*2;
dirNode->SetPosition(pos);
DiCullNode* spotNode = sm->GetRootNode()->CreateChild();
DiSpotLightPtr sptLt = make_shared<DiSpotLight>();
spotNode->AttachObject(sptLt);
//spotNode->SetPosition(50, 100, 40);
spotNode->SetPosition(pos);
sptLt->SetDirection((-pos).normalisedCopy());
sptLt->SetRange( DiDegree(80), DiDegree(90) );
sptLt->InitForShadowCasting(sm, ShadowTextureConfig(1024,1024,PF_A32B32G32R32F));
sptLt->mShadowCameraNear = 50;
sptLt->mShadowCameraFar = 200;
sptLt->mShadowCameraFov = 50;
sptLt->_UpdateShadowCamera();
DiDebugHelperPtr dbghelper;
auto mat = DiMaterial::QuickCreate("lambert_v", "lambert_p", SHADER_FLAG_SHADOW_RECEIVER);
mat->SetAmbient(DiColor(0.8f, 0.8f, 0.8f));
mat->SetDiffuse(DiColor(0.8f, 0.8f, 0.8f));
dbghelper = make_shared<DiDebugHelper>();
sm->GetRootNode()->AttachObject(dbghelper);
DiMaterialPtr helpermat = DiMaterial::QuickCreate("basic_v", "basic_p", SHADER_FLAG_USE_COLOR);
helpermat->SetDepthCheck(false);
dbghelper->SetMaterial(helpermat);
//dbghelper->AddFrustum(dirlight->GetShadowCamera(0), DiColor::Red);
hp = dbghelper.get();
lt = sptLt.get();
#if 0
DiSimpleShapePtr plane = make_shared<DiSimpleShape>();
plane->SetShadowCastEnable(false);
plane->CreatePlane(600, 600);
plane->SetMaterial(mat);
plane->GetMaterial()->SetDiffuse(DiColor::White);
DiCullNode* planeNode = sm->GetRootNode()->CreateChild();
planeNode->AttachObject(plane);
planeNode->Translate(0, 0, 0);
const int size = 1;
for (int i = -size; i <= size; i++)
{
for (int j = -size; j <= size; j++)
{
DiMaterialPtr mat = DiMaterial::QuickCreate("lambert_v", "lambert_p", SHADER_FLAG_SKINNED | SHADER_FLAG_SHADOW_RECEIVER);
mat->SetDiffuse(DiColor(1, 1, 1));
mat->SetAmbient(DiColor(0.7f, 0.7f, 0.7f));
DiString name;
name.Format("md_%d_%d", i, j);
DiAnimModelPtr model = make_shared<DiAnimModel>(name, "robot.model", "robot.motion");
//DiModelPtr model = make_shared<DiModel>(name, "robot.model");
model->SetMaterial(mat);
model->SetShadowCastEnable(true);
model->SetAutoUpdateAnims(true);
model->GetClipSet()->GetClipController("Walk")->SetEnabled(true);
DiCullNode* cullnode = sm->GetRootNode()->CreateChild();
cullnode->AttachObject(model);
cullnode->SetPosition(i * 140.0f, 0, j * 140.0f);
}
}
#else
DiSimpleShapePtr plane = make_shared<DiSimpleShape>();
plane->SetShadowCastEnable(false);
plane->CreatePlane(300, 300);
plane->SetMaterial(mat);
plane->GetMaterial()->SetDiffuse(DiColor::White);
DiCullNode* planeNode = sm->GetRootNode()->CreateChild();
planeNode->AttachObject(plane);
DiMaterialPtr m = DiMaterial::QuickCreate("basic_v", "basic_p", SHADER_FLAG_SHADOW_RECEIVER);
m->SetDiffuse(DiColor(0.9f, 0.9f, 0.9f));
DiSimpleShapePtr box = make_shared<DiSimpleShape>();
box->SetShadowCastEnable(true);
box->CreateBox(10);
box->SetMaterial(m);
DiCullNode* cullnode = sm->GetRootNode()->CreateChild();
cullnode->SetPosition(0,5,0);
cullnode->AttachObject(box);
#endif
//SetupScene();
DiCamera* camera = sm->GetCamera();
camera->SetNearClipDistance(5);
camera->SetFarClipDistance(5000);
}
void InitScene()
{
DiSceneManager* sm = DiBase::Driver->GetSceneManager();
mat = DiMaterial::QuickCreate("lambert_v", "lambert_p");
mat->SetDiffuse(DiColor::White);
sm->SetAmbientColor(DiColor(0.1f, 0.1f, 0.1f, 0.1f));
DiDirLightPtr dirlight = make_shared<DiDirLight>();
sm->AttachObject(dirlight);
dirlight->SetColor(DiColor());
dirlight->SetDirection(DiVec3(-1, -1, -2).normalisedCopy());
int amount = 2;
DiCullNode* parent = sm->GetRootNode();
for (int i = 0; i < amount; i++)
{
DiSimpleShapePtr model = make_shared<DiSimpleShape>();
model->CreateBox(10);
model->SetMaterial(mat);
DiCullNode* node = parent->CreateChild();
node->AttachObject(model);
node->Translate(10, 0, 0);
nodes.push_back(node);
parent = node;
}
parent = sm->GetRootNode();
for (int i = 0; i < amount; i++)
{
DiSimpleShapePtr model = make_shared<DiSimpleShape>();
model->CreateBox(10);
model->SetMaterial(mat);
DiCullNode* node = parent->CreateChild();
node->AttachObject(model);
node->Translate(-10, 0, 0);
nodes.push_back(node);
parent = node;
}
parent = sm->GetRootNode();
for (int i = 0; i < amount; i++)
{
DiSimpleShapePtr model = make_shared<DiSimpleShape>();
model->CreateBox(10);
model->SetMaterial(mat);
DiCullNode* node = parent->CreateChild();
node->AttachObject(model);
node->Translate(0, 10, 0);
nodes.push_back(node);
parent = node;
}
parent = sm->GetRootNode();
for (int i = 0; i < amount; i++)
{
DiSimpleShapePtr model = make_shared<DiSimpleShape>();
model->CreateBox(10);
model->SetMaterial(mat);
DiCullNode* node = parent->CreateChild();
node->AttachObject(model);
node->Translate(0, -10, 0);
nodes.push_back(node);
parent = node;
}
parent = sm->GetRootNode();
for (int i = 0; i < amount; i++)
{
DiSimpleShapePtr model = make_shared<DiSimpleShape>();
model->CreateBox(10);
model->SetMaterial(mat);
DiCullNode* node = parent->CreateChild();
node->AttachObject(model);
node->Translate(0, 0, 10);
nodes.push_back(node);
parent = node;
}
parent = sm->GetRootNode();
for (int i = 0; i < amount; i++)
{
DiSimpleShapePtr model = make_shared<DiSimpleShape>();
model->CreateBox(10);
model->SetMaterial(mat);
DiCullNode* node = parent->CreateChild();
node->AttachObject(model);
node->Translate(0, 0, -10);
nodes.push_back(node);
parent = node;
}
}
void SetupWater(DiSceneManager* sm)
{
// Render targets
auto reflectMap = DiAssetManager::GetInstance().CreateOrReplaceAsset<DiTexture>("reflect_rt");
reflectMap->SetDimensions(512, 512);
reflectMap->SetFormat(PF_A8R8G8B8);
reflectMap->SetUsage(TU_RENDER_TARGET);
reflectMap->SetAutoMipmap(false);
reflectMap->SetAddressing(AM_CLAMP);
reflectMap->CreateTexture();
auto reflectRT = reflectMap->GetRenderTarget();
auto refractMap = DiAssetManager::GetInstance().CreateOrReplaceAsset<DiTexture>("refract_rt");
refractMap->SetDimensions(512, 512);
refractMap->SetFormat(PF_A8R8G8B8);
refractMap->SetUsage(TU_RENDER_TARGET);
refractMap->SetAutoMipmap(false);
refractMap->SetAddressing(AM_CLAMP);
refractMap->CreateTexture();
auto refractRT = refractMap->GetRenderTarget();
// Water plane
DiCullNode* nodePlane = sm->GetRootNode()->CreateChild();
DiSimpleShapePtr model = make_shared<DiSimpleShape>();
model->CreatePlane(100);
auto waterMat = DiMaterial::QuickCreate("pool_fresnel_v", "pool_fresnel_p");
auto shaderParam = waterMat->GetShaderParameter();
shaderParam->WriteFloat("scale", 1.0f);
shaderParam->WriteFloat("scroll", 0.05f);
shaderParam->WriteFloat("fresnelBias", -0.1f);
shaderParam->WriteFloat("fresnelScale", 1.8f);
shaderParam->WriteFloat("fresnelPower", 8.0f);
shaderParam->WriteFloat("noiseScale", 0.05f);
shaderParam->WriteFloat4("tintColour", DiVec4(0, 0.05f, 0.05f, 1));
shaderParam->WriteTexture2D("noiseMap", "waves2.dds");
shaderParam->WriteTexture2D("reflectMap", "reflect_rt");
shaderParam->WriteTexture2D("refractMap", "refract_rt");
model->SetMaterial(waterMat);
nodePlane->AttachObject(model);
nodePlane->SetScale(7, 1, 13);
// Add to scene manager with the callbacks
DiCamera* cam = sm->GetCamera();
cam->MoveRelative(DiVec3(0, 0, 700));
sm->AddExtraRenderTarget(refractRT, cam,
[nodePlane](DiRenderTarget*) {
nodePlane->SetVisible(false);
},
[nodePlane](DiRenderTarget*) {
nodePlane->SetVisible(true);
}
);
sm->AddExtraRenderTarget(reflectRT, cam,
[nodePlane, cam](DiRenderTarget*) {
nodePlane->SetVisible(false);
cam->EnableReflection(DiPlane(DiVec3::UNIT_Y, 0));
},
[nodePlane, cam](DiRenderTarget*) {
nodePlane->SetVisible(true);
cam->DisableReflection();
}
);
DiPostEffectManager* peMgr = DiBase::Driver->GetMainRenderWindow()->GetPostEffectManager();
DiPostEffect* bloom = peMgr->GetEffect("Bloom");
if (bloom)
bloom->SetEnable(false);
}
void InitFx_Repeater01()
{
// effect
auto _ps = DiEffectManager::GetInstance().CreateParticleSystemTemplate("Fx_repeater1");
std::shared_ptr<DiTransformUnit> ps(_ps);
_ps->Start();
{
DiParticleElement* element = _ps->CreateElement();
element->SetRenderer("Billboard");
auto emitter = element->CreateEmitter("Box");
auto mat = DiMaterial::QuickCreate("basic_v", "basic_p", SHADER_FLAG_USE_COLOR | SHADER_FLAG_USE_MAP);
mat->GetShaderParameter()->WriteTexture2D("map", "glow_01.dds");
mat->SetBlendMode(BLEND_ADD);
mat->SetDepthWrite(false);
element->SetMaterialName(mat->GetName());
((DiBoxEmitter*)emitter)->SetWidth(50);
((DiBoxEmitter*)emitter)->SetHeight(70);
((DiBoxEmitter*)emitter)->SetDepth(50);
emitter->position = DiVec3(0, 165, 5);
auto rt = DI_NEW DiAttributeFixed();
rt->SetValue(30);
emitter->SetDynEmissionRate(rt);
auto spd = DI_NEW DiAttributeFixed();
spd->SetValue(20);
emitter->SetDynVelocity(spd);
auto ttl = DI_NEW DiAttributeRandom();
ttl->SetMinMax(1, 2);
emitter->SetDynTotalTimeToLive(ttl);
auto sz = DI_NEW DiAttributeRandom();
sz->SetMinMax(20, 40);
emitter->SetDynParticleAllDimensions(sz);
DiColorController* colorCtrl = (DiColorController*)element->CreateController("Color");
colorCtrl->AddColour(0, DiColor::Black);
colorCtrl->AddColour(0.5f, DiColor(0.25f, 1, 0.5f));
colorCtrl->AddColour(1, DiColor::Black);
}
{
DiParticleElement* element = _ps->CreateElement();
element->SetRenderer("Billboard");
auto emitter = element->CreateEmitter("Box");
auto mat = DiMaterial::QuickCreate("basic_v", "basic_p", SHADER_FLAG_USE_COLOR | SHADER_FLAG_USE_MAP);
auto texture = mat->GetShaderParameter()->WriteTexture2D("map", "mysticenergy2.dds");
mat->SetBlendMode(BLEND_ADD);
mat->SetDepthWrite(false);
element->SetMaterialName(mat->GetName());
texture->SetAddressing(AM_CLAMP);
((DiBoxEmitter*)emitter)->SetWidth(50);
((DiBoxEmitter*)emitter)->SetHeight(70);
((DiBoxEmitter*)emitter)->SetDepth(50);
emitter->position = DiVec3(0, 165, 5);
auto rt = DI_NEW DiAttributeFixed();
rt->SetValue(6);
emitter->SetDynEmissionRate(rt);
auto spd = DI_NEW DiAttributeFixed();
spd->SetValue(20);
emitter->SetDynVelocity(spd);
auto ttl = DI_NEW DiAttributeRandom();
ttl->SetMinMax(1, 2);
emitter->SetDynTotalTimeToLive(ttl);
auto sz = DI_NEW DiAttributeRandom();
sz->SetMinMax(20, 40);
emitter->SetDynParticleAllDimensions(sz);
DiColorController* colorCtrl = (DiColorController*)element->CreateController("Color");
colorCtrl->AddColour(0, DiColor::Black);
colorCtrl->AddColour(0.5f, DiColor(0.25f, 1, 0.5f));
colorCtrl->AddColour(1, DiColor::Black);
DiTextureRotatorController* texrotCtrl = (DiTextureRotatorController*)element->CreateController("TextureRotator");
texrotCtrl->SetUseOwnRotationSpeed(true);
auto rotspeed = DI_NEW DiAttributeRandom();
rotspeed->SetMinMax(-100, 100);
texrotCtrl->SetRotationSpeed(rotspeed);
auto rot = DI_NEW DiAttributeRandom();
rot->SetMinMax(0, 300);
texrotCtrl->SetRotation(rot);
}
// create the editor object from the particle system
DiEditorManager::Get()->LoadParticleSystem(_ps);
}
void HonFxerApp::OpenImpl()
{
DemiDemo::OpenImpl();
DI_INSTALL_PLUGIN(DiFx);
DI_INSTALL_PLUGIN(DiK2);
Driver->GetMainRenderWindow()->SetForceRenderToCanvas(true);
DiPostEffectManager* peMgr = DiBase::Driver->GetMainRenderWindow()->GetPostEffectManager();
peMgr->SetManualOutputTarget(DiBase::Driver->GetMainRenderWindow()->GetSceneCanvas());
DiBase::Driver->GetMainRenderWindow()->GetRenderBuffer()->SetClearColor(DiColor(0.2f, 0.2f, 0.2f));
DiBase::Driver->GetMainRenderWindow()->GetSceneCanvas()->SetClearColor(DiColor(0.2f, 0.2f, 0.2f));
DiSceneManager* sm = DiBase::Driver->GetSceneManager();
sm->SetAmbientColor(DiColor(0.3f, 0.3f, 0.3f));
DiDirLightPtr dirlight;
dirlight = make_shared<DiDirLight>();
DiCullNode* dirNode = sm->GetRootNode()->CreateChild();
dirNode->AttachObject(dirlight);
dirlight->SetColor(DiColor());
dirlight->SetDirection(DiVec3(0, -0.3f, -0.4).normalisedCopy());
//////////////////////////////////////////////////////////////////////////
new CommandManager();
CommandManager::getInstance().initialise();
new HotKeyManager();
HotKeyManager::getInstance().initialise();
MyGUI::FactoryManager::getInstance().registerFactory<MyGUI::RTTLayer>("Layer");
MyGUI::FactoryManager::getInstance().registerFactory<MyGUI::FilterNone>("BasisSkin");
MyGUI::ResourceManager::getInstance().load("FxEditorLayers.xml");
MyGUI::ResourceManager::getInstance().load("FxToolbar.xml");
MyGUI::ResourceManager::getInstance().load("FxHotkeys.xml");
DiString userSettings = DiPathLib::GetApplicationPath() + "FxSettings.xml";
new SettingsManager();
SettingsManager::getInstance().initialise(userSettings.c_str());
std::string mLocale = "English";
MyGUI::LanguageManager::getInstance().setCurrentLanguage(mLocale);
new MessageBoxManager();
MessageBoxManager::getInstance().initialise();
new ColourManager();
ColourManager::getInstance().initialise();
MyGUI::ResourceManager::getInstance().load("FxInitialise.xml");
MyGUI::FactoryManager& factory = MyGUI::FactoryManager::getInstance();
factory.registerFactory<MyGUI::TreeControl>("Widget");
factory.registerFactory<MyGUI::TreeControlItem>("Widget");
MyGUI::ResourceManager::getInstance().load("TreeControlSkin.xml");
MyGUI::ResourceManager::getInstance().load("TreeItemIcons.xml");
CommandManager::getInstance().registerCommand("Command_Quit", MyGUI::newDelegate(this, &HonFxerApp::Command_QuitApp));
CommandManager::getInstance().registerCommand("Command_Export", MyGUI::newDelegate(this, &HonFxerApp::Command_Export));
CommandManager::getInstance().registerCommand("Command_ResLocation", MyGUI::newDelegate(this, &HonFxerApp::Command_ResLocation));
CommandManager::getInstance().registerCommand("Command_GameLocation", MyGUI::newDelegate(this, &HonFxerApp::Command_GameLocation));
CommandManager::getInstance().registerCommand("Command_ViewHelp", MyGUI::newDelegate(this, &HonFxerApp::Command_ViewHelp));
mMainPane = new MainPaneControl();
new DialogManager();
DialogManager::getInstance().initialise();
DI_NEW DiEditorManager();
#if 0
DiBase::CommandMgr->ExecuteCommand("selectLast");
DiBase::CommandMgr->ExecuteCommand("createChild ParticleSystem");
DiBase::CommandMgr->ExecuteCommand("selectLast");
DiBase::CommandMgr->ExecuteCommand("createChild ParticleElement");
DiBase::CommandMgr->ExecuteCommand("selectLast");
DiBase::CommandMgr->ExecuteCommand("createChild PointEmitter");
DiBase::CommandMgr->ExecuteCommand("selectLast");
#endif
mSetResLocWindow = new SetResLocWindow();
mSetResLocWindow->eventEndDialog = MyGUI::newDelegate(this, &HonFxerApp::NotifySetResLocWindowEndDialog);
mSetGameLocWindow = new SetGameLocWindow();
mSetGameLocWindow->eventEndDialog = MyGUI::newDelegate(this, &HonFxerApp::NotifySetGameLocWindowEndDialog);
mCameraHelper->UseShiftKeyToOrbit(true);
//InitFx_Repeater01();
}
