/* 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;
}
}
}
int parse_scene(t_list **tokens)
{
if (parse_camera(tokens) == 0)
return (0);
if (parse_window(tokens) == 0)
return (0);
return (1);
}
/* 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;
}
}
}
/* 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;
}
}
}
bool load_scene( Scene* scene, const char* filename )
{
TiXmlDocument doc( filename );
const TiXmlElement* root = 0;
const TiXmlElement* elem = 0;
MaterialMap materials;
MeshMap meshes;
TriVertMap triverts;
assert( scene );
// load the document
if ( !doc.LoadFile() ) {
std::cout << "ERROR, " << doc.ErrorRow() << ":" << doc.ErrorCol() << "; "
<< "parse error: " << doc.ErrorDesc() << "\n";
return false;
}
// check for root element
root = doc.RootElement();
if ( !root ) {
std::cout << "No root element.\n";
return false;
}
// reset the scene
scene->reset();
try {
// parse the camera
elem = get_unique_child( root, true, STR_CAMERA );
parse_camera( elem, &scene->camera );
// parse background color
parse_elem( root, true, STR_BACKGROUND, &scene->background_color );
// parse refractive index
parse_elem( root, true, STR_REFRACT, &scene->refractive_index );
// parse ambient light
parse_elem( root, false, STR_AMLIGHT, &scene->ambient_light );
// parse the lights
elem = root->FirstChildElement( STR_PLIGHT );
while ( elem ) {
PointLight pl;
parse_point_light( elem, &pl );
scene->add_light( pl );
elem = elem->NextSiblingElement( STR_PLIGHT );
}
// parse the materials
elem = root->FirstChildElement( STR_MATERIAL );
while ( elem ) {
Material* mat = new Material();
check_mem( mat );
scene->add_material( mat );
const char* name = parse_material( elem, mat );
assert( name );
// place each material in map by it's name, so we can associate geometries
// with them when loading geometries
// check for repeat name
if ( !materials.insert( std::make_pair( name, mat ) ).second ) {
print_error_header( elem );
std::cout << "Material '" << name << "' multiply defined.\n";
throw std::exception();
}
elem = elem->NextSiblingElement( STR_MATERIAL );
}
// parse the meshes
elem = root->FirstChildElement( STR_MESH );
while ( elem ) {
Mesh* mesh = new Mesh();
check_mem( mesh );
scene->add_mesh( mesh );
const char* name = parse_mesh( elem, mesh );
assert( name );
// place each mesh in map by it's name, so we can associate geometries
// with them when loading geometries
if ( !meshes.insert( std::make_pair( name, mesh ) ).second ) {
print_error_header( elem );
std::cout << "Mesh '" << name << "' multiply defined.\n";
throw std::exception();
}
elem = elem->NextSiblingElement( STR_MESH );
}
// parse vertices (used by triangles)
elem = root->FirstChildElement( STR_VERTEX );
while ( elem ) {
Triangle::Vertex v;
const char* name = parse_triangle_vertex( materials, elem, &v );
assert( name );
// place each vertex in map by it's name, so we can associate triangles
// with them when loading geometries
if ( !triverts.insert( std::make_pair( name, v ) ).second ) {
print_error_header( elem );
std::cout << "Triangle vertex '" << name << "' multiply defined.\n";
throw std::exception();
}
elem = elem->NextSiblingElement( STR_VERTEX );
}
// parse the geometries
// spheres
elem = root->FirstChildElement( STR_SPHERE );
while ( elem ) {
Sphere* geom = new Sphere();
check_mem( geom );
scene->add_geometry( geom );
parse_geom_sphere( materials, elem, geom );
elem = elem->NextSiblingElement( STR_SPHERE );
}
// triangles
elem = root->FirstChildElement( STR_TRIANGLE );
while ( elem ) {
Triangle* geom = new Triangle();
check_mem( geom );
scene->add_geometry( geom );
parse_geom_triangle( materials, triverts, elem, geom );
elem = elem->NextSiblingElement( STR_TRIANGLE );
}
// models
elem = root->FirstChildElement( STR_MODEL );
while ( elem ) {
Model* geom = new Model();
check_mem( geom );
scene->add_geometry( geom );
parse_geom_model( materials, meshes, elem, geom );
elem = elem->NextSiblingElement( STR_MODEL );
}
// TODO add you own geometries here
} catch ( std::bad_alloc const& ) {
std::cout << "Out of memory error while loading scene\n.";
scene->reset();
return false;
} catch ( ... ) {
scene->reset();
return false;
}
return true;
}
