caiyu/gmio
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

c-libstl: add _set_cookie() functions and buffer parameter

Browse Source
This commit is contained in:
Hugues Delorme 2013-02-05 12:24:13 +01:00
parent dc832d3f81
commit 24495d6655
8 changed files with 133 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/c/libstl/stlb_read.c
View File

@ -29,6 +29,12 @@ void* foug_stlb_geom_input_get_cookie(const foug_stlb_geom_input_t* geom)
return geom != NULL ? geom->cookie : NULL;
}
void foug_stlb_geom_input_set_cookie(foug_stlb_geom_input_t* geom, void* data)
{
if (geom != NULL)
geom->cookie = data;
}
static foug_bool_t foug_stlb_no_error(int code)
{
return code == FOUG_STLB_READ_NO_ERROR;
@ -79,7 +85,6 @@ static void foug_stlb_read_facets(foug_stlb_geom_input_t* geom_input,
int foug_stlb_read(foug_stlb_read_args_t args)
{
uint8_t buffer[8192];
uint8_t header_data[FOUG_STLB_HEADER_SIZE];
uint32_t total_facet_count;
size_t buffer_facet_count;
@ -91,8 +96,10 @@ int foug_stlb_read(foug_stlb_read_args_t args)
return FOUG_STLB_READ_NULL_GEOM_INPUT_ERROR;
if (args.stream == NULL)
return FOUG_STLB_READ_NULL_STREAM_ERROR;
/* if (args.buffer_size == 0)
return FOUG_STLB_READ_INVALID_BUFFER_SIZE_ERROR;*/
if (args.buffer == NULL)
return FOUG_STLB_READ_NULL_BUFFER;
if (args.buffer_size < FOUG_STLB_MIN_CONTENTS_SIZE)
return FOUG_STLB_READ_INVALID_BUFFER_SIZE_ERROR;
/* Read header */
if (foug_stream_read(args.stream, header_data, 1, FOUG_STLB_HEADER_SIZE) != FOUG_STLB_HEADER_SIZE)
@ -102,10 +109,10 @@ int foug_stlb_read(foug_stlb_read_args_t args)
(*(args.geom_input->manip.process_header_func))(args.geom_input, header_data);
/* Read facet count */
if (foug_stream_read(args.stream, buffer, sizeof(uint32_t), 1) != 1)
if (foug_stream_read(args.stream, args.buffer, sizeof(uint32_t), 1) != 1)
return FOUG_STLB_READ_FACET_COUNT_ERROR;
total_facet_count = foug_decode_uint32_le(buffer);
total_facet_count = foug_decode_uint32_le(args.buffer);
if (args.geom_input->manip.begin_triangles_func != NULL)
(*(args.geom_input->manip.begin_triangles_func))(args.geom_input, total_facet_count);
@ -113,12 +120,12 @@ int foug_stlb_read(foug_stlb_read_args_t args)
foug_task_control_set_range(args.task_control, 0., (foug_real32_t)total_facet_count);
/* Read triangles */
buffer_facet_count = 163;
buffer_facet_count = args.buffer_size / FOUG_STLB_TRIANGLE_SIZE;
accum_facet_count_read = 0;
error = FOUG_STLB_READ_NO_ERROR;
while (foug_stlb_no_error(error) && accum_facet_count_read < total_facet_count) {
facet_count_read = foug_stream_read(args.stream,
buffer, FOUG_STLB_TRIANGLE_SIZE, buffer_facet_count);
args.buffer, FOUG_STLB_TRIANGLE_SIZE, buffer_facet_count);
if (foug_stream_error(args.stream) != 0)
error = FOUG_STLB_READ_STREAM_ERROR;
else if (facet_count_read > 0)
@ -127,15 +134,14 @@ int foug_stlb_read(foug_stlb_read_args_t args)
break; /* Exit if no facet to read */
if (foug_stlb_no_error(error)) {
foug_stlb_read_facets(args.geom_input, buffer, facet_count_read);
foug_stlb_read_facets_one_go(args.geom_input, args.buffer, facet_count_read);
accum_facet_count_read += facet_count_read;
if (foug_task_control_is_stop_requested(args.task_control)) {
error = FOUG_STLB_READ_TASK_STOPPED_ERROR;
foug_task_control_handle_stop(args.task_control);
}
else {
foug_task_control_set_progress(args.task_control,
(foug_real32_t)accum_facet_count_read);
foug_task_control_set_progress(args.task_control, (foug_real32_t)accum_facet_count_read);
}
}
} /* end while */

20
src/c/libstl/stlb_read.h
View File

@ -30,25 +30,29 @@ foug_stlb_geom_input_t* foug_stlb_geom_input_create(foug_malloc_func_t func,
FOUG_DATAEX_LIBSTL_EXPORT
void* foug_stlb_geom_input_get_cookie(const foug_stlb_geom_input_t* geom);
FOUG_DATAEX_LIBSTL_EXPORT
void foug_stlb_geom_input_set_cookie(foug_stlb_geom_input_t* geom, void* data);
typedef struct
{
foug_stlb_geom_input_t* geom_input;
foug_stream_t* stream;
foug_task_control_t* task_control;
uint8_t* buffer;
uint32_t buffer_size;
} foug_stlb_read_args_t;
FOUG_DATAEX_LIBSTL_EXPORT
int foug_stlb_read(foug_stlb_read_args_t args);
#define FOUG_STLB_READ_NO_ERROR 0
#define FOUG_STLB_READ_NULL_GEOM_INPUT_ERROR 1
#define FOUG_STLB_READ_NULL_STREAM_ERROR 2
#define FOUG_STLB_READ_INVALID_BUFFER_SIZE_ERROR 3
#define FOUG_STLB_READ_HEADER_WRONG_SIZE_ERROR 4
#define FOUG_STLB_READ_FACET_COUNT_ERROR 5
#define FOUG_STLB_READ_STREAM_ERROR 6
#define FOUG_STLB_READ_TASK_STOPPED_ERROR 7
#define FOUG_STLB_READ_NO_ERROR 0
#define FOUG_STLB_READ_NULL_GEOM_INPUT_ERROR 1
#define FOUG_STLB_READ_NULL_STREAM_ERROR 2
#define FOUG_STLB_READ_NULL_BUFFER 3
#define FOUG_STLB_READ_INVALID_BUFFER_SIZE_ERROR 4
#define FOUG_STLB_READ_HEADER_WRONG_SIZE_ERROR 5
#define FOUG_STLB_READ_FACET_COUNT_ERROR 6
#define FOUG_STLB_READ_STREAM_ERROR 7
#define FOUG_STLB_READ_TASK_STOPPED_ERROR 8
#endif /* FOUG_C_LIBSTL_STLB_READ_H */

114
src/c/libstl/stlb_write.c
View File

@ -30,27 +30,79 @@ void* foug_stlb_geom_output_get_cookie(const foug_stlb_geom_output_t* geom)
return geom != NULL ? geom->cookie : NULL;
}
void foug_stlb_geom_output_set_cookie(foug_stlb_geom_output_t* geom, void* data)
{
if (geom != NULL)
geom->cookie = data;
}
static foug_bool_t foug_stlb_no_error(int code)
{
return code == FOUG_STLB_WRITE_NO_ERROR;
}
int foug_stlb_write(foug_stlb_write_args_t args)
static void foug_stlb_write_facets(const foug_stlb_geom_output_t* geom_output,
uint8_t* buffer,
uint32_t ifacet_start,
uint32_t facet_count)
{
uint8_t buffer[128];
uint8_t header_data[FOUG_STLB_HEADER_SIZE];
uint32_t facet_count;
foug_stl_triangle_t triangle;
uint16_t attr_byte_count;
uint32_t buffer_offset;
uint32_t i_facet;
if (geom_output->manip.get_triangle_func == NULL)
return;
attr_byte_count = 0;
buffer_offset = 0;
for (i_facet = ifacet_start; i_facet < (ifacet_start + facet_count); ++i_facet) {
(*(geom_output->manip.get_triangle_func))(geom_output, i_facet, &triangle, &attr_byte_count);
/* Normal */
foug_encode_real32_le(triangle.normal.x, buffer + buffer_offset);
foug_encode_real32_le(triangle.normal.y, buffer + 1*sizeof(foug_real32_t) + buffer_offset);
foug_encode_real32_le(triangle.normal.z, buffer + 2*sizeof(foug_real32_t) + buffer_offset);
/* Vertex1 */
foug_encode_real32_le(triangle.v1.x, buffer + 3*sizeof(foug_real32_t) + buffer_offset);
foug_encode_real32_le(triangle.v1.y, buffer + 4*sizeof(foug_real32_t) + buffer_offset);
foug_encode_real32_le(triangle.v1.z, buffer + 5*sizeof(foug_real32_t) + buffer_offset);
/* Vertex2 */
foug_encode_real32_le(triangle.v2.x, buffer + 6*sizeof(foug_real32_t) + buffer_offset);
foug_encode_real32_le(triangle.v2.y, buffer + 7*sizeof(foug_real32_t) + buffer_offset);
foug_encode_real32_le(triangle.v2.z, buffer + 8*sizeof(foug_real32_t) + buffer_offset);
/* Vertex3 */
foug_encode_real32_le(triangle.v3.x, buffer + 9*sizeof(foug_real32_t) + buffer_offset);
foug_encode_real32_le(triangle.v3.y, buffer + 10*sizeof(foug_real32_t) + buffer_offset);
foug_encode_real32_le(triangle.v3.z, buffer + 11*sizeof(foug_real32_t) + buffer_offset);
/* Attribute byte count */
foug_encode_uint16_le(attr_byte_count, buffer + 12*sizeof(foug_real32_t) + buffer_offset);
buffer_offset += FOUG_STLB_TRIANGLE_SIZE;
} /* end for */
}
int foug_stlb_write(foug_stlb_write_args_t args)
{
uint8_t header_data[FOUG_STLB_HEADER_SIZE];
uint32_t facet_count;
uint32_t i_facet;
uint32_t buffer_facet_count;
uint32_t ifacet_start;
int error;
if (args.geom_output == NULL)
return FOUG_STLB_WRITE_NULL_GEOM_OUTPUT_ERROR;
if (args.stream == NULL)
return FOUG_STLB_WRITE_NULL_STREAM_ERROR;
/* if (args.buffer_size == 0)
return FOUG_STLB_WRITE_INVALID_BUFFER_SIZE_ERROR;*/
if (args.buffer == NULL)
return FOUG_STLB_WRITE_NULL_BUFFER_ERROR;
if (args.buffer_size < FOUG_STLB_MIN_CONTENTS_SIZE)
return FOUG_STLB_WRITE_INVALID_BUFFER_SIZE_ERROR;
if (args.geom_output->manip.get_triangle_count_func == NULL)
return FOUG_STLB_WRITE_NULL_GET_TRIANGLE_COUNT_FUNC;
if (args.geom_output->manip.get_triangle_func == NULL)
@ -67,46 +119,34 @@ int foug_stlb_write(foug_stlb_write_args_t args)
/* Write facet count */
facet_count = (*(args.geom_output->manip.get_triangle_count_func))(args.geom_output);
foug_encode_uint32_le(facet_count, buffer);
if (foug_stream_write(args.stream, buffer, sizeof(uint32_t), 1) != 1)
foug_encode_uint32_le(facet_count, args.buffer);
if (foug_stream_write(args.stream, args.buffer, sizeof(uint32_t), 1) != 1)
return FOUG_STLB_WRITE_STREAM_ERROR;
foug_task_control_reset(args.task_control);
foug_task_control_set_range(args.task_control, 0., (foug_real32_t)facet_count);
/* Write triangles */
attr_byte_count = 0;
error = FOUG_STLB_WRITE_NO_ERROR;
for (i_facet = 0; i_facet < facet_count && foug_stlb_no_error(error); ++i_facet) {
(*(args.geom_output->manip.get_triangle_func))(args.geom_output, i_facet,
&triangle, &attr_byte_count);
/* Normal */
foug_encode_real32_le(triangle.normal.x, buffer);
foug_encode_real32_le(triangle.normal.y, buffer + 1*sizeof(foug_real32_t));
foug_encode_real32_le(triangle.normal.z, buffer + 2*sizeof(foug_real32_t));
buffer_facet_count = args.buffer_size / FOUG_STLB_TRIANGLE_SIZE;
ifacet_start = 0;
for (i_facet = 0;
i_facet < facet_count && foug_stlb_no_error(error);
i_facet += buffer_facet_count)
{
/* Write to buffer */
if (buffer_facet_count > (facet_count - ifacet_start))
buffer_facet_count = facet_count - ifacet_start;
foug_stlb_write_facets(args.geom_output, args.buffer, ifacet_start, buffer_facet_count);
ifacet_start += buffer_facet_count;
/* Vertex1 */
foug_encode_real32_le(triangle.v1.x, buffer + 3*sizeof(foug_real32_t));
foug_encode_real32_le(triangle.v1.y, buffer + 4*sizeof(foug_real32_t));
foug_encode_real32_le(triangle.v1.z, buffer + 5*sizeof(foug_real32_t));
/* Vertex2 */
foug_encode_real32_le(triangle.v2.x, buffer + 6*sizeof(foug_real32_t));
foug_encode_real32_le(triangle.v2.y, buffer + 7*sizeof(foug_real32_t));
foug_encode_real32_le(triangle.v2.z, buffer + 8*sizeof(foug_real32_t));
/* Vertex3 */
foug_encode_real32_le(triangle.v3.x, buffer + 9*sizeof(foug_real32_t));
foug_encode_real32_le(triangle.v3.y, buffer + 10*sizeof(foug_real32_t));
foug_encode_real32_le(triangle.v3.z, buffer + 11*sizeof(foug_real32_t));
/* Attribute byte count */
foug_encode_uint16_le(attr_byte_count, buffer + 12*sizeof(foug_real32_t));
/* Write to stream */
if (foug_stream_write(args.stream, buffer, FOUG_STLB_TRIANGLE_SIZE, 1) != 1)
/* Write buffer to stream */
if (foug_stream_write(args.stream, args.buffer, FOUG_STLB_TRIANGLE_SIZE, buffer_facet_count)
!= buffer_facet_count)
{
error = FOUG_STLB_WRITE_STREAM_ERROR;
}
/* Task control */
if (foug_stlb_no_error(error)) {
@ -116,7 +156,7 @@ int foug_stlb_write(foug_stlb_write_args_t args)
}
else {
foug_task_control_set_progress(args.task_control,
(foug_real32_t)(i_facet + 1));
(foug_real32_t)(i_facet + 1));
}
}
} /* end for */

20
src/c/libstl/stlb_write.h
View File

@ -29,25 +29,29 @@ foug_stlb_geom_output_t* foug_stlb_geom_output_create(foug_malloc_func_t func,
FOUG_DATAEX_LIBSTL_EXPORT
void* foug_stlb_geom_output_get_cookie(const foug_stlb_geom_output_t* geom);
FOUG_DATAEX_LIBSTL_EXPORT
void foug_stlb_geom_output_set_cookie(foug_stlb_geom_output_t* geom, void* data);
typedef struct
{
foug_stlb_geom_output_t* geom_output;
foug_stream_t* stream;
foug_task_control_t* task_control;
uint8_t* buffer;
uint32_t buffer_size;
} foug_stlb_write_args_t;
FOUG_DATAEX_LIBSTL_EXPORT
int foug_stlb_write(foug_stlb_write_args_t args);
#define FOUG_STLB_WRITE_NO_ERROR 0
#define FOUG_STLB_WRITE_NULL_GEOM_OUTPUT_ERROR 1
#define FOUG_STLB_WRITE_NULL_STREAM_ERROR 2
#define FOUG_STLB_WRITE_NULL_GET_TRIANGLE_COUNT_FUNC 3
#define FOUG_STLB_WRITE_NULL_GET_TRIANGLE_FUNC 4
#define FOUG_STLB_WRITE_STREAM_ERROR 5
#define FOUG_STLB_WRITE_TASK_STOPPED_ERROR 6
#define FOUG_STLB_WRITE_INVALID_BUFFER_SIZE_ERROR 7
#define FOUG_STLB_WRITE_NO_ERROR 0
#define FOUG_STLB_WRITE_NULL_GEOM_OUTPUT_ERROR 1
#define FOUG_STLB_WRITE_NULL_STREAM_ERROR 2
#define FOUG_STLB_WRITE_NULL_BUFFER_ERROR 3
#define FOUG_STLB_WRITE_NULL_GET_TRIANGLE_COUNT_FUNC 4
#define FOUG_STLB_WRITE_NULL_GET_TRIANGLE_FUNC 5
#define FOUG_STLB_WRITE_STREAM_ERROR 6
#define FOUG_STLB_WRITE_TASK_STOPPED_ERROR 7
#define FOUG_STLB_WRITE_INVALID_BUFFER_SIZE_ERROR 8
#endif /* FOUG_C_LIBSTL_STLB_WRITE_H */

6
src/c/stream.c
View File

@ -99,3 +99,9 @@ void* foug_stream_get_cookie(const foug_stream_t* stream)
{
return stream != NULL ? stream->cookie : NULL;
}
void foug_stream_set_cookie(foug_stream_t* stream, void* data)
{
if (stream != NULL)
stream->cookie = data;
}

1
src/c/stream.h
View File

@ -35,5 +35,6 @@ FOUG_LIB_EXPORT size_t foug_stream_read(foug_stream_t* stream,
FOUG_LIB_EXPORT size_t foug_stream_write(foug_stream_t* stream,
const void* ptr, size_t item_size, size_t item_count);
FOUG_LIB_EXPORT void* foug_stream_get_cookie(const foug_stream_t* stream);
FOUG_LIB_EXPORT void foug_stream_set_cookie(foug_stream_t* stream, void* data);
#endif /* FOUG_C_STREAM_H */

10
src/c/task_control.c
View File

@ -27,7 +27,7 @@ foug_task_control_t* foug_task_control_create(foug_malloc_func_t func,
return NULL;
ctrl = (*func)(sizeof(struct _internal_foug_task_control));
if (ctrl != 0) {
if (ctrl != NULL) {
ctrl->range_min = -1.f;
ctrl->range_max = -2.f;
ctrl->range_length = -0.f;
@ -88,7 +88,7 @@ foug_real32_t foug_task_control_get_progress_as_pc(const foug_task_control_t* ct
{
if (ctrl == NULL)
return 0.f;
return fabsf((ctrl->progress_value - ctrl->range_min) / ctrl->range_length);
return fabs((ctrl->progress_value - ctrl->range_min) / ctrl->range_length);
}
foug_real32_t foug_task_control_get_progress(const foug_task_control_t* ctrl)
@ -160,3 +160,9 @@ void* foug_task_control_get_cookie(const foug_task_control_t* ctrl)
{
return ctrl != NULL ? ctrl->cookie : NULL;
}
void foug_task_control_set_cookie(foug_task_control_t* ctrl, void* data)
{
if (ctrl != NULL)
ctrl->cookie = data;
}

1
src/c/task_control.h
View File

@ -52,5 +52,6 @@ FOUG_LIB_EXPORT foug_bool_t foug_task_control_is_stop_requested(const foug_task_
/* Cookie */
FOUG_LIB_EXPORT void* foug_task_control_get_cookie(const foug_task_control_t* ctrl);
FOUG_LIB_EXPORT void foug_task_control_set_cookie(foug_task_control_t* ctrl, void* data);
#endif /* FOUG_C_TASK_CONTROL_H */