void DiK2World::Load(const DiString& path)
{
DI_LOG("Loading world: %s", path.c_str());
DiK2WorldSerial serial;
serial.Load(path,this);
mRootNode->AttachObject(mTerrain);
// sun light
mSun = make_shared<DiDirLight>();
DiSceneManager* sm = DiBase::Driver->GetSceneManager();
DiCullNode* dirNode = sm->GetRootNode()->CreateChild();
dirNode->AttachObject(mSun);
mSun->SetColor(DiColor());
DiRadian altitude(DiDegree(mConfigs.mSunAltitude));
DiVec3 dir(0,-DiMath::Sin(altitude),DiMath::Cos(altitude));
DiRadian azimuth(DiDegree(mConfigs.mSunAzimuth));
DiQuat rot(azimuth, DiVec3::UNIT_Y);
dir = rot * dir;
mSun->SetDirection(dir);
sm->SetAmbientColor(DiColor());
Demi::DiRenderBatchGroup* group = Driver->GetPipeline()->GetBatchGroup(Demi::BATCH_MODEL);
group->SetPreProcess([this](){
Driver->GetPipeline()->GetShaderEnvironment()->globalAmbient = mConfigs.mEntityAmbient;
Driver->GetPipeline()->GetShaderEnvironment()->dirLightsColor[0] = mConfigs.mEntitySunColor;
});
}
void AddMeshes()
{
DiSceneManager* sm = DiBase::Driver->GetSceneManager();
DiCullNode* cullnode = sm->GetRootNode()->CreateChild();
DiModelPtr model = make_shared<DiModel>("sponza_model","sponza.model");
cullnode->AttachObject(model);
cullnode->SetScale(6,6,6);
//sm->GetCamera()->SetFarClipDistance(200);
}
void InitScene()
{
DiSceneManager* sm = DiBase::Driver->GetSceneManager();
sm->AttachObject(make_shared<DiModel>("columns", "columns.model"));
sm->AttachObject(make_shared<DiModel>("bathlower", "romanbathlower.model"));
sm->AttachObject(make_shared<DiModel>("bathupper", "romanbathupper.model"));
sm->GetSkybox()->Enable(1000, "park.dds");
SetupWater(sm);
}
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 DiBaseEditorObj::OnCreate()
{
DiSceneManager* sm = DiBase::Driver->GetSceneManager();
if(!mParent)
{
mSceneNode = sm->GetRootNode()->CreateChild();
}
else
{
mSceneNode = mParent->GetSceneNode()->CreateChild();
}
mGizmo = DI_NEW DiTransGizmo(this);
mGizmo->Show(false);
}
void DiFocusedShadowPolicy::calculateB(const DiSceneManager& sm, const DiCamera& cam,
const DiLight& light, const DiAABB& sceneBB, const DiAABB& receiverBB,
PointListBody *out_bodyB) const
{
DI_ASSERT_MESSAGE(out_bodyB != NULL, "bodyB vertex list is NULL");
/// perform convex intersection of the form B = ((V \cap S) + l) \cap S \cap L
// get V
mBodyB.define(cam);
if (light.GetType() != LIGHT_DIRECTIONAL)
{
if (mUseAggressiveRegion)
mBodyB.clip(sceneBB);
// form a convex hull of bodyB with the light position
mBodyB.extend(light.GetDerivedPosition());
// clip bodyB with sceneBB
mBodyB.clip(sceneBB);
// clip with the light frustum
// set up light camera to clip with the resulting frustum planes
if (!mLightFrustumCameraCalculated)
{
calculateShadowMappingMatrix(sm, cam, light, NULL, NULL, mLightFrustumCamera);
mLightFrustumCameraCalculated = true;
}
mBodyB.clip(*mLightFrustumCamera);
// extract bodyB vertices
out_bodyB->build(mBodyB);
}
else
{
// For directional lights, all we care about is projecting the receivers
// backwards towards the light, clipped by the camera region
mBodyB.clip(receiverBB);
// Also clip based on shadow far distance if appropriate
float farDist = sm.GetShadowFarDistance();
if (farDist)
{
DiVec3 pointOnPlane = cam.GetDerivedPosition() +
(cam.GetDerivedDirection() * farDist);
DiPlane p(cam.GetDerivedDirection(), pointOnPlane);
mBodyB.clip(p);
}
// Extrude the intersection bodyB into the inverted light direction and store
// the info in the point list.
// Maximum extrusion extent is to the shadow far distance
out_bodyB->buildAndIncludeDirection(mBodyB,
farDist ? farDist : cam.GetNearClipDistance() * 3000,
-light.GetDerivedDirection());
}
}
void DiFocusedShadowPolicy::calculateShadowMappingMatrix(const DiSceneManager& sm,
const DiCamera& cam, const DiLight& light, DiMat4 *out_view, DiMat4 *out_proj,
DiCamera *out_cam) const
{
DiVec3 lightPos = light.GetDerivedPosition();
DiVec3 lightDir = light.GetDerivedDirection();
// get the shadow frustum's far distance
float shadowDist = sm.GetShadowFarDistance();
if (!shadowDist)
{
// need a shadow distance, make one up
shadowDist = cam.GetNearClipDistance() * 3000;
}
float shadowOffset = shadowDist * sm.GetShadowDirLightTextureOffset();
if (light.GetType() == LIGHT_DIRECTIONAL)
{
// generate view matrix if requested
if (out_view != NULL)
{
DiVec3 pos;
#if 0
if (sm.getCameraRelativeRendering())
{
pos = DiVec3::ZERO;
}
else
#endif
{
pos = cam.GetDerivedPosition();
}
*out_view = buildViewMatrix(pos,
lightDir,
cam.GetDerivedUp());
}
// generate projection matrix if requested
if (out_proj != NULL)
{
*out_proj = DiMat4::getScale(1, 1, -1);
//*out_proj = DiMat4::IDENTITY;
}
// set up camera if requested
if (out_cam != NULL)
{
out_cam->SetProjectionType(PT_ORTHOGRAPHIC);
out_cam->SetDirection(lightDir);
out_cam->SetPosition(cam.GetDerivedPosition());
out_cam->SetFOVy(DiDegree(90));
out_cam->SetNearClipDistance(shadowOffset);
}
}
else if (light.GetType() == LIGHT_SPOT)
{
const DiSpotLight* spot = static_cast<const DiSpotLight*>(&light);
// generate view matrix if requested
if (out_view != NULL)
{
*out_view = buildViewMatrix(light.GetDerivedPosition(),
light.GetDerivedDirection(),
cam.GetDerivedUp());
}
// generate projection matrix if requested
if (out_proj != NULL)
{
// set FOV slightly larger than spotlight range
mTempFrustum->SetFOVy(DiMath::Clamp<DiRadian>(spot->GetOuterAngle() * 1.2, DiRadian(0), DiRadian(DiMath::PI/2.0f)));
mTempFrustum->SetNearClipDistance(light.DeriveShadowNearClipDistance(&cam));
mTempFrustum->SetFarClipDistance(light.DeriveShadowFarClipDistance(&cam));
*out_proj = mTempFrustum->GetProjectionMatrix();
}
// set up camera if requested
if (out_cam != NULL)
{
out_cam->SetProjectionType(PT_PERSPECTIVE);
out_cam->SetDirection(light.GetDerivedDirection());
out_cam->SetPosition(light.GetDerivedPosition());
out_cam->SetFOVy(DiMath::Clamp<DiRadian>(spot->GetOuterAngle() * 1.2, DiRadian(0), DiRadian(DiMath::PI/2.0f)));
out_cam->SetNearClipDistance(light.DeriveShadowNearClipDistance(&cam));
out_cam->SetFarClipDistance(light.DeriveShadowFarClipDistance(&cam));
}
}
#if 0
else if (light.GetType() == LIGHT_POINT)
{
// target analogue to the default shadow textures
// Calculate look at position
// We want to look at a spot shadowOffset away from near plane
// 0.5 is a little too close for angles
DiVec3 target = cam.GetDerivedPosition() +
(cam.GetDerivedDirection() * shadowOffset);
lightDir = target - lightPos;
lightDir.normalise();
// generate view matrix if requested
if (out_view != NULL)
{
*out_view = buildViewMatrix(lightPos,
lightDir,
cam.GetDerivedUp());
}
// generate projection matrix if requested
if (out_proj)
{
// set FOV to 120 degrees
mTempFrustum->SetFOVy(DiDegree(120));
mTempFrustum->SetNearClipDistance(light._deriveShadowNearClipDistance(&cam));
mTempFrustum->SetFarClipDistance(light._deriveShadowFarClipDistance(&cam));
*out_proj = mTempFrustum->GetProjectionMatrix();
}
// set up camera if requested
if (out_cam)
{
out_cam->SetProjectionType(PT_PERSPECTIVE);
out_cam->SetDirection(lightDir);
out_cam->SetPosition(lightPos);
out_cam->SetFOVy(DiDegree(120));
out_cam->SetNearClipDistance(light._deriveShadowNearClipDistance(&cam));
out_cam->SetFarClipDistance(light._deriveShadowFarClipDistance(&cam));
}
}
#endif
}
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 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();
}