summaryrefslogtreecommitdiffstats
path: root/src/graphics
diff options
context:
space:
mode:
Diffstat (limited to 'src/graphics')
-rw-r--r--src/graphics/core/device.h60
-rw-r--r--src/graphics/core/vertex.h20
-rw-r--r--src/graphics/engine/engine.cpp2273
-rw-r--r--src/graphics/engine/engine.h361
-rw-r--r--src/graphics/engine/modelfile.cpp137
-rw-r--r--src/graphics/engine/modelfile.h27
-rw-r--r--src/graphics/engine/modelmanager.cpp213
-rw-r--r--src/graphics/engine/modelmanager.h97
-rw-r--r--src/graphics/engine/particle.cpp2
-rw-r--r--src/graphics/engine/terrain.cpp27
-rw-r--r--src/graphics/engine/terrain.h2
-rw-r--r--src/graphics/engine/test/CMakeLists.txt2
-rw-r--r--src/graphics/engine/test/modelfile_test.cpp12
-rw-r--r--src/graphics/engine/text.cpp10
-rw-r--r--src/graphics/engine/water.cpp6
-rw-r--r--src/graphics/opengl/gldevice.cpp543
-rw-r--r--src/graphics/opengl/gldevice.h43
-rw-r--r--src/graphics/opengl/test/CMakeLists.txt1
-rw-r--r--src/graphics/opengl/test/light_test.cpp27
-rw-r--r--src/graphics/opengl/test/texture_test.cpp1
20 files changed, 2436 insertions, 1428 deletions
diff --git a/src/graphics/core/device.h b/src/graphics/core/device.h
index b6dd138..41d7796 100644
--- a/src/graphics/core/device.h
+++ b/src/graphics/core/device.h
@@ -104,8 +104,7 @@ enum RenderState
RENDER_STATE_DEPTH_TEST,
RENDER_STATE_DEPTH_WRITE,
RENDER_STATE_ALPHA_TEST,
- RENDER_STATE_CULLING,
- RENDER_STATE_DITHERING
+ RENDER_STATE_CULLING
};
/**
@@ -204,22 +203,22 @@ enum PrimitiveType
};
/**
- * \enum IntersectPlane
- * \brief Intersection plane of projection volume
+ * \enum FrustumPlane
+ * \brief Planes of frustum space
*
- * These flags can be OR'd together.
+ * Bitset of flags - can be OR'd together.
*/
-enum IntersectPlane
+enum FrustumPlane
{
- INTERSECT_PLANE_LEFT = 0x01,
- INTERSECT_PLANE_RIGHT = 0x02,
- INTERSECT_PLANE_TOP = 0x04,
- INTERSECT_PLANE_BOTTOM = 0x08,
- INTERSECT_PLANE_FRONT = 0x10,
- INTERSECT_PLANE_BACK = 0x20,
- INTERSECT_PLANE_ALL = INTERSECT_PLANE_LEFT | INTERSECT_PLANE_RIGHT |
- INTERSECT_PLANE_TOP | INTERSECT_PLANE_BOTTOM |
- INTERSECT_PLANE_FRONT | INTERSECT_PLANE_BACK
+ FRUSTUM_PLANE_LEFT = 0x01,
+ FRUSTUM_PLANE_RIGHT = 0x02,
+ FRUSTUM_PLANE_TOP = 0x04,
+ FRUSTUM_PLANE_BOTTOM = 0x08,
+ FRUSTUM_PLANE_FRONT = 0x10,
+ FRUSTUM_PLANE_BACK = 0x20,
+ FRUSTUM_PLANE_ALL = FRUSTUM_PLANE_LEFT | FRUSTUM_PLANE_RIGHT |
+ FRUSTUM_PLANE_TOP | FRUSTUM_PLANE_BOTTOM |
+ FRUSTUM_PLANE_FRONT | FRUSTUM_PLANE_BACK
};
/**
@@ -287,7 +286,7 @@ public:
virtual void DestroyAllTextures() = 0;
//! Returns the maximum number of multitexture stages
- virtual int GetMaxTextureCount() = 0;
+ virtual int GetMaxTextureStageCount() = 0;
//! Sets the texture at given texture stage
virtual void SetTexture(int index, const Texture &texture) = 0;
//! Sets the texture image by ID at given texture stage
@@ -313,10 +312,35 @@ public:
//! Renders primitive composed of vertices with multitexturing (2 textures)
virtual void DrawPrimitive(PrimitiveType type, const VertexTex2 *vertices, int vertexCount,
Color color = Color(1.0f, 1.0f, 1.0f, 1.0f)) = 0;
- //! Renders primitive composed of vertices with color information
+ //! Renders primitive composed of vertices with solid color
virtual void DrawPrimitive(PrimitiveType type, const VertexCol *vertices , int vertexCount) = 0;
- //! Tests whether a sphere intersects the 6 clipping planes of projection volume
+ //! Creates a static buffer composed of given primitives with single texture vertices
+ virtual unsigned int CreateStaticBuffer(PrimitiveType primitiveType, const Vertex* vertices, int vertexCount) = 0;
+
+ //! Creates a static buffer composed of given primitives with multitexturing
+ virtual unsigned int CreateStaticBuffer(PrimitiveType primitiveType, const VertexTex2* vertices, int vertexCount) = 0;
+
+ //! Creates a static buffer composed of given primitives with solid color
+ virtual unsigned int CreateStaticBuffer(PrimitiveType primitiveType, const VertexCol* vertices, int vertexCount) = 0;
+
+ //! Updates the static buffer composed of given primitives with single texture vertices
+ virtual void UpdateStaticBuffer(unsigned int bufferId, PrimitiveType primitiveType, const Vertex* vertices, int vertexCount) = 0;
+
+ //! Updates the static buffer composed of given primitives with multitexturing
+ virtual void UpdateStaticBuffer(unsigned int bufferId, PrimitiveType primitiveType, const VertexTex2* vertices, int vertexCount) = 0;
+
+ //! Updates the static buffer composed of given primitives with solid color
+ virtual void UpdateStaticBuffer(unsigned int bufferId, PrimitiveType primitiveType, const VertexCol* vertices, int vertexCount) = 0;
+
+ //! Draws a static buffer
+ virtual void DrawStaticBuffer(unsigned int bufferId) = 0;
+
+ //! Deletes a static buffer
+ virtual void DestroyStaticBuffer(unsigned int bufferId) = 0;
+
+ //! Tests whether a sphere is (partially) within the frustum volume
+ //! Returns a mask of frustum planes for which the test is positive
virtual int ComputeSphereVisibility(const Math::Vector &center, float radius) = 0;
//! Enables/disables the given render state
diff --git a/src/graphics/core/vertex.h b/src/graphics/core/vertex.h
index 2ee6be4..66e1503 100644
--- a/src/graphics/core/vertex.h
+++ b/src/graphics/core/vertex.h
@@ -44,23 +44,18 @@ namespace Gfx {
* - vertex coordinates (x,y,z) as Math::Vector,
* - normal coordinates (nx,ny,nz) as Math::Vector
* - texture coordinates (u,v) as Math::Point.
- *
- * Additional padding is provided to align to even multiplies of 4 floats for faster access.
*/
struct Vertex
{
Math::Vector coord;
- float pad1;
Math::Vector normal;
- float pad2;
Math::Point texCoord;
- float pad3, pad4;
explicit Vertex(Math::Vector aCoord = Math::Vector(),
Math::Vector aNormal = Math::Vector(),
Math::Point aTexCoord = Math::Point())
- : coord(aCoord), pad1(0.0f), normal(aNormal),
- pad2(0.0f),texCoord(aTexCoord), pad3(0.0f), pad4(0.0f) {}
+ : coord(aCoord), normal(aNormal),
+ texCoord(aTexCoord) {}
//! Returns a string "(c: [...], n: [...], tc: [...])"
@@ -81,18 +76,15 @@ struct Vertex
* It contains:
* - vertex coordinates (x,y,z) as Math::Vector,
* - RGBA color as Color
- *
- * Additional padding is provided to align to even multiplies of 4 floats for faster access.
*/
struct VertexCol
{
Math::Vector coord;
- float pad;
Color color;
explicit VertexCol(Math::Vector aCoord = Math::Vector(),
Color aColor = Color())
- : coord(aCoord), pad(0.0f), color(aColor) {}
+ : coord(aCoord), color(aColor) {}
//! Returns a string "(c: [...], col: [...])"
inline std::string ToString() const
@@ -111,15 +103,11 @@ struct VertexCol
*
* In addition to fields from Vector, it contains
* secondary texture coordinates (u2, v2) as Math::Point
- *
- * Additional padding is provided to align to even multiplies of 4 floats for faster access.
*/
struct VertexTex2
{
Math::Vector coord;
- float pad1;
Math::Vector normal;
- float pad2;
Math::Point texCoord;
Math::Point texCoord2;
@@ -127,7 +115,7 @@ struct VertexTex2
Math::Vector aNormal = Math::Vector(),
Math::Point aTexCoord = Math::Point(),
Math::Point aTexCoord2 = Math::Point())
- : coord(aCoord), pad1(0.0f), normal(aNormal), pad2(0.0f),
+ : coord(aCoord), normal(aNormal),
texCoord(aTexCoord), texCoord2(aTexCoord2) {}
//! Sets the fields from Vertex with texCoord2 = (0,0)
diff --git a/src/graphics/engine/engine.cpp b/src/graphics/engine/engine.cpp
index 3365b24..7c90a8d 100644
--- a/src/graphics/engine/engine.cpp
+++ b/src/graphics/engine/engine.cpp
@@ -47,55 +47,6 @@
// Graphics module namespace
namespace Gfx {
-
-// Initial size of various vectors
-const int OBJECT_PREALLOCATE_COUNT = 1200;
-const int SHADOW_PREALLOCATE_COUNT = 500;
-const int GROUNDSPOT_PREALLOCATE_COUNT = 100;
-
-const int LEVEL1_PREALLOCATE_COUNT = 50;
-const int LEVEL2_PREALLOCATE_COUNT = 100;
-const int LEVEL3_PREALLOCATE_COUNT = 5;
-const int LEVEL4_PREALLOCATE_COUNT = 100;
-const int LEVEL4_VERTEX_PREALLOCATE_COUNT = 200;
-
-
-EngineObjLevel1::EngineObjLevel1(bool used, const std::string& tex1Name, const std::string& tex2Name)
-{
- this->used = used;
- this->tex1Name = tex1Name;
- this->tex2Name = tex2Name;
-
- next.reserve(LEVEL2_PREALLOCATE_COUNT);
-}
-
-EngineObjLevel2::EngineObjLevel2(bool used, int objRank)
-{
- this->used = used;
- this->objRank = objRank;
-
- next.reserve(LEVEL3_PREALLOCATE_COUNT);
-}
-
-EngineObjLevel3::EngineObjLevel3(bool used, float min, float max)
-{
- this->used = used;
- this->min = min;
- this->max = max;
-
- next.reserve(LEVEL4_PREALLOCATE_COUNT);
-}
-
-EngineObjLevel4::EngineObjLevel4(bool used, EngineTriangleType type, const Material& material, int state)
-{
- this->used = used;
- this->type = type;
- this->material = material;
- this->state = state;
-
- vertices.reserve(LEVEL4_VERTEX_PREALLOCATE_COUNT);
-}
-
CEngine::CEngine(CInstanceManager *iMan, CApplication *app)
{
m_iMan = iMan;
@@ -182,6 +133,7 @@ CEngine::CEngine(CInstanceManager *iMan, CApplication *app)
m_alphaMode = 1;
m_updateGeometry = false;
+ m_updateStaticBuffers = false;
m_interfaceMode = false;
@@ -218,11 +170,6 @@ CEngine::CEngine(CInstanceManager *iMan, CApplication *app)
m_terrainTexParams.mipmap = false;
m_terrainTexParams.minFilter = TEX_MIN_FILTER_LINEAR;
m_terrainTexParams.magFilter = TEX_MAG_FILTER_LINEAR;
-
- m_objectTree.reserve(LEVEL1_PREALLOCATE_COUNT);
- m_objects.reserve(OBJECT_PREALLOCATE_COUNT);
- m_shadows.reserve(SHADOW_PREALLOCATE_COUNT);
- m_groundSpots.reserve(GROUNDSPOT_PREALLOCATE_COUNT);
}
CEngine::~CEngine()
@@ -334,6 +281,8 @@ void CEngine::Destroy()
void CEngine::ResetAfterDeviceChanged()
{
+ m_size = m_app->GetVideoConfig().size;;
+
m_text->FlushCache();
// TODO reload textures, reset device state, etc.
@@ -378,9 +327,14 @@ void CEngine::FrameUpdate()
float rTime = m_app->GetRelTime();
m_lightMan->UpdateProgression(rTime);
+
+ m_app->StartPerformanceCounter(PCNT_UPDATE_PARTICLE);
m_particle->FrameParticle(rTime);
+ m_app->StopPerformanceCounter(PCNT_UPDATE_PARTICLE);
+
ComputeDistance();
UpdateGeometry();
+ UpdateStaticBuffers();
m_highlightTime = m_app->GetAbsTime();
@@ -409,7 +363,7 @@ void CEngine::FrameUpdate()
{
m_groundMark.intensity = 0.0f;
m_groundMark.phase = ENG_GR_MARK_PHASE_NULL;
- m_groundMark.draw = false;
+ m_groundMark.draw = false;
}
}
}
@@ -422,18 +376,6 @@ bool CEngine::WriteScreenShot(const std::string& fileName, int width, int height
return true;
}
-bool CEngine::ReadSettings()
-{
- // TODO: when INI reading is completed
- return true;
-}
-
-bool CEngine::WriteSettings()
-{
- // TODO: when INI writing is completed
- return true;
-}
-
void CEngine::SetPause(bool pause)
{
m_pause = pause;
@@ -500,7 +442,7 @@ Math::Point CEngine::WindowToInterfaceSize(Math::IntPoint size)
Math::IntPoint CEngine::InterfaceToWindowSize(Math::Point size)
{
return Math::IntPoint(static_cast<int>(size.x * m_size.x),
- static_cast<int>(size.y * m_size.y));
+ static_cast<int>(size.y * m_size.y));
}
void CEngine::AddStatisticTriangle(int count)
@@ -519,480 +461,377 @@ int CEngine::GetStatisticTriangle()
Object management
*******************************************************/
+EngineBaseObjTexTier& CEngine::AddLevel2(EngineBaseObject& p1, const std::string& tex1Name, const std::string& tex2Name)
+{
+ for (int i = 0; i < static_cast<int>( p1.next.size() ); i++)
+ {
+ if (p1.next[i].tex1Name == tex1Name && p1.next[i].tex2Name == tex2Name)
+ return p1.next[i];
+ }
+ p1.next.push_back(EngineBaseObjTexTier(tex1Name, tex2Name));
+ return p1.next.back();
+}
-int CEngine::CreateObject()
+EngineBaseObjLODTier& CEngine::AddLevel3(EngineBaseObjTexTier& p2, float min, float max)
{
- int i = 0;
- for ( ; i < static_cast<int>( m_objects.size() ); i++)
+ for (int i = 0; i < static_cast<int>( p2.next.size() ); i++)
{
- if (! m_objects[i].used)
+ if ( (p2.next[i].min == min) && (p2.next[i].max == max) )
+ return p2.next[i];
+ }
+
+ p2.next.push_back(EngineBaseObjLODTier(min, max));
+ return p2.next.back();
+}
+
+EngineBaseObjDataTier& CEngine::AddLevel4(EngineBaseObjLODTier& p3, EngineTriangleType type,
+ const Material& material, int state)
+{
+ for (int i = 0; i < static_cast<int>( p3.next.size() ); i++)
+ {
+ if ( (p3.next[i].type == type) && (p3.next[i].material == material) && (p3.next[i].state == state) )
+ return p3.next[i];
+ }
+
+ p3.next.push_back(EngineBaseObjDataTier(type, material, state));
+ return p3.next.back();
+}
+
+int CEngine::CreateBaseObject()
+{
+ int baseObjRank = 0;
+ for ( ; baseObjRank < static_cast<int>( m_baseObjects.size() ); baseObjRank++)
+ {
+ if (! m_baseObjects[baseObjRank].used)
{
- m_objects[i].LoadDefault();
+ m_baseObjects[baseObjRank].LoadDefault();
break;
}
}
- if (i == static_cast<int>( m_objects.size() ))
- m_objects.push_back(EngineObject());
-
+ if (baseObjRank == static_cast<int>( m_baseObjects.size() ))
+ m_baseObjects.push_back(EngineBaseObject());
+ else
+ m_baseObjects[baseObjRank].LoadDefault();
- m_objects[i].used = true;
- Math::Matrix mat;
- mat.LoadIdentity();
- SetObjectTransform(i, mat);
+ m_baseObjects[baseObjRank].used = true;
- m_objects[i].drawWorld = true;
- m_objects[i].distance = 0.0f;
- m_objects[i].bboxMin = Math::Vector(0.0f, 0.0f, 0.0f);
- m_objects[i].bboxMax = Math::Vector(0.0f, 0.0f, 0.0f);
- m_objects[i].shadowRank = -1;
-
- return i;
+ return baseObjRank;
}
-void CEngine::FlushObject()
+void CEngine::DeleteBaseObject(int baseObjRank)
{
- m_objectTree.clear();
- m_objects.clear();
+ assert(baseObjRank >= 0 && baseObjRank < static_cast<int>( m_baseObjects.size() ));
- m_shadows.clear();
+ EngineBaseObject& p1 = m_baseObjects[baseObjRank];
- FlushGroundSpot();
-}
-
-bool CEngine::DeleteObject(int objRank)
-{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return false;
+ if (! p1.used)
+ return;
- // Delete object's triangles
- for (int l1 = 0; l1 < static_cast<int>( m_objectTree.size() ); l1++)
+ for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
{
- EngineObjLevel1& p1 = m_objectTree[l1];
- if (! p1.used) continue;
+ EngineBaseObjTexTier& p2 = p1.next[l2];
- for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
+ for (int l3 = 0; l3 < static_cast<int>( p2.next.size() ); l3++)
{
- EngineObjLevel2& p2 = p1.next[l2];
- if (! p2.used) continue;
+ EngineBaseObjLODTier& p3 = p2.next[l3];
- if (p2.objRank == objRank)
+ for (int l4 = 0; l4 < static_cast<int>( p3.next.size() ); l4++)
{
- p2.used = false;
- p2.next.clear();
+ EngineBaseObjDataTier& p4 = p3.next[l4];
+
+ m_device->DestroyStaticBuffer(p4.staticBufferId);
+ p4.staticBufferId = 0;
}
}
}
- // Mark object as deleted
- m_objects[objRank].used = false;
+ p1.next.clear();
- // Delete associated shadows
- DeleteShadow(objRank);
-
- return true;
+ p1.used = false;
}
-bool CEngine::SetObjectType(int objRank, EngineObjectType type)
+void CEngine::DeleteAllBaseObjects()
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return false;
-
- m_objects[objRank].type = type;
- return true;
-}
-
-EngineObjectType CEngine::GetObjectType(int objRank)
-{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return ENG_OBJTYPE_NULL;
-
- return m_objects[objRank].type;
+ m_baseObjects.clear();
}
-
-bool CEngine::SetObjectTransform(int objRank, const Math::Matrix& transform)
+void CEngine::CopyBaseObject(int sourceBaseObjRank, int destBaseObjRank)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return false;
+ assert(sourceBaseObjRank >= 0 && sourceBaseObjRank < static_cast<int>( m_baseObjects.size() ));
+ assert(destBaseObjRank >= 0 && destBaseObjRank < static_cast<int>( m_baseObjects.size() ));
- m_objects[objRank].transform = transform;
- return true;
+ m_baseObjects[destBaseObjRank] = m_baseObjects[sourceBaseObjRank];
}
-bool CEngine::GetObjectTransform(int objRank, Math::Matrix& transform)
+void CEngine::AddBaseObjTriangles(int baseObjRank, const std::vector<VertexTex2>& vertices,
+ EngineTriangleType triangleType,
+ const Material& material, int state,
+ std::string tex1Name, std::string tex2Name,
+ float min, float max, bool globalUpdate)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return false;
+ assert(baseObjRank >= 0 && baseObjRank < static_cast<int>( m_baseObjects.size() ));
- transform = m_objects[objRank].transform;
- return true;
-}
+ m_lastSize = m_size;
+ m_lastObjectDetail = m_objectDetail;
+ m_lastClippingDistance = m_clippingDistance;
-bool CEngine::SetObjectDrawWorld(int objRank, bool draw)
-{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return false;
+ EngineBaseObject& p1 = m_baseObjects[baseObjRank];
+ EngineBaseObjTexTier& p2 = AddLevel2(p1, tex1Name, tex2Name);
+ EngineBaseObjLODTier& p3 = AddLevel3(p2, min, max);
+ EngineBaseObjDataTier& p4 = AddLevel4(p3, triangleType, material, state);
- m_objects[objRank].drawWorld = draw;
- return true;
-}
+ p4.vertices.insert(p4.vertices.end(), vertices.begin(), vertices.end());
-bool CEngine::SetObjectDrawFront(int objRank, bool draw)
-{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return false;
+ p4.updateStaticBuffer = true;
+ m_updateStaticBuffers = true;
- m_objects[objRank].drawFront = draw;
- return true;
-}
+ if (globalUpdate)
+ {
+ m_updateGeometry = true;
+ }
+ else
+ {
+ for (int i = 0; i < static_cast<int>( 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);
+ }
-bool CEngine::SetObjectTransparency(int objRank, float value)
-{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return false;
+ p1.radius = Math::Max(p1.bboxMin.Length(), p1.bboxMax.Length());
+ }
- m_objects[objRank].transparency = value;
- return true;
+ if (triangleType == ENG_TRIANGLE_TYPE_TRIANGLES)
+ p1.totalTriangles += vertices.size() / 3;
+ else
+ p1.totalTriangles += vertices.size() - 2;
}
-bool CEngine::GetObjectBBox(int objRank, Math::Vector& min, Math::Vector& max)
+void CEngine::AddBaseObjQuick(int baseObjRank, const EngineBaseObjDataTier& buffer,
+ std::string tex1Name, std::string tex2Name,
+ float min, float max, bool globalUpdate)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return 0;
+ assert(baseObjRank >= 0 && baseObjRank < static_cast<int>( m_baseObjects.size() ));
- min = m_objects[objRank].bboxMin;
- max = m_objects[objRank].bboxMax;
- return true;
-}
+ EngineBaseObject& p1 = m_baseObjects[baseObjRank];
+ EngineBaseObjTexTier& p2 = AddLevel2(p1, tex1Name, tex2Name);
+ EngineBaseObjLODTier& p3 = AddLevel3(p2, min, max);
+ p3.next.push_back(buffer);
-int CEngine::GetObjectTotalTriangles(int objRank)
-{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return 0;
+ EngineBaseObjDataTier& p4 = p3.next.back();
- return m_objects[objRank].totalTriangles;
-}
+ UpdateStaticBuffer(p4);
-
-EngineObjLevel1& CEngine::AddLevel1(const std::string& tex1Name, const std::string& tex2Name)
-{
- bool unusedPresent = false;
- for (int i = 0; i < static_cast<int>( m_objectTree.size() ); i++)
+ if (globalUpdate)
{
- if (! m_objectTree[i].used)
- {
- unusedPresent = true;
- continue;
- }
-
- if (m_objectTree[i].tex1Name == tex1Name && m_objectTree[i].tex2Name == tex2Name)
- return m_objectTree[i];
+ m_updateGeometry = true;
}
-
- if (unusedPresent)
+ else
{
- for (int i = 0; i < static_cast<int>( m_objectTree.size() ); i++)
+ for (int i = 0; i < static_cast<int>( p4.vertices.size() ); i++)
{
- if (! m_objectTree[i].used)
- {
- m_objectTree[i].used = true;
- m_objectTree[i].tex1Name = tex1Name;
- m_objectTree[i].tex2Name = tex2Name;
- return m_objectTree[i];
- }
+ p1.bboxMin.x = Math::Min(p4.vertices[i].coord.x, p1.bboxMin.x);
+ p1.bboxMin.y = Math::Min(p4.vertices[i].coord.y, p1.bboxMin.y);
+ p1.bboxMin.z = Math::Min(p4.vertices[i].coord.z, p1.bboxMin.z);
+ p1.bboxMax.x = Math::Max(p4.vertices[i].coord.x, p1.bboxMax.x);
+ p1.bboxMax.y = Math::Max(p4.vertices[i].coord.y, p1.bboxMax.y);
+ p1.bboxMax.z = Math::Max(p4.vertices[i].coord.z, p1.bboxMax.z);
}
+
+ p1.radius = Math::Max(p1.bboxMin.Length(), p1.bboxMax.Length());
}
- m_objectTree.push_back(EngineObjLevel1(true, tex1Name, tex2Name));
- return m_objectTree.back();
+ if (p4.type == ENG_TRIANGLE_TYPE_TRIANGLES)
+ p1.totalTriangles += p4.vertices.size() / 3;
+ else if (p4.type == ENG_TRIANGLE_TYPE_SURFACE)
+ p1.totalTriangles += p4.vertices.size() - 2;
}
-EngineObjLevel2& CEngine::AddLevel2(EngineObjLevel1& p1, int objRank)
+
+int CEngine::CreateObject()
{
- bool unusedPresent = false;
- for (int i = 0; i < static_cast<int>( p1.next.size() ); i++)
+ int objRank = 0;
+ for ( ; objRank < static_cast<int>( m_objects.size() ); objRank++)
{
- if (! p1.next[i].used)
+ if (! m_objects[objRank].used)
{
- unusedPresent = true;
- continue;
+ m_objects[objRank].LoadDefault();
+ break;
}
-
- if (p1.next[i].objRank == objRank)
- return p1.next[i];
}
- if (unusedPresent)
- {
- for (int i = 0; i < static_cast<int>( p1.next.size() ); i++)
- {
- if (! p1.next[i].used)
- {
- p1.next[i].used = true;
- p1.next[i].objRank = objRank;
- return p1.next[i];
- }
- }
- }
+ if (objRank == static_cast<int>( m_objects.size() ))
+ m_objects.push_back(EngineObject());
- p1.next.push_back(EngineObjLevel2(true, objRank));
- return p1.next.back();
+
+ m_objects[objRank].used = true;
+
+ Math::Matrix mat;
+ mat.LoadIdentity();
+ SetObjectTransform(objRank, mat);
+
+ m_objects[objRank].drawWorld = true;
+ m_objects[objRank].distance = 0.0f;
+ m_objects[objRank].shadowRank = -1;
+
+ return objRank;
}
-EngineObjLevel3& CEngine::AddLevel3(EngineObjLevel2& p2, float min, float max)
+void CEngine::DeleteAllObjects()
{
- bool unusedPresent = false;
- for (int i = 0; i < static_cast<int>( p2.next.size() ); i++)
- {
- if (! p2.next[i].used)
- {
- unusedPresent = true;
- continue;
- }
+ m_objects.clear();
+ m_shadows.clear();
- if ( (p2.next[i].min == min) && (p2.next[i].max == max) )
- return p2.next[i];
- }
+ DeleteAllGroundSpots();
+}
- if (unusedPresent)
- {
- for (int i = 0; i < static_cast<int>( p2.next.size() ); i++)
- {
- if (! p2.next[i].used)
- {
- p2.next[i].used = true;
- p2.next[i].min = min;
- p2.next[i].max = max;
- return p2.next[i];
- }
- }
- }
+void CEngine::DeleteObject(int objRank)
+{
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- p2.next.push_back(EngineObjLevel3(true, min, max));
- return p2.next.back();
+ // Mark object as deleted
+ m_objects[objRank].used = false;
+
+ // Delete associated shadows
+ DeleteShadow(objRank);
}
-EngineObjLevel4& CEngine::AddLevel4(EngineObjLevel3& p3, EngineTriangleType type,
- const Material& material, int state)
+void CEngine::SetObjectBaseRank(int objRank, int baseObjRank)
{
- bool unusedPresent = false;
- for (int i = 0; i < static_cast<int>( p3.next.size() ); i++)
- {
- if (! p3.next[i].used)
- {
- unusedPresent = true;
- continue;
- }
+ assert(objRank == -1 || (objRank >= 0 && objRank < static_cast<int>( m_objects.size() )));
- if ( (p3.next[i].type == type) && (p3.next[i].material == material) && (p3.next[i].state == state) )
- return p3.next[i];
- }
+ m_objects[objRank].baseObjRank = baseObjRank;
+}
- if (unusedPresent)
- {
- for (int i = 0; i < static_cast<int>( p3.next.size() ); i++)
- {
- if (! p3.next[i].used)
- {
- p3.next[i].used = true;
- p3.next[i].type = type;
- p3.next[i].material = material;
- p3.next[i].state = state;
- return p3.next[i];
- }
- }
- }
+int CEngine::GetObjectBaseRank(int objRank)
+{
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- p3.next.push_back(EngineObjLevel4(true, type, material, state));
- return p3.next.back();
+ return m_objects[objRank].baseObjRank;
}
-bool CEngine::AddTriangles(int objRank, const std::vector<VertexTex2>& vertices,
- const Material& material, int state,
- std::string tex1Name, std::string tex2Name,
- float min, float max, bool globalUpdate)
+void CEngine::SetObjectType(int objRank, EngineObjectType type)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- {
- GetLogger()->Error("AddTriangle(): invalid object rank %d\n", objRank);
- return false;
- }
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- m_lastSize = m_size;
- m_lastObjectDetail = m_objectDetail;
- m_lastClippingDistance = m_clippingDistance;
+ m_objects[objRank].type = type;
+}
- EngineObjLevel1& p1 = AddLevel1(tex1Name, tex2Name);
- EngineObjLevel2& p2 = AddLevel2(p1, objRank);
- EngineObjLevel3& p3 = AddLevel3(p2, min, max);
- EngineObjLevel4& p4 = AddLevel4(p3, ENG_TRIANGLE_TYPE_TRIANGLES, material, state);
+EngineObjectType CEngine::GetObjectType(int objRank)
+{
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- p4.vertices.insert(p4.vertices.end(), vertices.begin(), vertices.end());
+ return m_objects[objRank].type;
+}
- if (globalUpdate)
- {
- m_updateGeometry = true;
- }
- else
- {
- for (int i = 0; i < static_cast<int>( vertices.size() ); i++)
- {
- m_objects[objRank].bboxMin.x = Math::Min(vertices[i].coord.x, m_objects[objRank].bboxMin.x);
- m_objects[objRank].bboxMin.y = Math::Min(vertices[i].coord.y, m_objects[objRank].bboxMin.y);
- m_objects[objRank].bboxMin.z = Math::Min(vertices[i].coord.z, m_objects[objRank].bboxMin.z);
- m_objects[objRank].bboxMax.x = Math::Max(vertices[i].coord.x, m_objects[objRank].bboxMax.x);
- m_objects[objRank].bboxMax.y = Math::Max(vertices[i].coord.y, m_objects[objRank].bboxMax.y);
- m_objects[objRank].bboxMax.z = Math::Max(vertices[i].coord.z, m_objects[objRank].bboxMax.z);
- }
- m_objects[objRank].radius = Math::Max(m_objects[objRank].bboxMin.Length(),
- m_objects[objRank].bboxMax.Length());
- }
-
- m_objects[objRank].totalTriangles += vertices.size() / 3;
+void CEngine::SetObjectTransform(int objRank, const Math::Matrix& transform)
+{
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- return true;
+ m_objects[objRank].transform = transform;
}
-bool CEngine::AddSurface(int objRank, const std::vector<VertexTex2>& vertices,
- const Material& material, int state,
- std::string tex1Name, std::string tex2Name,
- float min, float max, bool globalUpdate)
+void CEngine::GetObjectTransform(int objRank, Math::Matrix& transform)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- {
- GetLogger()->Error("AddSurface(): invalid object rank %d\n", objRank);
- return false;
- }
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- m_lastSize = m_size;
- m_lastObjectDetail = m_objectDetail;
- m_lastClippingDistance = m_clippingDistance;
+ transform = m_objects[objRank].transform;
+}
- EngineObjLevel1& p1 = AddLevel1(tex1Name, tex2Name);
- EngineObjLevel2& p2 = AddLevel2(p1, objRank);
- EngineObjLevel3& p3 = AddLevel3(p2, min, max);
- EngineObjLevel4& p4 = AddLevel4(p3, ENG_TRIANGLE_TYPE_SURFACE, material, state);
+void CEngine::SetObjectDrawWorld(int objRank, bool draw)
+{
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- p4.vertices.insert(p4.vertices.end(), vertices.begin(), vertices.end());
+ m_objects[objRank].drawWorld = draw;
+}
- if (globalUpdate)
- {
- m_updateGeometry = true;
- }
- else
- {
- for (int i = 0; i < static_cast<int>( vertices.size() ); i++)
- {
- m_objects[objRank].bboxMin.x = Math::Min(vertices[i].coord.x, m_objects[objRank].bboxMin.x);
- m_objects[objRank].bboxMin.y = Math::Min(vertices[i].coord.y, m_objects[objRank].bboxMin.y);
- m_objects[objRank].bboxMin.z = Math::Min(vertices[i].coord.z, m_objects[objRank].bboxMin.z);
- m_objects[objRank].bboxMax.x = Math::Max(vertices[i].coord.x, m_objects[objRank].bboxMax.x);
- m_objects[objRank].bboxMax.y = Math::Max(vertices[i].coord.y, m_objects[objRank].bboxMax.y);
- m_objects[objRank].bboxMax.z = Math::Max(vertices[i].coord.z, m_objects[objRank].bboxMax.z);
- }
+void CEngine::SetObjectDrawFront(int objRank, bool draw)
+{
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- m_objects[objRank].radius = Math::Max(m_objects[objRank].bboxMin.Length(),
- m_objects[objRank].bboxMax.Length());
- }
+ m_objects[objRank].drawFront = draw;
+}
- m_objects[objRank].totalTriangles += vertices.size() - 2;
+void CEngine::SetObjectTransparency(int objRank, float value)
+{
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- return true;
+ m_objects[objRank].transparency = value;
}
-bool CEngine::AddQuick(int objRank, const EngineObjLevel4& buffer,
- std::string tex1Name, std::string tex2Name,
- float min, float max, bool globalUpdate)
+void CEngine::GetObjectBBox(int objRank, Math::Vector& min, Math::Vector& max)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- {
- GetLogger()->Error("AddQuick(): invalid object rank %d\n", objRank);
- return false;
- }
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- EngineObjLevel1& p1 = AddLevel1(tex1Name, tex2Name);
- EngineObjLevel2& p2 = AddLevel2(p1, objRank);
- EngineObjLevel3& p3 = AddLevel3(p2, min, max);
+ int baseObjRank = m_objects[objRank].baseObjRank;
+ if (baseObjRank == -1)
+ return;
- p3.next.push_back(buffer);
- p3.next.back().used = true; // ensure that it is used
+ assert(baseObjRank >= 0 && baseObjRank < static_cast<int>(m_baseObjects.size()));
- if (globalUpdate)
- {
- m_updateGeometry = true;
- }
- else
- {
- for (int i = 0; i < static_cast<int>( buffer.vertices.size() ); i++)
- {
- m_objects[objRank].bboxMin.x = Math::Min(buffer.vertices[i].coord.x, m_objects[objRank].bboxMin.x);
- m_objects[objRank].bboxMin.y = Math::Min(buffer.vertices[i].coord.y, m_objects[objRank].bboxMin.y);
- m_objects[objRank].bboxMin.z = Math::Min(buffer.vertices[i].coord.z, m_objects[objRank].bboxMin.z);
- m_objects[objRank].bboxMax.x = Math::Max(buffer.vertices[i].coord.x, m_objects[objRank].bboxMax.x);
- m_objects[objRank].bboxMax.y = Math::Max(buffer.vertices[i].coord.y, m_objects[objRank].bboxMax.y);
- m_objects[objRank].bboxMax.z = Math::Max(buffer.vertices[i].coord.z, m_objects[objRank].bboxMax.z);
- }
+ min = m_baseObjects[baseObjRank].bboxMin;
+ max = m_baseObjects[baseObjRank].bboxMax;
+}
- m_objects[objRank].radius = Math::Max(m_objects[objRank].bboxMin.Length(),
- m_objects[objRank].bboxMax.Length());
- }
- if (buffer.type == ENG_TRIANGLE_TYPE_TRIANGLES)
- m_objects[objRank].totalTriangles += buffer.vertices.size() / 3;
- else if (buffer.type == ENG_TRIANGLE_TYPE_SURFACE)
- m_objects[objRank].totalTriangles += buffer.vertices.size() - 2;
+int CEngine::GetObjectTotalTriangles(int objRank)
+{
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- return true;
+ int baseObjRank = m_objects[objRank].baseObjRank;
+ if (baseObjRank == -1)
+ return 0;
+
+ assert(baseObjRank >= 0 && baseObjRank < static_cast<int>( m_baseObjects.size() ));
+
+ return m_baseObjects[baseObjRank].totalTriangles;
}
-EngineObjLevel4* CEngine::FindTriangles(int objRank, const Material& material,
- int state, std::string tex1Name,
- std::string tex2Name, float min, float max)
+EngineBaseObjDataTier* CEngine::FindTriangles(int objRank, const Material& material,
+ int state, std::string tex1Name,
+ std::string tex2Name, float min, float max)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- {
- GetLogger()->Error("FindTriangles(): invalid object rank %d\n", objRank);
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
+
+ int baseObjRank = m_objects[objRank].baseObjRank;
+ if (baseObjRank == -1)
return nullptr;
- }
- for (int l1 = 0; l1 < static_cast<int>( m_objectTree.size() ); l1++)
+ assert(baseObjRank >= 0 && baseObjRank < static_cast<int>( m_baseObjects.size() ));
+
+ EngineBaseObject& p1 = m_baseObjects[baseObjRank];
+
+ for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
{
- EngineObjLevel1& p1 = m_objectTree[l1];
- if (! p1.used) continue;
+ EngineBaseObjTexTier& p2 = p1.next[l2];
- if (p1.tex1Name != tex1Name) continue;
- // TODO: tex2Name compare?
+ if (p2.tex1Name != tex1Name)
+ continue;
- for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
+ for (int l3 = 0; l3 < static_cast<int>( p2.next.size() ); l3++)
{
- EngineObjLevel2& p2 = p1.next[l2];
- if (! p2.used) continue;
+ EngineBaseObjLODTier& p3 = p2.next[l3];
- if (p2.objRank != objRank) continue;
+ if (p3.min != min || p3.max != max)
+ continue;
- for (int l3 = 0; l3 < static_cast<int>( p2.next.size() ); l3++)
+ for (int l4 = 0; l4 < static_cast<int>( p3.next.size() ); l4++)
{
- EngineObjLevel3& p3 = p2.next[l3];
- if (! p3.used) continue;
-
- if (p3.min != min || p3.max != max) continue;
-
- for (int l4 = 0; l4 < static_cast<int>( p3.next.size() ); l4++)
- {
- EngineObjLevel4& p4 = p3.next[l4];
- if (! p4.used) continue;
+ EngineBaseObjDataTier& p4 = p3.next[l4];
- if ( (p4.state & (~(ENG_RSTATE_DUAL_BLACK|ENG_RSTATE_DUAL_WHITE))) != state ||
- p4.material != material )
- continue;
+ if ( (p4.state & (~(ENG_RSTATE_DUAL_BLACK|ENG_RSTATE_DUAL_WHITE))) != state ||
+ p4.material != material )
+ continue;
- return &p4;
- }
+ return &p4;
}
}
}
@@ -1001,91 +840,85 @@ EngineObjLevel4* CEngine::FindTriangles(int objRank, const Material& material,
}
int CEngine::GetPartialTriangles(int objRank, float min, float max, float percent, int maxCount,
- std::vector<EngineTriangle>& triangles)
+ std::vector<EngineTriangle>& triangles)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- {
- GetLogger()->Error("GetPartialTriangles(): invalid object rank %d\n", objRank);
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
+
+ int baseObjRank = m_objects[objRank].baseObjRank;
+ if (baseObjRank == -1)
return 0;
- }
- int total = m_objects[objRank].totalTriangles;
+ assert(baseObjRank >= 0 && baseObjRank < static_cast<int>( m_baseObjects.size() ));
+
+ EngineBaseObject& p1 = m_baseObjects[baseObjRank];
+
+ int total = p1.totalTriangles;
int expectedCount = static_cast<int>(percent * total);
triangles.reserve(Math::Min(maxCount, expectedCount));
int actualCount = 0;
- for (int l1 = 0; l1 < static_cast<int>( m_objectTree.size() ); l1++)
+ for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
{
- EngineObjLevel1& p1 = m_objectTree[l1];
- if (! p1.used) continue;
+ EngineBaseObjTexTier& p2 = p1.next[l2];
- for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
+ for (int l3 = 0; l3 < static_cast<int>( p2.next.size() ); l3++)
{
- EngineObjLevel2& p2 = p1.next[l2];
- if (! p2.used) continue;
+ EngineBaseObjLODTier& p3 = p2.next[l3];
- if (p2.objRank != objRank) continue;
+ if (p3.min != min || p3.max != max)
+ continue;
- for (int l3 = 0; l3 < static_cast<int>( p2.next.size() ); l3++)
+ for (int l4 = 0; l4 < static_cast<int>( p3.next.size() ); l4++)
{
- EngineObjLevel3& p3 = p2.next[l3];
- if (! p3.used) continue;
+ EngineBaseObjDataTier& p4 = p3.next[l4];
- if (p3.min != min || p3.max != max) continue;
-
- for (int l4 = 0; l4 < static_cast<int>( p3.next.size() ); l4++)
+ if (p4.type == ENG_TRIANGLE_TYPE_TRIANGLES)
{
- EngineObjLevel4& p4 = p3.next[l4];
- if (! p4.used) continue;
-
- if (p4.type == ENG_TRIANGLE_TYPE_TRIANGLES)
+ for (int i = 0; i < static_cast<int>( p4.vertices.size() ); i += 3)
{
- for (int i = 0; i < static_cast<int>( p4.vertices.size() ); i += 3)
- {
- if (static_cast<float>(actualCount) / total >= percent)
- break;
+ if (static_cast<float>(actualCount) / total >= percent)
+ break;
- if (actualCount >= maxCount)
- break;
+ if (actualCount >= maxCount)
+ break;
- EngineTriangle t;
- t.triangle[0] = p4.vertices[i];
- t.triangle[1] = p4.vertices[i+1];
- t.triangle[2] = p4.vertices[i+2];
- t.material = p4.material;
- t.state = p4.state;
- t.tex1Name = p1.tex1Name;
- t.tex2Name = p1.tex2Name;
+ EngineTriangle t;
+ t.triangle[0] = p4.vertices[i];
+ t.triangle[1] = p4.vertices[i+1];
+ t.triangle[2] = p4.vertices[i+2];
+ t.material = p4.material;
+ t.state = p4.state;
+ t.tex1Name = p2.tex1Name;
+ t.tex2Name = p2.tex2Name;
- triangles.push_back(t);
+ triangles.push_back(t);
- ++actualCount;
- }
+ ++actualCount;
}
- else if (p4.type == ENG_TRIANGLE_TYPE_SURFACE)
+ }
+ else if (p4.type == ENG_TRIANGLE_TYPE_SURFACE)
+ {
+ for (int i = 0; i < static_cast<int>( p4.vertices.size() ); i += 1)
{
- for (int i = 0; i < static_cast<int>( p4.vertices.size() ); i += 1)
- {
- if (static_cast<float>(actualCount) / total >= percent)
- break;
+ if (static_cast<float>(actualCount) / total >= percent)
+ break;
- if (actualCount >= maxCount)
- break;
+ if (actualCount >= maxCount)
+ break;
- EngineTriangle t;
- t.triangle[0] = p4.vertices[i];
- t.triangle[1] = p4.vertices[i+1];
- t.triangle[2] = p4.vertices[i+2];
- t.material = p4.material;
- t.state = p4.state;
- t.tex1Name = p1.tex1Name;
- t.tex2Name = p1.tex2Name;
+ EngineTriangle t;
+ t.triangle[0] = p4.vertices[i];
+ t.triangle[1] = p4.vertices[i+1];
+ t.triangle[2] = p4.vertices[i+2];
+ t.material = p4.material;
+ t.state = p4.state;
+ t.tex1Name = p2.tex1Name;
+ t.tex2Name = p2.tex2Name;
- triangles.push_back(t);
+ triangles.push_back(t);
- ++actualCount;
- }
+ ++actualCount;
}
}
}
@@ -1112,20 +945,20 @@ void CEngine::ChangeLOD()
float oldTerrain = m_terrainVision * m_lastClippingDistance;
float newTerrain = m_terrainVision * m_clippingDistance;
- for (int l1 = 0; l1 < static_cast<int>( m_objectTree.size() ); l1++)
+ for (int baseObjRank = 0; baseObjRank < static_cast<int>( m_baseObjects.size() ); baseObjRank++)
{
- EngineObjLevel1& p1 = m_objectTree[l1];
- if (! p1.used) continue;
+ EngineBaseObject& p1 = m_baseObjects[baseObjRank];
+
+ if (! p1.used)
+ continue;
for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
{
- EngineObjLevel2& p2 = p1.next[l2];
- if (! p2.used) continue;
+ EngineBaseObjTexTier& p2 = p1.next[l2];
for (int l3 = 0; l3 < static_cast<int>( p2.next.size() ); l3++)
{
- EngineObjLevel3& p3 = p2.next[l3];
- if (! p3.used) continue;
+ EngineBaseObjLODTier& p3 = p2.next[l3];
if ( Math::IsEqual(p3.min, 0.0f ) &&
Math::IsEqual(p3.max, oldLimit[0]) )
@@ -1157,43 +990,40 @@ void CEngine::ChangeLOD()
m_lastClippingDistance = m_clippingDistance;
}
-bool CEngine::ChangeSecondTexture(int objRank, const std::string& tex2Name)
+void CEngine::ChangeSecondTexture(int objRank, const std::string& tex2Name)
{
- for (int l1 = 0; l1 < static_cast<int>( m_objectTree.size() ); l1++)
- {
- EngineObjLevel1& p1 = m_objectTree[l1];
- if (! p1.used) continue;
-
- if (p1.tex2Name == tex2Name) continue; // already new
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
- {
- EngineObjLevel2& p2 = p1.next[l2];
- if (! p2.used) continue;
+ int baseObjRank = m_objects[objRank].baseObjRank;
+ if (baseObjRank == -1)
+ return;
- if (p2.objRank != objRank) continue;
+ assert(baseObjRank >= 0 && baseObjRank < static_cast<int>( m_baseObjects.size() ));
- EngineObjLevel1& newP1 = AddLevel1(p1.tex1Name, tex2Name);
+ EngineBaseObject& p1 = m_baseObjects[baseObjRank];
- newP1.next.push_back(EngineObjLevel2(true, objRank));
+ for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
+ {
+ EngineBaseObjTexTier& p2 = p1.next[l2];
- EngineObjLevel2& newP2 = newP1.next.back();
- newP2.next.swap(p2.next);
+ if (p2.tex2Name == tex2Name)
+ continue; // already new
- p2.used = false;
- }
+ EngineBaseObjTexTier& newP2 = AddLevel2(p1, p2.tex1Name, tex2Name);
+ newP2.next.swap(p2.next);
}
- return true;
}
-bool CEngine::ChangeTextureMapping(int objRank, const Material& mat, int state,
- const std::string& tex1Name, const std::string& tex2Name,
- float min, float max, EngineTextureMapping mode,
- float au, float bu, float av, float bv)
+void CEngine::ChangeTextureMapping(int objRank, const Material& mat, int state,
+ const std::string& tex1Name, const std::string& tex2Name,
+ float min, float max, EngineTextureMapping mode,
+ float au, float bu, float av, float bv)
{
- EngineObjLevel4* p4 = FindTriangles(objRank, mat, state, tex1Name, tex2Name, min, max);
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
+
+ EngineBaseObjDataTier* p4 = FindTriangles(objRank, mat, state, tex1Name, tex2Name, min, max);
if (p4 == nullptr)
- return false;
+ return;
int nb = p4->vertices.size();
@@ -1243,27 +1073,113 @@ bool CEngine::ChangeTextureMapping(int objRank, const Material& mat, int state,
}
}
- return true;
+ UpdateStaticBuffer(*p4);
}
-bool CEngine::TrackTextureMapping(int objRank, const Material& mat, int state,
- const std::string& tex1Name, const std::string& tex2Name,
- float min, float max, EngineTextureMapping mode,
- float pos, float factor, float tl, float ts, float tt)
+void CEngine::TrackTextureMapping(int objRank, const Material& mat, int state,
+ const std::string& tex1Name, const std::string& tex2Name,
+ float min, float max, EngineTextureMapping mode,
+ float pos, float factor, float tl, float ts, float tt)
{
- // TODO track texture mapping: pretty complex code, so leaving it for now
- GetLogger()->Trace("CEngine::TrackTextureMapping(): stub!\n");
- return true;
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
+
+ EngineBaseObjDataTier* p4 = FindTriangles(objRank, mat, state, tex1Name, tex2Name, min, max);
+ if (p4 == nullptr)
+ return;
+
+ int tNum = p4->vertices.size();
+ if (tNum < 12 || tNum % 6 != 0)
+ return;
+
+ std::vector<Gfx::VertexTex2>& vs = p4->vertices;
+
+ while (pos < 0.0f)
+ pos += 1.0f; // never negative!
+
+ Math::Vector current;
+
+ for (int i = 0; i < 6; i++)
+ {
+ for (int j = 0; j < 6; j++)
+ {
+ if (Math::IsEqual(vs[i].coord.x, vs[j+6].coord.x) &&
+ Math::IsEqual(vs[i].coord.y, vs[j+6].coord.y))
+ {
+ current.x = vs[i].coord.x; // position end link
+ current.y = vs[i].coord.y;
+ break;
+ }
+ }
+ }
+
+ float ps = 0.0f; // start position on the periphery
+ float pe = 0.0f;
+ int is[6] = { 0 }, ie[6] = { 0 };
+
+ int tBase = 0;
+ for (int ti = 0; ti < tNum / 6; ti++)
+ {
+ int s = 0;
+ int e = 0;
+
+ for (int i = 0; i < 6; i++)
+ {
+ if (Math::IsEqual(vs[tBase + i].coord.x, current.x, 0.0001f) &&
+ Math::IsEqual(vs[tBase + i].coord.y, current.y, 0.0001f))
+ {
+ ie[e++] = i;
+ }
+ else
+ {
+ is[s++] = i;
+ }
+ }
+ if (s == 3 && e == 3)
+ {
+ pe = ps + Math::Point(vs[tBase + is[0]].coord.x - vs[tBase + ie[0]].coord.x,
+ vs[tBase + is[0]].coord.y - vs[tBase + ie[0]].coord.y).Length() / factor; // end position on the periphery
+
+ float pps = ps + pos;
+ float ppe = pe + pos;
+ int offset = static_cast<int>(pps);
+ ppe -= offset;
+ pps -= offset;
+
+ for (int i = 0; i < 3; i++)
+ {
+ vs[tBase + is[i]].texCoord.x = ((pps * tl) + ts) / tt;
+ vs[tBase + ie[i]].texCoord.x = ((ppe * tl) + ts) / tt;
+ }
+ }
+
+ if (ti >= (tNum / 6) - 1)
+ break;
+
+ for (int i = 0; i < 6; i++)
+ {
+ if (!Math::IsEqual(vs[tBase + i+6].coord.x, current.x, 0.0001f) ||
+ !Math::IsEqual(vs[tBase + i+6].coord.y, current.y, 0.0001f))
+ {
+ current.x = vs[tBase + i+6].coord.x; // end next link
+ current.y = vs[tBase + i+6].coord.y;
+ break;
+ }
+ }
+ ps = pe; // following start position on the periphery
+ tBase += 6;
+ }
+
+ UpdateStaticBuffer(*p4);
}
-bool CEngine::CreateShadow(int objRank)
+void CEngine::CreateShadow(int objRank)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return false;
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
// Already allocated?
- if (m_objects[objRank].shadowRank != -1) return true;
+ if (m_objects[objRank].shadowRank != -1)
+ return;
int index = 0;
for ( ; index < static_cast<int>( m_shadows.size() ); index++)
@@ -1275,146 +1191,147 @@ bool CEngine::CreateShadow(int objRank)
}
}
- m_shadows.push_back(EngineShadow());
+ if (index == static_cast<int>( m_shadows.size() ))
+ m_shadows.push_back(EngineShadow());
m_shadows[index].used = true;
m_shadows[index].objRank = objRank;
m_shadows[index].height = 0.0f;
m_objects[objRank].shadowRank = index;
-
- return true;
}
void CEngine::DeleteShadow(int objRank)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return;
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- int i = m_objects[objRank].shadowRank;
- if (i == -1)
+ int shadowRank = m_objects[objRank].shadowRank;
+ if (shadowRank == -1)
return;
- m_shadows[i].used = false;
- m_shadows[i].objRank = -1;
+ assert(shadowRank >= 0 && shadowRank < static_cast<int>( m_shadows.size() ));
+
+ m_shadows[shadowRank].used = false;
+ m_shadows[shadowRank].objRank = -1;
m_objects[objRank].shadowRank = -1;
}
-bool CEngine::SetObjectShadowHide(int objRank, bool hide)
+void CEngine::SetObjectShadowHide(int objRank, bool hide)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return false;
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- int i = m_objects[objRank].shadowRank;
- if (i == -1)
- return false;
+ int shadowRank = m_objects[objRank].shadowRank;
+ if (shadowRank == -1)
+ return;
- m_shadows[i].hide = hide;
- return true;
+ assert(shadowRank >= 0 && shadowRank < static_cast<int>( m_shadows.size() ));
+
+ m_shadows[shadowRank].hide = hide;
}
-bool CEngine::SetObjectShadowType(int objRank, EngineShadowType type)
+void CEngine::SetObjectShadowType(int objRank, EngineShadowType type)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return false;
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- int i = m_objects[objRank].shadowRank;
- if (i == -1)
- return false;
+ int shadowRank = m_objects[objRank].shadowRank;
+ if (shadowRank == -1)
+ return;
- m_shadows[i].type = type;
- return true;
+ assert(shadowRank >= 0 && shadowRank < static_cast<int>( m_shadows.size() ));
+
+ m_shadows[shadowRank].type = type;
}
-bool CEngine::SetObjectShadowPos(int objRank, const Math::Vector& pos)
+void CEngine::SetObjectShadowPos(int objRank, const Math::Vector& pos)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return false;
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- int i = m_objects[objRank].shadowRank;
- if (i == -1)
- return false;
+ int shadowRank = m_objects[objRank].shadowRank;
+ if (shadowRank == -1)
+ return;
- m_shadows[i].pos = pos;
- return true;
+ assert(shadowRank >= 0 && shadowRank < static_cast<int>( m_shadows.size() ));
+
+ m_shadows[shadowRank].pos = pos;
}
-bool CEngine::SetObjectShadowNormal(int objRank, const Math::Vector& normal)
+void CEngine::SetObjectShadowNormal(int objRank, const Math::Vector& normal)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return false;
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- int i = m_objects[objRank].shadowRank;
- if (i == -1)
- return false;
+ int shadowRank = m_objects[objRank].shadowRank;
+ if (shadowRank == -1)
+ return;
- m_shadows[i].normal = normal;
- return true;
+ assert(shadowRank >= 0 && shadowRank < static_cast<int>( m_shadows.size() ));
+
+ m_shadows[shadowRank].normal = normal;
}
-bool CEngine::SetObjectShadowAngle(int objRank, float angle)
+void CEngine::SetObjectShadowAngle(int objRank, float angle)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return false;
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- int i = m_objects[objRank].shadowRank;
- if (i == -1)
- return false;
+ int shadowRank = m_objects[objRank].shadowRank;
+ if (shadowRank == -1)
+ return;
- m_shadows[i].angle = angle;
- return true;
+ assert(shadowRank >= 0 && shadowRank < static_cast<int>( m_shadows.size() ));
+
+ m_shadows[shadowRank].angle = angle;
}
-bool CEngine::SetObjectShadowRadius(int objRank, float radius)
+void CEngine::SetObjectShadowRadius(int objRank, float radius)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return false;
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- int i = m_objects[objRank].shadowRank;
- if (i == -1)
- return false;
+ int shadowRank = m_objects[objRank].shadowRank;
+ if (shadowRank == -1)
+ return;
- m_shadows[i].radius = radius;
- return true;
+ assert(shadowRank >= 0 && shadowRank < static_cast<int>( m_shadows.size() ));
+
+ m_shadows[shadowRank].radius = radius;
}
-bool CEngine::SetObjectShadowIntensity(int objRank, float intensity)
+void CEngine::SetObjectShadowIntensity(int objRank, float intensity)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return false;
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- int i = m_objects[objRank].shadowRank;
- if (i == -1)
- return false;
+ int shadowRank = m_objects[objRank].shadowRank;
+ if (shadowRank == -1)
+ return;
- m_shadows[i].intensity = intensity;
- return true;
+ assert(shadowRank >= 0 && shadowRank < static_cast<int>( m_shadows.size() ));
+
+ m_shadows[shadowRank].intensity = intensity;
}
-bool CEngine::SetObjectShadowHeight(int objRank, float height)
+void CEngine::SetObjectShadowHeight(int objRank, float height)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return false;
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- int i = m_objects[objRank].shadowRank;
- if (i == -1)
- return false;
+ int shadowRank = m_objects[objRank].shadowRank;
+ if (shadowRank == -1)
+ return;
- m_shadows[i].height = height;
- return true;
+ assert(shadowRank >= 0 && shadowRank < static_cast<int>( m_shadows.size() ));
+
+ m_shadows[shadowRank].height = height;
}
float CEngine::GetObjectShadowRadius(int objRank)
{
- if ( objRank < 0 || objRank >= static_cast<int>( m_objects.size() ) )
- return 0.0f;
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
- int i = m_objects[objRank].shadowRank;
- if (i == -1)
+ int shadowRank = m_objects[objRank].shadowRank;
+ if (shadowRank == -1)
return 0.0f;
- return m_shadows[i].radius;
+ assert(shadowRank >= 0 && shadowRank < static_cast<int>( m_shadows.size() ));
+
+ return m_shadows[shadowRank].radius;
}
bool CEngine::GetHighlight(Math::Point &p1, Math::Point &p2)
@@ -1436,21 +1353,31 @@ void CEngine::SetHighlightRank(int *rankList)
bool CEngine::GetBBox2D(int objRank, Math::Point &min, Math::Point &max)
{
+ assert(objRank >= 0 && objRank < static_cast<int>( m_objects.size() ));
+
min.x = 1000000.0f;
min.y = 1000000.0f;
max.x = -1000000.0f;
max.y = -1000000.0f;
+ int baseObjRank = m_objects[objRank].baseObjRank;
+ if (baseObjRank == -1)
+ return false;
+
+ assert(baseObjRank >= 0 && baseObjRank < static_cast<int>( m_baseObjects.size() ));
+
+ EngineBaseObject& p1 = m_baseObjects[baseObjRank];
+
for (int i = 0; i < 8; i++)
{
Math::Vector p;
- if ( i & (1<<0) ) p.x = m_objects[objRank].bboxMin.x;
- else p.x = m_objects[objRank].bboxMax.x;
- if ( i & (1<<1) ) p.y = m_objects[objRank].bboxMin.y;
- else p.y = m_objects[objRank].bboxMax.y;
- if ( i & (1<<2) ) p.z = m_objects[objRank].bboxMin.z;
- else p.z = m_objects[objRank].bboxMax.z;
+ if ( i & (1<<0) ) p.x = p1.bboxMin.x;
+ else p.x = p1.bboxMax.x;
+ if ( i & (1<<1) ) p.y = p1.bboxMin.y;
+ else p.y = p1.bboxMax.y;
+ if ( i & (1<<2) ) p.z = p1.bboxMin.z;
+ else p.z = p1.bboxMax.z;
Math::Vector pp;
if (TransformPoint(pp, objRank, p))
@@ -1462,20 +1389,36 @@ bool CEngine::GetBBox2D(int objRank, Math::Point &min, Math::Point &max)
}
}
- if ( min.x == 1000000.0f ||
- min.y == 1000000.0f ||
- max.x == -1000000.0f ||
- max.y == -1000000.0f ) return false;
+ if (min.x == 1000000.0f ||
+ min.y == 1000000.0f ||
+ max.x == -1000000.0f ||
+ max.y == -1000000.0f)
+ return false;
return true;
}
-void CEngine::FlushGroundSpot()
+void CEngine::DeleteAllGroundSpots()
{
m_groundSpots.clear();
m_firstGroundSpot = true;
- // TODO: blank all shadow textures
+ for (int s = 0; s < 16; s++)
+ {
+ CImage shadowImg(Math::IntPoint(256, 256));
+ shadowImg.Fill(Gfx::IntColor(255, 255, 255, 255));
+
+ std::stringstream str;
+ str << "shadow" << std::setfill('0') << std::setw(2) << s << ".png";
+ std::string texName = str.str();
+
+ DeleteTexture(texName);
+
+ Gfx::Texture tex = m_device->CreateTexture(&shadowImg, m_defaultTexParams);
+
+ m_texNameMap[texName] = tex;
+ m_revTexNameMap[tex] = texName;
+ }
}
int CEngine::CreateGroundSpot()
@@ -1500,54 +1443,46 @@ int CEngine::CreateGroundSpot()
void CEngine::DeleteGroundSpot(int rank)
{
+ assert(rank >= 0 && rank < static_cast<int>( m_groundSpots.size() ));
+
m_groundSpots[rank].used = false;
m_groundSpots[rank].pos = Math::Vector(0.0f, 0.0f, 0.0f);
}
-bool CEngine::SetObjectGroundSpotPos(int rank, const Math::Vector& pos)
+void CEngine::SetObjectGroundSpotPos(int rank, const Math::Vector& pos)
{
- if ( rank < 0 || rank >= static_cast<int>( m_groundSpots.size() ) )
- return 0.0f;
+ assert(rank >= 0 && rank < static_cast<int>( m_groundSpots.size() ));
m_groundSpots[rank].pos = pos;
- return true;
}
-bool CEngine::SetObjectGroundSpotRadius(int rank, float radius)
+void CEngine::SetObjectGroundSpotRadius(int rank, float radius)
{
- if ( rank < 0 || rank >= static_cast<int>( m_groundSpots.size() ) )
- return 0.0f;
+ assert(rank >= 0 && rank < static_cast<int>( m_groundSpots.size() ));
m_groundSpots[rank].radius = radius;
- return true;
}
-bool CEngine::SetObjectGroundSpotColor(int rank, const Color& color)
+void CEngine::SetObjectGroundSpotColor(int rank, const Color& color)
{
- if ( rank < 0 || rank >= static_cast<int>( m_groundSpots.size() ) )
- return 0.0f;
+ assert(rank >= 0 && rank < static_cast<int>( m_groundSpots.size() ));
m_groundSpots[rank].color = color;
- return true;
}
-bool CEngine::SetObjectGroundSpotMinMax(int rank, float min, float max)
+void CEngine::SetObjectGroundSpotMinMax(int rank, float min, float max)
{
- if ( rank < 0 || rank >= static_cast<int>( m_groundSpots.size() ) )
- return 0.0f;
+ assert(rank >= 0 && rank < static_cast<int>( m_groundSpots.size() ));
m_groundSpots[rank].min = min;
m_groundSpots[rank].max = max;
- return true;
}
-bool CEngine::SetObjectGroundSpotSmooth(int rank, float smooth)
+void CEngine::SetObjectGroundSpotSmooth(int rank, float smooth)
{
- if ( rank < 0 || rank >= static_cast<int>( m_groundSpots.size() ) )
- return 0.0f;
+ assert(rank >= 0 && rank < static_cast<int>( m_groundSpots.size() ));
m_groundSpots[rank].smooth = smooth;
- return true;
}
void CEngine::CreateGroundMark(Math::Vector pos, float radius,
@@ -1556,6 +1491,7 @@ void CEngine::CreateGroundMark(Math::Vector pos, float radius,
{
m_groundMark.LoadDefault();
+ m_groundMark.draw = true;
m_groundMark.phase = ENG_GR_MARK_PHASE_INC;
m_groundMark.delay[0] = delay1;
m_groundMark.delay[1] = delay2;
@@ -1575,8 +1511,6 @@ void CEngine::DeleteGroundMark(int rank)
void CEngine::ComputeDistance()
{
- // TODO: s_resol???
-
for (int i = 0; i < static_cast<int>( m_objects.size() ); i++)
{
if (! m_objects[i].used)
@@ -1595,51 +1529,39 @@ void CEngine::UpdateGeometry()
if (! m_updateGeometry)
return;
- for (int i = 0; i < static_cast<int>( m_objects.size() ); i++)
+ for (int baseObjRank = 0; baseObjRank < static_cast<int>( m_baseObjects.size() ); baseObjRank++)
{
- m_objects[i].bboxMin.x = 0;
- m_objects[i].bboxMin.y = 0;
- m_objects[i].bboxMin.z = 0;
- m_objects[i].bboxMax.x = 0;
- m_objects[i].bboxMax.y = 0;
- m_objects[i].bboxMax.z = 0;
- m_objects[i].radius = 0;
- }
+ EngineBaseObject &p1 = m_baseObjects[baseObjRank];
+ if (! p1.used)
+ continue;
- for (int l1 = 0; l1 < static_cast<int>( m_objectTree.size() ); l1++)
- {
- EngineObjLevel1& p1 = m_objectTree[l1];
- if (! p1.used) continue;
+ p1.bboxMin.LoadZero();
+ p1.bboxMax.LoadZero();
+ p1.radius = 0;
for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
{
- EngineObjLevel2& p2 = p1.next[l2];
- if (! p2.used) continue;
+ EngineBaseObjTexTier& p2 = p1.next[l2];
for (int l3 = 0; l3 < static_cast<int>( p2.next.size() ); l3++)
{
- EngineObjLevel3& p3 = p2.next[l3];
- if (! p3.used) continue;
+ EngineBaseObjLODTier& p3 = p2.next[l3];
for (int l4 = 0; l4 < static_cast<int>( p3.next.size() ); l4++)
{
- EngineObjLevel4& p4 = p3.next[l4];
- if (! p4.used) continue;
-
- int objRank = p2.objRank;
+ EngineBaseObjDataTier& p4 = p3.next[l4];
for (int i = 0; i < static_cast<int>( p4.vertices.size() ); i++)
{
- m_objects[objRank].bboxMin.x = Math::Min(p4.vertices[i].coord.x, m_objects[objRank].bboxMin.x);
- m_objects[objRank].bboxMin.y = Math::Min(p4.vertices[i].coord.y, m_objects[objRank].bboxMin.y);
- m_objects[objRank].bboxMin.z = Math::Min(p4.vertices[i].coord.z, m_objects[objRank].bboxMin.z);
- m_objects[objRank].bboxMax.x = Math::Max(p4.vertices[i].coord.x, m_objects[objRank].bboxMax.x);
- m_objects[objRank].bboxMax.y = Math::Max(p4.vertices[i].coord.y, m_objects[objRank].bboxMax.y);
- m_objects[objRank].bboxMax.z = Math::Max(p4.vertices[i].coord.z, m_objects[objRank].bboxMax.z);
+ p1.bboxMin.x = Math::Min(p4.vertices[i].coord.x, p1.bboxMin.x);
+ p1.bboxMin.y = Math::Min(p4.vertices[i].coord.y, p1.bboxMin.y);
+ p1.bboxMin.z = Math::Min(p4.vertices[i].coord.z, p1.bboxMin.z);
+ p1.bboxMax.x = Math::Max(p4.vertices[i].coord.x, p1.bboxMax.x);
+ p1.bboxMax.y = Math::Max(p4.vertices[i].coord.y, p1.bboxMax.y);
+ p1.bboxMax.z = Math::Max(p4.vertices[i].coord.z, p1.bboxMax.z);
}
- m_objects[objRank].radius = Math::Max(m_objects[objRank].bboxMin.Length(),
- m_objects[objRank].bboxMax.Length());
+ p1.radius = Math::Max(p1.bboxMin.Length(), p1.bboxMax.Length());
}
}
}
@@ -1648,14 +1570,76 @@ void CEngine::UpdateGeometry()
m_updateGeometry = false;
}
+void CEngine::UpdateStaticBuffer(EngineBaseObjDataTier& p4)
+{
+ PrimitiveType type;
+ if (p4.type == ENG_TRIANGLE_TYPE_TRIANGLES)
+ type = PRIMITIVE_TRIANGLES;
+ else
+ type = PRIMITIVE_TRIANGLE_STRIP;
+
+ if (p4.staticBufferId == 0)
+ p4.staticBufferId = m_device->CreateStaticBuffer(type, &p4.vertices[0], p4.vertices.size());
+ else
+ m_device->UpdateStaticBuffer(p4.staticBufferId, type, &p4.vertices[0], p4.vertices.size());
+
+ p4.updateStaticBuffer = false;
+}
+
+void CEngine::UpdateStaticBuffers()
+{
+ if (!m_updateStaticBuffers)
+ return;
+
+ m_updateStaticBuffers = false;
+
+ for (int baseObjRank = 0; baseObjRank < static_cast<int>( m_baseObjects.size() ); baseObjRank++)
+ {
+ EngineBaseObject& p1 = m_baseObjects[baseObjRank];
+ if (! p1.used)
+ continue;
+
+ for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
+ {
+ EngineBaseObjTexTier& p2 = p1.next[l2];
+
+ for (int l3 = 0; l3 < static_cast<int>( p2.next.size() ); l3++)
+ {
+ EngineBaseObjLODTier& p3 = p2.next[l3];
+
+ for (int l4 = 0; l4 < static_cast<int>( p3.next.size() ); l4++)
+ {
+ EngineBaseObjDataTier& p4 = p3.next[l4];
+
+ if (! p4.updateStaticBuffer)
+ continue;
+
+ UpdateStaticBuffer(p4);
+ }
+ }
+ }
+ }
+}
+
void CEngine::Update()
{
ComputeDistance();
UpdateGeometry();
+ UpdateStaticBuffers();
}
bool CEngine::DetectBBox(int objRank, Math::Point mouse)
{
+ assert(objRank >= 0 && objRank < static_cast<int>(m_objects.size()));
+
+ int baseObjRank = m_objects[objRank].baseObjRank;
+ if (baseObjRank == -1)
+ return false;
+
+ assert(baseObjRank >= 0 && baseObjRank < static_cast<int>(m_baseObjects.size()));
+
+ EngineBaseObject& p1 = m_baseObjects[baseObjRank];
+
Math::Point min, max;
min.x = 1000000.0f;
min.y = 1000000.0f;
@@ -1666,12 +1650,12 @@ bool CEngine::DetectBBox(int objRank, Math::Point mouse)
{
Math::Vector p;
- if ( i & (1<<0) ) p.x = m_objects[objRank].bboxMin.x;
- else p.x = m_objects[objRank].bboxMax.x;
- if ( i & (1<<1) ) p.y = m_objects[objRank].bboxMin.y;
- else p.y = m_objects[objRank].bboxMax.y;
- if ( i & (1<<2) ) p.z = m_objects[objRank].bboxMin.z;
- else p.z = m_objects[objRank].bboxMax.z;
+ if ( i & (1<<0) ) p.x = p1.bboxMin.x;
+ else p.x = p1.bboxMax.x;
+ if ( i & (1<<1) ) p.y = p1.bboxMin.y;
+ else p.y = p1.bboxMax.y;
+ if ( i & (1<<2) ) p.z = p1.bboxMin.z;
+ else p.z = p1.bboxMax.z;
Math::Vector pp;
if ( TransformPoint(pp, objRank, p) )
@@ -1694,41 +1678,51 @@ int CEngine::DetectObject(Math::Point mouse)
float min = 1000000.0f;
int nearest = -1;
- for (int l1 = 0; l1 < static_cast<int>( m_objectTree.size() ); l1++)
+ for (int objRank = 0; objRank < static_cast<int>( m_objects.size() ); objRank++)
{
- EngineObjLevel1& p1 = m_objectTree[l1];
- if (! p1.used) continue;
+ if (! m_objects[objRank].used)
+ continue;
- for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
- {
- EngineObjLevel2& p2 = p1.next[l2];
- if (! p2.used) continue;
+ if (m_objects[objRank].type == ENG_OBJTYPE_TERRAIN)
+ continue;
- if (m_objects[p2.objRank].type == ENG_OBJTYPE_TERRAIN) continue;
+ if (! DetectBBox(objRank, mouse))
+ continue;
- if (! DetectBBox(p2.objRank, mouse)) continue;
+ int baseObjRank = m_objects[objRank].baseObjRank;
+ if (baseObjRank == -1)
+ continue;
+
+ assert(baseObjRank >= 0 && baseObjRank < static_cast<int>(m_baseObjects.size()));
+
+ EngineBaseObject& p1 = m_baseObjects[baseObjRank];
+ if (! p1.used)
+ continue;
+
+ for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
+ {
+ EngineBaseObjTexTier& p2 = p1.next[l2];
for (int l3 = 0; l3 < static_cast<int>( p2.next.size() ); l3++)
{
- EngineObjLevel3& p3 = p2.next[l3];
- if (! p3.used) continue;
+ EngineBaseObjLODTier& p3 = p2.next[l3];
- if (p3.min != 0.0f) continue; // LOD B or C?
+ if (p3.min != 0.0f)
+ continue; // LOD B or C?
for (int l4 = 0; l4 < static_cast<int>( p3.next.size() ); l4++)
{
- EngineObjLevel4& p4 = p3.next[l4];
- if (! p4.used) continue;
+ EngineBaseObjDataTier& p4 = p3.next[l4];
if (p4.type == ENG_TRIANGLE_TYPE_TRIANGLES)
{
for (int i = 0; i < static_cast<int>( p4.vertices.size() ); i += 3)
{
float dist = 0.0f;
- if (DetectTriangle(mouse, &p4.vertices[i], p2.objRank, dist) && dist < min)
+ if (DetectTriangle(mouse, &p4.vertices[i], objRank, dist) && dist < min)
{
min = dist;
- nearest = p2.objRank;
+ nearest = objRank;
}
}
}
@@ -1737,10 +1731,10 @@ int CEngine::DetectObject(Math::Point mouse)
for (int i = 0; i < static_cast<int>( p4.vertices.size() ) - 2; i += 1)
{
float dist = 0.0f;
- if (DetectTriangle(mouse, &p4.vertices[i], p2.objRank, dist) && dist < min)
+ if (DetectTriangle(mouse, &p4.vertices[i], objRank, dist) && dist < min)
{
min = dist;
- nearest = p2.objRank;
+ nearest = objRank;
}
}
}
@@ -1754,6 +1748,8 @@ int CEngine::DetectObject(Math::Point mouse)
bool CEngine::DetectTriangle(Math::Point mouse, VertexTex2* triangle, int objRank, float& dist)
{
+ assert(objRank >= 0 && objRank < static_cast<int>(m_objects.size()));
+
Math::Vector p2D[3], p3D;
for (int i = 0; i < 3; i++)
@@ -1766,18 +1762,25 @@ bool CEngine::DetectTriangle(Math::Point mouse, VertexTex2* triangle, int objRan
return false;
}
- if ( mouse.x < p2D[0].x &&
- mouse.x < p2D[1].x &&
- mouse.x < p2D[2].x ) return false;
- if ( mouse.x > p2D[0].x &&
- mouse.x > p2D[1].x &&
- mouse.x > p2D[2].x ) return false;
- if ( mouse.y < p2D[0].y &&
- mouse.y < p2D[1].y &&
- mouse.y < p2D[2].y ) return false;
- if ( mouse.y > p2D[0].y &&
- mouse.y > p2D[1].y &&
- mouse.y > p2D[2].y ) return false;
+ if (mouse.x < p2D[0].x &&
+ mouse.x < p2D[1].x &&
+ mouse.x < p2D[2].x)
+ return false;
+
+ if (mouse.x > p2D[0].x &&
+ mouse.x > p2D[1].x &&
+ mouse.x > p2D[2].x)
+ return false;
+
+ if (mouse.y < p2D[0].y &&
+ mouse.y < p2D[1].y &&
+ mouse.y < p2D[2].y)
+ return false;
+
+ if (mouse.y > p2D[0].y &&
+ mouse.y > p2D[1].y &&
+ mouse.y > p2D[2].y)
+ return false;
Math::Point a, b, c;
a.x = p2D[0].x;
@@ -1794,18 +1797,38 @@ bool CEngine::DetectTriangle(Math::Point mouse, VertexTex2* triangle, int objRan
return true;
}
+//! Use only after world transform already set
bool CEngine::IsVisible(int objRank)
{
- // TODO: use ComputeSphereVisiblity() after tested OK
- return true;
+ assert(objRank >= 0 && objRank < static_cast<int>(m_objects.size()));
+
+ int baseObjRank = m_objects[objRank].baseObjRank;
+ if (baseObjRank == -1)
+ return false;
+
+ assert(baseObjRank >= 0 && baseObjRank < static_cast<int>(m_baseObjects.size()));
+
+ float radius = m_baseObjects[baseObjRank].radius;
+ Math::Vector center(0.0f, 0.0f, 0.0f);
+ if (m_device->ComputeSphereVisibility(center, radius) == Gfx::FRUSTUM_PLANE_ALL)
+ {
+ m_objects[objRank].visible = true;
+ return true;
+ }
+
+ m_objects[objRank].visible = false;
+ return false;
}
bool CEngine::TransformPoint(Math::Vector& p2D, int objRank, Math::Vector p3D)
{
+ assert(objRank >= 0 && objRank < static_cast<int>(m_objects.size()));
+
p3D = Math::Transform(m_objects[objRank].transform, p3D);
p3D = Math::Transform(m_matView, p3D);
- if (p3D.z < 2.0f) return false; // behind?
+ if (p3D.z < 2.0f)
+ return false; // behind?
p2D.x = (p3D.x/p3D.z)*m_matProj.Get(1,1);
p2D.y = (p3D.y/p3D.z)*m_matProj.Get(2,2);
@@ -1855,7 +1878,7 @@ void CEngine::SetState(int state, const Color& color)
params.colorOperation = TEX_MIX_OPER_MODULATE;
params.colorArg1 = TEX_MIX_ARG_TEXTURE;
params.colorArg2 = TEX_MIX_ARG_FACTOR;
- params.alphaOperation = TEX_MIX_OPER_DEFAULT; // TODO: replace with src color ?
+ params.alphaOperation = TEX_MIX_OPER_DEFAULT;
params.factor = color;
m_device->SetTextureEnabled(0, true);
@@ -1874,7 +1897,7 @@ void CEngine::SetState(int state, const Color& color)
params.colorOperation = TEX_MIX_OPER_ADD;
params.colorArg1 = TEX_MIX_ARG_TEXTURE;
params.colorArg2 = TEX_MIX_ARG_FACTOR;
- params.alphaOperation = TEX_MIX_OPER_DEFAULT; // TODO: replace with src color ?
+ params.alphaOperation = TEX_MIX_OPER_DEFAULT;
params.factor = color.Inverse();
m_device->SetTextureEnabled(0, true);
@@ -1914,7 +1937,7 @@ void CEngine::SetState(int state, const Color& color)
TextureStageParams params;
params.colorOperation = TEX_MIX_OPER_REPLACE;
params.colorArg1 = TEX_MIX_ARG_TEXTURE;
- params.alphaOperation = TEX_MIX_OPER_DEFAULT; // TODO: replace with src color ?
+ params.alphaOperation = TEX_MIX_OPER_DEFAULT;
m_device->SetTextureEnabled(0, true);
m_device->SetTextureStageParams(0, params);
@@ -1982,7 +2005,7 @@ void CEngine::SetState(int state, const Color& color)
TextureStageParams params;
params.colorOperation = TEX_MIX_OPER_DEFAULT; // default modulate
- params.alphaOperation = TEX_MIX_OPER_DEFAULT; // TODO: replace with src color ?
+ params.alphaOperation = TEX_MIX_OPER_DEFAULT;
m_device->SetTextureEnabled(0, true);
m_device->SetTextureStageParams(0, params);
@@ -2003,7 +2026,7 @@ void CEngine::SetState(int state, const Color& color)
params.colorOperation = TEX_MIX_OPER_MODULATE;
params.colorArg1 = TEX_MIX_ARG_TEXTURE;
params.colorArg2 = TEX_MIX_ARG_COMPUTED_COLOR;
- params.alphaOperation = TEX_MIX_OPER_DEFAULT; // TODO: ???
+ params.alphaOperation = TEX_MIX_OPER_DEFAULT;
m_device->SetTextureEnabled(1, true);
m_device->SetTextureStageParams(1, params);
}
@@ -2013,7 +2036,7 @@ void CEngine::SetState(int state, const Color& color)
params.colorOperation = TEX_MIX_OPER_ADD;
params.colorArg1 = TEX_MIX_ARG_TEXTURE;
params.colorArg2 = TEX_MIX_ARG_COMPUTED_COLOR;
- params.alphaOperation = TEX_MIX_OPER_DEFAULT; // TODO: ???
+ params.alphaOperation = TEX_MIX_OPER_DEFAULT;
m_device->SetTextureEnabled(1, true);
m_device->SetTextureStageParams(1, params);
}
@@ -2168,42 +2191,50 @@ bool CEngine::LoadAllTextures()
bool ok = true;
- for (int l1 = 0; l1 < static_cast<int>( m_objectTree.size() ); l1++)
+ for (int objRank = 0; objRank < static_cast<int>( m_objects.size() ); objRank++)
{
- EngineObjLevel1& p1 = m_objectTree[l1];
- if (! p1.used) continue;
+ if (! m_objects[objRank].used)
+ continue;
bool terrain = false;
+ if (m_objects[objRank].type == ENG_OBJTYPE_TERRAIN)
+ terrain = true;
- for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
- {
- EngineObjLevel2& p2 = p1.next[l2];
- if (! p2.used) continue;
+ int baseObjRank = m_objects[objRank].baseObjRank;
+ if (baseObjRank == -1)
+ continue;
- if (m_objects[p2.objRank].type == ENG_OBJTYPE_TERRAIN)
- terrain = true;
- }
+ assert(baseObjRank >= 0 && baseObjRank < static_cast<int>( m_baseObjects.size() ));
+
+ EngineBaseObject& p1 = m_baseObjects[baseObjRank];
+ if (! p1.used)
+ continue;
- if (! p1.tex1Name.empty())
+ for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
{
- if (terrain)
- p1.tex1 = LoadTexture(p1.tex1Name, m_terrainTexParams);
- else
- p1.tex1 = LoadTexture(p1.tex1Name);
+ EngineBaseObjTexTier& p2 = p1.next[l2];
- if (! p1.tex1.Valid())
- ok = false;
- }
+ if (! p2.tex1Name.empty())
+ {
+ if (terrain)
+ p2.tex1 = LoadTexture(p2.tex1Name, m_terrainTexParams);
+ else
+ p2.tex1 = LoadTexture(p2.tex1Name);
- if (! p1.tex2Name.empty())
- {
- if (terrain)
- p1.tex2 = LoadTexture(p1.tex2Name, m_terrainTexParams);
- else
- p1.tex2 = LoadTexture(p1.tex2Name);
+ if (! p2.tex1.Valid())
+ ok = false;
+ }
- if (! p1.tex2.Valid())
- ok = false;
+ if (! p2.tex2Name.empty())
+ {
+ if (terrain)
+ p2.tex2 = LoadTexture(p2.tex2Name, m_terrainTexParams);
+ else
+ p2.tex2 = LoadTexture(p2.tex2Name);
+
+ if (! p2.tex2.Valid())
+ ok = false;
+ }
}
}
@@ -2219,7 +2250,8 @@ bool IsExcludeColor(Math::Point *exclude, int x, int y)
if ( x >= static_cast<int>(exclude[i+0].x*256.0f) &&
x < static_cast<int>(exclude[i+1].x*256.0f) &&
y >= static_cast<int>(exclude[i+0].y*256.0f) &&
- y < static_cast<int>(exclude[i+1].y*256.0f) ) return true; // exclude
+ y < static_cast<int>(exclude[i+1].y*256.0f) )
+ return true; // exclude
i += 2;
}
@@ -2235,12 +2267,13 @@ bool CEngine::ChangeTextureColor(const std::string& texName,
Math::Point ts, Math::Point ti,
Math::Point *exclude, float shift, bool hsv)
{
- if ( colorRef1.r == colorNew1.r &&
- colorRef1.g == colorNew1.g &&
- colorRef1.b == colorNew1.b &&
- colorRef2.r == colorNew2.r &&
- colorRef2.g == colorNew2.g &&
- colorRef2.b == colorNew2.b ) return true;
+ if (colorRef1.r == colorNew1.r &&
+ colorRef1.g == colorNew1.g &&
+ colorRef1.b == colorNew1.b &&
+ colorRef2.r == colorNew2.r &&
+ colorRef2.g == colorNew2.g &&
+ colorRef2.b == colorNew2.b)
+ return true;
DeleteTexture(texName);
@@ -2275,7 +2308,8 @@ bool CEngine::ChangeTextureColor(const std::string& texName,
{
for (int x = sx; x < ex; x++)
{
- if (exclude != nullptr && IsExcludeColor(exclude, x,y) ) continue;
+ if (exclude != nullptr && IsExcludeColor(exclude, x,y) )
+ continue;
Color color = img.GetPixel(Math::IntPoint(x, y));
@@ -2905,7 +2939,8 @@ void CEngine::ApplyChange()
viewport, and renders the scene. */
void CEngine::Render()
{
- if (! m_render) return;
+ if (! m_render)
+ return;
m_statisticTriangle = 0;
m_lastState = -1;
@@ -2928,7 +2963,9 @@ void CEngine::Render()
if (m_drawWorld)
Draw3DScene();
+ m_app->StartPerformanceCounter(PCNT_RENDER_INTERFACE);
DrawInterface();
+ m_app->StopPerformanceCounter(PCNT_RENDER_INTERFACE);
// End the scene
m_device->EndScene();
@@ -2959,41 +2996,49 @@ void CEngine::Draw3DScene()
if (m_waterMode) m_water->DrawBack(); // draws water background
+ m_app->StartPerformanceCounter(PCNT_RENDER_TERRAIN);
+
+ // Draw terrain with shadows, if shadows enabled
if (m_shadowVisible)
{
m_lightMan->UpdateDeviceLights(ENG_OBJTYPE_TERRAIN);
- // Draw the terrain
-
- for (int l1 = 0; l1 < static_cast<int>( m_objectTree.size() ); l1++)
+ for (int objRank = 0; objRank < static_cast<int>(m_objects.size()); objRank++)
{
- EngineObjLevel1& p1 = m_objectTree[l1];
- if (! p1.used) continue;
+ if (! m_objects[objRank].used)
+ continue;
- // Should be loaded by now
- SetTexture(p1.tex1, 0);
- SetTexture(p1.tex2, 1);
+ if (m_objects[objRank].type != ENG_OBJTYPE_TERRAIN)
+ continue;
- for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
- {
- EngineObjLevel2& p2 = p1.next[l2];
- if (! p2.used) continue;
+ if (! m_objects[objRank].drawWorld)
+ continue;
- int objRank = p2.objRank;
- if (m_objects[objRank].type != ENG_OBJTYPE_TERRAIN)
- continue;
- if (! m_objects[objRank].drawWorld)
- continue;
+ m_device->SetTransform(TRANSFORM_WORLD, m_objects[objRank].transform);
- m_device->SetTransform(TRANSFORM_WORLD, m_objects[objRank].transform);
+ if (! IsVisible(objRank))
+ continue;
- if (! IsVisible(objRank))
- continue;
+ int baseObjRank = m_objects[objRank].baseObjRank;
+ if (baseObjRank == -1)
+ continue;
+
+ assert(baseObjRank >= 0 && baseObjRank < static_cast<int>( m_baseObjects.size() ));
+
+ EngineBaseObject& p1 = m_baseObjects[baseObjRank];
+ if (! p1.used)
+ continue;
+
+ for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
+ {
+ EngineBaseObjTexTier& p2 = p1.next[l2];
+
+ SetTexture(p2.tex1, 0);
+ SetTexture(p2.tex2, 1);
for (int l3 = 0; l3 < static_cast<int>( p2.next.size() ); l3++)
{
- EngineObjLevel3& p3 = p2.next[l3];
- if (! p3.used) continue;
+ EngineBaseObjLODTier& p3 = p2.next[l3];
if ( m_objects[objRank].distance < p3.min ||
m_objects[objRank].distance >= p3.max )
@@ -3001,26 +3046,12 @@ void CEngine::Draw3DScene()
for (int l4 = 0; l4 < static_cast<int>( p3.next.size() ); l4++)
{
- EngineObjLevel4& p4 = p3.next[l4];
- if (! p4.used) continue;
+ EngineBaseObjDataTier& p4 = p3.next[l4];
SetMaterial(p4.material);
SetState(p4.state);
- if (p4.type == ENG_TRIANGLE_TYPE_TRIANGLES)
- {
- m_device->DrawPrimitive( PRIMITIVE_TRIANGLES,
- &p4.vertices[0],
- p4.vertices.size() );
- m_statisticTriangle += p4.vertices.size() / 3;
- }
- if (p4.type == ENG_TRIANGLE_TYPE_SURFACE)
- {
- m_device->DrawPrimitive( PRIMITIVE_TRIANGLE_STRIP,
- &p4.vertices[0],
- p4.vertices.size() );
- m_statisticTriangle += p4.vertices.size() - 2;
- }
+ DrawObject(p4);
}
}
}
@@ -3030,51 +3061,60 @@ void CEngine::Draw3DScene()
DrawShadow();
}
- // Draw objects (non-terrain)
+ m_app->StopPerformanceCounter(PCNT_RENDER_TERRAIN);
+
+ // Draw other objects (and if shadows disabled, also terrain)
+
+ m_app->StartPerformanceCounter(PCNT_RENDER_OBJECTS);
bool transparent = false;
- for (int l1 = 0; l1 < static_cast<int>( m_objectTree.size() ); l1++)
+ for (int objRank = 0; objRank < static_cast<int>(m_objects.size()); objRank++)
{
- EngineObjLevel1& p1 = m_objectTree[l1];
- if (! p1.used) continue;
+ if (! m_objects[objRank].used)
+ continue;
- // Should be loaded by now
- SetTexture(p1.tex1, 0);
- SetTexture(p1.tex2, 1);
+ if (m_objects[objRank].type == ENG_OBJTYPE_TERRAIN)
+ continue;
- for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
- {
- EngineObjLevel2& p2 = p1.next[l2];
- if (! p2.used) continue;
+ if (! m_objects[objRank].drawWorld)
+ continue;
- int objRank = p2.objRank;
+ m_device->SetTransform(TRANSFORM_WORLD, m_objects[objRank].transform);
- if (m_shadowVisible && m_objects[objRank].type == ENG_OBJTYPE_TERRAIN)
- continue;
+ if (! IsVisible(objRank))
+ continue;
- if (! m_objects[objRank].drawWorld)
- continue;
+ int baseObjRank = m_objects[objRank].baseObjRank;
+ if (baseObjRank == -1)
+ continue;
- m_device->SetTransform(TRANSFORM_WORLD, m_objects[objRank].transform);
+ assert(baseObjRank >= 0 && baseObjRank < static_cast<int>( m_baseObjects.size() ));
- if (! IsVisible(objRank))
- continue;
+ EngineBaseObject& p1 = m_baseObjects[baseObjRank];
+ if (! p1.used)
+ continue;
- m_lightMan->UpdateDeviceLights(m_objects[objRank].type);
+ m_lightMan->UpdateDeviceLights(m_objects[objRank].type);
+
+ for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
+ {
+ EngineBaseObjTexTier& p2 = p1.next[l2];
+
+ SetTexture(p2.tex1, 0);
+ SetTexture(p2.tex2, 1);
for (int l3 = 0; l3 < static_cast<int>( p2.next.size() ); l3++)
{
- EngineObjLevel3& p3 = p2.next[l3];
- if (! p3.used) continue;
+ EngineBaseObjLODTier& p3 = p2.next[l3];
if ( m_objects[objRank].distance < p3.min ||
- m_objects[objRank].distance >= p3.max ) continue;
+ m_objects[objRank].distance >= p3.max )
+ continue;
for (int l4 = 0; l4 < static_cast<int>( p3.next.size() ); l4++)
{
- EngineObjLevel4& p4 = p3.next[l4];
- if (! p4.used) continue;
+ EngineBaseObjDataTier& p4 = p3.next[l4];
if (m_objects[objRank].transparency != 0.0f) // transparent ?
{
@@ -3085,22 +3125,7 @@ void CEngine::Draw3DScene()
SetMaterial(p4.material);
SetState(p4.state);
- if (p4.type == ENG_TRIANGLE_TYPE_TRIANGLES)
- {
- m_device->DrawPrimitive( PRIMITIVE_TRIANGLES,
- &p4.vertices[0],
- p4.vertices.size() );
-
- m_statisticTriangle += p4.vertices.size() / 3;
- }
- else if (p4.type == ENG_TRIANGLE_TYPE_SURFACE)
- {
- m_device->DrawPrimitive( PRIMITIVE_TRIANGLE_STRIP,
- &p4.vertices[0],
- p4.vertices.size() );
-
- m_statisticTriangle += p4.vertices.size() - 2;
- }
+ DrawObject(p4);
}
}
}
@@ -3113,47 +3138,52 @@ void CEngine::Draw3DScene()
int tState = ENG_RSTATE_TTEXTURE_BLACK | ENG_RSTATE_2FACE;
Color tColor = Color(68.0f / 255.0f, 68.0f / 255.0f, 68.0f / 255.0f, 68.0f / 255.0f);
- for (int l1 = 0; l1 < static_cast<int>( m_objectTree.size() ); l1++)
+ for (int objRank = 0; objRank < static_cast<int>(m_objects.size()); objRank++)
{
- EngineObjLevel1& p1 = m_objectTree[l1];
- if (! p1.used) continue;
+ if (! m_objects[objRank].used)
+ continue;
- // Should be loaded by now
- SetTexture(p1.tex1, 0);
- SetTexture(p1.tex2, 1);
+ if (m_objects[objRank].type == ENG_OBJTYPE_TERRAIN)
+ continue;
- for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
- {
- EngineObjLevel2& p2 = p1.next[l2];
- if (! p2.used) continue;
+ if (! m_objects[objRank].drawWorld)
+ continue;
- int objRank = p2.objRank;
+ m_device->SetTransform(TRANSFORM_WORLD, m_objects[objRank].transform);
- if (m_shadowVisible && m_objects[objRank].type == ENG_OBJTYPE_TERRAIN)
- continue;
+ if (! IsVisible(objRank))
+ continue;
- if (! m_objects[objRank].drawWorld)
- continue;
+ int baseObjRank = m_objects[objRank].baseObjRank;
+ if (baseObjRank == -1)
+ continue;
- m_device->SetTransform(TRANSFORM_WORLD, m_objects[objRank].transform);
+ assert(baseObjRank >= 0 && baseObjRank < static_cast<int>( m_baseObjects.size() ));
- if (! IsVisible(objRank))
- continue;
+ EngineBaseObject& p1 = m_baseObjects[baseObjRank];
+ if (! p1.used)
+ continue;
+
+ m_lightMan->UpdateDeviceLights(m_objects[objRank].type);
+
+ for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
+ {
+ EngineBaseObjTexTier& p2 = p1.next[l2];
- m_lightMan->UpdateDeviceLights(m_objects[objRank].type);
+ SetTexture(p2.tex1, 0);
+ SetTexture(p2.tex2, 1);
for (int l3 = 0; l3 < static_cast<int>( p2.next.size() ); l3++)
{
- EngineObjLevel3& p3 = p2.next[l3];
- if (! p3.used) continue;
+ EngineBaseObjLODTier& p3 = p2.next[l3];
- if ( m_objects[objRank].distance < p3.min ||
- m_objects[objRank].distance >= p3.max ) continue;
+ if (m_objects[objRank].distance < p3.min ||
+ m_objects[objRank].distance >= p3.max)
+ continue;
for (int l4 = 0; l4 < static_cast<int>( p3.next.size() ); l4++)
{
- EngineObjLevel4& p4 = p3.next[l4];
- if (! p4.used) continue;
+ EngineBaseObjDataTier& p4 = p3.next[l4];
if (m_objects[objRank].transparency == 0.0f)
continue;
@@ -3161,40 +3191,61 @@ void CEngine::Draw3DScene()
SetMaterial(p4.material);
SetState(tState, tColor);
- if (p4.type == ENG_TRIANGLE_TYPE_TRIANGLES)
- {
- m_device->DrawPrimitive( PRIMITIVE_TRIANGLES,
- &p4.vertices[0],
- p4.vertices.size() );
-
- m_statisticTriangle += p4.vertices.size() / 3;
- }
- else if (p4.type == ENG_TRIANGLE_TYPE_SURFACE)
- {
- m_device->DrawPrimitive( PRIMITIVE_TRIANGLE_STRIP,
- &p4.vertices[0],
- p4.vertices.size() );
- m_statisticTriangle += p4.vertices.size() - 2;
- }
+ DrawObject(p4);
}
}
}
}
}
+ m_app->StopPerformanceCounter(PCNT_RENDER_OBJECTS);
+
m_lightMan->UpdateDeviceLights(ENG_OBJTYPE_TERRAIN);
- if (m_waterMode) m_water->DrawSurf(); // draws water surface
+ if (m_waterMode)
+ {
+ m_app->StartPerformanceCounter(PCNT_RENDER_WATER);
+ m_water->DrawSurf(); // draws water surface
+ m_app->StopPerformanceCounter(PCNT_RENDER_WATER);
+ }
+ m_app->StartPerformanceCounter(PCNT_RENDER_PARTICLE);
m_particle->DrawParticle(SH_WORLD); // draws the particles of the 3D world
+ m_app->StopPerformanceCounter(PCNT_RENDER_PARTICLE);
+
m_lightning->Draw(); // draws lightning
- // TODO: fix white screen error; commenting out temporarily
- // if (m_lensMode) DrawForegroundImage(); // draws the foreground
+ if (m_lensMode) DrawForegroundImage(); // draws the foreground
if (! m_overFront) DrawOverColor(); // draws the foreground color
}
+void CEngine::DrawObject(const EngineBaseObjDataTier& p4)
+{
+ if (p4.staticBufferId != 0)
+ {
+ m_device->DrawStaticBuffer(p4.staticBufferId);
+
+ if (p4.type == ENG_TRIANGLE_TYPE_TRIANGLES)
+ m_statisticTriangle += p4.vertices.size() / 3;
+ else
+ m_statisticTriangle += p4.vertices.size() - 2;
+ }
+ else
+ {
+ if (p4.type == ENG_TRIANGLE_TYPE_TRIANGLES)
+ {
+ m_device->DrawPrimitive(PRIMITIVE_TRIANGLES, &p4.vertices[0], p4.vertices.size());
+ m_statisticTriangle += p4.vertices.size() / 3;
+ }
+ else
+ {
+ m_device->DrawPrimitive(PRIMITIVE_TRIANGLE_STRIP, &p4.vertices[0], p4.vertices.size() );
+ m_statisticTriangle += p4.vertices.size() - 2;
+ }
+ }
+}
+
void CEngine::DrawInterface()
{
m_device->SetRenderState(RENDER_STATE_DEPTH_TEST, false);
@@ -3240,66 +3291,57 @@ void CEngine::DrawInterface()
m_device->SetTransform(TRANSFORM_VIEW, m_matView);
- for (int l1 = 0; l1 < static_cast<int>( m_objectTree.size() ); l1++)
+ for (int objRank = 0; objRank < static_cast<int>(m_objects.size()); objRank++)
{
- EngineObjLevel1& p1 = m_objectTree[l1];
- if (! p1.used) continue;
+ if (! m_objects[objRank].used)
+ continue;
- // Should be loaded by now
- SetTexture(p1.tex1, 0);
- SetTexture(p1.tex2, 1);
+ if (m_shadowVisible && m_objects[objRank].type == ENG_OBJTYPE_TERRAIN)
+ continue;
- for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
- {
- EngineObjLevel2& p2 = p1.next[l2];
- if (! p2.used) continue;
+ if (! m_objects[objRank].drawFront)
+ continue;
- int objRank = p2.objRank;
+ m_device->SetTransform(TRANSFORM_WORLD, m_objects[objRank].transform);
- if (m_shadowVisible && m_objects[objRank].type == ENG_OBJTYPE_TERRAIN)
- continue;
+ if (! IsVisible(objRank))
+ continue;
- if (! m_objects[objRank].drawFront)
- continue;
+ int baseObjRank = m_objects[objRank].baseObjRank;
+ if (baseObjRank == -1)
+ continue;
- m_device->SetTransform(TRANSFORM_WORLD, m_objects[objRank].transform);
+ assert(baseObjRank >= 0 && baseObjRank < static_cast<int>( m_baseObjects.size() ));
- if (! IsVisible(objRank))
- continue;
+ EngineBaseObject& p1 = m_baseObjects[baseObjRank];
+ if (! p1.used)
+ continue;
- m_lightMan->UpdateDeviceLights(m_objects[objRank].type);
+ m_lightMan->UpdateDeviceLights(m_objects[objRank].type);
+
+ for (int l2 = 0; l2 < static_cast<int>( p1.next.size() ); l2++)
+ {
+ EngineBaseObjTexTier& p2 = p1.next[l2];
+
+ SetTexture(p2.tex1, 0);
+ SetTexture(p2.tex2, 1);
for (int l3 = 0; l3 < static_cast<int>( p2.next.size() ); l3++)
{
- EngineObjLevel3& p3 = p2.next[l3];
- if (! p3.used) continue;
+ EngineBaseObjLODTier& p3 = p2.next[l3];
- if ( m_objects[objRank].distance < p3.min ||
- m_objects[objRank].distance >= p3.max ) continue;
+ if (m_objects[objRank].distance < p3.min ||
+ m_objects[objRank].distance >= p3.max)
+ continue;
for (int l4 = 0; l4 < static_cast<int>( p3.next.size() ); l4++)
{
- EngineObjLevel4& p4 = p3.next[l4];
- if (! p4.used) continue;
+ EngineBaseObjDataTier& p4 = p3.next[l4];
SetMaterial(p4.material);
SetState(p4.state);
- if (p4.type == ENG_TRIANGLE_TYPE_TRIANGLES)
- {
- m_device->DrawPrimitive( PRIMITIVE_TRIANGLES,
- &p4.vertices[0],
- p4.vertices.size() );
-
- m_statisticTriangle += p4.vertices.size() / 3;
- }
- else if (p4.type == ENG_TRIANGLE_TYPE_SURFACE)
- {
- m_device->DrawPrimitive( PRIMITIVE_TRIANGLE_STRIP,
- &p4.vertices[0],
- p4.vertices.size() );
- m_statisticTriangle += p4.vertices.size() - 2;
- }
+ DrawObject(p4);
}
}
}
@@ -3328,8 +3370,270 @@ void CEngine::DrawInterface()
void CEngine::UpdateGroundSpotTextures()
{
- // TODO the original code modifying the textures is very complex, so stub for now
- GetLogger()->Trace("CEngine::UpdateGroundSpotTextures(): stub!\n");
+ if (!m_firstGroundSpot &&
+ m_groundMark.drawPos.x == m_groundMark.pos.x &&
+ m_groundMark.drawPos.z == m_groundMark.pos.z &&
+ m_groundMark.drawRadius == m_groundMark.radius &&
+ m_groundMark.drawIntensity == m_groundMark.intensity)
+ return;
+
+ for (int s = 0; s < 16; s++)
+ {
+ Math::Point min, max;
+ min.x = (s%4) * 254.0f - 1.0f; // 1 pixel cover
+ min.y = (s/4) * 254.0f - 1.0f;
+ max.x = min.x + 254.0f + 2.0f;
+ max.y = min.y + 254.0f + 2.0f;
+
+ bool clear = false;
+ bool set = false;
+
+ // Calculate the area to be erased.
+ int dot = static_cast<int>(m_groundMark.drawRadius/2.0f);
+
+ float tu, tv;
+ float cx, cy;
+
+ tu = (m_groundMark.drawPos.x+1600.0f)/3200.0f;
+ tv = (m_groundMark.drawPos.z+1600.0f)/3200.0f; // 0..1
+
+ cx = (tu*254.0f*4.0f)-0.5f;
+ cy = (tv*254.0f*4.0f)-0.5f;
+
+ if (dot == 0)
+ {
+ cx += 0.5f;
+ cy += 0.5f;
+ }
+
+ float px = cx-Math::Mod(cx, 1.0f);
+ float py = cy-Math::Mod(cy, 1.0f); // multiple of 1
+
+ if (m_firstGroundSpot ||
+ (m_groundMark.drawRadius != 0.0f &&
+ px+dot >= min.x && py+dot >= min.y &&
+ px-dot <= max.x && py-dot <= max.y))
+ {
+ clear = true;
+ }
+
+ // Calculate the area to draw.
+ dot = static_cast<int>(m_groundMark.radius/2.0f);
+
+ tu = (m_groundMark.pos.x+1600.0f)/3200.0f;
+ tv = (m_groundMark.pos.z+1600.0f)/3200.0f; // 0..1
+
+ cx = (tu*254.0f*4.0f)-0.5f;
+ cy = (tv*254.0f*4.0f)-0.5f;
+
+ if ( dot == 0 )
+ {
+ cx += 0.5f;
+ cy += 0.5f;
+ }
+
+ px = cx - Math::Mod(cx, 1.0f);
+ py = cy - Math::Mod(cy, 1.0f); // multiple of 1
+
+ if (m_groundMark.draw &&
+ px+dot >= min.x && py+dot >= min.y &&
+ px-dot <= max.x && py-dot <= max.y)
+ {
+ set = true;
+ }
+
+ if (clear || set)
+ {
+ CImage shadowImg(Math::IntPoint(256, 256));
+ shadowImg.Fill(Gfx::IntColor(255, 255, 255, 255));
+
+ // Draw the new shadows.
+ for (int i = 0; i < static_cast<int>( m_groundSpots.size() ); i++)
+ {
+ if (m_groundSpots[i].used == false ||
+ m_groundSpots[i].radius == 0.0f)
+ continue;
+
+ if (m_groundSpots[i].min == 0.0f &&
+ m_groundSpots[i].max == 0.0f)
+ {
+ dot = static_cast<int>(m_groundSpots[i].radius/2.0f);
+
+ tu = (m_groundSpots[i].pos.x+1600.0f)/3200.0f;
+ tv = (m_groundSpots[i].pos.z+1600.0f)/3200.0f; // 0..1
+
+ cx = (tu*254.0f*4.0f) - 0.5f;
+ cy = (tv*254.0f*4.0f) - 0.5f;
+
+ if (dot == 0)
+ {
+ cx += 0.5f;
+ cy += 0.5f;
+ }
+
+ px = cx-Math::Mod(cx, 1.0f);
+ py = cy-Math::Mod(cy, 1.0f); // multiple of 1
+
+ if (px+dot < min.x || py+dot < min.y ||
+ px-dot > max.x || py-dot > max.y)
+ continue;
+
+ for (int iy = -dot; iy <= dot; iy++)
+ {
+ for (int ix =- dot; ix <= dot; ix++)
+ {
+ float ppx = px+ix;
+ float ppy = py+iy;
+
+ if (ppx < min.x || ppy < min.y ||
+ ppx >= max.x || ppy >= max.y)
+ continue;
+
+ float intensity;
+ if (dot == 0)
+ intensity = 0.0f;
+ else
+ intensity = Math::Point(ppx-cx, ppy-cy).Length()/dot;
+
+ Gfx::Color color;
+ color.r = Math::Norm(m_groundSpots[i].color.r+intensity);
+ color.g = Math::Norm(m_groundSpots[i].color.g+intensity);
+ color.b = Math::Norm(m_groundSpots[i].color.b+intensity);
+
+ ppx -= min.x; // on the texture
+ ppy -= min.y;
+
+ shadowImg.SetPixel(Math::IntPoint(ppx, ppy), color);
+ }
+ }
+ }
+ else
+ {
+ for (int iy = 0; iy < 256; iy++)
+ {
+ for (int ix = 0; ix < 256; ix++)
+ {
+ Math::Vector pos;
+ pos.x = (256.0f * (s%4) + ix) * 3200.0f/1024.0f - 1600.0f;
+ pos.z = (256.0f * (s/4) + iy) * 3200.0f/1024.0f - 1600.0f;
+ pos.y = 0.0f;
+
+ float level = m_terrain->GetFloorLevel(pos, true);
+ if (level < m_groundSpots[i].min ||
+ level > m_groundSpots[i].max)
+ continue;
+
+ float intensity;
+ if (level > (m_groundSpots[i].max+m_groundSpots[i].min)/2.0f)
+ intensity = 1.0f - (m_groundSpots[i].max-level) / m_groundSpots[i].smooth;
+ else
+ intensity = 1.0f - (level-m_groundSpots[i].min) / m_groundSpots[i].smooth;
+
+ if (intensity < 0.0f) intensity = 0.0f;
+
+ Gfx::Color color;
+ color.r = Math::Norm(m_groundSpots[i].color.r+intensity);
+ color.g = Math::Norm(m_groundSpots[i].color.g+intensity);
+ color.b = Math::Norm(m_groundSpots[i].color.b+intensity);
+
+ shadowImg.SetPixel(Math::IntPoint(ix, iy), color);
+ }
+ }
+ }
+ }
+
+ if (set)
+ {
+ dot = static_cast<int>(m_groundMark.radius/2.0f);
+
+ tu = (m_groundMark.pos.x + 1600.0f) / 3200.0f;
+ tv = (m_groundMark.pos.z + 1600.0f) / 3200.0f; // 0..1
+
+ cx = (tu*254.0f*4.0f)-0.5f;
+ cy = (tv*254.0f*4.0f)-0.5f;
+
+ if (dot == 0)
+ {
+ cx += 0.5f;
+ cy += 0.5f;
+ }
+
+ px = cx-Math::Mod(cx, 1.0f);
+ py = cy-Math::Mod(cy, 1.0f); // multiple of 1
+
+ for (int iy = -dot; iy <= dot; iy++)
+ {
+ for (int ix = -dot; ix <= dot; ix++)
+ {
+ float ppx = px+ix;
+ float ppy = py+iy;
+
+ if (ppx < min.x || ppy < min.y ||
+ ppx >= max.x || ppy >= max.y)
+ continue;
+
+ ppx -= min.x; // on the texture
+ ppy -= min.y;
+
+ float intensity = 1.0f - Math::Point(ix, iy).Length() / dot;
+ if (intensity <= 0.0f)
+ continue;
+
+ intensity *= m_groundMark.intensity;
+
+ int j = (ix+dot) + (iy+dot) * m_groundMark.dx;
+ if (m_groundMark.table[j] == 1) // green ?
+ {
+ Gfx::Color color;
+ color.r = Math::Norm(1.0f-intensity);
+ color.g = 1.0f;
+ color.b = Math::Norm(1.0f-intensity);
+ shadowImg.SetPixel(Math::IntPoint(ppx, ppy), color);
+ }
+ if (m_groundMark.table[j] == 2) // red ?
+ {
+ Gfx::Color color;
+ color.r = 1.0f;
+ color.g = Math::Norm(1.0f-intensity);
+ color.b = Math::Norm(1.0f-intensity);
+ shadowImg.SetPixel(Math::IntPoint(ppx, ppy), color);
+ }
+ }
+ }
+ }
+
+ std::stringstream str;
+ str << "shadow" << std::setfill('0') << std::setw(2) << s << ".png";
+ std::string texName = str.str();
+
+ DeleteTexture(texName);
+
+ Gfx::Texture tex = m_device->CreateTexture(&shadowImg, m_defaultTexParams);
+
+ m_texNameMap[texName] = tex;
+ m_revTexNameMap[tex] = texName;
+ }
+ }
+
+ for (int i = 0; i < static_cast<int>( m_groundSpots.size() ); i++)
+ {
+ if (m_groundSpots[i].used == false ||
+ m_groundSpots[i].radius == 0.0f)
+ {
+ m_groundSpots[i].drawRadius = 0.0f;
+ }
+ else
+ {
+ m_groundSpots[i].drawPos = m_groundSpots[i].pos;
+ m_groundSpots[i].drawRadius = m_groundSpots[i].radius;
+ }
+ }
+
+ m_groundMark.drawPos = m_groundMark.pos;
+ m_groundMark.drawRadius = m_groundMark.radius;
+ m_groundMark.drawIntensity = m_groundMark.intensity;
+
+ m_firstGroundSpot = false;
}
void CEngine::DrawShadow()
@@ -3366,11 +3670,13 @@ void CEngine::DrawShadow()
float lastIntensity = -1.0f;
for (int i = 0; i < static_cast<int>( m_shadows.size() ); i++)
{
- if (m_shadows[i].hide) continue;
+ if (m_shadows[i].hide)
+ continue;
Math::Vector pos = m_shadows[i].pos; // pos = center of the shadow on the ground
- if (m_eyePt.y == pos.y) continue; // camera at the same level?
+ if (m_eyePt.y == pos.y)
+ continue; // camera at the same level?
float d = 0.0f;
float D = 0.0f;
@@ -3386,7 +3692,9 @@ void CEngine::DrawShadow()
if ( h > 4.0f ) h = 4.0f;
D = Math::Distance(m_eyePt, pos);
- if ( D >= endDeepView ) continue;
+ if (D >= endDeepView)
+ continue;
+
d = D*h/height;
pos.x += (m_eyePt.x-pos.x)*d/D;
@@ -3402,7 +3710,9 @@ void CEngine::DrawShadow()
if ( h > 4.0f ) h = 4.0f;
D = Math::Distance(m_eyePt, pos);
- if ( D >= endDeepView ) continue;
+ if (D >= endDeepView)
+ continue;
+
d = D*h/height;
pos.x += (m_eyePt.x-pos.x)*d/D;
@@ -3510,7 +3820,8 @@ void CEngine::DrawShadow()
if ( D > startDeepView )
intensity *= 1.0f-(D-startDeepView)/(endDeepView-startDeepView);
- if (intensity == 0.0f) continue;
+ if (intensity == 0.0f)
+ continue;
if (lastIntensity != intensity) // intensity changed?
{
@@ -3526,7 +3837,6 @@ void CEngine::DrawShadow()
m_device->SetRenderState(RENDER_STATE_LIGHTING, true);
}
-// STATUS: TESTED, VERIFIED
void CEngine::DrawBackground()
{
if (m_skyMode && m_cloud->GetLevel() != 0.0f) // clouds ?
@@ -3546,7 +3856,6 @@ void CEngine::DrawBackground()
}
}
-// STATUS: TESTED
void CEngine::DrawBackgroundGradient(const Color& up, const Color& down)
{
Math::Point p1(0.0f, 0.5f);
@@ -3577,7 +3886,6 @@ void CEngine::DrawBackgroundGradient(const Color& up, const Color& down)
AddStatisticTriangle(2);
}
-// Status: TESTED, VERIFIED
void CEngine::DrawBackgroundImage()
{
Math::Point p1, p2;
@@ -3586,7 +3894,7 @@ void CEngine::DrawBackgroundImage()
p2.x = 1.0f;
p2.y = 1.0f;
-Math::Vector n = Math::Vector(0.0f, 0.0f, -1.0f); // normal
+ Math::Vector n = Math::Vector(0.0f, 0.0f, -1.0f); // normal
float u1, u2, v1, v2;
if (m_backgroundFull)
@@ -3635,7 +3943,8 @@ Math::Vector n = Math::Vector(0.0f, 0.0f, -1.0f); // normal
void CEngine::DrawPlanet()
{
- if (! m_planet->PlanetExist()) return;
+ if (! m_planet->PlanetExist())
+ return;
m_device->SetRenderState(RENDER_STATE_DEPTH_WRITE, false);
m_device->SetRenderState(RENDER_STATE_LIGHTING, false);
@@ -3648,10 +3957,10 @@ void CEngine::DrawPlanet()
m_planet->Draw(); // draws the planets
}
-// Status: PART_TESTED
void CEngine::DrawForegroundImage()
{
- if (m_foregroundName.empty()) return;
+ if (m_foregroundName.empty())
+ return;
Math::Vector n = Math::Vector(0.0f, 0.0f, -1.0f); // normal
@@ -3684,12 +3993,11 @@ void CEngine::DrawForegroundImage()
AddStatisticTriangle(2);
}
-// Status: PART_TESTED
void CEngine::DrawOverColor()
{
- // TODO: fuzzy compare?
- if ( (m_overColor == Color(0.0f, 0.0f, 0.0f, 0.0f) && m_overMode == ENG_RSTATE_TCOLOR_BLACK) ||
- (m_overColor == Color(1.0f, 1.0f, 1.0f, 1.0f) && m_overMode == ENG_RSTATE_TCOLOR_WHITE) ) return;
+ if ((m_overColor == Color(0.0f, 0.0f, 0.0f, 0.0f) && m_overMode == ENG_RSTATE_TCOLOR_BLACK) ||
+ (m_overColor == Color(1.0f, 1.0f, 1.0f, 1.0f) && m_overMode == ENG_RSTATE_TCOLOR_WHITE))
+ return;
Math::Point p1(0.0f, 0.0f);
Math::Point p2(1.0f, 1.0f);
@@ -3703,11 +4011,6 @@ void CEngine::DrawOverColor()
SetState(m_overMode);
- // TODO: set also with m_overMode ?
- m_device->SetRenderState(RENDER_STATE_DEPTH_WRITE, false);
- m_device->SetRenderState(RENDER_STATE_LIGHTING, false);
- m_device->SetRenderState(RENDER_STATE_FOG, false);
-
m_device->SetTransform(TRANSFORM_VIEW, m_matViewInterface);
m_device->SetTransform(TRANSFORM_PROJECTION, m_matProjInterface);
m_device->SetTransform(TRANSFORM_WORLD, m_matWorldInterface);
@@ -3724,7 +4027,6 @@ void CEngine::DrawOverColor()
AddStatisticTriangle(2);
}
-// Status: TESTED, VERIFIED
void CEngine::DrawHighlight()
{
Math::Point min, max;
@@ -3816,7 +4118,6 @@ void CEngine::DrawHighlight()
m_device->DrawPrimitive(PRIMITIVE_LINE_STRIP, line, 3);
}
-// Status: TESTED, VERIFIED
void CEngine::DrawMouse()
{
MouseMode mode = m_app->GetMouseMode();
@@ -3850,7 +4151,6 @@ void CEngine::DrawMouse()
DrawMouseSprite(pos, m_mouseSize, m_mice[index].icon2);
}
-// Status: TESTED, VERIFIED
void CEngine::DrawMouseSprite(Math::Point pos, Math::Point size, int icon)
{
if (icon == -1)
@@ -3889,15 +4189,10 @@ void CEngine::DrawStats()
if (!m_showStats)
return;
- std::stringstream str;
- str << "Triangles: ";
- str << m_statisticTriangle;
- std::string triangleText = str.str();
-
float height = m_text->GetAscent(FONT_COLOBOT, 12.0f);
float width = 0.2f;
- Math::Point pos(0.04f, 0.04f + height);
+ Math::Point pos(0.04f, 0.04f + 17 * height);
SetState(ENG_RSTATE_OPAQUE_COLOR);
@@ -3905,9 +4200,9 @@ void CEngine::DrawStats()
VertexCol vertex[4] =
{
- VertexCol(Math::Vector(pos.x , pos.y - height, 0.0f), black),
+ VertexCol(Math::Vector(pos.x , pos.y - 17 * height, 0.0f), black),
VertexCol(Math::Vector(pos.x , pos.y + height, 0.0f), black),
- VertexCol(Math::Vector(pos.x + width, pos.y - height, 0.0f), black),
+ VertexCol(Math::Vector(pos.x + width, pos.y - 17 * height, 0.0f), black),
VertexCol(Math::Vector(pos.x + width, pos.y + height, 0.0f), black)
};
@@ -3915,7 +4210,107 @@ void CEngine::DrawStats()
SetState(ENG_RSTATE_TEXT);
- m_text->DrawText(triangleText, FONT_COLOBOT, 12.0f, pos, 1.0f, TEXT_ALIGN_LEFT, 0, Color(1.0f, 1.0f, 1.0f, 1.0f));
+ std::stringstream str;
+
+ str.str("");
+ str << "Event processing: " << std::fixed << std::setprecision(2) << m_app->GetPerformanceCounterData(PCNT_EVENT_PROCESSING);
+ m_text->DrawText(str.str(), FONT_COLOBOT, 12.0f, pos, 1.0f, TEXT_ALIGN_LEFT, 0, Color(1.0f, 1.0f, 1.0f, 1.0f));
+
+ pos.y -= height;
+ pos.y -= height;
+
+
+ str.str("");
+ str << "Frame update: " << std::fixed << std::setprecision(2) << m_app->GetPerformanceCounterData(PCNT_UPDATE_ALL);
+ m_text->DrawText(str.str(), FONT_COLOBOT, 12.0f, pos, 1.0f, TEXT_ALIGN_LEFT, 0, Color(1.0f, 1.0f, 1.0f, 1.0f));
+
+ pos.y -= height;
+
+ str.str("");
+ str << "Engine update: " << std::fixed << std::setprecision(2) << m_app->GetPerformanceCounterData(PCNT_UPDATE_ENGINE);
+ m_text->DrawText(str.str(), FONT_COLOBOT, 12.0f, pos, 1.0f, TEXT_ALIGN_LEFT, 0, Color(1.0f, 1.0f, 1.0f, 1.0f));
+
+ pos.y -= height;
+
+ str.str("");
+ str << "Particle update: " << std::fixed << std::setprecision(2) << m_app->GetPerformanceCounterData(PCNT_UPDATE_PARTICLE);
+ m_text->DrawText(str.str(), FONT_COLOBOT, 12.0f, pos, 1.0f, TEXT_ALIGN_LEFT, 0, Color(1.0f, 1.0f, 1.0f, 1.0f));
+
+ pos.y -= height;
+
+ str.str("");
+ str << "Game update: " << std::fixed << std::setprecision(2) << m_app->GetPerformanceCounterData(PCNT_UPDATE_GAME);
+ m_text->DrawText(str.str(), FONT_COLOBOT, 12.0f, pos, 1.0f, TEXT_ALIGN_LEFT, 0, Color(1.0f, 1.0f, 1.0f, 1.0f));
+
+ pos.y -= height;
+
+ float otherUpdate = Math::Max(0.0f, m_app->GetPerformanceCounterData(PCNT_UPDATE_ALL) -
+ m_app->GetPerformanceCounterData(PCNT_UPDATE_ENGINE) -
+ m_app->GetPerformanceCounterData(PCNT_UPDATE_PARTICLE) -
+ m_app->GetPerformanceCounterData(PCNT_UPDATE_GAME));
+
+ str.str("");
+ str << "Other update: " << std::fixed << std::setprecision(2) << otherUpdate;
+ m_text->DrawText(str.str(), FONT_COLOBOT, 12.0f, pos, 1.0f, TEXT_ALIGN_LEFT, 0, Color(1.0f, 1.0f, 1.0f, 1.0f));
+
+ pos.y -= height;
+ pos.y -= height;
+
+
+ str.str("");
+ str << "Frame render: " << std::fixed << std::setprecision(2) << m_app->GetPerformanceCounterData(PCNT_RENDER_ALL);
+ m_text->DrawText(str.str(), FONT_COLOBOT, 12.0f, pos, 1.0f, TEXT_ALIGN_LEFT, 0, Color(1.0f, 1.0f, 1.0f, 1.0f));
+
+ pos.y -= height;
+
+ str.str("");
+ str << "Particle render: " << std::fixed << std::setprecision(2) << m_app->GetPerformanceCounterData(PCNT_RENDER_PARTICLE);
+ m_text->DrawText(str.str(), FONT_COLOBOT, 12.0f, pos, 1.0f, TEXT_ALIGN_LEFT, 0, Color(1.0f, 1.0f, 1.0f, 1.0f));
+
+ pos.y -= height;
+
+ str.str("");
+ str << "Water render: " << std::fixed << std::setprecision(2) << m_app->GetPerformanceCounterData(PCNT_RENDER_WATER);
+ m_text->DrawText(str.str(), FONT_COLOBOT, 12.0f, pos, 1.0f, TEXT_ALIGN_LEFT, 0, Color(1.0f, 1.0f, 1.0f, 1.0f));
+
+ pos.y -= height;
+
+ str.str("");
+ str << "Terrain render: " << std::fixed << std::setprecision(2) << m_app->GetPerformanceCounterData(PCNT_RENDER_TERRAIN);
+ m_text->DrawText(str.str(), FONT_COLOBOT, 12.0f, pos, 1.0f, TEXT_ALIGN_LEFT, 0, Color(1.0f, 1.0f, 1.0f, 1.0f));
+
+ pos.y -= height;
+
+ str.str("");
+ str << "Objects render: " << std::fixed << std::setprecision(2) << m_app->GetPerformanceCounterData(PCNT_RENDER_OBJECTS);
+ m_text->DrawText(str.str(), FONT_COLOBOT, 12.0f, pos, 1.0f, TEXT_ALIGN_LEFT, 0, Color(1.0f, 1.0f, 1.0f, 1.0f));
+
+ pos.y -= height;
+
+ str.str("");
+ str << "UI render: " << std::fixed << std::setprecision(2) << m_app->GetPerformanceCounterData(PCNT_RENDER_INTERFACE);
+ m_text->DrawText(str.str(), FONT_COLOBOT, 12.0f, pos, 1.0f, TEXT_ALIGN_LEFT, 0, Color(1.0f, 1.0f, 1.0f, 1.0f));
+
+ pos.y -= height;
+
+ float otherRender = m_app->GetPerformanceCounterData(PCNT_RENDER_ALL) -
+ m_app->GetPerformanceCounterData(PCNT_RENDER_PARTICLE) -
+ m_app->GetPerformanceCounterData(PCNT_RENDER_WATER) -
+ m_app->GetPerformanceCounterData(PCNT_RENDER_TERRAIN) -
+ m_app->GetPerformanceCounterData(PCNT_RENDER_OBJECTS) -
+ m_app->GetPerformanceCounterData(PCNT_RENDER_INTERFACE);
+
+ str.str("");
+ str << "Other render: " << std::fixed << std::setprecision(2) << otherRender;
+ m_text->DrawText(str.str(), FONT_COLOBOT, 12.0f, pos, 1.0f, TEXT_ALIGN_LEFT, 0, Color(1.0f, 1.0f, 1.0f, 1.0f));
+
+ pos.y -= height;
+ pos.y -= height;
+
+
+ str.str("");
+ str << "Triangles: " << m_statisticTriangle;
+ m_text->DrawText(str.str(), FONT_COLOBOT, 12.0f, pos, 1.0f, TEXT_ALIGN_LEFT, 0, Color(1.0f, 1.0f, 1.0f, 1.0f));
pos.y -= height;
diff --git a/src/graphics/engine/engine.h b/src/graphics/engine/engine.h
index 27f0173..c9391db 100644
--- a/src/graphics/engine/engine.h
+++ b/src/graphics/engine/engine.h
@@ -151,7 +151,7 @@ struct EngineTriangle
//! 2nd texture
std::string tex2Name;
- EngineTriangle()
+ inline EngineTriangle()
{
state = ENG_RSTATE_NORMAL;
}
@@ -178,6 +178,92 @@ enum EngineObjectType
ENG_OBJTYPE_METAL = 6
};
+
+/**
+ * \struct EngineBaseObjDataTier
+ * \brief Tier 4 of object tree (data)
+ */
+struct EngineBaseObjDataTier
+{
+ EngineTriangleType type;
+ Material material;
+ int state;
+ std::vector<VertexTex2> vertices;
+ unsigned int staticBufferId;
+ bool updateStaticBuffer;
+
+ inline EngineBaseObjDataTier(EngineTriangleType type = ENG_TRIANGLE_TYPE_TRIANGLES,
+ const Material& material = Material(),
+ int state = ENG_RSTATE_NORMAL)
+ : type(type), material(material), state(state), staticBufferId(0), updateStaticBuffer(false) {}
+};
+
+/**
+ * \struct EngineBaseObjLODTier
+ * \brief Tier 3 of base object tree (LOD)
+ */
+struct EngineBaseObjLODTier
+{
+ float min;
+ float max;
+ std::vector<EngineBaseObjDataTier> next;
+
+ inline EngineBaseObjLODTier(float min = 0.0f, float max = 0.0f)
+ : min(min), max(max) {}
+};
+
+/**
+ * \struct EngineBaseObjTexTier
+ * \brief Tier 2 of base object tree (textures)
+ */
+struct EngineBaseObjTexTier
+{
+ std::string tex1Name;
+ Texture tex1;
+ std::string tex2Name;
+ Texture tex2;
+ std::vector<EngineBaseObjLODTier> next;
+
+ inline EngineBaseObjTexTier(const std::string& tex1Name = "", const std::string& tex2Name = "")
+ : tex1Name(tex1Name), tex2Name(tex2Name) {}
+};
+
+/**
+ * \struct BaseEngineObject
+ * \brief Base (template) object - geometry for engine objects
+ *
+ * This is also the tier 1 of base object tree.
+ */
+struct EngineBaseObject
+{
+ //! If true, base object is valid in objects vector
+ bool used;
+ //! Number of triangles
+ int totalTriangles;
+ //! Bounding box min (origin 0,0,0 always included)
+ Math::Vector bboxMin;
+ //! bounding box max (origin 0,0,0 always included)
+ Math::Vector bboxMax;
+ //! Radius of the sphere at the origin
+ float radius;
+ //! Next tier (LOD)
+ std::vector<EngineBaseObjTexTier> next;
+
+ inline EngineBaseObject()
+ {
+ LoadDefault();
+ }
+
+ inline void LoadDefault()
+ {
+ used = false;
+ totalTriangles = 0;
+ bboxMax.LoadZero();
+ bboxMin.LoadZero();
+ radius = 0.0f;
+ }
+};
+
/**
* \struct EngineObject
* \brief Object drawn by the graphics engine
@@ -186,33 +272,27 @@ struct EngineObject
{
//! If true, object is valid in objects vector
bool used;
+ //! Rank of associated base engine object
+ int baseObjRank;
//! If true, the object is drawn
bool visible;
//! If true, object is behind the 2D interface
bool drawWorld;
//! If true, the shape is before the 2D interface
bool drawFront;
- //! Number of triangles
- int totalTriangles;
//! Type of object
- EngineObjectType type;
+ EngineObjectType type;
//! Transformation matrix
Math::Matrix transform;
//! Distance to object from eye point
float distance;
- //! Bounding box min (origin 0,0,0 always included)
- Math::Vector bboxMin;
- //! bounding box max (origin 0,0,0 always included)
- Math::Vector bboxMax;
- //! Radius of the sphere at the origin
- float radius;
//! Rank of the associated shadow
int shadowRank;
//! Transparency of the object [0, 1]
float transparency;
//! Calls LoadDefault()
- EngineObject()
+ inline EngineObject()
{
LoadDefault();
}
@@ -221,88 +301,18 @@ struct EngineObject
inline void LoadDefault()
{
used = false;
+ baseObjRank = -1;
visible = false;
drawWorld = false;
drawFront = false;
- totalTriangles = 0;
type = ENG_OBJTYPE_NULL;
transform.LoadIdentity();
- bboxMax.LoadZero();
- bboxMin.LoadZero();
distance = 0.0f;
- radius = 0.0f;
shadowRank = -1;
transparency = 0.0f;
}
};
-struct EngineObjLevel1;
-struct EngineObjLevel2;
-struct EngineObjLevel3;
-struct EngineObjLevel4;
-
-/**
- * \struct EngineObjLevel4
- * \brief Tier 4 of object tree
- */
-struct EngineObjLevel4
-{
- bool used;
- EngineTriangleType type;
- Material material;
- int state;
- std::vector<VertexTex2> vertices;
-
- EngineObjLevel4(bool used = false,
- EngineTriangleType type = ENG_TRIANGLE_TYPE_TRIANGLES,
- const Material& material = Material(),
- int state = ENG_RSTATE_NORMAL);
-};
-
-/**
- * \struct EngineObjLevel3
- * \brief Tier 3 of object tree
- */
-struct EngineObjLevel3
-{
- bool used;
- float min;
- float max;
- std::vector<EngineObjLevel4> next;
-
- EngineObjLevel3(bool used = false, float min = 0.0f, float max = 0.0f);
-};
-
-/**
- * \struct EngineObjLevel2
- * \brief Tier 2 of object tree
- */
-struct EngineObjLevel2
-{
- bool used;
- int objRank;
- std::vector<EngineObjLevel3> next;
-
- EngineObjLevel2(bool used = false, int objRank = -1);
-};
-
-/**
- * \struct EngineObjLevel1
- * \brief Tier 1 of object tree
- */
-struct EngineObjLevel1
-{
- bool used;
- std::string tex1Name;
- Texture tex1;
- std::string tex2Name;
- Texture tex2;
- std::vector<EngineObjLevel2> next;
-
- EngineObjLevel1(bool used = false, const std::string& tex1Name = "",
- const std::string& tex2Name = "");
-};
-
/**
* \struct EngineShadowType
* \brief Type of shadow drawn by the graphics engine
@@ -342,12 +352,12 @@ struct EngineShadow
//! Height from the ground
float height;
- EngineShadow()
+ inline EngineShadow()
{
LoadDefault();
}
- void LoadDefault()
+ inline void LoadDefault()
{
used = false;
hide = false;
@@ -384,12 +394,12 @@ struct EngineGroundSpot
//! Radius of the shadow drawn
float drawRadius;
- EngineGroundSpot()
+ inline EngineGroundSpot()
{
LoadDefault();
}
- void LoadDefault()
+ inline void LoadDefault()
{
used = false;
color = Color();
@@ -448,12 +458,12 @@ struct EngineGroundMark
//! Pointer to the table
char* table;
- EngineGroundMark()
+ inline EngineGroundMark()
{
LoadDefault();
}
- void LoadDefault()
+ inline void LoadDefault()
{
draw = false;
phase = ENG_GR_MARK_PHASE_NULL;
@@ -545,10 +555,10 @@ struct EngineMouse
//! Hot point
Math::Point hotPoint;
- EngineMouse(int icon1 = -1, int icon2 = -1, int iconShadow = -1,
- EngineRenderState mode1 = ENG_RSTATE_NORMAL,
- EngineRenderState mode2 = ENG_RSTATE_NORMAL,
- Math::Point hotPoint = Math::Point())
+ inline EngineMouse(int icon1 = -1, int icon2 = -1, int iconShadow = -1,
+ EngineRenderState mode1 = ENG_RSTATE_NORMAL,
+ EngineRenderState mode2 = ENG_RSTATE_NORMAL,
+ Math::Point hotPoint = Math::Point())
{
this->icon1 = icon1;
this->icon2 = icon2;
@@ -609,27 +619,36 @@ struct EngineMouse
*
* Objects are uniquely identified by object rank obtained at object creation. Creating an
* object equals to allocating space for EngineObject structure which holds object parameters.
- * Object's geometric data is stored in a separate structure - a 4-tier tree which splits
- * the information of each geometric triangle.
+ *
+ * Object's geometric data is stored as a separate object -- base engine object. Each object
+ * must reference a valid base engine object or an empty base engine object (with rank = -1).
+ * This many-to-one association allows to share same geometric data (e.g. from same model)
+ * across objects.
+ *
+ * Base engine object data is stored in a 4-tier tree which splits the data describing triangles.
*
* The 4 tiers contain the following information:
- * - level 1 (EngineObjLevel1) - two textures (names and structs) applied to triangles,
- * - level 2 (EngineObjLevel2) - object rank
- * - level 3 (EngineObjLevel3) - minumum and maximum LOD (=level of detail)
- * - level 4 (EngineObjLevel4) - type of object*, material, render state and the actual triangle data
+ * - level 1 (EngineBaseObject) - geometric statistics
+ * - level 2 (EngineBaseObjTexTier) - two textures (names and structs) applied to triangles,
+ * - level 3 (EngineBaseObjLODTier) - minumum and maximum LOD (=level of detail)
+ * - level 4 (EngineBaseObjDataTier) - type of object*, material, render state and the actual vertex data
*
- * NOTE: type of object in this context means only the internal type in 3D engine. It is not related
+ * *NOTE: type of object in this context means only the internal type in 3D engine. It is not related
* to CObject types.
*
+ * Last tier containing vertex data contains also an ID of static buffer holding the data.
+ * The static buffer is created and updated with new data as needed.
+ *
* Such tiered structure complicates loops over all object data, but saves a lot of memory and
- * optimizes the rendering process (for instance, switching of textures is an expensive operation).
+ * optimizes the rendering process.
*
* \section Shadows Shadows
*
* Each engine object can be associated with a shadow (EngineShadow). Like objects, shadows are
* identified by their rank obtained upon creation.
*
- * ...
+ * Shadows are drawn as circular spots on the ground, except for shadows for worms, which have
+ * special mode for them.
*
* \section RenderStates Render States
*
@@ -692,12 +711,6 @@ public:
//! Writes a screenshot containing the current frame
bool WriteScreenShot(const std::string& fileName, int width, int height);
-
- //! Reads settings from INI
- bool ReadSettings();
- //! Writes settings to INI
- bool WriteSettings();
-
//@{
//! Management of game pause mode
void SetPause(bool pause);
@@ -747,58 +760,73 @@ public:
/* *************** Object management *************** */
+ // Base objects
+
+ //! Creates a base object and returns its rank
+ int CreateBaseObject();
+ //! Deletes a base object
+ void DeleteBaseObject(int baseObjRank);
+ //! Deletes all base objects
+ void DeleteAllBaseObjects();
+
+ //! Copies geometry between two base objects
+ void CopyBaseObject(int sourceBaseObjRank, int destBaseObjRank);
+
+ //! Adds triangles to given object with the specified params
+ void AddBaseObjTriangles(int baseObjRank, const std::vector<VertexTex2>& vertices,
+ EngineTriangleType triangleType,
+ const Material& material, int state,
+ std::string tex1Name, std::string tex2Name,
+ float min, float max, bool globalUpdate);
+
+ //! Adds a tier 4 engine object directly
+ void AddBaseObjQuick(int baseObjRank, const EngineBaseObjDataTier& buffer,
+ std::string tex1Name, std::string tex2Name,
+ float min, float max, bool globalUpdate);
+
+ // Objects
+
//! Creates a new object and returns its rank
int CreateObject();
//! Deletes all objects, shadows and ground spots
- void FlushObject();
+ void DeleteAllObjects();
//! Deletes the given object
- bool DeleteObject(int objRank);
+ void DeleteObject(int objRank);
+
+ //@{
+ //! Management of the base object rank for engine object
+ void SetObjectBaseRank(int objRank, int baseObjRank);
+ int GetObjectBaseRank(int objRank);
+ //@}
//@{
//! Management of engine object type
- bool SetObjectType(int objRank, EngineObjectType type);
+ void SetObjectType(int objRank, EngineObjectType type);
EngineObjectType GetObjectType(int objRank);
//@}
//@{
//! Management of object transform
- bool SetObjectTransform(int objRank, const Math::Matrix& transform);
- bool GetObjectTransform(int objRank, Math::Matrix& transform);
+ void SetObjectTransform(int objRank, const Math::Matrix& transform);
+ void GetObjectTransform(int objRank, Math::Matrix& transform);
//@}
//! Sets drawWorld for given object
- bool SetObjectDrawWorld(int objRank, bool draw);
+ void SetObjectDrawWorld(int objRank, bool draw);
//! Sets drawFront for given object
- bool SetObjectDrawFront(int objRank, bool draw);
+ void SetObjectDrawFront(int objRank, bool draw);
//! Sets the transparency level for given object
- bool SetObjectTransparency(int objRank, float value);
+ void SetObjectTransparency(int objRank, float value);
//! Returns the bounding box for an object
- bool GetObjectBBox(int objRank, Math::Vector& min, Math::Vector& max);
+ void GetObjectBBox(int objRank, Math::Vector& min, Math::Vector& max);
//! Returns the total number of triangles of given object
int GetObjectTotalTriangles(int objRank);
- //! Adds triangles to given object with the specified params
- bool AddTriangles(int objRank, const std::vector<VertexTex2>& vertices,
- const Material& material, int state,
- std::string tex1Name, std::string tex2Name,
- float min, float max, bool globalUpdate);
-
- //! Adds a surface to given object with the specified params
- bool AddSurface(int objRank, const std::vector<VertexTex2>& vertices,
- const Material& material, int state,
- std::string tex1Name, std::string tex2Name,
- float min, float max, bool globalUpdate);
-
- //! Adds a tier 4 engine object directly
- bool AddQuick(int objRank, const EngineObjLevel4& buffer,
- std::string tex1Name, std::string tex2Name,
- float min, float max, bool globalUpdate);
-
//! Returns the first found tier 4 engine object for the given params or nullptr if not found
- EngineObjLevel4* FindTriangles(int objRank, const Material& material,
+ EngineBaseObjDataTier* FindTriangles(int objRank, const Material& material,
int state, std::string tex1Name, std::string tex2Name,
float min, float max);
@@ -810,16 +838,16 @@ public:
void ChangeLOD();
//! Changes the 2nd texure for given object
- bool ChangeSecondTexture(int objRank, const std::string& tex2Name);
+ void ChangeSecondTexture(int objRank, const std::string& tex2Name);
//! Changes (recalculates) texture mapping for given object
- bool ChangeTextureMapping(int objRank, const Material& mat, int state,
+ void ChangeTextureMapping(int objRank, const Material& mat, int state,
const std::string& tex1Name, const std::string& tex2Name,
float min, float max, EngineTextureMapping mode,
float au, float bu, float av, float bv);
//! Changes texture mapping for robot tracks
- bool TrackTextureMapping(int objRank, const Material& mat, int state,
+ void TrackTextureMapping(int objRank, const Material& mat, int state,
const std::string& tex1Name, const std::string& tex2Name,
float min, float max, EngineTextureMapping mode,
float pos, float factor, float tl, float ts, float tt);
@@ -829,20 +857,20 @@ public:
int DetectObject(Math::Point mouse);
//! Creates a shadow for the given object
- bool CreateShadow(int objRank);
+ void CreateShadow(int objRank);
//! Deletes the shadow for given object
void DeleteShadow(int objRank);
//@{
//! Management of different shadow params
- bool SetObjectShadowHide(int objRank, bool hide);
- bool SetObjectShadowType(int objRank, EngineShadowType type);
- bool SetObjectShadowPos(int objRank, const Math::Vector& pos);
- bool SetObjectShadowNormal(int objRank, const Math::Vector& normal);
- bool SetObjectShadowAngle(int objRank, float angle);
- bool SetObjectShadowRadius(int objRank, float radius);
- bool SetObjectShadowIntensity(int objRank, float intensity);
- bool SetObjectShadowHeight(int objRank, float height);
+ 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);
//@}
@@ -852,7 +880,7 @@ public:
bool GetHighlight(Math::Point& p1, Math::Point& p2);
//! Deletes all ground spots
- void FlushGroundSpot();
+ void DeleteAllGroundSpots();
//! Creates a new ground spot and returns its rank
int CreateGroundSpot();
//! Deletes the given ground spot
@@ -860,11 +888,11 @@ public:
//@{
//! Management of different ground spot params
- bool SetObjectGroundSpotPos(int rank, const Math::Vector& pos);
- bool SetObjectGroundSpotRadius(int rank, float radius);
- bool SetObjectGroundSpotColor(int rank, const Color& color);
- bool SetObjectGroundSpotMinMax(int rank, float min, float max);
- bool SetObjectGroundSpotSmooth(int rank, float smooth);
+ void SetObjectGroundSpotPos(int rank, const Math::Vector& pos);
+ void SetObjectGroundSpotRadius(int rank, float radius);
+ void SetObjectGroundSpotColor(int rank, const Color& color);
+ void SetObjectGroundSpotMinMax(int rank, float min, float max);
+ void SetObjectGroundSpotSmooth(int rank, float smooth);
//@}
//! Creates the ground mark with the given params
@@ -1157,6 +1185,8 @@ public:
protected:
//! Prepares the interface for 3D scene
void Draw3DScene();
+ //! Draw 3D object
+ void DrawObject(const EngineBaseObjDataTier& p4);
//! Draws the user interface over the scene
void DrawInterface();
@@ -1186,15 +1216,13 @@ protected:
//! Draw statistic texts
void DrawStats();
- //! Creates new tier 1 object
- EngineObjLevel1& AddLevel1(const std::string& tex1Name, const std::string& tex2Name);
- //! Creates a new tier 2 object
- EngineObjLevel2& AddLevel2(EngineObjLevel1 &p1, int objRank);
- //! Creates a new tier 3 object
- EngineObjLevel3& AddLevel3(EngineObjLevel2 &p2, float min, float max);
- //! Creates a new tier 4 object
- EngineObjLevel4& AddLevel4(EngineObjLevel3 &p3, EngineTriangleType type,
- const Material& mat, int state);
+ //! Creates a new tier 2 object (texture)
+ EngineBaseObjTexTier& AddLevel2(EngineBaseObject& p1, const std::string& tex1Name, const std::string& tex2Name);
+ //! Creates a new tier 3 object (LOD)
+ EngineBaseObjLODTier& AddLevel3(EngineBaseObjTexTier &p2, float min, float max);
+ //! Creates a new tier 4 object (data)
+ EngineBaseObjDataTier& AddLevel4(EngineBaseObjLODTier &p3, EngineTriangleType type,
+ const Material& mat, int state);
//! Create texture and add it to cache
Texture CreateTexture(const std::string &texName, const TextureCreateParams &params, CImage* image = nullptr);
@@ -1221,6 +1249,12 @@ protected:
//! Updates geometric parameters of objects (bounding box and radius)
void UpdateGeometry();
+ //! Updates a given static buffer
+ void UpdateStaticBuffer(EngineBaseObjDataTier& p4);
+
+ //! Updates static buffers of changed objects
+ void UpdateStaticBuffers();
+
protected:
CInstanceManager* m_iMan;
CApplication* m_app;
@@ -1273,8 +1307,8 @@ protected:
//! Previous size of viewport window
Math::IntPoint m_lastSize;
- //! Root of tree object structure (level 1 list)
- std::vector<EngineObjLevel1> m_objectTree;
+ //! Base objects (also level 1 tier list)
+ std::vector<EngineBaseObject> m_baseObjects;
//! Object parameters
std::vector<EngineObject> m_objects;
//! Shadow list
@@ -1299,6 +1333,7 @@ protected:
Color m_waterAddColor;
int m_statisticTriangle;
bool m_updateGeometry;
+ bool m_updateStaticBuffers;
int m_alphaMode;
bool m_groundSpotVisible;
bool m_shadowVisible;
diff --git a/src/graphics/engine/modelfile.cpp b/src/graphics/engine/modelfile.cpp
index c0d04a0..a942b08 100644
--- a/src/graphics/engine/modelfile.cpp
+++ b/src/graphics/engine/modelfile.cpp
@@ -34,22 +34,10 @@
#include <sstream>
-/*
- * NOTE: #ifndef checking for MODELFILE_NO_ENGINE
- * is provided in this module to conditionally
- * disable dependence on CEngine.
- */
-
-
// Graphics module namespace
namespace Gfx {
-//! How big the triangle vector is by default
-const int TRIANGLE_PREALLOCATE_COUNT = 2000;
-
-
-
bool ReadBinaryVertex(std::istream& stream, Vertex& vertex)
{
vertex.coord.x = IOUtils::ReadBinaryFloat(stream);
@@ -322,15 +310,8 @@ bool ReadLineString(std::istream& stream, const std::string& prefix, std::string
}
-CModelFile::CModelFile(CInstanceManager* iMan)
+CModelFile::CModelFile()
{
- m_iMan = iMan;
-
-#ifndef MODELFILE_NO_ENGINE
- m_engine = static_cast<CEngine*>(m_iMan->SearchInstance(CLASS_ENGINE));
-#endif
-
- m_triangles.reserve(TRIANGLE_PREALLOCATE_COUNT);
}
CModelFile::~CModelFile()
@@ -608,9 +589,6 @@ bool CModelFile::ReadModel(std::istream& stream)
triangle.state = t.state;
triangle.variableTex2 = t.texNum2 == 1;
- if (triangle.tex1Name == "plant.png")
- triangle.state |= ENG_RSTATE_ALPHA;
-
if (!triangle.variableTex2 && t.texNum2 != 0)
{
if (t.texNum2 >= 1 && t.texNum2 <= 10)
@@ -637,6 +615,10 @@ bool CModelFile::ReadModel(std::istream& stream)
m_triangles[i].tex2Name = StrUtils::Replace(m_triangles[i].tex2Name, "bmp", "png");
m_triangles[i].tex2Name = StrUtils::Replace(m_triangles[i].tex2Name, "tga", "png");
+ // TODO: fix this in model files
+ if (m_triangles[i].tex1Name == "plant.png")
+ m_triangles[i].state |= ENG_RSTATE_ALPHA;
+
GetLogger()->Trace("ModelTriangle %d\n", i+1);
std::string s1 = m_triangles[i].p1.ToString();
GetLogger()->Trace(" p1: %s\n", s1.c_str());
@@ -1154,93 +1136,6 @@ bool CModelFile::WriteBinaryModel(std::ostream& stream)
Other stuff
*******************************************************/
-#ifndef MODELFILE_NO_ENGINE
-
-bool CModelFile::CreateEngineObject(int objRank)
-{
- std::vector<VertexTex2> vs(3, VertexTex2());
-
- float limit[2];
- limit[0] = m_engine->GetLimitLOD(0); // frontier AB as config
- limit[1] = m_engine->GetLimitLOD(1); // frontier BC as config
-
- for (int i = 0; i < static_cast<int>( m_triangles.size() ); i++)
- {
- // TODO move this to CEngine
-
- float min = m_triangles[i].min;
- float max = m_triangles[i].max;
-
- // Standard frontiers -> config
- if (min == 0.0f && max == 100.0f) // resolution A ?
- {
- max = limit[0];
- }
- else if (min == 100.0f && max == 200.0f) // resolution B ?
- {
- min = limit[0];
- max = limit[1];
- }
- else if (min == 200.0f && max == 1000000.0f) // resolution C ?
- {
- min = limit[1];
- }
-
- int state = m_triangles[i].state;
- std::string tex2Name = m_triangles[i].tex2Name;
-
- if (m_triangles[i].variableTex2)
- {
- int texNum = m_engine->GetSecondTexture();
-
- if (texNum >= 1 && texNum <= 10)
- state |= ENG_RSTATE_DUAL_BLACK;
-
- if (texNum >= 11 && texNum <= 20)
- state |= ENG_RSTATE_DUAL_WHITE;
-
- char name[20] = { 0 };
- sprintf(name, "dirty%.2d.png", texNum);
- tex2Name = name;
- }
-
- vs[0] = m_triangles[i].p1;
- vs[1] = m_triangles[i].p2;
- vs[2] = m_triangles[i].p3;
-
- bool ok = m_engine->AddTriangles(objRank, vs,
- m_triangles[i].material,
- state,
- m_triangles[i].tex1Name,
- tex2Name,
- min, max, false);
- if (!ok)
- return false;
- }
-
- return true;
-}
-
-#endif
-
-void CModelFile::Mirror()
-{
- for (int i = 0; i < static_cast<int>( m_triangles.size() ); i++)
- {
- VertexTex2 t = m_triangles[i].p1;
- m_triangles[i].p1 = m_triangles[i].p2;
- m_triangles[i].p2 = t;
-
- m_triangles[i].p1.coord.z = -m_triangles[i].p1.coord.z;
- m_triangles[i].p2.coord.z = -m_triangles[i].p2.coord.z;
- m_triangles[i].p3.coord.z = -m_triangles[i].p3.coord.z;
-
- m_triangles[i].p1.normal.z = -m_triangles[i].p1.normal.z;
- m_triangles[i].p2.normal.z = -m_triangles[i].p2.normal.z;
- m_triangles[i].p3.normal.z = -m_triangles[i].p3.normal.z;
- }
-}
-
const std::vector<ModelTriangle>& CModelFile::GetTriangles()
{
return m_triangles;
@@ -1251,28 +1146,6 @@ int CModelFile::GetTriangleCount()
return m_triangles.size();
}
-float CModelFile::GetHeight(Math::Vector pos)
-{
- float limit = 5.0f;
-
- for (int i = 0; i < static_cast<int>( m_triangles.size() ); i++)
- {
- if ( fabs(pos.x - m_triangles[i].p1.coord.x) < limit &&
- fabs(pos.z - m_triangles[i].p1.coord.z) < limit )
- return m_triangles[i].p1.coord.y;
-
- if ( fabs(pos.x - m_triangles[i].p2.coord.x) < limit &&
- fabs(pos.z - m_triangles[i].p2.coord.z) < limit )
- return m_triangles[i].p2.coord.y;
-
- if ( fabs(pos.x - m_triangles[i].p3.coord.x) < limit &&
- fabs(pos.z - m_triangles[i].p3.coord.z) < limit )
- return m_triangles[i].p3.coord.y;
- }
-
- return 0.0f;
-}
-
void CModelFile::CreateTriangle(Math::Vector p1, Math::Vector p2, Math::Vector p3, float min, float max)
{
ModelTriangle triangle;
diff --git a/src/graphics/engine/modelfile.h b/src/graphics/engine/modelfile.h
index 6c573b8..b2b5d87 100644
--- a/src/graphics/engine/modelfile.h
+++ b/src/graphics/engine/modelfile.h
@@ -33,14 +33,10 @@
#include <iostream>
-class CInstanceManager;
-
// Graphics module namespace
namespace Gfx {
-class CEngine;
-
/**
\struct ModelTriangle
@@ -79,14 +75,15 @@ struct ModelTriangle
/**
- \class CModelFile
- \brief Model file reader/writer
-
- Allows reading and writing model objects. Models are collections of ModelTriangle structs. */
+ * \class CModelFile
+ * \brief Model file reader/writer
+ *
+ * Allows reading and writing model objects. Models are collections of ModelTriangle structs.
+ */
class CModelFile
{
public:
- CModelFile(CInstanceManager* iMan);
+ CModelFile();
~CModelFile();
//! Reads a model in text format from file
@@ -128,23 +125,11 @@ public:
//! Returns the triangle vector
const std::vector<ModelTriangle>& GetTriangles();
- //! Returns the height of model -- closest point to X and Z coords of \a pos
- float GetHeight(Math::Vector pos);
-
- //! Mirrors the model along the Z axis
- void Mirror();
-
- //! Creates an object in the graphics engine from the model
- bool CreateEngineObject(int objRank);
-
protected:
//! Adds a triangle to the list
void CreateTriangle(Math::Vector p1, Math::Vector p2, Math::Vector p3, float min, float max);
protected:
- CInstanceManager* m_iMan;
- CEngine* m_engine;
-
//! Model triangles
std::vector<ModelTriangle> m_triangles;
};
diff --git a/src/graphics/engine/modelmanager.cpp b/src/graphics/engine/modelmanager.cpp
new file mode 100644
index 0000000..5b17769
--- /dev/null
+++ b/src/graphics/engine/modelmanager.cpp
@@ -0,0 +1,213 @@
+#include "graphics/engine/modelmanager.h"
+
+#include "app/app.h"
+
+#include "common/logger.h"
+
+#include "graphics/engine/engine.h"
+
+#include <cstdio>
+
+template<> Gfx::CModelManager* CSingleton<Gfx::CModelManager>::mInstance = nullptr;
+
+namespace Gfx {
+
+CModelManager::CModelManager(CEngine* engine)
+{
+ m_engine = engine;
+}
+
+CModelManager::~CModelManager()
+{
+}
+
+bool CModelManager::LoadModel(const std::string& fileName, bool mirrored)
+{
+ GetLogger()->Info("Loading model '%s'\n", fileName.c_str());
+
+ CModelFile modelFile;
+
+ std::string filePath = CApplication::GetInstance().GetDataFilePath(DIR_MODEL, fileName);
+
+ if (!modelFile.ReadModel(filePath))
+ {
+ GetLogger()->Error("Loading model '%s' failed\n", filePath.c_str());
+ return false;
+ }
+
+ ModelInfo modelInfo;
+ modelInfo.baseObjRank = m_engine->CreateBaseObject();
+ modelInfo.triangles = modelFile.GetTriangles();
+
+ if (mirrored)
+ Mirror(modelInfo.triangles);
+
+ FileInfo fileInfo(fileName, mirrored);
+ m_models[fileInfo] = modelInfo;
+
+ std::vector<VertexTex2> vs(3, VertexTex2());
+
+ float limit[2];
+ limit[0] = m_engine->GetLimitLOD(0); // frontier AB as config
+ limit[1] = m_engine->GetLimitLOD(1); // frontier BC as config
+
+ for (int i = 0; i < static_cast<int>( modelInfo.triangles.size() ); i++)
+ {
+ float min = modelInfo.triangles[i].min;
+ float max = modelInfo.triangles[i].max;
+
+ // Standard frontiers -> config
+ if (min == 0.0f && max == 100.0f) // resolution A ?
+ {
+ max = limit[0];
+ }
+ else if (min == 100.0f && max == 200.0f) // resolution B ?
+ {
+ min = limit[0];
+ max = limit[1];
+ }
+ else if (min == 200.0f && max == 1000000.0f) // resolution C ?
+ {
+ min = limit[1];
+ }
+
+ int state = modelInfo.triangles[i].state;
+ std::string tex2Name = modelInfo.triangles[i].tex2Name;
+
+ if (modelInfo.triangles[i].variableTex2)
+ {
+ int texNum = m_engine->GetSecondTexture();
+
+ if (texNum >= 1 && texNum <= 10)
+ state |= ENG_RSTATE_DUAL_BLACK;
+
+ if (texNum >= 11 && texNum <= 20)
+ state |= ENG_RSTATE_DUAL_WHITE;
+
+ char name[20] = { 0 };
+ sprintf(name, "dirty%.2d.png", texNum);
+ tex2Name = name;
+ }
+
+ vs[0] = modelInfo.triangles[i].p1;
+ vs[1] = modelInfo.triangles[i].p2;
+ vs[2] = modelInfo.triangles[i].p3;
+
+ m_engine->AddBaseObjTriangles(modelInfo.baseObjRank, vs, ENG_TRIANGLE_TYPE_TRIANGLES,
+ modelInfo.triangles[i].material, state,
+ modelInfo.triangles[i].tex1Name, tex2Name,
+ min, max, false);
+ }
+
+ return true;
+}
+
+bool CModelManager::AddModelReference(const std::string& fileName, bool mirrored, int objRank)
+{
+ auto it = m_models.find(FileInfo(fileName, mirrored));
+ if (it == m_models.end())
+ {
+ if (!LoadModel(fileName, mirrored))
+ return false;
+
+ it = m_models.find(FileInfo(fileName, mirrored));
+ }
+
+ m_engine->SetObjectBaseRank(objRank, (*it).second.baseObjRank);
+
+ return true;
+}
+
+bool CModelManager::AddModelCopy(const std::string& fileName, bool mirrored, int objRank)
+{
+ auto it = m_models.find(FileInfo(fileName, mirrored));
+ if (it == m_models.end())
+ {
+ if (!LoadModel(fileName, mirrored))
+ return false;
+
+ it = m_models.find(FileInfo(fileName, mirrored));
+ }
+
+ int copyBaseObjRank = m_engine->CreateBaseObject();
+ m_engine->CopyBaseObject((*it).second.baseObjRank, copyBaseObjRank);
+ m_engine->SetObjectBaseRank(objRank, copyBaseObjRank);
+
+ return true;
+}
+
+bool CModelManager::IsModelLoaded(const std::string& fileName, bool mirrored)
+{
+ return m_models.count(FileInfo(fileName, mirrored)) > 0;
+}
+
+int CModelManager::GetModelBaseObjRank(const std::string& fileName, bool mirrored)
+{
+ auto it = m_models.find(FileInfo(fileName, mirrored));
+ if (it == m_models.end())
+ return -1;
+
+ return (*it).second.baseObjRank;
+}
+
+void CModelManager::UnloadModel(const std::string& fileName, bool mirrored)
+{
+ auto it = m_models.find(FileInfo(fileName, mirrored));
+ if (it == m_models.end())
+ return;
+
+ m_engine->DeleteBaseObject((*it).second.baseObjRank);
+
+ m_models.erase(it);
+}
+
+void CModelManager::UnloadAllModels()
+{
+ for (auto& mf : m_models)
+ m_engine->DeleteBaseObject(mf.second.baseObjRank);
+
+ m_models.clear();
+}
+
+void CModelManager::Mirror(std::vector<ModelTriangle>& triangles)
+{
+ for (int i = 0; i < static_cast<int>( triangles.size() ); i++)
+ {
+ VertexTex2 t = triangles[i].p1;
+ triangles[i].p1 = triangles[i].p2;
+ triangles[i].p2 = t;
+
+ triangles[i].p1.coord.z = -triangles[i].p1.coord.z;
+ triangles[i].p2.coord.z = -triangles[i].p2.coord.z;
+ triangles[i].p3.coord.z = -triangles[i].p3.coord.z;
+
+ triangles[i].p1.normal.z = -triangles[i].p1.normal.z;
+ triangles[i].p2.normal.z = -triangles[i].p2.normal.z;
+ triangles[i].p3.normal.z = -triangles[i].p3.normal.z;
+ }
+}
+
+float CModelManager::GetHeight(std::vector<ModelTriangle>& triangles, Math::Vector pos)
+{
+ const float limit = 5.0f;
+
+ for (int i = 0; i < static_cast<int>( triangles.size() ); i++)
+ {
+ if ( fabs(pos.x - triangles[i].p1.coord.x) < limit &&
+ fabs(pos.z - triangles[i].p1.coord.z) < limit )
+ return triangles[i].p1.coord.y;
+
+ if ( fabs(pos.x - triangles[i].p2.coord.x) < limit &&
+ fabs(pos.z - triangles[i].p2.coord.z) < limit )
+ return triangles[i].p2.coord.y;
+
+ if ( fabs(pos.x - triangles[i].p3.coord.x) < limit &&
+ fabs(pos.z - triangles[i].p3.coord.z) < limit )
+ return triangles[i].p3.coord.y;
+ }
+
+ return 0.0f;
+}
+
+
+}
diff --git a/src/graphics/engine/modelmanager.h b/src/graphics/engine/modelmanager.h
new file mode 100644
index 0000000..601d636
--- /dev/null
+++ b/src/graphics/engine/modelmanager.h
@@ -0,0 +1,97 @@
+#pragma once
+
+#include "common/singleton.h"
+
+#include "graphics/engine/modelfile.h"
+
+#include <string>
+#include <vector>
+#include <map>
+
+namespace Gfx {
+
+class CEngine;
+class CModelFile;
+
+/**
+ * \class CModelManager
+ * \brief Manager for static models
+ *
+ * The manager allows for loading models as static objects and adding
+ * new instances of models to the engine.
+ *
+ * The models are loaded from stanard application model directory and
+ * they are identified by unique file names.
+ *
+ * The models are loaded by creating (if it doesn't exist yet)
+ * a base engine object from the model geometry. This base object
+ * is then shared among all instances of this model with the instances
+ * being engine objects linked to the shared base object.
+ *
+ * There is also a possibility of creating a copy of model so it has
+ * its own and unique base engine object. This is especially useful
+ * for models where the geometry must be altered.
+ */
+class CModelManager : public CSingleton<CModelManager>
+{
+public:
+ CModelManager(CEngine* engine);
+ ~CModelManager();
+
+ //! Loads a model from given file
+ bool LoadModel(const std::string& fileName, bool mirrored);
+
+ //! Adds an instance of model to the given object rank as a reference to base object
+ bool AddModelReference(const std::string& fileName, bool mirrored, int objRank);
+
+ //! Adds an instance of model to the given object rank as a copy (copied base object)
+ bool AddModelCopy(const std::string& fileName, bool mirrored, int objRank);
+
+ //! Returns true if given model is loaded
+ bool IsModelLoaded(const std::string& fileName, bool mirrored);
+
+ //! Returns the rank of base engine object of given loaded model
+ int GetModelBaseObjRank(const std::string& fileName, bool mirrored);
+
+ //! Unloads the given model
+ void UnloadModel(const std::string& fileName, bool mirrored);
+ //! Unloads all models
+ void UnloadAllModels();
+
+protected:
+ //! Returns the height of model -- closest point to X and Z coords of \a pos
+ float GetHeight(std::vector<ModelTriangle>& triangles, Math::Vector pos);
+
+ //! Mirrors the model along the Z axis
+ void Mirror(std::vector<ModelTriangle>& triangles);
+
+private:
+ struct ModelInfo
+ {
+ std::vector<ModelTriangle> triangles;
+ int baseObjRank;
+ };
+ struct FileInfo
+ {
+ std::string fileName;
+ bool mirrored;
+
+ inline FileInfo(const std::string& fileName, bool mirrored)
+ : fileName(fileName), mirrored(mirrored) {}
+
+ inline bool operator<(const FileInfo& other) const
+ {
+ int compare = fileName.compare(other.fileName);
+ if (compare < 0)
+ return true;
+ if (compare > 0)
+ return false;
+
+ return !mirrored && mirrored != other.mirrored;
+ }
+ };
+ std::map<FileInfo, ModelInfo> m_models;
+ CEngine* m_engine;
+};
+
+} // namespace Gfx
diff --git a/src/graphics/engine/particle.cpp b/src/graphics/engine/particle.cpp
index acc40df..388c189 100644
--- a/src/graphics/engine/particle.cpp
+++ b/src/graphics/engine/particle.cpp
@@ -3214,7 +3214,7 @@ void CParticle::DrawParticleSphere(int i)
angle.z = m_particle[i].angle*0.7f;
Math::Matrix rot;
Math::LoadRotationZXYMatrix(rot, angle);
- mat = Math::MultiplyMatrices(rot, mat);
+ mat = Math::MultiplyMatrices(mat, rot);
}
m_device->SetTransform(TRANSFORM_WORLD, mat);
diff --git a/src/graphics/engine/terrain.cpp b/src/graphics/engine/terrain.cpp
index 4c22a32..a66b4b0 100644
--- a/src/graphics/engine/terrain.cpp
+++ b/src/graphics/engine/terrain.cpp
@@ -34,10 +34,6 @@
// Graphics module namespace
namespace Gfx {
-const int LEVEL_MAT_PREALLOCATE_COUNT = 101;
-const int FLYING_LIMIT_PREALLOCATE_COUNT = 10;
-const int BUILDING_LEVEL_PREALLOCATE_COUNT = 101;
-
CTerrain::CTerrain(CInstanceManager* iMan)
{
@@ -60,10 +56,6 @@ CTerrain::CTerrain(CInstanceManager* iMan)
m_defaultHardness = 0.5f;
m_useMaterials = false;
- m_materials.reserve(LEVEL_MAT_PREALLOCATE_COUNT);
- m_flyingLimits.reserve(FLYING_LIMIT_PREALLOCATE_COUNT);
- m_buildingLevels.reserve(BUILDING_LEVEL_PREALLOCATE_COUNT);
-
FlushBuildingLevel();
FlushFlyingLimit();
FlushMaterials();
@@ -478,6 +470,8 @@ VertexTex2 CTerrain::GetVertex(int x, int y, int step)
v.texCoord.x = (o.x-oo.x)*m_textureScale*m_textureSubdivCount;
v.texCoord.y = 1.0f - (o.z-oo.z)*m_textureScale*m_textureSubdivCount;
+ v.texCoord2 = v.texCoord;
+
return v;
}
@@ -496,6 +490,13 @@ bool CTerrain::CreateMosaic(int ox, int oy, int step, int objRank,
const Material &mat,
float min, float max)
{
+ int baseObjRank = m_engine->GetObjectBaseRank(objRank);
+ if (baseObjRank == -1)
+ {
+ baseObjRank = m_engine->CreateBaseObject();
+ m_engine->SetObjectBaseRank(objRank, baseObjRank);
+ }
+
std::string texName1;
std::string texName2;
@@ -545,7 +546,7 @@ bool CTerrain::CreateMosaic(int ox, int oy, int step, int objRank,
for (int y = 0; y < brick; y += step)
{
- EngineObjLevel4 buffer;
+ EngineBaseObjDataTier buffer;
buffer.vertices.reserve(total);
buffer.type = ENG_TRIANGLE_TYPE_SURFACE;
@@ -638,7 +639,8 @@ bool CTerrain::CreateMosaic(int ox, int oy, int step, int objRank,
buffer.vertices.push_back(p1);
buffer.vertices.push_back(p2);
}
- m_engine->AddQuick(objRank, buffer, texName1, texName2, min, max, true);
+
+ m_engine->AddBaseObjQuick(baseObjRank, buffer, texName1, texName2, min, max, true);
}
}
}
@@ -1272,7 +1274,10 @@ bool CTerrain::Terraform(const Math::Vector &p1, const Math::Vector &p2, float h
{
for (int x = pp1.x; x <= pp2.x; x++)
{
- m_engine->DeleteObject(m_objRanks[x+y*m_mosaicCount]);
+ int objRank = m_objRanks[x+y*m_mosaicCount];
+ int baseObjRank = m_engine->GetObjectBaseRank(objRank);
+ m_engine->DeleteBaseObject(baseObjRank);
+ m_engine->DeleteObject(objRank);
CreateSquare(x, y); // recreates the square
}
}
diff --git a/src/graphics/engine/terrain.h b/src/graphics/engine/terrain.h
index 3012e62..e17144e 100644
--- a/src/graphics/engine/terrain.h
+++ b/src/graphics/engine/terrain.h
@@ -328,7 +328,7 @@ protected:
//! Calculates a vector of the terrain
Math::Vector GetVector(int x, int y);
//! Calculates a vertex of the terrain
- VertexTex2 GetVertex(int x, int y, int step);
+ VertexTex2 GetVertex(int x, int y, int step);
//! Creates all objects of a mosaic
bool CreateMosaic(int ox, int oy, int step, int objRank, const Material& mat, float min, float max);
//! Creates all objects in a mesh square ground
diff --git a/src/graphics/engine/test/CMakeLists.txt b/src/graphics/engine/test/CMakeLists.txt
index 46509f4..afaa86a 100644
--- a/src/graphics/engine/test/CMakeLists.txt
+++ b/src/graphics/engine/test/CMakeLists.txt
@@ -3,7 +3,6 @@ cmake_minimum_required(VERSION 2.8)
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE debug)
endif(NOT CMAKE_BUILD_TYPE)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wold-style-cast -std=gnu++0x")
set(CMAKE_CXX_FLAGS_DEBUG "-g -O0")
set(MODELFILE_TEST_SOURCES
@@ -11,7 +10,6 @@ modelfile_test.cpp
../modelfile.cpp
../../../common/logger.cpp
../../../common/stringutils.cpp
-../../../common/iman.cpp
)
add_definitions(-DMODELFILE_NO_ENGINE)
diff --git a/src/graphics/engine/test/modelfile_test.cpp b/src/graphics/engine/test/modelfile_test.cpp
index 6879a1b..43cd43b 100644
--- a/src/graphics/engine/test/modelfile_test.cpp
+++ b/src/graphics/engine/test/modelfile_test.cpp
@@ -15,12 +15,11 @@
// * along with this program. If not, see http://www.gnu.org/licenses/.
-#include "common/iman.h"
#include "common/logger.h"
#include "graphics/engine/modelfile.h"
#include "math/func.h"
-#include "gtest/gtest.h"
+#include <gtest/gtest.h>
#include <cassert>
#include <sstream>
@@ -190,8 +189,7 @@ TEST(ModelFileTest, RWTxtModel)
std::stringstream str;
str.str(TEXT_MODEL);
- CInstanceManager iMan;
- Gfx::CModelFile modelFile(&iMan);
+ Gfx::CModelFile modelFile;
EXPECT_TRUE(modelFile.ReadTextModel(str));
@@ -216,8 +214,7 @@ TEST(ModelFileTest, RWBinModel)
std::stringstream str;
str.str(TEXT_MODEL);
- CInstanceManager iMan;
- Gfx::CModelFile modelFile(&iMan);
+ Gfx::CModelFile modelFile;
EXPECT_TRUE(modelFile.ReadTextModel(str));
@@ -242,8 +239,7 @@ TEST(ModelFileTest, RWOldModel)
std::stringstream str;
str.str(TEXT_MODEL);
- CInstanceManager iMan;
- Gfx::CModelFile modelFile(&iMan);
+ Gfx::CModelFile modelFile;
EXPECT_TRUE(modelFile.ReadTextModel(str));
diff --git a/src/graphics/engine/text.cpp b/src/graphics/engine/text.cpp
index 101e01a..da1a290 100644
--- a/src/graphics/engine/text.cpp
+++ b/src/graphics/engine/text.cpp
@@ -46,7 +46,7 @@ struct CachedFont
};
-
+const Math::IntPoint REFERENCE_SIZE(800, 600);
CText::CText(CInstanceManager *iMan, CEngine* engine)
@@ -147,6 +147,10 @@ void CText::FlushCache()
f->cache.clear();
}
}
+
+ m_lastFontType = FONT_COLOBOT;
+ m_lastFontSize = 0;
+ m_lastCachedFont = nullptr;
}
void CText::DrawText(const std::string &text, std::map<unsigned int, FontMetaChar> &format,
@@ -723,8 +727,8 @@ void CText::DrawCharAndAdjustPos(UTF8Char ch, FontType font, float size, Math::P
CachedFont* CText::GetOrOpenFont(FontType font, float size)
{
- // TODO: sizing
- int pointSize = static_cast<int>(size);
+ Math::IntPoint windowSize = m_engine->GetWindowSize();
+ int pointSize = static_cast<int>(size * (windowSize.Length() / REFERENCE_SIZE.Length()));
if (m_lastCachedFont != nullptr)
{
diff --git a/src/graphics/engine/water.cpp b/src/graphics/engine/water.cpp
index 18811eb..6c822b3 100644
--- a/src/graphics/engine/water.cpp
+++ b/src/graphics/engine/water.cpp
@@ -386,9 +386,11 @@ void CWater::DrawSurf()
Math::Vector p = pos;
p.x += size*(m_lines[i].len-1);
float radius = sqrtf(powf(size, 2.0f)+powf(size*m_lines[i].len, 2.0f));
- if ( Math::Distance(p, eye) > deep+radius ) continue;
+ if (Math::Distance(p, eye) > deep + radius)
+ continue;
- // TODO: ComputeSphereVisibility
+ if (device->ComputeSphereVisibility(p, radius) != Gfx::FRUSTUM_PLANE_ALL)
+ continue;
int vertexIndex = 0;
diff --git a/src/graphics/opengl/gldevice.cpp b/src/graphics/opengl/gldevice.cpp
index 94b0dbc..80fa9a1 100644
--- a/src/graphics/opengl/gldevice.cpp
+++ b/src/graphics/opengl/gldevice.cpp
@@ -24,22 +24,9 @@
#include "math/geometry.h"
-#if defined(USE_GLEW)
-
-// When using GLEW, only glew.h is needed
+// Using GLEW so only glew.h is needed
#include <GL/glew.h>
-#else
-
-// Should define prototypes of used extensions as OpenGL functions
-#define GL_GLEXT_PROTOTYPES
-
-#include <GL/gl.h>
-#include <GL/glu.h>
-#include <GL/glext.h>
-
-#endif // if defined(GLEW)
-
#include <SDL/SDL.h>
#include <cassert>
@@ -73,6 +60,9 @@ CGLDevice::CGLDevice(const GLDeviceConfig &config)
{
m_config = config;
m_lighting = false;
+ m_lastVboId = 0;
+ m_multitextureAvailable = false;
+ m_vboAvailable = false;
}
@@ -91,29 +81,30 @@ bool CGLDevice::Create()
{
GetLogger()->Info("Creating CDevice\n");
-#if defined(USE_GLEW)
static bool glewInited = false;
if (!glewInited)
{
glewInited = true;
+ glewExperimental = GL_TRUE;
+
if (glewInit() != GLEW_OK)
{
GetLogger()->Error("GLEW initialization failed\n");
return false;
}
- if ( (! GLEW_ARB_multitexture) || (! GLEW_EXT_texture_env_combine) )
- {
- GetLogger()->Error("GLEW reports required extensions not supported\n");
- return false;
- }
- }
-#endif
+ m_multitextureAvailable = glewIsSupported("GL_ARB_multitexture GL_ARB_texture_env_combine");
+ if (!m_multitextureAvailable)
+ GetLogger()->Warn("GLEW reports multitexturing not supported - graphics quality will be degraded!\n");
- /* NOTE: when not using GLEW, extension testing is not performed, as it is assumed that
- glext.h is up-to-date and the OpenGL shared library has the required functions present. */
+ m_vboAvailable = glewIsSupported("GL_ARB_vertex_buffer_object");
+ if (m_vboAvailable)
+ GetLogger()->Info("Detected ARB_vertex_buffer_object extension - using VBOs\n");
+ else
+ GetLogger()->Info("No ARB_vertex_buffer_object extension present - using display lists\n");
+ }
// This is mostly done in all modern hardware by default
// DirectX doesn't even allow the option to turn off perspective correction anymore
@@ -123,6 +114,9 @@ bool CGLDevice::Create()
// To avoid problems with scaling & lighting
glEnable(GL_RESCALE_NORMAL);
+ // Minimal depth bias to avoid Z-fighting
+ SetDepthBias(0.001f);
+
// Set just to be sure
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glMatrixMode(GL_PROJECTION);
@@ -174,6 +168,16 @@ void CGLDevice::ConfigChanged(const GLDeviceConfig& newConfig)
Create();
}
+void CGLDevice::SetUseVbo(bool vboAvailable)
+{
+ m_vboAvailable = vboAvailable;
+}
+
+bool CGLDevice::GetUseVbo()
+{
+ return m_vboAvailable;
+}
+
void CGLDevice::BeginScene()
{
Clear();
@@ -413,7 +417,9 @@ Texture CGLDevice::CreateTexture(ImageData *data, const TextureCreateParams &par
result.size.y = data->surface->h;
// Use & enable 1st texture stage
- glActiveTexture(GL_TEXTURE0);
+ if (m_multitextureAvailable)
+ glActiveTexture(GL_TEXTURE0);
+
glEnable(GL_TEXTURE_2D);
glGenTextures(1, &result.id);
@@ -588,7 +594,7 @@ void CGLDevice::DestroyAllTextures()
m_allTextures.clear();
}
-int CGLDevice::GetMaxTextureCount()
+int CGLDevice::GetMaxTextureStageCount()
{
return m_currentTextures.size();
}
@@ -599,17 +605,21 @@ int CGLDevice::GetMaxTextureCount()
The setting is remembered, even if texturing is disabled at the moment. */
void CGLDevice::SetTexture(int index, const Texture &texture)
{
- assert(index >= 0);
- assert(index < static_cast<int>( m_currentTextures.size() ));
+ assert(index >= 0 && index < static_cast<int>( m_currentTextures.size() ));
bool same = m_currentTextures[index].id == texture.id;
m_currentTextures[index] = texture; // remember the new value
+ if (!m_multitextureAvailable && index != 0)
+ return;
+
if (same)
return; // nothing to do
- glActiveTexture(GL_TEXTURE0 + index);
+ if (m_multitextureAvailable)
+ glActiveTexture(GL_TEXTURE0 + index);
+
glBindTexture(GL_TEXTURE_2D, texture.id);
// Params need to be updated for the new bound texture
@@ -618,15 +628,19 @@ void CGLDevice::SetTexture(int index, const Texture &texture)
void CGLDevice::SetTexture(int index, unsigned int textureId)
{
- assert(index >= 0);
- assert(index < static_cast<int>( m_currentTextures.size() ));
+ assert(index >= 0 && index < static_cast<int>( m_currentTextures.size() ));
if (m_currentTextures[index].id == textureId)
return; // nothing to do
m_currentTextures[index].id = textureId;
- glActiveTexture(GL_TEXTURE0 + index);
+ if (!m_multitextureAvailable && index != 0)
+ return;
+
+ if (m_multitextureAvailable)
+ glActiveTexture(GL_TEXTURE0 + index);
+
glBindTexture(GL_TEXTURE_2D, textureId);
// Params need to be updated for the new bound texture
@@ -637,16 +651,14 @@ void CGLDevice::SetTexture(int index, unsigned int textureId)
Returns the previously assigned texture or invalid texture if the given stage is not enabled. */
Texture CGLDevice::GetTexture(int index)
{
- assert(index >= 0);
- assert(index < static_cast<int>( m_currentTextures.size() ));
+ assert(index >= 0 && index < static_cast<int>( m_currentTextures.size() ));
return m_currentTextures[index];
}
void CGLDevice::SetTextureEnabled(int index, bool enabled)
{
- assert(index >= 0);
- assert(index < static_cast<int>( m_currentTextures.size() ));
+ assert(index >= 0 && index < static_cast<int>( m_currentTextures.size() ));
bool same = m_texturesEnabled[index] == enabled;
@@ -655,7 +667,12 @@ void CGLDevice::SetTextureEnabled(int index, bool enabled)
if (same)
return; // nothing to do
- glActiveTexture(GL_TEXTURE0 + index);
+ if (!m_multitextureAvailable && index != 0)
+ return;
+
+ if (m_multitextureAvailable)
+ glActiveTexture(GL_TEXTURE0 + index);
+
if (enabled)
glEnable(GL_TEXTURE_2D);
else
@@ -664,8 +681,7 @@ void CGLDevice::SetTextureEnabled(int index, bool enabled)
bool CGLDevice::GetTextureEnabled(int index)
{
- assert(index >= 0);
- assert(index < static_cast<int>( m_currentTextures.size() ));
+ assert(index >= 0 && index < static_cast<int>( m_currentTextures.size() ));
return m_texturesEnabled[index];
}
@@ -676,17 +692,36 @@ bool CGLDevice::GetTextureEnabled(int index)
The settings are remembered, even if texturing is disabled at the moment. */
void CGLDevice::SetTextureStageParams(int index, const TextureStageParams &params)
{
- assert(index >= 0);
- assert(index < static_cast<int>( m_currentTextures.size() ));
+ assert(index >= 0 && index < static_cast<int>( m_currentTextures.size() ));
// Remember the settings
m_textureStageParams[index] = params;
+ if (!m_multitextureAvailable && index != 0)
+ return;
+
// Don't actually do anything if texture not set
if (! m_currentTextures[index].Valid())
return;
- glActiveTexture(GL_TEXTURE0 + index);
+ if (m_multitextureAvailable)
+ glActiveTexture(GL_TEXTURE0 + index);
+
+ if (params.wrapS == TEX_WRAP_CLAMP)
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+ else if (params.wrapS == TEX_WRAP_REPEAT)
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ else assert(false);
+
+ if (params.wrapT == TEX_WRAP_CLAMP)
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+ else if (params.wrapT == TEX_WRAP_REPEAT)
+ glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+ else assert(false);
+
+ // Texture env setting is silly without multitexturing
+ if (!m_multitextureAvailable)
+ return;
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, params.factor.Array());
@@ -790,26 +825,12 @@ after_tex_color:
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_CONSTANT);
else assert(false);
-
-after_tex_operations:
-
- if (params.wrapS == TEX_WRAP_CLAMP)
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
- else if (params.wrapS == TEX_WRAP_REPEAT)
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
- else assert(false);
-
- if (params.wrapT == TEX_WRAP_CLAMP)
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
- else if (params.wrapT == TEX_WRAP_REPEAT)
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
- else assert(false);
+after_tex_operations: ;
}
void CGLDevice::SetTextureStageWrap(int index, TexWrapMode wrapS, TexWrapMode wrapT)
{
- assert(index >= 0);
- assert(index < static_cast<int>( m_currentTextures.size() ));
+ assert(index >= 0 && index < static_cast<int>( m_currentTextures.size() ));
// Remember the settings
m_textureStageParams[index].wrapS = wrapS;
@@ -819,7 +840,11 @@ void CGLDevice::SetTextureStageWrap(int index, TexWrapMode wrapS, TexWrapMode wr
if (! m_currentTextures[index].Valid())
return;
- glActiveTexture(GL_TEXTURE0 + index);
+ if (!m_multitextureAvailable && index != 0)
+ return;
+
+ if (m_multitextureAvailable)
+ glActiveTexture(GL_TEXTURE0 + index);
if (wrapS == TEX_WRAP_CLAMP)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
@@ -836,8 +861,7 @@ void CGLDevice::SetTextureStageWrap(int index, TexWrapMode wrapS, TexWrapMode wr
TextureStageParams CGLDevice::GetTextureStageParams(int index)
{
- assert(index >= 0);
- assert(index < static_cast<int>( m_currentTextures.size() ));
+ assert(index >= 0 && index < static_cast<int>( m_currentTextures.size() ));
return m_textureStageParams[index];
}
@@ -868,7 +892,9 @@ void CGLDevice::DrawPrimitive(PrimitiveType type, const Vertex *vertices, int ve
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, sizeof(Vertex), reinterpret_cast<GLfloat*>(&vs[0].normal));
- glClientActiveTexture(GL_TEXTURE0);
+ if (m_multitextureAvailable)
+ glClientActiveTexture(GL_TEXTURE0);
+
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex), reinterpret_cast<GLfloat*>(&vs[0].texCoord));
@@ -892,13 +918,18 @@ void CGLDevice::DrawPrimitive(PrimitiveType type, const VertexTex2 *vertices, in
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, sizeof(VertexTex2), reinterpret_cast<GLfloat*>(&vs[0].normal));
- glClientActiveTexture(GL_TEXTURE0);
+ if (m_multitextureAvailable)
+ glClientActiveTexture(GL_TEXTURE0);
+
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(VertexTex2), reinterpret_cast<GLfloat*>(&vs[0].texCoord));
- glClientActiveTexture(GL_TEXTURE1);
- glEnableClientState(GL_TEXTURE_COORD_ARRAY);
- glTexCoordPointer(2, GL_FLOAT, sizeof(VertexTex2), reinterpret_cast<GLfloat*>(&vs[0].texCoord2));
+ if (m_multitextureAvailable)
+ {
+ glClientActiveTexture(GL_TEXTURE1);
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ glTexCoordPointer(2, GL_FLOAT, sizeof(VertexTex2), reinterpret_cast<GLfloat*>(&vs[0].texCoord2));
+ }
glColor4fv(color.Array());
@@ -907,8 +938,11 @@ void CGLDevice::DrawPrimitive(PrimitiveType type, const VertexTex2 *vertices, in
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY); // GL_TEXTURE1
- glClientActiveTexture(GL_TEXTURE0);
- glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ if (m_multitextureAvailable)
+ {
+ glClientActiveTexture(GL_TEXTURE0);
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ }
}
void CGLDevice::DrawPrimitive(PrimitiveType type, const VertexCol *vertices, int vertexCount)
@@ -927,29 +961,318 @@ void CGLDevice::DrawPrimitive(PrimitiveType type, const VertexCol *vertices, int
glDisableClientState(GL_COLOR_ARRAY);
}
+unsigned int CGLDevice::CreateStaticBuffer(PrimitiveType primitiveType, const Vertex* vertices, int vertexCount)
+{
+ unsigned int id = 0;
+ if (m_vboAvailable)
+ {
+ id = ++m_lastVboId;
+
+ VboObjectInfo info;
+ info.primitiveType = primitiveType;
+ info.vertexType = VERTEX_TYPE_NORMAL;
+ info.vertexCount = vertexCount;
+ info.bufferId = 0;
+
+ glGenBuffers(1, &info.bufferId);
+ glBindBuffer(GL_ARRAY_BUFFER, info.bufferId);
+ glBufferData(GL_ARRAY_BUFFER, vertexCount * sizeof(Vertex), vertices, GL_STATIC_DRAW);
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+ m_vboObjects[id] = info;
+ }
+ else
+ {
+ id = glGenLists(1);
+
+ glNewList(id, GL_COMPILE);
+
+ DrawPrimitive(primitiveType, vertices, vertexCount);
+
+ glEndList();
+ }
+
+ return id;
+}
+
+unsigned int CGLDevice::CreateStaticBuffer(PrimitiveType primitiveType, const VertexTex2* vertices, int vertexCount)
+{
+ unsigned int id = 0;
+ if (m_vboAvailable)
+ {
+ id = ++m_lastVboId;
+
+ VboObjectInfo info;
+ info.primitiveType = primitiveType;
+ info.vertexType = VERTEX_TYPE_TEX2;
+ info.vertexCount = vertexCount;
+ info.bufferId = 0;
+
+ glGenBuffers(1, &info.bufferId);
+ glBindBuffer(GL_ARRAY_BUFFER, info.bufferId);
+ glBufferData(GL_ARRAY_BUFFER, vertexCount * sizeof(VertexTex2), vertices, GL_STATIC_DRAW);
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+ m_vboObjects[id] = info;
+ }
+ else
+ {
+ id = glGenLists(1);
+
+ glNewList(id, GL_COMPILE);
+
+ DrawPrimitive(primitiveType, vertices, vertexCount);
+
+ glEndList();
+ }
+
+ return id;
+}
+
+unsigned int CGLDevice::CreateStaticBuffer(PrimitiveType primitiveType, const VertexCol* vertices, int vertexCount)
+{
+ unsigned int id = 0;
+ if (m_vboAvailable)
+ {
+ id = ++m_lastVboId;
+
+ VboObjectInfo info;
+ info.primitiveType = primitiveType;
+ info.vertexType = VERTEX_TYPE_COL;
+ info.vertexCount = vertexCount;
+ info.bufferId = 0;
+
+ glGenBuffers(1, &info.bufferId);
+ glBindBuffer(GL_ARRAY_BUFFER, info.bufferId);
+ glBufferData(GL_ARRAY_BUFFER, vertexCount * sizeof(VertexCol), vertices, GL_STATIC_DRAW);
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+ m_vboObjects[id] = info;
+ }
+ else
+ {
+ id = glGenLists(1);
+
+ glNewList(id, GL_COMPILE);
+
+ DrawPrimitive(primitiveType, vertices, vertexCount);
+
+ glEndList();
+ }
+
+ return id;
+}
+
+void CGLDevice::UpdateStaticBuffer(unsigned int bufferId, PrimitiveType primitiveType, const Vertex* vertices, int vertexCount)
+{
+ if (m_vboAvailable)
+ {
+ auto it = m_vboObjects.find(bufferId);
+ if (it == m_vboObjects.end())
+ return;
+
+ VboObjectInfo& info = (*it).second;
+ info.primitiveType = primitiveType;
+ info.vertexType = VERTEX_TYPE_NORMAL;
+ info.vertexCount = vertexCount;
+
+ glBindBuffer(GL_ARRAY_BUFFER, info.bufferId);
+ glBufferData(GL_ARRAY_BUFFER, vertexCount * sizeof(Vertex), vertices, GL_STATIC_DRAW);
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+ }
+ else
+ {
+ glNewList(bufferId, GL_COMPILE);
+
+ DrawPrimitive(primitiveType, vertices, vertexCount);
+
+ glEndList();
+ }
+}
+
+void CGLDevice::UpdateStaticBuffer(unsigned int bufferId, PrimitiveType primitiveType, const VertexTex2* vertices, int vertexCount)
+{
+ if (m_vboAvailable)
+ {
+ auto it = m_vboObjects.find(bufferId);
+ if (it == m_vboObjects.end())
+ return;
+
+ VboObjectInfo& info = (*it).second;
+ info.primitiveType = primitiveType;
+ info.vertexType = VERTEX_TYPE_TEX2;
+ info.vertexCount = vertexCount;
+
+ glBindBuffer(GL_ARRAY_BUFFER, info.bufferId);
+ glBufferData(GL_ARRAY_BUFFER, vertexCount * sizeof(VertexTex2), vertices, GL_STATIC_DRAW);
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+ }
+ else
+ {
+ glNewList(bufferId, GL_COMPILE);
+
+ DrawPrimitive(primitiveType, vertices, vertexCount);
+
+ glEndList();
+ }
+}
+
+void CGLDevice::UpdateStaticBuffer(unsigned int bufferId, PrimitiveType primitiveType, const VertexCol* vertices, int vertexCount)
+{
+ if (m_vboAvailable)
+ {
+ auto it = m_vboObjects.find(bufferId);
+ if (it == m_vboObjects.end())
+ return;
+
+ VboObjectInfo& info = (*it).second;
+ info.primitiveType = primitiveType;
+ info.vertexType = VERTEX_TYPE_COL;
+ info.vertexCount = vertexCount;
+
+ glBindBuffer(GL_ARRAY_BUFFER, info.bufferId);
+ glBufferData(GL_ARRAY_BUFFER, vertexCount * sizeof(VertexCol), vertices, GL_STATIC_DRAW);
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+ }
+ else
+ {
+ glNewList(bufferId, GL_COMPILE);
+
+ DrawPrimitive(primitiveType, vertices, vertexCount);
+
+ glEndList();
+ }
+}
+
+void CGLDevice::DrawStaticBuffer(unsigned int bufferId)
+{
+ if (m_vboAvailable)
+ {
+ auto it = m_vboObjects.find(bufferId);
+ if (it == m_vboObjects.end())
+ return;
+
+ glEnable(GL_VERTEX_ARRAY);
+ glBindBuffer(GL_ARRAY_BUFFER, (*it).second.bufferId);
+
+ if ((*it).second.vertexType == VERTEX_TYPE_NORMAL)
+ {
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glVertexPointer(3, GL_FLOAT, sizeof(Vertex), static_cast<char*>(nullptr) + offsetof(Vertex, coord));
+
+ glEnableClientState(GL_NORMAL_ARRAY);
+ glNormalPointer(GL_FLOAT, sizeof(Vertex), static_cast<char*>(nullptr) + offsetof(Vertex, normal));
+
+ if (m_multitextureAvailable)
+ glClientActiveTexture(GL_TEXTURE0);
+
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ glTexCoordPointer(2, GL_FLOAT, sizeof(Vertex), static_cast<char*>(nullptr) + offsetof(Vertex, texCoord));
+ }
+ else if ((*it).second.vertexType == VERTEX_TYPE_TEX2)
+ {
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glVertexPointer(3, GL_FLOAT, sizeof(VertexTex2), static_cast<char*>(nullptr) + offsetof(VertexTex2, coord));
+
+ glEnableClientState(GL_NORMAL_ARRAY);
+ glNormalPointer(GL_FLOAT, sizeof(VertexTex2), static_cast<char*>(nullptr) + offsetof(VertexTex2, normal));
+
+ if (m_multitextureAvailable)
+ glClientActiveTexture(GL_TEXTURE0);
+
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ glTexCoordPointer(2, GL_FLOAT, sizeof(VertexTex2), static_cast<char*>(nullptr) + offsetof(VertexTex2, texCoord));
+
+ if (m_multitextureAvailable)
+ {
+ glClientActiveTexture(GL_TEXTURE1);
+ glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+ glTexCoordPointer(2, GL_FLOAT, sizeof(VertexTex2), static_cast<char*>(nullptr) + offsetof(VertexTex2, texCoord2));
+ }
+ }
+ else if ((*it).second.vertexType == VERTEX_TYPE_COL)
+ {
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glVertexPointer(3, GL_FLOAT, sizeof(VertexCol), static_cast<char*>(nullptr) + offsetof(VertexCol, coord));
+
+ glEnableClientState(GL_COLOR_ARRAY);
+ glColorPointer(4, GL_FLOAT, sizeof(VertexCol), static_cast<char*>(nullptr) + offsetof(VertexCol, color));
+ }
+
+ GLenum mode = TranslateGfxPrimitive((*it).second.primitiveType);
+ glDrawArrays(mode, 0, (*it).second.vertexCount);
+
+ if ((*it).second.vertexType == VERTEX_TYPE_NORMAL)
+ {
+ glDisableClientState(GL_VERTEX_ARRAY);
+ glDisableClientState(GL_NORMAL_ARRAY);
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY); // GL_TEXTURE0
+ }
+ else if ((*it).second.vertexType == VERTEX_TYPE_TEX2)
+ {
+ glDisableClientState(GL_VERTEX_ARRAY);
+ glDisableClientState(GL_NORMAL_ARRAY);
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY); // GL_TEXTURE1
+ if (m_multitextureAvailable)
+ {
+ glClientActiveTexture(GL_TEXTURE0);
+ glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+ }
+ }
+ else if ((*it).second.vertexType == VERTEX_TYPE_COL)
+ {
+ glDisableClientState(GL_VERTEX_ARRAY);
+ glDisableClientState(GL_COLOR_ARRAY);
+ }
+
+ glBindBuffer(GL_ARRAY_BUFFER, 0);
+ glDisable(GL_VERTEX_ARRAY);
+ }
+ else
+ {
+ glCallList(bufferId);
+ }
+}
+
+void CGLDevice::DestroyStaticBuffer(unsigned int bufferId)
+{
+ if (m_vboAvailable)
+ {
+ auto it = m_vboObjects.find(bufferId);
+ if (it == m_vboObjects.end())
+ return;
+
+ glDeleteBuffers(1, &(*it).second.bufferId);
+
+ m_vboObjects.erase(it);
+ }
+ else
+ {
+ glDeleteLists(bufferId, 1);
+ }
+}
+
bool InPlane(Math::Vector normal, float originPlane, Math::Vector center, float radius)
{
- float distance = (originPlane + Math::DotProduct(normal, center)) / normal.Length();
+ float distance = originPlane + Math::DotProduct(normal, center);
if (distance < -radius)
- return true;
+ return false;
- return false;
+ return true;
}
-/*
- The implementation of ComputeSphereVisibility is taken from libwine's device.c
- Copyright of the WINE team, licensed under GNU LGPL v 2.1
- */
+/* Based on libwine's implementation */
-// TODO: testing
int CGLDevice::ComputeSphereVisibility(const Math::Vector &center, float radius)
{
Math::Matrix m;
- m.LoadIdentity();
- m = Math::MultiplyMatrices(m, m_worldMat);
- m = Math::MultiplyMatrices(m, m_viewMat);
- m = Math::MultiplyMatrices(m, m_projectionMat);
+ m = Math::MultiplyMatrices(m_worldMat, m);
+ m = Math::MultiplyMatrices(m_viewMat, m);
+ Math::Matrix sc;
+ Math::LoadScaleMatrix(sc, Math::Vector(1.0f, 1.0f, -1.0f));
+ m = Math::MultiplyMatrices(sc, m);
+ m = Math::MultiplyMatrices(m_projectionMat, m);
Math::Vector vec[6];
float originPlane[6];
@@ -958,52 +1281,64 @@ int CGLDevice::ComputeSphereVisibility(const Math::Vector &center, float radius)
vec[0].x = m.Get(4, 1) + m.Get(1, 1);
vec[0].y = m.Get(4, 2) + m.Get(1, 2);
vec[0].z = m.Get(4, 3) + m.Get(1, 3);
- originPlane[0] = m.Get(4, 4) + m.Get(1, 4);
+ float l1 = vec[0].Length();
+ vec[0].Normalize();
+ originPlane[0] = (m.Get(4, 4) + m.Get(1, 4)) / l1;
// Right plane
vec[1].x = m.Get(4, 1) - m.Get(1, 1);
vec[1].y = m.Get(4, 2) - m.Get(1, 2);
vec[1].z = m.Get(4, 3) - m.Get(1, 3);
- originPlane[1] = m.Get(4, 4) - m.Get(1, 4);
-
- // Top plane
- vec[2].x = m.Get(4, 1) - m.Get(2, 1);
- vec[2].y = m.Get(4, 2) - m.Get(2, 2);
- vec[2].z = m.Get(4, 3) - m.Get(2, 3);
- originPlane[2] = m.Get(4, 4) - m.Get(2, 4);
+ float l2 = vec[1].Length();
+ vec[1].Normalize();
+ originPlane[1] = (m.Get(4, 4) - m.Get(1, 4)) / l2;
// Bottom plane
- vec[3].x = m.Get(4, 1) + m.Get(2, 1);
- vec[3].y = m.Get(4, 2) + m.Get(2, 2);
- vec[3].z = m.Get(4, 3) + m.Get(2, 3);
- originPlane[3] = m.Get(4, 4) + m.Get(2, 4);
+ vec[2].x = m.Get(4, 1) + m.Get(2, 1);
+ vec[2].y = m.Get(4, 2) + m.Get(2, 2);
+ vec[2].z = m.Get(4, 3) + m.Get(2, 3);
+ float l3 = vec[2].Length();
+ vec[2].Normalize();
+ originPlane[2] = (m.Get(4, 4) + m.Get(2, 4)) / l3;
+
+ // Top plane
+ vec[3].x = m.Get(4, 1) - m.Get(2, 1);
+ vec[3].y = m.Get(4, 2) - m.Get(2, 2);
+ vec[3].z = m.Get(4, 3) - m.Get(2, 3);
+ float l4 = vec[3].Length();
+ vec[3].Normalize();
+ originPlane[3] = (m.Get(4, 4) - m.Get(2, 4)) / l4;
// Front plane
- vec[4].x = m.Get(3, 1);
- vec[4].y = m.Get(3, 2);
- vec[4].z = m.Get(3, 3);
- originPlane[4] = m.Get(3, 4);
+ vec[4].x = m.Get(4, 1) + m.Get(3, 1);
+ vec[4].y = m.Get(4, 2) + m.Get(3, 2);
+ vec[4].z = m.Get(4, 3) + m.Get(3, 3);
+ float l5 = vec[4].Length();
+ vec[4].Normalize();
+ originPlane[4] = (m.Get(4, 4) + m.Get(3, 4)) / l5;
// Back plane
vec[5].x = m.Get(4, 1) - m.Get(3, 1);
vec[5].y = m.Get(4, 2) - m.Get(3, 2);
vec[5].z = m.Get(4, 3) - m.Get(3, 3);
- originPlane[5] = m.Get(4, 4) - m.Get(3, 4);
+ float l6 = vec[5].Length();
+ vec[5].Normalize();
+ originPlane[5] = (m.Get(4, 4) - m.Get(3, 4)) / l6;
int result = 0;
if (InPlane(vec[0], originPlane[0], center, radius))
- result |= INTERSECT_PLANE_LEFT;
+ result |= FRUSTUM_PLANE_LEFT;
if (InPlane(vec[1], originPlane[1], center, radius))
- result |= INTERSECT_PLANE_RIGHT;
+ result |= FRUSTUM_PLANE_RIGHT;
if (InPlane(vec[2], originPlane[2], center, radius))
- result |= INTERSECT_PLANE_TOP;
+ result |= FRUSTUM_PLANE_BOTTOM;
if (InPlane(vec[3], originPlane[3], center, radius))
- result |= INTERSECT_PLANE_BOTTOM;
+ result |= FRUSTUM_PLANE_TOP;
if (InPlane(vec[4], originPlane[4], center, radius))
- result |= INTERSECT_PLANE_FRONT;
+ result |= FRUSTUM_PLANE_FRONT;
if (InPlane(vec[5], originPlane[5], center, radius))
- result |= INTERSECT_PLANE_BACK;
+ result |= FRUSTUM_PLANE_BACK;
return result;
}
@@ -1042,7 +1377,6 @@ void CGLDevice::SetRenderState(RenderState state, bool enabled)
case RENDER_STATE_DEPTH_TEST: flag = GL_DEPTH_TEST; break;
case RENDER_STATE_ALPHA_TEST: flag = GL_ALPHA_TEST; break;
case RENDER_STATE_CULLING: flag = GL_CULL_FACE; break;
- case RENDER_STATE_DITHERING: flag = GL_DITHER; break;
default: assert(false); break;
}
@@ -1067,7 +1401,6 @@ bool CGLDevice::GetRenderState(RenderState state)
case RENDER_STATE_DEPTH_TEST: flag = GL_DEPTH_TEST; break;
case RENDER_STATE_ALPHA_TEST: flag = GL_ALPHA_TEST; break;
case RENDER_STATE_CULLING: flag = GL_CULL_FACE; break;
- case RENDER_STATE_DITHERING: flag = GL_DITHER; break;
default: assert(false); break;
}
diff --git a/src/graphics/opengl/gldevice.h b/src/graphics/opengl/gldevice.h
index 87c1247..7137671 100644
--- a/src/graphics/opengl/gldevice.h
+++ b/src/graphics/opengl/gldevice.h
@@ -27,6 +27,7 @@
#include <string>
#include <vector>
#include <set>
+#include <map>
// Graphics module namespace
@@ -84,6 +85,9 @@ public:
void ConfigChanged(const GLDeviceConfig &newConfig);
+ void SetUseVbo(bool useVbo);
+ bool GetUseVbo();
+
virtual void BeginScene();
virtual void EndScene();
@@ -107,7 +111,7 @@ public:
virtual void DestroyTexture(const Texture &texture);
virtual void DestroyAllTextures();
- virtual int GetMaxTextureCount();
+ virtual int GetMaxTextureStageCount();
virtual void SetTexture(int index, const Texture &texture);
virtual void SetTexture(int index, unsigned int textureId);
virtual Texture GetTexture(int index);
@@ -119,14 +123,21 @@ public:
virtual void SetTextureStageWrap(int index, Gfx::TexWrapMode wrapS, Gfx::TexWrapMode wrapT);
- //! Renders primitive composed of vertices with single texture
virtual void DrawPrimitive(PrimitiveType type, const Vertex *vertices , int vertexCount,
Color color = Color(1.0f, 1.0f, 1.0f, 1.0f));
- //! Renders primitive composed of vertices with multitexturing (2 textures)
virtual void DrawPrimitive(PrimitiveType type, const VertexTex2 *vertices, int vertexCount,
Color color = Color(1.0f, 1.0f, 1.0f, 1.0f));
virtual void DrawPrimitive(PrimitiveType type, const VertexCol *vertices , int vertexCount);
+ virtual unsigned int CreateStaticBuffer(PrimitiveType primitiveType, const Vertex* vertices, int vertexCount);
+ virtual unsigned int CreateStaticBuffer(PrimitiveType primitiveType, const VertexTex2* vertices, int vertexCount);
+ virtual unsigned int CreateStaticBuffer(PrimitiveType primitiveType, const VertexCol* vertices, int vertexCount);
+ virtual void UpdateStaticBuffer(unsigned int bufferId, PrimitiveType primitiveType, const Vertex* vertices, int vertexCount);
+ virtual void UpdateStaticBuffer(unsigned int bufferId, PrimitiveType primitiveType, const VertexTex2* vertices, int vertexCount);
+ virtual void UpdateStaticBuffer(unsigned int bufferId, PrimitiveType primitiveType, const VertexCol* vertices, int vertexCount);
+ virtual void DrawStaticBuffer(unsigned int bufferId);
+ virtual void DestroyStaticBuffer(unsigned int bufferId);
+
virtual int ComputeSphereVisibility(const Math::Vector &center, float radius);
virtual void SetRenderState(RenderState state, bool enabled);
@@ -200,6 +211,32 @@ private:
//! Set of all created textures
std::set<Texture> m_allTextures;
+
+ //! Type of vertex structure
+ enum VertexType
+ {
+ VERTEX_TYPE_NORMAL,
+ VERTEX_TYPE_TEX2,
+ VERTEX_TYPE_COL,
+ };
+
+ //! Info about static VBO buffers
+ struct VboObjectInfo
+ {
+ PrimitiveType primitiveType;
+ unsigned int bufferId;
+ VertexType vertexType;
+ int vertexCount;
+ };
+
+ //! Whether to use multitexturing
+ bool m_multitextureAvailable;
+ //! Whether to use VBOs or display lists
+ bool m_vboAvailable;
+ //! Map of saved VBO objects
+ std::map<unsigned int, VboObjectInfo> m_vboObjects;
+ //! Last ID of VBO object
+ unsigned int m_lastVboId;
};
diff --git a/src/graphics/opengl/test/CMakeLists.txt b/src/graphics/opengl/test/CMakeLists.txt
index 154fec8..79e0ba5 100644
--- a/src/graphics/opengl/test/CMakeLists.txt
+++ b/src/graphics/opengl/test/CMakeLists.txt
@@ -8,7 +8,6 @@ find_package(PNG REQUIRED)
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE debug)
endif(NOT CMAKE_BUILD_TYPE)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wold-style-cast -std=gnu++0x")
set(CMAKE_CXX_FLAGS_DEBUG "-g -O0")
set(ADD_LIBS "")
diff --git a/src/graphics/opengl/test/light_test.cpp b/src/graphics/opengl/test/light_test.cpp
index 6ff3b1c..b19ba4b 100644
--- a/src/graphics/opengl/test/light_test.cpp
+++ b/src/graphics/opengl/test/light_test.cpp
@@ -51,7 +51,7 @@ void Render(Gfx::CGLDevice *device)
device->SetRenderState(Gfx::RENDER_STATE_CULLING, false); // Double-sided drawing
Math::Matrix persp;
- Math::LoadProjectionMatrix(persp, Math::PI / 4.0f, (800.0f) / (600.0f), 0.1f, 100.0f);
+ Math::LoadProjectionMatrix(persp, Math::PI / 4.0f, (800.0f) / (600.0f), 0.1f, 50.0f);
device->SetTransform(Gfx::TRANSFORM_PROJECTION, persp);
@@ -121,6 +121,31 @@ void Render(Gfx::CGLDevice *device)
Math::LoadTranslationMatrix(worldMat, Math::Vector(-40.0f, 2.0f, -40.0f));
device->SetTransform(Gfx::TRANSFORM_WORLD, worldMat);
+ int planes = device->ComputeSphereVisibility(Math::Vector(0.0f, 0.0f, 0.0f), 1.0f);
+ printf("Planes:");
+ if (planes == 0)
+ printf(" (none)");
+
+ if (planes & Gfx::FRUSTUM_PLANE_LEFT)
+ printf(" LEFT");
+
+ if (planes & Gfx::FRUSTUM_PLANE_RIGHT)
+ printf(" RIGHT");
+
+ if (planes & Gfx::FRUSTUM_PLANE_BOTTOM)
+ printf(" BOTTOM");
+
+ if (planes & Gfx::FRUSTUM_PLANE_TOP)
+ printf(" TOP");
+
+ if (planes & Gfx::FRUSTUM_PLANE_FRONT)
+ printf(" FRONT");
+
+ if (planes & Gfx::FRUSTUM_PLANE_BACK)
+ printf(" BACK");
+
+ printf("\n");
+
device->DrawPrimitive(Gfx::PRIMITIVE_TRIANGLE_STRIP, quad, 4);
for (int i = 0; i < 6; ++i)
diff --git a/src/graphics/opengl/test/texture_test.cpp b/src/graphics/opengl/test/texture_test.cpp
index 534a5c0..d771927 100644
--- a/src/graphics/opengl/test/texture_test.cpp
+++ b/src/graphics/opengl/test/texture_test.cpp
@@ -13,7 +13,6 @@ void Init(Gfx::CGLDevice *device)
device->SetShadeModel(Gfx::SHADE_SMOOTH);
device->SetRenderState(Gfx::RENDER_STATE_DEPTH_TEST, false);
- device->SetRenderState(Gfx::RENDER_STATE_TEXTURING, true);
device->SetTextureEnabled(0, true);
device->SetTextureEnabled(1, true);
generated by cgit v1.2.3-1-g7c22 (git 2.25.1) at 2024-07-03 12:39:39 +0000