Esempio n. 1
0
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;

}
Esempio n. 2
0
int parse_data_module( DATAModule *module ) {
  int data_count;
  bool fatalError = TRUE; // if true, catch leads to exit(-1)
  try {
    data_count = module->datas_count;
    for ( int i = 0; i < module->datas_count; i++ ) {
      DataContext ctx; data_context = &ctx;

      const char *tagName = module->datas[i]->tag->image;
      const int tagId = find_tag( tagName );
      if ( DATA_VERBOSE > 4 ) {
	printf("tagName: %s  tagId: %d\n\r", tagName, tagId );
      }
      switch ( tagId ) {
      case TAG_Prereq: parse_prerequisite( module->datas[i] ); break;
      case TAG_BrewFormula: 
	create_brew_formula_table( module->datas_count ); 
	parse_brew_formula( module->datas[i] ); 
	break;
      case TAG_Ban: parse_ban( module->datas[i] ); break;
      case TAG_Command:
	create_command_table( module->datas_count );
	parse_command( module->datas[i] );
	break;
      case TAG_Unique: parse_unique( module->datas[i] ); break;
      case TAG_Disable: parse_disabled( module->datas[i] ); break;
      case TAG_Material: 
	create_material_table( module->datas_count );
	parse_material( module->datas[i] );
	break;
      case TAG_Liquid:
	create_liquid_table( module->datas_count );
	parse_liquid( module->datas[i] );
	break;
      case TAG_God:
	create_god_table( module->datas_count );
	parse_god( module->datas[i] );
	break;
      case TAG_Clan: parse_clan( module->datas[i] ); break;
      case TAG_Faction:
	create_faction_table( module->datas_count, module );
	parse_faction( module->datas[i] );
	break;
      case TAG_Race:
	create_races_table( module->datas_count );
	parse_race( module->datas[i] );
	break;
      case TAG_PCRace:
	create_pcraces_table( module->datas_count );
	parse_pcrace( module->datas[i] );
	break;
      case TAG_Sphere:
	create_spheres_table( module->datas_count );
	parse_sphere( module->datas[i] );
	break;
      case TAG_Group:
	create_groups_table( module->datas_count );
	parse_groups( module->datas[i] );
	break;
      case TAG_Ability: parse_abilities( module->datas[i] ); break;
      case TAG_Class: 
	create_classes_table( module->datas_count );
	parse_classes( module->datas[i] );
	break;
      case TAG_Player: 
	fatalError = FALSE;
	parse_player( module->datas[i] );
	fatalError = TRUE;
	break;
      case TAG_Area: parse_area( module->datas[i] ); break;
      case TAG_Config:
	if ( parse_config( module->datas[i] ) )  // once we have found the right config: skip others
	  return data_count;
	break;
      case TAG_AreaState: parse_area_state( module->datas[i] ); break;
      case TAG_Time: parse_time( module->datas[i] ); break;
      case TAG_Hometown:
	create_hometown_table( module->datas_count );
	parse_hometown( module->datas[i] );
	break;
      case TAG_School:
	create_school_table( module->datas_count );
	parse_school( module->datas[i] );
	break;
      case TAG_Super_Race:
	create_super_race_table( module->datas_count );
	parse_super_race( module->datas[i] );
	break;

      default: p_error("Invalid Tag: %s", tagName ); break;
      }

    }
  } catch (ScriptException e) {
    bug("Error while parsing datas. %s", e.msg );
    if ( fatalError ) {
      bug("FATAL error. Bye!");
      exit(-1);
    }
    else
      return -1;
  }

  dump_GC_info();

  return data_count;
}