void
ColladaGeometry::readMesh(domMesh *mesh)
{
readSources(mesh->getSource_array());
const domLines_Array &linesArray = mesh->getLines_array();
for(UInt32 i = 0; i < linesArray.getCount(); ++i)
{
readLines(mesh, linesArray[i]);
}
const domLinestrips_Array &lineStripsArray = mesh->getLinestrips_array();
for(UInt32 i = 0; i < lineStripsArray.getCount(); ++i)
{
readLineStrips(mesh, lineStripsArray[i]);
}
const domPolygons_Array &polygonsArray = mesh->getPolygons_array();
for(UInt32 i = 0; i < polygonsArray.getCount(); ++i)
{
readPolygons(mesh, polygonsArray[i]);
}
const domPolylist_Array &polyListArray = mesh->getPolylist_array();
for(UInt32 i = 0; i < polyListArray.getCount(); ++i)
{
readPolyList(mesh, polyListArray[i]);
}
const domTriangles_Array &triArray = mesh->getTriangles_array();
for(UInt32 i = 0; i < triArray.getCount(); ++i)
{
readTriangles(mesh, triArray[i]);
}
const domTrifans_Array &triFansArray = mesh->getTrifans_array();
for(UInt32 i = 0; i < triFansArray.getCount(); ++i)
{
readTriFans(mesh, triFansArray[i]);
}
const domTristrips_Array &triStripsArray = mesh->getTristrips_array();
for(UInt32 i = 0; i < triStripsArray.getCount(); ++i)
{
readTriStrips(mesh, triStripsArray[i]);
}
}
void readMesh(dae_reader_t *reader, MSXML2::IXMLDOMNodePtr geometry)
{
MSXML2::IXMLDOMNodePtr mesh = geometry->selectSingleNode("r:mesh");
if (mesh == NULL) return;
geometry_t object;
MSXML2::IXMLDOMNamedNodeMapPtr attributes = geometry->attributes;
if (attributes->length > 0)
object.name = attributes->getNamedItem("name")->text;
readVerticesNormalsTexcoords(mesh, object);
readTriangles(mesh, object);
object.maxIndex = 0;
reader->geometry.push_back(object);
}
vector<KeyFrame>
ModelLoaderMD2::loadKeyFrames(const FileName &fileName,
const FileName &skinName,
TextureFactory &textureFactory) const {
FILE *stream=0;
// fopen_s(&stream, fileName.c_str(), "rb");
stream = fopen(fileName.c_str(), "rb");
VERIFY(stream && !ferror(stream), "MD2 failed to open: "+fileName.str());
Header header = readHeader(stream);
Skin *skins = readSkins(stream, header);
TexCoord *texCoords = readTexCoords(stream, header);
Triangle *triangles = readTriangles(stream, header);
Frame *frames = readFrames(stream, header);
fclose(stream);
Material skin;
if (header.numOfSkins>0) {
skin.setTexture(textureFactory.load(FileName((const char*)skins[0].name)));
} else {
skin.setTexture(textureFactory.load(skinName));
}
vector<KeyFrame> keyFrames = buildKeyFrames(fileName,
skin,
header,
texCoords,
triangles,
frames);
delete [] skins;
delete [] texCoords;
delete [] triangles;
delete [] frames;
return keyFrames;
}
void AMD3Decoder::readMeshes()
{
DEBUG_OUT<<"AMD3Decoder::readMeshes()...\n";
if(!fd) return;
//if(errorFlag) return;
DEBUG_OUT<<"There are "<<nmeshes<<" meshes.\n";
if(!nmeshes) return;
fseek(fd,meshesOffset,SEEK_SET);
for(unsigned int i=0;i<nmeshes;i++) {
lastMesh=i;
DEBUG_OUT<<"mesh "<<i<<": \n";
// NOTE: Only read first mesh, since we lose track of the offset to the next mesh header
if(!i) {
/*if(!errorFlag)*/ readMeshHeader();
/*if(!errorFlag)*/ readVertices();
/*if(!errorFlag)*/ readTriangles();
/*if(!errorFlag)*/ readTextures();
/*if(!errorFlag)*/ readTextCoords();
}
}
}
void MeditParser::readMesh(string fname) {
ifstream fp(fname.c_str(), ios::in);
fprintf(stderr, "failbit = %d\n", fp.fail());
string line;
// while(line != "Vertices") {
// fp >> line;
// }
int count;
double x, y, z;
int i;
fp >> count;
for (int vidx = 0; vidx < count; vidx++) {
fp >> x >> y >> z >> i;
addPoint(new Point3D(x, y, z));
}
std::string shape;
fp >> shape;
bool done = false;
while (!done) {
if (shape == "End") {
done = true;
} else {
fp >> count;
if (shape == "Triangles") {
readTriangles(count, fp);
} else if (shape == "Quadrilaterals") {
}
}
fp >> shape;
}
fp.close();
calculateNormals();
}
int main (int argc, char **argv)
{
Options mergetr = readParameters (argc, argv);
char filename_mesh_node[FILENAME_MAX];
char filename_mesh_ele[FILENAME_MAX];
char filename_otoczka[FILENAME_MAX];
char filename_output_node[FILENAME_MAX];
char filename_output_ele[FILENAME_MAX];
int no_of_meshes = argc-mergetr.args_start;
strcpy (filename_otoczka, mergetr.input);
if ( strstr (filename_otoczka, ".poly") == NULL)
strcat (filename_otoczka, ".poly");
strcpy (filename_output_node, mergetr.output);
strcat (filename_output_node, ".node");
strcpy (filename_output_ele, mergetr.output);
strcat (filename_output_ele, ".ele");
fprintf(stdout, "************************************\n");
fprintf(stdout, "***** M * E * R * G * E * T * R ****\n");
fprintf(stdout, "************************************\n");
fprintf(stdout, "* Otoczka filename: %s\n", filename_otoczka);
fprintf(stdout, "* Output filenames: %s & %s\n", filename_output_node, filename_output_ele);
fprintf(stdout, "* Triangle options: %s\n", mergetr.tr_opt);
fprintf(stdout, "************************************\n");
struct triangulateio *siatka;
struct triangulateio otoczka;
struct triangulateio out;
EdgeList **v;
PointList **p;
int i;
siatka = malloc ( no_of_meshes * sizeof *siatka);
v = malloc ( no_of_meshes * sizeof **v );
p = malloc ( no_of_meshes * sizeof **p );
if (siatka == NULL || v == NULL || p == NULL) {
fprintf (stderr, "** Error! Not enough memory!");
return -1;
}
initTriangulation (&otoczka);
/* OTOCZKA */
FILE *file_otoczka = fopen( filename_otoczka, "r");
if (file_otoczka == NULL) {
fprintf(stderr, "** Error while opening %s\n", filename_otoczka);
return -100;
}
readPoints (file_otoczka, &otoczka);
readSegments (file_otoczka, &otoczka);
readHoles (file_otoczka, &otoczka);
readRegions (file_otoczka, &otoczka);
fclose (file_otoczka);
/* MESHES */
for (i = 0; i < (argc - mergetr.args_start); i++) {
strcpy (filename_mesh_node, argv[mergetr.args_start+i]);
strcat (filename_mesh_node, ".node");
strcpy (filename_mesh_ele, argv[mergetr.args_start+i]);
strcat (filename_mesh_ele, ".ele");
fprintf(stdout, "************************************\n");
fprintf(stdout, "* Mesh filenames: %s & %s\n", filename_mesh_node, filename_mesh_ele);
fprintf(stdout, "************************************\n");
FILE *file_mesh_node = fopen( filename_mesh_node, "r");
FILE *file_mesh_ele = fopen( filename_mesh_ele, "r");
if (file_mesh_node == NULL) {
fprintf(stderr, "** Error while opening %s\n", filename_mesh_node);
return -101;
}
if (file_mesh_node == NULL) {
fprintf(stderr, "** Error while opening %s\n", filename_mesh_ele);
return -102;
}
initTriangulation (&siatka[i]);
readPoints (file_mesh_node, &siatka[i]);
readTriangles (file_mesh_ele, &siatka[i]);
fclose (file_mesh_node);
fclose (file_mesh_ele);
v[i] = createEdgeList(siatka[i]);
markBndEdges (siatka[i], v[i]);
p[i] = makePointList (otoczka, siatka[i], v[i]);
updatePoints (&otoczka, siatka[i], v[i], p[i]);
updateSegments (&otoczka, siatka[i], v[i], p[i]);
updateHoles (&otoczka, siatka[i]);
}
fprintf(stdout, "************************************\n");
/* TRIANGULAtE */
initTriangulation (&out);
strcat (mergetr.tr_opt, "pYYQ");
triangulate (mergetr.tr_opt, &otoczka, &out, (struct triangulateio *) NULL);
/* GLUE HOLES */
/* markNotBndEdges (siatka1, v); */
for (i = 0; i < no_of_meshes; i++) {
glueNotBndPoints (&out, siatka[i], p[i]); /* DOKLEJANIE DO OUT */
fixPointListNumbers (&out, &siatka[i], p[i]);
glueInteriorTriangles (&out, siatka[i], p[i]);
removeHole (&out);
}
FILE *file_output_node = fopen (filename_output_node, "w");
FILE *file_output_ele = fopen (filename_output_ele, "w");
writePoints (file_output_node, out);
writeTriangles (file_output_ele, out);
fclose (file_output_node);
fclose (file_output_ele);
fprintf(stdout, "************************************\n");
free (p);
free (v);
freeTriangulation (&otoczka);
freeTriangulation (&out);
for (i = 0; i < no_of_meshes; i++)
freeTriangulation (&siatka[i]);
return 0;
}
