static int create_mesh(int i) { int j; if ((j = vecadd(get_object(i)->mv)) >= 0) { struct object_mesh *m = get_object_mesh(i, j); m->fv = vecnew(0, sizeof (struct object_face)); m->ev = vecnew(0, sizeof (struct object_edge)); } return j; }
void recv_create_object(void) { /* Unpack the object header. */ int i = new_object(); int n = recv_index(); int j, k; struct object *o = get_object(i); struct object_mesh *m = NULL; o->count = 1; /* Unpack the vertices and meshes. */ o->vv = recv_vector(); o->mv = vecnew(n, sizeof (struct object_mesh)); for (j = 0; j < n; ++j) if ((k = vecadd(o->mv)) >= 0) { m = (struct object_mesh *) vecget(o->mv, k); m->brush = recv_index(); m->fv = recv_vector(); m->ev = recv_vector(); } /* Encapsulate this object in an entity. */ recv_create_entity(); }
struct entity_func *startup_sprite(void) { if ((sprite = vecnew(MIN_SPRITES, sizeof (struct sprite)))) return &sprite_func; else return NULL; }
struct entity_func *startup_object(void) { if ((object = vecnew(MIN_OBJECTS, sizeof (struct object)))) return &object_func; else return NULL; }
struct entity_func *startup_camera(void) { if ((camera = vecnew(MIN_CAMERAS, sizeof (struct camera)))) return &camera_func; else return NULL; }
static struct uniform *get_uniform(struct brush *b, const char *n) { struct uniform *u = NULL; /* Ensure that the uniform vector exists. */ if (b->uniform == NULL) b->uniform = vecnew(4, sizeof (struct uniform)); if (b->uniform) { int i; /* Search for an existing uniform of the given name. */ for (i = 0; i < vecnum(b->uniform); ++i) if (!strcmp(((struct uniform *) vecget(b->uniform, i))->name, n)) return (struct uniform *) vecget(b->uniform, i); /* This uniform does not exist. Create it. */ if ((u = (struct uniform *) vecget(b->uniform, vecadd(b->uniform)))) { u->name = memdup(n, 1, strlen(n) + 1); u->rows = 0; u->cols = 0; u->indx = 0; u->vals = NULL; } } return u; }
struct entity_func *startup_galaxy(void) { if ((galaxy = vecnew(MIN_GALAXIES, sizeof (struct galaxy)))) return &galaxy_func; else return NULL; }
static void RecvProxy_VectorDirtySurround( const CRecvProxyData *pData, void *pStruct, void *pOut ) { Vector &vecold = *((Vector*)pOut); Vector vecnew( pData->m_Value.m_Vector[0], pData->m_Value.m_Vector[1], pData->m_Value.m_Vector[2] ); if ( vecold != vecnew ) { vecold = vecnew; ((CCollisionProperty*)pStruct)->MarkSurroundingBoundsDirty(); } }
static struct object_mesh *read_usemtl(vector_t mv, const char *line, const char *file) { int i; if ((i = vecadd(mv)) >= 0) { struct object_mesh *m = (struct object_mesh *) vecget(mv, i); if (line) m->brush = send_create_brush(file, parse_name(line)); else m->brush = 0; m->fv = vecnew(0, sizeof (struct object_face)); m->ev = vecnew(0, sizeof (struct object_edge)); return m; } return NULL; }
int startup_brush(void) { if ((brush = vecnew(16, sizeof (struct brush)))) { int i; /* Create a default brush. */ if ((i = new_brush()) >= 0) { struct brush *b = get_brush(i); b->count = 1; b->state = 0; b->flags = BRUSH_DIFFUSE | BRUSH_SPECULAR | BRUSH_AMBIENT | BRUSH_SHINY; b->d[0] = BRUSH_DIFFUSE_R; b->d[1] = BRUSH_DIFFUSE_G; b->d[2] = BRUSH_DIFFUSE_B; b->d[3] = BRUSH_DIFFUSE_A; b->s[0] = BRUSH_SPECULAR_R; b->s[1] = BRUSH_SPECULAR_G; b->s[2] = BRUSH_SPECULAR_B; b->s[3] = BRUSH_SPECULAR_A; b->a[0] = BRUSH_AMBIENT_R; b->a[1] = BRUSH_AMBIENT_G; b->a[2] = BRUSH_AMBIENT_B; b->a[3] = BRUSH_AMBIENT_A; b->x[0] = BRUSH_SHININESS; b->line_width = 1.0f; return 1; } } return 0; }
static int read_obj(const char *filename, struct object *o) { char L[MAXSTR]; char W[MAXSTR]; FILE *fin; int i, j, n = 0; /* Initialize the object element vectors. */ vector_t vv = o->vv = vecnew(0, sizeof (struct object_vert)); vector_t mv = o->mv = vecnew(0, sizeof (struct object_mesh)); if (filename) { path_push(get_file_path(filename)); /* Initialize the loader vector caches. */ _uv = vecnew(1024, sizeof (struct vec2)); _nv = vecnew(1024, sizeof (struct vec3)); _vv = vecnew(1024, sizeof (struct vec3)); uerr = nerr = verr = 0; if ((fin = open_file(get_file_name(filename), "r"))) { /* Create a default catch-all group using the default material. */ struct object_mesh *m = read_usemtl(mv, NULL, NULL); const char *F = NULL; /* Process each line, invoking the handler for each keyword. */ while (fgets(L, MAXSTR, fin)) if (sscanf(L, "%s%n", W, &n) >= 1) { char *V = L + n; if (!strcmp(W, "mtllib")) F = read_mtllib(mv, V); else if (!strcmp(W, "usemtl")) m = read_usemtl(mv, V, F); else if (!strcmp(W, "f")) read_f(vv, m->fv, V); else if (!strcmp(W, "l")) read_l(vv, m->ev, V); else if (!strcmp(W, "vt")) read_vt(V); else if (!strcmp(W, "vn")) read_vn(V); else if (!strcmp(W, "v" )) read_v (V); } fclose(fin); } else error("OBJ file '%s': %s", filename, system_error()); /* Remove any empty meshes. */ for (i = 0; i < vecnum(o->mv); ) if (vecnum(((struct object_mesh *) vecget(o->mv, i))->fv) || vecnum(((struct object_mesh *) vecget(o->mv, i))->ev)) i++; else { memmove(vecget(o->mv, i), vecget(o->mv, i + 1), (vecnum(o->mv) - i - 1) * sizeof (struct object_mesh)); vecpop(o->mv); } /* Compute tangent and bitangent vectors. */ calc_tbn(o); /* Sort meshes such that transparent ones appear last. */ for (i = 0; i < vecnum(o->mv); ++i) for (j = i + 1; j < vecnum(o->mv); ++j) { struct object_mesh *mi = vecget(o->mv, i); struct object_mesh *mj = vecget(o->mv, j); struct object_mesh mt; if (get_brush_t(mi->brush) > get_brush_t(mj->brush)) { mt = *mi; *mi = *mj; *mj = mt; } } /* Release the loader caches. */ vecdel(_vv); vecdel(_nv); vecdel(_uv); /* Report index errors. */ if (uerr > 0) error("OBJ file '%s' has %d bad texture indices", filename, uerr); if (nerr > 0) error("OBJ file '%s' has %d bad normal indices", filename, nerr); if (verr > 0) error("OBJ file '%s' has %d bad vertex indices", filename, verr); path_pop(); } return 1; }