[Hgengine-cvs] SF.net SVN: hgengine:[541] Mercury2/src

[<cn...@us...>]

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.