separate definition from implementation in OsEventBuffer

engine/CMakeLists.txt

@@ -301,11 +301,15 @@ set (RESOURCE_HEADERS
 	resource/ResourcePackage.h
 )
 
-set (OS_SRC)
+set (OS_SRC
+	os/OsEventBuffer.cpp
+)
 
 set (OS_HEADERS
 	os/OS.h
 	os/NetAddress.h
+	os/OsEventBuffer.h
+	os/OsEvents.h
 )
 
 set (LUA_SRC

engine/os/OsEventBuffer.cpp

@@ -0,0 +1,104 @@
+#include "OsEventBuffer.h"
+#include "Log.h"
+
+namespace crown
+{
+
+//-----------------------------------------------------------------------------
+OsEventBuffer::OsEventBuffer() : m_size(0)
+{
+}
+
+//-----------------------------------------------------------------------------
+void OsEventBuffer::push_event(OsEventType event_type, void* event_data, size_t event_size)
+{
+	if (m_size + sizeof(event_type) + sizeof(event_size) + event_size > MAX_OS_EVENT_BUFFER_SIZE)
+	{
+		flush();
+	}
+
+	char* cur = m_buffer + m_size;
+
+	*(uint32_t*) cur = event_type;
+	*(size_t*) (cur + sizeof(event_type)) = event_size;
+	memcpy(cur + sizeof(event_type) + sizeof(event_size), event_data, event_size);
+
+	m_size = sizeof(event_type) + sizeof(event_size) + event_size;
+
+	Log::i("event type: %d", event_type);
+}
+
+//-----------------------------------------------------------------------------
+void OsEventBuffer::push_event_buffer(char* event_buffer, size_t buffer_size)
+{
+	if (m_size + buffer_size > MAX_OS_EVENT_BUFFER_SIZE)
+	{
+		flush();
+	}
+
+	char* cur = m_buffer + m_size;
+
+	memcpy(cur, event_buffer, buffer_size);
+
+	m_size += buffer_size;
+}
+
+
+//-----------------------------------------------------------------------------
+void* OsEventBuffer::get_next_event(uint32_t& event_type, size_t& event_size)
+{
+	static size_t read = 0;
+
+	if (read < m_size)
+	{
+		char* cur = m_buffer + read;
+
+		// Saves type
+		event_type = *(uint32_t*) cur;
+		// Saves size
+		event_size = *(size_t*) cur + sizeof(uint32_t);
+
+		// Set read to next event
+		read += sizeof(size_t) + sizeof(uint32_t) + event_size;
+
+		return cur + sizeof(size_t) + sizeof(uint32_t);
+	}
+
+	read = 0;
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+void OsEventBuffer::clear()
+{
+	m_size = 0;
+}
+
+//-----------------------------------------------------------------------------
+void OsEventBuffer::flush()
+{
+	m_size = 0;
+}
+
+//-----------------------------------------------------------------------------
+size_t OsEventBuffer::size() const
+{
+	return m_size;
+}
+
+//-----------------------------------------------------------------------------
+char* OsEventBuffer::buffer()
+{
+	return m_buffer;
+}
+
+//-----------------------------------------------------------------------------
+OsEventBuffer g_os_event_buffer;
+
+OsEventBuffer* os_event_buffer()
+{
+	return &g_os_event_buffer;
+}
+
+} // namespace crown

engine/os/OsEventBuffer.h

@@ -30,8 +30,10 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 #include "Types.h"
 #include "OS.h"
+#include "Log.h"
+#include "OsEvents.h"
 
-#define MAX_OS_EVENT_BUFFER_SIZE 64 * 1024
+#define MAX_OS_EVENT_BUFFER_SIZE 1024
 
 namespace crown
 {
@@ -49,7 +51,7 @@ public:
 				OsEventBuffer();
 
 	/// Pushes an @a event_data of size @a event_size with type @a event_type 
-	void		push_event(uint32_t event_type, void* event_data, size_t event_size);
+	void		push_event(OsEventType event_type, void* event_data, size_t event_size);
 	/// Pushes an entire @a event_buffer of size @a buffer_size
 	void		push_event_buffer(char* event_buffer, size_t buffer_size);
 	/// Retrieves the @a event_type and @a event_size of next os event
@@ -68,94 +70,9 @@ public:
 public:
 
 	size_t		m_size;
-	char		m_buffer[MAX_EVENT_QUEUE_SIZE];
+	char		m_buffer[MAX_OS_EVENT_BUFFER_SIZE];
 };
 
-//-----------------------------------------------------------------------------
-inline OsEventBuffer::OsEventBuffer() : m_size(0), m_buffer(NULL)
-{
-}
-
-//-----------------------------------------------------------------------------
-inline void OsEventBuffer::push_event(OsEventType event_type, void* event_data, size_t event_size)
-{
-	if (m_size + sizeof(event_type) + sizeof(event_size) + event_size > MAX_OS_EVENT_BUFFER_SIZE)
-	{
-		flush();
-	}
-
-	char* cur = m_buffer + m_size;
-
-	*(uint32_t*) cur = event_type;
-	*(size_t*) (cur + sizeof(event_type)) = event_size;
-	memcpy(cur + sizeof(event_type) + sizeof(event_size), event_data, event_size);
-
-	m_size = sizeof(event_type) + sizeof(event_size) + event_size;
-}
-
-//-----------------------------------------------------------------------------
-inline void OsEventBuffer::push_event_buffer(char* event_buffer, size_t buffer_size)
-{
-	if (m_size + buffer_size > MAX_OS_EVENT_BUFFER_SIZE)
-	{
-		flush();
-	}
-
-	char* cur = m_buffer + m_size;
-
-	memcpy(cur, event_buffer, event_size);
-
-	m_size += buffer_size;
-}
-
-
-//-----------------------------------------------------------------------------
-inline void* OsEventBuffer::get_next_event(uint32_t& event_type, size_t& event_size)
-{
-	static size_t read = 0;
-
-	if (read < m_size)
-	{
-		char* cur = m_buffer + read;
-
-		// Saves type
-		event_type = *(uint32_t*) cur;
-		// Saves size
-		event_size = *(size_t*) cur + sizeof(uint32_t);
-
-		// Set read to next event
-		read += sizeof(size_t) + sizeof(uint32_t) + event_size;
-
-		return cur + sizeof(size_t) + sizeof(uint32_t);
-	}
-
-	read = 0;
-
-	return NULL;
-}
-
-//-----------------------------------------------------------------------------
-inline void OsEventBuffer::clear()
-{
-	m_size = 0;
-}
-
-//-----------------------------------------------------------------------------
-inline void OsEventBuffer::flush()
-{
-	m_size = 0;
-}
-
-//-----------------------------------------------------------------------------
-inline size_t OsEventBuffer::size() const
-{
-	return m_size;
-}
-
-//-----------------------------------------------------------------------------
-inline char* OsEventBuffer::buffer()
-{
-	return m_buffer;
-}
+OsEventBuffer* os_event_buffer();
 
-} // namespace crown
+} // namespace crown