Model* loadOBJ(const char* filename){ printf("Loading %s.obj...\n", filename); string fn = "../../Models/"; fn += filename; fn += ".obj"; //char * dir = getcwd(NULL, 0); // Platform-dependent, see reference link below //printf("Current dir: %s", dir); ifstream file; file.open(fn.c_str()); //file.open("test.rtf"); if(file.fail()){ printf("Failed to load %s.obj!\n", filename); return NULL; } Model* m = new Model(); while(true){ skipHeader(&file); if(file.eof()) break; readShape(&file, m); } file.close(); return m; }
int VRML_MODEL_PARSER::readChildren( FILE* file, int* LineNum ) { char line[1024], * text; while( GetLine( file, line, LineNum, 512 ) ) { text = strtok( line, sep_chars ); if( *text == ']' ) return 0; if( *text == ',' ) continue; if( stricmp( text, "Shape" ) == 0 ) { readShape( file, LineNum ); } else { DBG( printf( "ReadChildren error line %d <%s> \n", *LineNum, text ) ); break; } } return 1; }
void Reader::readModel(){ model = new Model(); while(true){ readHeader(); if(file.eof()) break; readShape(); } }
Circle *JsonFileReader::readCircle(const QJsonObject &c) { Circle *circle = new Circle(); readShape(circle, c); circle->setRadius(c["Radius"].toInt()); return circle; }
CSGShapeNodePointer SceneLoader::readCSGShapeNode(const QDomElement &element) const { ShapePointer shape = readShape(element); if (shape != NULL) { return CSGShapeNodePointer(new CSGShapeNode(shape)); } std::cerr << "Scene parsing error: failed shape parameters reading" << std::endl; return CSGShapeNodePointer(NULL); }
Rectangle *JsonFileReader::readRectangle(const QJsonObject &r) { Rectangle *rect = new Rectangle(); readShape(rect, r); rect->setWidth(r["Width"].toInt()); rect->setHeight(r["Height"].toInt()); return rect; }
void readGeometry(CborValue *it0, Geometry *geometry) { CborValue it1; CborValue *it = &it1; cbor_value_enter_container(it0, it); int i; cbor_value_get_int(it, &i); cbor_value_advance_fixed(it); geometry->selector = (EnumGeometry)i; if (geometry->selector == 0) { readShape(it, &(geometry->data.ShapeGeometry.value0)); }; if (geometry->selector == 1) { { size_t l; cbor_value_calculate_string_length(it, &l); geometry->data.ResourceGeometry.value0.resize(l+1); cbor_value_copy_text_string(it, (char *)(geometry->data.ResourceGeometry.value0.c_str()), &l, NULL); cbor_value_advance(it);} }; cbor_value_leave_container(it0, it); }
//------------------------------------------------------------------------------ static int checkMesh( shaperec const & r, int levels ) { int count=0; float deltaAvg[3] = {0.0f, 0.0f, 0.0f}, deltaCnt[3] = {0.0f, 0.0f, 0.0f}; xyzmesh * mesh = simpleHbr<xyzVV>(r.data.c_str(), r.scheme, 0); int firstface=0, lastface=mesh->GetNumFaces(), firstvert=0, lastvert=mesh->GetNumVertices(), nverts; static char const * schemes[] = { "Bilinear", "Catmark", "Loop" }; printf("- %-25s ( %-8s ): ", r.name.c_str(), schemes[r.scheme]); for (int l=0; l<levels; ++l ) { int errcount=0; std::stringstream fname; fname << g_baseline_path << r.name << "_level" << l << ".obj"; Shape * sh = readShape( fname.str().c_str(), r.scheme ); assert(sh); // subdivide up to current level for (int i=firstface; i<lastface; ++i) { xyzface * f = mesh->GetFace(i); f->Refine(); } firstface = lastface; lastface = mesh->GetNumFaces(); //nfaces = lastface - firstface; firstvert = lastvert; lastvert = mesh->GetNumVertices(); nverts = lastvert - firstvert; for (int i=firstvert; i<lastvert; ++i) { const float * apos = mesh->GetVertex(i)->GetData().GetPos(), * bpos = &sh->verts[(i-firstvert)*3]; if ( apos[0] != bpos[0] ) deltaCnt[0]++; if ( apos[1] != bpos[1] ) deltaCnt[1]++; if ( apos[2] != bpos[2] ) deltaCnt[2]++; float delta[3] = { apos[0] - bpos[0], apos[1] - bpos[1], apos[2] - bpos[2] }; deltaAvg[0]+=delta[0]; deltaAvg[1]+=delta[1]; deltaAvg[2]+=delta[2]; float dist = sqrtf( delta[0]*delta[0]+delta[1]*delta[1]+delta[2]*delta[2]); if ( dist > STRICT_PRECISION ) { if(dist < WEAK_PRECISION and g_allowWeakRegression) { g_strictRegressionFailure=true; } else { if (g_verbose) { printf("\n// HbrVertex<T> %d fails : dist=%.10f " "(%.10f %.10f %.10f) (%.10f %.10f %.10f)", i, dist, apos[0], apos[1], apos[2], bpos[0], bpos[1], bpos[2] ); } ++errcount; } } } if (errcount) { std::stringstream errfile; errfile << r.name << "_level" << l << "_error.obj"; writeObj(errfile.str().c_str(), mesh, firstface, lastface, firstvert, lastvert); printf("\n wrote: %s\n", errfile.str().c_str()); } delete sh; count += errcount; } if (deltaCnt[0]) deltaAvg[0]/=deltaCnt[0]; if (deltaCnt[1]) deltaAvg[1]/=deltaCnt[1]; if (deltaCnt[2]) deltaAvg[2]/=deltaCnt[2]; if (g_verbose) { printf("\n delta ratio : (%d/%d %d/%d %d/%d)", (int)deltaCnt[0], nverts, (int)deltaCnt[1], nverts, (int)deltaCnt[2], nverts ); printf("\n average delta : (%.10f %.10f %.10f)", deltaAvg[0], deltaAvg[1], deltaAvg[2] ); } if (count==0) { printf(" success !\n"); } else printf(" failed !\n"); delete mesh; return count; }
//-------------------------------------------------------------------- // read a brick set for the world void ChunkWorld::readBrickSet( BrickSetFile& brickSetFile) { m_brickSet = new BrickSet(); // assign index to each texture used m_nextTextureId = 0; m_textureIds.removeAll(); // add an entry for air BrickDefn* desc = new BrickDefn(); desc->m_trans[BRICK_FACE_XMIN] = true; desc->m_trans[BRICK_FACE_XMAX] = true; desc->m_trans[BRICK_FACE_YMIN] = true; desc->m_trans[BRICK_FACE_YMAX] = true; desc->m_trans[BRICK_FACE_ZMIN] = true; desc->m_trans[BRICK_FACE_ZMAX] = true; m_brickSet->m_defns[0] = desc; m_brickSet->m_defns[0]->m_subDefns[0] = new BrickSubDefn(); // for each brick type for (int i = 0; i < brickSetFile.m_brickTags.length(); i++) { BrickTag* brick = (BrickTag*) brickSetFile.m_brickTags[i]; // get existing defn, if any, for this major code desc = m_brickSet->m_defns[brick->m_majorCode]; if (desc == NULL) { desc = new BrickDefn(); m_brickSet->m_defns[brick->m_majorCode] = desc; } // get entry for minor code if (brick->m_minorCode < 0 || brick->m_minorCode >= SUBDEFN_COUNT) throw new mgException("Invalid brick defn minor code %02x%02x", brick->m_majorCode, brick->m_minorCode); // don't allow duplicates BrickSubDefn* subDefn = desc->m_subDefns[brick->m_minorCode]; if (subDefn != NULL) throw new mgException("Duplicate brick defn code %02x%02x", brick->m_majorCode, brick->m_minorCode); // create new subdefinition subDefn = new BrickSubDefn(); desc->m_subDefns[brick->m_minorCode] = subDefn; int shape; if (brick->m_shape.equalsIgnoreCase("slab")) shape = SHAPE_SLAB; else if (brick->m_shape.equalsIgnoreCase("column")) shape = SHAPE_COLUMN; else if (brick->m_shape.equalsIgnoreCase("cap")) shape = SHAPE_CAP; else if (brick->m_shape.equalsIgnoreCase("stair")) shape = SHAPE_STAIR; else if (brick->m_shape.equalsIgnoreCase("cube")) shape = SHAPE_CUBE; else shape = SHAPE_DEFN; // minor code 0 sets shape and transparency of brick if (brick->m_minorCode == 0) { desc->m_shape = shape; switch (desc->m_shape) { case SHAPE_CUBE: desc->m_trans[BRICK_FACE_XMIN] = brick->m_transparent; desc->m_trans[BRICK_FACE_XMAX] = brick->m_transparent; desc->m_trans[BRICK_FACE_YMIN] = brick->m_transparent; desc->m_trans[BRICK_FACE_YMAX] = brick->m_transparent; desc->m_trans[BRICK_FACE_ZMIN] = brick->m_transparent; desc->m_trans[BRICK_FACE_ZMAX] = brick->m_transparent; break; case SHAPE_SLAB: desc->m_trans[BRICK_FACE_XMIN] = true; desc->m_trans[BRICK_FACE_XMAX] = true; desc->m_trans[BRICK_FACE_YMIN] = brick->m_transparent; desc->m_trans[BRICK_FACE_YMAX] = brick->m_transparent; desc->m_trans[BRICK_FACE_ZMIN] = true; desc->m_trans[BRICK_FACE_ZMAX] = true; break; case SHAPE_CAP: desc->m_trans[BRICK_FACE_XMIN] = true; desc->m_trans[BRICK_FACE_XMAX] = true; desc->m_trans[BRICK_FACE_YMIN] = brick->m_transparent; desc->m_trans[BRICK_FACE_YMAX] = brick->m_transparent; desc->m_trans[BRICK_FACE_ZMIN] = true; desc->m_trans[BRICK_FACE_ZMAX] = true; break; case SHAPE_STAIR: desc->m_trans[BRICK_FACE_XMIN] = true; desc->m_trans[BRICK_FACE_XMAX] = true; desc->m_trans[BRICK_FACE_YMIN] = brick->m_transparent; desc->m_trans[BRICK_FACE_YMAX] = true; desc->m_trans[BRICK_FACE_ZMIN] = true; desc->m_trans[BRICK_FACE_ZMAX] = true; break; case SHAPE_COLUMN: desc->m_trans[BRICK_FACE_XMIN] = true; desc->m_trans[BRICK_FACE_XMAX] = true; desc->m_trans[BRICK_FACE_YMIN] = true; desc->m_trans[BRICK_FACE_YMAX] = true; desc->m_trans[BRICK_FACE_ZMIN] = true; desc->m_trans[BRICK_FACE_ZMAX] = true; break; case SHAPE_DEFN: desc->m_trans[BRICK_FACE_XMIN] = true; desc->m_trans[BRICK_FACE_XMAX] = true; desc->m_trans[BRICK_FACE_YMIN] = true; desc->m_trans[BRICK_FACE_YMAX] = true; desc->m_trans[BRICK_FACE_ZMIN] = true; desc->m_trans[BRICK_FACE_ZMAX] = true; break; } // set summary flags desc->m_hasTransparent = false; desc->m_hasOpaque = false; for (int j = 0; j < 6; j++) { if (desc->m_trans[j]) desc->m_hasTransparent = true; else desc->m_hasOpaque = true; } } // find all the textures specified if (!brick->m_xminTexture.isEmpty()) subDefn->m_xmin = findTexture(brick->m_xminTexture); if (!brick->m_xmaxTexture.isEmpty()) subDefn->m_xmax = findTexture(brick->m_xmaxTexture); if (!brick->m_yminTexture.isEmpty()) subDefn->m_ymin = findTexture(brick->m_yminTexture); if (!brick->m_ymaxTexture.isEmpty()) subDefn->m_ymax = findTexture(brick->m_ymaxTexture); if (!brick->m_zminTexture.isEmpty()) subDefn->m_zmin = findTexture(brick->m_zminTexture); if (!brick->m_zmaxTexture.isEmpty()) subDefn->m_zmax = findTexture(brick->m_zmaxTexture); if (brick->m_dir < 0 || brick->m_dir >= DIRECTION_COUNT) throw new mgException("Invalid direction on brick defn code %02x%02x", brick->m_majorCode, brick->m_minorCode); if (shape == SHAPE_DEFN) subDefn->m_shapeDefn = readShape(brick->m_shape); subDefn->m_dir = brick->m_dir; subDefn->m_light = brick->m_light; if (brick->m_light) mgDebug("light on brick code %02x%02x", brick->m_majorCode, brick->m_minorCode); } // combine minor and major definitions, check for missing info checkBrickSet(); }
/* * private: */ ScenePointer SceneLoader::readScene(const QDomNode &rootNode) const { if (rootNode.toElement().tagName() != "scene") { std::cerr << "Scene parsing error: invalid root tag name, 'scene' expected" << std::endl; return ScenePointer(NULL); } ScenePointer scene = ScenePointer(new Scene()); bool isCameraIntialized = false; bool isBackgroundMaterialInitialized = false; QDomElement element = rootNode.firstChildElement(); while (!element.isNull()) { QString elementTagName = element.tagName(); if (elementTagName == "camera") { if (isCameraIntialized) { std::cerr << "Scene parsing error: 'camera' tag occurred twice, only one camera is allowed" << std::endl; return ScenePointer(NULL); } CameraPointer camera = readCamera(element); if (camera == NULL) { std::cerr << "Scene parsing error: failed camera parameters reading" << std::endl; return ScenePointer(NULL); } scene->setCamera(camera); isCameraIntialized = true; } else if (elementTagName == "light") { LightSourcePointer lightSource = readLightSource(element); if (lightSource == NULL) { std::cerr << "Scene parsing error: failed light source parameters reading" << std::endl; return ScenePointer(NULL); } scene->addLightSource(lightSource); } else if (elementTagName == "object") { ShapePointer shape = readShape(element); if (shape == NULL) { std::cerr << "Scene parsing error: failed shape parameters reading" << std::endl; return ScenePointer(NULL); } scene->addShape(shape); } else if (elementTagName == "csg") { CSGTreePointer csgTree = readCSGTree(element); if (csgTree == NULL) { std::cerr << "Scene parsing error: failed CSG tree parameters reading" << std::endl; return ScenePointer(NULL); } scene->addShape(csgTree); } else if (elementTagName == "background") { if (isBackgroundMaterialInitialized) { std::cerr << "Scene parsing error: 'background' tag occurred twice" << std::endl; return ScenePointer(NULL); } MaterialPointer material = readMaterial(element); if (material == NULL) { std::cerr << "Scene parsing error: failed background material parameters reading" << std::endl; return ScenePointer(NULL); } scene->setBackgroundMaterial(material); isBackgroundMaterialInitialized = true; } else { std::cerr << "Scene parsing error: unknown tag '" << elementTagName.toUtf8().constData() << "'" << std::endl; return ScenePointer(NULL); } element = element.nextSiblingElement(); } if (!isCameraIntialized) { std::cerr << "Scene parsing error: camera parameters are not specified" << std::endl; return ScenePointer(NULL); } if (!isBackgroundMaterialInitialized) { std::cerr << "Scene parsing error: background material parameters are not specified" << std::endl; return ScenePointer(NULL); } return scene; }