From e8582d214c97366b01331479fc349616d97680f7 Mon Sep 17 00:00:00 2001 From: Piotr Dziwinski Date: Sat, 11 Jul 2015 19:48:37 +0200 Subject: [PATCH] CStaticObject subclass using new model framework * added reading/writing working version of new model format V3 * added CStaticObject with minial interface intended for non-interactive static objects like trees * converted first model, tree0, to new format --- data | 2 +- src/CMakeLists.txt | 2 + src/app/app.h | 2 +- src/graphics/engine/engine.cpp | 290 ++++++-- src/graphics/engine/engine.h | 53 +- src/graphics/engine/oldmodelmanager.cpp | 78 +-- src/graphics/engine/oldmodelmanager.h | 3 - src/graphics/model/model.cpp | 58 +- src/graphics/model/model.h | 47 +- src/graphics/model/model_crash_sphere.h | 19 + src/graphics/model/model_format.h | 19 + src/graphics/model/model_input.cpp | 269 +++++++- src/graphics/model/model_input.h | 19 + src/graphics/model/model_io_exception.h | 19 + src/graphics/model/model_io_structs.h | 27 +- src/graphics/model/model_manager.cpp | 31 +- src/graphics/model/model_manager.h | 23 +- src/graphics/model/model_mesh.cpp | 19 + src/graphics/model/model_mesh.h | 19 + src/graphics/model/model_output.cpp | 180 ++++- src/graphics/model/model_output.h | 19 + src/graphics/model/model_shadow_spot.h | 19 + src/graphics/model/model_triangle.h | 19 + src/object/object.cpp | 13 + src/object/object.h | 11 +- src/object/object_create_exception.h | 38 ++ src/object/object_factory.cpp | 310 +++++---- src/object/object_factory.h | 7 +- src/object/object_interface_type.h | 1 + src/object/object_manager.cpp | 10 +- src/object/object_manager.h | 4 +- src/object/object_type.h | 10 + src/object/old_object.cpp | 109 +-- src/object/old_object_interface.cpp | 851 ++++++++++++++++++++++++ src/object/old_object_interface.h | 308 +++++---- src/object/robotmain.cpp | 49 +- src/object/robotmain.h | 4 +- src/object/subclass/static_object.cpp | 141 ++++ src/object/subclass/static_object.h | 78 +++ src/sound/sound_type.cpp | 2 +- 40 files changed, 2526 insertions(+), 656 deletions(-) create mode 100644 src/object/object_create_exception.h create mode 100644 src/object/old_object_interface.cpp create mode 100644 src/object/subclass/static_object.cpp create mode 100644 src/object/subclass/static_object.h diff --git a/data b/data index 57478f17..408e5996 160000 --- a/data +++ b/data @@ -1 +1 @@ -Subproject commit 57478f17b86736c8a8b6e132eed529b853241462 +Subproject commit 408e599635b117fdb92e63f75b249d9f2c8d5161 diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 4039813c..b7b51bb8 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -167,6 +167,7 @@ set(BASE_SOURCES object/object_factory.cpp object/object_manager.cpp object/old_object.cpp + object/old_object_interface.cpp object/robotmain.cpp object/scene_conditions.cpp object/task/task.cpp @@ -193,6 +194,7 @@ set(BASE_SOURCES object/task/taskwait.cpp object/tool_type.cpp object/subclass/exchange_post.cpp + object/subclass/static_object.cpp physics/physics.cpp script/cbottoken.cpp script/script.cpp diff --git a/src/app/app.h b/src/app/app.h index 665ebb18..796c27ee 100644 --- a/src/app/app.h +++ b/src/app/app.h @@ -24,7 +24,7 @@ #pragma once - +#include "common/event.h" #include "common/global.h" #include "common/singleton.h" #include "common/profile.h" diff --git a/src/graphics/engine/engine.cpp b/src/graphics/engine/engine.cpp index cf43efcb..496cfd19 100644 --- a/src/graphics/engine/engine.cpp +++ b/src/graphics/engine/engine.cpp @@ -40,6 +40,9 @@ #include "graphics/engine/text.h" #include "graphics/engine/water.h" +#include "graphics/model/model_mesh.h" +#include "graphics/model/model_shadow_spot.h" + #include "math/geometry.h" #include "sound/sound.h" @@ -706,45 +709,33 @@ void CEngine::CopyBaseObject(int sourceBaseObjRank, int destBaseObjRank) } void CEngine::AddBaseObjTriangles(int baseObjRank, const std::vector& vertices, - EngineTriangleType triangleType, const Material& material, int state, - std::string tex1Name, std::string tex2Name, - bool globalUpdate) + std::string tex1Name, std::string tex2Name) { assert(baseObjRank >= 0 && baseObjRank < static_cast( m_baseObjects.size() )); EngineBaseObject& p1 = m_baseObjects[baseObjRank]; EngineBaseObjTexTier& p2 = AddLevel2(p1, tex1Name, tex2Name); - EngineBaseObjDataTier& p3 = AddLevel3(p2, triangleType, material, state); + EngineBaseObjDataTier& p3 = AddLevel3(p2, ENG_TRIANGLE_TYPE_TRIANGLES, material, state); p3.vertices.insert(p3.vertices.end(), vertices.begin(), vertices.end()); p3.updateStaticBuffer = true; m_updateStaticBuffers = true; - if (globalUpdate) + for (int i = 0; i < static_cast( vertices.size() ); i++) { - m_updateGeometry = true; - } - else - { - for (int i = 0; i < static_cast( vertices.size() ); i++) - { - p1.bboxMin.x = Math::Min(vertices[i].coord.x, p1.bboxMin.x); - p1.bboxMin.y = Math::Min(vertices[i].coord.y, p1.bboxMin.y); - p1.bboxMin.z = Math::Min(vertices[i].coord.z, p1.bboxMin.z); - p1.bboxMax.x = Math::Max(vertices[i].coord.x, p1.bboxMax.x); - p1.bboxMax.y = Math::Max(vertices[i].coord.y, p1.bboxMax.y); - p1.bboxMax.z = Math::Max(vertices[i].coord.z, p1.bboxMax.z); - } - - p1.radius = Math::Max(p1.bboxMin.Length(), p1.bboxMax.Length()); + p1.bboxMin.x = Math::Min(vertices[i].coord.x, p1.bboxMin.x); + p1.bboxMin.y = Math::Min(vertices[i].coord.y, p1.bboxMin.y); + p1.bboxMin.z = Math::Min(vertices[i].coord.z, p1.bboxMin.z); + p1.bboxMax.x = Math::Max(vertices[i].coord.x, p1.bboxMax.x); + p1.bboxMax.y = Math::Max(vertices[i].coord.y, p1.bboxMax.y); + p1.bboxMax.z = Math::Max(vertices[i].coord.z, p1.bboxMax.z); } - if (triangleType == ENG_TRIANGLE_TYPE_TRIANGLES) - p1.totalTriangles += vertices.size() / 3; - else - p1.totalTriangles += vertices.size() - 2; + p1.radius = Math::Max(p1.bboxMin.Length(), p1.bboxMax.Length()); + + p1.totalTriangles += vertices.size() / 3; } void CEngine::AddBaseObjQuick(int baseObjRank, const EngineBaseObjDataTier& buffer, @@ -1386,19 +1377,6 @@ void CEngine::SetObjectShadowPos(int objRank, const Math::Vector& pos) m_shadows[shadowRank].pos = pos; } -void CEngine::SetObjectShadowNormal(int objRank, const Math::Vector& normal) -{ - assert(objRank >= 0 && objRank < static_cast( m_objects.size() )); - - int shadowRank = m_objects[objRank].shadowRank; - if (shadowRank == -1) - return; - - assert(shadowRank >= 0 && shadowRank < static_cast( m_shadows.size() )); - - m_shadows[shadowRank].normal = normal; -} - void CEngine::SetObjectShadowAngle(int objRank, float angle) { assert(objRank >= 0 && objRank < static_cast( m_objects.size() )); @@ -1451,19 +1429,6 @@ void CEngine::SetObjectShadowHeight(int objRank, float height) m_shadows[shadowRank].height = height; } -float CEngine::GetObjectShadowRadius(int objRank) -{ - assert(objRank >= 0 && objRank < static_cast( m_objects.size() )); - - int shadowRank = m_objects[objRank].shadowRank; - if (shadowRank == -1) - return 0.0f; - - assert(shadowRank >= 0 && shadowRank < static_cast( m_shadows.size() )); - - return m_shadows[shadowRank].radius; -} - bool CEngine::GetHighlight(Math::Point &p1, Math::Point &p2) { p1 = m_highlightP1; @@ -3233,7 +3198,7 @@ void CEngine::Draw3DScene() UseShadowMapping(false); // Draws the shadows , if shadows enabled - if (m_shadowVisible) + if (m_shadowVisible) DrawShadow(); @@ -4943,6 +4908,229 @@ void CEngine::DrawTimer() m_text->DrawText(m_timerText, FONT_COLOBOT, 15.0f, pos, 1.0f, TEXT_ALIGN_RIGHT, 0, Color(1.0f, 1.0f, 1.0f, 1.0f)); } +void CEngine::AddBaseObjTriangles(int baseObjRank, const std::vector& triangles) +{ + std::vector vs(3, VertexTex2()); + + for (const auto& triangle : triangles) + { + vs[0] = triangle.p1; + vs[1] = triangle.p2; + vs[2] = triangle.p3; + + Material material; + material.ambient = triangle.ambient; + material.diffuse = triangle.diffuse; + material.specular = triangle.specular; + + int state = GetEngineState(triangle); + + std::string tex1Name; + if (!triangle.tex1Name.empty()) + tex1Name = "objects/" + triangle.tex1Name; + + std::string tex2Name; + if (triangle.variableTex2) + tex2Name = GetSecondTexture(); + else + tex2Name = triangle.tex2Name; + + AddBaseObjTriangles(baseObjRank, vs, material, state, tex1Name, tex2Name); + } +} + +int CEngine::GetEngineState(const ModelTriangle& triangle) +{ + int state = 0; + + if (!triangle.tex2Name.empty() || triangle.variableTex2) + state |= ENG_RSTATE_DUAL_BLACK; + + switch (triangle.transparentMode) + { + case ModelTransparentMode::None: + break; + + case ModelTransparentMode::AlphaChannel: + state |= ENG_RSTATE_ALPHA; + break; + + case ModelTransparentMode::MapBlackToAlpha: + state |= ENG_RSTATE_TTEXTURE_BLACK; + break; + + case ModelTransparentMode::MapWhiteToAlpha: + state |= ENG_RSTATE_TTEXTURE_WHITE; + break; + } + + switch (triangle.specialMark) + { + case ModelSpecialMark::None: + break; + + case ModelSpecialMark::Part1: + state |= ENG_RSTATE_PART1; + break; + + case ModelSpecialMark::Part2: + state |= ENG_RSTATE_PART2; + break; + + case ModelSpecialMark::Part3: + state |= ENG_RSTATE_PART3; + break; + } + + if (triangle.doubleSided) + state |= ENG_RSTATE_2FACE; + + return state; +} + +void CEngine::UpdateObjectShadowNormal(int rank) +{ + assert(rank >= 0 && rank < static_cast( m_objects.size() )); + + int shadowRank = m_objects[rank].shadowRank; + if (shadowRank == -1) + return; + + assert(shadowRank >= 0 && shadowRank < static_cast( m_shadows.size() )); + + // Calculating the normal to the ground in nine strategic locations, + // then perform a weighted average (the dots in the center are more important). + + Math::Vector pos = m_shadows[shadowRank].pos; + float radius = m_shadows[shadowRank].radius; + + Math::Vector n[20]; + Math::Vector norm; + int i = 0; + + m_terrain->GetNormal(norm, pos); + n[i++] = norm; + n[i++] = norm; + n[i++] = norm; + + Math::Vector shPos = pos; + shPos.x += radius*0.6f; + shPos.z += radius*0.6f; + m_terrain->GetNormal(norm, shPos); + n[i++] = norm; + n[i++] = norm; + + shPos = pos; + shPos.x -= radius*0.6f; + shPos.z += radius*0.6f; + m_terrain->GetNormal(norm, shPos); + n[i++] = norm; + n[i++] = norm; + + shPos = pos; + shPos.x += radius*0.6f; + shPos.z -= radius*0.6f; + m_terrain->GetNormal(norm, shPos); + n[i++] = norm; + n[i++] = norm; + + shPos = pos; + shPos.x -= radius*0.6f; + shPos.z -= radius*0.6f; + m_terrain->GetNormal(norm, shPos); + n[i++] = norm; + n[i++] = norm; + + shPos = pos; + shPos.x += radius; + shPos.z += radius; + m_terrain->GetNormal(norm, shPos); + n[i++] = norm; + + shPos = pos; + shPos.x -= radius; + shPos.z += radius; + m_terrain->GetNormal(norm, shPos); + n[i++] = norm; + + shPos = pos; + shPos.x += radius; + shPos.z -= radius; + m_terrain->GetNormal(norm, shPos); + n[i++] = norm; + + shPos = pos; + shPos.x -= radius; + shPos.z -= radius; + m_terrain->GetNormal(norm, shPos); + n[i++] = norm; + + norm.LoadZero(); + for (int j = 0; j < i; j++) + { + norm += n[j]; + } + norm /= static_cast(i); // average vector + + m_shadows[shadowRank].normal = norm; +} + +int CEngine::AddStaticMesh(const std::string& key, const CModelMesh* mesh, const Math::Matrix& worldMatrix) +{ + int baseObjRank = -1; + + auto it = m_staticMeshBaseObjects.find(key); + if (it == m_staticMeshBaseObjects.end()) + { + baseObjRank = CreateBaseObject(); + AddBaseObjTriangles(baseObjRank, mesh->GetTriangles()); + m_staticMeshBaseObjects[key] = baseObjRank; + } + else + { + baseObjRank = it->second; + } + + int objRank = CreateObject(); + SetObjectBaseRank(objRank, baseObjRank); + SetObjectTransform(objRank, worldMatrix); + SetObjectType(objRank, ENG_OBJTYPE_FIX); + + return objRank; +} + +void CEngine::AddStaticMeshShadowSpot(int meshHandle, const ModelShadowSpot& shadowSpot) +{ + int objRank = meshHandle; + + CreateShadow(objRank); + SetObjectShadowRadius(objRank, shadowSpot.radius); + SetObjectShadowIntensity(objRank, shadowSpot.intensity); + SetObjectShadowType(objRank, ENG_SHADOW_NORM); + SetObjectShadowHeight(objRank, 0.0f); + SetObjectShadowAngle(objRank, 0.0f); + UpdateObjectShadowNormal(objRank); +} + +void CEngine::DeleteStaticMesh(int meshHandle) +{ + int objRank = meshHandle; + + DeleteShadow(objRank); + DeleteObject(objRank); +} + +const Math::Matrix& CEngine::GetStaticMeshWorldMatrix(int meshHandle) +{ + int objRank = meshHandle; + return m_objects[objRank].transform; +} + +void CEngine::SetStaticMeshTransparency(int meshHandle, float value) +{ + int objRank = meshHandle; + SetObjectTransparency(objRank, value); +} } // namespace Gfx diff --git a/src/graphics/engine/engine.h b/src/graphics/engine/engine.h index 89ce99ab..e394a723 100644 --- a/src/graphics/engine/engine.h +++ b/src/graphics/engine/engine.h @@ -24,10 +24,8 @@ #pragma once - #include "app/system.h" -#include "common/event.h" #include "common/singleton.h" #include "graphics/core/color.h" @@ -46,6 +44,7 @@ #include #include #include +#include class CApplication; @@ -53,6 +52,7 @@ class CObject; class CSoundInterface; class CImage; class CPauseManager; +struct Event; // Graphics module namespace @@ -70,6 +70,9 @@ class CLightning; class CPlanet; class CTerrain; class CPyroManager; +class CModelMesh; +struct ModelShadowSpot; +struct ModelTriangle; /** @@ -765,14 +768,39 @@ public: void AddStatisticTriangle(int nb); //! Returns the number of triangles in current frame int GetStatisticTriangle(); - + //! Sets the coordinates to display in stats window void SetStatisticPos(Math::Vector pos); - + //! Sets text to display as mission timer void SetTimerDisplay(const std::string& text); + /* *************** New mesh interface *************** */ + //! Add new instance of static mesh + /** + * Static meshes never change their geometry or texture mapping, + * so specific instances can share mesh data. + * + * @param mesh mesh data + * @param key key unique per object class + * @return mesh instance handle + */ + int AddStaticMesh(const std::string& key, const Gfx::CModelMesh* mesh, const Math::Matrix& worldMatrix); + + //! Removes given static mesh + void DeleteStaticMesh(int meshHandle); + + //! Adds a shadow spot to mesh + void AddStaticMeshShadowSpot(int meshHandle, const Gfx::ModelShadowSpot& shadowSpot); + + //! Returns static mesh world matrix + const Math::Matrix& GetStaticMeshWorldMatrix(int meshHandle); + + //! Sets transparency for static mesh + void SetStaticMeshTransparency(int meshHandle, float value); + + /* *************** Object management *************** */ // Base objects @@ -788,11 +816,7 @@ public: void CopyBaseObject(int sourceBaseObjRank, int destBaseObjRank); //! Adds triangles to given object with the specified params - void AddBaseObjTriangles(int baseObjRank, const std::vector& vertices, - EngineTriangleType triangleType, - const Material& material, int state, - std::string tex1Name, std::string tex2Name, - bool globalUpdate); + void AddBaseObjTriangles(int baseObjRank, const std::vector& triangles); //! Adds a tier 4 engine object directly void AddBaseObjQuick(int baseObjRank, const EngineBaseObjDataTier& buffer, @@ -880,12 +904,11 @@ public: void SetObjectShadowHide(int objRank, bool hide); void SetObjectShadowType(int objRank, EngineShadowType type); void SetObjectShadowPos(int objRank, const Math::Vector& pos); - void SetObjectShadowNormal(int objRank, const Math::Vector& normal); void SetObjectShadowAngle(int objRank, float angle); void SetObjectShadowRadius(int objRank, float radius); void SetObjectShadowIntensity(int objRank, float intensity); void SetObjectShadowHeight(int objRank, float height); - float GetObjectShadowRadius(int objRank); + void UpdateObjectShadowNormal(int objRank); //@} //! Lists the ranks of objects and subobjects selected @@ -1314,6 +1337,12 @@ protected: //! Updates static buffers of changed objects void UpdateStaticBuffers(); + void AddBaseObjTriangles(int baseObjRank, const std::vector& vertices, + const Material& material, int state, + std::string tex1Name, std::string tex2Name); + + int GetEngineState(const ModelTriangle& triangle); + protected: CApplication* m_app; CSoundInterface* m_sound; @@ -1509,6 +1538,8 @@ protected: bool m_debugDumpLights; std::string m_timerText; + + std::unordered_map m_staticMeshBaseObjects; }; diff --git a/src/graphics/engine/oldmodelmanager.cpp b/src/graphics/engine/oldmodelmanager.cpp index b1449816..3d42ef90 100644 --- a/src/graphics/engine/oldmodelmanager.cpp +++ b/src/graphics/engine/oldmodelmanager.cpp @@ -75,34 +75,7 @@ bool COldModelManager::LoadModel(const std::string& fileName, bool mirrored) FileInfo fileInfo(fileName, mirrored); m_models[fileInfo] = modelInfo; - std::vector vs(3, VertexTex2()); - - for (const auto& triangle : modelInfo.triangles) - { - vs[0] = triangle.p1; - vs[1] = triangle.p2; - vs[2] = triangle.p3; - - Material material; - material.ambient = triangle.ambient; - material.diffuse = triangle.diffuse; - material.specular = triangle.specular; - - int state = GetEngineState(triangle); - - std::string tex1Name; - if (!triangle.tex1Name.empty()) - tex1Name = "objects/" + triangle.tex1Name; - - std::string tex2Name; - if (triangle.variableTex2) - tex2Name = m_engine->GetSecondTexture(); - else - tex2Name = triangle.tex2Name; - - m_engine->AddBaseObjTriangles(modelInfo.baseObjRank, vs, ENG_TRIANGLE_TYPE_TRIANGLES, - material, state, tex1Name, tex2Name, false); - } + m_engine->AddBaseObjTriangles(modelInfo.baseObjRank, modelInfo.triangles); return true; } @@ -204,54 +177,5 @@ void COldModelManager::Mirror(std::vector& triangles) } } -int COldModelManager::GetEngineState(const ModelTriangle& triangle) -{ - int state = 0; - - if (!triangle.tex2Name.empty() || triangle.variableTex2) - state |= ENG_RSTATE_DUAL_BLACK; - - switch (triangle.transparentMode) - { - case ModelTransparentMode::None: - break; - - case ModelTransparentMode::AlphaChannel: - state |= ENG_RSTATE_ALPHA; - break; - - case ModelTransparentMode::MapBlackToAlpha: - state |= ENG_RSTATE_TTEXTURE_BLACK; - break; - - case ModelTransparentMode::MapWhiteToAlpha: - state |= ENG_RSTATE_TTEXTURE_WHITE; - break; - } - - switch (triangle.specialMark) - { - case ModelSpecialMark::None: - break; - - case ModelSpecialMark::Part1: - state |= ENG_RSTATE_PART1; - break; - - case ModelSpecialMark::Part2: - state |= ENG_RSTATE_PART2; - break; - - case ModelSpecialMark::Part3: - state |= ENG_RSTATE_PART3; - break; - } - - if (triangle.doubleSided) - state |= ENG_RSTATE_2FACE; - - return state; -} - } diff --git a/src/graphics/engine/oldmodelmanager.h b/src/graphics/engine/oldmodelmanager.h index c41ca7b7..e965aa1f 100644 --- a/src/graphics/engine/oldmodelmanager.h +++ b/src/graphics/engine/oldmodelmanager.h @@ -84,9 +84,6 @@ protected: //! Mirrors the model along the Z axis void Mirror(std::vector& triangles); - //! Converts from model to engine rendering state - int GetEngineState(const ModelTriangle& triangle); - private: struct ModelInfo { diff --git a/src/graphics/model/model.cpp b/src/graphics/model/model.cpp index f657ff65..3f97d31d 100644 --- a/src/graphics/model/model.cpp +++ b/src/graphics/model/model.cpp @@ -1,3 +1,22 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + #include "graphics/model/model.h" #include "common/logger.h" @@ -37,9 +56,19 @@ void CModel::AddMesh(const std::string& name, CModelMesh&& mesh) m_meshes[name] = mesh; } -const boost::optional& CModel::GetShadowSpot() const +std::vector CModel::GetMeshNames() const { - return m_shadowSpot; + std::vector meshNames; + + for (const auto& v : m_meshes) + meshNames.push_back(v.first); + + return meshNames; +} + +const ModelShadowSpot& CModel::GetShadowSpot() const +{ + return *m_shadowSpot; } void CModel::SetShadowSpot(const ModelShadowSpot& shadowSpot) @@ -47,6 +76,11 @@ void CModel::SetShadowSpot(const ModelShadowSpot& shadowSpot) m_shadowSpot = shadowSpot; } +bool CModel::HasShadowSpot() const +{ + return m_shadowSpot.is_initialized(); +} + const std::vector& CModel::GetCrashSpheres() const { return m_crashSpheres; @@ -57,4 +91,24 @@ void CModel::AddCrashSphere(const ModelCrashSphere& crashSphere) m_crashSpheres.push_back(crashSphere); } +int CModel::GetCrashSphereCount() const +{ + return m_crashSpheres.size(); +} + +const Math::Sphere& CModel::GetCameraCollisionSphere() const +{ + return *m_cameraCollisionSphere; +} + +void CModel::SetCameraCollisionSphere(const Math::Sphere& sphere) +{ + m_cameraCollisionSphere = sphere; +} + +bool CModel::HasCameraCollisionSphere() const +{ + return m_cameraCollisionSphere.is_initialized(); +} + } // namespace Gfx diff --git a/src/graphics/model/model.h b/src/graphics/model/model.h index 3031e179..794b0322 100644 --- a/src/graphics/model/model.h +++ b/src/graphics/model/model.h @@ -1,9 +1,30 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + #pragma once #include "graphics/model/model_crash_sphere.h" #include "graphics/model/model_mesh.h" #include "graphics/model/model_shadow_spot.h" +#include "math/sphere.h" + #include #include #include @@ -26,21 +47,35 @@ public: const CModelMesh* GetMesh(const std::string& name) const; //! Add new \a mesh with given \a name void AddMesh(const std::string& name, CModelMesh&& mesh); - - //! Returns the optional shadow spot associated with model - const boost::optional& GetShadowSpot() const; - //! Sets the shadow spot associated with model - void SetShadowSpot(const ModelShadowSpot& shadowSpot); + //! Returns list of mesh names + std::vector GetMeshNames() const; //! Returns the model's crash spheres const std::vector& GetCrashSpheres() const; //! Adds a new crash sphere void AddCrashSphere(const ModelCrashSphere& crashSphere); + //! Returns number of crash spheres + int GetCrashSphereCount() const; + + //! Returns the shadow spot associated with model (assumes it is present) + const ModelShadowSpot& GetShadowSpot() const; + //! Sets the shadow spot associated with model + void SetShadowSpot(const ModelShadowSpot& shadowSpot); + //! Returns whether there is shadow spot + bool HasShadowSpot() const; + + //! Returns the optional shadow spot associated with model (assumes it is present) + const Math::Sphere& GetCameraCollisionSphere() const; + //! Sets the shadow spot associated with model + void SetCameraCollisionSphere(const Math::Sphere& sphere); + //! Returns whether there is camera collision sphere + bool HasCameraCollisionSphere() const; private: std::map m_meshes; - boost::optional m_shadowSpot; std::vector m_crashSpheres; + boost::optional m_shadowSpot; + boost::optional m_cameraCollisionSphere; }; } // namespace Gfx diff --git a/src/graphics/model/model_crash_sphere.h b/src/graphics/model/model_crash_sphere.h index 6a887919..c8d45b42 100644 --- a/src/graphics/model/model_crash_sphere.h +++ b/src/graphics/model/model_crash_sphere.h @@ -1,3 +1,22 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + #pragma once #include "math/vector.h" diff --git a/src/graphics/model/model_format.h b/src/graphics/model/model_format.h index a4649019..25651895 100644 --- a/src/graphics/model/model_format.h +++ b/src/graphics/model/model_format.h @@ -1,3 +1,22 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + #pragma once namespace Gfx { diff --git a/src/graphics/model/model_input.cpp b/src/graphics/model/model_input.cpp index ab16c7e7..d8b18fa7 100644 --- a/src/graphics/model/model_input.cpp +++ b/src/graphics/model/model_input.cpp @@ -1,3 +1,22 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + #include "graphics/model/model_input.h" #include "common/ioutils.h" @@ -20,7 +39,10 @@ namespace ModelInput { void ReadTextModel(CModel &model, std::istream &stream); void ReadTextModelV1AndV2(CModel &model, std::istream &stream); + void ReadTextModelV3(CModel &model, std::istream &stream); + ModelHeaderV3 ReadTextHeader(std::istream &stream); + CModelMesh ReadTextMesh(std::istream &stream); void ReadBinaryModel(CModel &model, std::istream &stream); void ReadBinaryModelV1AndV2(CModel &model, std::istream &stream); @@ -36,8 +58,15 @@ namespace ModelInput Material ReadBinaryMaterial(std::istream& stream); std::string ReadLineString(std::istream& stream, const std::string& prefix); + void ReadValuePrefix(std::istream& stream, const std::string& prefix); VertexTex2 ParseVertexTex2(const std::string& text); - Material ParseTextMaterial(const std::string& text); + Material ParseMaterial(const std::string& text); + Math::Vector ParseVector(const std::string& text); + ModelCrashSphere ParseCrashSphere(const std::string& text); + ModelShadowSpot ParseShadowSpot(const std::string& text); + Math::Sphere ParseCameraCollisionSphere(const std::string& text); + ModelTransparentMode ParseTransparentMode(const std::string& text); + ModelSpecialMark ParseSpecialMark(const std::string& text); void ConvertOldTex1Name(ModelTriangle& triangle, const char* tex1Name); void ConvertFromOldRenderState(ModelTriangle& triangle, int state); @@ -217,7 +246,7 @@ void ModelInput::ReadTextModelV1AndV2(CModel &model, std::istream &stream) t.p3 = ParseVertexTex2(p3Text); std::string matText = ReadLineString(stream, "mat"); - t.material = ParseTextMaterial(matText); + t.material = ParseMaterial(matText); t.tex1Name = ReadLineString(stream, "tex1"); t.tex2Name = ReadLineString(stream, "tex2"); @@ -253,7 +282,94 @@ void ModelInput::ReadTextModelV1AndV2(CModel &model, std::istream &stream) void ModelInput::ReadTextModelV3(CModel &model, std::istream &stream) { - // TODO... + ModelHeaderV3 header; + + try + { + header = ReadTextHeader(stream); + } + catch (const std::exception& e) + { + throw CModelIOException(std::string("Error reading model header: ") + e.what()); + } + + for (int i = 0; i < header.totalCrashSpheres; ++i) + { + auto crashSphere = ParseCrashSphere(ReadLineString(stream, "crash_sphere")); + model.AddCrashSphere(crashSphere); + } + + if (header.hasShadowSpot) + { + auto shadowSpot = ParseShadowSpot(ReadLineString(stream, "shadow_spot")); + model.SetShadowSpot(shadowSpot); + } + + if (header.hasCameraCollisionSphere) + { + auto sphere = ParseCameraCollisionSphere(ReadLineString(stream, "camera_collision_sphere")); + model.SetCameraCollisionSphere(sphere); + } + + for (int i = 0; i < header.totalMeshes; ++i) + { + std::string meshName = ReadLineString(stream, "mesh"); + CModelMesh mesh = ReadTextMesh(stream); + model.AddMesh(meshName, std::move(mesh)); + } +} + +ModelHeaderV3 ModelInput::ReadTextHeader(std::istream &stream) +{ + ModelHeaderV3 header; + header.version = boost::lexical_cast(ReadLineString(stream, "version")); + header.totalCrashSpheres = boost::lexical_cast(ReadLineString(stream, "total_crash_spheres")); + header.hasShadowSpot = ReadLineString(stream, "has_shadow_spot") == std::string("Y"); + header.hasCameraCollisionSphere = ReadLineString(stream, "has_camera_collision_sphere") == std::string("Y"); + header.totalMeshes = boost::lexical_cast(ReadLineString(stream, "total_meshes")); + return header; +} + +CModelMesh ModelInput::ReadTextMesh(std::istream& stream) +{ + CModelMesh mesh; + + mesh.SetPosition(ParseVector(ReadLineString(stream, "position"))); + mesh.SetRotation(ParseVector(ReadLineString(stream, "rotation"))); + mesh.SetScale(ParseVector(ReadLineString(stream, "scale"))); + mesh.SetParent(ReadLineString(stream, "parent")); + + int totalTriangles = boost::lexical_cast(ReadLineString(stream, "total_triangles")); + + for (int i = 0; i < totalTriangles; ++i) + { + ModelTriangleV3 t; + + std::string p1Text = ReadLineString(stream, "p1"); + t.p1 = ParseVertexTex2(p1Text); + std::string p2Text = ReadLineString(stream, "p2"); + t.p2 = ParseVertexTex2(p2Text); + std::string p3Text = ReadLineString(stream, "p3"); + t.p3 = ParseVertexTex2(p3Text); + + std::string matText = ReadLineString(stream, "mat"); + Material mat = ParseMaterial(matText); + t.ambient = mat.ambient; + t.diffuse = mat.diffuse; + t.specular = mat.specular; + + t.tex1Name = ReadLineString(stream, "tex1"); + t.tex2Name = ReadLineString(stream, "tex2"); + t.variableTex2 = ReadLineString(stream, "var_tex2") == std::string("Y"); + + t.transparentMode = ParseTransparentMode(ReadLineString(stream, "trans_mode")); + t.specialMark = ParseSpecialMark(ReadLineString(stream, "mark")); + t.doubleSided = ReadLineString(stream, "dbl_side") == std::string("Y"); + + mesh.AddTriangle(t); + } + + return mesh; } void ModelInput::ReadOldModel(CModel &model, std::istream &stream) @@ -592,6 +708,14 @@ std::string ModelInput::ReadLineString(std::istream& stream, const std::string& return value; } +void ModelInput::ReadValuePrefix(std::istream& stream, const std::string& expectedPrefix) +{ + std::string prefix; + stream >> prefix; + if (prefix != expectedPrefix) + throw CModelIOException(std::string("Unexpected prefix: '") + prefix + "', expected was: '" + expectedPrefix + "'"); +} + VertexTex2 ModelInput::ParseVertexTex2(const std::string& text) { VertexTex2 vertex; @@ -599,66 +723,41 @@ VertexTex2 ModelInput::ParseVertexTex2(const std::string& text) std::stringstream stream; stream.str(text); - std::string prefix; - - stream >> prefix; - if (prefix != "c") - throw CModelIOException(std::string("Unexpected prefix: '") + prefix + "'"); - + ReadValuePrefix(stream, "c"); stream >> vertex.coord.x >> vertex.coord.y >> vertex.coord.z; - stream >> prefix; - if (prefix != "n") - throw CModelIOException(std::string("Unexpected prefix: '") + prefix + "'"); - + ReadValuePrefix(stream, "n"); stream >> vertex.normal.x >> vertex.normal.y >> vertex.normal.z; - stream >> prefix; - if (prefix != "t1") - throw CModelIOException(std::string("Unexpected prefix: '") + prefix + "'"); - + ReadValuePrefix(stream, "t1"); stream >> vertex.texCoord.x >> vertex.texCoord.y; - stream >> prefix; - if (prefix != "t2") - throw CModelIOException(std::string("Unexpected prefix: '") + prefix + "'"); - + ReadValuePrefix(stream, "t2"); stream >> vertex.texCoord2.x >> vertex.texCoord2.y; return vertex; } -Material ModelInput::ParseTextMaterial(const std::string& text) +Material ModelInput::ParseMaterial(const std::string& text) { Material material; std::stringstream stream; stream.str(text); - std::string prefix; - - stream >> prefix; - if (prefix != "dif") - throw CModelIOException(std::string("Unexpected prefix: '") + prefix + "'"); - + ReadValuePrefix(stream, "dif"); stream >> material.diffuse.r >> material.diffuse.g >> material.diffuse.b >> material.diffuse.a; - stream >> prefix; - if (prefix != "amb") - throw CModelIOException(std::string("Unexpected prefix: '") + prefix + "'"); - + ReadValuePrefix(stream, "amb"); stream >> material.ambient.r >> material.ambient.g >> material.ambient.b >> material.ambient.a; - stream >> prefix; - if (prefix != "spc") - throw CModelIOException(std::string("Unexpected prefix: '") + prefix + "'"); - + ReadValuePrefix(stream, "spc"); stream >> material.specular.r >> material.specular.g >> material.specular.b @@ -667,4 +766,102 @@ Material ModelInput::ParseTextMaterial(const std::string& text) return material; } +Math::Vector ModelInput::ParseVector(const std::string& text) +{ + Math::Vector vector; + + std::stringstream stream; + stream.str(text); + + stream >> vector.x >> vector.y >> vector.z; + + return vector; +} + +ModelCrashSphere ModelInput::ParseCrashSphere(const std::string& text) +{ + ModelCrashSphere crashSphere; + + std::stringstream stream; + stream.str(text); + + ReadValuePrefix(stream, "pos"); + stream >> crashSphere.position.x + >> crashSphere.position.y + >> crashSphere.position.z; + + ReadValuePrefix(stream, "rad"); + stream >> crashSphere.radius; + + ReadValuePrefix(stream, "sound"); + stream >> crashSphere.sound; + + ReadValuePrefix(stream, "hard"); + stream >> crashSphere.hardness; + + return crashSphere; +} + +ModelShadowSpot ModelInput::ParseShadowSpot(const std::string& text) +{ + ModelShadowSpot shadowSpot; + + std::stringstream stream; + stream.str(text); + + ReadValuePrefix(stream, "rad"); + stream >> shadowSpot.radius; + + ReadValuePrefix(stream, "int"); + stream >> shadowSpot.intensity; + + return shadowSpot; +} + +Math::Sphere ModelInput::ParseCameraCollisionSphere(const std::string& text) +{ + Math::Sphere sphere; + + std::stringstream stream; + stream.str(text); + + ReadValuePrefix(stream, "pos"); + stream >> sphere.pos.x + >> sphere.pos.y + >> sphere.pos.z; + + ReadValuePrefix(stream, "rad"); + stream >> sphere.radius; + + return sphere; +} + +ModelTransparentMode ModelInput::ParseTransparentMode(const std::string& text) +{ + if (text == "none") + return ModelTransparentMode::None; + else if (text == "alpha") + return ModelTransparentMode::AlphaChannel; + else if (text == "map_black") + return ModelTransparentMode::MapBlackToAlpha; + else if (text == "map_white") + return ModelTransparentMode::MapWhiteToAlpha; + else + throw CModelIOException(std::string("Unexpected transparent mode: '") + text + "'"); +} + +ModelSpecialMark ModelInput::ParseSpecialMark(const std::string& text) +{ + if (text == "none") + return ModelSpecialMark::None; + else if (text == "part1") + return ModelSpecialMark::Part1; + else if (text == "part2") + return ModelSpecialMark::Part2; + else if (text == "part3") + return ModelSpecialMark::Part3; + else + throw CModelIOException(std::string("Unexpected special mark: '") + text + "'"); +} + } // namespace Gfx diff --git a/src/graphics/model/model_input.h b/src/graphics/model/model_input.h index 7267bf99..e8cfb27d 100644 --- a/src/graphics/model/model_input.h +++ b/src/graphics/model/model_input.h @@ -1,3 +1,22 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + #pragma once #include "graphics/model/model.h" diff --git a/src/graphics/model/model_io_exception.h b/src/graphics/model/model_io_exception.h index 4cc55543..4c5f8d3e 100644 --- a/src/graphics/model/model_io_exception.h +++ b/src/graphics/model/model_io_exception.h @@ -1,3 +1,22 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + #pragma once #include diff --git a/src/graphics/model/model_io_structs.h b/src/graphics/model/model_io_structs.h index 88f24ea5..c4660d60 100644 --- a/src/graphics/model/model_io_structs.h +++ b/src/graphics/model/model_io_structs.h @@ -1,3 +1,22 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + #pragma once #include "graphics/core/material.h" @@ -92,12 +111,14 @@ struct ModelHeaderV3 { //! File version (1, 2, ...) int version = 0; - //! Total number of meshes - int totalMeshes = 0; //! Total number of crash spheres int totalCrashSpheres = 0; //! Whether model has shadow spot - bool shadowSpot = false; + bool hasShadowSpot = false; + //! Whether model has camera collision sphere + bool hasCameraCollisionSphere = false; + //! Total number of meshes + int totalMeshes = 0; }; /** diff --git a/src/graphics/model/model_manager.cpp b/src/graphics/model/model_manager.cpp index 4c1d561f..0a78438a 100644 --- a/src/graphics/model/model_manager.cpp +++ b/src/graphics/model/model_manager.cpp @@ -1,3 +1,22 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + #include "graphics/model/model_manager.h" #include "common/resources/inputstream.h" @@ -7,21 +26,21 @@ namespace Gfx { -CModel& CModelManager::GetModel(const std::string& fileName) +CModel& CModelManager::GetModel(const std::string& modelName) { - auto it = m_models.find(fileName); + auto it = m_models.find(modelName); if (it != m_models.end()) return it->second; CInputStream stream; - stream.open("models-new/" + fileName); + stream.open("models-new/" + modelName + ".txt"); if (!stream.is_open()) - throw CModelIOException(std::string("Could not open file '") + fileName + "'"); + throw CModelIOException(std::string("Could not open file '") + modelName + "'"); CModel model = ModelInput::Read(stream, ModelFormat::Text); - m_models[fileName] = model; + m_models[modelName] = model; - return m_models[fileName]; + return m_models[modelName]; } void CModelManager::ClearCache() diff --git a/src/graphics/model/model_manager.h b/src/graphics/model/model_manager.h index 296455f5..30db355d 100644 --- a/src/graphics/model/model_manager.h +++ b/src/graphics/model/model_manager.h @@ -1,3 +1,22 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + #pragma once #include "graphics/model/model.h" @@ -14,9 +33,9 @@ namespace Gfx { class CModelManager { public: - //! Returns a model read from \a fileName + //! Returns a model named \a modelName /** @throws CModelIOException on read error */ - CModel& GetModel(const std::string& fileName); + CModel& GetModel(const std::string& modelName); //! Clears cached models void ClearCache(); diff --git a/src/graphics/model/model_mesh.cpp b/src/graphics/model/model_mesh.cpp index 455a14de..531c2191 100644 --- a/src/graphics/model/model_mesh.cpp +++ b/src/graphics/model/model_mesh.cpp @@ -1,3 +1,22 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + #include "graphics/model/model_mesh.h" namespace Gfx { diff --git a/src/graphics/model/model_mesh.h b/src/graphics/model/model_mesh.h index 7f710128..5d763a38 100644 --- a/src/graphics/model/model_mesh.h +++ b/src/graphics/model/model_mesh.h @@ -1,3 +1,22 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + #pragma once #include "math/vector.h" diff --git a/src/graphics/model/model_output.cpp b/src/graphics/model/model_output.cpp index 4365b4f7..6dc17cde 100644 --- a/src/graphics/model/model_output.cpp +++ b/src/graphics/model/model_output.cpp @@ -1,3 +1,22 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + #include "graphics/model/model_output.h" #include "common/ioutils.h" @@ -15,6 +34,14 @@ namespace Gfx { namespace ModelOutput { void WriteTextModel(const CModel& model, std::ostream &stream); + void WriteTextHeader(const ModelHeaderV3& header, std::ostream &stream); + void WriteCrashSphere(const ModelCrashSphere& crashSphere, std::ostream &stream); + void WriteShadowSpot(const ModelShadowSpot& shadowSpot, std::ostream &stream); + void WriteCameraCollisionSphere(const Math::Sphere& sphere, std::ostream &stream); + void WriteTextMesh(const CModelMesh* mesh, const std::string& meshName, std::ostream &stream); + std::string VectorToString(const Math::Vector& vector); + std::string TransparentModeToString(ModelTransparentMode mode); + std::string SpecialMarkToString(ModelSpecialMark specialMark); void WriteBinaryModel(const CModel& model, std::ostream &stream); @@ -64,38 +91,94 @@ void ModelOutput::Write(const CModel& model, std::ostream &stream, ModelFormat f void ModelOutput::WriteTextModel(const CModel& model, std::ostream &stream) { - const CModelMesh* mesh = model.GetMesh("main"); - if (mesh == nullptr) - throw CModelIOException("No main mesh found in model"); + ModelHeaderV3 header; + header.version = 3; + header.totalCrashSpheres = model.GetCrashSphereCount(); + header.hasShadowSpot = model.HasShadowSpot(); + header.hasCameraCollisionSphere = model.HasCameraCollisionSphere(); + header.totalMeshes = model.GetMeshCount(); + WriteTextHeader(header, stream); - ModelHeaderV1AndV2 header; + stream << "# MODEL PROPERTIES" << std::endl; - header.version = 2; - header.totalTriangles = mesh->GetTriangleCount(); + for (const auto& crashSphere : model.GetCrashSpheres()) + WriteCrashSphere(crashSphere, stream); + if (model.HasShadowSpot()) + WriteShadowSpot(model.GetShadowSpot(), stream); + + if (model.HasCameraCollisionSphere()) + WriteCameraCollisionSphere(model.GetCameraCollisionSphere(), stream); + + stream << std::endl; + + for (const std::string& meshName : model.GetMeshNames()) + { + const CModelMesh* mesh = model.GetMesh(meshName); + assert(mesh != nullptr); + WriteTextMesh(mesh, meshName, stream); + } +} + +void ModelOutput::WriteTextHeader(const ModelHeaderV3& header, std::ostream &stream) +{ stream << "# Colobot text model" << std::endl; stream << std::endl; stream << "### HEAD" << std::endl; stream << "version " << header.version << std::endl; - stream << "total_triangles " << header.totalTriangles << std::endl; + stream << "total_crash_spheres " << header.totalCrashSpheres << std::endl; + stream << "has_shadow_spot " << (header.hasShadowSpot ? "Y" : "N") << std::endl; + stream << "has_camera_collision_sphere " << (header.hasCameraCollisionSphere ? "Y" : "N") << std::endl; + stream << "total_meshes " << header.totalMeshes << std::endl; stream << std::endl; - stream << "### TRIANGLES" << std::endl; +} - for (const ModelTriangle& triangle : mesh->GetTriangles()) +void ModelOutput::WriteCrashSphere(const ModelCrashSphere& crashSphere, std::ostream &stream) +{ + stream << "crash_sphere"; + stream << " pos" + << " " << crashSphere.position.x + << " " << crashSphere.position.y + << " " << crashSphere.position.z; + stream << " rad " << crashSphere.radius; + stream << " sound " << crashSphere.sound; + stream << " hard " << crashSphere.hardness; + stream << std::endl; +} + +void ModelOutput::WriteShadowSpot(const ModelShadowSpot& shadowSpot, std::ostream &stream) +{ + stream << "shadow_spot"; + stream << " rad " << shadowSpot.radius; + stream << " int " << shadowSpot.intensity; + stream << std::endl; +} + +void ModelOutput::WriteCameraCollisionSphere(const Math::Sphere& sphere, std::ostream &stream) +{ + stream << "camera_collision_sphere "; + stream << " pos " + << sphere.pos.x + << sphere.pos.y + << sphere.pos.z; + stream << " rad " << sphere.radius; + stream << std::endl; +} + +void ModelOutput::WriteTextMesh(const CModelMesh* mesh, const std::string& meshName, std::ostream &stream) +{ + stream << "### MESH" << std::endl; + stream << "mesh " << meshName << std::endl; + stream << "position " << VectorToString(mesh->GetPosition()) << std::endl; + stream << "rotation " << VectorToString(mesh->GetRotation()) << std::endl; + stream << "scale " << VectorToString(mesh->GetScale()) << std::endl; + stream << "parent " << mesh->GetParent() << std::endl; + stream << "total_triangles " << mesh->GetTriangleCount() << std::endl; + stream << std::endl; + + stream << "### MESH TRIANGLES" << std::endl; + for (const ModelTriangle& t : mesh->GetTriangles()) { - ModelTriangleV1AndV2 t; - - t.p1 = triangle.p1; - t.p2 = triangle.p2; - t.p3 = triangle.p3; - t.material.ambient = triangle.ambient; - t.material.diffuse = triangle.diffuse; - t.material.specular = triangle.specular; - t.tex1Name = triangle.tex1Name; - t.tex2Name = triangle.tex2Name; - t.variableTex2 = triangle.variableTex2; - t.state = ConvertToOldState(triangle); - stream << "p1 "; WriteTextVertexTex2(t.p1, stream); stream << "p2 "; @@ -103,17 +186,66 @@ void ModelOutput::WriteTextModel(const CModel& model, std::ostream &stream) stream << "p3 "; WriteTextVertexTex2(t.p3, stream); stream << "mat "; - WriteTextMaterial(t.material, stream); + Material material; + material.ambient = t.ambient; + material.diffuse = t.diffuse; + material.specular = t.specular; + WriteTextMaterial(material, stream); stream << "tex1 " << t.tex1Name << std::endl; stream << "tex2 " << t.tex2Name << std::endl; stream << "var_tex2 " << (t.variableTex2 ? 'Y' : 'N') << std::endl; - stream << "state " << t.state << std::endl; + stream << "trans_mode " << TransparentModeToString(t.transparentMode) << std::endl; + stream << "mark " << SpecialMarkToString(t.specialMark) << std::endl; + stream << "dbl_side " << (t.doubleSided ? 'Y' : 'N') << std::endl; stream << std::endl; } } +std::string ModelOutput::VectorToString(const Math::Vector& vector) +{ + std::ostringstream str; + str << vector.x << " " << vector.y << " " << vector.z; + return str.str(); +} + +std::string ModelOutput::TransparentModeToString(ModelTransparentMode mode) +{ + switch (mode) + { + case ModelTransparentMode::None: + return "none"; + + case ModelTransparentMode::AlphaChannel: + return "alpha"; + + case ModelTransparentMode::MapBlackToAlpha: + return "map_black"; + + case ModelTransparentMode::MapWhiteToAlpha: + return "map_white"; + } +} + +std::string ModelOutput::SpecialMarkToString(ModelSpecialMark specialMark) +{ + switch (specialMark) + { + case ModelSpecialMark::None: + return "none"; + + case ModelSpecialMark::Part1: + return "part1"; + + case ModelSpecialMark::Part2: + return "part2"; + + case ModelSpecialMark::Part3: + return "part3"; + } +} + void ModelOutput::WriteBinaryModel(const CModel& model, std::ostream &stream) { const CModelMesh* mesh = model.GetMesh("main"); diff --git a/src/graphics/model/model_output.h b/src/graphics/model/model_output.h index 78fb8ec6..88be7014 100644 --- a/src/graphics/model/model_output.h +++ b/src/graphics/model/model_output.h @@ -1,3 +1,22 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + #pragma once #include "graphics/model/model_format.h" diff --git a/src/graphics/model/model_shadow_spot.h b/src/graphics/model/model_shadow_spot.h index 05245026..a15d67f7 100644 --- a/src/graphics/model/model_shadow_spot.h +++ b/src/graphics/model/model_shadow_spot.h @@ -1,3 +1,22 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + #pragma once namespace Gfx { diff --git a/src/graphics/model/model_triangle.h b/src/graphics/model/model_triangle.h index fc38a9ba..773a7b93 100644 --- a/src/graphics/model/model_triangle.h +++ b/src/graphics/model/model_triangle.h @@ -1,3 +1,22 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + #pragma once #include "graphics/core/color.h" diff --git a/src/object/object.cpp b/src/object/object.cpp index faf6954b..9c640c87 100644 --- a/src/object/object.cpp +++ b/src/object/object.cpp @@ -1,5 +1,8 @@ #include "object/object.h" +#include "graphics/model/model_crash_sphere.h" + + CObject::CObject(int id, ObjectType type) : m_id(id) , m_type(type) @@ -11,6 +14,16 @@ CObject::~CObject() { } +void CObject::SetCrashSpheres(const std::vector& crashSpheres) +{ + for (const auto& crashSphere : crashSpheres) + { + SoundType sound = ParseSoundType(crashSphere.sound); + CrashSphere objectCrashSphere(crashSphere.position, crashSphere.radius, sound, crashSphere.hardness); + AddCrashSphere(objectCrashSphere); + } +} + void CObject::AddCrashSphere(const CrashSphere& crashSphere) { m_crashSpheres.push_back(crashSphere); diff --git a/src/object/object.h b/src/object/object.h index f31d92b3..5ae6f152 100644 --- a/src/object/object.h +++ b/src/object/object.h @@ -28,6 +28,11 @@ #include "object/object_interface_type.h" #include "object/old_object_interface.h" +#include + +namespace Gfx { +struct ModelCrashSphere; +} // namespace Gfx /** * \class CObject @@ -74,13 +79,14 @@ public: //! Reads object properties from line in level file virtual void Read(CLevelParserLine* line) = 0; - //! Check if object implements the given type of interface inline bool Implements(ObjectInterfaceType type) const { return m_implementedInterfaces[static_cast(type)]; } + //! Sets crash spheres for object + void SetCrashSpheres(const std::vector& crashSpheres); //! Adds a new crash sphere /** Crash sphere position is given in object coordinates */ void AddCrashSphere(const CrashSphere& crashSphere); @@ -101,6 +107,9 @@ public: // TODO: remove from here once no longer necessary void SetCameraCollisionSphere(const Math::Sphere& sphere); + //! Sets the transparency of object + virtual void SetTransparency(float value) = 0; + protected: //! Transform crash sphere by object's world matrix virtual void TransformCrashSphere(Math::Sphere& crashSphere) = 0; diff --git a/src/object/object_create_exception.h b/src/object/object_create_exception.h new file mode 100644 index 00000000..50dc0335 --- /dev/null +++ b/src/object/object_create_exception.h @@ -0,0 +1,38 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + +#pragma once + +#include "object/object_type.h" + +#include +#include + +class CObjectCreateException : public std::runtime_error +{ +public: + explicit CObjectCreateException(const std::string& error, ObjectType type) + : std::runtime_error("Error creating object type " + boost::lexical_cast(type)) + {} + explicit CObjectCreateException(const std::string& error, ObjectType type, const std::string& modelName) + : std::runtime_error("Error creating object type " + + boost::lexical_cast(type) + + " from model " + modelName + ": " + error) + {} +}; diff --git a/src/object/object_factory.cpp b/src/object/object_factory.cpp index 94578c47..50630227 100644 --- a/src/object/object_factory.cpp +++ b/src/object/object_factory.cpp @@ -23,6 +23,7 @@ #include "graphics/engine/oldmodelmanager.h" #include "graphics/engine/terrain.h" #include "graphics/engine/lightning.h" +#include "graphics/model/model_manager.h" #include "object/old_object.h" #include "object/brain.h" @@ -61,6 +62,7 @@ #include "object/motion/motionvehicle.h" #include "object/motion/motionworm.h" #include "object/subclass/exchange_post.h" +#include "object/subclass/static_object.h" #include "math/geometry.h" @@ -70,23 +72,37 @@ using COldObjectUPtr = std::unique_ptr; CObjectFactory::CObjectFactory(Gfx::CEngine* engine, Gfx::CTerrain* terrain, - Gfx::COldModelManager* modelManager, + Gfx::COldModelManager* oldModelManager, + Gfx::CModelManager* modelManager, Gfx::CParticle* particle) : m_engine(engine) , m_terrain(terrain) + , m_oldModelManager(oldModelManager) , m_modelManager(modelManager) , m_particle(particle) {} CObjectUPtr CObjectFactory::CreateObject(const ObjectCreateParams& params) { + if (CStaticObject::IsStaticObject(params.type)) + { + return CStaticObject::Create(params.id, + params.type, + params.pos, + params.angle, + params.height, + m_engine, + m_modelManager, + m_engine->GetTerrain()); + } + switch (params.type) { case OBJECT_NULL: return nullptr; case OBJECT_INFO: - return CExchangePost::Create(params, m_modelManager, m_engine); + return CExchangePost::Create(params, m_oldModelManager, m_engine); case OBJECT_PORTICO: case OBJECT_BASE: @@ -178,7 +194,6 @@ CObjectUPtr CObjectFactory::CreateObject(const ObjectCreateParams& params) case OBJECT_PLANT17: case OBJECT_PLANT18: case OBJECT_PLANT19: - case OBJECT_TREE0: case OBJECT_TREE1: case OBJECT_TREE2: case OBJECT_TREE3: @@ -295,7 +310,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_PORTICO ) { - m_modelManager->AddModelReference("portico1.mod", false, rank); + m_oldModelManager->AddModelReference("portico1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -304,14 +319,14 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1, rank); obj->SetObjectParent(1, 0); - m_modelManager->AddModelReference("portico2.mod", false, rank); + m_oldModelManager->AddModelReference("portico2.mod", false, rank); obj->SetPosition(1, Math::Vector(0.0f, 67.0f, 0.0f)); rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(2, rank); obj->SetObjectParent(2, 1); - m_modelManager->AddModelReference("portico3.mod", false, rank); + m_oldModelManager->AddModelReference("portico3.mod", false, rank); obj->SetPosition(2, Math::Vector(0.0f, 0.0f, -33.0f)); obj->SetAngleY(2, 45.0f*Math::PI/180.0f); @@ -319,7 +334,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(3, rank); obj->SetObjectParent(3, 2); - m_modelManager->AddModelReference("portico4.mod", false, rank); + m_oldModelManager->AddModelReference("portico4.mod", false, rank); obj->SetPosition(3, Math::Vector(50.0f, 0.0f, 0.0f)); obj->SetAngleY(3, -60.0f*Math::PI/180.0f); @@ -327,7 +342,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(4, rank); obj->SetObjectParent(4, 3); - m_modelManager->AddModelReference("portico5.mod", false, rank); + m_oldModelManager->AddModelReference("portico5.mod", false, rank); obj->SetPosition(4, Math::Vector(35.0f, 0.0f, 0.0f)); obj->SetAngleY(4, -55.0f*Math::PI/180.0f); @@ -335,7 +350,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(5, rank); obj->SetObjectParent(5, 1); - m_modelManager->AddModelReference("portico3.mod", false, rank); + m_oldModelManager->AddModelReference("portico3.mod", false, rank); obj->SetPosition(5, Math::Vector(0.0f, 0.0f, 33.0f)); obj->SetAngleY(5, -45.0f*Math::PI/180.0f); @@ -343,7 +358,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(6, rank); obj->SetObjectParent(6, 5); - m_modelManager->AddModelReference("portico4.mod", false, rank); + m_oldModelManager->AddModelReference("portico4.mod", false, rank); obj->SetPosition(6, Math::Vector(50.0f, 0.0f, 0.0f)); obj->SetAngleY(6, 60.0f*Math::PI/180.0f); @@ -351,7 +366,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(7, rank); obj->SetObjectParent(7, 6); - m_modelManager->AddModelReference("portico5.mod", false, rank); + m_oldModelManager->AddModelReference("portico5.mod", false, rank); obj->SetPosition(7, Math::Vector(35.0f, 0.0f, 0.0f)); obj->SetAngleY(7, 55.0f*Math::PI/180.0f); @@ -359,7 +374,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(8, rank); obj->SetObjectParent(8, 0); - m_modelManager->AddModelReference("portico6.mod", false, rank); + m_oldModelManager->AddModelReference("portico6.mod", false, rank); obj->SetPosition(8, Math::Vector(-35.0f, 50.0f, -35.0f)); obj->SetAngleY(8, -Math::PI/2.0f); obj->SetZoom(8, 2.0f); @@ -368,14 +383,14 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(9, rank); obj->SetObjectParent(9, 8); - m_modelManager->AddModelReference("portico7.mod", false, rank); + m_oldModelManager->AddModelReference("portico7.mod", false, rank); obj->SetPosition(9, Math::Vector(0.0f, 4.5f, 1.9f)); rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(10, rank); obj->SetObjectParent(10, 0); - m_modelManager->AddModelReference("portico6.mod", false, rank); + m_oldModelManager->AddModelReference("portico6.mod", false, rank); obj->SetPosition(10, Math::Vector(-35.0f, 50.0f, 35.0f)); obj->SetAngleY(10, -Math::PI/2.0f); obj->SetZoom(10, 2.0f); @@ -384,7 +399,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(11, rank); obj->SetObjectParent(11, 10); - m_modelManager->AddModelReference("portico7.mod", false, rank); + m_oldModelManager->AddModelReference("portico7.mod", false, rank); obj->SetPosition(11, Math::Vector(0.0f, 4.5f, 1.9f)); obj->AddCrashSphere(CrashSphere(Math::Vector( 0.0f, 28.0f, 0.0f), 45.5f, SOUND_BOUMm, 0.45f)); @@ -405,7 +420,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_BASE ) { - m_modelManager->AddModelReference("base1.mod", false, rank); + m_oldModelManager->AddModelReference("base1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -416,7 +431,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1+i, rank); obj->SetObjectParent(1+i, 0); - m_modelManager->AddModelReference("base2.mod", false, rank); + m_oldModelManager->AddModelReference("base2.mod", false, rank); Math::Point p = Math::RotatePoint(-Math::PI/4.0f*i, 27.8f); obj->SetPosition(1+i, Math::Vector(p.x, 30.0f, p.y)); obj->SetAngleY(1+i, Math::PI/4.0f*i); @@ -426,14 +441,14 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(10+i, rank); obj->SetObjectParent(10+i, 1+i); - m_modelManager->AddModelReference("base4.mod", false, rank); + m_oldModelManager->AddModelReference("base4.mod", false, rank); obj->SetPosition(10+i, Math::Vector(23.5f, 0.0f, 7.0f)); rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(18+i, rank); obj->SetObjectParent(18+i, 1+i); - m_modelManager->AddModelReference("base4.mod", true, rank); + m_oldModelManager->AddModelReference("base4.mod", true, rank); obj->SetPosition(18+i, Math::Vector(23.5f, 0.0f, -7.0f)); } @@ -441,7 +456,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(9, rank); obj->SetObjectParent(9, 0); - m_modelManager->AddModelReference("base3.mod", false, rank); // central pillar + m_oldModelManager->AddModelReference("base3.mod", false, rank); // central pillar obj->AddCrashSphere(CrashSphere(Math::Vector( 0.0f, 33.0f, 0.0f), 2.5f, SOUND_BOUMm, 0.45f)); obj->AddCrashSphere(CrashSphere(Math::Vector( 0.0f, 39.0f, 0.0f), 2.5f, SOUND_BOUMm, 0.45f)); @@ -471,7 +486,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_DERRICK ) { - m_modelManager->AddModelReference("derrick1.mod", false, rank); + m_oldModelManager->AddModelReference("derrick1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -480,7 +495,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1, rank); obj->SetObjectParent(1, 0); - m_modelManager->AddModelReference("derrick2.mod", false, rank); + m_oldModelManager->AddModelReference("derrick2.mod", false, rank); obj->AddCrashSphere(CrashSphere(Math::Vector(0.0f, 0.0f, 0.0f), 6.0f, SOUND_BOUMm, 0.45f)); obj->AddCrashSphere(CrashSphere(Math::Vector(0.0f, 10.0f, 0.0f), 5.0f, SOUND_BOUMm, 0.45f)); @@ -494,7 +509,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_RESEARCH ) { - m_modelManager->AddModelReference("search1.mod", false, rank); + m_oldModelManager->AddModelReference("search1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -503,14 +518,14 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1, rank); obj->SetObjectParent(1, 0); - m_modelManager->AddModelReference("search2.mod", false, rank); + m_oldModelManager->AddModelReference("search2.mod", false, rank); obj->SetPosition(1, Math::Vector(0.0f, 13.0f, 0.0f)); rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(2, rank); obj->SetObjectParent(2, 1); - m_modelManager->AddModelReference("search3.mod", false, rank); + m_oldModelManager->AddModelReference("search3.mod", false, rank); obj->SetPosition(2, Math::Vector(0.0f, 4.0f, 0.0f)); obj->SetAngleZ(2, 35.0f*Math::PI/180.0f); @@ -526,7 +541,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_RADAR ) { - m_modelManager->AddModelReference("radar1.mod", false, rank); + m_oldModelManager->AddModelReference("radar1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -535,14 +550,14 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1, rank); obj->SetObjectParent(1, 0); - m_modelManager->AddModelReference("radar2.mod", false, rank); + m_oldModelManager->AddModelReference("radar2.mod", false, rank); obj->SetPosition(1, Math::Vector(0.0f, 5.0f, 0.0f)); rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(2, rank); obj->SetObjectParent(2, 0); - m_modelManager->AddModelReference("radar3.mod", false, rank); + m_oldModelManager->AddModelReference("radar3.mod", false, rank); obj->SetPosition(2, Math::Vector(0.0f, 11.0f, 0.0f)); obj->SetAngleY(2, -Math::PI/2.0f); @@ -550,7 +565,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(3, rank); obj->SetObjectParent(3, 2); - m_modelManager->AddModelReference("radar4.mod", false, rank); + m_oldModelManager->AddModelReference("radar4.mod", false, rank); obj->SetPosition(3, Math::Vector(0.0f, 4.5f, 1.9f)); obj->AddCrashSphere(CrashSphere(Math::Vector(0.0f, 3.0f, 0.0f), 6.0f, SOUND_BOUMm, 0.45f)); @@ -562,7 +577,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_ENERGY ) { - m_modelManager->AddModelCopy("energy.mod", false, rank); + m_oldModelManager->AddModelCopy("energy.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -580,7 +595,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_LABO ) { - m_modelManager->AddModelReference("labo1.mod", false, rank); + m_oldModelManager->AddModelReference("labo1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -589,7 +604,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1, rank); obj->SetObjectParent(1, 0); - m_modelManager->AddModelReference("labo2.mod", false, rank); + m_oldModelManager->AddModelReference("labo2.mod", false, rank); obj->SetPosition(1, Math::Vector(-9.0f, 3.0f, 0.0f)); obj->SetAngleZ(1, Math::PI/2.0f); @@ -597,14 +612,14 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(2, rank); obj->SetObjectParent(2, 1); - m_modelManager->AddModelReference("labo3.mod", false, rank); + m_oldModelManager->AddModelReference("labo3.mod", false, rank); obj->SetPosition(2, Math::Vector(9.0f, -1.0f, 0.0f)); rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(3, rank); obj->SetObjectParent(3, 2); - m_modelManager->AddModelReference("labo4.mod", false, rank); + m_oldModelManager->AddModelReference("labo4.mod", false, rank); obj->SetPosition(3, Math::Vector(0.0f, 0.0f, 0.0f)); obj->SetAngleZ(3, 80.0f*Math::PI/180.0f); @@ -612,7 +627,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(4, rank); obj->SetObjectParent(4, 2); - m_modelManager->AddModelReference("labo4.mod", false, rank); + m_oldModelManager->AddModelReference("labo4.mod", false, rank); obj->SetPosition(4, Math::Vector(0.0f, 0.0f, 0.0f)); obj->SetAngleZ(4, 80.0f*Math::PI/180.0f); obj->SetAngleY(4, Math::PI*2.0f/3.0f); @@ -621,7 +636,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(5, rank); obj->SetObjectParent(5, 2); - m_modelManager->AddModelReference("labo4.mod", false, rank); + m_oldModelManager->AddModelReference("labo4.mod", false, rank); obj->SetPosition(5, Math::Vector(0.0f, 0.0f, 0.0f)); obj->SetAngleZ(5, 80.0f*Math::PI/180.0f); obj->SetAngleY(5, -Math::PI*2.0f/3.0f); @@ -640,7 +655,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_FACTORY ) { - m_modelManager->AddModelReference("factory1.mod", false, rank); + m_oldModelManager->AddModelReference("factory1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -651,7 +666,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1+i, rank); obj->SetObjectParent(1+i, 0); - m_modelManager->AddModelReference("factory2.mod", false, rank); + m_oldModelManager->AddModelReference("factory2.mod", false, rank); obj->SetPosition(1+i, Math::Vector(10.0f, 2.0f*i, 10.0f)); obj->SetAngleZ(1+i, Math::PI/2.0f); obj->SetZoomZ(1+i, 0.30f); @@ -660,7 +675,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(10+i, rank); obj->SetObjectParent(10+i, 0); - m_modelManager->AddModelReference("factory2.mod", false, rank); + m_oldModelManager->AddModelReference("factory2.mod", false, rank); obj->SetPosition(10+i, Math::Vector(10.0f, 2.0f*i, -10.0f)); obj->SetAngleZ(10+i, -Math::PI/2.0f); obj->SetAngleY(10+i, Math::PI); @@ -697,7 +712,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_REPAIR ) { - m_modelManager->AddModelReference("repair1.mod", false, rank); + m_oldModelManager->AddModelReference("repair1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -706,7 +721,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1, rank); obj->SetObjectParent(1, 0); - m_modelManager->AddModelReference("repair2.mod", false, rank); + m_oldModelManager->AddModelReference("repair2.mod", false, rank); obj->SetPosition(1, Math::Vector(-11.0f, 13.5f, 0.0f)); obj->SetAngleZ(1, Math::PI/2.0f); @@ -721,7 +736,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_DESTROYER ) { - m_modelManager->AddModelReference("destroy1.mod", false, rank); + m_oldModelManager->AddModelReference("destroy1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -730,7 +745,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1, rank); obj->SetObjectParent(1, 0); - m_modelManager->AddModelReference("destroy2.mod", false, rank); + m_oldModelManager->AddModelReference("destroy2.mod", false, rank); obj->SetPosition(1, Math::Vector(0.0f, 0.0f, 0.0f)); m_terrain->AddBuildingLevel(pos, 7.0f, 9.0f, 1.0f, 0.5f); @@ -745,7 +760,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_STATION ) { - m_modelManager->AddModelCopy("station.mod", false, rank); + m_oldModelManager->AddModelCopy("station.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -761,7 +776,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_CONVERT ) { - m_modelManager->AddModelReference("convert1.mod", false, rank); + m_oldModelManager->AddModelReference("convert1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -770,14 +785,14 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1, rank); obj->SetObjectParent(1, 0); - m_modelManager->AddModelReference("convert2.mod", false, rank); + m_oldModelManager->AddModelReference("convert2.mod", false, rank); obj->SetPosition(1, Math::Vector(0.0f, 14.0f, 0.0f)); rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(2, rank); obj->SetObjectParent(2, 0); - m_modelManager->AddModelReference("convert3.mod", false, rank); + m_oldModelManager->AddModelReference("convert3.mod", false, rank); obj->SetPosition(2, Math::Vector(0.0f, 11.5f, 0.0f)); obj->SetAngleX(2, -Math::PI*0.35f); @@ -785,7 +800,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(3, rank); obj->SetObjectParent(3, 0); - m_modelManager->AddModelReference("convert3.mod", false, rank); + m_oldModelManager->AddModelReference("convert3.mod", false, rank); obj->SetPosition(3, Math::Vector(0.0f, 11.5f, 0.0f)); obj->SetAngleY(3, Math::PI); obj->SetAngleX(3, -Math::PI*0.35f); @@ -801,7 +816,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_TOWER ) { - m_modelManager->AddModelReference("tower.mod", false, rank); + m_oldModelManager->AddModelReference("tower.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -810,7 +825,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1, rank); obj->SetObjectParent(1, 0); - m_modelManager->AddModelReference("roller2c.mod", false, rank); + m_oldModelManager->AddModelReference("roller2c.mod", false, rank); obj->SetPosition(1, Math::Vector(0.0f, 20.0f, 0.0f)); obj->SetAngleZ(1, Math::PI/2.0f); @@ -818,7 +833,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(2, rank); obj->SetObjectParent(2, 1); - m_modelManager->AddModelReference("roller3c.mod", false, rank); + m_oldModelManager->AddModelReference("roller3c.mod", false, rank); obj->SetPosition(2, Math::Vector(4.5f, 0.0f, 0.0f)); obj->SetAngleZ(2, 0.0f); @@ -836,7 +851,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_NUCLEAR ) { - m_modelManager->AddModelReference("nuclear1.mod", false, rank); + m_oldModelManager->AddModelReference("nuclear1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -845,7 +860,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1, rank); obj->SetObjectParent(1, 0); - m_modelManager->AddModelReference("nuclear2.mod", false, rank); + m_oldModelManager->AddModelReference("nuclear2.mod", false, rank); obj->SetPosition(1, Math::Vector(20.0f, 10.0f, 0.0f)); obj->SetAngleZ(1, 135.0f*Math::PI/180.0f); @@ -861,7 +876,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_PARA ) { - m_modelManager->AddModelReference("para.mod", false, rank); + m_oldModelManager->AddModelReference("para.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -886,7 +901,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_SAFE ) { - m_modelManager->AddModelReference("safe1.mod", false, rank); + m_oldModelManager->AddModelReference("safe1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -895,14 +910,14 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1, rank); obj->SetObjectParent(1, 0); - m_modelManager->AddModelReference("safe2.mod", false, rank); + m_oldModelManager->AddModelReference("safe2.mod", false, rank); obj->SetZoom(1, 1.05f); rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(2, rank); obj->SetObjectParent(2, 0); - m_modelManager->AddModelReference("safe3.mod", false, rank); + m_oldModelManager->AddModelReference("safe3.mod", false, rank); obj->SetZoom(2, 1.05f); m_terrain->AddBuildingLevel(pos, 18.0f, 20.0f, 1.0f, 0.5f); @@ -915,7 +930,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_HUSTON ) { - m_modelManager->AddModelReference("huston1.mod", false, rank); + m_oldModelManager->AddModelReference("huston1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -924,7 +939,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1, rank); obj->SetObjectParent(1, 0); - m_modelManager->AddModelReference("huston2.mod", false, rank); + m_oldModelManager->AddModelReference("huston2.mod", false, rank); obj->SetPosition(1, Math::Vector(0.0f, 39.0f, 30.0f)); obj->SetAngleY(1, -Math::PI/2.0f); obj->SetZoom(1, 3.0f); @@ -933,7 +948,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(2, rank); obj->SetObjectParent(2, 1); - m_modelManager->AddModelReference("huston3.mod", false, rank); + m_oldModelManager->AddModelReference("huston3.mod", false, rank); obj->SetPosition(2, Math::Vector(0.0f, 4.5f, 1.9f)); obj->AddCrashSphere(CrashSphere(Math::Vector( 15.0f, 6.0f, -53.0f), 16.0f, SOUND_BOUMm, 0.45f)); @@ -956,7 +971,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_TARGET1 ) { - m_modelManager->AddModelReference("target1.mod", false, rank); + m_oldModelManager->AddModelReference("target1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetZoom(0, 1.5f); @@ -985,7 +1000,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_TARGET2 ) { - m_modelManager->AddModelReference("target2.mod", false, rank); + m_oldModelManager->AddModelReference("target2.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -995,7 +1010,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_NEST ) { - m_modelManager->AddModelReference("nest.mod", false, rank); + m_oldModelManager->AddModelReference("nest.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -1007,7 +1022,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_START ) { - m_modelManager->AddModelReference("start.mod", false, rank); + m_oldModelManager->AddModelReference("start.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -1017,7 +1032,7 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) if ( type == OBJECT_END ) { - m_modelManager->AddModelReference("end.mod", false, rank); + m_oldModelManager->AddModelReference("end.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -1037,8 +1052,8 @@ CObjectUPtr CObjectFactory::CreateBuilding(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); pPower->obj->SetObjectRank(0, rank); - if ( power <= 1.0f ) m_modelManager->AddModelReference("power.mod", false, rank); - else m_modelManager->AddModelReference("atomic.mod", false, rank); + if ( power <= 1.0f ) m_oldModelManager->AddModelReference("power.mod", false, rank); + else m_oldModelManager->AddModelReference("atomic.mod", false, rank); pPower->obj->SetPosition(0, GetCharacter()->posPower); pPower->obj->AddCrashSphere(CrashSphere(Math::Vector(0.0f, 1.0f, 0.0f), 1.0f, SOUND_BOUMm, 0.45f)); @@ -1114,11 +1129,11 @@ CObjectUPtr CObjectFactory::CreateResource(const ObjectCreateParams& params) if (type == OBJECT_POWER || type == OBJECT_ATOMIC) { - m_modelManager->AddModelCopy(name, false, rank); + m_oldModelManager->AddModelCopy(name, false, rank); } else { - m_modelManager->AddModelReference(name, false, rank); + m_oldModelManager->AddModelReference(name, false, rank); } obj->SetPosition(0, pos); @@ -1206,7 +1221,7 @@ CObjectUPtr CObjectFactory::CreateFlag(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); // it is a stationary object obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference(name, false, rank); + m_oldModelManager->AddModelReference(name, false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1223,7 +1238,7 @@ CObjectUPtr CObjectFactory::CreateFlag(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1+i, rank); obj->SetObjectParent(1+i, i); - m_modelManager->AddModelReference(name, false, rank); + m_oldModelManager->AddModelReference(name, false, rank); if ( i == 0 ) obj->SetPosition(1+i, Math::Vector(0.15f, 5.0f, 0.0f)); else obj->SetPosition(1+i, Math::Vector(0.79f, 0.0f, 0.0f)); } @@ -1260,7 +1275,7 @@ CObjectUPtr CObjectFactory::CreateBarrier(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("barrier0.mod", false, rank); + m_oldModelManager->AddModelReference("barrier0.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1276,7 +1291,7 @@ CObjectUPtr CObjectFactory::CreateBarrier(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("barrier1.mod", false, rank); + m_oldModelManager->AddModelReference("barrier1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1294,7 +1309,7 @@ CObjectUPtr CObjectFactory::CreateBarrier(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("barrier2.mod", false, rank); + m_oldModelManager->AddModelReference("barrier2.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1312,7 +1327,7 @@ CObjectUPtr CObjectFactory::CreateBarrier(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("barrier3.mod", false, rank); + m_oldModelManager->AddModelReference("barrier3.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1361,11 +1376,11 @@ CObjectUPtr CObjectFactory::CreatePlant(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - if ( type == OBJECT_PLANT0 ) m_modelManager->AddModelReference("plant0.mod", false, rank); - if ( type == OBJECT_PLANT1 ) m_modelManager->AddModelReference("plant1.mod", false, rank); - if ( type == OBJECT_PLANT2 ) m_modelManager->AddModelReference("plant2.mod", false, rank); - if ( type == OBJECT_PLANT3 ) m_modelManager->AddModelReference("plant3.mod", false, rank); - if ( type == OBJECT_PLANT4 ) m_modelManager->AddModelReference("plant4.mod", false, rank); + if ( type == OBJECT_PLANT0 ) m_oldModelManager->AddModelReference("plant0.mod", false, rank); + if ( type == OBJECT_PLANT1 ) m_oldModelManager->AddModelReference("plant1.mod", false, rank); + if ( type == OBJECT_PLANT2 ) m_oldModelManager->AddModelReference("plant2.mod", false, rank); + if ( type == OBJECT_PLANT3 ) m_oldModelManager->AddModelReference("plant3.mod", false, rank); + if ( type == OBJECT_PLANT4 ) m_oldModelManager->AddModelReference("plant4.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1385,9 +1400,9 @@ CObjectUPtr CObjectFactory::CreatePlant(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - if ( type == OBJECT_PLANT5 ) m_modelManager->AddModelReference("plant5.mod", false, rank); - if ( type == OBJECT_PLANT6 ) m_modelManager->AddModelReference("plant6.mod", false, rank); - if ( type == OBJECT_PLANT7 ) m_modelManager->AddModelReference("plant7.mod", false, rank); + if ( type == OBJECT_PLANT5 ) m_oldModelManager->AddModelReference("plant5.mod", false, rank); + if ( type == OBJECT_PLANT6 ) m_oldModelManager->AddModelReference("plant6.mod", false, rank); + if ( type == OBJECT_PLANT7 ) m_oldModelManager->AddModelReference("plant7.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1403,8 +1418,8 @@ CObjectUPtr CObjectFactory::CreatePlant(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - if ( type == OBJECT_PLANT8 ) m_modelManager->AddModelReference("plant8.mod", false, rank); - if ( type == OBJECT_PLANT9 ) m_modelManager->AddModelReference("plant9.mod", false, rank); + if ( type == OBJECT_PLANT8 ) m_oldModelManager->AddModelReference("plant8.mod", false, rank); + if ( type == OBJECT_PLANT9 ) m_oldModelManager->AddModelReference("plant9.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1423,11 +1438,11 @@ CObjectUPtr CObjectFactory::CreatePlant(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - if ( type == OBJECT_PLANT10 ) m_modelManager->AddModelReference("plant10.mod", false, rank); - if ( type == OBJECT_PLANT11 ) m_modelManager->AddModelReference("plant11.mod", false, rank); - if ( type == OBJECT_PLANT12 ) m_modelManager->AddModelReference("plant12.mod", false, rank); - if ( type == OBJECT_PLANT13 ) m_modelManager->AddModelReference("plant13.mod", false, rank); - if ( type == OBJECT_PLANT14 ) m_modelManager->AddModelReference("plant14.mod", false, rank); + if ( type == OBJECT_PLANT10 ) m_oldModelManager->AddModelReference("plant10.mod", false, rank); + if ( type == OBJECT_PLANT11 ) m_oldModelManager->AddModelReference("plant11.mod", false, rank); + if ( type == OBJECT_PLANT12 ) m_oldModelManager->AddModelReference("plant12.mod", false, rank); + if ( type == OBJECT_PLANT13 ) m_oldModelManager->AddModelReference("plant13.mod", false, rank); + if ( type == OBJECT_PLANT14 ) m_oldModelManager->AddModelReference("plant14.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1447,11 +1462,11 @@ CObjectUPtr CObjectFactory::CreatePlant(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - if ( type == OBJECT_PLANT15 ) m_modelManager->AddModelReference("plant15.mod", false, rank); - if ( type == OBJECT_PLANT16 ) m_modelManager->AddModelReference("plant16.mod", false, rank); - if ( type == OBJECT_PLANT17 ) m_modelManager->AddModelReference("plant17.mod", false, rank); - if ( type == OBJECT_PLANT18 ) m_modelManager->AddModelReference("plant18.mod", false, rank); - if ( type == OBJECT_PLANT19 ) m_modelManager->AddModelReference("plant19.mod", false, rank); + if ( type == OBJECT_PLANT15 ) m_oldModelManager->AddModelReference("plant15.mod", false, rank); + if ( type == OBJECT_PLANT16 ) m_oldModelManager->AddModelReference("plant16.mod", false, rank); + if ( type == OBJECT_PLANT17 ) m_oldModelManager->AddModelReference("plant17.mod", false, rank); + if ( type == OBJECT_PLANT18 ) m_oldModelManager->AddModelReference("plant18.mod", false, rank); + if ( type == OBJECT_PLANT19 ) m_oldModelManager->AddModelReference("plant19.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1465,29 +1480,12 @@ CObjectUPtr CObjectFactory::CreatePlant(const ObjectCreateParams& params) obj->CreateShadowCircle(8.0f, 0.5f); } - if ( type == OBJECT_TREE0 ) - { - int rank = m_engine->CreateObject(); - m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); - obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("tree0.mod", false, rank); - obj->SetPosition(0, pos); - obj->SetAngleY(0, angle); - - obj->AddCrashSphere(CrashSphere(Math::Vector( 0.0f, 3.0f, 2.0f), 3.0f, SOUND_BOUMs, 0.20f)); - obj->AddCrashSphere(CrashSphere(Math::Vector(-1.0f, 10.0f, 1.0f), 2.0f, SOUND_BOUMs, 0.20f)); - obj->AddCrashSphere(CrashSphere(Math::Vector( 0.0f, 17.0f, 0.0f), 2.0f, SOUND_BOUMs, 0.20f)); - obj->AddCrashSphere(CrashSphere(Math::Vector( 1.0f, 27.0f, 0.0f), 2.0f, SOUND_BOUMs, 0.20f)); - - obj->CreateShadowCircle(8.0f, 0.5f); - } - if ( type == OBJECT_TREE1 ) { int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("tree1.mod", false, rank); + m_oldModelManager->AddModelReference("tree1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1505,7 +1503,7 @@ CObjectUPtr CObjectFactory::CreatePlant(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("tree2.mod", false, rank); + m_oldModelManager->AddModelReference("tree2.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1523,7 +1521,7 @@ CObjectUPtr CObjectFactory::CreatePlant(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("tree3.mod", false, rank); + m_oldModelManager->AddModelReference("tree3.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1540,7 +1538,7 @@ CObjectUPtr CObjectFactory::CreatePlant(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("tree4.mod", false, rank); + m_oldModelManager->AddModelReference("tree4.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1556,7 +1554,7 @@ CObjectUPtr CObjectFactory::CreatePlant(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("tree5.mod", false, rank); + m_oldModelManager->AddModelReference("tree5.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1598,7 +1596,7 @@ CObjectUPtr CObjectFactory::CreateMushroom(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("mush1.mod", false, rank); + m_oldModelManager->AddModelReference("mush1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1614,7 +1612,7 @@ CObjectUPtr CObjectFactory::CreateMushroom(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("mush2.mod", false, rank); + m_oldModelManager->AddModelReference("mush2.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1656,7 +1654,7 @@ CObjectUPtr CObjectFactory::CreateQuartz(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_QUARTZ); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("quartz0.mod", false, rank); + m_oldModelManager->AddModelReference("quartz0.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1670,7 +1668,7 @@ CObjectUPtr CObjectFactory::CreateQuartz(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_QUARTZ); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("quartz1.mod", false, rank); + m_oldModelManager->AddModelReference("quartz1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1684,7 +1682,7 @@ CObjectUPtr CObjectFactory::CreateQuartz(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_QUARTZ); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("quartz2.mod", false, rank); + m_oldModelManager->AddModelReference("quartz2.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1698,7 +1696,7 @@ CObjectUPtr CObjectFactory::CreateQuartz(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_QUARTZ); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("quartz3.mod", false, rank); + m_oldModelManager->AddModelReference("quartz3.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1762,7 +1760,7 @@ CObjectUPtr CObjectFactory::CreateRoot(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("root0.mod", false, rank); + m_oldModelManager->AddModelReference("root0.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetZoom(0, 2.0f); @@ -1783,7 +1781,7 @@ CObjectUPtr CObjectFactory::CreateRoot(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("root1.mod", false, rank); + m_oldModelManager->AddModelReference("root1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetZoom(0, 2.0f); @@ -1804,7 +1802,7 @@ CObjectUPtr CObjectFactory::CreateRoot(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("root2.mod", false, rank); + m_oldModelManager->AddModelReference("root2.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetZoom(0, 2.0f); @@ -1824,7 +1822,7 @@ CObjectUPtr CObjectFactory::CreateRoot(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("root3.mod", false, rank); + m_oldModelManager->AddModelReference("root3.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetZoom(0, 2.0f); @@ -1846,7 +1844,7 @@ CObjectUPtr CObjectFactory::CreateRoot(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("root4.mod", false, rank); + m_oldModelManager->AddModelReference("root4.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetZoom(0, 2.0f); @@ -1870,7 +1868,7 @@ CObjectUPtr CObjectFactory::CreateRoot(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("root4.mod", false, rank); + m_oldModelManager->AddModelReference("root4.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetZoom(0, 2.0f); @@ -1879,7 +1877,7 @@ CObjectUPtr CObjectFactory::CreateRoot(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1, rank); obj->SetObjectParent(1, 0); - m_modelManager->AddModelReference("root5.mod", false, rank); + m_oldModelManager->AddModelReference("root5.mod", false, rank); obj->SetPosition(1, Math::Vector(-5.0f, 28.0f, -4.0f)); obj->SetAngleX(1, -30.0f*Math::PI/180.0f); obj->SetAngleZ(1, 20.0f*Math::PI/180.0f); @@ -1929,7 +1927,7 @@ CObjectUPtr CObjectFactory::CreateHome(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("home1.mod", false, rank); + m_oldModelManager->AddModelReference("home1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetZoom(0, 1.3f); @@ -1983,7 +1981,7 @@ CObjectUPtr CObjectFactory::CreateRuin(const ObjectCreateParams& params) if ( type == OBJECT_RUINbase ) name = "ruin9.mod"; if ( type == OBJECT_RUINhead ) name = "ruin10.mod"; - m_modelManager->AddModelReference(name, false, rank); + m_oldModelManager->AddModelReference(name, false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); @@ -1996,7 +1994,7 @@ CObjectUPtr CObjectFactory::CreateRuin(const ObjectCreateParams& params) obj->SetObjectRank(6, rank); obj->SetObjectParent(6, 0); - m_modelManager->AddModelReference("ruin1w.mod", false, rank); + m_oldModelManager->AddModelReference("ruin1w.mod", false, rank); obj->SetPosition(6, Math::Vector(-3.0f, 1.8f, -4.0f)); obj->SetAngleX(6, -Math::PI/2.0f); @@ -2007,7 +2005,7 @@ CObjectUPtr CObjectFactory::CreateRuin(const ObjectCreateParams& params) obj->SetObjectRank(7, rank); obj->SetObjectParent(7, 0); - m_modelManager->AddModelReference("ruin1w.mod", false, rank); + m_oldModelManager->AddModelReference("ruin1w.mod", false, rank); obj->SetPosition(7, Math::Vector(-3.0f, 1.0f, 3.0f)); obj->SetAngleY(7, Math::PI-0.3f); @@ -2019,7 +2017,7 @@ CObjectUPtr CObjectFactory::CreateRuin(const ObjectCreateParams& params) obj->SetObjectRank(8, rank); obj->SetObjectParent(8, 0); - m_modelManager->AddModelReference("ruin1w.mod", false, rank); + m_oldModelManager->AddModelReference("ruin1w.mod", false, rank); obj->SetPosition(8, Math::Vector(2.0f, 1.6f, -3.0f)); obj->SetAngleY(8, 0.3f); @@ -2030,7 +2028,7 @@ CObjectUPtr CObjectFactory::CreateRuin(const ObjectCreateParams& params) obj->SetObjectRank(9, rank); obj->SetObjectParent(9, 0); - m_modelManager->AddModelReference("ruin1w.mod", false, rank); + m_oldModelManager->AddModelReference("ruin1w.mod", false, rank); obj->SetPosition(9, Math::Vector(2.0f, 1.0f, 3.0f)); obj->SetAngleY(9, Math::PI-0.2f); @@ -2050,7 +2048,7 @@ CObjectUPtr CObjectFactory::CreateRuin(const ObjectCreateParams& params) obj->SetObjectRank(7, rank); obj->SetObjectParent(7, 0); - m_modelManager->AddModelReference("ruin1w.mod", false, rank); + m_oldModelManager->AddModelReference("ruin1w.mod", false, rank); obj->SetPosition(7, Math::Vector(-3.0f, 1.0f, 3.0f)); obj->SetAngleY(7, Math::PI+0.3f); @@ -2062,7 +2060,7 @@ CObjectUPtr CObjectFactory::CreateRuin(const ObjectCreateParams& params) obj->SetObjectRank(9, rank); obj->SetObjectParent(9, 0); - m_modelManager->AddModelReference("ruin1w.mod", false, rank); + m_oldModelManager->AddModelReference("ruin1w.mod", false, rank); obj->SetPosition(9, Math::Vector(2.0f, 1.0f, 3.0f)); obj->SetAngleY(9, Math::PI+0.3f); @@ -2082,7 +2080,7 @@ CObjectUPtr CObjectFactory::CreateRuin(const ObjectCreateParams& params) obj->SetObjectRank(1, rank); obj->SetObjectParent(1, 0); - m_modelManager->AddModelReference("ruin2c.mod", false, rank); + m_oldModelManager->AddModelReference("ruin2c.mod", false, rank); obj->SetPosition(1, Math::Vector(3.0f, 5.0f, -2.5f)); obj->SetAngleX(1, -Math::PI*0.85f); @@ -2384,7 +2382,7 @@ CObjectUPtr CObjectFactory::CreateApollo(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); // it is a stationary object obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("apollol1.mod", false, rank); + m_oldModelManager->AddModelReference("apollol1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetZoom(0, 1.2f); @@ -2396,7 +2394,7 @@ CObjectUPtr CObjectFactory::CreateApollo(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(i+1, rank); obj->SetObjectParent(i+1, 0); - m_modelManager->AddModelReference("apollol2.mod", false, rank); + m_oldModelManager->AddModelReference("apollol2.mod", false, rank); obj->SetAngleY(i+1, Math::PI/2.0f*i); } @@ -2404,7 +2402,7 @@ CObjectUPtr CObjectFactory::CreateApollo(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(5, rank); obj->SetObjectParent(5, 0); - m_modelManager->AddModelReference("apollol3.mod", false, rank); // ladder + m_oldModelManager->AddModelReference("apollol3.mod", false, rank); // ladder //? m_terrain->AddBuildingLevel(pos, 10.0f, 13.0f, 12.0f, 0.0f); @@ -2424,7 +2422,7 @@ CObjectUPtr CObjectFactory::CreateApollo(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); //it is a stationary object obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("apolloj1.mod", false, rank); + m_oldModelManager->AddModelReference("apolloj1.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -2434,28 +2432,28 @@ CObjectUPtr CObjectFactory::CreateApollo(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1, rank); obj->SetObjectParent(1, 0); - m_modelManager->AddModelReference("apolloj4.mod", false, rank); // wheel + m_oldModelManager->AddModelReference("apolloj4.mod", false, rank); // wheel obj->SetPosition(1, Math::Vector(-5.75f, 1.65f, -5.0f)); rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(2, rank); obj->SetObjectParent(2, 0); - m_modelManager->AddModelReference("apolloj4.mod", false, rank); // wheel + m_oldModelManager->AddModelReference("apolloj4.mod", false, rank); // wheel obj->SetPosition(2, Math::Vector(-5.75f, 1.65f, 5.0f)); rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(3, rank); obj->SetObjectParent(3, 0); - m_modelManager->AddModelReference("apolloj4.mod", false, rank); // wheel + m_oldModelManager->AddModelReference("apolloj4.mod", false, rank); // wheel obj->SetPosition(3, Math::Vector(5.75f, 1.65f, -5.0f)); rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(4, rank); obj->SetObjectParent(4, 0); - m_modelManager->AddModelReference("apolloj4.mod", false, rank); // wheel + m_oldModelManager->AddModelReference("apolloj4.mod", false, rank); // wheel obj->SetPosition(4, Math::Vector(5.75f, 1.65f, 5.0f)); // Accessories: @@ -2463,7 +2461,7 @@ CObjectUPtr CObjectFactory::CreateApollo(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(5, rank); obj->SetObjectParent(5, 0); - m_modelManager->AddModelReference("apolloj2.mod", false, rank); // antenna + m_oldModelManager->AddModelReference("apolloj2.mod", false, rank); // antenna obj->SetPosition(5, Math::Vector(5.5f, 8.8f, 2.0f)); obj->SetAngleY(5, -120.0f*Math::PI/180.0f); obj->SetAngleZ(5, 45.0f*Math::PI/180.0f); @@ -2472,7 +2470,7 @@ CObjectUPtr CObjectFactory::CreateApollo(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(6, rank); obj->SetObjectParent(6, 0); - m_modelManager->AddModelReference("apolloj3.mod", false, rank); // camera + m_oldModelManager->AddModelReference("apolloj3.mod", false, rank); // camera obj->SetPosition(6, Math::Vector(5.5f, 2.8f, -2.0f)); obj->SetAngleY(6, 30.0f*Math::PI/180.0f); @@ -2490,7 +2488,7 @@ CObjectUPtr CObjectFactory::CreateApollo(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); // it is a stationary object obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("apollof.mod", false, rank); + m_oldModelManager->AddModelReference("apollof.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -2504,7 +2502,7 @@ CObjectUPtr CObjectFactory::CreateApollo(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); // it is a stationary object obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("apollom.mod", false, rank); + m_oldModelManager->AddModelReference("apollom.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -2520,7 +2518,7 @@ CObjectUPtr CObjectFactory::CreateApollo(const ObjectCreateParams& params) int rank = m_engine->CreateObject(); m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_FIX); // it is a stationary object obj->SetObjectRank(0, rank); - m_modelManager->AddModelReference("apolloa.mod", false, rank); + m_oldModelManager->AddModelReference("apolloa.mod", false, rank); obj->SetPosition(0, pos); obj->SetAngleY(0, angle); obj->SetFloorHeight(0.0f); @@ -2529,7 +2527,7 @@ CObjectUPtr CObjectFactory::CreateApollo(const ObjectCreateParams& params) m_engine->SetObjectType(rank, Gfx::ENG_OBJTYPE_DESCENDANT); obj->SetObjectRank(1, rank); obj->SetObjectParent(1, 0); - m_modelManager->AddModelReference("apolloj2.mod", false, rank); // antenna + m_oldModelManager->AddModelReference("apolloj2.mod", false, rank); // antenna obj->SetPosition(1, Math::Vector(0.0f, 5.0f, 0.0f)); obj->SetAngleY(1, -120.0f*Math::PI/180.0f); obj->SetAngleZ(1, 45.0f*Math::PI/180.0f); @@ -2566,7 +2564,7 @@ CObjectUPtr CObjectFactory::CreateVehicle(const ObjectCreateParams& params) if ( type == OBJECT_TOTO ) { std::unique_ptr motion{new CMotionToto(obj.get())}; - motion->Create(pos, angle, type, 1.0f, m_modelManager); + motion->Create(pos, angle, type, 1.0f, m_oldModelManager); obj->SetMotion(std::move(motion)); return std::move(obj); } @@ -2639,7 +2637,7 @@ CObjectUPtr CObjectFactory::CreateVehicle(const ObjectCreateParams& params) physics->SetBrain(brain.get()); physics->SetMotion(motion.get()); - motion->Create(pos, angle, type, power, m_modelManager); + motion->Create(pos, angle, type, power, m_oldModelManager); obj->SetBrain(std::move(brain)); obj->SetMotion(std::move(motion)); @@ -2693,7 +2691,7 @@ CObjectUPtr CObjectFactory::CreateInsect(const ObjectCreateParams& params) motion->SetBrain(brain.get()); motion->SetPhysics(physics.get()); - motion->Create(pos, angle, type, 0.0f, m_modelManager); + motion->Create(pos, angle, type, 0.0f, m_oldModelManager); obj->SetMotion(std::move(motion)); obj->SetPhysics(std::move(physics)); diff --git a/src/object/object_factory.h b/src/object/object_factory.h index c0aa2580..607abf2d 100644 --- a/src/object/object_factory.h +++ b/src/object/object_factory.h @@ -33,6 +33,7 @@ namespace Gfx { class CEngine; class COldModelManager; +class CModelManager; class CParticle; class CTerrain; } // namespace Gfx @@ -48,7 +49,8 @@ class CObjectFactory public: CObjectFactory(Gfx::CEngine* engine, Gfx::CTerrain* terrain, - Gfx::COldModelManager* modelManager, + Gfx::COldModelManager* oldModelManager, + Gfx::CModelManager* modelManager, Gfx::CParticle* particle); CObjectUPtr CreateObject(const ObjectCreateParams& params); @@ -72,6 +74,7 @@ private: private: Gfx::CEngine* m_engine; Gfx::CTerrain* m_terrain; - Gfx::COldModelManager* m_modelManager; + Gfx::COldModelManager* m_oldModelManager; + Gfx::CModelManager* m_modelManager; Gfx::CParticle* m_particle; }; diff --git a/src/object/object_interface_type.h b/src/object/object_interface_type.h index 863fb95b..910b0565 100644 --- a/src/object/object_interface_type.h +++ b/src/object/object_interface_type.h @@ -38,6 +38,7 @@ enum class ObjectInterfaceType Jostleable, //!< object that can be jostled Carrier, //!< object that can carry other objects Powered, //!< object powered with power cell + Old, //!< old objects, TODO: remove once no longer necessary Max //!< maximum value (for getting number of items in enum) }; diff --git a/src/object/object_manager.cpp b/src/object/object_manager.cpp index 79d4cbcd..99177c00 100644 --- a/src/object/object_manager.cpp +++ b/src/object/object_manager.cpp @@ -24,6 +24,7 @@ #include "object/object.h" #include "object/object_create_params.h" +#include "object/object_create_exception.h" #include "object/object_factory.h" #include "object/old_object.h" #include "object/auto/auto.h" @@ -38,9 +39,10 @@ template<> CObjectManager* CSingleton::m_instance = nullptr; CObjectManager::CObjectManager(Gfx::CEngine* engine, Gfx::CTerrain* terrain, - Gfx::COldModelManager* modelManager, + Gfx::COldModelManager* oldModelManager, + Gfx::CModelManager* modelManager, Gfx::CParticle* particle) - : m_objectFactory(new CObjectFactory(engine, terrain, modelManager, particle)) + : m_objectFactory(new CObjectFactory(engine, terrain, oldModelManager, modelManager, particle)) , m_nextId(0) { } @@ -132,6 +134,10 @@ CObject* CObjectManager::CreateObject(Math::Vector pos, params.id = id; auto objectUPtr = m_objectFactory->CreateObject(params); + + if (objectUPtr == nullptr) + throw CObjectCreateException("Something went wrong in CObjectFactory", type); + CObject* objectPtr = objectUPtr.get(); m_objects[id] = std::move(objectUPtr); diff --git a/src/object/object_manager.h b/src/object/object_manager.h index 5e30b72f..5353df6e 100644 --- a/src/object/object_manager.h +++ b/src/object/object_manager.h @@ -37,6 +37,7 @@ namespace Gfx { class CEngine; +class CModelManager; class COldModelManager; class CParticle; class CTerrain; @@ -121,7 +122,8 @@ class CObjectManager : public CSingleton public: CObjectManager(Gfx::CEngine* engine, Gfx::CTerrain* terrain, - Gfx::COldModelManager* modelManager, + Gfx::COldModelManager* oldModelManager, + Gfx::CModelManager* modelManager, Gfx::CParticle* particle); virtual ~CObjectManager(); diff --git a/src/object/object_type.h b/src/object/object_type.h index 7de18dca..1e9d4409 100644 --- a/src/object/object_type.h +++ b/src/object/object_type.h @@ -24,6 +24,8 @@ #pragma once +#include + /** * \enum ObjectType * \brief Type of game object @@ -191,3 +193,11 @@ enum ObjectType OBJECT_MAX = 1000 //! < number of values }; + +struct ObjectTypeHash +{ + inline std::size_t operator()(ObjectType t) const + { + return std::hash()(t); + } +}; diff --git a/src/object/old_object.cpp b/src/object/old_object.cpp index a8adbab8..4a328782 100644 --- a/src/object/old_object.cpp +++ b/src/object/old_object.cpp @@ -203,6 +203,8 @@ COldObject::COldObject(int id) // Another hack m_implementedInterfaces[static_cast(ObjectInterfaceType::Jostleable)] = false; + m_implementedInterfaces[static_cast(ObjectInterfaceType::Old)] = true; + m_sound = CApplication::GetInstancePointer()->GetSound(); m_engine = Gfx::CEngine::GetInstancePointer(); m_lightMan = m_engine->GetLightManager(); @@ -941,6 +943,8 @@ void COldObject::Write(CLevelParserLine* line) if ( m_virusTime != 0.0f ) line->AddParam("virusTime", CLevelParserParamUPtr{new CLevelParserParam(m_virusTime)}); + line->AddParam("ignoreBuildCheck", CLevelParserParamUPtr{new CLevelParserParam(GetIgnoreBuildCheck())}); + // Sets the parameters of the command line. CLevelParserParamVec cmdline; for(float value : m_cmdLine) @@ -975,14 +979,13 @@ void COldObject::Write(CLevelParserLine* line) void COldObject::Read(CLevelParserLine* line) { - Math::Vector pos, dir; - Gfx::CameraType cType = line->GetParam("camera")->AsCameraType(Gfx::CAM_TYPE_NULL); if ( cType != Gfx::CAM_TYPE_NULL ) { SetCameraType(cType); } + SetCameraDist(line->GetParam("cameraDist")->AsFloat(50.0f)); SetCameraLock(line->GetParam("cameraLock")->AsBool(false)); SetEnergy(line->GetParam("energy")->AsFloat(0.0f)); SetCapacity(line->GetParam("capacity")->AsFloat(1.0f)); @@ -1000,6 +1003,7 @@ void COldObject::Read(CLevelParserLine* line) SetTeam(line->GetParam("team")->AsInt(0)); SetGunGoalV(line->GetParam("aimV")->AsFloat(0.0f)); SetGunGoalH(line->GetParam("aimH")->AsFloat(0.0f)); + SetResetCap(static_cast(line->GetParam("resetCap")->AsInt(0))); SetResetPosition(line->GetParam("resetPos")->AsPoint(Math::Vector())*g_unit); SetResetAngle(line->GetParam("resetAngle")->AsPoint(Math::Vector())*(Math::PI/180.0f)); @@ -1007,6 +1011,7 @@ void COldObject::Read(CLevelParserLine* line) m_bBurn = line->GetParam("burnMode")->AsBool(false); m_bVirusMode = line->GetParam("virusMode")->AsBool(false); m_virusTime = line->GetParam("virusTime")->AsFloat(0.0f); + SetIgnoreBuildCheck(line->GetParam("ignoreBuildCheck")->AsBool(false)); // Sets the parameters of the command line. if (line->GetParam("cmdline")->IsDefined()) @@ -1028,7 +1033,6 @@ void COldObject::Read(CLevelParserLine* line) { m_brain->Read(line); } - if ( m_physics != nullptr ) { m_physics->Read(line); @@ -1229,114 +1233,38 @@ Math::Vector COldObject::GetTilt() void COldObject::SetPosition(int part, const Math::Vector &pos) { - Math::Vector shPos, n[20], norm; - float height, radius; - int rank, i, j; - m_objectPart[part].position = pos; m_objectPart[part].bTranslate = true; // it will recalculate the matrices if ( part == 0 && !m_bFlat ) // main part? { - rank = m_objectPart[0].object; + int rank = m_objectPart[0].object; - shPos = pos; + Math::Vector shPos = pos; m_terrain->AdjustToFloor(shPos, true); m_engine->SetObjectShadowPos(rank, shPos); + float height = 0.0f; if ( m_physics != nullptr && m_physics->GetType() == TYPE_FLYING ) { height = pos.y-shPos.y; } - else - { - height = 0.0f; - } m_engine->SetObjectShadowHeight(rank, height); - // Calculating the normal to the ground in nine strategic locations, - // then perform a weighted average (the dots in the center are more important). - radius = m_engine->GetObjectShadowRadius(rank); - i = 0; - - m_terrain->GetNormal(norm, pos); - n[i++] = norm; - n[i++] = norm; - n[i++] = norm; - - shPos = pos; - shPos.x += radius*0.6f; - shPos.z += radius*0.6f; - m_terrain->GetNormal(norm, shPos); - n[i++] = norm; - n[i++] = norm; - - shPos = pos; - shPos.x -= radius*0.6f; - shPos.z += radius*0.6f; - m_terrain->GetNormal(norm, shPos); - n[i++] = norm; - n[i++] = norm; - - shPos = pos; - shPos.x += radius*0.6f; - shPos.z -= radius*0.6f; - m_terrain->GetNormal(norm, shPos); - n[i++] = norm; - n[i++] = norm; - - shPos = pos; - shPos.x -= radius*0.6f; - shPos.z -= radius*0.6f; - m_terrain->GetNormal(norm, shPos); - n[i++] = norm; - n[i++] = norm; - - shPos = pos; - shPos.x += radius; - shPos.z += radius; - m_terrain->GetNormal(norm, shPos); - n[i++] = norm; - - shPos = pos; - shPos.x -= radius; - shPos.z += radius; - m_terrain->GetNormal(norm, shPos); - n[i++] = norm; - - shPos = pos; - shPos.x += radius; - shPos.z -= radius; - m_terrain->GetNormal(norm, shPos); - n[i++] = norm; - - shPos = pos; - shPos.x -= radius; - shPos.z -= radius; - m_terrain->GetNormal(norm, shPos); - n[i++] = norm; - - norm.LoadZero(); - for ( j=0 ; j(i); // average vector - - m_engine->SetObjectShadowNormal(rank, norm); + m_engine->UpdateObjectShadowNormal(rank); if ( m_shadowLight != -1 ) { - shPos = pos; - shPos.y += m_shadowHeight; - m_lightMan->SetLightPos(m_shadowLight, shPos); + Math::Vector lightPos = pos; + lightPos.y += m_shadowHeight; + m_lightMan->SetLightPos(m_shadowLight, lightPos); } if ( m_effectLight != -1 ) { - shPos = pos; - shPos.y += m_effectHeight; - m_lightMan->SetLightPos(m_effectLight, shPos); + Math::Vector lightPos = pos; + lightPos.y += m_effectHeight; + m_lightMan->SetLightPos(m_effectLight, lightPos); } if ( m_bShowLimit ) @@ -3437,8 +3365,6 @@ void COldObject::SetAuto(std::unique_ptr automat) m_auto = std::move(automat); } - - // Management of the position in the file definition. void COldObject::SetDefRank(int rank) @@ -3451,7 +3377,6 @@ int COldObject::GetDefRank() return m_defRank; } - // Getes the object name for the tooltip. bool COldObject::GetTooltipName(std::string& name) diff --git a/src/object/old_object_interface.cpp b/src/object/old_object_interface.cpp new file mode 100644 index 00000000..e086d2a8 --- /dev/null +++ b/src/object/old_object_interface.cpp @@ -0,0 +1,851 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + +#include "object/old_object_interface.h" + + +void COldObjectInterface::Simplify() +{ + throw std::logic_error("Simplify: not implemented!"); +} + +bool COldObjectInterface::ExplodeObject(ExplosionType type, float force, float decay) +{ + throw std::logic_error("ExplodeObject: not implemented!"); +} + + +void COldObjectInterface::UpdateMapping() +{ + throw std::logic_error("UpdateMapping: not implemented!"); +} + + +void COldObjectInterface::DeletePart(int part) +{ + throw std::logic_error("DeletePart: not implemented!"); +} + +void COldObjectInterface::SetObjectRank(int part, int objRank) +{ + throw std::logic_error("SetObjectRank: not implemented!"); +} + +int COldObjectInterface::GetObjectRank(int part) +{ + throw std::logic_error("GetObjectRank: not implemented!"); +} + +void COldObjectInterface::SetObjectParent(int part, int parent) +{ + throw std::logic_error("SetObjectParent: not implemented!"); +} + +void COldObjectInterface::SetType(ObjectType type) +{ + throw std::logic_error("SetType: not implemented!"); +} + +const char* COldObjectInterface::GetName() +{ + throw std::logic_error("GetName: not implemented!"); +} + +int COldObjectInterface::GetOption() +{ + throw std::logic_error("GetOption: not implemented!"); +} + + +void COldObjectInterface::SetDrawWorld(bool bDraw) +{ + throw std::logic_error("SetDrawWorld: not implemented!"); +} + +void COldObjectInterface::SetDrawFront(bool bDraw) +{ + throw std::logic_error("SetDrawFront: not implemented!"); +} + + +bool COldObjectInterface::ReadProgram(Program* program, const char* filename) +{ + throw std::logic_error("ReadProgram: not implemented!"); +} + +bool COldObjectInterface::WriteProgram(Program* program, const char* filename) +{ + throw std::logic_error("WriteProgram: not implemented!"); +} + + +int COldObjectInterface::GetShadowLight() +{ + throw std::logic_error("GetShadowLight: not implemented!"); +} + +int COldObjectInterface::GetEffectLight() +{ + throw std::logic_error("GetEffectLight: not implemented!"); +} + +void COldObjectInterface::SetShieldRadius(float radius) +{ + throw std::logic_error("SetShieldRadius: not implemented!"); +} + +float COldObjectInterface::GetShieldRadius() +{ + throw std::logic_error("GetShieldRadius: not implemented!"); +} + + +void COldObjectInterface::SetFloorHeight(float height) +{ + throw std::logic_error("SetFloorHeight: not implemented!"); +} + +void COldObjectInterface::FloorAdjust() +{ + throw std::logic_error("FloorAdjust: not implemented!"); +} + + +void COldObjectInterface::SetLinVibration(Math::Vector dir) +{ + throw std::logic_error("SetLinVibration: not implemented!"); +} + +Math::Vector COldObjectInterface::GetLinVibration() +{ + throw std::logic_error("GetLinVibration: not implemented!"); +} + +void COldObjectInterface::SetCirVibration(Math::Vector dir) +{ + throw std::logic_error("SetCirVibration: not implemented!"); +} + +Math::Vector COldObjectInterface::GetCirVibration() +{ + throw std::logic_error("GetCirVibration: not implemented!"); +} + +void COldObjectInterface::SetTilt(Math::Vector dir) +{ + throw std::logic_error("SetTilt: not implemented!"); +} + +Math::Vector COldObjectInterface::GetTilt() +{ + throw std::logic_error("GetTilt: not implemented!"); +} + + +void COldObjectInterface::SetPosition(int part, const Math::Vector &pos) +{ + throw std::logic_error("SetPosition: not implemented!"); +} + +Math::Vector COldObjectInterface::GetPosition(int part) +{ + throw std::logic_error("GetPosition: not implemented!"); +} + +void COldObjectInterface::SetAngle(int part, const Math::Vector &angle) +{ + throw std::logic_error("SetAngle: not implemented!"); +} + +Math::Vector COldObjectInterface::GetAngle(int part) +{ + throw std::logic_error("GetAngle: not implemented!"); +} + +void COldObjectInterface::SetAngleY(int part, float angle) +{ + throw std::logic_error("SetAngleY: not implemented!"); +} + +void COldObjectInterface::SetAngleX(int part, float angle) +{ + throw std::logic_error("SetAngleX: not implemented!"); +} + +void COldObjectInterface::SetAngleZ(int part, float angle) +{ + throw std::logic_error("SetAngleZ: not implemented!"); +} + +float COldObjectInterface::GetAngleY(int part) +{ + throw std::logic_error("GetAngleY: not implemented!"); +} + +float COldObjectInterface::GetAngleX(int part) +{ + throw std::logic_error("GetAngleX: not implemented!"); +} + +float COldObjectInterface::GetAngleZ(int part) +{ + throw std::logic_error("GetAngleZ: not implemented!"); +} + +void COldObjectInterface::SetZoom(int part, float zoom) +{ + throw std::logic_error("SetZoom: not implemented!"); +} + +void COldObjectInterface::SetZoom(int part, Math::Vector zoom) +{ + throw std::logic_error("SetZoom: not implemented!"); +} + +Math::Vector COldObjectInterface::GetZoom(int part) +{ + throw std::logic_error("GetZoom: not implemented!"); +} + +void COldObjectInterface::SetZoomX(int part, float zoom) +{ + throw std::logic_error("SetZoomX: not implemented!"); +} + +float COldObjectInterface::GetZoomX(int part) +{ + throw std::logic_error("GetZoomX: not implemented!"); +} + +void COldObjectInterface::SetZoomY(int part, float zoom) +{ + throw std::logic_error("SetZoomY: not implemented!"); +} + +float COldObjectInterface::GetZoomY(int part) +{ + throw std::logic_error("GetZoomY: not implemented!"); +} + +void COldObjectInterface::SetZoomZ(int part, float zoom) +{ + throw std::logic_error("SetZoomZ: not implemented!"); +} + +float COldObjectInterface::GetZoomZ(int part) +{ + throw std::logic_error("GetZoomZ: not implemented!"); +} + + +void COldObjectInterface::SetTrainer(bool bEnable) +{ + throw std::logic_error("SetTrainer: not implemented!"); +} + +bool COldObjectInterface::GetTrainer() +{ + throw std::logic_error("GetTrainer: not implemented!"); +} + + +void COldObjectInterface::SetToy(bool bEnable) +{ + throw std::logic_error("SetToy: not implemented!"); +} + +bool COldObjectInterface::GetToy() +{ + throw std::logic_error("GetToy: not implemented!"); +} + + +void COldObjectInterface::SetManual(bool bManual) +{ + throw std::logic_error("SetManual: not implemented!"); +} + +bool COldObjectInterface::GetManual() +{ + throw std::logic_error("GetManual: not implemented!"); +} + + +void COldObjectInterface::SetResetCap(ResetCap cap) +{ + throw std::logic_error("SetResetCap: not implemented!"); +} + +ResetCap COldObjectInterface::GetResetCap() +{ + throw std::logic_error("GetResetCap: not implemented!"); +} + +void COldObjectInterface::SetResetBusy(bool bBusy) +{ + throw std::logic_error("SetResetBusy: not implemented!"); +} + +bool COldObjectInterface::GetResetBusy() +{ + throw std::logic_error("GetResetBusy: not implemented!"); +} + +void COldObjectInterface::SetResetPosition(const Math::Vector &pos) +{ + throw std::logic_error("SetResetPosition: not implemented!"); +} + +Math::Vector COldObjectInterface::GetResetPosition() +{ + throw std::logic_error("GetResetPosition: not implemented!"); +} + +void COldObjectInterface::SetResetAngle(const Math::Vector &angle) +{ + throw std::logic_error("SetResetAngle: not implemented!"); +} + +Math::Vector COldObjectInterface::GetResetAngle() +{ + throw std::logic_error("GetResetAngle: not implemented!"); +} + +void COldObjectInterface::SetResetRun(Program* run) +{ + throw std::logic_error("SetResetRun: not implemented!"); +} + +Program* COldObjectInterface::GetResetRun() +{ + throw std::logic_error("GetResetRun: not implemented!"); +} + + +void COldObjectInterface::SetMasterParticle(int part, int parti) +{ + throw std::logic_error("SetMasterParticle: not implemented!"); +} + +int COldObjectInterface::GetMasterParticle(int part) +{ + throw std::logic_error("GetMasterParticle: not implemented!"); +} + +void COldObjectInterface::SetCmdLine(unsigned int rank, float value) +{ + throw std::logic_error("SetCmdLine: not implemented!"); +} + +float COldObjectInterface::GetCmdLine(unsigned int rank) +{ + throw std::logic_error("GetCmdLine: not implemented!"); +} + + +Math::Matrix* COldObjectInterface::GetRotateMatrix(int part) +{ + throw std::logic_error("GetRotateMatrix: not implemented!"); +} + +Math::Matrix* COldObjectInterface::GetWorldMatrix(int part) +{ + throw std::logic_error("GetWorldMatrix: not implemented!"); +} + +void COldObjectInterface::SetViewFromHere(Math::Vector &eye, float &dirH, float &dirV, + Math::Vector &lookat, Math::Vector &upVec, + Gfx::CameraType type) +{ + throw std::logic_error("SetViewFromHere: not implemented!"); +} + +void COldObjectInterface::GetCharacter(Character* character) +{ + throw std::logic_error("GetCharacter: not implemented!"); +} + +Character* COldObjectInterface::GetCharacter() +{ + throw std::logic_error("GetCharacter: not implemented!"); +} + + +float COldObjectInterface::GetAbsTime() +{ + throw std::logic_error("GetAbsTime: not implemented!"); +} + + +void COldObjectInterface::SetEnergy(float level) +{ + throw std::logic_error("SetEnergy: not implemented!"); +} + +float COldObjectInterface::GetEnergy() +{ + throw std::logic_error("GetEnergy: not implemented!"); +} + + +float COldObjectInterface::GetCapacity() +{ + throw std::logic_error("GetCapacity: not implemented!"); +} + + +void COldObjectInterface::SetShield(float level) +{ + throw std::logic_error("SetShield: not implemented!"); +} + +float COldObjectInterface::GetShield() +{ + throw std::logic_error("GetShield: not implemented!"); +} + + +void COldObjectInterface::SetRange(float delay) +{ + throw std::logic_error("SetRange: not implemented!"); +} + +float COldObjectInterface::GetRange() +{ + throw std::logic_error("GetRange: not implemented!"); +} + +void COldObjectInterface::SetFixed(bool bFixed) +{ + throw std::logic_error("SetFixed: not implemented!"); +} + +bool COldObjectInterface::GetFixed() +{ + throw std::logic_error("GetFixed: not implemented!"); +} + + +void COldObjectInterface::SetClip(bool bClip) +{ + throw std::logic_error("SetClip: not implemented!"); +} + +bool COldObjectInterface::GetClip() +{ + throw std::logic_error("GetClip: not implemented!"); +} + + +void COldObjectInterface::SetTeam(int team) +{ + throw std::logic_error("SetTeam: not implemented!"); +} + +int COldObjectInterface::GetTeam() +{ + throw std::logic_error("GetTeam: not implemented!"); +} + + +void COldObjectInterface::StartDetectEffect(CObject *target, bool bFound) +{ + throw std::logic_error("StartDetectEffect: not implemented!"); +} + + +void COldObjectInterface::SetVirusMode(bool bEnable) +{ + throw std::logic_error("SetVirusMode: not implemented!"); +} + +bool COldObjectInterface::GetVirusMode() +{ + throw std::logic_error("GetVirusMode: not implemented!"); +} + +float COldObjectInterface::GetVirusTime() +{ + throw std::logic_error("GetVirusTime: not implemented!"); +} + + +void COldObjectInterface::SetCameraType(Gfx::CameraType type) +{ + throw std::logic_error("SetCameraType: not implemented!"); +} + +Gfx::CameraType COldObjectInterface::GetCameraType() +{ + throw std::logic_error("GetCameraType: not implemented!"); +} + +void COldObjectInterface::SetCameraDist(float dist) +{ + throw std::logic_error("SetCameraDist: not implemented!"); +} + +float COldObjectInterface::GetCameraDist() +{ + throw std::logic_error("GetCameraDist: not implemented!"); +} + +void COldObjectInterface::SetCameraLock(bool bLock) +{ + throw std::logic_error("SetCameraLock: not implemented!"); +} + +bool COldObjectInterface::GetCameraLock() +{ + throw std::logic_error("GetCameraLock: not implemented!"); +} + + +void COldObjectInterface::SetHighlight(bool mode) +{ + // TODO: temporary hack + return; + //throw std::logic_error("SetHighlight: not implemented!"); +} + + +void COldObjectInterface::SetSelect(bool bMode, bool bDisplayError) +{ + // TODO: temporary hack + //throw std::logic_error("SetSelect: not implemented!"); +} + +bool COldObjectInterface::GetSelect(bool bReal) +{ + // TODO: temporary hack + return false; + //throw std::logic_error("GetSelect: not implemented!"); +} + + +void COldObjectInterface::SetSelectable(bool bMode) +{ + throw std::logic_error("SetSelectable: not implemented!"); +} + +bool COldObjectInterface::GetSelectable() +{ + throw std::logic_error("GetSelectable: not implemented!"); +} + + +void COldObjectInterface::SetActivity(bool bMode) +{ + throw std::logic_error("SetActivity: not implemented!"); +} + +bool COldObjectInterface::GetActivity() +{ + throw std::logic_error("GetActivity: not implemented!"); +} + + +void COldObjectInterface::SetVisible(bool bVisible) +{ + throw std::logic_error("SetVisible: not implemented!"); +} + + +void COldObjectInterface::SetEnable(bool bEnable) +{ + throw std::logic_error("SetEnable: not implemented!"); +} + +bool COldObjectInterface::GetEnable() +{ + // TODO: temporary hack + return true; + //throw std::logic_error("GetEnable: not implemented!"); +} + + +void COldObjectInterface::SetCheckToken(bool bMode) +{ + throw std::logic_error("SetCheckToken: not implemented!"); +} + +bool COldObjectInterface::GetCheckToken() +{ + throw std::logic_error("GetCheckToken: not implemented!"); +} + + +void COldObjectInterface::SetProxyActivate(bool bActivate) +{ + throw std::logic_error("SetProxyActivate: not implemented!"); +} + +bool COldObjectInterface::GetProxyActivate() +{ + throw std::logic_error("GetProxyActivate: not implemented!"); +} + +void COldObjectInterface::SetProxyDistance(float distance) +{ + throw std::logic_error("SetProxyDistance: not implemented!"); +} + + +void COldObjectInterface::SetMagnifyDamage(float factor) +{ + throw std::logic_error("SetMagnifyDamage: not implemented!"); +} + +float COldObjectInterface::GetMagnifyDamage() +{ + throw std::logic_error("GetMagnifyDamage: not implemented!"); +} + + +void COldObjectInterface::SetParam(float value) +{ + throw std::logic_error("SetParam: not implemented!"); +} + +float COldObjectInterface::GetParam() +{ + throw std::logic_error("GetParam: not implemented!"); +} + +void COldObjectInterface::SetIgnoreBuildCheck(bool bIgnoreBuildCheck) +{ + throw std::logic_error("SetIgnoreBuildCheck: not implemented!"); +} + +bool COldObjectInterface::GetIgnoreBuildCheck() +{ + throw std::logic_error("GetIgnoreBuildCheck: not implemented!"); +} + + +void COldObjectInterface::SetExploding(bool bExplo) +{ + throw std::logic_error("SetExploding: not implemented!"); +} + +bool COldObjectInterface::IsExploding() +{ + throw std::logic_error("IsExploding: not implemented!"); +} + +void COldObjectInterface::SetLock(bool bLock) +{ + throw std::logic_error("SetLock: not implemented!"); +} + +bool COldObjectInterface::GetLock() +{ + // TODO: temporary hack + return false; + //throw std::logic_error("GetLock: not implemented!"); +} + +void COldObjectInterface::SetSpaceshipCargo(bool bCargo) +{ + throw std::logic_error("SetSpaceshipCargo: not implemented!"); +} + +bool COldObjectInterface::IsSpaceshipCargo() +{ + throw std::logic_error("IsSpaceshipCargo: not implemented!"); +} + +void COldObjectInterface::SetBurn(bool bBurn) +{ + throw std::logic_error("SetBurn: not implemented!"); +} + +bool COldObjectInterface::GetBurn() +{ + throw std::logic_error("GetBurn: not implemented!"); +} + +void COldObjectInterface::SetDead(bool bDead) +{ + throw std::logic_error("SetDead: not implemented!"); +} + +bool COldObjectInterface::GetDead() +{ + // TODO: temporary hack + return false; + //throw std::logic_error("GetDead: not implemented!"); +} + +bool COldObjectInterface::GetRuin() +{ + // TODO: temporary hack + return false; + //throw std::logic_error("GetRuin: not implemented!"); +} + +bool COldObjectInterface::GetActive() +{ + // TODO: temporary hack + return false; + //throw std::logic_error("GetActive: not implemented!"); +} + + +void COldObjectInterface::SetGunGoalV(float gunGoal) +{ + throw std::logic_error("SetGunGoalV: not implemented!"); +} + +void COldObjectInterface::SetGunGoalH(float gunGoal) +{ + throw std::logic_error("SetGunGoalH: not implemented!"); +} + +float COldObjectInterface::GetGunGoalV() +{ + throw std::logic_error("GetGunGoalV: not implemented!"); +} + +float COldObjectInterface::GetGunGoalH() +{ + throw std::logic_error("GetGunGoalH: not implemented!"); +} + + +bool COldObjectInterface::StartShowLimit() +{ + throw std::logic_error("StartShowLimit: not implemented!"); +} + +void COldObjectInterface::StopShowLimit() +{ + throw std::logic_error("StopShowLimit: not implemented!"); +} + + +bool COldObjectInterface::IsProgram() +{ + throw std::logic_error("IsProgram: not implemented!"); +} + +void COldObjectInterface::CreateSelectParticle() +{ + throw std::logic_error("CreateSelectParticle: not implemented!"); +} + + +void COldObjectInterface::SetRunScript(CScript* script) +{ + throw std::logic_error("SetRunScript: not implemented!"); +} + +CScript* COldObjectInterface::GetRunScript() +{ + throw std::logic_error("GetRunScript: not implemented!"); +} + +CBotVar* COldObjectInterface::GetBotVar() +{ + throw std::logic_error("GetBotVar: not implemented!"); +} + +CPhysics* COldObjectInterface::GetPhysics() +{ + throw std::logic_error("GetPhysics: not implemented!"); +} + +CMotion* COldObjectInterface::GetMotion() +{ + throw std::logic_error("GetMotion: not implemented!"); +} + +CAuto* COldObjectInterface::GetAuto() +{ + throw std::logic_error("GetAuto: not implemented!"); +} + + +void COldObjectInterface::SetDefRank(int rank) +{ + throw std::logic_error("SetDefRank: not implemented!"); +} + +int COldObjectInterface::GetDefRank() +{ + throw std::logic_error("GetDefRank: not implemented!"); +} + + +bool COldObjectInterface::GetTooltipName(std::string& name) +{ + throw std::logic_error("GetTooltipName: not implemented!"); +} + + +void COldObjectInterface::AddDeselList(CObject* pObj) +{ + throw std::logic_error("AddDeselList: not implemented!"); +} + +CObject* COldObjectInterface::SubDeselList() +{ + throw std::logic_error("SubDeselList: not implemented!"); +} + +void COldObjectInterface::DeleteDeselList(CObject* pObj) +{ + // TODO: temporary hack + return; + //throw std::logic_error("DeleteDeselList: not implemented!"); +} + + +bool COldObjectInterface::CreateShadowCircle(float radius, float intensity, Gfx::EngineShadowType type) +{ + throw std::logic_error("CreateShadowCircle: not implemented!"); +} + +bool COldObjectInterface::CreateShadowLight(float height, Gfx::Color color) +{ + throw std::logic_error("CreateShadowLight: not implemented!"); +} + +bool COldObjectInterface::CreateEffectLight(float height, Gfx::Color color) +{ + throw std::logic_error("CreateEffectLight: not implemented!"); +} + + +void COldObjectInterface::FlatParent() +{ + throw std::logic_error("FlatParent: not implemented!"); +} + + +void COldObjectInterface::SetInfoReturn(float value) +{ + throw std::logic_error("SetInfoReturn: not implemented!"); +} + +float COldObjectInterface::GetInfoReturn() +{ + throw std::logic_error("GetInfoReturn: not implemented!"); +} + diff --git a/src/object/old_object_interface.h b/src/object/old_object_interface.h index 7eab6069..70ac6ead 100644 --- a/src/object/old_object_interface.h +++ b/src/object/old_object_interface.h @@ -76,212 +76,210 @@ class COldObjectInterface public: virtual ~COldObjectInterface() {} - virtual void Simplify() = 0; - virtual bool ExplodeObject(ExplosionType type, float force, float decay=1.0f) = 0; + virtual void Simplify(); + virtual bool ExplodeObject(ExplosionType type, float force, float decay=1.0f); - virtual void UpdateMapping() = 0; + virtual void UpdateMapping(); - virtual void DeletePart(int part) = 0; - virtual void SetObjectRank(int part, int objRank) = 0; - virtual int GetObjectRank(int part) = 0; - virtual void SetObjectParent(int part, int parent) = 0; - virtual void SetType(ObjectType type) = 0; - virtual const char* GetName() = 0; - virtual int GetOption() = 0; + virtual void DeletePart(int part); + virtual void SetObjectRank(int part, int objRank); + virtual int GetObjectRank(int part); + virtual void SetObjectParent(int part, int parent); + virtual void SetType(ObjectType type); + virtual const char* GetName(); + virtual int GetOption(); - virtual void SetDrawWorld(bool bDraw) = 0; - virtual void SetDrawFront(bool bDraw) = 0; + virtual void SetDrawWorld(bool bDraw); + virtual void SetDrawFront(bool bDraw); - virtual bool ReadProgram(Program* program, const char* filename) = 0; - virtual bool WriteProgram(Program* program, const char* filename) = 0; + virtual bool ReadProgram(Program* program, const char* filename); + virtual bool WriteProgram(Program* program, const char* filename); - virtual int GetShadowLight() = 0; - virtual int GetEffectLight() = 0; + virtual int GetShadowLight(); + virtual int GetEffectLight(); - virtual void SetShieldRadius(float radius) = 0; - virtual float GetShieldRadius() = 0; + virtual void SetShieldRadius(float radius); + virtual float GetShieldRadius(); - virtual void SetFloorHeight(float height) = 0; - virtual void FloorAdjust() = 0; + virtual void SetFloorHeight(float height); + virtual void FloorAdjust(); - virtual void SetLinVibration(Math::Vector dir) = 0; - virtual Math::Vector GetLinVibration() = 0; - virtual void SetCirVibration(Math::Vector dir) = 0; - virtual Math::Vector GetCirVibration() = 0; - virtual void SetTilt(Math::Vector dir) = 0; - virtual Math::Vector GetTilt() = 0; + virtual void SetLinVibration(Math::Vector dir); + virtual Math::Vector GetLinVibration(); + virtual void SetCirVibration(Math::Vector dir); + virtual Math::Vector GetCirVibration(); + virtual void SetTilt(Math::Vector dir); + virtual Math::Vector GetTilt(); - virtual void SetPosition(int part, const Math::Vector &pos) = 0; - virtual Math::Vector GetPosition(int part) = 0; - virtual void SetAngle(int part, const Math::Vector &angle) = 0; - virtual Math::Vector GetAngle(int part) = 0; - virtual void SetAngleY(int part, float angle) = 0; - virtual void SetAngleX(int part, float angle) = 0; - virtual void SetAngleZ(int part, float angle) = 0; - virtual float GetAngleY(int part) = 0; - virtual float GetAngleX(int part) = 0; - virtual float GetAngleZ(int part) = 0; - virtual void SetZoom(int part, float zoom) = 0; - virtual void SetZoom(int part, Math::Vector zoom) = 0; - virtual Math::Vector GetZoom(int part) = 0; - virtual void SetZoomX(int part, float zoom) = 0; - virtual float GetZoomX(int part) = 0; - virtual void SetZoomY(int part, float zoom) = 0; - virtual float GetZoomY(int part) = 0; - virtual void SetZoomZ(int part, float zoom) = 0; - virtual float GetZoomZ(int part) = 0; + virtual void SetPosition(int part, const Math::Vector &pos); + virtual Math::Vector GetPosition(int part); + virtual void SetAngle(int part, const Math::Vector &angle); + virtual Math::Vector GetAngle(int part); + virtual void SetAngleY(int part, float angle); + virtual void SetAngleX(int part, float angle); + virtual void SetAngleZ(int part, float angle); + virtual float GetAngleY(int part); + virtual float GetAngleX(int part); + virtual float GetAngleZ(int part); + virtual void SetZoom(int part, float zoom); + virtual void SetZoom(int part, Math::Vector zoom); + virtual Math::Vector GetZoom(int part); + virtual void SetZoomX(int part, float zoom); + virtual float GetZoomX(int part); + virtual void SetZoomY(int part, float zoom); + virtual float GetZoomY(int part); + virtual void SetZoomZ(int part, float zoom); + virtual float GetZoomZ(int part); - virtual void SetTrainer(bool bEnable) = 0; - virtual bool GetTrainer() = 0; + virtual void SetTrainer(bool bEnable); + virtual bool GetTrainer(); - virtual void SetToy(bool bEnable) = 0; - virtual bool GetToy() = 0; + virtual void SetToy(bool bEnable); + virtual bool GetToy(); - virtual void SetManual(bool bManual) = 0; - virtual bool GetManual() = 0; + virtual void SetManual(bool bManual); + virtual bool GetManual(); - virtual void SetResetCap(ResetCap cap) = 0; - virtual ResetCap GetResetCap() = 0; - virtual void SetResetBusy(bool bBusy) = 0; - virtual bool GetResetBusy() = 0; - virtual void SetResetPosition(const Math::Vector &pos) = 0; - virtual Math::Vector GetResetPosition() = 0; - virtual void SetResetAngle(const Math::Vector &angle) = 0; - virtual Math::Vector GetResetAngle() = 0; - virtual void SetResetRun(Program* run) = 0; - virtual Program* GetResetRun() = 0; + virtual void SetResetCap(ResetCap cap); + virtual ResetCap GetResetCap(); + virtual void SetResetBusy(bool bBusy); + virtual bool GetResetBusy(); + virtual void SetResetPosition(const Math::Vector &pos); + virtual Math::Vector GetResetPosition(); + virtual void SetResetAngle(const Math::Vector &angle); + virtual Math::Vector GetResetAngle(); + virtual void SetResetRun(Program* run); + virtual Program* GetResetRun(); - virtual void SetMasterParticle(int part, int parti) = 0; - virtual int GetMasterParticle(int part) = 0; + virtual void SetMasterParticle(int part, int parti); + virtual int GetMasterParticle(int part); - virtual void SetCmdLine(unsigned int rank, float value) = 0; - virtual float GetCmdLine(unsigned int rank) = 0; + virtual void SetCmdLine(unsigned int rank, float value); + virtual float GetCmdLine(unsigned int rank); - virtual Math::Matrix* GetRotateMatrix(int part) = 0; - virtual Math::Matrix* GetWorldMatrix(int part) = 0; + virtual Math::Matrix* GetRotateMatrix(int part); + virtual Math::Matrix* GetWorldMatrix(int part); virtual void SetViewFromHere(Math::Vector &eye, float &dirH, float &dirV, Math::Vector &lookat, Math::Vector &upVec, - Gfx::CameraType type) = 0; + Gfx::CameraType type); - virtual void GetCharacter(Character* character) = 0; - virtual Character* GetCharacter() = 0; + virtual void GetCharacter(Character* character); + virtual Character* GetCharacter(); - virtual float GetAbsTime() = 0; + virtual float GetAbsTime(); - virtual void SetEnergy(float level) = 0; - virtual float GetEnergy() = 0; + virtual void SetEnergy(float level); + virtual float GetEnergy(); - virtual float GetCapacity() = 0; + virtual float GetCapacity(); - virtual void SetShield(float level) = 0; - virtual float GetShield() = 0; + virtual void SetShield(float level); + virtual float GetShield(); - virtual void SetRange(float delay) = 0; - virtual float GetRange() = 0; + virtual void SetRange(float delay); + virtual float GetRange(); - virtual void SetTransparency(float value) = 0; + virtual void SetFixed(bool bFixed); + virtual bool GetFixed(); - virtual void SetFixed(bool bFixed) = 0; - virtual bool GetFixed() = 0; + virtual void SetClip(bool bClip); + virtual bool GetClip(); - virtual void SetClip(bool bClip) = 0; - virtual bool GetClip() = 0; + virtual void SetTeam(int team); + virtual int GetTeam(); - virtual void SetTeam(int team) = 0; - virtual int GetTeam() = 0; + virtual void StartDetectEffect(CObject *target, bool bFound); - virtual void StartDetectEffect(CObject *target, bool bFound) = 0; + virtual void SetVirusMode(bool bEnable); + virtual bool GetVirusMode(); + virtual float GetVirusTime(); - virtual void SetVirusMode(bool bEnable) = 0; - virtual bool GetVirusMode() = 0; - virtual float GetVirusTime() = 0; + virtual void SetCameraType(Gfx::CameraType type); + virtual Gfx::CameraType GetCameraType(); + virtual void SetCameraDist(float dist); + virtual float GetCameraDist(); + virtual void SetCameraLock(bool bLock); + virtual bool GetCameraLock(); - virtual void SetCameraType(Gfx::CameraType type) = 0; - virtual Gfx::CameraType GetCameraType() = 0; - virtual void SetCameraDist(float dist) = 0; - virtual float GetCameraDist() = 0; - virtual void SetCameraLock(bool bLock) = 0; - virtual bool GetCameraLock() = 0; + virtual void SetHighlight(bool mode); - virtual void SetHighlight(bool mode) = 0; + virtual void SetSelect(bool bMode, bool bDisplayError=true); + virtual bool GetSelect(bool bReal=false); - virtual void SetSelect(bool bMode, bool bDisplayError=true) = 0; - virtual bool GetSelect(bool bReal=false) = 0; + virtual void SetSelectable(bool bMode); + virtual bool GetSelectable(); - virtual void SetSelectable(bool bMode) = 0; - virtual bool GetSelectable() = 0; + virtual void SetActivity(bool bMode); + virtual bool GetActivity(); - virtual void SetActivity(bool bMode) = 0; - virtual bool GetActivity() = 0; + virtual void SetVisible(bool bVisible); - virtual void SetVisible(bool bVisible) = 0; + virtual void SetEnable(bool bEnable); + virtual bool GetEnable(); - virtual void SetEnable(bool bEnable) = 0; - virtual bool GetEnable() = 0; + virtual void SetCheckToken(bool bMode); + virtual bool GetCheckToken(); - virtual void SetCheckToken(bool bMode) = 0; - virtual bool GetCheckToken() = 0; + virtual void SetProxyActivate(bool bActivate); + virtual bool GetProxyActivate(); + virtual void SetProxyDistance(float distance); - virtual void SetProxyActivate(bool bActivate) = 0; - virtual bool GetProxyActivate() = 0; - virtual void SetProxyDistance(float distance) = 0; + virtual void SetMagnifyDamage(float factor); + virtual float GetMagnifyDamage(); - virtual void SetMagnifyDamage(float factor) = 0; - virtual float GetMagnifyDamage() = 0; + virtual void SetParam(float value); + virtual float GetParam(); + virtual void SetIgnoreBuildCheck(bool bIgnoreBuildCheck); + virtual bool GetIgnoreBuildCheck(); - virtual void SetParam(float value) = 0; - virtual float GetParam() = 0; - virtual void SetIgnoreBuildCheck(bool bIgnoreBuildCheck) = 0; - virtual bool GetIgnoreBuildCheck() = 0; + virtual void SetExploding(bool bExplo); + virtual bool IsExploding(); + virtual void SetLock(bool bLock); + virtual bool GetLock(); + virtual void SetSpaceshipCargo(bool bCargo); + virtual bool IsSpaceshipCargo(); + virtual void SetBurn(bool bBurn); + virtual bool GetBurn(); + virtual void SetDead(bool bDead); + virtual bool GetDead(); + virtual bool GetRuin(); + virtual bool GetActive(); - virtual void SetExploding(bool bExplo) = 0; - virtual bool IsExploding() = 0; - virtual void SetLock(bool bLock) = 0; - virtual bool GetLock() = 0; - virtual void SetSpaceshipCargo(bool bCargo) = 0; - virtual bool IsSpaceshipCargo() = 0; - virtual void SetBurn(bool bBurn) = 0; - virtual bool GetBurn() = 0; - virtual void SetDead(bool bDead) = 0; - virtual bool GetDead() = 0; - virtual bool GetRuin() = 0; - virtual bool GetActive() = 0; + virtual void SetGunGoalV(float gunGoal); + virtual void SetGunGoalH(float gunGoal); + virtual float GetGunGoalV(); + virtual float GetGunGoalH(); - virtual void SetGunGoalV(float gunGoal) = 0; - virtual void SetGunGoalH(float gunGoal) = 0; - virtual float GetGunGoalV() = 0; - virtual float GetGunGoalH() = 0; + virtual bool StartShowLimit(); + virtual void StopShowLimit(); - virtual bool StartShowLimit() = 0; - virtual void StopShowLimit() = 0; + virtual bool IsProgram(); + virtual void CreateSelectParticle(); - virtual bool IsProgram() = 0; - virtual void CreateSelectParticle() = 0; + virtual void SetRunScript(CScript* script); + virtual CScript* GetRunScript(); + virtual CBotVar* GetBotVar(); + virtual CPhysics* GetPhysics(); + virtual CMotion* GetMotion(); + virtual CAuto* GetAuto(); - virtual void SetRunScript(CScript* script) = 0; - virtual CScript* GetRunScript() = 0; - virtual CBotVar* GetBotVar() = 0; - virtual CPhysics* GetPhysics() = 0; - virtual CMotion* GetMotion() = 0; - virtual CAuto* GetAuto() = 0; + virtual void SetDefRank(int rank); + virtual int GetDefRank(); - virtual void SetDefRank(int rank) = 0; - virtual int GetDefRank() = 0; + virtual bool GetTooltipName(std::string& name); - virtual bool GetTooltipName(std::string& name) = 0; + virtual void AddDeselList(CObject* pObj); + virtual CObject* SubDeselList(); + virtual void DeleteDeselList(CObject* pObj); - virtual void AddDeselList(CObject* pObj) = 0; - virtual CObject* SubDeselList() = 0; - virtual void DeleteDeselList(CObject* pObj) = 0; + virtual bool CreateShadowCircle(float radius, float intensity, Gfx::EngineShadowType type = Gfx::ENG_SHADOW_NORM); + virtual bool CreateShadowLight(float height, Gfx::Color color); + virtual bool CreateEffectLight(float height, Gfx::Color color); - virtual bool CreateShadowCircle(float radius, float intensity, Gfx::EngineShadowType type = Gfx::ENG_SHADOW_NORM) = 0; - virtual bool CreateShadowLight(float height, Gfx::Color color) = 0; - virtual bool CreateEffectLight(float height, Gfx::Color color) = 0; + virtual void FlatParent(); - virtual void FlatParent() = 0; - - virtual void SetInfoReturn(float value) = 0; - virtual float GetInfoReturn() = 0; + virtual void SetInfoReturn(float value); + virtual float GetInfoReturn(); }; diff --git a/src/object/robotmain.cpp b/src/object/robotmain.cpp index 220f99c4..2ab63117 100644 --- a/src/object/robotmain.cpp +++ b/src/object/robotmain.cpp @@ -51,6 +51,7 @@ #include "graphics/engine/terrain.h" #include "graphics/engine/text.h" #include "graphics/engine/water.h" +#include "graphics/model/model_manager.h" #include "math/const.h" #include "math/geometry.h" @@ -133,7 +134,8 @@ CRobotMain::CRobotMain(CController* controller) m_sound = nullptr; m_engine = nullptr; - m_modelManager = nullptr; + m_oldModelManager = nullptr; + m_modelManager = std::unique_ptr(new Gfx::CModelManager()); m_lightMan = nullptr; m_particle = nullptr; m_water = nullptr; @@ -252,7 +254,7 @@ void CRobotMain::Create(bool loadProfile) m_sound = m_app->GetSound(); m_engine = Gfx::CEngine::GetInstancePointer(); - m_modelManager = m_engine->GetModelManager(); + m_oldModelManager = m_engine->GetModelManager(); m_lightMan = m_engine->GetLightManager(); m_particle = m_engine->GetParticle(); m_water = m_engine->GetWater(); @@ -274,7 +276,8 @@ void CRobotMain::Create(bool loadProfile) m_objMan = new CObjectManager(m_engine, m_terrain, - m_modelManager, + m_oldModelManager, + m_modelManager.get(), m_particle); m_engine->SetTerrain(m_terrain); @@ -473,7 +476,7 @@ void CRobotMain::ChangePhase(Phase phase) m_engine->SetRankView(0); m_terrain->FlushRelief(); m_engine->DeleteAllObjects(); - m_modelManager->DeleteAllModelCopies(); + m_oldModelManager->DeleteAllModelCopies(); m_engine->SetWaterAddColor(Gfx::Color(0.0f, 0.0f, 0.0f, 0.0f)); m_engine->SetBackground(""); m_engine->SetBackForce(false); @@ -2840,7 +2843,7 @@ void CRobotMain::ScenePerso() DeleteAllObjects(); // removes all the current 3D Scene m_terrain->FlushRelief(); m_engine->DeleteAllObjects(); - m_modelManager->DeleteAllModelCopies(); + m_oldModelManager->DeleteAllModelCopies(); m_terrain->FlushBuildingLevel(); m_terrain->FlushFlyingLimit(); m_lightMan->FlushLights(); @@ -3535,11 +3538,18 @@ void CRobotMain::CreateScene(bool soluce, bool fixScene, bool resetObject) if (m_phase == PHASE_LOST) motion->SetAction(MHS_LOST, 0.5f); } - if (obj != nullptr) + if (obj->Implements(ObjectInterfaceType::Old)) // TODO: temporary hack { - obj->SetDefRank(rankObj); + obj->SetDefRank(rankObj); // TODO: do we really need this? - if (type == OBJECT_BASE) m_base = obj; + if (type == OBJECT_BASE) + m_base = obj; + + if (line->GetParam("select")->AsBool(false)) + sel = obj; + + // TODO: everything below should go to CObject::Read() function + // In fact, we could give CLevelParserLine as parameter to CreateObject() in the first place Gfx::CameraType cType = line->GetParam("camera")->AsCameraType(Gfx::CAM_TYPE_NULL); if (cType != Gfx::CAM_TYPE_NULL) @@ -3570,11 +3580,6 @@ void CRobotMain::CreateScene(bool soluce, bool fixScene, bool resetObject) } } - if (line->GetParam("select")->AsBool(false)) - { - sel = obj; - } - bool selectable = line->GetParam("selectable")->AsBool(true); obj->SetSelectable(selectable); obj->SetIgnoreBuildCheck(line->GetParam("ignoreBuildCheck")->AsBool(false)); @@ -3597,14 +3602,17 @@ void CRobotMain::CreateScene(bool soluce, bool fixScene, bool resetObject) if (zoom.x != 0.0f || zoom.y != 0.0f || zoom.z != 0.0f) obj->SetZoom(0, zoom); - //TODO: I don't remember what this is used for - CMotion* motion = obj->GetMotion(); - if (motion != nullptr && line->GetParam("param")->IsDefined()) + // only used in AlienWorm lines + if (type == OBJECT_WORM) { - const auto& p = line->GetParam("param")->AsArray(); - for (unsigned int i = 0; i < 10 && i < p.size(); i++) + CMotion* motion = obj->GetMotion(); + if (motion != nullptr && line->GetParam("param")->IsDefined()) { - motion->SetParam(i, p[i]->AsFloat()); + const auto& p = line->GetParam("param")->AsArray(); + for (unsigned int i = 0; i < 10 && i < p.size(); i++) + { + motion->SetParam(i, p[i]->AsFloat()); + } } } @@ -3669,7 +3677,6 @@ void CRobotMain::CreateScene(bool soluce, bool fixScene, bool resetObject) obj->SetResetPosition(obj->GetPosition(0)); obj->SetResetAngle(obj->GetAngle(0)); obj->SetResetRun(loadedPrograms[run]); - if (line->GetParam("reset")->AsBool(false)) obj->SetResetCap(RESET_MOVE); } @@ -4855,7 +4862,6 @@ void CRobotMain::IOWriteObject(CLevelParserLine* line, CObject* obj) } line->AddParam("trainer", CLevelParserParamUPtr{new CLevelParserParam(obj->GetTrainer())}); - line->AddParam("ignoreBuildCheck", CLevelParserParamUPtr{new CLevelParserParam(obj->GetIgnoreBuildCheck())}); line->AddParam("option", CLevelParserParamUPtr{new CLevelParserParam(obj->GetOption())}); if (obj == m_infoObject) line->AddParam("select", CLevelParserParamUPtr{new CLevelParserParam(1)}); @@ -5033,7 +5039,6 @@ CObject* CRobotMain::IOReadObject(CLevelParserLine *line, const char* filename, obj->SetDefRank(objRank); obj->SetPosition(0, pos); obj->SetAngle(0, dir); - obj->SetIgnoreBuildCheck(line->GetParam("ignoreBuildCheck")->AsBool(false)); if (zoom.x != 0.0f || zoom.y != 0.0f || zoom.z != 0.0f) obj->SetZoom(0, zoom); diff --git a/src/object/robotmain.h b/src/object/robotmain.h index d62c0171..4b0ab91c 100644 --- a/src/object/robotmain.h +++ b/src/object/robotmain.h @@ -94,6 +94,7 @@ class CCloud; class CLightning; class CPlanet; class CTerrain; +class CModelManager; } namespace Ui { @@ -381,7 +382,8 @@ protected: Gfx::CCloud* m_cloud; Gfx::CLightning* m_lightning; Gfx::CPlanet* m_planet; - Gfx::COldModelManager* m_modelManager; + Gfx::COldModelManager* m_oldModelManager; + std::unique_ptr m_modelManager; Gfx::CLightManager* m_lightMan; Gfx::CTerrain* m_terrain; Gfx::CCamera* m_camera; diff --git a/src/object/subclass/static_object.cpp b/src/object/subclass/static_object.cpp new file mode 100644 index 00000000..67d6face --- /dev/null +++ b/src/object/subclass/static_object.cpp @@ -0,0 +1,141 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + +#include "object/subclass/static_object.h" + +#include "graphics/engine/terrain.h" +#include "graphics/model/model.h" +#include "graphics/model/model_io_exception.h" +#include "graphics/model/model_manager.h" + +#include "object/object_create_exception.h" + +#include "math/geometry.h" + + +const std::unordered_map CStaticObject::m_staticModelNames = +{ + { OBJECT_TREE0, "tree0" } +}; + + +CStaticObject::CStaticObject(int id, + ObjectType type, + const std::string& key, + const Math::Vector& position, + float angleY, + const Gfx::CModel& model, + Gfx::CEngine* engine) + : CObject(id, type) + , m_engine(engine) +{ + const Gfx::CModelMesh* mesh = model.GetMesh("main"); + assert(mesh != nullptr); + + Math::Matrix worldMatrix = ComputeWorldMatrix(position, angleY); + m_meshHandle = m_engine->AddStaticMesh(key, mesh, worldMatrix); + + if (model.HasShadowSpot()) + m_engine->AddStaticMeshShadowSpot(m_meshHandle, model.GetShadowSpot()); + + SetCrashSpheres(model.GetCrashSpheres()); + + if (model.HasCameraCollisionSphere()) + SetCameraCollisionSphere(model.GetCameraCollisionSphere()); +} + +CStaticObject::~CStaticObject() +{ + m_engine->DeleteStaticMesh(m_meshHandle); +} + +Math::Matrix CStaticObject::ComputeWorldMatrix(const Math::Vector& position, float angleY) +{ + Math::Matrix translationMatrix; + Math::LoadTranslationMatrix(translationMatrix, position); + + Math::Matrix rotationMatrix; + Math::LoadRotationZXYMatrix(rotationMatrix, Math::Vector(0.0f, angleY, 0.0f)); + + return Math::MultiplyMatrices(translationMatrix, rotationMatrix); +} + +void CStaticObject::Read(CLevelParserLine* line) +{ +} + +void CStaticObject::Write(CLevelParserLine* line) +{ +} + +void CStaticObject::TransformCrashSphere(Math::Sphere& crashSphere) +{ + Math::Matrix worldMatrix = m_engine->GetStaticMeshWorldMatrix(m_meshHandle); + Math::Transform(worldMatrix, crashSphere.pos); +} + +void CStaticObject::TransformCameraCollisionSphere(Math::Sphere& collisionSphere) +{ + Math::Matrix worldMatrix = m_engine->GetStaticMeshWorldMatrix(m_meshHandle); + Math::Transform(worldMatrix, collisionSphere.pos); +} + +void CStaticObject::SetTransparency(float value) +{ + m_engine->SetStaticMeshTransparency(m_meshHandle, value); +} + +bool CStaticObject::IsStaticObject(ObjectType type) +{ + return m_staticModelNames.count(type) > 0; +} + +CStaticObjectUPtr CStaticObject::Create(int id, + ObjectType type, + const Math::Vector& position, + float angleY, + float height, + Gfx::CEngine* engine, + Gfx::CModelManager* modelManager, + Gfx::CTerrain* terrain) +{ + auto it = m_staticModelNames.find(type); + if (it == m_staticModelNames.end()) + throw CObjectCreateException("Object type is not static object", type); + + std::string modelFile = it->second; + + Math::Vector adjustedPosition = position; + terrain->AdjustToFloor(adjustedPosition); + adjustedPosition.y += height; + + try + { + Gfx::CModel& model = modelManager->GetModel(modelFile); + + if (model.GetMeshCount() != 1 || model.GetMesh("main") == nullptr) + throw CObjectCreateException("Unexpected mesh configuration", type, modelFile); + + return CStaticObjectUPtr{new CStaticObject(id, type, modelFile, adjustedPosition, angleY, model, engine)}; + } + catch (const Gfx::CModelIOException& e) + { + throw CObjectCreateException(std::string("Error loading model file: ") + e.what(), type, modelFile); + } +} diff --git a/src/object/subclass/static_object.h b/src/object/subclass/static_object.h new file mode 100644 index 00000000..77b56359 --- /dev/null +++ b/src/object/subclass/static_object.h @@ -0,0 +1,78 @@ +/* + * This file is part of the Colobot: Gold Edition source code + * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam + * http://epsiteс.ch; http://colobot.info; http://github.com/colobot + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see http://gnu.org/licenses + */ + +#pragma once + +#include "object/object.h" + +#include + +namespace Gfx { +class CModelManager; +class CEngine; +class CModel; +} // namespace Gfx + +class CStaticObject; +using CStaticObjectUPtr = std::unique_ptr; + +class CStaticObject : public CObject +{ +protected: + CStaticObject(int id, + ObjectType type, + const std::string& key, + const Math::Vector& position, + float angleY, + const Gfx::CModel& model, + Gfx::CEngine* engine); + +public: + virtual ~CStaticObject(); + + void Read(CLevelParserLine* line) override; + void Write(CLevelParserLine* line) override; + + void SetTransparency(float value) override; + +public: + static bool IsStaticObject(ObjectType type); + + static CStaticObjectUPtr Create(int id, + ObjectType type, + const Math::Vector& position, + float angleY, + float height, + Gfx::CEngine* engine, + Gfx::CModelManager* modelManager, + Gfx::CTerrain* terrain); + +protected: + void TransformCrashSphere(Math::Sphere& crashSphere) override; + void TransformCameraCollisionSphere(Math::Sphere& collisionSphere) override; + +private: + static Math::Matrix ComputeWorldMatrix(const Math::Vector& position, + float angleY); + +private: + Gfx::CEngine* m_engine; + int m_meshHandle; + static const std::unordered_map m_staticModelNames; +}; diff --git a/src/sound/sound_type.cpp b/src/sound/sound_type.cpp index a0088496..8702343e 100644 --- a/src/sound/sound_type.cpp +++ b/src/sound/sound_type.cpp @@ -114,7 +114,7 @@ const std::unordered_map SOUND_STRINGS = } // anonymous namespace -SoundType StringToSound(const std::string& str) +SoundType ParseSoundType(const std::string& str) { auto it = SOUND_STRINGS.find(str); if (it == SOUND_STRINGS.end())