void Model::mesh_create_all(Scene &scene, const aiNode &node, const BoneForAssimpBone &boneForAssimpBone)
{
mesh_create(scene, node, boneForAssimpBone);
for (unsigned int i = 0; i < node.mNumChildren; i++) {
mesh_create_all(scene, *node.mChildren[i], boneForAssimpBone);
}
}
void create_random_meshes(const char *filename,int num_meshes)
{
hid_t fid,mid;
herr_t status = output_file_create(filename,&fid);
char mesh_name[64];
telem_t elem;
int seed = 0x123456;
int m;
if ( status != DANU_SUCCESS ) {
printf("FAILED TO CREATE DUMMY TEST FILE\n");
fail_exit_now();
}
for(m=1; m <= num_meshes; m++) {
elem = generate_random_bound_int(LINE_ELEM,HEX_ELEM,&seed);
sprintf(mesh_name,"Mesh %02d",m);
status = mesh_create(fid,mesh_name,UNSTRUCTURED_MESH,elem,&mid);
if ( status != DANU_SUCCESS ) {
printf("FAILED TO CREATE DUMMY MESH\n");
fail_exit_now();
}
danu_group_close(mid);
}
output_file_close(&fid);
}
RID VisualServer::make_sphere_mesh(int p_lats,int p_lons,float p_radius) {
DVector<Vector3> vertices;
DVector<Vector3> normals;
for(int i = 1; i <= p_lats; i++) {
double lat0 = Math_PI * (-0.5 + (double) (i - 1) / p_lats);
double z0 = Math::sin(lat0);
double zr0 = Math::cos(lat0);
double lat1 = Math_PI * (-0.5 + (double) i / p_lats);
double z1 = Math::sin(lat1);
double zr1 = Math::cos(lat1);
for(int j = p_lons; j >= 1; j--) {
double lng0 = 2 * Math_PI * (double) (j - 1) / p_lons;
double x0 = Math::cos(lng0);
double y0 = Math::sin(lng0);
double lng1 = 2 * Math_PI * (double) (j) / p_lons;
double x1 = Math::cos(lng1);
double y1 = Math::sin(lng1);
Vector3 v[4]={
Vector3(x1 * zr0, z0, y1 *zr0),
Vector3(x1 * zr1, z1, y1 *zr1),
Vector3(x0 * zr1, z1, y0 *zr1),
Vector3(x0 * zr0, z0, y0 *zr0)
};
#define ADD_POINT(m_idx)\
normals.push_back(v[m_idx]); \
vertices.push_back(v[m_idx]*p_radius);\
ADD_POINT(0);
ADD_POINT(1);
ADD_POINT(2);
ADD_POINT(2);
ADD_POINT(3);
ADD_POINT(0);
}
}
RID mesh = mesh_create();
Array d;
d.resize(VS::ARRAY_MAX);
d[ARRAY_VERTEX]=vertices;
d[ARRAY_NORMAL]=normals;
mesh_add_surface(mesh,PRIMITIVE_TRIANGLES,d);
return mesh;
}
int
main(int argc, char** argv) {
cairo_surface_t *sfc;
cairo_t *ctx;
int x, y;
struct timespec ts = {0, 500000000};
int running;
x = y = 0;
sfc = cairo_create_x11_surface(&x, &y);
ctx = cairo_create(sfc);
cairo_set_antialias(ctx, CAIRO_ANTIALIAS_NONE);
mesh_t* m = mesh_create(x, y);
for (running = 1; running;) {
cairo_push_group(ctx);
cairo_set_source_rgb(ctx, 0.1, 0.1, 0.1);
cairo_paint(ctx);
mesh_draw(ctx, m);
cairo_pop_group_to_source(ctx);
cairo_paint(ctx);
cairo_surface_flush(sfc);
int event=0;
switch (event=cairo_check_event(sfc, 0)) {
case 0xff53: // right cursor
break;
case 0xff51: // left cursor
break;
case 0xff1b: // Esc
case -1: // left mouse button
running = 0;
break;
}
nanosleep(&ts, NULL);
}
mesh_free(m);
cairo_destroy(ctx);
cairo_close_x11_surface(sfc);
return 0;
}
bool
mesh_resize_capacity(Mesh_data *data, const size_t size_hint)
{
assert(data);
assert(size_hint > data->size); // Will slice data
// Create new data.
Mesh_data new_data;
const bool created_new = mesh_create(&new_data, size_hint);
// Failed to resize.
if(!created_new)
{
mesh_destroy(&new_data);
return false;
}
// Copy over data
{
memcpy(new_data.keys, data->keys, sizeof(uint32_t) * data->size);
memcpy(new_data.field_name, data->field_name, sizeof(char) * data->size * 32);
memcpy(new_data.field_mesh, data->field_mesh, sizeof(Graphics_api::Mesh) * data->size * 1);
memcpy(new_data.field_aabb, data->field_aabb, sizeof(math::aabb) * data->size * 1);
}
// Swap ptrs
{
uint32_t *old_keys = data->keys;
data->keys = new_data.keys;
new_data.keys = old_keys;
char *old_name = data->field_name;
data->field_name = new_data.field_name;
new_data.field_name = old_name;
Graphics_api::Mesh *old_mesh = data->field_mesh;
data->field_mesh = new_data.field_mesh;
new_data.field_mesh = old_mesh;
math::aabb *old_aabb = data->field_aabb;
data->field_aabb = new_data.field_aabb;
new_data.field_aabb = old_aabb;
}
// Set the Capacity
{
size_t *capacity = const_cast<size_t*>(&data->capacity);
*capacity = new_data.capacity;
}
// Destroy new data
mesh_destroy(&new_data);
return true;
}
struct mesh *obj_read(const char *file)
{
FILE *f;
char line[512];
const char *str;
struct mesh *mesh;
int has_normals = 0;
if (!(f = fopen(file, "r")))
return NULL;
mesh = mesh_create();
while (!feof(f)) {
if (!fgets(line, sizeof(line), f))
break;
str = line;
if (strncmp(str, "v ", 2) == 0) {
/* Vertex command */
vector v;
sscanf(str, "v %f %f %f", v, v + 1, v + 2);
mesh_add_vertex(mesh, v);
} else if (strncmp(str, "vn ", 3) == 0) {
/* Normal command */
vector n;
sscanf(str, "vn %f %f %f", n, n + 1, n + 2);
mesh_add_normal(mesh, n);
} else if (strncmp(str, "f ", 2) == 0) {
/* Face command */
int vi, ti, ni;
mesh_begin_face(mesh);
str = skip_space(++str); /* Skip 'f ' */
while (*str) {
vi = ti = ni = 0;
if (sscanf(str, "%d/%d/%d", &vi, &ti, &ni) == 3)
has_normals = 1;
mesh_add_index(mesh, vi - 1, ni - 1);
str = skip_non_space(str);
str = skip_space(str);
}
mesh_end_face(mesh);
}
}
fclose(f);
if (!has_normals)
mesh_compute_normals(mesh);
return mesh;
}
Text *Node::text_create(Font *font, Scene &scene)
{
Assets &assets = scene.assets_get();
std::unique_ptr<Text> text(new Text());
Text *text_ptr = text.get();
text_ptr->font_set(font);
text_set(text_ptr);
if (!mesh_get())
mesh_create(scene);
assets.text_add(std::move(text));
return text_ptr;
}
END_TEST
START_TEST (test_unstruct_mesh_create)
{
const char test_file[] = FILENAME;
hid_t fid,mid;
herr_t status = output_file_create(test_file,&fid);
char mesh_name[64];
telem_t elem;
fail_unless ( H5_ISA_VALID_ID(fid),
"Failed to create output file. Invalid H5 ID");
if ( H5_ISA_VALID_ID(fid) ) {
elem = -2;
sprintf(mesh_name,"Failed Mesh");
status = mesh_create(fid,mesh_name,UNSTRUCTURED_MESH,elem,&mid);
fail_unless( status != DANU_SUCCESS,
"Failed to flag bad elem type");
/* Create mesh for each element type */
for(elem=LINE_ELEM; elem <= HEX_ELEM; elem++) {
sprintf(mesh_name,"%s elemtype=%d",MESHNAME, elem);
status = mesh_create(fid,mesh_name,UNSTRUCTURED_MESH,elem,&mid);
fail_unless( status == DANU_SUCCESS,
"Failed to create 2D unstructured mesh");
}
output_file_close(&fid);
danu_file_delete(test_file);
}
}
struct mesh *luaL_checkmesh(lua_State *L, int index)
{
struct mesh *m;
luaL_argcheck(L, lua_ismesh(L, index), index, "not a mesh");
m = mesh_create();
lua_getfield(L, -1, "vertices");
mesh_addluaverts(m, L, -1);
lua_pop(L, 1);
lua_getfield(L, -1, "faces");
mesh_addluafaces(m, L, -1);
lua_pop(L, 1);
return m;
}
int load_level(const char *filename)
{
struct mesh *m;
const char *err;
int ret;
DEBUG(1, "game: load_level(\"%s\")\n", filename);
ret = luaL_dofile(L1, filename);
if (ret)
{
err = lua_tostring(L1, -1);
ERROR("error while loading level: %s", err);
lua_pop(L1, 1);
return 1;
}
lua_getfield(L1, -1, "vertices");
if (!lua_istable(L1, -1))
{
ERROR("expected `vertices' field in Lua level data table");
lua_pop(L1, 2);
return 1;
}
clear_level();
m = mesh_create();
mesh_addluaverts(m, L1, -1);
lua_pop(L1, 1);
lua_getfield(L1, -1, "faces");
if (!lua_istable(L1, -1))
{
mesh_destroy(m);
ERROR("expected `faces' field in Lua level data table");
return 1;
}
mesh_addluafaces(m, L1, -1);
lua_pop(L1, 1);
lua_setglobal(L1, "level");
level = model_create(m);
/* m is no longer needed. */
mesh_destroy(m);
gfx_prepmodel(level);
gfx->set_level(level);
return 0;
}
struct model *model_create(const struct mesh *data)
{
struct model *m;
m = CALLOC1(struct model);
if (data)
{
DEBUG(3, "model_create(%p) = %p\n", data, m);
DEBUG(2, "Created new model\n");
m->ngroups = 1;
m->groups = mesh_create();
mesh_copy(m->groups, data);
m->offsets = CALLOC1(vector);
}
else
{
DEBUG(3, "model_create(NULL) = %p\n", m);
DEBUG(2, "Created new empty model\n");
}
return m;
}
object_t *
object_get_fs_quad(void)
{
vbuf_fmt_t format = 0;
mesh_t *mesh;
object_t *object;
float verts[] = {
-1.0, -1.0, 0.0, 1.0,
1.0, -1.0, 0.0, 1.0,
1.0, 1.0, 0.0, 1.0,
-1.0, 1.0, 0.0, 1.0,
};
uint16_t elems[] = { 0, 1, 2, 3 };
vbuf_fmt_add(&format, "position", 4, GL_FLOAT);
mesh = mesh_create(4, verts, 4, elems, format, GL_TRIANGLE_FAN);
object = object_create(NULL);
object_set_mesh(object, mesh);
mesh_ungrab(mesh);
return object;
}
/** setup fresh libworker struct */
static struct libworker*
libworker_setup(struct ub_ctx* ctx, int is_bg, struct ub_event_base* eb)
{
unsigned int seed;
struct libworker* w = (struct libworker*)calloc(1, sizeof(*w));
struct config_file* cfg = ctx->env->cfg;
int* ports;
int numports;
if(!w) return NULL;
w->is_bg = is_bg;
w->ctx = ctx;
w->env = (struct module_env*)malloc(sizeof(*w->env));
if(!w->env) {
free(w);
return NULL;
}
*w->env = *ctx->env;
w->env->alloc = context_obtain_alloc(ctx, !w->is_bg || w->is_bg_thread);
if(!w->env->alloc) {
libworker_delete(w);
return NULL;
}
w->thread_num = w->env->alloc->thread_num;
alloc_set_id_cleanup(w->env->alloc, &libworker_alloc_cleanup, w);
if(!w->is_bg || w->is_bg_thread) {
lock_basic_lock(&ctx->cfglock);
}
w->env->scratch = regional_create_custom(cfg->msg_buffer_size);
w->env->scratch_buffer = sldns_buffer_new(cfg->msg_buffer_size);
w->env->fwds = forwards_create();
if(w->env->fwds && !forwards_apply_cfg(w->env->fwds, cfg)) {
forwards_delete(w->env->fwds);
w->env->fwds = NULL;
}
w->env->hints = hints_create();
if(w->env->hints && !hints_apply_cfg(w->env->hints, cfg)) {
hints_delete(w->env->hints);
w->env->hints = NULL;
}
if(cfg->ssl_upstream) {
w->sslctx = connect_sslctx_create(NULL, NULL,
cfg->tls_cert_bundle);
if(!w->sslctx) {
/* to make the setup fail after unlock */
hints_delete(w->env->hints);
w->env->hints = NULL;
}
}
if(!w->is_bg || w->is_bg_thread) {
lock_basic_unlock(&ctx->cfglock);
}
if(!w->env->scratch || !w->env->scratch_buffer || !w->env->fwds ||
!w->env->hints) {
libworker_delete(w);
return NULL;
}
w->env->worker = (struct worker*)w;
w->env->probe_timer = NULL;
seed = (unsigned int)time(NULL) ^ (unsigned int)getpid() ^
(((unsigned int)w->thread_num)<<17);
seed ^= (unsigned int)w->env->alloc->next_id;
if(!w->is_bg || w->is_bg_thread) {
lock_basic_lock(&ctx->cfglock);
}
if(!(w->env->rnd = ub_initstate(seed, ctx->seed_rnd))) {
if(!w->is_bg || w->is_bg_thread) {
lock_basic_unlock(&ctx->cfglock);
}
seed = 0;
libworker_delete(w);
return NULL;
}
if(!w->is_bg || w->is_bg_thread) {
lock_basic_unlock(&ctx->cfglock);
}
if(1) {
/* primitive lockout for threading: if it overwrites another
* thread it is like wiping the cache (which is likely empty
* at the start) */
/* note we are holding the ctx lock in normal threaded
* cases so that is solved properly, it is only for many ctx
* in different threads that this may clash */
static int done_raninit = 0;
if(!done_raninit) {
done_raninit = 1;
hash_set_raninit((uint32_t)ub_random(w->env->rnd));
}
}
seed = 0;
if(eb)
w->base = comm_base_create_event(eb);
else w->base = comm_base_create(0);
if(!w->base) {
libworker_delete(w);
return NULL;
}
w->env->worker_base = w->base;
if(!w->is_bg || w->is_bg_thread) {
lock_basic_lock(&ctx->cfglock);
}
numports = cfg_condense_ports(cfg, &ports);
if(numports == 0) {
int locked = !w->is_bg || w->is_bg_thread;
libworker_delete(w);
if(locked) {
lock_basic_unlock(&ctx->cfglock);
}
return NULL;
}
w->back = outside_network_create(w->base, cfg->msg_buffer_size,
(size_t)cfg->outgoing_num_ports, cfg->out_ifs,
cfg->num_out_ifs, cfg->do_ip4, cfg->do_ip6,
cfg->do_tcp?cfg->outgoing_num_tcp:0,
w->env->infra_cache, w->env->rnd, cfg->use_caps_bits_for_id,
ports, numports, cfg->unwanted_threshold,
cfg->outgoing_tcp_mss, &libworker_alloc_cleanup, w,
cfg->do_udp || cfg->udp_upstream_without_downstream, w->sslctx,
cfg->delay_close, NULL);
w->env->outnet = w->back;
if(!w->is_bg || w->is_bg_thread) {
lock_basic_unlock(&ctx->cfglock);
}
free(ports);
if(!w->back) {
libworker_delete(w);
return NULL;
}
w->env->mesh = mesh_create(&ctx->mods, w->env);
if(!w->env->mesh) {
libworker_delete(w);
return NULL;
}
w->env->send_query = &libworker_send_query;
w->env->detach_subs = &mesh_detach_subs;
w->env->attach_sub = &mesh_attach_sub;
w->env->add_sub = &mesh_add_sub;
w->env->kill_sub = &mesh_state_delete;
w->env->detect_cycle = &mesh_detect_cycle;
comm_base_timept(w->base, &w->env->now, &w->env->now_tv);
return w;
}
RID VisualServer::_make_test_cube() {
DVector<Vector3> vertices;
DVector<Vector3> normals;
DVector<float> tangents;
DVector<Vector3> uvs;
int vtx_idx=0;
#define ADD_VTX(m_idx);\
vertices.push_back( face_points[m_idx] );\
normals.push_back( normal_points[m_idx] );\
tangents.push_back( normal_points[m_idx][1] );\
tangents.push_back( normal_points[m_idx][2] );\
tangents.push_back( normal_points[m_idx][0] );\
tangents.push_back( 1.0 );\
uvs.push_back( Vector3(uv_points[m_idx*2+0],uv_points[m_idx*2+1],0) );\
vtx_idx++;\
for (int i=0;i<6;i++) {
Vector3 face_points[4];
Vector3 normal_points[4];
float uv_points[8]={0,0,0,1,1,1,1,0};
for (int j=0;j<4;j++) {
float v[3];
v[0]=1.0;
v[1]=1-2*((j>>1)&1);
v[2]=v[1]*(1-2*(j&1));
for (int k=0;k<3;k++) {
if (i<3)
face_points[j][(i+k)%3]=v[k]*(i>=3?-1:1);
else
face_points[3-j][(i+k)%3]=v[k]*(i>=3?-1:1);
}
normal_points[j]=Vector3();
normal_points[j][i%3]=(i>=3?-1:1);
}
//tri 1
ADD_VTX(0);
ADD_VTX(1);
ADD_VTX(2);
//tri 2
ADD_VTX(2);
ADD_VTX(3);
ADD_VTX(0);
}
RID test_cube = mesh_create();
Array d;
d.resize(VS::ARRAY_MAX);
d[VisualServer::ARRAY_NORMAL]= normals ;
d[VisualServer::ARRAY_TANGENT]= tangents ;
d[VisualServer::ARRAY_TEX_UV]= uvs ;
d[VisualServer::ARRAY_VERTEX]= vertices ;
DVector<int> indices;
indices.resize(vertices.size());
for(int i=0;i<vertices.size();i++)
indices.set(i,i);
d[VisualServer::ARRAY_INDEX]=indices;
mesh_add_surface( test_cube, PRIMITIVE_TRIANGLES,d );
RID material = fixed_material_create();
//material_set_flag(material, MATERIAL_FLAG_BILLBOARD_TOGGLE,true);
fixed_material_set_texture( material, FIXED_MATERIAL_PARAM_DIFFUSE, get_test_texture() );
fixed_material_set_param( material, FIXED_MATERIAL_PARAM_SPECULAR_EXP, 70 );
fixed_material_set_param( material, FIXED_MATERIAL_PARAM_EMISSION, Vector3(0.2,0.2,0.2) );
fixed_material_set_param( material, FIXED_MATERIAL_PARAM_DIFFUSE, Color(1, 1, 1) );
fixed_material_set_param( material, FIXED_MATERIAL_PARAM_SPECULAR, Color(1,1,1) );
mesh_surface_set_material(test_cube, 0, material );
return test_cube;
}
int main(int argc, char ** argv)
{
int num_errs = 0;
hid_t fid, mid;
char root_file[] = FILE;
char meshname[] = MESH_NAME1;
tmesh_t mesh_type = UNSTRUCTURED_MESH;
telem_t elem_type = HEX_ELEM;
int elem_order = HEX_ELEM_ORDER;
double *coordinates[DIM];
int exists;
int nmesh;
char **meshnames;
int i,*size;
if ( DANU_RETURN_FAIL(output_file_create(root_file,&fid)) ) {
DANU_ERROR_MESS("Failed to create the output file");
num_errs++;
goto EXIT_NOW;
}
/* Create a mesh */
if ( DANU_RETURN_FAIL(mesh_create(fid,meshname,DIM,mesh_type,elem_type)) ) {
DANU_ERROR_MESS("Failed to create the mesh group");
num_errs++;
goto EXIT_NOW;
}
/* Query the existence of the mesh */
if ( DANU_RETURN_FAIL(mesh_exists(fid,meshname,&exists) ) ) {
DANU_ERROR_MESS("Failed to query mesh");
num_errs++;
goto EXIT_NOW;
}
if ( exists ) {
printf("Mesh existence query successful\n");
}
/* Query a mesh that does not exist */
if ( DANU_RETURN_FAIL(mesh_exists(fid,"DUHMesh",&exists) ) ) {
DANU_ERROR_MESS("Failed to query fake mesh");
num_errs++;
goto EXIT_NOW;
}
if ( ! exists ) {
printf("Query of fake mesh passed\n");
}
/* Create another mesh */
sprintf(meshname,MESH_NAME2);
mesh_type = STRUCTURED_MESH;
elem_type = HEX_ELEM;
if ( DANU_RETURN_FAIL(mesh_create(fid,meshname,DIM,mesh_type,elem_type)) ) {
DANU_ERROR_MESS("Failed to create the second mesh group");
num_errs++;
goto EXIT_NOW;
}
/* Count the number of meshes */
if ( DANU_RETURN_FAIL(mesh_count(fid,&nmesh) ) ) {
DANU_ERROR_MESS("Failed to count meshes");
num_errs++;
goto EXIT_NOW;
}
printf("Found %d meshes in %s\n", nmesh, root_file);
/* Now get the names */
meshnames = DANU_MALLOC(char *, nmesh);
size = DANU_MALLOC(int,nmesh);
for(i=0;i<nmesh;i++) {
size[i] = 64;
meshnames[i] = DANU_MALLOC(char, size[i]);
}
if ( DANU_RETURN_FAIL(mesh_list(fid,nmesh,size,meshnames) ) ) {
DANU_ERROR_MESS("Failed to get mesh list");
num_errs++;
goto EXIT_NOW;
}
DANU_FREE(size);
for(i=0;i<nmesh;i++) {
printf("\t-->%s\n",meshnames[i]);
DANU_FREE(meshnames[i]);
}
DANU_FREE(meshnames);
danu_file_close(fid);
goto EXIT_NOW;
EXIT_NOW:
printf("Found %d errors\n",num_errs);
return num_errs;
}
