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;
}
