Added a basic htogg reader

core/io/treecursion_types.cpp

@@ -63,7 +63,6 @@ Ref<TreecursionWriteTask> TreecursionTestData::variant2write_task(const Variant
 		}
 	}
 	return Ref<TreecursionWriteTask>(nullptr);
-
 }
 Ref<TreecursionWriteTask> TreecursionTestData::peek(){
 	Ref<TreecursionWriteTask> ret = commands[counter];

core/io/treecursion_types.h

@@ -190,6 +190,9 @@ class TreecursionEngineHeaderTask : public TreecursionHeaderTask {
 		Error err = w.write_to_string(init_vars, ret);
 		return ret;
 	}
+	Dictionary get_vars() const {
+		return init_vars.duplicate();
+	}
 };
 
 

modules/talkingtree_storage/ogg_routines.cpp

@@ -2,20 +2,39 @@
 #include "ogg_routines.h"
 
 #include "ustring.h"
+#include "os/copymem.h"
 #include <string.h>
-
+#include <stdlib.h>
 //https://dismaldenizen.wordpress.com/2010/08/20/the-ogg-container-format-explained/
 int htogg_write_page(ogg_page *page, FileAccess *fa){
 	fa->store_buffer(page->header, page->header_len);
 	fa->store_buffer(page->body, page->body_len);
 	return page->header_len + page->body_len;
 }
 
