forked from bartvdbraak/blender
1155 lines
50 KiB
C
1155 lines
50 KiB
C
/*
|
|
** This is automatically generated source code -- do not edit.
|
|
** Changes are affected either by editing the corresponding protocol
|
|
** definition file (v_cmd_def_X.c where X=node type), or by editing
|
|
** the code generator itself, in v_cmd_gen.c.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
|
|
#include "v_cmd_gen.h"
|
|
#if !defined(V_GENERATE_FUNC_MODE)
|
|
#include "verse.h"
|
|
#include "v_cmd_buf.h"
|
|
#include "v_network_out_que.h"
|
|
#include "v_network.h"
|
|
#include "v_connection.h"
|
|
#include "v_util.h"
|
|
|
|
void verse_send_g_layer_create(VNodeID node_id, VLayerID layer_id, const char *name, VNGLayerType type, uint32 def_uint, real64 def_real)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_80);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 48); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_layer_create(node_id = %u layer_id = %u name = %s type = %u def_uint = %u def_real = %f );\n", node_id, layer_id, name, type, def_uint, def_real);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], layer_id);
|
|
buffer_pos += vnp_raw_pack_string(&buf[buffer_pos], name, 16);
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], (uint8)type);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], def_uint);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], def_real);
|
|
if(node_id == (uint32) ~0u || layer_id == (uint16) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 7);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 7);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
void verse_send_g_layer_destroy(VNodeID node_id, VLayerID layer_id)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_80);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 48); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_layer_destroy(node_id = %u layer_id = %u );\n", node_id, layer_id);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], layer_id);
|
|
buffer_pos += vnp_raw_pack_string(&buf[buffer_pos], NULL, 16);
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], (uint8)-1);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], -1);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], V_REAL64_MAX);
|
|
if(node_id == (uint32) ~0u || layer_id == (uint16) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 7);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 7);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
unsigned int v_unpack_g_layer_create(const char *buf, size_t buffer_length)
|
|
{
|
|
uint8 enum_temp;
|
|
unsigned int buffer_pos = 0;
|
|
void (* func_g_layer_create)(void *user_data, VNodeID node_id, VLayerID layer_id, const char *name, VNGLayerType type, uint32 def_uint, real64 def_real);
|
|
VNodeID node_id;
|
|
VLayerID layer_id;
|
|
char name[16];
|
|
VNGLayerType type;
|
|
uint32 def_uint;
|
|
real64 def_real;
|
|
|
|
func_g_layer_create = v_fs_get_user_func(48);
|
|
if(buffer_length < 6)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
|
|
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &layer_id);
|
|
buffer_pos += vnp_raw_unpack_string(&buf[buffer_pos], name, 16, buffer_length - buffer_pos);
|
|
if(buffer_length < 13 + buffer_pos)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint8(&buf[buffer_pos], &enum_temp);
|
|
type = (VNGLayerType)enum_temp;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &def_uint);
|
|
buffer_pos += vnp_raw_unpack_real64(&buf[buffer_pos], &def_real);
|
|
#if defined V_PRINT_RECEIVE_COMMANDS
|
|
if(name[0] == 0)
|
|
printf("receive: verse_send_g_layer_destroy(node_id = %u layer_id = %u ); callback = %p\n", node_id, layer_id, v_fs_get_alias_user_func(48));
|
|
else
|
|
printf("receive: verse_send_g_layer_create(node_id = %u layer_id = %u name = %s type = %u def_uint = %u def_real = %f ); callback = %p\n", node_id, layer_id, name, type, def_uint, def_real, v_fs_get_user_func(48));
|
|
#endif
|
|
if(name[0] == 0)
|
|
{
|
|
void (* alias_g_layer_destroy)(void *user_data, VNodeID node_id, VLayerID layer_id);
|
|
alias_g_layer_destroy = v_fs_get_alias_user_func(48);
|
|
if(alias_g_layer_destroy != NULL)
|
|
alias_g_layer_destroy(v_fs_get_alias_user_data(48), node_id, layer_id);
|
|
return buffer_pos;
|
|
}
|
|
if(func_g_layer_create != NULL)
|
|
func_g_layer_create(v_fs_get_user_data(48), node_id, layer_id, name, (VNGLayerType) type, def_uint, def_real);
|
|
|
|
return buffer_pos;
|
|
}
|
|
|
|
void verse_send_g_layer_subscribe(VNodeID node_id, VLayerID layer_id, VNRealFormat type)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_10);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 49); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_layer_subscribe(node_id = %u layer_id = %u type = %u );\n", node_id, layer_id, type);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], layer_id);
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], (uint8)type);
|
|
if(node_id == (uint32) ~0u || layer_id == (uint16) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 7);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 7);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
void verse_send_g_layer_unsubscribe(VNodeID node_id, VLayerID layer_id)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_10);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 49); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_layer_unsubscribe(node_id = %u layer_id = %u );\n", node_id, layer_id);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], layer_id);
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], (uint8)-1);
|
|
if(node_id == (uint32) ~0u || layer_id == (uint16) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 7);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 7);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
unsigned int v_unpack_g_layer_subscribe(const char *buf, size_t buffer_length)
|
|
{
|
|
uint8 enum_temp;
|
|
unsigned int buffer_pos = 0;
|
|
void (* func_g_layer_subscribe)(void *user_data, VNodeID node_id, VLayerID layer_id, VNRealFormat type);
|
|
VNodeID node_id;
|
|
VLayerID layer_id;
|
|
VNRealFormat type;
|
|
|
|
func_g_layer_subscribe = v_fs_get_user_func(49);
|
|
if(buffer_length < 6)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
|
|
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &layer_id);
|
|
buffer_pos += vnp_raw_unpack_uint8(&buf[buffer_pos], &enum_temp);
|
|
type = (VNRealFormat)enum_temp;
|
|
#if defined V_PRINT_RECEIVE_COMMANDS
|
|
if(type > VN_FORMAT_REAL64)
|
|
printf("receive: verse_send_g_layer_unsubscribe(node_id = %u layer_id = %u ); callback = %p\n", node_id, layer_id, v_fs_get_alias_user_func(49));
|
|
else
|
|
printf("receive: verse_send_g_layer_subscribe(node_id = %u layer_id = %u type = %u ); callback = %p\n", node_id, layer_id, type, v_fs_get_user_func(49));
|
|
#endif
|
|
if(type > VN_FORMAT_REAL64)
|
|
{
|
|
void (* alias_g_layer_unsubscribe)(void *user_data, VNodeID node_id, VLayerID layer_id);
|
|
alias_g_layer_unsubscribe = v_fs_get_alias_user_func(49);
|
|
if(alias_g_layer_unsubscribe != NULL)
|
|
alias_g_layer_unsubscribe(v_fs_get_alias_user_data(49), node_id, layer_id);
|
|
return buffer_pos;
|
|
}
|
|
if(func_g_layer_subscribe != NULL)
|
|
func_g_layer_subscribe(v_fs_get_user_data(49), node_id, layer_id, (VNRealFormat) type);
|
|
|
|
return buffer_pos;
|
|
}
|
|
|
|
void verse_send_g_vertex_set_xyz_real32(VNodeID node_id, VLayerID layer_id, uint32 vertex_id, real32 x, real32 y, real32 z)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_30);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 50); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_vertex_set_xyz_real32(node_id = %u layer_id = %u vertex_id = %u x = %f y = %f z = %f );\n", node_id, layer_id, vertex_id, x, y, z);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], layer_id);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], vertex_id);
|
|
buffer_pos += vnp_raw_pack_real32(&buf[buffer_pos], x);
|
|
buffer_pos += vnp_raw_pack_real32(&buf[buffer_pos], y);
|
|
buffer_pos += vnp_raw_pack_real32(&buf[buffer_pos], z);
|
|
if(node_id == (uint32) ~0u || layer_id == (uint16) ~0u || vertex_id == (uint32) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 11);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 11);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
void verse_send_g_vertex_delete_real32(VNodeID node_id, uint32 vertex_id)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_30);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 50); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_vertex_delete_real32(node_id = %u vertex_id = %u );\n", node_id, vertex_id);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], 0);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], vertex_id);
|
|
buffer_pos += vnp_raw_pack_real32(&buf[buffer_pos], V_REAL32_MAX);
|
|
buffer_pos += vnp_raw_pack_real32(&buf[buffer_pos], V_REAL32_MAX);
|
|
buffer_pos += vnp_raw_pack_real32(&buf[buffer_pos], V_REAL32_MAX);
|
|
if(node_id == (uint32) ~0u || vertex_id == (uint32) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 11);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 11);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
unsigned int v_unpack_g_vertex_set_xyz_real32(const char *buf, size_t buffer_length)
|
|
{
|
|
unsigned int buffer_pos = 0;
|
|
void (* func_g_vertex_set_xyz_real32)(void *user_data, VNodeID node_id, VLayerID layer_id, uint32 vertex_id, real32 x, real32 y, real32 z);
|
|
VNodeID node_id;
|
|
VLayerID layer_id;
|
|
uint32 vertex_id;
|
|
real32 x;
|
|
real32 y;
|
|
real32 z;
|
|
|
|
func_g_vertex_set_xyz_real32 = v_fs_get_user_func(50);
|
|
if(buffer_length < 10)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
|
|
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &layer_id);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &vertex_id);
|
|
buffer_pos += vnp_raw_unpack_real32(&buf[buffer_pos], &x);
|
|
buffer_pos += vnp_raw_unpack_real32(&buf[buffer_pos], &y);
|
|
buffer_pos += vnp_raw_unpack_real32(&buf[buffer_pos], &z);
|
|
#if defined V_PRINT_RECEIVE_COMMANDS
|
|
if(x == V_REAL32_MAX || y == V_REAL32_MAX || z == V_REAL32_MAX)
|
|
printf("receive: verse_send_g_vertex_delete_real32(node_id = %u vertex_id = %u ); callback = %p\n", node_id, vertex_id, v_fs_get_alias_user_func(50));
|
|
else
|
|
printf("receive: verse_send_g_vertex_set_xyz_real32(node_id = %u layer_id = %u vertex_id = %u x = %f y = %f z = %f ); callback = %p\n", node_id, layer_id, vertex_id, x, y, z, v_fs_get_user_func(50));
|
|
#endif
|
|
if(x == V_REAL32_MAX || y == V_REAL32_MAX || z == V_REAL32_MAX)
|
|
{
|
|
void (* alias_g_vertex_delete_real32)(void *user_data, VNodeID node_id, uint32 vertex_id);
|
|
alias_g_vertex_delete_real32 = v_fs_get_alias_user_func(50);
|
|
if(alias_g_vertex_delete_real32 != NULL)
|
|
alias_g_vertex_delete_real32(v_fs_get_alias_user_data(50), node_id, vertex_id);
|
|
return buffer_pos;
|
|
}
|
|
if(func_g_vertex_set_xyz_real32 != NULL)
|
|
func_g_vertex_set_xyz_real32(v_fs_get_user_data(50), node_id, layer_id, vertex_id, x, y, z);
|
|
|
|
return buffer_pos;
|
|
}
|
|
|
|
void verse_send_g_vertex_set_xyz_real64(VNodeID node_id, VLayerID layer_id, uint32 vertex_id, real64 x, real64 y, real64 z)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_80);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 51); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_vertex_set_xyz_real64(node_id = %u layer_id = %u vertex_id = %u x = %f y = %f z = %f );\n", node_id, layer_id, vertex_id, x, y, z);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], layer_id);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], vertex_id);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], x);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], y);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], z);
|
|
if(node_id == (uint32) ~0u || layer_id == (uint16) ~0u || vertex_id == (uint32) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 11);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 11);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
void verse_send_g_vertex_delete_real64(VNodeID node_id, uint32 vertex_id)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_80);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 51); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_vertex_delete_real64(node_id = %u vertex_id = %u );\n", node_id, vertex_id);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], 0);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], vertex_id);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], V_REAL64_MAX);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], V_REAL64_MAX);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], V_REAL64_MAX);
|
|
if(node_id == (uint32) ~0u || vertex_id == (uint32) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 11);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 11);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
unsigned int v_unpack_g_vertex_set_xyz_real64(const char *buf, size_t buffer_length)
|
|
{
|
|
unsigned int buffer_pos = 0;
|
|
void (* func_g_vertex_set_xyz_real64)(void *user_data, VNodeID node_id, VLayerID layer_id, uint32 vertex_id, real64 x, real64 y, real64 z);
|
|
VNodeID node_id;
|
|
VLayerID layer_id;
|
|
uint32 vertex_id;
|
|
real64 x;
|
|
real64 y;
|
|
real64 z;
|
|
|
|
func_g_vertex_set_xyz_real64 = v_fs_get_user_func(51);
|
|
if(buffer_length < 10)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
|
|
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &layer_id);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &vertex_id);
|
|
buffer_pos += vnp_raw_unpack_real64(&buf[buffer_pos], &x);
|
|
buffer_pos += vnp_raw_unpack_real64(&buf[buffer_pos], &y);
|
|
buffer_pos += vnp_raw_unpack_real64(&buf[buffer_pos], &z);
|
|
#if defined V_PRINT_RECEIVE_COMMANDS
|
|
if(x == V_REAL64_MAX || y == V_REAL64_MAX || z == V_REAL64_MAX)
|
|
printf("receive: verse_send_g_vertex_delete_real64(node_id = %u vertex_id = %u ); callback = %p\n", node_id, vertex_id, v_fs_get_alias_user_func(51));
|
|
else
|
|
printf("receive: verse_send_g_vertex_set_xyz_real64(node_id = %u layer_id = %u vertex_id = %u x = %f y = %f z = %f ); callback = %p\n", node_id, layer_id, vertex_id, x, y, z, v_fs_get_user_func(51));
|
|
#endif
|
|
if(x == V_REAL64_MAX || y == V_REAL64_MAX || z == V_REAL64_MAX)
|
|
{
|
|
void (* alias_g_vertex_delete_real64)(void *user_data, VNodeID node_id, uint32 vertex_id);
|
|
alias_g_vertex_delete_real64 = v_fs_get_alias_user_func(51);
|
|
if(alias_g_vertex_delete_real64 != NULL)
|
|
alias_g_vertex_delete_real64(v_fs_get_alias_user_data(51), node_id, vertex_id);
|
|
return buffer_pos;
|
|
}
|
|
if(func_g_vertex_set_xyz_real64 != NULL)
|
|
func_g_vertex_set_xyz_real64(v_fs_get_user_data(51), node_id, layer_id, vertex_id, x, y, z);
|
|
|
|
return buffer_pos;
|
|
}
|
|
|
|
void verse_send_g_vertex_set_uint32(VNodeID node_id, VLayerID layer_id, uint32 vertex_id, uint32 value)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_20);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 52); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_vertex_set_uint32(node_id = %u layer_id = %u vertex_id = %u value = %u );\n", node_id, layer_id, vertex_id, value);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], layer_id);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], vertex_id);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], value);
|
|
if(node_id == (uint32) ~0u || layer_id == (uint16) ~0u || vertex_id == (uint32) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 11);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 11);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
unsigned int v_unpack_g_vertex_set_uint32(const char *buf, size_t buffer_length)
|
|
{
|
|
unsigned int buffer_pos = 0;
|
|
void (* func_g_vertex_set_uint32)(void *user_data, VNodeID node_id, VLayerID layer_id, uint32 vertex_id, uint32 value);
|
|
VNodeID node_id;
|
|
VLayerID layer_id;
|
|
uint32 vertex_id;
|
|
uint32 value;
|
|
|
|
func_g_vertex_set_uint32 = v_fs_get_user_func(52);
|
|
if(buffer_length < 10)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
|
|
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &layer_id);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &vertex_id);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &value);
|
|
#if defined V_PRINT_RECEIVE_COMMANDS
|
|
printf("receive: verse_send_g_vertex_set_uint32(node_id = %u layer_id = %u vertex_id = %u value = %u ); callback = %p\n", node_id, layer_id, vertex_id, value, v_fs_get_user_func(52));
|
|
#endif
|
|
if(func_g_vertex_set_uint32 != NULL)
|
|
func_g_vertex_set_uint32(v_fs_get_user_data(52), node_id, layer_id, vertex_id, value);
|
|
|
|
return buffer_pos;
|
|
}
|
|
|
|
void verse_send_g_vertex_set_real64(VNodeID node_id, VLayerID layer_id, uint32 vertex_id, real64 value)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_20);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 53); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_vertex_set_real64(node_id = %u layer_id = %u vertex_id = %u value = %f );\n", node_id, layer_id, vertex_id, value);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], layer_id);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], vertex_id);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], value);
|
|
if(node_id == (uint32) ~0u || layer_id == (uint16) ~0u || vertex_id == (uint32) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 11);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 11);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
unsigned int v_unpack_g_vertex_set_real64(const char *buf, size_t buffer_length)
|
|
{
|
|
unsigned int buffer_pos = 0;
|
|
void (* func_g_vertex_set_real64)(void *user_data, VNodeID node_id, VLayerID layer_id, uint32 vertex_id, real64 value);
|
|
VNodeID node_id;
|
|
VLayerID layer_id;
|
|
uint32 vertex_id;
|
|
real64 value;
|
|
|
|
func_g_vertex_set_real64 = v_fs_get_user_func(53);
|
|
if(buffer_length < 10)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
|
|
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &layer_id);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &vertex_id);
|
|
buffer_pos += vnp_raw_unpack_real64(&buf[buffer_pos], &value);
|
|
#if defined V_PRINT_RECEIVE_COMMANDS
|
|
printf("receive: verse_send_g_vertex_set_real64(node_id = %u layer_id = %u vertex_id = %u value = %f ); callback = %p\n", node_id, layer_id, vertex_id, value, v_fs_get_user_func(53));
|
|
#endif
|
|
if(func_g_vertex_set_real64 != NULL)
|
|
func_g_vertex_set_real64(v_fs_get_user_data(53), node_id, layer_id, vertex_id, value);
|
|
|
|
return buffer_pos;
|
|
}
|
|
|
|
void verse_send_g_vertex_set_real32(VNodeID node_id, VLayerID layer_id, uint32 vertex_id, real32 value)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_20);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 54); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_vertex_set_real32(node_id = %u layer_id = %u vertex_id = %u value = %f );\n", node_id, layer_id, vertex_id, value);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], layer_id);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], vertex_id);
|
|
buffer_pos += vnp_raw_pack_real32(&buf[buffer_pos], value);
|
|
if(node_id == (uint32) ~0u || layer_id == (uint16) ~0u || vertex_id == (uint32) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 11);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 11);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
unsigned int v_unpack_g_vertex_set_real32(const char *buf, size_t buffer_length)
|
|
{
|
|
unsigned int buffer_pos = 0;
|
|
void (* func_g_vertex_set_real32)(void *user_data, VNodeID node_id, VLayerID layer_id, uint32 vertex_id, real32 value);
|
|
VNodeID node_id;
|
|
VLayerID layer_id;
|
|
uint32 vertex_id;
|
|
real32 value;
|
|
|
|
func_g_vertex_set_real32 = v_fs_get_user_func(54);
|
|
if(buffer_length < 10)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
|
|
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &layer_id);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &vertex_id);
|
|
buffer_pos += vnp_raw_unpack_real32(&buf[buffer_pos], &value);
|
|
#if defined V_PRINT_RECEIVE_COMMANDS
|
|
printf("receive: verse_send_g_vertex_set_real32(node_id = %u layer_id = %u vertex_id = %u value = %f ); callback = %p\n", node_id, layer_id, vertex_id, value, v_fs_get_user_func(54));
|
|
#endif
|
|
if(func_g_vertex_set_real32 != NULL)
|
|
func_g_vertex_set_real32(v_fs_get_user_data(54), node_id, layer_id, vertex_id, value);
|
|
|
|
return buffer_pos;
|
|
}
|
|
|
|
void verse_send_g_polygon_set_corner_uint32(VNodeID node_id, VLayerID layer_id, uint32 polygon_id, uint32 v0, uint32 v1, uint32 v2, uint32 v3)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_30);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 55); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_polygon_set_corner_uint32(node_id = %u layer_id = %u polygon_id = %u v0 = %u v1 = %u v2 = %u v3 = %u );\n", node_id, layer_id, polygon_id, v0, v1, v2, v3);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], layer_id);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], polygon_id);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], v0);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], v1);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], v2);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], v3);
|
|
if(node_id == (uint32) ~0u || layer_id == (uint16) ~0u || polygon_id == (uint32) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 11);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 11);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
void verse_send_g_polygon_delete(VNodeID node_id, uint32 polygon_id)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_30);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 55); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_polygon_delete(node_id = %u polygon_id = %u );\n", node_id, polygon_id);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], 1);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], polygon_id);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], -1);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], -1);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], -1);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], -1);
|
|
if(node_id == (uint32) ~0u || polygon_id == (uint32) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 11);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 11);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
unsigned int v_unpack_g_polygon_set_corner_uint32(const char *buf, size_t buffer_length)
|
|
{
|
|
unsigned int buffer_pos = 0;
|
|
void (* func_g_polygon_set_corner_uint32)(void *user_data, VNodeID node_id, VLayerID layer_id, uint32 polygon_id, uint32 v0, uint32 v1, uint32 v2, uint32 v3);
|
|
VNodeID node_id;
|
|
VLayerID layer_id;
|
|
uint32 polygon_id;
|
|
uint32 v0;
|
|
uint32 v1;
|
|
uint32 v2;
|
|
uint32 v3;
|
|
|
|
func_g_polygon_set_corner_uint32 = v_fs_get_user_func(55);
|
|
if(buffer_length < 10)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
|
|
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &layer_id);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &polygon_id);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &v0);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &v1);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &v2);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &v3);
|
|
#if defined V_PRINT_RECEIVE_COMMANDS
|
|
if(layer_id == 1 && v0 == ~0u)
|
|
printf("receive: verse_send_g_polygon_delete(node_id = %u polygon_id = %u ); callback = %p\n", node_id, polygon_id, v_fs_get_alias_user_func(55));
|
|
else
|
|
printf("receive: verse_send_g_polygon_set_corner_uint32(node_id = %u layer_id = %u polygon_id = %u v0 = %u v1 = %u v2 = %u v3 = %u ); callback = %p\n", node_id, layer_id, polygon_id, v0, v1, v2, v3, v_fs_get_user_func(55));
|
|
#endif
|
|
if(layer_id == 1 && v0 == ~0u)
|
|
{
|
|
void (* alias_g_polygon_delete)(void *user_data, VNodeID node_id, uint32 polygon_id);
|
|
alias_g_polygon_delete = v_fs_get_alias_user_func(55);
|
|
if(alias_g_polygon_delete != NULL)
|
|
alias_g_polygon_delete(v_fs_get_alias_user_data(55), node_id, polygon_id);
|
|
return buffer_pos;
|
|
}
|
|
if(func_g_polygon_set_corner_uint32 != NULL)
|
|
func_g_polygon_set_corner_uint32(v_fs_get_user_data(55), node_id, layer_id, polygon_id, v0, v1, v2, v3);
|
|
|
|
return buffer_pos;
|
|
}
|
|
|
|
void verse_send_g_polygon_set_corner_real64(VNodeID node_id, VLayerID layer_id, uint32 polygon_id, real64 v0, real64 v1, real64 v2, real64 v3)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_80);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 56); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_polygon_set_corner_real64(node_id = %u layer_id = %u polygon_id = %u v0 = %f v1 = %f v2 = %f v3 = %f );\n", node_id, layer_id, polygon_id, v0, v1, v2, v3);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], layer_id);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], polygon_id);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], v0);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], v1);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], v2);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], v3);
|
|
if(node_id == (uint32) ~0u || layer_id == (uint16) ~0u || polygon_id == (uint32) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 11);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 11);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
unsigned int v_unpack_g_polygon_set_corner_real64(const char *buf, size_t buffer_length)
|
|
{
|
|
unsigned int buffer_pos = 0;
|
|
void (* func_g_polygon_set_corner_real64)(void *user_data, VNodeID node_id, VLayerID layer_id, uint32 polygon_id, real64 v0, real64 v1, real64 v2, real64 v3);
|
|
VNodeID node_id;
|
|
VLayerID layer_id;
|
|
uint32 polygon_id;
|
|
real64 v0;
|
|
real64 v1;
|
|
real64 v2;
|
|
real64 v3;
|
|
|
|
func_g_polygon_set_corner_real64 = v_fs_get_user_func(56);
|
|
if(buffer_length < 10)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
|
|
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &layer_id);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &polygon_id);
|
|
buffer_pos += vnp_raw_unpack_real64(&buf[buffer_pos], &v0);
|
|
buffer_pos += vnp_raw_unpack_real64(&buf[buffer_pos], &v1);
|
|
buffer_pos += vnp_raw_unpack_real64(&buf[buffer_pos], &v2);
|
|
buffer_pos += vnp_raw_unpack_real64(&buf[buffer_pos], &v3);
|
|
#if defined V_PRINT_RECEIVE_COMMANDS
|
|
printf("receive: verse_send_g_polygon_set_corner_real64(node_id = %u layer_id = %u polygon_id = %u v0 = %f v1 = %f v2 = %f v3 = %f ); callback = %p\n", node_id, layer_id, polygon_id, v0, v1, v2, v3, v_fs_get_user_func(56));
|
|
#endif
|
|
if(func_g_polygon_set_corner_real64 != NULL)
|
|
func_g_polygon_set_corner_real64(v_fs_get_user_data(56), node_id, layer_id, polygon_id, v0, v1, v2, v3);
|
|
|
|
return buffer_pos;
|
|
}
|
|
|
|
void verse_send_g_polygon_set_corner_real32(VNodeID node_id, VLayerID layer_id, uint32 polygon_id, real32 v0, real32 v1, real32 v2, real32 v3)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_30);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 57); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_polygon_set_corner_real32(node_id = %u layer_id = %u polygon_id = %u v0 = %f v1 = %f v2 = %f v3 = %f );\n", node_id, layer_id, polygon_id, v0, v1, v2, v3);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], layer_id);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], polygon_id);
|
|
buffer_pos += vnp_raw_pack_real32(&buf[buffer_pos], v0);
|
|
buffer_pos += vnp_raw_pack_real32(&buf[buffer_pos], v1);
|
|
buffer_pos += vnp_raw_pack_real32(&buf[buffer_pos], v2);
|
|
buffer_pos += vnp_raw_pack_real32(&buf[buffer_pos], v3);
|
|
if(node_id == (uint32) ~0u || layer_id == (uint16) ~0u || polygon_id == (uint32) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 11);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 11);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
unsigned int v_unpack_g_polygon_set_corner_real32(const char *buf, size_t buffer_length)
|
|
{
|
|
unsigned int buffer_pos = 0;
|
|
void (* func_g_polygon_set_corner_real32)(void *user_data, VNodeID node_id, VLayerID layer_id, uint32 polygon_id, real32 v0, real32 v1, real32 v2, real32 v3);
|
|
VNodeID node_id;
|
|
VLayerID layer_id;
|
|
uint32 polygon_id;
|
|
real32 v0;
|
|
real32 v1;
|
|
real32 v2;
|
|
real32 v3;
|
|
|
|
func_g_polygon_set_corner_real32 = v_fs_get_user_func(57);
|
|
if(buffer_length < 10)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
|
|
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &layer_id);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &polygon_id);
|
|
buffer_pos += vnp_raw_unpack_real32(&buf[buffer_pos], &v0);
|
|
buffer_pos += vnp_raw_unpack_real32(&buf[buffer_pos], &v1);
|
|
buffer_pos += vnp_raw_unpack_real32(&buf[buffer_pos], &v2);
|
|
buffer_pos += vnp_raw_unpack_real32(&buf[buffer_pos], &v3);
|
|
#if defined V_PRINT_RECEIVE_COMMANDS
|
|
printf("receive: verse_send_g_polygon_set_corner_real32(node_id = %u layer_id = %u polygon_id = %u v0 = %f v1 = %f v2 = %f v3 = %f ); callback = %p\n", node_id, layer_id, polygon_id, v0, v1, v2, v3, v_fs_get_user_func(57));
|
|
#endif
|
|
if(func_g_polygon_set_corner_real32 != NULL)
|
|
func_g_polygon_set_corner_real32(v_fs_get_user_data(57), node_id, layer_id, polygon_id, v0, v1, v2, v3);
|
|
|
|
return buffer_pos;
|
|
}
|
|
|
|
void verse_send_g_polygon_set_face_uint8(VNodeID node_id, VLayerID layer_id, uint32 polygon_id, uint8 value)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_20);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 58); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_polygon_set_face_uint8(node_id = %u layer_id = %u polygon_id = %u value = %u );\n", node_id, layer_id, polygon_id, value);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], layer_id);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], polygon_id);
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], value);
|
|
if(node_id == (uint32) ~0u || layer_id == (uint16) ~0u || polygon_id == (uint32) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 11);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 11);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
unsigned int v_unpack_g_polygon_set_face_uint8(const char *buf, size_t buffer_length)
|
|
{
|
|
unsigned int buffer_pos = 0;
|
|
void (* func_g_polygon_set_face_uint8)(void *user_data, VNodeID node_id, VLayerID layer_id, uint32 polygon_id, uint8 value);
|
|
VNodeID node_id;
|
|
VLayerID layer_id;
|
|
uint32 polygon_id;
|
|
uint8 value;
|
|
|
|
func_g_polygon_set_face_uint8 = v_fs_get_user_func(58);
|
|
if(buffer_length < 10)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
|
|
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &layer_id);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &polygon_id);
|
|
buffer_pos += vnp_raw_unpack_uint8(&buf[buffer_pos], &value);
|
|
#if defined V_PRINT_RECEIVE_COMMANDS
|
|
printf("receive: verse_send_g_polygon_set_face_uint8(node_id = %u layer_id = %u polygon_id = %u value = %u ); callback = %p\n", node_id, layer_id, polygon_id, value, v_fs_get_user_func(58));
|
|
#endif
|
|
if(func_g_polygon_set_face_uint8 != NULL)
|
|
func_g_polygon_set_face_uint8(v_fs_get_user_data(58), node_id, layer_id, polygon_id, value);
|
|
|
|
return buffer_pos;
|
|
}
|
|
|
|
void verse_send_g_polygon_set_face_uint32(VNodeID node_id, VLayerID layer_id, uint32 polygon_id, uint32 value)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_20);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 59); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_polygon_set_face_uint32(node_id = %u layer_id = %u polygon_id = %u value = %u );\n", node_id, layer_id, polygon_id, value);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], layer_id);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], polygon_id);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], value);
|
|
if(node_id == (uint32) ~0u || layer_id == (uint16) ~0u || polygon_id == (uint32) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 11);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 11);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
unsigned int v_unpack_g_polygon_set_face_uint32(const char *buf, size_t buffer_length)
|
|
{
|
|
unsigned int buffer_pos = 0;
|
|
void (* func_g_polygon_set_face_uint32)(void *user_data, VNodeID node_id, VLayerID layer_id, uint32 polygon_id, uint32 value);
|
|
VNodeID node_id;
|
|
VLayerID layer_id;
|
|
uint32 polygon_id;
|
|
uint32 value;
|
|
|
|
func_g_polygon_set_face_uint32 = v_fs_get_user_func(59);
|
|
if(buffer_length < 10)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
|
|
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &layer_id);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &polygon_id);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &value);
|
|
#if defined V_PRINT_RECEIVE_COMMANDS
|
|
printf("receive: verse_send_g_polygon_set_face_uint32(node_id = %u layer_id = %u polygon_id = %u value = %u ); callback = %p\n", node_id, layer_id, polygon_id, value, v_fs_get_user_func(59));
|
|
#endif
|
|
if(func_g_polygon_set_face_uint32 != NULL)
|
|
func_g_polygon_set_face_uint32(v_fs_get_user_data(59), node_id, layer_id, polygon_id, value);
|
|
|
|
return buffer_pos;
|
|
}
|
|
|
|
void verse_send_g_polygon_set_face_real64(VNodeID node_id, VLayerID layer_id, uint32 polygon_id, real64 value)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_20);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 60); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_polygon_set_face_real64(node_id = %u layer_id = %u polygon_id = %u value = %f );\n", node_id, layer_id, polygon_id, value);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], layer_id);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], polygon_id);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], value);
|
|
if(node_id == (uint32) ~0u || layer_id == (uint16) ~0u || polygon_id == (uint32) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 11);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 11);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
unsigned int v_unpack_g_polygon_set_face_real64(const char *buf, size_t buffer_length)
|
|
{
|
|
unsigned int buffer_pos = 0;
|
|
void (* func_g_polygon_set_face_real64)(void *user_data, VNodeID node_id, VLayerID layer_id, uint32 polygon_id, real64 value);
|
|
VNodeID node_id;
|
|
VLayerID layer_id;
|
|
uint32 polygon_id;
|
|
real64 value;
|
|
|
|
func_g_polygon_set_face_real64 = v_fs_get_user_func(60);
|
|
if(buffer_length < 10)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
|
|
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &layer_id);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &polygon_id);
|
|
buffer_pos += vnp_raw_unpack_real64(&buf[buffer_pos], &value);
|
|
#if defined V_PRINT_RECEIVE_COMMANDS
|
|
printf("receive: verse_send_g_polygon_set_face_real64(node_id = %u layer_id = %u polygon_id = %u value = %f ); callback = %p\n", node_id, layer_id, polygon_id, value, v_fs_get_user_func(60));
|
|
#endif
|
|
if(func_g_polygon_set_face_real64 != NULL)
|
|
func_g_polygon_set_face_real64(v_fs_get_user_data(60), node_id, layer_id, polygon_id, value);
|
|
|
|
return buffer_pos;
|
|
}
|
|
|
|
void verse_send_g_polygon_set_face_real32(VNodeID node_id, VLayerID layer_id, uint32 polygon_id, real32 value)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_20);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 61); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_polygon_set_face_real32(node_id = %u layer_id = %u polygon_id = %u value = %f );\n", node_id, layer_id, polygon_id, value);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], layer_id);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], polygon_id);
|
|
buffer_pos += vnp_raw_pack_real32(&buf[buffer_pos], value);
|
|
if(node_id == (uint32) ~0u || layer_id == (uint16) ~0u || polygon_id == (uint32) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 11);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 11);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
unsigned int v_unpack_g_polygon_set_face_real32(const char *buf, size_t buffer_length)
|
|
{
|
|
unsigned int buffer_pos = 0;
|
|
void (* func_g_polygon_set_face_real32)(void *user_data, VNodeID node_id, VLayerID layer_id, uint32 polygon_id, real32 value);
|
|
VNodeID node_id;
|
|
VLayerID layer_id;
|
|
uint32 polygon_id;
|
|
real32 value;
|
|
|
|
func_g_polygon_set_face_real32 = v_fs_get_user_func(61);
|
|
if(buffer_length < 10)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
|
|
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &layer_id);
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &polygon_id);
|
|
buffer_pos += vnp_raw_unpack_real32(&buf[buffer_pos], &value);
|
|
#if defined V_PRINT_RECEIVE_COMMANDS
|
|
printf("receive: verse_send_g_polygon_set_face_real32(node_id = %u layer_id = %u polygon_id = %u value = %f ); callback = %p\n", node_id, layer_id, polygon_id, value, v_fs_get_user_func(61));
|
|
#endif
|
|
if(func_g_polygon_set_face_real32 != NULL)
|
|
func_g_polygon_set_face_real32(v_fs_get_user_data(61), node_id, layer_id, polygon_id, value);
|
|
|
|
return buffer_pos;
|
|
}
|
|
|
|
void verse_send_g_crease_set_vertex(VNodeID node_id, const char *layer, uint32 def_crease)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_30);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 62); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_crease_set_vertex(node_id = %u layer = %s def_crease = %u );\n", node_id, layer, def_crease);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_string(&buf[buffer_pos], layer, 16);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], def_crease);
|
|
if(node_id == (uint32) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 5);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 5);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
unsigned int v_unpack_g_crease_set_vertex(const char *buf, size_t buffer_length)
|
|
{
|
|
unsigned int buffer_pos = 0;
|
|
void (* func_g_crease_set_vertex)(void *user_data, VNodeID node_id, const char *layer, uint32 def_crease);
|
|
VNodeID node_id;
|
|
char layer[16];
|
|
uint32 def_crease;
|
|
|
|
func_g_crease_set_vertex = v_fs_get_user_func(62);
|
|
if(buffer_length < 4)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
|
|
buffer_pos += vnp_raw_unpack_string(&buf[buffer_pos], layer, 16, buffer_length - buffer_pos);
|
|
if(buffer_length < 4 + buffer_pos)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &def_crease);
|
|
#if defined V_PRINT_RECEIVE_COMMANDS
|
|
printf("receive: verse_send_g_crease_set_vertex(node_id = %u layer = %s def_crease = %u ); callback = %p\n", node_id, layer, def_crease, v_fs_get_user_func(62));
|
|
#endif
|
|
if(func_g_crease_set_vertex != NULL)
|
|
func_g_crease_set_vertex(v_fs_get_user_data(62), node_id, layer, def_crease);
|
|
|
|
return buffer_pos;
|
|
}
|
|
|
|
void verse_send_g_crease_set_edge(VNodeID node_id, const char *layer, uint32 def_crease)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_30);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 63); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_crease_set_edge(node_id = %u layer = %s def_crease = %u );\n", node_id, layer, def_crease);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_string(&buf[buffer_pos], layer, 16);
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], def_crease);
|
|
if(node_id == (uint32) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 5);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 5);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
unsigned int v_unpack_g_crease_set_edge(const char *buf, size_t buffer_length)
|
|
{
|
|
unsigned int buffer_pos = 0;
|
|
void (* func_g_crease_set_edge)(void *user_data, VNodeID node_id, const char *layer, uint32 def_crease);
|
|
VNodeID node_id;
|
|
char layer[16];
|
|
uint32 def_crease;
|
|
|
|
func_g_crease_set_edge = v_fs_get_user_func(63);
|
|
if(buffer_length < 4)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
|
|
buffer_pos += vnp_raw_unpack_string(&buf[buffer_pos], layer, 16, buffer_length - buffer_pos);
|
|
if(buffer_length < 4 + buffer_pos)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &def_crease);
|
|
#if defined V_PRINT_RECEIVE_COMMANDS
|
|
printf("receive: verse_send_g_crease_set_edge(node_id = %u layer = %s def_crease = %u ); callback = %p\n", node_id, layer, def_crease, v_fs_get_user_func(63));
|
|
#endif
|
|
if(func_g_crease_set_edge != NULL)
|
|
func_g_crease_set_edge(v_fs_get_user_data(63), node_id, layer, def_crease);
|
|
|
|
return buffer_pos;
|
|
}
|
|
|
|
void verse_send_g_bone_create(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)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_160);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 64); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_bone_create(node_id = %u bone_id = %u weight = %s reference = %s parent = %u pos_x = %f pos_y = %f pos_z = %f position_label = %s rotation_label = %s scale_label = %s );\n", node_id, bone_id, weight, reference, parent, pos_x, pos_y, pos_z, position_label, rotation_label, scale_label);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], bone_id);
|
|
buffer_pos += vnp_raw_pack_string(&buf[buffer_pos], weight, 16);
|
|
buffer_pos += vnp_raw_pack_string(&buf[buffer_pos], reference, 16);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], parent);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], pos_x);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], pos_y);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], pos_z);
|
|
buffer_pos += vnp_raw_pack_string(&buf[buffer_pos], position_label, 16);
|
|
buffer_pos += vnp_raw_pack_string(&buf[buffer_pos], rotation_label, 16);
|
|
buffer_pos += vnp_raw_pack_string(&buf[buffer_pos], scale_label, 16);
|
|
if(node_id == (uint32) ~0u || bone_id == (uint16) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 7);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 7);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
void verse_send_g_bone_destroy(VNodeID node_id, uint16 bone_id)
|
|
{
|
|
uint8 *buf;
|
|
unsigned int buffer_pos = 0;
|
|
VCMDBufHead *head;
|
|
head = v_cmd_buf_allocate(VCMDBS_160);/* Allocating the buffer */
|
|
buf = ((VCMDBuffer10 *)head)->buf;
|
|
|
|
buffer_pos += vnp_raw_pack_uint8(&buf[buffer_pos], 64); /* Pack the command. */
|
|
#if defined V_PRINT_SEND_COMMANDS
|
|
printf("send: verse_send_g_bone_destroy(node_id = %u bone_id = %u );\n", node_id, bone_id);
|
|
#endif
|
|
buffer_pos += vnp_raw_pack_uint32(&buf[buffer_pos], node_id);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], bone_id);
|
|
buffer_pos += vnp_raw_pack_string(&buf[buffer_pos], NULL, 16);
|
|
buffer_pos += vnp_raw_pack_string(&buf[buffer_pos], NULL, 16);
|
|
buffer_pos += vnp_raw_pack_uint16(&buf[buffer_pos], -1);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], V_REAL64_MAX);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], V_REAL64_MAX);
|
|
buffer_pos += vnp_raw_pack_real64(&buf[buffer_pos], V_REAL64_MAX);
|
|
buffer_pos += vnp_raw_pack_string(&buf[buffer_pos], NULL, 16);
|
|
buffer_pos += vnp_raw_pack_string(&buf[buffer_pos], NULL, 16);
|
|
buffer_pos += vnp_raw_pack_string(&buf[buffer_pos], NULL, 16);
|
|
if(node_id == (uint32) ~0u || bone_id == (uint16) ~0u)
|
|
v_cmd_buf_set_unique_address_size(head, 7);
|
|
else
|
|
v_cmd_buf_set_address_size(head, 7);
|
|
v_cmd_buf_set_size(head, buffer_pos);
|
|
v_noq_send_buf(v_con_get_network_queue(), head);
|
|
}
|
|
|
|
unsigned int v_unpack_g_bone_create(const char *buf, size_t buffer_length)
|
|
{
|
|
unsigned int buffer_pos = 0;
|
|
void (* func_g_bone_create)(void *user_data, 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);
|
|
VNodeID node_id;
|
|
uint16 bone_id;
|
|
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];
|
|
|
|
func_g_bone_create = v_fs_get_user_func(64);
|
|
if(buffer_length < 6)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint32(&buf[buffer_pos], &node_id);
|
|
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &bone_id);
|
|
buffer_pos += vnp_raw_unpack_string(&buf[buffer_pos], weight, 16, buffer_length - buffer_pos);
|
|
if(buffer_length < 0 + buffer_pos)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_string(&buf[buffer_pos], reference, 16, buffer_length - buffer_pos);
|
|
if(buffer_length < 26 + buffer_pos)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_uint16(&buf[buffer_pos], &parent);
|
|
buffer_pos += vnp_raw_unpack_real64(&buf[buffer_pos], &pos_x);
|
|
buffer_pos += vnp_raw_unpack_real64(&buf[buffer_pos], &pos_y);
|
|
buffer_pos += vnp_raw_unpack_real64(&buf[buffer_pos], &pos_z);
|
|
buffer_pos += vnp_raw_unpack_string(&buf[buffer_pos], position_label, 16, buffer_length - buffer_pos);
|
|
if(buffer_length < 0 + buffer_pos)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_string(&buf[buffer_pos], rotation_label, 16, buffer_length - buffer_pos);
|
|
if(buffer_length < 0 + buffer_pos)
|
|
return -1;
|
|
buffer_pos += vnp_raw_unpack_string(&buf[buffer_pos], scale_label, 16, buffer_length - buffer_pos);
|
|
#if defined V_PRINT_RECEIVE_COMMANDS
|
|
if(weight[0] == 0)
|
|
printf("receive: verse_send_g_bone_destroy(node_id = %u bone_id = %u ); callback = %p\n", node_id, bone_id, v_fs_get_alias_user_func(64));
|
|
else
|
|
printf("receive: verse_send_g_bone_create(node_id = %u bone_id = %u weight = %s reference = %s parent = %u pos_x = %f pos_y = %f pos_z = %f position_label = %s rotation_label = %s scale_label = %s ); callback = %p\n", node_id, bone_id, weight, reference, parent, pos_x, pos_y, pos_z, position_label, rotation_label, scale_label, v_fs_get_user_func(64));
|
|
#endif
|
|
if(weight[0] == 0)
|
|
{
|
|
void (* alias_g_bone_destroy)(void *user_data, VNodeID node_id, uint16 bone_id);
|
|
alias_g_bone_destroy = v_fs_get_alias_user_func(64);
|
|
if(alias_g_bone_destroy != NULL)
|
|
alias_g_bone_destroy(v_fs_get_alias_user_data(64), node_id, bone_id);
|
|
return buffer_pos;
|
|
}
|
|
if(func_g_bone_create != NULL)
|
|
func_g_bone_create(v_fs_get_user_data(64), node_id, bone_id, weight, reference, parent, pos_x, pos_y, pos_z, position_label, rotation_label, scale_label);
|
|
|
|
return buffer_pos;
|
|
}
|
|
|
|
#endif
|
|
|