/* assuming the spec is going to be properly written
not error-checking here */
void read_spec(char *fname) {
char buffer[300];
FILE *fp;
fp = fopen(fname, "r");
my_assert(fp, "can't open spec");
while(!feof(fp)){
fgets(buffer, 300, fp);
//printf("read line: %s\n", buffer);
switch (buffer[0]) {
case '#':
break;
case '1': //cube
//read in the cube
parse_obj(buffer);
break;
//etc
case 'l':
parse_light(buffer);
break;
case 'c':
parse_camera(buffer);
break;
default:
break;
}
}
}
bool parse_scene_obj(t_xml_parser *xml, t_parse_scene *scene)
{
t_obj *obj;
if (!parse_obj(xml, &obj, &scene->kdtree.pts))
return (false);
kdtree_builder_push(&scene->kdtree, obj);
return (true);
}
static void init(){
vertices = (Real**)malloc(numOfObjects*sizeof(Real*));//create multidimensinal arrays
faces = (int**)malloc(numOfObjects*sizeof(int*));
numOfVerts = (int*)malloc(numOfObjects*sizeof(int));
numOfFaces = (int*)malloc(numOfObjects*sizeof(int));
getNumOfVertsFaces("datafiles/sphere.obj", 0, vertices, faces, numOfVerts, numOfFaces);
getNumOfVertsFaces("datafiles/arena.obj", 1, vertices, faces, numOfVerts, numOfFaces);
getNumOfVertsFaces("datafiles/ends1.obj", 2, vertices, faces, numOfVerts, numOfFaces);
getNumOfVertsFaces("datafiles/ends2.obj", 3, vertices, faces, numOfVerts, numOfFaces);
getNumOfVertsFaces("datafiles/stands.obj", 4, vertices, faces, numOfVerts, numOfFaces);
getNumOfVertsFaces("datafiles/bar.obj", 5, vertices, faces, numOfVerts, numOfFaces);
parse_obj("datafiles/sphere.obj", 0, vertices, faces);
parse_obj("datafiles/arena.obj", 1, vertices, faces);
parse_obj("datafiles/ends1.obj", 2, vertices, faces);
parse_obj("datafiles/ends2.obj", 3, vertices, faces);
parse_obj("datafiles/stands.obj", 4, vertices, faces);
parse_obj("datafiles/bar.obj", 5, vertices, faces);
//init terrain
grid_terrain_set_draw_op(GL_TRIANGLES);
grid_terrain_set_unit(grid_unit);
grid_terrain_set_color(ground_color);
grid_terrain_create();
}
void _lao_load_model(LaoModel *m, const char *filename) {
_LaoObjFileData data;
unsigned int i;
LaoVertex *verts;
memset(m, 0, sizeof(LaoModel));
m->name = _lao_get_res_name(LAO_MODEL_PATH, filename);
parse_obj(filename, &data);
m->count = data.icount;
verts = calloc(data.icount, sizeof(LaoVertex));
memset(verts, 0, data.icount*sizeof(LaoVertex));
for(i = 0; i < data.icount; i++) {
int xi, ni, ti;
xi = data.indices[i][0]-1;
if(xi < 0 || xi >= data.xcount)
bad_reference_error(filename, "vertex", i);
memcpy(verts[i].x, data.xs[xi], sizeof(Vec3));
if(data.tcount) {
ti = data.indices[i][1]-1;
if(ti < 0 || ti >= data.tcount)
bad_reference_error(filename, "texcoord", i);
verts[i].s = data.texcoords[ti][0];
verts[i].t = data.texcoords[ti][1];
}
if(data.ncount) {
ni = data.indices[i][2]-1;
if(ni < 0 || ni >= data.ncount)
bad_reference_error(filename, "normal", ni);
memcpy(verts[i].n, data.normals[ni], sizeof(Vec3));
}
}
_lao_vbo_bind_model(&lao_bos.vbo, m, verts);
lao_log_msg("%s -> %s", filename, m->name);
free(verts);
free(data.xs);
free(data.normals);
free(data.texcoords);
free(data.indices);
}
int main(int ac, char **av)
{
t_mlx *e;
t_obj *obj;
if (ac != 2)
{
printf("Usage: %s [file.obj]\n", av[0]);
return (0);
}
obj = parse_obj(av[1]);
e = ft_memalloc(sizeof(t_mlx));
e->mlx = mlx_init();
e->win = mlx_new_opengl_window(e->mlx, WIDTH, HEIGHT, "Scop");
mlx_opengl_window_set_context(e->win);
init();
render_window(e, obj);
mlx_loop(e->mlx);
return (0);
}
/* assuming the spec is going to be properly written
not error-checking here */
void read_spec(char *fname) {
char buffer[300];
FILE *fp;
fp = fopen(fname, "r");
my_assert(fp, "can't open spec");
while(!feof(fp))
{
buffer[0] = '#';
fgets(buffer, 300, fp);
//printf("read line: %s\n", buffer);
switch (buffer[0])
{
case '#':
break;
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
{ //You dont need seperate cases, you always just call parse_obj()
parse_obj(buffer);
break;
}
case 'l':
parse_light(buffer);
break;
case 'c':
parse_camera(buffer);
break;
default:
break;
}
}
}
std::string ConfigReader::parse_olist(const std::string &key,
const std::string &buf, std::string &err)
{
std::string s, item;
size_t end;
s = buf.substr(1);
while (s.back() != '}')
s.pop_back();
s.pop_back();
while (isspace(s.back()))
s.pop_back();
end = 0;
while (end != std::string::npos) {
remove_leading(s);
if ((end = s.find('}')) != std::string::npos) {
item = s.substr(0, end + 1);
if (!parse_obj(key, item, err))
return "";
s = s.substr(end + 1);
remove_leading(s);
if (s[0] == ',') {
s = s.substr(1);
if (s.find('{') == std::string::npos) {
err = "expected item after comma";
return "";
}
} else if (s.find('{') != std::string::npos) {
err = "unexpected list continuation";
return "";
}
}
}
return "olist";
}
/* assuming the spec is going to be properly written
not error-checking here */
void read_spec(char *fname) {
char buffer[300];
FILE *fp;
fp = fopen(fname, "r");
my_assert(fp, "can't open spec");
while(!feof(fp)){
fgets(buffer, 300, fp);
//printf("read line: %s\n", buffer);
switch (buffer[0]) {
case '#':
break;
case '0': // house
case '1': //cube
case '2': // sphere
case '3': // cone
case '4': // torus
//read in the shape
{
printf("parse object");
parse_obj(buffer);
} break;
//etc
case 'l':
parse_light(buffer);
break;
case 'c':
parse_camera(buffer);
break;
default:
break;
}
}
}
Model *load_model(char *filename) {
Model *m = create_element((void **)&resources.models, sizeof(Model));
ObjFileData data;
unsigned int i;
Vertex *verts;
unsigned int ioffset = _vbo.offset;
char *beg = strstr(filename, "models/") + 7;
char *end = strrchr(filename, '.');
m->name = malloc(end - beg + 1);
memset(m->name, 0, end-beg + 1);
strncpy(m->name, beg, end-beg);
parse_obj(filename, &data);
m->fverts = data.fverts;
m->indices = calloc(data.icount, sizeof(int));
m->icount = data.icount;
verts = calloc(data.icount, sizeof(Vertex));
memset(verts, 0, data.icount*sizeof(Vertex));
for(i = 0; i < data.icount; i++) {
int xi, ni, ti;
xi = data.indices[i][0]-1;
if(xi < 0 || xi >= data.xcount)
bad_reference_error(filename, "vertex", i);
memcpy(verts[i].x, data.xs[xi], sizeof(Vector));
if(data.tcount) {
ti = data.indices[i][1]-1;
if(ti < 0 || ti >= data.tcount)
bad_reference_error(filename, "texcoord", i);
verts[i].s = data.texcoords[ti][0];
verts[i].t = data.texcoords[ti][1];
}
if(data.ncount) {
ni = data.indices[i][2]-1;
if(ni < 0 || ni >= data.ncount)
bad_reference_error(filename, "normal", ni);
memcpy(verts[i].n, data.normals[ni], sizeof(Vector));
}
m->indices[i] = i+ioffset;
}
vbo_add_verts(&_vbo, verts, data.icount);
printf("-- loaded '%s' as '%s'\n", filename, m->name);
free(verts);
free(data.xs);
free(data.normals);
free(data.texcoords);
free(data.indices);
return m;
}
void* load_model_begin(const char *path, uint flags) {
ObjFileData *data = malloc(sizeof(ObjFileData));
GenericModelVertex *verts;
if(!parse_obj(path, data)) {
free(data);
return NULL;
}
uint *indices = calloc(data->icount, sizeof(uint));
uint icount = data->icount;
verts = calloc(data->icount, sizeof(GenericModelVertex));
#define BADREF(filename,aux,n) { \
log_error("OBJ file '%s': Index %d: bad %s index reference\n", filename, n, aux); \
goto fail; \
}
memset(verts, 0, data->icount*sizeof(GenericModelVertex));
for(uint i = 0; i < data->icount; i++) {
int xi, ni, ti;
xi = data->indices[i][0]-1;
if(xi < 0 || xi >= data->xcount)
BADREF(path, "vertex", i);
memcpy(verts[i].position, data->xs[xi], sizeof(vec3_noalign));
if(data->tcount) {
ti = data->indices[i][1]-1;
if(ti < 0 || ti >= data->tcount)
BADREF(path, "texcoord", i);
verts[i].uv.s = data->texcoords[ti][0];
verts[i].uv.t = data->texcoords[ti][1];
}
if(data->ncount) {
ni = data->indices[i][2]-1;
if(ni < 0 || ni >= data->ncount)
BADREF(path, "normal", ni);
memcpy(verts[i].normal, data->normals[ni], sizeof(vec3_noalign));
}
indices[i] = i;
}
free_obj(data);
free(data);
#undef BADREF
ModelLoadData *ldata = malloc(sizeof(ModelLoadData));
ldata->verts = verts;
ldata->indices = indices;
ldata->icount = icount;
return ldata;
fail:
free(indices);
free(verts);
free_obj(data);
free(data);
return NULL;
}