+void ogg_page_init(ogg_page *page){
+	page ->header = NULL;
+	page ->header_len = 0;
+	page ->body = NULL;
+	page -> body_len = 0;
+}
+
+void ogg_page_clear(ogg_page * page){
+	if(page->header && page->body){
+		_ogg_free(page->header);
+	}
+	ogg_page_init(page);
+}
+
+void ogg_packet_init(ogg_packet * packet){
+	zeromem(packet, sizeof(ogg_packet));
+}
+
 int ogg_buffer(FileAccess *fa, ogg_sync_state *oy){
   uint8_t * buffer  = (uint8_t *) ogg_sync_buffer (oy, 4096);
   int bytes = fa->get_buffer(buffer, 4096);
   ogg_sync_wrote (oy,bytes);
-  return (bytes);
+  return bytes;
 }
 
 bool is_fishhead_packet(ogg_packet *packet){

modules/talkingtree_storage/ogg_routines.h

@@ -1,11 +1,18 @@
 #include "ogg/ogg.h"
 #include "os/file_access.h"
 
-
+#ifndef HTOGG_ROUTES_H
+#define HTOGG_ROUTES_H
 int htogg_write_page(ogg_page *page, FileAccess *fa);
 
 int ogg_buffer(FileAccess *fa, ogg_sync_state *oy);
 
+void ogg_page_init(ogg_page *page);
+
+void ogg_page_clear(ogg_page * page);
+
+void ogg_packet_init(ogg_packet *packet);
+
 bool is_fishhead_packet(ogg_packet *packet);
 
 bool is_fishbone_packet(ogg_packet *packet);
@@ -16,3 +23,5 @@ unsigned char * write_le16(unsigned char* p, const ogg_uint32_t num);
 
 unsigned char * write_le64(unsigned char* p, const ogg_int64_t num);
 
+#endif HTOGG_ROUTES_H
+

modules/talkingtree_storage/register_types.cpp

@@ -1,32 +1,53 @@
 #include "register_types.h"
 #include "class_db.h"
 #include "talking_tree_storage.h"
+#include "treecursion_reader.h"
 #include "talkingtree_storage_loader.h"
+#include "treecursion_player.h"
 #include "engine.h"
 
 
 static ResourceFormatTalkingTreeStorage *talkingtree_storage_loader = NULL;
-static TalkingTreeStorage *talking_tree_storage_writer = NULL;
 
+static TalkingTreeStorage *talking_tree_storage_writer = NULL;
+static _TalkingTreeStorage *_talking_tree_storage = NULL;
 
-static _TalkingTreeStorage *talking_tree_storage = NULL;
+static TreecursionPlayer *treecursion_player = NULL;
+static _TreecursionPlayer *_treecursion_player = NULL;
 
 void register_talkingtree_storage_types(){
-
-
+	//loader
 	talkingtree_storage_loader = memnew(ResourceFormatTalkingTreeStorage);
     ResourceLoader::add_resource_format_loader(talkingtree_storage_loader);
 
+	//writer
 	talking_tree_storage_writer = memnew(TalkingTreeStorage);
 	talking_tree_storage_writer->init();
-	talking_tree_storage_writer->set_singleton();
-	//ClassDB::register_class<TreecursionWriter>();
-
 
-	talking_tree_storage = memnew(_TalkingTreeStorage);
+	_talking_tree_storage = memnew(_TalkingTreeStorage);
 	ClassDB::register_class<_TalkingTreeStorage>();
 	Engine::get_singleton()->add_singleton(Engine::Singleton("TalkingTreeStorage", _TalkingTreeStorage::get_singleton()));
+
+	//reader
+	ClassDB::register_class<Treecursion>();
+
+	//submission queue
+	treecursion_player = memnew(TreecursionPlayer);
+	treecursion_player->init();
+	_treecursion_player = memnew(_TreecursionPlayer);
+	ClassDB::register_class<_TreecursionPlayer>();
+	Engine::get_singleton()->add_singleton(Engine::Singleton("TreecursionPlayer", _TreecursionPlayer::get_singleton()));
+
 }
 void unregister_talkingtree_storage_types(){
 	talking_tree_storage_writer->finish();
+	treecursion_player->finish();
+
+	memdelete(talkingtree_storage_loader);
+
+	memdelete(_treecursion_player);
+	memdelete(_talking_tree_storage);
+
+	memdelete(treecursion_player);
+	memdelete(talking_tree_storage_writer);
 }

modules/talkingtree_storage/talking_tree_storage.cpp

@@ -48,9 +48,6 @@ TalkingTreeStorage *TalkingTreeStorage::_singleton = NULL;
 TalkingTreeStorage *TalkingTreeStorage::get_singleton() {
 	return _singleton;
 }
-void TalkingTreeStorage::set_singleton() {
-	_singleton = this;
-}
 
 void TalkingTreeStorage::new_file(){
 //	_treecursion = memnew(TreecursionWriter());
@@ -159,7 +156,7 @@ void TalkingTreeStorage::finish() {
 
 TalkingTreeStorage::TalkingTreeStorage() : _recording_state(ERROR) {
 	//opusEncoder = opus_multistream_encoder_create();
-
+	_singleton = this;
 }
 
 TalkingTreeStorage::~TalkingTreeStorage() {
@@ -187,9 +184,7 @@ void _TalkingTreeStorage::set_file_name(String name){
 	//TalkingTreeStorage::get_singleton()->set_file_name(name);
 }
 _TalkingTreeStorage::_TalkingTreeStorage() {
-	_singleton = this;
-	TalkingTreeStorage::get_singleton()->init();
-
+	_singleton = this;	
 }
 _TalkingTreeStorage::~_TalkingTreeStorage() {
 	_singleton = nullptr;

modules/talkingtree_storage/talking_tree_storage.h

@@ -2,8 +2,6 @@
 #ifndef TALKING_TREE_STORAGE_H
 #define TALKING_TREE_STORAGE_H
 
-
-
 #include "object.h"
 #include "variant.h"
 #include "core/os/thread.h"
@@ -28,7 +26,6 @@ class TalkingTreeStorage : public Object {
 	static void thread_func(void *p_udata);
 public:
 	static TalkingTreeStorage *get_singleton();
-	void set_singleton();
 	void lock();
 	void unlock();
 	void finish();

modules/talkingtree_storage/talkingtree_storage_loader.cpp

@@ -5,12 +5,11 @@
 ResourceFormatTalkingTreeStorage::ResourceFormatTalkingTreeStorage() {
 }
 RES ResourceFormatTalkingTreeStorage::load(const String &p_path, const String &p_original_path, Error *r_error) {
+	Treecursion *treecursion = memnew(Treecursion);
+	treecursion->set_file(p_path);
 	if (r_error)
 		*r_error = OK;
-
-	TreecursionReader *treecursion = memnew(TreecursionReader);
-	treecursion->set_file(p_path);
-	return Ref<TreecursionReader>(treecursion);
+	return Ref<Treecursion>(treecursion);
 }
 
 void ResourceFormatTalkingTreeStorage::get_recognized_extensions(List<String> *p_extensions) const {

modules/talkingtree_storage/treecursion_player.cpp

@@ -0,0 +1,171 @@
+#include "treecursion_player.h"
+#include "os/os.h"
+#include "message_queue.h"
+#include "scene/main/scene_tree.h"
+#include "scene/main/node.h"
+#include "scene/main/viewport.h"
+#include "error_macros.h"
+
+TreecursionPlayer *TreecursionPlayer::_singleton = nullptr;
+
+TreecursionPlayer::TreecursionPlayer() : state(ERROR) {
+	_singleton = this;
+}
+TreecursionPlayer::~TreecursionPlayer() {
+
+}
+TreecursionPlayer *TreecursionPlayer::get_singleton(){
+	return _singleton;
+}
+void TreecursionPlayer::_bind_methods() {
+
+}
+
+void TreecursionPlayer::lock() {
+	if (!_thread || !_mutex)
+		return;
+	_mutex->lock();
+}
+void TreecursionPlayer::unlock() {
+	if (!_thread || !_mutex)
+		return;
+	_mutex->unlock();
+}
+
+
+Error TreecursionPlayer::init(){
+	_thread_exited = false;
+	_mutex = Mutex::create();
+	_thread = Thread::create(TreecursionPlayer::thread_func, this);
+	return OK;
+}
+
+
+void TreecursionPlayer::thread_func(void *p_udata){
+	TreecursionPlayer *ac = (TreecursionPlayer *) p_udata;
+
+	uint64_t usdelay = 20000;
+	while(!ac -> _exit_thread){
+		if(!ac->is_paused()) {
+			ac->flush();
+			OS::get_singleton()->delay_usec(usdelay);
+		}
+	}
+}
+void TreecursionPlayer::set_pause(bool paused) {
+	if(state == ERROR)
+		return;
+	if(paused){
+		state = PAUSED;
+	} else {
+		state = RUNNING;
+	}
+}
+bool TreecursionPlayer::is_paused() const {
+	return state != RUNNING;
+}
+void TreecursionPlayer::close_file() {
+	reader.unref();
+	state = ERROR;
+}
+void TreecursionPlayer::finish() {
+	if (!_thread)
+		return;
+	_exit_thread = true;
+	Thread::wait_to_finish(_thread);
+	close_file();
+	memdelete(_thread);
+	if (_mutex)
+		memdelete(_mutex);
+	_thread = NULL;
+}
+
+void TreecursionPlayer::set_treecursion_reader( Ref<Treecursion> &in_reader){
+	if(reader.is_valid()){
+		reader.unref();
+	}
+
+	if(in_reader.is_valid()){
+		reader = in_reader->instance_playback();
+		state = PAUSED;
+	} else {
+		ERR_PRINTS("Treecursion HTOGG file is invalid");
+	}
+}
+Variant TreecursionPlayer::get_init_vars() const {
+	return reader->get_init_values();
+}
+void TreecursionPlayer::flush(){
+	uint64_t current_time = OS::get_singleton()->get_ticks_usec();
+	while(reader->has_next()) {
+		uint64_t next_cmd_time = reader->peek_time();
+		if(current_time > next_cmd_time) {
+			Ref<TreecursionWriteTask> t = reader->pop();
+			push_task(t);
+			//print_line(t->toString());
+		}else
+			break;
+	}
+}
+void TreecursionPlayer::print_all_task_time(){
+	while(reader->has_next()) {
+		Ref<TreecursionWriteTask> t = reader->pop();
+		print_line("command time: " + itos(t->get_time()) + t->toJson());
+	}
+}
+void TreecursionPlayer::push_task(const Ref<TreecursionWriteTask> &task){
+	Node *node = NULL;
+	switch(task->get_type()){
+		case TreecursionWriteTask::CALL_TASK: {
+			TreecursionCallTask *ct = (TreecursionCallTask *)task.ptr();
+
+			Vector<Variant> args(ct->get_args());
+			int argc = args.size();
+			Vector<Variant *> argp;
+			argp.resize(argc);
+			for (int i = 0; i < argc; i++) {
+				argp[i] = &args[i];
+			}
+			node = SceneTree::get_singleton()->get_root()->get_node(ct -> get_node_path());
+			MessageQueue::get_singleton()->push_call(node->get_instance_id(), ct->get_name(), (const Variant **)argp.ptr(), argc, true);
+			break;
+		}
+		case TreecursionWriteTask::SET_TASK: {
+			TreecursionSetTask *st = (TreecursionSetTask *)task.ptr();
+			bool valid;
+			node = SceneTree::get_singleton()->get_root()->get_node(st -> get_node_path());
+			MessageQueue::get_singleton()->push_set(node, st->get_name(), st ->get_value());
+			break;
+		}
+		default:
+			break;
+	}
+
+}
+
+_TreecursionPlayer *_TreecursionPlayer::_singleton = nullptr;
+
+void _TreecursionPlayer::set_treecursion_reader( Ref<Treecursion> in_reader) {
+	TreecursionPlayer::get_singleton()->set_treecursion_reader(in_reader);
+}
+void _TreecursionPlayer::print_all_task_time(){
+	TreecursionPlayer::get_singleton()->print_all_task_time();
+}
+Variant _TreecursionPlayer::get_init_values() const {
+	return TreecursionPlayer::get_singleton()->get_init_vars();
+}
+void _TreecursionPlayer::set_pause(bool paused) {
+	TreecursionPlayer::get_singleton()->set_pause(paused);
+}
+void _TreecursionPlayer::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_pause", "enable"), &_TreecursionPlayer::set_pause);
+	ClassDB::bind_method(D_METHOD("get_init_values"), &_TreecursionPlayer::get_init_values);
+	ClassDB::bind_method(D_METHOD("set_treecursion", "treecursion"), &_TreecursionPlayer::set_treecursion_reader);
+	ClassDB::bind_method(D_METHOD("print_all_task_time"), &_TreecursionPlayer::print_all_task_time);
+}
+_TreecursionPlayer::_TreecursionPlayer() {
+	_singleton = this;	
+}
+_TreecursionPlayer::~_TreecursionPlayer() {
+	_singleton = nullptr;
+}