// Here's the main
int main(int argc, char* argv[])
{
// Initialize GLUT
meshReader("Shape.obj", 1);
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutCreateWindow("Assignment 2 Template (orthogonal)");
glutDisplayFunc(display);
glutReshapeFunc(resize);
glutMouseFunc(mouseButton);
glutMotionFunc(mouseMotion);
glutKeyboardFunc(keyboard);
// Initialize GL
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-2.5,2.5,-2.5,2.5,-10000,10000);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glEnable(GL_DEPTH_TEST);
// Switch to main loop
glutMainLoop();
return 0;
}
AglScene* ModelBaseFactory::readScene(const string& p_name, const string* p_path)
{
string fullPath;
if (p_path!=NULL) fullPath = *p_path;
fullPath += p_name;
// test file
string fileChkMsg;
if (!isFileOk(fullPath,fileChkMsg,__FILE__,__FUNCTION__,__LINE__))
throw MeshLoadException(fileChkMsg);
// read file and extract scene
AglReader meshReader(fullPath.c_str());
AglScene* aglScene = meshReader.getScene();
return aglScene;
}
//BEGIN
TEST(CommunicateFieldData, CommunicateMultipleGhostings)
{
stk::ParallelMachine communicator = MPI_COMM_WORLD;
const std::string fileName = "generated:8x8x8";
stk::io::StkMeshIoBroker meshReader(communicator);
meshReader.add_mesh_database(fileName, stk::io::READ_MESH);
meshReader.create_input_mesh();
stk::mesh::MetaData& meta = meshReader.meta_data();
typedef stk::mesh::Field<double> ScalarField;
ScalarField& temperatureField = meta.declare_field<ScalarField>(stk::topology::NODE_RANK, "temperature");
double initialTemperatureValue = 25.0;
stk::mesh::put_field_on_entire_mesh_with_initial_value(temperatureField, &initialTemperatureValue);
meshReader.populate_bulk_data();
stk::mesh::BulkData& bulk = meshReader.bulk_data();
stk::mesh::Selector select_not_owned = !meta.locally_owned_part();
const stk::mesh::BucketVector& buckets_not_owned = bulk.get_buckets(stk::topology::NODE_RANK,select_not_owned);
for(size_t i=0; i<buckets_not_owned.size(); ++i) {
stk::mesh::Bucket& bucket = *buckets_not_owned[i];
for(size_t j=0; j<bucket.size(); ++j) {
stk::mesh::Entity node = bucket[j];
double* data = stk::mesh::field_data(temperatureField, node);
double garbage = -1.2345;
*data = garbage;
}
}
std::vector<const stk::mesh::FieldBase*> fields(1, &temperatureField);
stk::mesh::communicate_field_data(bulk, fields);
for(size_t i=0; i<buckets_not_owned.size(); ++i) {
stk::mesh::Bucket& bucket = *buckets_not_owned[i];
for(size_t j=0; j<bucket.size(); ++j) {
stk::mesh::Entity node = bucket[j];
double* data = stk::mesh::field_data(temperatureField, node);
EXPECT_EQ(initialTemperatureValue, *data);
}
}
}
TEST(UnitTestNodeBucketsHaveValidTopology, testUnit)
{
std::string generated_mesh("generated:2x3x4");
stk::ParallelMachine comm = MPI_COMM_WORLD;
stk::io::StkMeshIoBroker meshReader(comm);
meshReader.add_mesh_database(generated_mesh, stk::io::READ_MESH);
meshReader.create_input_mesh();
meshReader.populate_bulk_data();
const stk::mesh::BulkData& stkmesh = meshReader.bulk_data();
const stk::mesh::BucketVector& nodeBuckets = stkmesh.buckets(stk::topology::NODE_RANK);
for(size_t i=0; i<nodeBuckets.size(); ++i) {
const stk::mesh::Bucket& bucket = *nodeBuckets[i];
EXPECT_EQ(stk::topology::NODE, bucket.topology());
}
}
void Read3DS::getMesh(TexturedMesh& texMesh)
{
SDL_RWops *rw = SDL_RWFromFile(m_filename.c_str(), "rb");
unsigned found = m_filename.find_last_of("/\\");
string basePath = m_filename.substr(0, found+1);
TextureFactory::setBasePath(basePath);
// Parse materials
map<string, int> matMap;
C3DSMaterialReader matReader(rw);
matReader.parse();
for(size_t i = 0; i < matReader.materials().size(); i++)
{
C3DSMaterialReader::Material m = matReader.materials()[i];
// Convert name into ID
matMap[m.name] = (int)i;
// Convert to Material struct
Material* mat = new Material;
mat->m_ambient.r = m.colorAmbient[0];
mat->m_ambient.g = m.colorAmbient[1];
mat->m_ambient.b = m.colorAmbient[2];
mat->m_diffuse.r = m.colorDiffuse[0];
mat->m_diffuse.g = m.colorDiffuse[1];
mat->m_diffuse.b = m.colorDiffuse[2];
mat->m_specular.r = m.colorSpecular[0];
mat->m_specular.g = m.colorSpecular[1];
mat->m_specular.b = m.colorSpecular[2];
mat->m_shininess = m.shininess;
// Load texture from file
if(m.texMaps.size() > 0)
{
mat->m_texture = TextureFactory::instance().getTexture(m.texMaps[0].filename);
}
else
{
mat->m_texture = 0;
}
texMesh.addMaterial(mat);
}
// Reset file pointer
SDL_RWseek(rw, 0, SEEK_SET);
// Read geometry
C3DSMeshReader meshReader(rw);
meshReader.parse();
// Create a mesh with normals
C3DSMeshNormalCalculator normalMesh(meshReader);
normalMesh.calculate();
// Save geometry information and merge with material info
for(size_t i = 0; i < normalMesh.meshes().size(); i++)
{
C3DSMeshNormalCalculator::Mesh &mesh = normalMesh.meshes()[i];
m_numVertices += mesh.vertices.size();
m_numFaces += mesh.faces.size();
}
// Alloc memory for buffers
m_vertexBuffer = new float [3 * m_numVertices];
m_normalBuffer = new float [3 * m_numVertices];
m_indexBuffer = new int [3 * m_numFaces];
float* textureBuffer = new float[2 * m_numVertices];
// Fill buffers
size_t vertexCount = 0;
size_t startFace = 0;
for(size_t i = 0; i < normalMesh.meshes().size(); i++)
{
C3DSMeshNormalCalculator::Mesh &n_mesh = normalMesh.meshes()[i];
C3DSMeshReader::Mesh &mesh = meshReader.meshes()[i];
for(size_t j = 0; j < mesh.vertices.size(); j++)
{
size_t vBufferIndex = 3 * vertexCount;
size_t cBufferIndex = 2 * vertexCount;
for(int a = 0; a < 3; a++)
{
m_vertexBuffer[vBufferIndex + a] = mesh.vertices[j][a];
m_normalBuffer[vBufferIndex + a] = n_mesh.normals[j][a];
}
if(j < mesh.mapCoords.size())
{
textureBuffer[cBufferIndex] = mesh.mapCoords[j].u;
textureBuffer[cBufferIndex + 1] = mesh.mapCoords[j].v;
}
else
{
textureBuffer[cBufferIndex] = 0.0f;
textureBuffer[cBufferIndex + 1] = 0.0f;
}
vertexCount++;
}
for(size_t j = 0; j < mesh.faceMaterials.size(); j++)
{
C3DSMeshReader::FaceMaterial fm = mesh.faceMaterials[j];
MaterialFaceList* matList = new MaterialFaceList;
matList->m_matIndex = matMap[fm.name];
for(size_t a = 0; a < fm.faces.size(); a++)
{
C3DSMeshReader::Face cFace = mesh.faces[fm.faces[a]];
matList->m_faces.push_back(cFace.indices[0] + startFace);
matList->m_faces.push_back(cFace.indices[1] + startFace);
matList->m_faces.push_back(cFace.indices[2] + startFace);
}
texMesh.addMaterialFaceList(matList);
}
startFace += mesh.vertices.size();
}
// Save buffer in mesh
texMesh.setVertexBuffer(m_vertexBuffer, m_numVertices);
texMesh.setIndexBuffer(m_indexBuffer, m_numFaces);
texMesh.setNormalBuffer(m_normalBuffer);
texMesh.setTextureBuffer(textureBuffer);
}
void Read3DS::readSimpleMesh()
{
SDL_RWops *rw = SDL_RWFromFile(m_filename.c_str(), "rb");
//C3DSMaterialReader matReader(rw);
// Parse mesh
C3DSMeshReader meshReader(rw);
meshReader.parse();
// Create a mesh with normals
C3DSMeshNormalCalculator normalMesh(meshReader);
normalMesh.calculate();
// Calc vertices and faces in all mesh groups
for(size_t i = 0; i < normalMesh.meshes().size(); i++)
{
C3DSMeshNormalCalculator::Mesh &mesh = normalMesh.meshes()[i];
m_numVertices += mesh.vertices.size();
m_numFaces += mesh.faces.size();
}
// Alloc memory for buffers
m_vertexBuffer = new float [3 * m_numVertices];
m_normalBuffer = new float [3 * m_numVertices];
m_indexBuffer = new int [3 * m_numFaces];
// Fill buffers
size_t vertexCount = 0;
size_t faceCount = 0;
size_t startFace = 0;
for(size_t i = 0; i < normalMesh.meshes().size(); i++)
{
C3DSMeshNormalCalculator::Mesh &mesh = normalMesh.meshes()[i];
for(size_t j = 0; j < mesh.vertices.size(); j++)
{
size_t vBufferIndex = 3 * vertexCount;
for(int a = 0; a < 3; a++)
{
m_vertexBuffer[vBufferIndex + a] = mesh.vertices[j][a];
m_normalBuffer[vBufferIndex + a] = mesh.normals[j][a];
}
vertexCount++;
}
for(size_t j = 0; j < mesh.faces.size(); j++)
{
size_t fBufferIndex = 3 * faceCount;
for(int a = 0; a < 3; a++)
{
m_indexBuffer[fBufferIndex + a] = mesh.faces[j].indices[a] + startFace;
}
faceCount++;
}
startFace += mesh.vertices.size();
}
}
