=== Verse ===

* add preliminary verse method support to Blender. This gets really interesting whenever I get Verse Chat completed.

5 files changed, 601 insertions, 1 deletions

diff --git a/source/blender/blenkernel/BKE_verse.h b/source/blender/blenkernel/BKE_verse.h
index fe5fc44ba1e..8f8fb61100f 100644
--- a/source/blender/blenkernel/BKE_verse.h
+++ b/source/blender/blenkernel/BKE_verse.h
@@ -335,6 +335,30 @@ typedef struct VTagGroup {
 	void (*post_taggroup_create)(struct VTagGroup *vtaggroup);
 } VTagGroup;
 
+ /*
+ * Verse Method Group
+ */
+typedef struct VMethodGroup
+{
+	struct VMethodGroup *next, *prev;
+	uint16 group_id;
+	char name[16];
+	struct ListBase methods;
+} VMethodGroup;
+
+/*
+ * Verse Method
+ */
+typedef struct VMethod
+{
+	struct VMethod *next, *prev;
+	uint16 id;
+	char name[500];
+	uint8 param_count;
+	VNOParamType *param_type;
+	char **param_name;
+} VMethod;
+
 /*
  * Verse Node
  */
@@ -349,6 +373,7 @@ typedef struct VNode {
 	/* blender internals */
 	char flag;			/* flags: NODE_SENT, NODE_RECEIVED, NODE_DELTED, NODE_OBSOLETE */
 	struct DynamicList taggroups;	/* dynamic list with access array of taggroups */
+	struct ListBase methodgroups;	/* method groups */
 	struct ListBase queue;		/* list of taggroups waiting for receiving from verse server */
 	void *data;			/* generic pointer at some data (VObjectData, VGeomData, ...) */
 	int counter;			/* counter of verse link pointing at this vnode (vlink->target) */
@@ -356,6 +381,10 @@ typedef struct VNode {
 	void (*post_node_create)(struct VNode *vnode);	
 	void (*post_node_destroy)(struct VNode *vnode);
 	void (*post_node_name_set)(struct VNode *vnode);
+#ifdef VERSECHAT
+	/* verse chat */
+	int chat_flag;			/* CHAT_LOGGED, CHAT_NOTLOGGED */
+#endif
 } VNode;
 
 
@@ -411,6 +440,11 @@ typedef struct PostCallbackFunction {
 #define NODE_DELTED		4
 #define NODE_OBSOLETE		8
 
+#ifdef VERSECHAT
+#define CHAT_NOTLOGGED		0
+#define CHAT_LOGGED		1
+#endif
+
 /* VLayer flags */
 #define LAYER_SENT		1
 #define LAYER_RECEIVED		2
@@ -482,7 +516,7 @@ struct VerseSession *current_verse_session(void);
 struct VerseSession *create_verse_session(const char *name, const char *pass, const char *address, uint8 *expected_key);
 void free_verse_session(struct VerseSession *session);
 void b_verse_update(void);
-void b_vers_ms_get(void);
+void b_verse_ms_get(void);
 void b_verse_connect(char *address);
 void end_verse_session(struct VerseSession *session);
 void end_all_verse_sessions(void);
@@ -493,6 +527,7 @@ void send_verse_taggroup(struct VTagGroup *vtaggroup);
 void send_verse_node(struct VNode *vnode);
 void free_verse_node_data(struct VNode *vnode);
 void free_verse_node(struct VNode *vnode);
+struct VNode* lookup_vnode(VerseSession *session, VNodeID node_id);
 struct VNode* create_verse_node(VerseSession *session, VNodeID node_id, uint8 type, VNodeID owner_id);
 void set_node_callbacks(void);
 
@@ -508,6 +543,18 @@ void send_verse_link(struct VLink *vlink);
 void free_object_data(struct VNode *vnode);
 void set_object_callbacks(void);
 struct VObjectData *create_object_data(void);
+	
+
+/* functions from verse_method.c */
+void free_verse_methodgroup(VMethodGroup *vmg);
+#ifdef VERSECHAT
+void send_say(const char *chan, const char *utter);
+void send_login(struct VNode *vnode);
+void send_logout(struct VNode *vnode);
+void send_join(struct VNode *vnode, const char *chan);
+void send_leave(struct VNode *vnode, const char *chan);
+#endif
+void set_method_callbacks(void);
 
 /* functions from verse_geometry_node.c */
 struct VerseFace* create_verse_face(struct VLayer *vlayer, uint32 polygon_id, uint32 v0, uint32 v1, uint32 v2, uint32 v3);
diff --git a/source/blender/blenkernel/intern/verse_method.c b/source/blender/blenkernel/intern/verse_method.c
new file mode 100644
index 00000000000..89b5282acfd
--- /dev/null
+++ b/source/blender/blenkernel/intern/verse_method.c
@@ -0,0 +1,523 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version. The Blender
+ * Foundation also sells licenses for use in proprietary software under
+ * the Blender License.  See http://www.blender.org/BL/ for information
+ * about this.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * Contributor(s): Nathan Letwory. 
+ *
+ * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ */
+
+#ifdef WITH_VERSE
+
+#include <string.h>
+
+#include "MEM_guardedalloc.h"
+
+#include "DNA_listBase.h"
+#include "DNA_userdef_types.h"
+#include "DNA_text_types.h"
+
+#include "BLI_dynamiclist.h"
+#include "BLI_blenlib.h"
+#include "BLI_arithb.h"
+
+#include "BIF_verse.h"
+
+#include "BKE_bad_level_calls.h"
+#include "BKE_library.h"
+#include "BKE_text.h"
+#include "BKE_verse.h"
+#include "BKE_global.h"
+#include "BKE_main.h"
+
+#include "verse.h"
+
+/* helper struct for creating method descriptions */
+typedef struct VMethodInfo {
+	const char *name;
+	uint8 param_count;
+	const VNOParamType param_type[4];
+	const char *param_name[4];
+	uint16 id;
+} VMethodInfo;
+
+#ifdef VERSECHAT
+/* array with methods for verse chat */
+static VMethodInfo vmethod_info[] = {
+	{ "join", 1, { VN_O_METHOD_PTYPE_STRING }, { "channel"}},
+	{ "leave", 1, { VN_O_METHOD_PTYPE_STRING }, { "channel"}},
+	{ "hear", 3, { VN_O_METHOD_PTYPE_STRING, VN_O_METHOD_PTYPE_STRING, VN_O_METHOD_PTYPE_STRING }, { "channel", "from", "msg"}}
+};
+#endif
+
+/* lookup a method group based on its name */
+struct VMethodGroup *lookup_vmethodgroup_name(ListBase *lb, const char *name) {
+	struct VMethodGroup *vmg;
+
+	for(vmg= lb->first; vmg; vmg= vmg->next)
+		if(strcmp(vmg->name,name)==0) break;
+	
+	return vmg;
+}
+
+/* lookup a method group based on its group_id */
+struct VMethodGroup *lookup_vmethodgroup(ListBase *lb, uint16 group_id) {
+	struct VMethodGroup *vmg;
+
+	for(vmg= lb->first; vmg; vmg= vmg->next)
+		if(vmg->group_id==group_id) break;
+	
+	return vmg;
+}
+
+/* lookup a method based on its name */
+struct VMethod *lookup_vmethod_name(ListBase *lb, const char *name) {
+	struct VMethod *vm;
+	for(vm= lb->first; vm; vm= vm->next)
+		if(strcmp(vm->name,name)==0) break;
+
+	return vm;
+}
+
+/* lookup a method based on its method_id */
+struct VMethod *lookup_vmethod(ListBase *lb, uint8 method_id) {
+	struct VMethod *vm;
+	for(vm= lb->first; vm; vm= vm->next)
+		if(vm->id==method_id) break;
+
+	return vm;
+}
+
+#ifdef VERSECHAT
+/*
+ * send say command
+ */
+void send_say(const char *chan, const char *utter)
+{
+	struct VerseSession *session = (VerseSession*)current_verse_session();
+	struct VNode *vnode;
+	struct VMethodGroup *vmg;
+	struct VMethod *vm;
+	VNOPackedParams *utterpack;
+	VNOParam args[2];
+	
+	vnode= (VNode *)(session->nodes.lb.first);
+
+	for( ; vnode; vnode= vnode->next) {
+		if(strcmp(vnode->name, "tawksrv")==0) {
+			vmg= lookup_vmethodgroup_name(&(vnode->methodgroups), "tawk");
+			if(!vmg) break;
+			vm= lookup_vmethod_name(&(vmg->methods), "say");
+			if(!vm) break;
+			args[0].vstring= (char *)chan;
+			args[1].vstring= (char *)utter;
+			if((utterpack= verse_method_call_pack(vm->param_count, vm->param_type, args))!=NULL) {
+				verse_send_o_method_call(vnode->id, vmg->group_id, vm->id, vnode->session->avatar, utterpack);
+			}
+			break;
+		}
+
+	}
+}
+
+/*
+ * send logout command
+ */
+void send_logout(VNode *vnode)
+{
+	struct VMethodGroup *vmg;
+	struct VMethod *vm;
+	VNOPackedParams *pack;
+
+	vnode->chat_flag = CHAT_LOGGED;
+	vmg= lookup_vmethodgroup_name(&(vnode->methodgroups), "tawk");
+	if(!vmg) return;
+	vm= lookup_vmethod_name(&(vmg->methods), "logout");
+	if(!vm) return;
+
+	if((pack= verse_method_call_pack(vm->param_count, vm->param_type, NULL))!=NULL) {
+		verse_send_o_method_call(vnode->id, vmg->group_id, vm->id, vnode->session->avatar, pack);
+	}
+	vnode->chat_flag = CHAT_NOTLOGGED;
+}
+
+/*
+ * send join command
+ */
+void send_join(VNode *vnode, const char *chan)
+{
+	struct VMethodGroup *vmg;
+	struct VMethod *vm;
+	VNOPackedParams *join;
+	VNOParam channel[1];
+
+	vmg= lookup_vmethodgroup_name(&(vnode->methodgroups), "tawk");
+	if(!vmg) return;
+	vm= lookup_vmethod_name(&(vmg->methods), "join");
+	if(!vm) return;
+
+	channel[0].vstring= (char *)chan;
+	if((join= verse_method_call_pack(vm->param_count, vm->param_type, channel))!=NULL) {
+		verse_send_o_method_call(vnode->id, vmg->group_id, vm->id, vnode->session->avatar, join);
+	}
+}
+
+/*
+ * send leave command
+ */
+void send_leave(VNode *vnode, const char *chan)
+{
+	struct VMethodGroup *vmg;
+	struct VMethod *vm;
+	VNOPackedParams *leave;
+	VNOParam channel[1];
+
+	vmg= lookup_vmethodgroup_name(&(vnode->methodgroups), "tawk");
+	if(!vmg) return;
+	vm= lookup_vmethod_name(&(vmg->methods), "leave");
+	if(!vm) return;
+
+	channel[0].vstring= (char *)chan;
+	if((leave= verse_method_call_pack(vm->param_count, vm->param_type, channel))!=NULL) {
+		verse_send_o_method_call(vnode->id, vmg->group_id, vm->id, vnode->session->avatar, leave);
+	}
+}
+
+/*
+ * send login command
+ */
+void send_login(VNode *vnode)
+{
+	struct VMethodGroup *vmg;
+	struct VMethod *vm;
+	VNOPackedParams *login;
+	VNOParam param[1];
+
+	vnode->chat_flag = CHAT_LOGGED;
+	vmg= lookup_vmethodgroup_name(&(vnode->methodgroups), "tawk");
+	if(!vmg) return;
+	vm= lookup_vmethod_name(&(vmg->methods), "login");
+	if(!vm) return;
+
+	param[0].vstring= U.verseuser;
+
+	if((login= verse_method_call_pack(vm->param_count, vm->param_type, param))!=NULL) {
+		verse_send_o_method_call(vnode->id, vmg->group_id, vm->id, vnode->session->avatar, login);
+	}
+	vnode->chat_flag = CHAT_LOGGED;
+
+	vnode= lookup_vnode(vnode->session, vnode->session->avatar);
+	vmg= lookup_vmethodgroup_name(&(vnode->methodgroups), "tawk-client");
+	if(!vmg)
+		verse_send_o_method_group_create(vnode->session->avatar, ~0, "tawk-client");
+}
+#endif
+
+/*
+ * Free a VMethod
+ */
+void free_verse_method(VMethod *vm) {
+	if(!vm) return;
+
+	MEM_freeN(vm->param_type);
+}
+
+/*
+ * Free methods for VMethodGroup
+ */
+void free_verse_methodgroup(VMethodGroup *vmg)
+{
+	struct VMethod *vm, *tmpvm;
+
+	if(!vmg) return;
+
+	vm= vmg->methods.first;
+	while(vm) {
+		tmpvm=vm->next;
+		free_verse_method(vm);
+		vm= tmpvm;
+	}
+	BLI_freelistN(&(vmg->methods));
+}
+
+/* callback for method group creation */
+static void cb_o_method_group_create(
+		void *user_data,
+		VNodeID node_id,
+		uint16 group_id,
+		const char *name)
+{
+	struct VerseSession *session = (VerseSession*)current_verse_session();
+	struct VNode *vnode;
+	struct VMethodGroup *vmg;
+
+	if(!session) return;
+
+	vnode = BLI_dlist_find_link(&(session->nodes), (unsigned int)node_id);
+
+	vmg = lookup_vmethodgroup(&(vnode->methodgroups), group_id);
+	
+	/* create method group holder in node node_id */
+	if(!vmg) {
+		vmg= MEM_mallocN(sizeof(VMethodGroup), "VMethodGroup");
+		vmg->group_id = group_id;
+		vmg->methods.first = vmg->methods.last = NULL;
+		BLI_addtail(&(vnode->methodgroups), vmg);
+		printf("new method group with name %s (group_id %d) for node %u created\n", name, group_id, node_id);
+	}
+
+	/* this ensures name of an existing group gets updated, in case it is changed */
+	BLI_strncpy(vmg->name, (char *)name, 16);
+
+	/* subscribe to method group */
+	verse_send_o_method_group_subscribe(node_id, group_id);
+
+#ifdef VERSECHAT
+	/* if this is our own method group, register our methods */
+	if(node_id==session->avatar) {
+		verse_send_o_method_create(node_id, group_id, (uint8)~0u, vmethod_info[0].name,
+				vmethod_info[0].param_count,
+				(VNOParamType *)vmethod_info[0].param_type,
+				(const char **)vmethod_info[0].param_name);
+		b_verse_update();
+		verse_send_o_method_create(node_id, group_id, (uint8)~0u, vmethod_info[1].name,
+				vmethod_info[1].param_count,
+				(VNOParamType *)vmethod_info[1].param_type,
+				(const char **)vmethod_info[1].param_name);
+		b_verse_update();
+		verse_send_o_method_create(node_id, group_id, (uint8)~0u, vmethod_info[2].name,
+				vmethod_info[2].param_count,
+				(VNOParamType *)vmethod_info[2].param_type,
+				(const char **)vmethod_info[2].param_name);
+		b_verse_update();
+	}
+#endif
+}
+
+/* callback for method group destruction */
+static void cb_o_method_group_destroy(
+		void *user_data,
+		VNodeID node_id,
+		uint16 group_id,
+		const char *name)
+{
+	struct VerseSession *session = (VerseSession*)current_verse_session();
+	struct VNode *vnode;
+	struct VMethodGroup *vmg;
+	struct VMethod *vm;
+
+	printf("method group %d destroyed\n", group_id);
+
+	if(!session) return;
+
+	vnode = BLI_dlist_find_link(&(session->nodes), (unsigned int)node_id);
+	for(vmg= vnode->methodgroups.first; vmg; vmg= vmg->next)
+		if(vmg->group_id==group_id) break;
+
+	if(!vmg) return; /* method group doesn't exist? */
+
+	vmg->group_id = 0;
+	vmg->name[0] = '\0';
+	vm= vmg->methods.first;
+	while(vm) {
+		/* free vm */
+		
+	}
+
+	/* TODO: unsubscribe from method group */
+	BLI_remlink(&(vnode->methodgroups),vmg);
+	MEM_freeN(vmg);
+}
+
+/* callback for method creation */
+static void cb_o_method_create(
+		void *user_data,
+		VNodeID node_id,
+		uint16 group_id,
+		uint16 method_id,
+		const char *name,
+		uint8 param_count,
+		const VNOParamType *param_type,
+		const char *param_name[])
+{
+	struct VerseSession *session = (VerseSession*)current_verse_session();
+	struct VNode *vnode;
+	struct VMethodGroup *vmg;
+	struct VMethod *vm;
+	unsigned int size;
+	unsigned int i;
+	char *put;
+
+	if(!session) return;
+
+	vnode = BLI_dlist_find_link(&(session->nodes), (unsigned int)node_id);
+
+	vmg= lookup_vmethodgroup((&vnode->methodgroups), group_id);
+
+	if(!vmg) return;
+
+	vm= lookup_vmethod((&vmg->methods), method_id);
+
+	if(!vm) {
+		vm= MEM_mallocN(sizeof(VMethod), "VMethod");
+		vm->id= method_id;
+		vm->param_count= param_count;
+		size= param_count* (sizeof(*vm->param_type) + sizeof(*vm->param_name));
+		for(i= 0; i <param_count; i++) {
+			size+=strlen(param_name[i])+1;
+		}
+		vm->param_type= MEM_mallocN(size, "param_type and param_name");
+		memcpy(vm->param_type, param_type, sizeof(VNOParamType)*param_count);
+		vm->param_name= (char **)(vm->param_type + param_count);
+		put= (char *)(vm->param_name + param_count);
+		for(i= 0; i < param_count; i++) {
+			vm->param_name[i]= put;
+			strcpy(put, param_name[i]);
+			put += strlen(param_name[i]) + 1;
+		}
+
+		BLI_addtail(&(vmg->methods), vm);
+#ifdef VERSECHAT
+		if(strcmp(vmethod_info[0].name, name)==0) {
+			vmethod_info[0].id = method_id;
+		}
+#endif
+		printf("method %s in group %d of node %u created\n", name, group_id, node_id);
+	}
+
+	BLI_strncpy(vm->name, (char *)name, 500);
+}
+
+/* callback for method destruction */
+static void cb_o_method_destroy(
+		void *user_data,
+		VNodeID node_id,
+		uint16 group_id,
+		uint16 method_id,
+		const char *name,
+		uint8 param_count,
+		const VNOParamType *param_type,
+		const char *param_name[])
+{
+	struct VerseSession *session = (VerseSession*)current_verse_session();
+	struct VNode *vnode;
+	struct VMethodGroup *vmg;
+	struct VMethod *vm;
+
+	if(!session) return;
+
+	vnode = BLI_dlist_find_link(&(session->nodes), (unsigned int)node_id);
+	for(vmg= vnode->methodgroups.first; vmg; vmg= vmg->next)
+		if(vmg->group_id==group_id) break;
+
+	if(!vmg) return; /* method group doesn't exist? */
+
+	for(vm= vmg->methods.first; vm; vm= vm->next)
+		if(vm->id==method_id) break;
+
+	if(!vm) return;
+
+	BLI_remlink(&(vmg->methods), vm);
+	MEM_freeN(vm->param_type);
+	MEM_freeN(vm);
+}
+
+/* callback for method calls */
+static void cb_o_method_call(void *user_data, VNodeID node_id, uint8 group_id, uint8 method_id, VNodeID sender, VNOPackedParams *params)
+{
+	struct VerseSession *session = (VerseSession*)current_verse_session();
+	struct VNode *vnode;
+	struct VMethodGroup *vmg;
+	struct VMethod *vm;
+	Text *text;
+	int method_idx= -1;
+
+	VNOParam arg[3];
+
+	if(!session) return;
+
+	if(session->avatar!=node_id) return;
+
+	vnode = BLI_dlist_find_link(&(session->nodes), (unsigned int)node_id);
+	vmg= lookup_vmethodgroup(&(vnode->methodgroups), group_id);
+	if(!vmg) return;
+
+	vm= lookup_vmethod(&(vmg->methods), method_id);
+	if(!vm) return;
+#ifdef VERSECHAT
+	if(strcmp(vm->name, "join")==0) method_idx=0;
+	if(strcmp(vm->name, "leave")==0) method_idx=1;
+	if(strcmp(vm->name, "hear")==0) method_idx=2;
+	if(method_idx>-1)
+		verse_method_call_unpack(params, vmethod_info[method_idx].param_count, vmethod_info[method_idx].param_type, arg);
+
+	switch(method_idx) {
+		case 0:
+			printf("Joining channel %s\n",arg[0].vstring);
+			text=add_empty_text();
+			text->flags |= TXT_ISCHAT;
+			rename_id(&(text->id), arg[0].vstring);
+			break;
+		case 1:
+			printf("Leaving channel %s\n",arg[0].vstring);
+			break;
+		case 2:
+			{
+				ListBase lb = G.main->text;
+				ID *id= (ID *)lb.first;
+				char showstr[1024];
+				showstr[0]='\0';
+				text = NULL;
+				sprintf(showstr, "%s: %s\n", arg[1].vstring, arg[2].vstring);
+				for(; id; id= id->next) {
+					if(strcmp(id->name+2, arg[0].vstring)==0 && strcmp(arg[0].vstring, "#server")!=0) {
+						text = (Text *)id;
+						break;
+					}
+				}
+				if(text) {
+					txt_insert_buf(text, showstr);
+					txt_move_eof(text, 0);
+					allqueue(REDRAWCHAT, 0);
+				} else {
+					printf("%s> %s: %s\n",arg[0].vstring, arg[1].vstring, arg[2].vstring);
+				}
+			}
+			break;
+	}
+#endif
+}
+
+void set_method_callbacks(void)
+{
+	/* create and destroy method groups */
+	verse_callback_set(verse_send_o_method_group_create, cb_o_method_group_create, NULL);
+	verse_callback_set(verse_send_o_method_group_destroy, cb_o_method_group_destroy, NULL);
+
+	/* create and destroy methods */
+	verse_callback_set(verse_send_o_method_create, cb_o_method_create, NULL);
+	verse_callback_set(verse_send_o_method_destroy, cb_o_method_destroy, NULL);
+
+	/* call methods */
+	verse_callback_set(verse_send_o_method_call, cb_o_method_call, NULL);
+}
+
+#endif
diff --git a/source/blender/blenkernel/intern/verse_node.c b/source/blender/blenkernel/intern/verse_node.c
index 774917a5581..fd5a25598d3 100644
--- a/source/blender/blenkernel/intern/verse_node.c
+++ b/source/blender/blenkernel/intern/verse_node.c
@@ -306,6 +306,17 @@ void free_verse_node(VNode *vnode)
 }
 
 /*
+ * Find a Verse Node from session
+ */
+VNode* lookup_vnode(VerseSession *session, VNodeID node_id)
+{
+	struct VNode *vnode;
+	vnode = BLI_dlist_find_link(&(session->nodes), (unsigned int)node_id);
+
+	return vnode;
+}
+
+/*
  * create new Verse Node
  */
 VNode* create_verse_node(VerseSession *session, VNodeID node_id, uint8 type, VNodeID owner_id)
@@ -322,12 +333,16 @@ VNode* create_verse_node(VerseSession *session, VNodeID node_id, uint8 type, VNo
 
 	BLI_dlist_init(&(vnode->taggroups));
 	vnode->queue.first = vnode->queue.last = NULL;
+	vnode->methodgroups.first = vnode->methodgroups.last = NULL;
 
 	vnode->data = NULL;
 
 	vnode->counter = 0;
 
 	vnode->flag = 0;
+#ifdef VERSECHAT
+	vnode->chat_flag = CHAT_NOTLOGGED;
+#endif
 
 	vnode->post_node_create = post_node_create;
 	vnode->post_node_destroy = post_node_destroy;
diff --git a/source/blender/blenkernel/intern/verse_object_node.c b/source/blender/blenkernel/intern/verse_object_node.c
index ce66109723e..d8be38cd00f 100644
--- a/source/blender/blenkernel/intern/verse_object_node.c
+++ b/source/blender/blenkernel/intern/verse_object_node.c
@@ -33,6 +33,7 @@
 #include "MEM_guardedalloc.h"
 
 #include "DNA_listBase.h"
+#include "DNA_userdef_types.h"
 
 #include "BLI_dynamiclist.h"
 #include "BLI_blenlib.h"
@@ -260,6 +261,7 @@ void free_object_data(VNode *vnode)
 	struct VerseSession *session = vnode->session;
 	struct VObjectData *obj = (VObjectData*)vnode->data;
 	struct VLink *vlink;
+	struct VMethodGroup *vmg;
 
 	if(!obj) return;
 
@@ -279,6 +281,12 @@ void free_object_data(VNode *vnode)
 	/* free dynamic list and sendig queue of links */
 	BLI_dlist_destroy(&(obj->links));
 	BLI_freelistN(&(obj->queue));
+	
+	/* free method groups and their methods */
+	for(vmg = vnode->methodgroups.first; vmg; vmg= vmg->next) {
+		free_verse_methodgroup(vmg);
+	}
+	BLI_freelistN(&(vnode->methodgroups));
 
 	/* free constraint between VerseNode and Object */
 	obj->post_object_free_constraint(vnode);
diff --git a/source/blender/blenkernel/intern/verse_session.c b/source/blender/blenkernel/intern/verse_session.c
index 288bfd01a9d..1226fffd929 100644
--- a/source/blender/blenkernel/intern/verse_session.c
+++ b/source/blender/blenkernel/intern/verse_session.c
@@ -185,6 +185,10 @@ static void cb_connect_accept(
 	for(i = 0; i < V_NT_NUM_TYPES; i++)
 		mask = mask | (1 << i);
 	verse_send_node_index_subscribe(mask);
+	verse_send_node_subscribe(session->avatar); /* subscribe to avatar node, as well */
+
+	/* create our own method group and method */
+	/*verse_send_o_method_group_create(session->avatar, ~0, "tawk-client");*/
 }
 
 /*
@@ -218,6 +222,9 @@ static void set_all_callbacks(void)
 
 	/* set up all callbacks for bitmap nodes */
 	set_bitmap_callbacks();
+	
+	/* set up all callbacks for method groups and methods */
+	set_method_callbacks();
 }
 
 /*