void MDAL::DriverFlo2D::createMesh( const std::vector<CellCenter> &cells, double half_cell_size )
{
// Create all Faces from cell centers.
// Vertexs must be also created, they are not stored in FLO-2D files
// try to reuse Vertexs already created for other Faces by usage of unique_Vertexs set.
Faces faces;
Vertices vertices;
std::map<Vertex, size_t, VertexCompare> unique_vertices; //vertex -> id
size_t vertex_idx = 0;
for ( size_t i = 0; i < cells.size(); ++i )
{
Face e( 4 );
for ( size_t position = 0; position < 4; ++position )
{
Vertex n = createVertex( position, half_cell_size, cells[i] );
const auto iter = unique_vertices.find( n );
if ( iter == unique_vertices.end() )
{
unique_vertices[n] = vertex_idx;
vertices.push_back( n );
e[position] = vertex_idx;
++vertex_idx;
}
else
{
e[position] = iter->second;
}
}
faces.push_back( e );
}
mMesh.reset(
new MemoryMesh(
name(),
vertices.size(),
faces.size(),
4, //maximum quads
computeExtent( vertices ),
mDatFileName
)
);
mMesh->faces = faces;
mMesh->vertices = vertices;
}
void generateTriangles(const unsigned xdiv,
const unsigned ydiv,
Faces& faces)
{
const unsigned xpts(xdiv + 1); // number of points in x
const unsigned NF(2 * xdiv * ydiv); // total number of faces
faces.reserve(NF);
for(unsigned y(0); y != ydiv; ++y)
for(unsigned x(0); x != xdiv; ++x) {
const unsigned a(y * xpts + x);
const unsigned b(a + 1);
const unsigned c(b + xdiv);
const unsigned d(c + 1);
faces.push_back(Trig(a, b, d));
faces.push_back(Trig(a, d, c));
}
assert(faces.size() == NF);
}
void setup(size_t& vertex_count, Ogre::Vector3* vertices, size_t& index_count, unsigned long* indices, double scale)
{
// If we add more Objects we need an Offset for the Indices
std::size_t indices_offset = m_Vertices.size();
Vector3 temp;
for (int i = 0; i < vertex_count; i++)
{
temp << vertices[i].x / (Ogre::Real)scale, vertices[i].y / (Ogre::Real)scale,
vertices[i].z / (Ogre::Real)scale;
m_Vertices.push_back(temp);
}
for (int i = 0; i < index_count; i += 3)
{
Eigen::Matrix<unsigned long, 3, 1> temp;
temp << (unsigned long)(indices[i] + indices_offset), (unsigned long)(indices[i + 1] + indices_offset),
(unsigned long)(indices[i + 2] + indices_offset);
m_Faces.push_back(temp);
// Calculate the normal to each triangle:
// m_Normals.push_back(Ogre::Math::calculateBasicFaceNormal(m_Vertices[indices[i]],m_Vertices[indices[i+1]],m_Vertices[indices[i+2]]));
}
};
int main(int argc, char** argv)
{
if(argc != 3)
return usage(argv[0]);
mark_tag vertex_index(1), vertex_x(2), vertex_y(3), vertex_z(4);
sregex tface_re = bos >> *space >> "TFACE" >> *space >> eos;
sregex vertex_re = bos >> *space >> "VRTX"
>> +space >> (vertex_index=+_d)
>> +space >> (vertex_x=+(digit|'-'|'+'|'.'))
>> +space >> (vertex_y=+(digit|'-'|'+'|'.'))
>> +space >> (vertex_z=+(digit|'-'|'+'|'.'))
>> eos;
sregex triangle_re = bos >> *space >> "TRGL"
>> +space >> (s1=+digit)
>> +space >> (s2=+digit)
>> +space >> (s3=+digit)
>> eos;
sregex end_re = bos >> *space >> "END" >> *space >> eos;
std::ifstream input(argv[1]);
std::ofstream output(argv[2]);
if(!input) {
std::cerr << "Cannot read \"" << argv[1] << "\"!\n";
return EXIT_FAILURE;
}
if(!output) {
std::cerr << "Cannot write to \"" << argv[2] << "\"!\n";
return EXIT_FAILURE;
}
std::string line;
std::getline(input, line);
smatch results;
while(input && ! regex_match(line, tface_re)) // search line "TFACE"
{
std::getline(input, line);
}
std::getline(input, line);
while(input && regex_match(line, results, vertex_re)) {
vertices.push_back(boost::make_tuple(results[vertex_x],
results[vertex_y],
results[vertex_z]));
std::getline(input, line);
}
while(input && regex_match(line, results, triangle_re)) {
std::stringstream s;
int i, j, k;
s << results[1] << " " << results[2] << " " << results[3];
s >> i >> j >> k;
faces.push_back(boost::make_tuple(i, j, k));
std::getline(input, line);
}
if(!input || !regex_match(line, end_re))
return incorrect_input("premature end of file!");
output << "OFF " << vertices.size() << " " << faces.size() << " " << "0\n";
for(Vertices::const_iterator vit = vertices.begin(), vend = vertices.end();
vit != vend; ++vit)
output << boost::get<0>(*vit) << " "
<< boost::get<1>(*vit) << " "
<< boost::get<2>(*vit) << "\n";
for(Faces::const_iterator fit = faces.begin(), fend = faces.end();
fit != fend; ++fit)
output << "3 " << boost::get<0>(*fit)
<< " " << boost::get<1>(*fit)
<< " " << boost::get<2>(*fit) << "\n";
if(output)
return EXIT_SUCCESS;
else
return EXIT_FAILURE;
};
// greebo: TODO: Make this a member method of the Brush class
bool Brush_merge(Brush& brush, const BrushPtrVector& in, bool onlyshape) {
// gather potential outer faces
typedef std::vector<const Face*> Faces;
Faces faces;
for (BrushPtrVector::const_iterator i(in.begin()); i != in.end(); ++i) {
(*i)->getBrush().evaluateBRep();
for (Brush::const_iterator j((*i)->getBrush().begin()); j != (*i)->getBrush().end(); ++j) {
if (!(*j)->contributes()) {
continue;
}
const Face& face1 = *(*j);
bool skip = false;
// test faces of all input brushes
//!\todo SPEEDUP: Flag already-skip faces and only test brushes from i+1 upwards.
for (BrushPtrVector::const_iterator k(in.begin()); !skip && k != in.end(); ++k) {
if (k != i) { // don't test a brush against itself
for (Brush::const_iterator l((*k)->getBrush().begin()); !skip && l != (*k)->getBrush().end(); ++l) {
const Face& face2 = *(*l);
// face opposes another face
if (face1.plane3() == -face2.plane3()) {
// skip opposing planes
skip = true;
break;
}
}
}
}
// check faces already stored
for (Faces::const_iterator m = faces.begin(); !skip && m != faces.end(); ++m) {
const Face& face2 = *(*m);
// face equals another face
if (face1.plane3() == face2.plane3()) {
// if the texture/shader references should be the same but are not
if (!onlyshape && !shader_equal(
face1.getFaceShader().getMaterialName(),
face2.getFaceShader().getMaterialName()
))
{
return false;
}
// skip duplicate planes
skip = true;
break;
}
// face1 plane intersects face2 winding or vice versa
if (Winding::planesConcave(face1.getWinding(), face2.getWinding(), face1.plane3(), face2.plane3())) {
// result would not be convex
return false;
}
}
if (!skip) {
faces.push_back(&face1);
}
}
}
for (Faces::const_iterator i = faces.begin(); i != faces.end(); ++i) {
if (!brush.addFace(*(*i))) {
// result would have too many sides
return false;
}
}
brush.removeEmptyFaces();
return true;
}