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 DiK2World::ProcessCliff(DiK2RenderObject* renderObj)
{
DiK2ModelPtr model = renderObj->GetModel();
model->SetBatchGroup(BATCH_TERRAIN);
DiCullNode* node = renderObj->GetNode();
DiVec3 pos = node->GetPosition();
DiQuat rot = node->GetOrientation();
DiTerrainDescPtr terDesc = mTerrain->GetDesc();
float cliffsize = terDesc->mCliffSize * terDesc->mGridSize / 2.0f;
DiVec3 transl(-cliffsize, 0, cliffsize);
pos += rot * transl;
DiTerrainDescPtr desc = mTerrain->GetDesc();
int gridx = pos.x / CHUNK_GRID_SIZE;
int gridy = pos.z / CHUNK_GRID_SIZE;
int gridSizeX = (CHUNK_GRID_SIZE * desc->mSizeX);
int gridSizeY = (CHUNK_GRID_SIZE * desc->mSizeY);
int realGrid = gridx + gridy * gridSizeX;
realGrid = DiMath::Clamp(realGrid, 0, gridSizeX*gridSizeY - 1);
uint16 diftexid = desc->mTextureIDMap->GetBuffer(0)[realGrid].diffuseID;
uint16 normtexid = desc->mTextureIDMap->GetBuffer(0)[realGrid].normalID;
DiString diffuse = desc->mTextureTable[diftexid];
DiString normal = desc->mTextureTable[normtexid];
DiTexturePtr textureDif = DiAssetManager::GetInstance().ManualLoadAsset<DiTexture>(diffuse);
#if DEMI_PLATFORM == DEMI_PLATFORM_IOS
DiTexturePtr textureNor = DiAssetManager::GetInstance().ManualLoadAsset<DiTexture>(normal);
#else
DiTexturePtr textureNor = DiAssetManager::GetInstance().ManualLoadAsset<DiTexture>(normal + "_rxgb");
DiTexturePtr textureSpe = DiAssetManager::GetInstance().ManualLoadAsset<DiTexture>(normal + "_s");
#endif
uint32 submodels = model->GetNumSubModels();
for (uint32 i = 0; i < submodels; ++i)
{
DiSubModel* sm = model->GetSubModel(i);
auto material = sm->GetMaterial();
auto newMat = material->Clone();
sm->SetMaterial(newMat);
DiShaderParameter* shaderparam = newMat->GetShaderParameter();
shaderparam->WriteTexture2D("terrainMap", textureDif);
shaderparam->WriteTexture2D("terrainNormalMap", textureNor);
#if DEMI_PLATFORM != DEMI_PLATFORM_IOS
shaderparam->WriteTexture2D("terrainSpecularMap", textureSpe);
#endif
shaderparam->WriteFloat("cliffUVScale", 1.0f / (terDesc->mTextureScale * terDesc->mGridSize));
}
}
DiNode* DiCullNode::CreateChild(const DiVec3& inTranslate, const DiQuat& inRotate)
{
DiCullNode* newNode = mCreator->CreateNode();
newNode->Translate(inTranslate);
newNode->Rotate(inRotate);
this->AddChild(newNode);
return newNode;
}
void DiCullNode::RemoveAllChildren( void )
{
for (size_t i = 0; i < mChildren.size(); ++i)
{
DiCullNode* on = static_cast<DiCullNode*>(mChildren[i]);
on->SetParent(nullptr);
on->RemoveNodeAndChildren();
}
mChildren.clear();
mChildrenToUpdate.clear();
}
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);
}
DiInstanceBatchPtr DiInstanceManager::BuildNewBatch(const DiString& materialName, bool firstTime)
{
DiSubMesh::IndexMap &idxMap = mMeshReference->GetSubMesh(mSubMeshIdx)->GetBlendIndexToBoneIndexMap();
//idxMap = idxMap.empty() ? mMeshReference->sharedBlendIndexToBoneIndexMap : idxMap;
DiMaterialPtr mat = DiAssetManager::GetInstance().GetAsset<DiMaterial>( materialName );
InstanceBatchVec &materialInstanceBatch = mInstanceBatches[materialName];
DiInstanceBatchPtr batch;
DiString name;
name.Format("%s_InstanceBatch_%d",mName.c_str(),mIdCount++);
switch( mInstancingTechnique )
{
case INSTANCE_SHADER_BASED:
batch = make_shared<DiInstanceBatchShader>( this, mMeshReference, mMotionReference, mat, mInstancesPerBatch,
&idxMap, name );
break;
case INSTANCE_HARDWARE_BASED:
batch = make_shared<DiInstanceBatchHardware>(this, mMeshReference, mat, mInstancesPerBatch,
name );
break;
default:
DI_ERROR("Unsupported instanced technique.");
break;
}
if( !firstTime )
{
batch->BuildFrom( mMeshReference->GetSubMesh(mSubMeshIdx) );
}
else
{
const size_t maxInstPerBatch = batch->CalculateMaxNumInstances( mMeshReference->
GetSubMesh(mSubMeshIdx) );
mInstancesPerBatch = DiMath::Min( maxInstPerBatch, mInstancesPerBatch );
batch->SetInstancesPerBatch( mInstancesPerBatch );
batch->Build( mMeshReference->GetSubMesh(mSubMeshIdx) );
}
//const BatchSettings &batchSettings = mBatchSettings[materialName];
//batch->SetCastShadows( batchSettings.setting[CAST_SHADOWS] );
DiCullNode *sceneNode = mSceneManager->GetRootNode()->CreateChild();
sceneNode->AttachObject( batch );
materialInstanceBatch.push_back( batch );
return batch;
}
void DiCullNode::FlipVisibility( bool cascade /*= true*/ )
{
for (auto oi = mObjects.begin(); oi != mObjects.end(); ++oi)
{
(*oi)->SetVisible(!(*oi)->GetVisible());
}
if (cascade)
{
for (size_t i = 0; i < mChildren.size(); ++i)
{
DiCullNode* sceneChild = static_cast<DiCullNode*>(mChildren[i]);
sceneChild->FlipVisibility(cascade);
}
}
}
void DiCullNode::FlipVisibility( bool cascade /*= true*/ )
{
ObjectMap::iterator oi, oiend;
oiend = mObjectsByName.end();
for (oi = mObjectsByName.begin(); oi != oiend; ++oi)
{
oi->second->SetVisible(!oi->second->GetVisible());
}
if (cascade)
{
for (size_t i = 0; i < mChildren.size(); ++i)
{
DiCullNode* sceneChild = static_cast<DiCullNode*>(mChildren[i]);
sceneChild->FlipVisibility(cascade);
}
}
}
DiInstanceBatch::~DiInstanceBatch()
{
DeleteAllInstancedModels();
DiCullNode *sceneNode = GetParentCullNode();
if( sceneNode )
{
sceneNode->DetachAllObjects();
sceneNode->GetParent()->RemoveChild( sceneNode->GetName() );
}
if( mRemoveOwnVertexData )
ReleaseSourceData();
if( mRemoveOwnIndexData )
ReleaseIndexBuffer();
ReleaseVertexDeclaration();
}
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;
}
}
DiNode* DiCullNode::RemoveChild( unsigned short index )
{
DiCullNode *on = static_cast<DiCullNode* >( DiNode::RemoveChild( index ) );
on->RemoveNodeAndChildren();
return on;
}
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 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();
}
DiNode* DiCullNode::RemoveChild( const DiString & name )
{
DiCullNode *on = static_cast<DiCullNode*>( DiNode::RemoveChild( name ) );
on->RemoveNodeAndChildren( );
return on;
}