SettingsMap* ConfigManager::GetSection(const Urho3D::String& section, bool create)
{
// Empty section gets assigned to main map
if (section == Urho3D::String::EMPTY)
return &_map;
// Split section into submaps
Urho3D::Vector<Urho3D::String> split;
unsigned splitPos = 0;
if (ConfigFile::ParseHeader(section).Empty())
{
return &_map;
}
// Split sections by '.' or '/'
// Comments will ignore splits behind them
while (splitPos != Urho3D::String::NPOS)
{
// Find next comment split
auto commentSplitPos = splitPos;
auto hashPos = section.Find("#", commentSplitPos);
auto slashesPos = section.Find("//", commentSplitPos);
commentSplitPos = (hashPos < slashesPos) ? hashPos : slashesPos;
// Find next split
auto lastSplitPos = splitPos;
auto dotPos = section.Find(".", lastSplitPos);
auto slashPos = section.Find("/", lastSplitPos);
splitPos = (dotPos < slashPos) ? dotPos : slashPos;
// Ignore splits after comments
splitPos = (commentSplitPos <= splitPos) ? Urho3D::String::NPOS : splitPos;
int length = splitPos - lastSplitPos;
if (splitPos == Urho3D::String::NPOS)
{
length = section.Length() - lastSplitPos;
}
auto sub = section.Substring(lastSplitPos, length);
if (sub != Urho3D::String::EMPTY)
split.Push(sub);
}
SettingsMap* currentMap = &_map;
for (auto itr = split.Begin(); itr != split.End(); itr++)
{
auto section = *itr;
// Find section
SettingsMap* newMap = 0;
for (auto map_itr = currentMap->Begin(); map_itr != currentMap->End(); map_itr++)
{
if (map_itr->first_ == section)
{
newMap = static_cast<SettingsMap*>(map_itr->second_.GetVoidPtr());
// Key exists, but is not a SettingsMap
if (!newMap)
{
return 0;
}
// Key exists
break;
}
}
// Key does not exist
if (!newMap)
{
if (create)
{
currentMap->operator[](section) = new SettingsMap();
newMap = static_cast<SettingsMap*>((*currentMap)[section].GetVoidPtr());
}
}
if (newMap)
{
currentMap = newMap;
}
}
return currentMap;
}
void ResourcePickerManager::InitVectorStructs()
{
// Fill vector structure data
Urho3D::Vector<Urho3D::String> billboardVariables;
billboardVariables.Push("Billboard Count");
billboardVariables.Push(" Position");
billboardVariables.Push(" Size");
billboardVariables.Push(" UV Coordinates");
billboardVariables.Push(" Color");
billboardVariables.Push(" Rotation");
billboardVariables.Push(" Is Enabled");
vectorStructs.Push(new VectorStruct("BillboardSet", "Billboards", billboardVariables, 1));
Urho3D::Vector<Urho3D::String> animationStateVariables;
animationStateVariables.Push("Anim State Count");
animationStateVariables.Push(" Animation");
animationStateVariables.Push(" Start Bone");
animationStateVariables.Push(" Is Looped");
animationStateVariables.Push(" Weight");
animationStateVariables.Push(" Time");
animationStateVariables.Push(" Layer");
vectorStructs.Push(new VectorStruct("AnimatedModel", "Animation States", animationStateVariables, 1));
Urho3D::Vector<Urho3D::String> particleColorVariables;
particleColorVariables.Push("Color Animation Frames");
particleColorVariables.Push(" Color");
particleColorVariables.Push(" Time");
vectorStructs.Push(new VectorStruct("ParticleEmitter", "Particle Colors", particleColorVariables, 1));
Urho3D::Vector<Urho3D::String> particleUVAnimVariables;
particleUVAnimVariables.Push("UV Animation Frames");
particleUVAnimVariables.Push(" UV Coords");
particleUVAnimVariables.Push(" Time");
vectorStructs.Push(new VectorStruct("ParticleEmitter", "UV Animation", particleUVAnimVariables, 1));
Urho3D::Vector<Urho3D::String> staticModelGroupInstanceVariables;
staticModelGroupInstanceVariables.Push("Instance Count");
staticModelGroupInstanceVariables.Push(" NodeID");
vectorStructs.Push(new VectorStruct("StaticModelGroup", "Instance Nodes", staticModelGroupInstanceVariables, 1));
Urho3D::Vector<Urho3D::String> splinePathInstanceVariables;
splinePathInstanceVariables.Push("Control Point Count");
splinePathInstanceVariables.Push(" NodeID");
vectorStructs.Push(new VectorStruct("SplinePath", "Control Points", splinePathInstanceVariables, 1));
}
// ----------------------------------------------------------------------------
void Hull::SetMesh(Polyhedron* polyhedron)
{
faces_.Clear();
edges_.Clear();
hullMesh_ = polyhedron;
if(hullMesh_->FaceCount() == 0)
return;
Urho3D::Vector<Urho3D::Vector3> trianglePositions;
Polyhedron::ConstIterator vertexIt = hullMesh_->Begin();
while(vertexIt != hullMesh_->End())
{
Vertex* v0 = *vertexIt++;
Vertex* v1 = *vertexIt++;
Vertex* v2 = *vertexIt++;
// Accumulate positions of triangle centres for average position
trianglePositions.Push(
(v0->position_ + v1->position_ + v2->position_) / 3.0f
);
// Add face
faces_.Push(Face(v0, v1, v2));
}
// Average triangle centres to get centre of hull
centre_ = Urho3D::Vector3::ZERO;
for(Urho3D::Vector<Urho3D::Vector3>::ConstIterator it = trianglePositions.Begin();
it != trianglePositions.End();
++it)
{
centre_ += *it;
}
centre_ /= trianglePositions.Size();
// Make sure each triangle's normal vector is pointing away from centre of
// the hull
for(Urho3D::Vector<Face>::Iterator it = faces_.Begin();
it != faces_.End();
++it)
{
Urho3D::Vector3 outwards = it->GetVertex(0)->position_ - centre_;
if(outwards.DotProduct(it->GetNormal()) < 0)
it->FlipNormal();
}
// With the centre and normals calculated, we can use that information to
// construct edges. Each edge stores the normal vectors of both triangles
// it joins in order to calculate if a projected point is projected from
// the correct angle or not.
//
// We iterate the polyhedron and the triangles list simultaneously, because
// it is more efficient to check for joined edges using the polyhedron data
// structure than the triangles list. The triangles list is required to get
// the calculated and adjusted normals.
vertexIt = hullMesh_->Begin();
Urho3D::Vector<Face>::ConstIterator triangleIt = faces_.Begin();
for(; vertexIt != hullMesh_->End(); triangleIt++)
{
Vertex* vertex[3];
vertex[0] = *vertexIt++;
vertex[1] = *vertexIt++;
vertex[2] = *vertexIt++;
// find the three adjacent triangles
Urho3D::Vector<Face>::ConstIterator triangleIt2 = faces_.Begin();
Polyhedron::ConstIterator vertexIt2 = hullMesh_->Begin();
for(; vertexIt2 != hullMesh_->End(); triangleIt2++)
{
Vertex* vertex2[3];
vertex2[0] = *vertexIt2++;
vertex2[1] = *vertexIt2++;
vertex2[2] = *vertexIt2++;
// skip self
if(vertexIt == vertexIt2)
continue;
// joined[2] will contain two Vertex objects if we find an edge
// that is shared between the two current triangles.
Vertex* joined[2];
Vertex** joinedPtr = joined;
for(unsigned char i = 0; i != 3; ++i)
for(unsigned char j = 0; j != 3; ++j)
if(vertex[i] == vertex2[j])
*joinedPtr++ = vertex[i];
// Calculate number of vertices that were found joined.
unsigned joinedCount = joinedPtr - joined;
assert(joinedCount != 3);
if(joinedCount != 2)
continue;
// Found a joined edge, add it
edges_.Push(Edge(
joined[0],
joined[1],
triangleIt->GetNormal(),
triangleIt2->GetNormal()
));
// Make sure edge boundary check points outwards from the hull's
// centre
Urho3D::Vector2 bary = edges_.Back().ProjectAndTransformToBarycentric(centre_);
if(edges_.Back().ProjectionAngleIsInBounds(edges_.Back().TransformToCartesian(bary), centre_))
edges_.Back().FlipBoundaryCheck();
}
}
}
void ResourcePickerManager::InitResourcePicker()
{
// Fill resource picker data
Urho3D::Vector<Urho3D::String> fontFilters;
fontFilters.Push("*.ttf");
fontFilters.Push("*.fnt");
fontFilters.Push("*.xml");
Urho3D::Vector<Urho3D::String> imageFilters;
imageFilters.Push("*.png");
imageFilters.Push("*.jpg");
imageFilters.Push("*.bmp");
imageFilters.Push("*.tga");
Urho3D::Vector<Urho3D::String> luaFileFilters;
luaFileFilters.Push("*.lua");
luaFileFilters.Push("*.luc");
Urho3D::Vector<Urho3D::String> scriptFilters;
scriptFilters.Push("*.as");
scriptFilters.Push("*.asc");
Urho3D::Vector<Urho3D::String> soundFilters;
soundFilters.Push("*.wav");
soundFilters.Push("*.ogg");
Urho3D::Vector<Urho3D::String> textureFilters;
textureFilters.Push("*.dds");
textureFilters.Push("*.png");
textureFilters.Push("*.jpg");
textureFilters.Push("*.bmp");
textureFilters.Push("*.tga");
textureFilters.Push("*.ktx");
textureFilters.Push("*.pvr");
Urho3D::Vector<Urho3D::String> materialFilters;
materialFilters.Push("*.xml");
materialFilters.Push("*.material");
Urho3D::Vector<Urho3D::String> pexFilters;
pexFilters.Push("*.pex");
Urho3D::Vector<Urho3D::String> anmFilters;
anmFilters.Push("*.anm");
resourcePickers.Push(new ResourcePicker("Animation", "*.ani", ACTION_PICK | ACTION_TEST));
resourcePickers.Push(new ResourcePicker("Font", fontFilters));
resourcePickers.Push(new ResourcePicker("Image", imageFilters));
resourcePickers.Push(new ResourcePicker("LuaFile", luaFileFilters));
resourcePickers.Push(new ResourcePicker("Material", materialFilters, ACTION_PICK | ACTION_OPEN | ACTION_EDIT));
resourcePickers.Push(new ResourcePicker("Model", "*.mdl", ACTION_PICK | ACTION_EDIT));
resourcePickers.Push(new ResourcePicker("ParticleEffect", "*.xml", ACTION_PICK | ACTION_OPEN));
resourcePickers.Push(new ResourcePicker("ScriptFile", scriptFilters));
resourcePickers.Push(new ResourcePicker("Sound", soundFilters));
resourcePickers.Push(new ResourcePicker("Technique", "*.xml"));
resourcePickers.Push(new ResourcePicker("Texture2D", textureFilters));
resourcePickers.Push(new ResourcePicker("TextureCube", "*.xml"));
resourcePickers.Push(new ResourcePicker("XMLFile", "*.xml"));
resourcePickers.Push(new ResourcePicker("Sprite2D", textureFilters, ACTION_PICK | ACTION_OPEN));
resourcePickers.Push(new ResourcePicker("Animation2D", anmFilters, ACTION_PICK | ACTION_OPEN));
resourcePickers.Push(new ResourcePicker("ParticleEffect2D", pexFilters, ACTION_PICK | ACTION_OPEN));
}
