Menu
▾
▴
[Hgengine-cvs] SF.net SVN: hgengine:[541] Mercury2/src
|
From: <cn...@us...> - 2009-09-26 18:09:33
|
Revision: 541
http://hgengine.svn.sourceforge.net/hgengine/?rev=541&view=rev
Author: cnlohr
Date: 2009-09-26 18:09:25 +0000 (Sat, 26 Sep 2009)
Log Message:
-----------
make use of new CTA + Priority Queue
Modified Paths:
--------------
Mercury2/src/MercuryMessageManager.cpp
Mercury2/src/MercuryMessageManager.h
Mercury2/src/RenderGraph.cpp
Mercury2/src/RenderGraph.h
Modified: Mercury2/src/MercuryMessageManager.cpp
===================================================================
--- Mercury2/src/MercuryMessageManager.cpp 2009-09-26 18:08:19 UTC (rev 540)
+++ Mercury2/src/MercuryMessageManager.cpp 2009-09-26 18:09:25 UTC (rev 541)
@@ -1,30 +1,39 @@
#include <MercuryMessageManager.h>
+#include <MercuryCTA.h>
+MercuryCTA HolderAllocator( sizeof(MessageHolder), 8 );
+
+
MessageHolder::MessageHolder()
- :data(NULL)
+ :data(NULL),when(0)
{
}
+bool MessageHolder::Compare( void * left, void * right )
+{
+ return (((MessageHolder*)left)->when) < (((MessageHolder*)right)->when);
+}
+
void MercuryMessageManager::PostMessage(const MString& message, MessageData* data, float delay)
{
- MessageHolder m;
- m.message = message;
- m.data = data;
- uint64_t fireTime = m_currTime + uint64_t(delay*1000000);
- m_messageQueue.Insert(fireTime, m);
+ MessageHolder * m = new(HolderAllocator.Malloc()) MessageHolder();
+ m->message = message;
+ m->data = data;
+ m->when = m_currTime + uint64_t(delay*1000000);
+ m_messageQueue.Push( m );
}
void MercuryMessageManager::PumpMessages(const uint64_t& currTime)
{
m_currTime = currTime;
- while ( !m_messageQueue.empty() )
+ while ( !m_messageQueue.Empty() )
{
- if ( m_messageQueue.PeekNextPriority() > m_currTime ) return;
+ if ( ((MessageHolder *)m_messageQueue.Peek())->when > m_currTime ) return;
- MessageHolder& message = m_messageQueue.GetNext();
- FireOffMessage( message );
- SAFE_DELETE( message.data );
- m_messageQueue.PopNext();
+ MessageHolder * message = (MessageHolder *)m_messageQueue.Pop();
+ FireOffMessage( *message );
+ SAFE_DELETE( message->data );
+ HolderAllocator.Free(message);
}
}
@@ -33,15 +42,15 @@
m_messageRecipients[message].push_back(ptr);
}
-void MercuryMessageManager::FireOffMessage(const MessageHolder& message)
+void MercuryMessageManager::FireOffMessage( const MessageHolder & message )
{
- std::map< MString, std::list< MessageHandler* > >::iterator i = m_messageRecipients.find(message.message);
-
- if ( i != m_messageRecipients.end() )
+// std::map< MString, std::list< MessageHandler* > >::iterator i = m_messageRecipients.find(message.message);
+ std::list< MessageHandler* > * ref = m_messageRecipients.get( message.message );
+ if ( ref )
{
- std::list< MessageHandler* >::iterator recipients = i->second.begin();
+ std::list< MessageHandler* >::iterator recipients = ref->begin();
- for (; recipients != i->second.end(); ++recipients)
+ for (; recipients != ref->end(); ++recipients)
(*recipients)->HandleMessage(message.message, message.data);
}
}
Modified: Mercury2/src/MercuryMessageManager.h
===================================================================
--- Mercury2/src/MercuryMessageManager.h 2009-09-26 18:08:19 UTC (rev 540)
+++ Mercury2/src/MercuryMessageManager.h 2009-09-26 18:09:25 UTC (rev 541)
@@ -1,20 +1,25 @@
#ifndef MERCURYMESSAGEMANAGER_H
#define MERCURYMESSAGEMANAGER_H
+
+#include <PriorityQueue.h>
#include <Callback.h>
#include <MessageHandler.h>
-#include <map>
-#include <PriorityQueue.h>
+#include <MercuryHash.h>
+#include <list>
#include <MercuryString.h>
#include <MercuryUtil.h>
#include <Mint.h>
+#include <MAutoPtr.h>
-class MessageHolder
+class MessageHolder : public RefBase
{
public:
MessageHolder();
MString message;
MessageData* data;
+ uint64_t when;
+ static bool Compare( void * left, void * right );
};
/* This message system uses absolute integer time values to fire off events.
@@ -25,18 +30,19 @@
class MercuryMessageManager
{
public:
+ MercuryMessageManager() : m_messageQueue( MessageHolder::Compare ) { }
void PostMessage(const MString& message, MessageData* data, float delay);
void PumpMessages(const uint64_t& currTime);
void RegisterForMessage(const MString& message, MessageHandler* ptr);
static MercuryMessageManager& GetInstance();
private:
- void FireOffMessage(const MessageHolder& message);
+ void FireOffMessage( const MessageHolder & message );
- PriorityQueue<uint64_t, MessageHolder> m_messageQueue;
+ PriorityQueue m_messageQueue;
uint64_t m_currTime; //microseconds
- std::map< MString, std::list< MessageHandler* > > m_messageRecipients;
+ MHash< std::list< MessageHandler* > > m_messageRecipients;
};
static InstanceCounter<MercuryMessageManager> MMcounter("MessageManager");
Modified: Mercury2/src/RenderGraph.cpp
===================================================================
--- Mercury2/src/RenderGraph.cpp 2009-09-26 18:08:19 UTC (rev 540)
+++ Mercury2/src/RenderGraph.cpp 2009-09-26 18:09:25 UTC (rev 541)
@@ -1,14 +1,18 @@
#include <MercuryMatrix.h>
#include <RenderGraph.h>
-
+#include <MercuryCTA.h>
#include <GLHeaders.h>
#include <Shader.h>
#include <Viewport.h>
#include <Texture.h>
+MercuryCTA AlphaHolderAllocator( sizeof(StoreRenderState), 8 );
+
RenderGraph* CURRENTRENDERGRAPH = NULL;
+
+
void RenderGraphEntry::Render()
{
MercuryMatrix modelView;
@@ -88,37 +92,40 @@
void RenderGraph::AddAlphaNode( MercuryNode* node )
{
- StoreRenderState srs;
- srs.Save();
- srs.Matrix = node->GetGlobalMatrix();
- srs.Node = node;
-
- MercuryVertex p = srs.Matrix * MercuryVertex(0,0,0,1);
+ StoreRenderState * srs = new(AlphaHolderAllocator.Malloc()) StoreRenderState();
+ srs->Save();
+ srs->Matrix = node->GetGlobalMatrix();
+ MercuryVertex p = srs->Matrix * MercuryVertex(0,0,0,1);
+ srs->Node = node;
//order from back to front (ensure furthest has lowest number and is first)
- float length = (p - EYE).Length() * -1;
- m_alphaNodesQueue.Insert(length, srs);
+ srs->fDistance = (p - EYE).Length() * -1;
+
+ //This makes the insertion linear time. We fix this up before rendering.
+ m_alphaNodesQueue.PushRaw( srs );
}
void RenderGraph::RenderAlpha()
{
- while ( !m_alphaNodesQueue.empty() )
+ m_alphaNodesQueue.Fixup();
+
+ while ( !m_alphaNodesQueue.Empty() )
{
- StoreRenderState& srs = m_alphaNodesQueue.GetNext();
-
- std::list< MercuryAsset* >::iterator i = srs.Assets.begin();
- for (;i != srs.Assets.end(); ++i)
+ StoreRenderState * srs = (StoreRenderState *)m_alphaNodesQueue.Pop();
+
+ std::list< MercuryAsset* >::iterator i = srs->Assets.begin();
+ for (;i != srs->Assets.end(); ++i)
{
- (*i)->PreRender(srs.Node);
- (*i)->Render(srs.Node);
+ (*i)->PreRender(srs->Node);
+ (*i)->Render(srs->Node);
}
- srs.Node->RecursiveRender();
+ srs->Node->RecursiveRender();
- for (i = srs.Assets.begin();i != srs.Assets.end(); ++i)
- (*i)->PostRender(srs.Node);
+ for (i = srs->Assets.begin();i != srs->Assets.end(); ++i)
+ (*i)->PostRender(srs->Node);
- m_alphaNodesQueue.PopNext();
+ AlphaHolderAllocator.Free( srs );
}
}
@@ -136,11 +143,17 @@
m_lights.clear();
}
+
StoreRenderState::StoreRenderState()
:Node(NULL)
{
}
+bool StoreRenderState::Compare( void * Left, void * Right )
+{
+ return ((StoreRenderState*)Left)->fDistance < ((StoreRenderState*)Right)->fDistance;
+}
+
void StoreRenderState::Save()
{
//get assets for current textures
Modified: Mercury2/src/RenderGraph.h
===================================================================
--- Mercury2/src/RenderGraph.h 2009-09-26 18:08:19 UTC (rev 540)
+++ Mercury2/src/RenderGraph.h 2009-09-26 18:09:25 UTC (rev 541)
@@ -39,6 +39,8 @@
void Save();
MercuryNode* Node;
MercuryMatrix Matrix;
+ float fDistance;
+ static bool Compare( void * Left, void * Right );
// private:
std::list< MercuryAsset* > Assets;
};
@@ -46,6 +48,7 @@
class RenderGraph
{
public:
+ RenderGraph() : m_alphaNodesQueue( &StoreRenderState::Compare ) { }
void Build( MercuryNode* node );
inline void Render() { m_root.Render(); }
@@ -59,7 +62,7 @@
RenderGraphEntry m_root;
//nodes that use alpha, ordered from farthest to nearest from the camera
- PriorityQueue<float, StoreRenderState > m_alphaNodesQueue;
+ PriorityQueue m_alphaNodesQueue;
std::list< Light* > m_lights;
};
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
