blender/extern/verse/dist/vs_node_geometry.c
2006-10-02 13:29:17 +00:00

1048 lines
40 KiB
C

/*
**
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "v_cmd_gen.h"
#if !defined V_GENERATE_FUNC_MODE
#include "verse.h"
#include "v_util.h"
#include "vs_server.h"
#define VS_G_LAYER_CHUNK 32
typedef struct {
VNGLayerType type;
char name[16];
void *layer;
VSSubscriptionList *subscribers;
VSSubscriptionList *subscribersd;
union{
uint32 integer;
real64 real;
} def;
} VSNGLayer;
typedef struct {
char weight[16];
char reference[16];
uint16 parent;
real64 pos_x;
real64 pos_y;
real64 pos_z;
char position_label[16];
char rotation_label[16];
char scale_label[16];
} VSNGBone;
typedef struct {
VSNodeHead head;
VSNGLayer *layer;
uint16 layer_count;
uint32 vertex_size;
uint32 poly_size;
uint32 vertex_hole;
uint32 polygon_hole;
uint32 crease_vertex;
char crease_vertex_layer[16];
uint32 crease_edge;
char crease_edge_layer[16];
VSNGBone *bones;
uint32 bone_count;
} VSNodeGeometry;
VSNodeGeometry * vs_g_create_node(unsigned int owner)
{
VSNodeGeometry *node;
unsigned int i;
char name[48];
node = malloc(sizeof *node);
vs_add_new_node(&node->head, V_NT_GEOMETRY);
sprintf(name, "Geometry_Node_%u", node->head.id);
create_node_head(&node->head, name, owner);
node->bones = malloc((sizeof *node->bones) * 16);
node->bone_count = 16;
for(i = 0; i < node->bone_count; i++)
node->bones[i].weight[0] = '\0';
node->layer = malloc((sizeof *node->layer) * 16);
node->layer_count = 16;
node->vertex_size = VS_G_LAYER_CHUNK;
node->poly_size = VS_G_LAYER_CHUNK;
strcpy(node->layer[0].name, "vertex");
node->layer[0].type = VN_G_LAYER_VERTEX_XYZ;
node->layer[0].layer = malloc(sizeof(real64) * VS_G_LAYER_CHUNK * 3);
for(i = 0; i < VS_G_LAYER_CHUNK * 3; i++)
((real64 *)node->layer[0].layer)[i] = V_REAL64_MAX;
node->layer[0].subscribers = NULL;/*vs_create_subscription_list();*/
node->layer[0].subscribersd = NULL;/*vs_create_subscription_list();*/
node->layer[0].def.real = 0;
strcpy(node->layer[1].name, "polygon");
node->layer[1].type = VN_G_LAYER_POLYGON_CORNER_UINT32;
node->layer[1].layer = malloc(sizeof(uint32) * VS_G_LAYER_CHUNK * 4);
for(i = 0; i < VS_G_LAYER_CHUNK * 4; i++)
((uint32 *)node->layer[1].layer)[i] = -1;
node->layer[1].subscribers = NULL;/*vs_create_subscription_list();*/
node->layer[1].subscribersd = NULL;
node->layer[1].def.integer = 0;
node->layer[1].def.real = 0.0;
for(i = 2; i < 16; i++)
{
node->layer[i].type = -1;
node->layer[i].name[0] = 0;
node->layer[i].layer = NULL;
node->layer[i].subscribers = NULL;
node->layer[i].subscribersd = NULL;
node->layer[i].def.real = 0;
}
node->crease_vertex = 0;
node->crease_vertex_layer[0] = 0;
node->crease_edge = 0;
node->crease_edge_layer[0] = 0;
node->vertex_hole = 0;
node->polygon_hole = 0;
return node;
}
void vs_g_destroy_node(VSNodeGeometry *node)
{
destroy_node_head(&node->head);
free(node);
}
void vs_g_subscribe(VSNodeGeometry *node)
{
unsigned int i;
for(i = 0; i < node->layer_count; i++)
{
if(node->layer[i].layer != NULL)
{
verse_send_g_layer_create(node->head.id, (uint16)i, node->layer[i].name, node->layer[i].type,
node->layer[i].def.integer, node->layer[i].def.real);
}
}
verse_send_g_crease_set_vertex(node->head.id, node->crease_vertex_layer, node->crease_vertex);
verse_send_g_crease_set_edge(node->head.id, node->crease_edge_layer, node->crease_edge);
for(i = 0; i < node->bone_count; i++)
{
if(node->bones[i].weight[0] != 0)
verse_send_g_bone_create(node->head.id, (uint16)i, node->bones[i].weight, node->bones[i].reference, node->bones[i].parent,
node->bones[i].pos_x, node->bones[i].pos_y, node->bones[i].pos_z, node->bones[i].position_label,
node->bones[i].rotation_label, node->bones[i].scale_label);
}
}
void vs_g_unsubscribe(VSNodeGeometry *node)
{
unsigned int i;
for(i = 0; i < node->layer_count; i++) {
if(node->layer[i].layer != NULL) {
if(node->layer[i].subscribers)
vs_remove_subscriptor(node->layer[i].subscribers);
if(node->layer[i].subscribersd)
vs_remove_subscriptor(node->layer[i].subscribersd);
}
}
}
static void callback_send_g_layer_create(void *user, VNodeID node_id, VLayerID layer_id, char *name, uint8 type, uint32 def_uint, real64 def_real)
{
VSNodeGeometry *node;
unsigned int i, j, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if((type < VN_G_LAYER_POLYGON_CORNER_UINT32 && type > VN_G_LAYER_VERTEX_REAL) ||
(type > VN_G_LAYER_POLYGON_FACE_REAL))
return;
if(layer_id < 2)
layer_id = -1;
for(i = 0; i < node->layer_count; i++)
{
if(node->layer[i].layer != NULL && i != layer_id)
{
for(j = 0; name[j] == node->layer[i].name[j] && name[j] != 0; j++);
if(name[j] == node->layer[i].name[j])
return;
}
}
if(layer_id >= node->layer_count || node->layer[layer_id].layer == NULL)
{
for(layer_id = 0; layer_id < node->layer_count && node->layer[layer_id].layer != NULL; layer_id++);
if(layer_id == node->layer_count)
{
layer_id = node->layer_count;
node->layer_count += 16;
node->layer = realloc(node->layer, (sizeof *node->layer) * node->layer_count);
for(i = layer_id; i < node->layer_count; i++)
{
node->layer[i].type = -1;
node->layer[i].name[0] = 0;
node->layer[i].layer = 0;
node->layer[i].subscribers = NULL;
node->layer[i].subscribersd = NULL;
}
}
}
for(i = 0; i < 16; i++)
node->layer[layer_id].name[i] = name[i];
if(node->layer[layer_id].type != type)
{
if(node->layer[layer_id].subscribers) {
vs_destroy_subscription_list(node->layer[layer_id].subscribers);
node->layer[layer_id].subscribers = NULL;
}
if(node->layer[layer_id].subscribersd) {
vs_destroy_subscription_list(node->layer[layer_id].subscribersd);
node->layer[layer_id].subscribersd = NULL;
}
node->layer[layer_id].type = type;
free(node->layer[layer_id].layer);
switch(type)
{
case VN_G_LAYER_VERTEX_XYZ :
node->layer[layer_id].layer = malloc(sizeof(real64) * node->vertex_size * 3);
for(i = 0; i < node->vertex_size * 3; i++)
((real64 *)node->layer[layer_id].layer)[i] = ((real64 *)node->layer[0].layer)[i];
break;
case VN_G_LAYER_VERTEX_UINT32 :
node->layer[layer_id].layer = malloc(sizeof(uint32) * node->vertex_size);
for(i = 0; i < node->vertex_size; i++)
((uint32 *)node->layer[layer_id].layer)[i] = def_uint;
node->layer[layer_id].def.integer = def_uint;
break;
case VN_G_LAYER_VERTEX_REAL :
node->layer[layer_id].layer = malloc(sizeof(real64) * node->vertex_size);
for(i = 0; i < node->vertex_size; i++)
((real64 *)node->layer[layer_id].layer)[i] = def_real;
node->layer[layer_id].def.real = def_real;
break;
case VN_G_LAYER_POLYGON_CORNER_UINT32 :
node->layer[layer_id].layer = malloc(sizeof(uint32) * node->poly_size * 4);
for(i = 0; i < node->poly_size * 4; i++)
((uint32 *)node->layer[layer_id].layer)[i] = def_uint;
node->layer[layer_id].def.integer = def_uint;
break;
case VN_G_LAYER_POLYGON_CORNER_REAL :
node->layer[layer_id].layer = malloc(sizeof(real64) * node->poly_size * 4);
for(i = 0; i < node->poly_size * 4; i++)
((real64 *)node->layer[layer_id].layer)[i] = def_real;
node->layer[layer_id].def.real = def_real;
break;
case VN_G_LAYER_POLYGON_FACE_UINT8 :
node->layer[layer_id].layer = malloc(sizeof(uint8) * node->poly_size);
for(i = 0; i < node->poly_size; i++)
((uint8 *)node->layer[layer_id].layer)[i] = def_uint;
node->layer[layer_id].def.integer = def_uint;
break;
case VN_G_LAYER_POLYGON_FACE_UINT32 :
node->layer[layer_id].layer = malloc(sizeof(uint32) * node->poly_size);
for(i = 0; i < node->poly_size; i++)
((uint32 *)node->layer[layer_id].layer)[i] = def_uint;
node->layer[layer_id].def.integer = def_uint;
break;
case VN_G_LAYER_POLYGON_FACE_REAL :
node->layer[layer_id].layer = malloc(sizeof(real64) * node->poly_size);
for(i = 0; i < node->poly_size; i++)
((real64 *)node->layer[layer_id].layer)[i] = def_real;
node->layer[layer_id].def.real = def_real;
break;
}
}
count = vs_get_subscript_count(node->head.subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->head.subscribers, i);
verse_send_g_layer_create(node_id, layer_id, name, type, def_uint, def_real);
}
vs_reset_subscript_session();
}
static void callback_send_g_layer_destroy(void *user, VNodeID node_id, VLayerID layer_id)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(layer_id >= node->layer_count || node->layer[layer_id].layer == NULL || layer_id < 2)
return;
free(node->layer[layer_id].layer);
node->layer[layer_id].layer = NULL;
node->layer[layer_id].name[0] = 0;
node->layer[layer_id].type = -1;
if(node->layer[layer_id].subscribers) {
vs_destroy_subscription_list(node->layer[layer_id].subscribers);
node->layer[layer_id].subscribers = NULL;
}
if(node->layer[layer_id].subscribersd) {
vs_destroy_subscription_list(node->layer[layer_id].subscribersd);
node->layer[layer_id].subscribersd = NULL;
}
count = vs_get_subscript_count(node->head.subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->head.subscribers, i);
verse_send_g_layer_destroy(node_id, layer_id);
}
vs_reset_subscript_session();
}
static void callback_send_g_layer_subscribe(void *user, VNodeID node_id, VLayerID layer_id, uint8 type)
{
VSNodeGeometry *node;
VSNGLayer *layer;
VSSubscriptionList **list = NULL;
unsigned int i;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(layer_id >= node->layer_count || node->layer[layer_id].layer == NULL)
return;
/* Pick subscription list to add subscriber to. */
layer = &node->layer[layer_id];
if(type == VN_FORMAT_REAL64 && (layer->type == VN_G_LAYER_VERTEX_XYZ || layer->type == VN_G_LAYER_VERTEX_REAL ||
layer->type == VN_G_LAYER_POLYGON_CORNER_REAL || layer->type == VN_G_LAYER_POLYGON_FACE_REAL))
{
list = &node->layer[layer_id].subscribersd;
}
else
list = &node->layer[layer_id].subscribers;
/* Add new subscriptor to whichever list was chosen by precision-test above. Create list if necessary. */
if(list == NULL)
return;
if(*list == NULL)
*list = vs_create_subscription_list();
vs_add_new_subscriptor(*list);
switch(layer->type)
{
case VN_G_LAYER_VERTEX_XYZ :
if(type == VN_FORMAT_REAL64)
{
for(i = 0; i < node->vertex_size; i++)
if(((real64 *)node->layer[0].layer)[i * 3] != V_REAL64_MAX)
verse_send_g_vertex_set_xyz_real64(node_id, layer_id, i, ((real64 *)layer->layer)[i * 3], ((real64 *)layer->layer)[i * 3 + 1], ((real64 *)layer->layer)[i * 3 + 2]);
}else
{
for(i = 0; i < node->vertex_size; i++)
if(((real64 *)node->layer[0].layer)[i * 3] != V_REAL64_MAX)
verse_send_g_vertex_set_xyz_real32(node_id, layer_id, i, (float)((real64 *)layer->layer)[i * 3], (float)((real64 *)layer->layer)[i * 3 + 1], (float)((real64 *)layer->layer)[i * 3 + 2]);
}
break;
case VN_G_LAYER_VERTEX_UINT32 :
for(i = 0; i < node->vertex_size; i++)
if(((real64 *)node->layer[0].layer)[i * 3] != V_REAL64_MAX && ((uint32 *)layer->layer)[i] != layer->def.integer)
verse_send_g_vertex_set_uint32(node_id, layer_id, i, ((uint32 *)layer->layer)[i]);
break;
case VN_G_LAYER_VERTEX_REAL :
if(type == VN_FORMAT_REAL64)
{
for(i = 0; i < node->vertex_size; i++)
if(((real64 *)node->layer[0].layer)[i * 3] != V_REAL64_MAX && ((real64 *)layer->layer)[i] != layer->def.real)
verse_send_g_vertex_set_real64(node_id, layer_id, i, ((real64 *)layer->layer)[i]);
}else
{
for(i = 0; i < node->vertex_size; i++)
if(((real64 *)node->layer[0].layer)[i * 3] != V_REAL64_MAX && ((real64 *)layer->layer)[i] != layer->def.real)
verse_send_g_vertex_set_real32(node_id, layer_id, i, (float)((real64 *)layer->layer)[i]);
}
break;
case VN_G_LAYER_POLYGON_CORNER_UINT32 :
for(i = 0; i < node->poly_size; i++)
if(((uint32 *)node->layer[1].layer)[i * 4] != (uint32) ~0u && !(((uint32 *)layer->layer)[i * 4] == layer->def.integer && ((uint32 *)layer->layer)[i * 4 + 1] == layer->def.integer && ((uint32 *)layer->layer)[i * 4 + 2] == layer->def.integer && ((uint32 *)layer->layer)[i * 4 + 3] == layer->def.integer))
verse_send_g_polygon_set_corner_uint32(node_id, layer_id, i, ((uint32 *)layer->layer)[i * 4], ((uint32 *)layer->layer)[i * 4 + 1], ((uint32 *)layer->layer)[i * 4 + 2], ((uint32 *)layer->layer)[i * 4 + 3]);
break;
case VN_G_LAYER_POLYGON_CORNER_REAL :
if(type == VN_FORMAT_REAL64)
{
for(i = 0; i < node->poly_size; i++)
if(((uint32 *)node->layer[1].layer)[i * 4] != (uint32) ~0u && !(((real64 *)layer->layer)[i * 4] == layer->def.real && ((real64 *)layer->layer)[i * 4 + 1] == layer->def.real && ((real64 *)layer->layer)[i * 4 + 2] == layer->def.real && ((real64 *)layer->layer)[i * 4 + 3] == layer->def.real))
verse_send_g_polygon_set_corner_real64(node_id, layer_id, i, ((real64 *)layer->layer)[i * 4], ((real64 *)layer->layer)[i * 4 + 1], ((real64 *)layer->layer)[i * 4 + 2], ((real64 *)layer->layer)[i * 4 + 3]);
}else
{
for(i = 0; i < node->poly_size; i++)
if(((uint32 *)node->layer[1].layer)[i * 4] != (uint32) ~0u && !(((real64 *)layer->layer)[i * 4] == layer->def.real && ((real64 *)layer->layer)[i * 4 + 1] == layer->def.real && ((real64 *)layer->layer)[i * 4 + 2] == layer->def.real && ((real64 *)layer->layer)[i * 4 + 3] == layer->def.real))
verse_send_g_polygon_set_corner_real32(node_id, layer_id, i, (float)((real64 *)layer->layer)[i * 4], (float)((real64 *)layer->layer)[i * 4 + 1], (float)((real64 *)layer->layer)[i * 4 + 2], (float)((real64 *)layer->layer)[i * 4 + 3]);
}
break;
case VN_G_LAYER_POLYGON_FACE_UINT8 :
for(i = 0; i < node->poly_size; i++)
if(((uint32 *)node->layer[1].layer)[i * 4] != (uint32) ~0u && ((uint8 *)layer->layer)[i] != layer->def.integer)
verse_send_g_polygon_set_face_uint8(node_id, layer_id, i, ((uint8 *)layer->layer)[i]);
break;
case VN_G_LAYER_POLYGON_FACE_UINT32 :
for(i = 0; i < node->poly_size; i++)
if(((uint32 *)node->layer[1].layer)[i * 4] != (uint32) ~0u && ((uint32 *)layer->layer)[i] != layer->def.integer)
verse_send_g_polygon_set_face_uint32(node_id, layer_id, i, ((uint32 *)layer->layer)[i]);
break;
case VN_G_LAYER_POLYGON_FACE_REAL :
if(type == VN_FORMAT_REAL64)
{
for(i = 0; i < node->poly_size; i++)
if(((uint32 *)node->layer[1].layer)[i * 4] != (uint32) ~0u && ((real64 *)layer->layer)[i] != layer->def.real)
verse_send_g_polygon_set_face_real64(node_id, layer_id, i, ((real64 *)layer->layer)[i]);
}else
{
for(i = 0; i < node->poly_size; i++)
if(((uint32 *)node->layer[1].layer)[i * 4] != (uint32) ~0u && ((real64 *)layer->layer)[i] != layer->def.real)
verse_send_g_polygon_set_face_real32(node_id, layer_id, i, (float)((real64 *)layer->layer)[i]);
}
break;
}
}
static void callback_send_g_layer_unsubscribe(void *user, VNodeID node_id, VLayerID layer_id)
{
VSNodeGeometry *node;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(layer_id >= node->layer_count || node->layer[layer_id].layer == NULL)
return;
if(node->layer[layer_id].subscribers)
vs_remove_subscriptor(node->layer[layer_id].subscribers);
if(node->layer[layer_id].subscribersd)
vs_remove_subscriptor(node->layer[layer_id].subscribersd);
}
static unsigned int vs_g_extend_arrays(VSNodeGeometry *node, boolean vertex, boolean base_layer, unsigned int id)
{
unsigned int i, j;
if(base_layer && id == ~0u)
{
if(vertex)
{
while(node->vertex_hole < node->vertex_size && ((real64 *)node->layer[0].layer)[node->vertex_hole * 3] != V_REAL64_MAX)
node->vertex_hole++;
id = node->vertex_hole;
}else
{
while(node->polygon_hole < node->poly_size && ((uint32 *)node->layer[1].layer)[node->polygon_hole * 4] != ~0u)
node->polygon_hole++;
id = node->polygon_hole;
}
}
if(vertex)
{
if(node->vertex_size + 4096 < id)
return -1;
if(node->vertex_size > id)
return id;
}else
{
if(node->poly_size + 4096 < id)
return -1;
if(node->poly_size > id)
return id;
}
for(i = 0; i < node->layer_count; i++)
{
if((vertex && node->layer[i].type < VN_G_LAYER_POLYGON_CORNER_UINT32) || (!vertex && node->layer[i].type >= VN_G_LAYER_POLYGON_CORNER_UINT32))
{
switch(node->layer[i].type)
{
case VN_G_LAYER_VERTEX_XYZ :
node->layer[i].layer = realloc(node->layer[i].layer, sizeof(real64) * (id + VS_G_LAYER_CHUNK) * 3);
for(j = node->vertex_size * 3; j < (id + VS_G_LAYER_CHUNK) * 3; j++)
((real64 *)node->layer[i].layer)[j] = V_REAL64_MAX;
break;
case VN_G_LAYER_VERTEX_UINT32 :
node->layer[i].layer = realloc(node->layer[i].layer, sizeof(uint32) * (id + VS_G_LAYER_CHUNK));
for(j = node->vertex_size; j < (id + VS_G_LAYER_CHUNK); j++)
((uint32 *)node->layer[i].layer)[j] = node->layer[i].def.integer;
break;
case VN_G_LAYER_VERTEX_REAL :
node->layer[i].layer = realloc(node->layer[i].layer, sizeof(real64) * (id + VS_G_LAYER_CHUNK));
for(j = node->vertex_size; j < (id + VS_G_LAYER_CHUNK); j++)
((real64 *)node->layer[i].layer)[j] = node->layer[i].def.real;
break;
case VN_G_LAYER_POLYGON_CORNER_UINT32 :
node->layer[i].layer = realloc(node->layer[i].layer, sizeof(uint32) * (id + VS_G_LAYER_CHUNK) * 4);
for(j = node->poly_size * 4; j < (id + VS_G_LAYER_CHUNK) * 4; j++)
((uint32 *)node->layer[i].layer)[j] = node->layer[i].def.integer;
break;
case VN_G_LAYER_POLYGON_CORNER_REAL :
node->layer[i].layer = realloc(node->layer[i].layer, sizeof(real64) * (id + VS_G_LAYER_CHUNK) * 4);
for(j = node->poly_size * 4; j < (id + VS_G_LAYER_CHUNK) * 4; j++)
((real64 *)node->layer[i].layer)[j] = node->layer[i].def.real;
break;
case VN_G_LAYER_POLYGON_FACE_UINT8 :
node->layer[i].layer = realloc(node->layer[i].layer, sizeof(uint8) * (id + VS_G_LAYER_CHUNK));
for(j = node->poly_size; j < (id + VS_G_LAYER_CHUNK); j++)
((uint8 *)node->layer[i].layer)[j] = node->layer[i].def.integer;
break;
case VN_G_LAYER_POLYGON_FACE_UINT32 :
node->layer[i].layer = realloc(node->layer[i].layer, sizeof(uint32) * (id + VS_G_LAYER_CHUNK));
for(j = node->poly_size; j < (id + VS_G_LAYER_CHUNK); j++)
((uint32 *)node->layer[i].layer)[j] = node->layer[i].def.integer;
break;
case VN_G_LAYER_POLYGON_FACE_REAL :
node->layer[i].layer = realloc(node->layer[i].layer, sizeof(real64) * (id + VS_G_LAYER_CHUNK));
for(j = node->poly_size; j < (id + VS_G_LAYER_CHUNK); j++)
((real64 *)node->layer[i].layer)[j] = node->layer[i].def.real;
break;
}
}
}
if(vertex)
node->vertex_size = id + VS_G_LAYER_CHUNK;
else
node->poly_size = id + VS_G_LAYER_CHUNK;
return id;
}
static void callback_send_g_vertex_set_xyz_real32(void *user, VNodeID node_id, VLayerID layer_id, uint32 vertex_id, float x, float y, float z)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(layer_id >= node->layer_count || node->layer[layer_id].layer == NULL || node->layer[layer_id].type != VN_G_LAYER_VERTEX_XYZ)
return;
if((vertex_id = vs_g_extend_arrays(node, TRUE, layer_id == 0, vertex_id)) == ~0u)
return;
if(((real64 *)node->layer[0].layer)[vertex_id * 3] == V_REAL64_MAX)
{
for(i = 0; i < node->layer_count; i++)
{
if(node->layer[i].name[0] != 0 && node->layer[i].type == VN_G_LAYER_VERTEX_XYZ && node->layer[i].layer != NULL)
{
((real64 *)node->layer[i].layer)[vertex_id * 3] = x;
((real64 *)node->layer[i].layer)[vertex_id * 3 + 1] = y;
((real64 *)node->layer[i].layer)[vertex_id * 3 + 2] = z;
}
}
layer_id = 0;
}else
{
((real64 *)node->layer[layer_id].layer)[vertex_id * 3] = x;
((real64 *)node->layer[layer_id].layer)[vertex_id * 3 + 1] = y;
((real64 *)node->layer[layer_id].layer)[vertex_id * 3 + 2] = z;
}
count = vs_get_subscript_count(node->layer[layer_id].subscribersd);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribersd, i);
verse_send_g_vertex_set_xyz_real64(node_id, layer_id, vertex_id, (real64)x, (real64)y, (real64)z);
}
count = vs_get_subscript_count(node->layer[layer_id].subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribers, i);
verse_send_g_vertex_set_xyz_real32(node_id, layer_id, vertex_id, x, y, z);
}
vs_reset_subscript_session();
}
static void callback_send_g_vertex_set_xyz_real64(void *user, VNodeID node_id, VLayerID layer_id, uint32 vertex_id, real64 x, real64 y, real64 z)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(layer_id >= node->layer_count || node->layer[layer_id].layer == NULL || node->layer[layer_id].type != VN_G_LAYER_VERTEX_XYZ)
return;
if((vertex_id = vs_g_extend_arrays(node, TRUE, layer_id == 0, vertex_id)) == ~0u)
return;
if(((real64 *)node->layer[0].layer)[vertex_id * 3] == V_REAL64_MAX)
{
for(i = 0; i < node->layer_count; i++)
{
if(node->layer[i].name[0] != 0 && node->layer[i].type == VN_G_LAYER_VERTEX_XYZ && node->layer[i].layer != NULL)
{
((real64 *)node->layer[i].layer)[vertex_id * 3] = x;
((real64 *)node->layer[i].layer)[vertex_id * 3 + 1] = y;
((real64 *)node->layer[i].layer)[vertex_id * 3 + 2] = z;
}
}
layer_id = 0;
}else
{
((real64 *)node->layer[layer_id].layer)[vertex_id * 3] = x;
((real64 *)node->layer[layer_id].layer)[vertex_id * 3 + 1] = y;
((real64 *)node->layer[layer_id].layer)[vertex_id * 3 + 2] = z;
}
count = vs_get_subscript_count(node->layer[layer_id].subscribersd);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribersd, i);
verse_send_g_vertex_set_xyz_real64(node_id, layer_id, vertex_id, x, y, z);
}
count = vs_get_subscript_count(node->layer[layer_id].subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribers, i);
verse_send_g_vertex_set_xyz_real32(node_id, layer_id, vertex_id, (float)x, (float)y, (float)z);
}
vs_reset_subscript_session();
}
static void callback_send_g_vertex_delete_real(void *user, VNodeID node_id, uint32 vertex_id)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(vertex_id >= node->vertex_size)
return;
if(vertex_id < node->vertex_hole)
node->vertex_hole = vertex_id;
for(i = 0; i < node->layer_count; i++)
if(node->layer[i].name[0] != 0 && node->layer[i].type == VN_G_LAYER_VERTEX_XYZ && node->layer[i].layer != NULL)
((real64 *)node->layer[i].layer)[vertex_id * 3] = V_REAL64_MAX;
count = vs_get_subscript_count(node->layer[0].subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[0].subscribers, i);
verse_send_g_vertex_delete_real32(node_id, vertex_id);
}
count = vs_get_subscript_count(node->layer[0].subscribersd);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[0].subscribersd, i);
verse_send_g_vertex_delete_real64(node_id, vertex_id);
}
vs_reset_subscript_session();
}
static void callback_send_g_vertex_set_uint32(void *user, VNodeID node_id, VLayerID layer_id, uint32 vertex_id, uint32 value)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(layer_id >= node->layer_count || node->layer[layer_id].layer == NULL || node->layer[layer_id].type != VN_G_LAYER_VERTEX_UINT32)
return;
if((vertex_id = vs_g_extend_arrays(node, TRUE, FALSE, vertex_id)) == ~0u)
return;
((uint32 *)node->layer[layer_id].layer)[vertex_id] = value;
count = vs_get_subscript_count(node->layer[layer_id].subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribers, i);
verse_send_g_vertex_set_uint32(node_id, layer_id, vertex_id, value);
}
vs_reset_subscript_session();
}
static void callback_send_g_vertex_set_real64(void *user, VNodeID node_id, VLayerID layer_id, uint32 vertex_id, real64 value)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(layer_id >= node->layer_count || node->layer[layer_id].layer == NULL || node->layer[layer_id].type != VN_G_LAYER_VERTEX_REAL)
return;
if((vertex_id = vs_g_extend_arrays(node, TRUE, FALSE, vertex_id)) == ~0u)
return;
((real64 *)node->layer[layer_id].layer)[vertex_id] = value;
count = vs_get_subscript_count(node->layer[layer_id].subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribers, i);
verse_send_g_vertex_set_real32(node_id, layer_id, vertex_id, (float)value);
}
count = vs_get_subscript_count(node->layer[layer_id].subscribersd);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribersd, i);
verse_send_g_vertex_set_real64(node_id, layer_id, vertex_id, value);
}
vs_reset_subscript_session();
}
static void callback_send_g_vertex_set_real32(void *user, VNodeID node_id, VLayerID layer_id, uint32 vertex_id, float value)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(layer_id >= node->layer_count || node->layer[layer_id].layer == NULL || node->layer[layer_id].type != VN_G_LAYER_VERTEX_REAL)
return;
if((vertex_id = vs_g_extend_arrays(node, TRUE, FALSE, vertex_id)) == ~0u)
return;
((real64 *)node->layer[layer_id].layer)[vertex_id] = (real64)value;
count = vs_get_subscript_count(node->layer[layer_id].subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribers, i);
verse_send_g_vertex_set_real32(node_id, layer_id, vertex_id, value);
}
count = vs_get_subscript_count(node->layer[layer_id].subscribersd);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribersd, i);
verse_send_g_vertex_set_real64(node_id, layer_id, vertex_id, (real64)value);
}
vs_reset_subscript_session();
}
static void callback_send_g_polygon_set_corner_uint32(void *user, VNodeID node_id, VLayerID layer_id, uint32 polygon_id, uint32 v0, uint32 v1, uint32 v2, uint32 v3)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(layer_id >= node->layer_count || node->layer[layer_id].layer == NULL || node->layer[layer_id].type != VN_G_LAYER_POLYGON_CORNER_UINT32)
return;
if(layer_id == 1 && (v0 == v1 || v1 == v2 || v2 == v3 || v3 == v0 || v0 == v2 || v1 == v3))
return;
if((polygon_id = vs_g_extend_arrays(node, FALSE, layer_id == 1, polygon_id)) == ~0u)
return;
((uint32 *)node->layer[layer_id].layer)[polygon_id * 4] = v0;
((uint32 *)node->layer[layer_id].layer)[polygon_id * 4 + 1] = v1;
((uint32 *)node->layer[layer_id].layer)[polygon_id * 4 + 2] = v2;
((uint32 *)node->layer[layer_id].layer)[polygon_id * 4 + 3] = v3;
count = vs_get_subscript_count(node->layer[layer_id].subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribers, i);
verse_send_g_polygon_set_corner_uint32(node_id, layer_id, polygon_id, v0, v1, v2, v3);
}
vs_reset_subscript_session();
}
static void callback_send_g_polygon_set_corner_real64(void *user, VNodeID node_id, VLayerID layer_id, uint32 polygon_id, real64 v0, real64 v1, real64 v2, real64 v3)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(layer_id >= node->layer_count || node->layer[layer_id].layer == NULL || node->layer[layer_id].type != VN_G_LAYER_POLYGON_CORNER_REAL)
return;
if((polygon_id = vs_g_extend_arrays(node, FALSE, FALSE, polygon_id)) == ~0u)
return;
((real64 *)node->layer[layer_id].layer)[polygon_id * 4] = v0;
((real64 *)node->layer[layer_id].layer)[polygon_id * 4 + 1] = v1;
((real64 *)node->layer[layer_id].layer)[polygon_id * 4 + 2] = v2;
((real64 *)node->layer[layer_id].layer)[polygon_id * 4 + 3] = v3;
count = vs_get_subscript_count(node->layer[layer_id].subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribers, i);
verse_send_g_polygon_set_corner_real32(node_id, layer_id, polygon_id, (float)v0, (float)v1, (float)v2, (float)v3);
}
count = vs_get_subscript_count(node->layer[layer_id].subscribersd);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribersd, i);
verse_send_g_polygon_set_corner_real64(node_id, layer_id, polygon_id, v0, v1, v2, v3);
}
vs_reset_subscript_session();
}
static void callback_send_g_polygon_set_corner_real32(void *user, VNodeID node_id, VLayerID layer_id, uint32 polygon_id, float v0, float v1, float v2, float v3)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(layer_id >= node->layer_count || node->layer[layer_id].layer == NULL || node->layer[layer_id].type != VN_G_LAYER_POLYGON_CORNER_REAL)
return;
if((polygon_id = vs_g_extend_arrays(node, FALSE, FALSE, polygon_id)) == ~0u)
return;
((real64 *)node->layer[layer_id].layer)[polygon_id * 4] = v0;
((real64 *)node->layer[layer_id].layer)[polygon_id * 4 + 1] = v1;
((real64 *)node->layer[layer_id].layer)[polygon_id * 4 + 2] = v2;
((real64 *)node->layer[layer_id].layer)[polygon_id * 4 + 3] = v3;
count = vs_get_subscript_count(node->layer[layer_id].subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribers, i);
verse_send_g_polygon_set_corner_real32(node_id, layer_id, polygon_id, v0, v1, v2, v3);
}
count = vs_get_subscript_count(node->layer[layer_id].subscribersd);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribersd, i);
verse_send_g_polygon_set_corner_real64(node_id, layer_id, polygon_id, (real64)v0, (real64)v1, (real64)v2, (real64)v3);
}
vs_reset_subscript_session();
}
static void callback_send_g_polygon_set_face_uint8(void *user, VNodeID node_id, VLayerID layer_id, uint32 polygon_id, uint8 value)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(layer_id >= node->layer_count || node->layer[layer_id].layer == NULL || node->layer[layer_id].type != VN_G_LAYER_POLYGON_FACE_UINT8)
return;
if((polygon_id = vs_g_extend_arrays(node, FALSE, FALSE, polygon_id)) == ~0u)
return;
((uint8 *)node->layer[layer_id].layer)[polygon_id] = value;
count = vs_get_subscript_count(node->layer[layer_id].subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribers, i);
verse_send_g_polygon_set_face_uint8(node_id, layer_id, polygon_id, value);
}
vs_reset_subscript_session();
}
static void callback_send_g_polygon_set_face_uint32(void *user, VNodeID node_id, VLayerID layer_id, uint32 polygon_id, uint32 value)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(layer_id >= node->layer_count || node->layer[layer_id].layer == NULL || node->layer[layer_id].type != VN_G_LAYER_POLYGON_FACE_UINT32)
return;
if((polygon_id = vs_g_extend_arrays(node, FALSE, FALSE, polygon_id)) == ~0u)
return;
((uint32 *)node->layer[layer_id].layer)[polygon_id] = value;
count = vs_get_subscript_count(node->layer[layer_id].subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribers, i);
verse_send_g_polygon_set_face_uint32(node_id, layer_id, polygon_id, value);
}
vs_reset_subscript_session();
}
static void callback_send_g_polygon_set_face_real64(void *user, VNodeID node_id, VLayerID layer_id, uint32 polygon_id, real64 value)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(layer_id >= node->layer_count || node->layer[layer_id].layer == NULL || node->layer[layer_id].type != VN_G_LAYER_POLYGON_FACE_REAL)
return;
if((polygon_id = vs_g_extend_arrays(node, FALSE, FALSE, polygon_id)) == ~0u)
return;
((real64 *)node->layer[layer_id].layer)[polygon_id] = value;
count = vs_get_subscript_count(node->layer[layer_id].subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribers, i);
verse_send_g_polygon_set_face_real32(node_id, layer_id, polygon_id, (float)value);
}
count = vs_get_subscript_count(node->layer[layer_id].subscribersd);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribersd, i);
verse_send_g_polygon_set_face_real64(node_id, layer_id, polygon_id, value);
}
vs_reset_subscript_session();
}
static void callback_send_g_polygon_set_face_real32(void *user, VNodeID node_id, VLayerID layer_id, uint32 polygon_id, float value)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(layer_id >= node->layer_count || node->layer[layer_id].layer == NULL || node->layer[layer_id].type != VN_G_LAYER_POLYGON_FACE_REAL)
return;
if((polygon_id = vs_g_extend_arrays(node, FALSE, FALSE, polygon_id)) == ~0u)
return;
((real64 *)node->layer[layer_id].layer)[polygon_id] = (real64)value;
count = vs_get_subscript_count(node->layer[layer_id].subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribers, i);
verse_send_g_polygon_set_face_real32(node_id, layer_id, polygon_id, value);
}
count = vs_get_subscript_count(node->layer[layer_id].subscribersd);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[layer_id].subscribersd, i);
verse_send_g_polygon_set_face_real64(node_id, layer_id, polygon_id, (real64)value);
}
vs_reset_subscript_session();
}
static void callback_send_g_polygon_delete(void *user, VNodeID node_id, uint32 polygon_id)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(polygon_id >= node->poly_size || ((uint32 *)node->layer[1].layer)[polygon_id * 4] == ~0u)
return;
if(polygon_id < node->polygon_hole)
node->polygon_hole = polygon_id;
((uint32 *)node->layer[1].layer)[polygon_id * 4] = ~0u;
count = vs_get_subscript_count(node->layer[1].subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->layer[1].subscribers, i);
verse_send_g_polygon_delete(node_id, polygon_id);
}
vs_reset_subscript_session();
}
static void callback_send_g_crease_set_vertex(void *user, VNodeID node_id, const char *layer, uint32 def_crease)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
node->crease_vertex = def_crease;
v_strlcpy(node->crease_vertex_layer, layer, sizeof node->crease_vertex_layer);
count = vs_get_subscript_count(node->head.subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->head.subscribers, i);
verse_send_g_crease_set_vertex(node_id, layer, def_crease);
}
vs_reset_subscript_session();
}
static void callback_send_g_crease_set_edge(void *user, VNodeID node_id, const char *layer, uint32 def_crease)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
node->crease_edge = def_crease;
v_strlcpy(node->crease_edge_layer, layer, sizeof node->crease_edge_layer);
count = vs_get_subscript_count(node->head.subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->head.subscribers, i);
verse_send_g_crease_set_edge(node_id, layer, def_crease);
}
vs_reset_subscript_session();
}
void callback_send_g_bone_create(void *user, VNodeID node_id, uint16 bone_id, const char *weight,
const char *reference, uint16 parent,
real64 pos_x, real64 pos_y, real64 pos_z,
const char *position_label, const char *rotation_label, const char *scale_label)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(bone_id >= node->bone_count || node->bones[bone_id].weight[0] == '\0')
{
/* Find free bone to re-use, if any. */
for(bone_id = 0; bone_id < node->bone_count && node->bones[bone_id].weight[0] != '\0'; bone_id++)
;
if(bone_id == node->bone_count)
{
bone_id = node->bone_count;
node->bone_count += 16;
node->bones = realloc(node->bones, (sizeof *node->bones) * node->bone_count);
for(i = bone_id; i < node->bone_count; i++)
node->bones[i].weight[0] = '\0';
}
}
v_strlcpy(node->bones[bone_id].weight, weight, sizeof node->bones[bone_id].weight);
v_strlcpy(node->bones[bone_id].reference, reference, sizeof node->bones[bone_id].reference);
node->bones[bone_id].parent = parent;
node->bones[bone_id].pos_x = pos_x;
node->bones[bone_id].pos_y = pos_y;
node->bones[bone_id].pos_z = pos_z;
v_strlcpy(node->bones[bone_id].position_label, position_label, sizeof node->bones[bone_id].position_label);
v_strlcpy(node->bones[bone_id].rotation_label, rotation_label, sizeof node->bones[bone_id].rotation_label);
v_strlcpy(node->bones[bone_id].scale_label, scale_label, sizeof node->bones[bone_id].scale_label);
count = vs_get_subscript_count(node->head.subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->head.subscribers, i);
verse_send_g_bone_create(node_id, bone_id, weight, reference, parent, pos_x, pos_y, pos_z, position_label, rotation_label, scale_label);
}
vs_reset_subscript_session();
}
void callback_send_g_bone_destroy(void *user, VNodeID node_id, uint32 bone_id)
{
VSNodeGeometry *node;
unsigned int i, count;
node = (VSNodeGeometry *)vs_get_node(node_id, V_NT_GEOMETRY);
if(node == NULL)
return;
if(bone_id >= node->bone_count || node->bones[bone_id].weight[0] == 0)
return;
node->bones[bone_id].weight[0] = 0;
count = vs_get_subscript_count(node->head.subscribers);
for(i = 0; i < count; i++)
{
vs_set_subscript_session(node->head.subscribers, i);
verse_send_g_bone_destroy(node_id, bone_id);
}
vs_reset_subscript_session();
}
void vs_g_callback_init(void)
{
verse_callback_set(verse_send_g_layer_create, callback_send_g_layer_create, NULL);
verse_callback_set(verse_send_g_layer_destroy, callback_send_g_layer_destroy, NULL);
verse_callback_set(verse_send_g_layer_subscribe, callback_send_g_layer_subscribe, NULL);
verse_callback_set(verse_send_g_layer_unsubscribe, callback_send_g_layer_unsubscribe, NULL);
verse_callback_set(verse_send_g_vertex_set_xyz_real32, callback_send_g_vertex_set_xyz_real32, NULL);
verse_callback_set(verse_send_g_vertex_set_xyz_real64, callback_send_g_vertex_set_xyz_real64, NULL);
verse_callback_set(verse_send_g_vertex_set_uint32, callback_send_g_vertex_set_uint32, NULL);
verse_callback_set(verse_send_g_vertex_set_real32, callback_send_g_vertex_set_real32, NULL);
verse_callback_set(verse_send_g_vertex_set_real64, callback_send_g_vertex_set_real64, NULL);
verse_callback_set(verse_send_g_vertex_delete_real32, callback_send_g_vertex_delete_real, NULL);
verse_callback_set(verse_send_g_vertex_delete_real64, callback_send_g_vertex_delete_real, NULL);
verse_callback_set(verse_send_g_polygon_set_corner_uint32, callback_send_g_polygon_set_corner_uint32, NULL);
verse_callback_set(verse_send_g_polygon_set_corner_real32, callback_send_g_polygon_set_corner_real32, NULL);
verse_callback_set(verse_send_g_polygon_set_corner_real64, callback_send_g_polygon_set_corner_real64, NULL);
verse_callback_set(verse_send_g_polygon_set_face_uint8, callback_send_g_polygon_set_face_uint8, NULL);
verse_callback_set(verse_send_g_polygon_set_face_uint32, callback_send_g_polygon_set_face_uint32, NULL);
verse_callback_set(verse_send_g_polygon_set_face_real32, callback_send_g_polygon_set_face_real32, NULL);
verse_callback_set(verse_send_g_polygon_set_face_real64, callback_send_g_polygon_set_face_real64, NULL);
verse_callback_set(verse_send_g_polygon_delete, callback_send_g_polygon_delete, NULL);
verse_callback_set(verse_send_g_crease_set_vertex, callback_send_g_crease_set_vertex, NULL);
verse_callback_set(verse_send_g_crease_set_edge, callback_send_g_crease_set_edge, NULL);
verse_callback_set(verse_send_g_bone_create, callback_send_g_bone_create, NULL);
verse_callback_set(verse_send_g_bone_destroy, callback_send_g_bone_destroy, NULL);
}
#endif