push changes

CMakeLists.txt

@@ -172,6 +172,7 @@ add_library(lego1 SHARED
   LEGO1/mxsoundmanager.cpp
   LEGO1/mxsoundpresenter.cpp
   LEGO1/mxstillpresenter.cpp
+  LEGO1/mxstreamchunk.cpp
   LEGO1/mxstreamchunklist.cpp
   LEGO1/mxstreamcontroller.cpp
   LEGO1/mxstreamer.cpp

LEGO1/mxdiskstreamcontroller.cpp

@@ -121,3 +121,10 @@ MxResult MxDiskStreamController::Tickle()
 	// TODO
 	return SUCCESS;
 }
+
+// FUNCTION: LEGO1 0x100c84a0
+void MxDiskStreamController::InsertToList74(MxDSBuffer* p_buffer)
+{
+	MxAutoLocker lock(&this->m_criticalSection);
+	m_list0x74.push_back(p_buffer);
+}

LEGO1/mxdiskstreamcontroller.h

@@ -51,6 +51,7 @@ class MxDiskStreamController : public MxStreamController {
 	undefined m_unk0xc4;               // 0xc4
 
 	void FUN_100c7f40(MxDSStreamingAction* p_streamingaction);
+	void InsertToList74(MxDSBuffer* p_buffer);
 };
 
 // TEMPLATE: LEGO1 0x100c7330

LEGO1/mxdsbuffer.cpp

@@ -1,6 +1,8 @@
 #include "mxdsbuffer.h"
 
+#include "mxdsstreamingaction.h"
 #include "mxomni.h"
+#include "mxstreamchunk.h"
 #include "mxstreamcontroller.h"
 #include "mxstreamer.h"
 
@@ -119,6 +121,105 @@ MxResult MxDSBuffer::SetBufferPointer(MxU32* p_buffer, MxU32 p_size)
 	return SUCCESS;
 }
 
