// ###########################################################
// ####### EXPORTERs DI SINGOLE ENTITA' DELLA SCENA #######
// ###########################################################
void SkeletonExporter::export_general_info(void)
{
int ff, lf, fs;
Interval range = ip->GetAnimRange();
Box3 bbox;
fprintf(fTXT, "[AD]Turbo ROX as usual !! \n\n");
INode *root = ip->GetRootNode();
bbox.pmin.x=bbox.pmin.y=bbox.pmin.z=(float)1E10;
bbox.pmax.x=bbox.pmax.y=bbox.pmax.z=(float)-1E10;
GetSceneBoundingBox(root, 0, &bbox);
ff=range.Start() / GetTicksPerFrame();
lf=range.End() / GetTicksPerFrame();
fs=GetFrameRate();
// Start with a file identifier and format version
fprintf(fTXT, "First frame : %d\n", ff);
fprintf(fTXT, "Last frame : %d\n", lf);
fprintf(fTXT, "Frame speed : %d\n", fs);
fprintf(fTXT, "Scene Bounding Box at time 0\n");
fprintf(fTXT, "min : %f, %f, %f\n",
bbox.pmin.x, bbox.pmin.y, bbox.pmin.z);
fprintf(fTXT, "max : %f, %f, %f\n",
bbox.pmax.x, bbox.pmax.y, bbox.pmax.z);
write_chunk_header(fA3D, SCENE_GENERAL_INFO_ID, "Scene Root", 36);
fwrite(&ff, sizeof(int), 1, fA3D);
fwrite(&lf, sizeof(int), 1, fA3D);
fwrite(&fs, sizeof(int), 1, fA3D);
write_bbox(&bbox, fA3D);
if (makeRAY) write_chunk_header(fRAY, SCENE_GENERAL_INFO_ID, "Scene Root", 36);
if (makeRAY) fwrite(&ff, sizeof(int), 1, fRAY);
if (makeRAY) fwrite(&lf, sizeof(int), 1, fRAY);
if (makeRAY) fwrite(&fs, sizeof(int), 1, fRAY);
if (makeRAY) write_bbox(&bbox, fRAY);
}
static int lwgeom_write_to_buffer(const LWGEOM *geom, TWKB_GLOBALS *globals, TWKB_STATE *parent_state)
{
int i, is_empty, has_z, has_m, ndims;
size_t bbox_size = 0, optional_precision_byte = 0;
uint8_t flag = 0, type_prec = 0;
TWKB_STATE child_state;
memset(&child_state, 0, sizeof(TWKB_STATE));
child_state.header_buf = bytebuffer_create_with_size(16);
child_state.geom_buf = bytebuffer_create_with_size(64);
child_state.idlist = parent_state->idlist;
/* Read dimensionality from input */
has_z = lwgeom_has_z(geom);
has_m = lwgeom_has_m(geom);
ndims = lwgeom_ndims(geom);
is_empty = lwgeom_is_empty(geom);
/* Do we need extended precision? If we have a Z or M we do. */
optional_precision_byte = (has_z || has_m);
/* Both X and Y dimension use the same precision */
globals->factor[0] = pow(10, globals->prec_xy);
globals->factor[1] = globals->factor[0];
/* Z and M dimensions have their own precisions */
if ( has_z )
globals->factor[2] = pow(10, globals->prec_z);
if ( has_m )
globals->factor[2 + has_z] = pow(10, globals->prec_m);
/* Reset stats */
for ( i = 0; i < MAX_N_DIMS; i++ )
{
/* Reset bbox calculation */
child_state.bbox_max[i] = INT64_MIN;
child_state.bbox_min[i] = INT64_MAX;
/* Reset acumulated delta values to get absolute values on next point */
child_state.accum_rels[i] = 0;
}
/* TYPE/PRECISION BYTE */
if ( abs(globals->prec_xy) > 7 )
lwerror("%s: X/Z precision cannot be greater than 7 or less than -7", __func__);
/* Read the TWKB type number from the geometry */
TYPE_PREC_SET_TYPE(type_prec, lwgeom_twkb_type(geom));
/* Zig-zag the precision value before encoding it since it is a signed value */
TYPE_PREC_SET_PREC(type_prec, zigzag8(globals->prec_xy));
/* Write the type and precision byte */
bytebuffer_append_byte(child_state.header_buf, type_prec);
/* METADATA BYTE */
/* Set first bit if we are going to store bboxes */
FIRST_BYTE_SET_BBOXES(flag, (globals->variant & TWKB_BBOX) && ! is_empty);
/* Set second bit if we are going to store resulting size */
FIRST_BYTE_SET_SIZES(flag, globals->variant & TWKB_SIZE);
/* There will be no ID-list (for now) */
FIRST_BYTE_SET_IDLIST(flag, parent_state->idlist && ! is_empty);
/* Are there higher dimensions */
FIRST_BYTE_SET_EXTENDED(flag, optional_precision_byte);
/* Empty? */
FIRST_BYTE_SET_EMPTY(flag, is_empty);
/* Write the header byte */
bytebuffer_append_byte(child_state.header_buf, flag);
/* EXTENDED PRECISION BYTE (OPTIONAL) */
/* If needed, write the extended dim byte */
if( optional_precision_byte )
{
uint8_t flag = 0;
if ( has_z && ( globals->prec_z > 7 || globals->prec_z < 0 ) )
lwerror("%s: Z precision cannot be negative or greater than 7", __func__);
if ( has_m && ( globals->prec_m > 7 || globals->prec_m < 0 ) )
lwerror("%s: M precision cannot be negative or greater than 7", __func__);
HIGHER_DIM_SET_HASZ(flag, has_z);
HIGHER_DIM_SET_HASM(flag, has_m);
HIGHER_DIM_SET_PRECZ(flag, globals->prec_z);
HIGHER_DIM_SET_PRECM(flag, globals->prec_m);
bytebuffer_append_byte(child_state.header_buf, flag);
}
/* It the geometry is empty, we're almost done */
if ( is_empty )
{
/* If this output is sized, write the size of */
/* all following content, which is zero because */
/* there is none */
if ( globals->variant & TWKB_SIZE )
bytebuffer_append_byte(child_state.header_buf, 0);
bytebuffer_append_bytebuffer(parent_state->geom_buf, child_state.header_buf);
bytebuffer_destroy(child_state.header_buf);
bytebuffer_destroy(child_state.geom_buf);
return 0;
}
/* Write the TWKB into the output buffer */
lwgeom_to_twkb_buf(geom, globals, &child_state);
/*If we have a header_buf, we know that this function is called inside a collection*/
/*and then we have to merge the bboxes of the included geometries*/
/*and put the result to the parent (the collection)*/
if( (globals->variant & TWKB_BBOX) && parent_state->header_buf )
{
LWDEBUG(4,"Merge bboxes");
for ( i = 0; i < ndims; i++ )
{
if(child_state.bbox_min[i]<parent_state->bbox_min[i])
parent_state->bbox_min[i] = child_state.bbox_min[i];
if(child_state.bbox_max[i]>parent_state->bbox_max[i])
parent_state->bbox_max[i] = child_state.bbox_max[i];
}
}
/* Did we have a box? If so, how big? */
bbox_size = 0;
if( globals->variant & TWKB_BBOX )
{
LWDEBUG(4,"We want boxes and will calculate required size");
bbox_size = sizeof_bbox(&child_state, ndims);
}
/* Write the size if wanted */
if( globals->variant & TWKB_SIZE )
{
/* Here we have to add what we know will be written to header */
/* buffer after size value is written */
size_t size_to_register = bytebuffer_getlength(child_state.geom_buf);
size_to_register += bbox_size;
bytebuffer_append_uvarint(child_state.header_buf, size_to_register);
}
if( globals->variant & TWKB_BBOX )
write_bbox(&child_state, ndims);
bytebuffer_append_bytebuffer(parent_state->geom_buf,child_state.header_buf);
bytebuffer_append_bytebuffer(parent_state->geom_buf,child_state.geom_buf);
bytebuffer_destroy(child_state.header_buf);
bytebuffer_destroy(child_state.geom_buf);
return 0;
}
