Esempio n. 1
0
// ***************************************************************************
void	CTransformShape::traverseLoadBalancingPass0()
{
	CLoadBalancingTrav		&loadTrav= getOwnerScene()->getLoadBalancingTrav();
	CSkeletonModel			*skeleton= getSkeletonModel();

	// World Model position
	const CVector		*modelPos;

	// If this isntance is binded or skinned to a skeleton, take the world matrix of this one as
	// center for LoadBalancing Resolution.
	if(skeleton)
	{
		// Take the root bone of the skeleton as reference (bone 0)
		// And so get our position.
		modelPos= &skeleton->Bones[0].getWorldMatrix().getPos();
	}
	else
	{
		// get our position from
		modelPos= &getWorldMatrix().getPos();
	}


	// Then compute distance from camera.
	float	modelDist= ( loadTrav.CamPos - *modelPos).norm();


	// Get the number of triangles this model use now.
	_FaceCount= getNumTriangles(modelDist);
	_LoadBalancingGroup->addNbFacesPass0(_FaceCount);
}
Esempio n. 2
0
void Writer::writeTrianglesRaw(size_type first, size_type count, const std::tr1::uint8_t *data)
{
    MLSGPU_ASSERT(isOpen(), state_error);
    MLSGPU_ASSERT(first + count <= getNumTriangles() && first <= std::numeric_limits<size_type>::max() - count, std::out_of_range);
    Statistics::Timer timer(writeTrianglesTime);
    handle->write(data, count * triangleSize, triangleStart + first * triangleSize);
}
Esempio n. 3
0
void TriMesh::recalculateNormals()
{
	mNormals.assign( mVertices.size(), Vec3f::zero() );

	size_t n = getNumTriangles();
	for( size_t i = 0; i < n; ++i ) {
		uint32_t index0 = mIndices[i * 3];
		uint32_t index1 = mIndices[i * 3 + 1];
		uint32_t index2 = mIndices[i * 3 + 2];

		Vec3f v0 = mVertices[ index0 ];
		Vec3f v1 = mVertices[ index1 ];
		Vec3f v2 = mVertices[ index2 ];

		Vec3f e0 = v1 - v0;
		Vec3f e1 = v2 - v0;
		Vec3f normal = e0.cross(e1).normalized();

		mNormals[ index0 ] += normal;
		mNormals[ index1 ] += normal;
		mNormals[ index2 ] += normal;
	}

	std::for_each( mNormals.begin(), mNormals.end(), std::mem_fun_ref(&Vec3f::normalize) );
}
//==============================================================================
void cTriangleArray::compress()
{
    // get number of allocated triangles
    unsigned int numTriangles = getNumTriangles();

    // remove non allocated triangles
    unsigned j=-1;
    for (int i=0; i<numTriangles; i++)
    {
        if (getAllocated(i))
        {
            j++;

            if (i!=j)
            {
                unsigned int index0 = getVertexIndex0(i);
                unsigned int index1 = getVertexIndex1(i);
                unsigned int index2 = getVertexIndex2(i);
                m_allocated[j] = true;
                setVertices(j, index0, index1, index2);
            }
        }
    }

    // resize arrays
    unsigned size = j+1;
    m_allocated.resize(size);
    m_indices.resize(3*size);
}
Esempio n. 5
0
bool PViewData::writeSTL(const std::string &fileName)
{
  FILE *fp = Fopen(fileName.c_str(), "w");
  if(!fp){
    Msg::Error("Unable to open file '%s'", fileName.c_str());
    return false;
  }

  if(!getNumTriangles() && !getNumQuadrangles()){
    Msg::Error("No surface elements to save");
    fclose(fp);
    return false;
  }

  int step = getFirstNonEmptyTimeStep();

  fprintf(fp, "solid Created by Gmsh\n");
  for(int ent = 0; ent < getNumEntities(step); ent++){
    for(int ele = 0; ele < getNumElements(step, ent); ele++){
      if(getDimension(step, ent, ele) != 2) continue;
      if(skipElement(step, ent, ele)) continue;
      int N = getNumNodes(step, ent, ele);
      if(N != 3 && N != 4) continue;
      double x[4], y[4], z[4], n[3];
      for(int i = 0; i < N; i++)
        getNode(step, ent, ele, i, x[i], y[i], z[i]);
      normal3points(x[0], y[0], z[0], x[1], y[1], z[1], x[2], y[2], z[2], n);
      if(N == 3){
        fprintf(fp, "facet normal %g %g %g\n", n[0], n[1], n[2]);
        fprintf(fp, "  outer loop\n");
        fprintf(fp, "    vertex %g %g %g\n", x[0], y[0], z[0]);
        fprintf(fp, "    vertex %g %g %g\n", x[1], y[1], z[1]);
        fprintf(fp, "    vertex %g %g %g\n", x[2], y[2], z[2]);
        fprintf(fp, "  endloop\n");
        fprintf(fp, "endfacet\n");
      }
      else{
        fprintf(fp, "facet normal %g %g %g\n", n[0], n[1], n[2]);
        fprintf(fp, "  outer loop\n");
        fprintf(fp, "    vertex %g %g %g\n", x[0], y[0], z[0]);
        fprintf(fp, "    vertex %g %g %g\n", x[1], y[1], z[1]);
        fprintf(fp, "    vertex %g %g %g\n", x[2], y[2], z[2]);
        fprintf(fp, "  endloop\n");
        fprintf(fp, "endfacet\n");
        fprintf(fp, "facet normal %g %g %g\n", n[0], n[1], n[2]);
        fprintf(fp, "  outer loop\n");
        fprintf(fp, "    vertex %g %g %g\n", x[0], y[0], z[0]);
        fprintf(fp, "    vertex %g %g %g\n", x[2], y[2], z[2]);
        fprintf(fp, "    vertex %g %g %g\n", x[3], y[3], z[3]);
        fprintf(fp, "  endloop\n");
        fprintf(fp, "endfacet\n");
      }
    }
  }
  fprintf(fp, "endsolid Created by Gmsh\n");

  fclose(fp);
  return true;
}
Esempio n. 6
0
void Writer::writeTrianglesRaw(
    Timeplot::Worker &tworker,
    size_type first, size_type count,
    const boost::shared_ptr<AsyncWriterItem> &data,
    AsyncWriter &async)
{
    MLSGPU_ASSERT(isOpen(), state_error);
    MLSGPU_ASSERT(first + count <= getNumTriangles() && first <= std::numeric_limits<size_type>::max() - count, std::out_of_range);
    async.push(tworker, data, handle, count * triangleSize, triangleStart + first * triangleSize);
}
Esempio n. 7
0
void Writer::open(const std::string &filename)
{
    MLSGPU_ASSERT(!isOpen(), state_error);
    handle = handleFactory();
    handle->open(filename);

    std::string header = makeHeader();
    handle->resize(header.size() + getNumVertices() * vertexSize + getNumTriangles() * triangleSize);
    handle->write(header.data(), header.size(), 0);
    vertexStart = header.size();
    triangleStart = vertexStart + getNumVertices() * vertexSize;
}
Esempio n. 8
0
char BaseMesh::selectComponent(IntersectionContext * ctx) const
{   
	Vector3F threeCorners[3];
	unsigned fvi[3];
	const unsigned nf = getNumTriangles();
	for(unsigned i = 0; i < nf; i++) {
		getTriangle(i, fvi);
		threeCorners[0] = _vertices[fvi[0]];
		threeCorners[1] = _vertices[fvi[1]];
		threeCorners[2] = _vertices[fvi[2]];
		if(triangleIntersect(threeCorners, ctx)) {
			ctx->m_componentIdx = BaseMesh::closestVertex(i, ctx->m_hitP);;
			return 1;
		}
	}
	return 0;
}
Esempio n. 9
0
void Writer::writeTriangles(size_type first, size_type count, const std::tr1::uint32_t *data)
{
    MLSGPU_ASSERT(isOpen(), state_error);
    MLSGPU_ASSERT(first + count <= getNumTriangles() && first <= std::numeric_limits<size_type>::max() - count, std::out_of_range);

    Statistics::Timer timer(writeTrianglesTime);
    BinaryWriter::offset_type pos = triangleStart + first * triangleSize;
    while (count > 0)
    {
        const unsigned int bufferTriangles = 8192;
        char buffer[bufferTriangles * triangleSize];
        char *ptr = buffer;
        unsigned int triangles = std::min(size_type(bufferTriangles), count);
        for (unsigned int i = 0; i < triangles; i++, ptr += triangleSize, data += 3)
        {
            ptr[0] = 3;
            std::memcpy(ptr + 1, data, 3 * sizeof(data[0]));
        }
        pos += handle->write(buffer, ptr - buffer, pos);
        count -= triangles;
    }
}
Esempio n. 10
0
void BaseMesh::verbose() const
{
	std::cout<<"mesh status:\n";
	std::cout<<" num vertices "<<getNumVertices()<<"\n";
	std::cout<<" num polygons "<<getNumPolygons()<<"\n";
	
	std::map<unsigned, unsigned> faceCountList;
	for(unsigned i = 0; i < getNumPolygons(); i++) {
		if(faceCountList.find(m_polygonCounts[i]) == faceCountList.end()) faceCountList[m_polygonCounts[i]] = 1;
		else faceCountList[m_polygonCounts[i]] += 1;
	}
	
	std::map<unsigned, unsigned>::const_iterator it = faceCountList.begin();
	for(; it != faceCountList.end(); ++it) {
		std::clog<<"  "<<(*it).second<<" "<<(*it).first<<"-sided faces\n";
	}
	
	std::cout<<" num polygon face vertices "<<getNumPolygonFaceVertices()<<"\n";
	std::cout<<" num triangles "<<getNumTriangles()<<"\n";
	std::cout<<" num quads "<<numQuads()<<"\n";
	std::cout<<" num uvs "<<getNumUVs()<<"\n";
	std::cout<<" num uvs indices "<<getNumUVIds()<<"\n";
}
//==============================================================================
cTriangleArrayPtr cTriangleArray::copy()
{
    // create new array of triangles
    cTriangleArrayPtr triangleArray = cTriangleArray::create(m_vertices);

    // get number of allocated triangles
    unsigned int numTriangles = getNumTriangles();

    // copy every allocated triangle
    for (unsigned int i=0; i<numTriangles; i++)
    {
        if (getAllocated(i))
        {
            unsigned int index0 = getVertexIndex0(i);
            unsigned int index1 = getVertexIndex1(i);
            unsigned int index2 = getVertexIndex2(i);

            triangleArray->newTriangle(index0, index1, index2);
        }
    }

    // return new triangle array
    return (triangleArray);
}
Esempio n. 12
0
void Geometry::write(IResource* resource)
{
    ChunkHeader geometryHeader( BA_GEOMETRY, sizeof( Chunk ) );
    geometryHeader.write( resource );

    Chunk chunk;
    chunk.id = (auid)( this );
    memset( chunk.name, 0, engine::maxNameLength );
    if( _name.length() > engine::maxNameLength )
    {
        strncpy( chunk.name, _name.c_str(), engine::maxNameLength - 1 );
    }
    else
    {
        strcpy( chunk.name, _name.c_str() );
    }
    chunk.numShaders    = getNumShaders();
    chunk.numVertices   = getNumVertices();
    chunk.numUVSets     = getNumUVSets();
    chunk.numPrelights  = getNumPrelights();
    chunk.numTriangles  = getNumTriangles();
    chunk.sharedShaders = _sharedShaders;
    if( _ocTreeRoot )
    {
        chunk.numOcTreeSectors = _ocTreeRoot->getOcTreeSize();
    }
    else
    {
        chunk.numOcTreeSectors = 0;
    }
    chunk.hasEffect = ( _effect != NULL );

    fwrite( &chunk, sizeof( Chunk ), 1, resource->getFile() );

    // write shaders
    if( !_sharedShaders ) for( int i=0; i<getNumShaders(); i++ )
    {
        _shaders[i]->write( resource );
    }

    // write vertices
    ChunkHeader verticesHeader( BA_BINARY, sizeof(Vector) * getNumVertices() );
    verticesHeader.write( resource );
    fwrite( getVertices(), verticesHeader.size, 1, resource->getFile() );

    // write normals
    ChunkHeader normalsHeader( BA_BINARY, sizeof(Vector) * getNumVertices() );
    normalsHeader.write( resource );
    fwrite( getNormals(), normalsHeader.size, 1, resource->getFile() );

    // write UV-sets
	int i;
    for( i=0; i<getNumUVSets(); i++ )
    {
        ChunkHeader uvsHeader( BA_BINARY, sizeof(Flector) * getNumVertices() );
        uvsHeader.write( resource );
        fwrite( getUVSet(i), uvsHeader.size, 1, resource->getFile() );
    }

    // write prelights
    for( i=0; i< getNumPrelights(); i++ )
    {
        ChunkHeader prelightsHeader( BA_BINARY, sizeof(Color) * getNumVertices() );
        prelightsHeader.write( resource );
        fwrite( getPrelights(i), prelightsHeader.size, 1, resource->getFile() );
    }

    // write triangles
    ChunkHeader trianglesHeader( BA_BINARY, sizeof(Triangle) * getNumTriangles() );
    trianglesHeader.write( resource );
    fwrite( getTriangles(), trianglesHeader.size, 1, resource->getFile() );

    // write shaders
    if( !_sharedShaders )
    {
        ChunkHeader shadersHeader( BA_BINARY, sizeof(auid) * getNumShaders() );
        shadersHeader.write( resource );
        fwrite( _shaders, shadersHeader.size, 1, resource->getFile() );
    }

    // write octree
    if( _ocTreeRoot )
    {
        _ocTreeRoot->write( resource );
    }

    // write effect
    if( chunk.hasEffect )
    {
        reinterpret_cast<Effect*>( _effect )->write( resource );
    }
}
Esempio n. 13
0
unsigned BaseMesh::getNumFaces() const
{
	return getNumTriangles();
}
Esempio n. 14
0
// @todo remove ... or just remove this complete class 
void VertexData::debugDraw(int drawMode) {
#if ROXLU_GL_MODE != ROXLU_GL_STRICT
	glPushAttrib(GL_ALL_ATTRIB_BITS);
	glDisable(GL_TEXTURE_2D);
	glUseProgram(0);
	glEnable(GL_DEPTH_TEST);
	// we adjust the size of the normals lines dynamically
	float line_length = 0.2;
	if(vertices.size() > 2) {
		float length = (vertices[1] - vertices[2]).length();
		if(length >= 3) {
			line_length = 3.2;
		}
	}


	float colors[4][3] = {
			{0.88,0.25,0.11}
			,{0.6,0.78,0.212}
			,{0.2,0.65,0.698}
			,{0.94,0.72,0.29}
	};
	 
	// draw using indices
	if(getNumTriangles() > 0) {
		// triangles (fills)
		Triangle tri;
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
		glColor3f(0.8,0.8,0.8);
		glBegin(GL_TRIANGLES);
			for(int i = 0; i < triangles.size(); ++i) {	
				tri = triangles[i];
				glVertex3fv(vertices[tri.va].getPtr());
				glVertex3fv(vertices[tri.vb].getPtr());
				glVertex3fv(vertices[tri.vc].getPtr());
			}
		glEnd();
		
		// triangles lines.
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
		glColor3f(0.1,0.1,0.1);
		glBegin(GL_TRIANGLES);
			for(int i = 0; i < triangles.size(); ++i) {	
				tri = triangles[i];
				glVertex3fv(vertices[tri.va].getPtr());
				glVertex3fv(vertices[tri.vb].getPtr());
				glVertex3fv(vertices[tri.vc].getPtr());
			}
		glEnd();
		
		// normals, tangents and binormals
		bool draw_normals= true;
		bool draw_tangents = true;
		bool draw_binormals = true;
		float s = 0.2;
		glBegin(GL_LINES);
			for(int i = 0; i < triangles.size(); ++i) {	
				tri = triangles[i];
				
				// normal - a
				if(draw_normals && tri.na) {
					glColor3f(0,1,1);
					glVertex3fv(vertices[tri.va].getPtr());
					glVertex3fv((vertices[tri.va]+normals[tri.na]*s).getPtr());	
				}

				// tangent - a
				if(draw_tangents && tri.ta) {
					glColor3f(1,0,0);
					glVertex3fv(vertices[tri.va].getPtr());
					glVertex3fv((vertices[tri.va]+(tangents[tri.ta]*s)).getPtr());	
				}

				// binormal - a 
				if(draw_binormals && tri.ba) {
					glColor3f(0,1,0);
					glVertex3fv(vertices[tri.va].getPtr());
					glVertex3fv((vertices[tri.va]+(binormals[tri.ba]*s)).getPtr());	
				}
				
				// normal - b
				if(draw_normals && tri.nb) {
					glColor3f(0,1,1);
					glVertex3fv(vertices[tri.vb].getPtr());
					glVertex3fv((vertices[tri.vb]+normals[tri.nb]*s).getPtr());	
				}
				
				// tangent - b
				if(draw_tangents && tri.tb) {
					glColor3f(1,0,0);
					glVertex3fv(vertices[tri.vb].getPtr());
					glVertex3fv((vertices[tri.vb]+(tangents[tri.tb]*s)).getPtr());	
				}
				
				// binormal - b
				if(draw_binormals && tri.bb) {
					glColor3f(0,1,0);
					glVertex3fv(vertices[tri.vb].getPtr());
					glVertex3fv((vertices[tri.vb]+(binormals[tri.bb]*s)).getPtr());	
				}
				
				// normal - c
				if(draw_normals && tri.nc) {
					glColor3f(0,1,1);
					glVertex3fv(vertices[tri.vc].getPtr());
					glVertex3fv((vertices[tri.vc]+normals[tri.nc]*s).getPtr());	
				}
				
				// tangent - c
				if(draw_tangents && tri.tc) {
					glColor3f(1,0,0);
					glVertex3fv(vertices[tri.vc].getPtr());
					glVertex3fv((vertices[tri.vc]+(tangents[tri.tc]*s)).getPtr());	
				}
				
				// binormal - c
				if(draw_binormals && tri.bc) {
					glColor3f(0,1,0);
					glVertex3fv(vertices[tri.vc].getPtr());
					glVertex3fv((vertices[tri.vc]+(binormals[tri.bc]*s)).getPtr());	
				}

			}
		glEnd();
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	}
	else if(getNumIndices() > 0) {
		if(getNumTexCoords() > 0) {
			int len = indices.size();
			glBegin(drawMode);
			for(int i = 0; i < len; ++i) {
				glTexCoord2fv(texcoords[indices[i]].getPtr());
				glVertex3fv(vertices[indices[i]].getPtr());
			}
			glEnd();
		}
		else {
			int len = indices.size();
			int mod = (drawMode == GL_QUADS) ? 4 : 3;
			
			Vec4 colors[4];
			colors[0].set(1,0,0, 0.8);
			colors[1].set(0,1,0, 0.8);
			colors[2].set(0,0,1, 0.8);
			colors[3].set(1,1,0, 0.8);
			
			glBegin(drawMode);
			for(int i = 0; i < len; ++i) {
				glColor4fv(colors[i%mod].getPtr());
				glVertex3fv(vertices[indices[i]].getPtr());
			}
			glEnd();
			
			if(normals.size() > 0) {
				glBegin(GL_LINES);
				for(int i = 0; i < len; ++i) {
					int dx = indices[i];
					//printf("%d <--\n", dx);
					Vec3 pos = vertices[dx];
					Vec3 norm = normals[dx];
					
					Vec3 end = pos + (norm.scale(line_length*2));
					glColor4f(1.0f,0.0f,0.4f,1.0f);
					glColor4f(0.98, 0.92, 0.75, 0.6);
					glVertex3fv(pos.getPtr());
					glColor4f(1.0f, 0.0f,1.0f,1.0f);
					glColor3f(0.98, 0.92, 0.75);
					glColor4f(0.98, 0.92, 0.75,0.6);
					glVertex3fv(end.getPtr());
					
				}
				glEnd();
			}


		}
	}
	// w/o indices
	else {

		glColor4f(1,1,1,1);
		glUseProgram(0);
		glDisable(GL_TEXTURE_2D);
		glDisable(GL_BLEND);
		bool draw_texture = false;		
		bool draw_tangents = true;
		bool draw_normals = true;
		bool draw_binormals = true;
		if(draw_texture && getNumTexCoords() > 0) {
			glColor3f(0.98, 0.92, 0.75); // yellowish
			int len = vertices.size();
			glEnable(GL_TEXTURE_2D);
			glBegin(drawMode);
			for(int i = 0; i < len; ++i) {
				int parts = 3;
				if(drawMode == GL_QUADS) {
					parts = 4;
				}
				glColor3fv(colors[i%parts]);
				glTexCoord2fv(texcoords[i].getPtr());
				glVertex3fv(vertices[i].getPtr());
			}
			glEnd();
			glDisable(GL_TEXTURE_2D);
			
		
		}
		else {
			// shape	
			//glColor3f(0.98, 0.92, 0.75); // yellowish
			glColor3f(0.8,0.8,0.8);
			glBegin(drawMode);
			vector<Vec3>::iterator it = vertices.begin();
			float len = vertices.size();
			while(it != vertices.end()) {	
				glVertex3fv((*it).getPtr());
				++it;
			}
			glEnd();
		}

		// normals.
		int len = normals.size();
		if(draw_normals && len == vertices.size()) {	
			glColor3f(0,1,1);
			glLineWidth(3.0);
			glBegin(GL_LINES);
			for(int i = 0; i < len; ++i) {
				Vec3 pos = vertices[i];
				Vec3 norm = normals[i];
				norm.normalize();
				Vec3 end = pos + (norm.scale(line_length));
				glVertex3fv(pos.getPtr());
				glVertex3fv(end.getPtr());
			}
			glEnd();
		}
		
		// tangents
		if(draw_tangents && tangents.size() > 0) {
			glLineWidth(3.0);
			glColor3f(1.0f,0.0f,0.0f);
			int len = tangents.size();
			glBegin(GL_LINES);
			for(int i = 0; i < len; ++i) {
				Vec3 pos = vertices[i];
				Vec3 norm = tangents[i];
				norm.normalize();
				Vec3 end = pos + (norm.scale(line_length));
				glVertex3fv(pos.getPtr());
				glVertex3fv(end.getPtr());
			};
			glEnd();
		}

		// binormals
		if(draw_binormals && binormals.size() > 0) {
			glLineWidth(3.0);
			glColor4f(0.0f,1.0f,0.0f,1.0f);
			int len = tangents.size();
			glBegin(GL_LINES);
			for(int i = 0; i < len; ++i) {
				Vec3 pos = vertices[i];
				Vec3 binorm = binormals[i].normalize();
				Vec3 end = pos + (binorm.scale(line_length));
				glVertex3fv(pos.getPtr());
				glVertex3fv(end.getPtr());
			};
			glEnd();
		}

		
		// draw lines
		glPolygonOffset(-1.0f, -1.0f);
		glEnable(GL_POLYGON_OFFSET_LINE);
		glEnable(GL_LINE_SMOOTH);
		glEnable(GL_BLEND);
		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
		glLineWidth(0.5f);
		glDisable(GL_TEXTURE_2D);
		glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
		glColor3f(0.4,0.4,0.4);
		glBegin(drawMode);
		for(int i = 0; i < vertices.size(); ++i) {
			glVertex3fv(vertices[i].getPtr());
		}
		glEnd();
		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
		glEnable(GL_TEXTURE_2D);
		glDisable(GL_POLYGON_OFFSET_LINE);
		glLineWidth(1.0f);
		glDisable(GL_BLEND);
		glDisable(GL_LINE_SMOOTH);
		glColor3f(1,1,1);

		
	}
	
//	if(!blend_enabled) {
//		glDisable(GL_BLEND);
//	}
	
	glPopAttrib();
#endif // roxlu_gl_variant	
}