+// FUNCTION: LEGO1 0x100c68a0
+MxResult MxDSBuffer::CreateObject(MxStreamController* p_controller, MxU32* p_data, MxDSAction* p_action, undefined4)
+{
+	if (p_data == NULL) {
+		return FAILURE;
+	}
+
+	MxCore* header = ReadChunk(p_data, p_action->GetUnknown24());
+
+	if (*p_data == FOURCC('M', 'x', 'O', 'b')) {
+		return StartPresenterFromAction(p_controller, p_action, (MxDSAction*) header);
+	}
+
+	if (*p_data == FOURCC('M', 'x', 'C', 'h')) {
+		if (m_unk0x30->HasId(((MxStreamChunk*) header)->GetUnk0xc()) == 0) {
+			delete header;
+			return SUCCESS;
+		}
+
+		return ParseChunk(p_controller, p_data, p_action, (MxStreamChunk*) header);
+	}
+
+	delete header;
+	return FAILURE;
+}
+
+// FUNCTION: LEGO1 0x100c6960
+MxResult MxDSBuffer::StartPresenterFromAction(
+	MxStreamController* p_controller,
+	MxDSAction* p_action1,
+	MxDSAction* p_object_header
+)
+{
+	if (!m_unk0x30->GetInternalAction()) {
+		p_object_header->SetAtomId(p_action1->GetAtomId());
+		p_object_header->SetUnknown28(p_action1->GetUnknown28());
+		p_object_header->SetUnknown84(p_action1->GetUnknown84());
+		p_object_header->SetOrigin(p_action1->GetOrigin());
+		p_object_header->SetUnknown90(p_action1->GetUnknown90());
+		p_object_header->MergeFrom(*p_action1);
+
+		m_unk0x30->SetInternalAction(p_object_header->Clone());
+
+		p_controller->InsertActionToList54(p_object_header);
+
+		if (MxOmni::GetInstance()->CreatePresenter(p_controller, *p_object_header) != SUCCESS) {
+			return FAILURE;
+		}
+
+		m_unk0x30->SetLoopCount(p_object_header->GetLoopCount());
+		m_unk0x30->SetFlags(p_object_header->GetFlags());
+		m_unk0x30->SetDuration(p_object_header->GetDuration());
+
+		if (m_unk0x30->GetInternalAction() == NULL) {
+			return FAILURE;
+		}
+	}
+	else if (p_object_header) {
+		delete p_object_header;
+	}
+
+	return SUCCESS;
+}
+
+// STUB: LEGO1 0x100c6a50
+MxResult MxDSBuffer::ParseChunk(
+	MxStreamController* p_controller,
+	MxU32* p_data,
+	MxDSAction* p_action,
+	MxStreamChunk* p_header
+)
+{
+	// TODO STUB
+	return FAILURE;
+}
+
+// FUNCTION: LEGO1 0x100c6d00
+MxCore* MxDSBuffer::ReadChunk(MxU32* p_chunkData, MxU16 p_flags)
+{
+	// This function reads a chunk. If it is an object, this function returns an MxDSObject. If it is a chunk, returns a
+	// MxDSChunk.
+	MxCore* result = NULL;
+	MxU8* dataStart = (MxU8*) p_chunkData + 8;
+
+	switch (*p_chunkData) {
+	case FOURCC('M', 'x', 'O', 'b'):
+		result = DeserializeDSObjectDispatch((char**) &dataStart, p_flags);
+		break;
+	case FOURCC('M', 'x', 'C', 'h'):
+		result = new MxStreamChunk();
+		if (result != NULL && ((MxStreamChunk*) result)->ReadChunk(this, (MxU8*) p_chunkData) != SUCCESS) {
+			delete result;
+			result = NULL;
+		}
+		break;
+	}
+	return result;
+}
+
 // STUB: LEGO1 0x100c67b0
 MxResult MxDSBuffer::FUN_100c67b0(MxStreamController* p_controller, MxDSAction* p_action, undefined4*)
 {

LEGO1/mxdsbuffer.h

@@ -6,6 +6,8 @@
 
 class MxStreamController;
 class MxDSAction;
+class MxDSStreamingAction;
+class MxStreamChunk;
 
 enum MxDSBufferType {
 	MxDSBufferType_Chunk = 0,
@@ -30,6 +32,10 @@ class MxDSBuffer : public MxCore {
 
 	MxResult AllocateBuffer(MxU32 p_bufferSize, MxDSBufferType p_mode);
 	MxResult SetBufferPointer(MxU32* p_buffer, MxU32 p_size);
+	MxResult CreateObject(MxStreamController* p_controller, MxU32* p_data, MxDSAction* p_action, undefined4);
+	MxResult StartPresenterFromAction(MxStreamController* p_controller, MxDSAction* p_action1, MxDSAction* p_action2);
+	MxResult ParseChunk(MxStreamController* p_controller, MxU32* p_data, MxDSAction* p_action, MxStreamChunk* p_header);
+	MxCore* ReadChunk(MxU32* p_chunkData, MxU16 p_flags);
 	MxResult FUN_100c67b0(MxStreamController* p_controller, MxDSAction* p_action, undefined4*);
 	void FUN_100c6f80(MxU32 p_writeOffset);
 
@@ -47,7 +53,7 @@ class MxDSBuffer : public MxCore {
 	MxDSBufferType m_mode;
 	MxU32 m_writeOffset;
 	MxU32 m_bytesRemaining;
-	MxDSAction* m_unk0x30;
+	MxDSStreamingAction* m_unk0x30;
 };
 
 #endif // MXDSBUFFER_H

LEGO1/mxdschunk.h

@@ -43,6 +43,8 @@ class MxDSChunk : public MxCore {
 	inline MxU32 GetLength() { return m_length; }
 	inline MxU8* GetData() { return m_data; }
 
+	inline undefined4 GetUnk0xc() { return m_unk0x0c; }
+
 	inline void Release()
 	{
 		if (m_data)

LEGO1/mxdsstreamingaction.h

@@ -34,6 +34,7 @@ class MxDSStreamingAction : public MxDSAction {
 	inline MxU32 GetUnknown94() { return m_unk0x94; }
 	inline MxDSBuffer* GetUnknowna0() { return m_unk0xa0; }
 	inline MxDSBuffer* GetUnknowna4() { return m_unk0xa4; }
+	inline MxDSAction* GetInternalAction() { return m_internalAction; }
 	inline void SetUnknowna0(MxDSBuffer* p_unk0xa0) { m_unk0xa0 = p_unk0xa0; }
 
 private:

LEGO1/mxpresenter.h

@@ -10,6 +10,7 @@
 
 class MxCompositePresenter;
 class MxStreamController;
+class MxPresenter;
 
 // VTABLE: LEGO1 0x100d4d38
 // SIZE 0x40

LEGO1/mxstreamchunk.cpp

@@ -0,0 +1,8 @@
+#include "mxstreamchunk.h"
+
+// STUB: LEGO1 0x100c3050
+MxResult MxStreamChunk::ReadChunk(MxDSBuffer* p_buffer, MxU8* p_chunkData)
+{
+	// TODO
+	return FAILURE;
+}

LEGO1/mxstreamchunk.h

@@ -3,6 +3,8 @@
 
 #include "mxdschunk.h"
 
+class MxDSBuffer;
+
 // VTABLE: LEGO1 0x100dc2a8
 // SIZE 0x20
 class MxStreamChunk : public MxDSChunk {
@@ -22,6 +24,8 @@ class MxStreamChunk : public MxDSChunk {
 		return !strcmp(p_name, MxStreamChunk::ClassName()) || MxDSChunk::IsA(p_name);
 	}
 
+	MxResult ReadChunk(MxDSBuffer* p_buffer, MxU8* p_chunkData);
+
 private:
 	void* m_unk0x1c; // 0x1c
 };

LEGO1/mxstreamcontroller.cpp

@@ -148,6 +148,23 @@ MxPresenter* MxStreamController::FUN_100c1e70(MxDSAction& p_action)
 	return result;
 }
 
+// FUNCTION: LEGO1 0x100c1da0
+MxResult MxStreamController::InsertActionToList54(MxDSAction* p_action)
+{
+	MxAutoLocker locker(&m_criticalSection);
+	MxDSAction* action = p_action->Clone();
+
+	if (action == NULL)
+	{
+		return FAILURE;
+	}
+	else
+	{
+		m_unk0x54.push_back(action);
+		return SUCCESS;
+	}
+}
+
 // STUB: LEGO1 0x100c1f00
 MxResult MxStreamController::FUN_100c1f00(MxDSAction* p_action)
 {

LEGO1/mxstreamcontroller.h

@@ -45,6 +45,7 @@ class MxStreamController : public MxCore {
 	MxBool FUN_100c20d0(MxDSObject& p_obj);
 	MxResult FUN_100c1a00(MxDSAction* p_action, MxU32 p_bufferval);
 	MxPresenter* FUN_100c1e70(MxDSAction& p_action);
+	MxResult InsertActionToList54(MxDSAction* p_action);
 	MxResult FUN_100c1f00(MxDSAction* p_action);
 
 	inline MxAtomId& GetAtom() { return m_atom; };