Пример #1
0
void OpenGLRenderInterface::drawMesh(const Eigen::Vector3d& _scale, const aiScene* _mesh) {
    if(_mesh) {
        glPushMatrix();
        glScaled(_scale(0), _scale(1), _scale(2));
        recursiveRender(_mesh, _mesh->mRootNode);
        glPopMatrix();
    }
}
Пример #2
0
void Model::drawModel(){
	LOGGER_ENTER("Model", "drawModel");
	glPushMatrix();
	glScalef(modelScale, modelScale, modelScale);
	recursiveRender(model->mRootNode);
	glPopMatrix();
	LOGGER_EXIT;
}
Пример #3
0
// This function is taken from the examples coming with assimp
void OpenGLRenderInterface::recursiveRender(const struct aiScene *sc, const struct aiNode* nd) {
    unsigned int i;
    unsigned int n = 0, t;
    aiMatrix4x4 m = nd->mTransformation;

    // update transform
    aiTransposeMatrix4(&m);
    glPushMatrix();
    glMultMatrixf((float*)&m);

    // draw all meshes assigned to this node
    for (; n < nd->mNumMeshes; ++n) {
        const struct aiMesh* mesh = sc->mMeshes[nd->mMeshes[n]];

        glPushAttrib(GL_POLYGON_BIT | GL_LIGHTING_BIT);  // for applyMaterial()
        if(mesh->mMaterialIndex != (unsigned int)(-1)) // -1 is being used by us to indicate no material
            applyMaterial(sc->mMaterials[mesh->mMaterialIndex]);

        if(mesh->mNormals == nullptr) { glDisable(GL_LIGHTING);
        } else {
            glEnable(GL_LIGHTING);
        }

        for (t = 0; t < mesh->mNumFaces; ++t) {
            const struct aiFace* face = &mesh->mFaces[t];
            GLenum face_mode;

            switch(face->mNumIndices) {
                case 1: face_mode = GL_POINTS; break;
                case 2: face_mode = GL_LINES; break;
                case 3: face_mode = GL_TRIANGLES; break;
                default: face_mode = GL_POLYGON; break;
            }

            glBegin(face_mode);

            for (i = 0; i < face->mNumIndices; i++) {
                int index = face->mIndices[i];
                if(mesh->mColors[0] != nullptr)
                    glColor4fv((GLfloat*)&mesh->mColors[0][index]);
                if(mesh->mNormals != nullptr)
                    glNormal3fv(&mesh->mNormals[index].x);
                glVertex3fv(&mesh->mVertices[index].x);
            }

            glEnd();
        }

        glPopAttrib();  // for applyMaterial()
    }

    // draw all children
    for (n = 0; n < nd->mNumChildren; ++n) {
        recursiveRender(sc, nd->mChildren[n]);
    }

    glPopMatrix();
}
Пример #4
0
void Model::recursiveRender(CommandBuffer* cmd, const ModelNode& node) {
    for (auto& node_data : node.mesh_data) {
        auto& mesh = _meshData[node_data.mesh_index];

        cmd->bindDescriptorSet(node_data.model_descriptor_set.get());
        cmd->drawIndexed(mesh.vertex_count, 1, mesh.vertex_offset, mesh.base_vertex, 0);
        cmd->unbindDescriptorSet(node_data.model_descriptor_set);
    }

    for (auto& child : node.child_nodes) {
        recursiveRender(cmd, *child);
    }
}
Пример #5
0
//==============================================================================
void OpenGLRenderInterface::drawMesh(
    const Eigen::Vector3d& scale, const aiScene* mesh)
{
  if (!mesh)
    return;

  glPushMatrix();

  glScaled(scale[0], scale[1], scale[2]);
  recursiveRender(mesh, mesh->mRootNode);

  glPopMatrix();
}
Пример #6
0
//----------------------------------------------------------------------------------------------
void DebugMultiPoly::recursiveRender(TriFragNode* currentNode)
{
    glPushMatrix();

    float maxTime = currentNode->keyframeTime.back();

    float adjustedTime = fmodf(m_timeToLiveSeconds, maxTime);
    if (maxTime == 0.f)
    {
        adjustedTime = 0.f; //corrects for NaN
    }
    bool timeExceeded = false;
    int matrixFrame = -1;
    unsigned int keyframeIndex;
    for (keyframeIndex = 0; keyframeIndex < currentNode->transform.size() && !timeExceeded; keyframeIndex++)
    {
        if (adjustedTime < currentNode->keyframeTime[keyframeIndex])
        {
            timeExceeded = true;
        }
    }

    glMultMatrixf(currentNode->transform[keyframeIndex-1]); //TODO reference the ttl seconds

    if (currentNode->sizeOfVBO > 0)
    {

        //TODO render thyself
        glBindBuffer(GL_ARRAY_BUFFER, currentNode->VBOID);

        //Note to self: this was moved from render() because it needs to be after bind buffer, but render is unsure if a VBO is being used
        currentNode->material->m_primaryLightSource = m_material.m_primaryLightSource;
        currentNode->material->m_lightBufferID = m_material.m_lightBufferID;
        currentNode->material->m_cameraPosition = m_material.m_cameraPosition;
        currentNode->material->m_shaderID = m_material.m_shaderID;
        currentNode->material->m_shaderProgram = m_material.m_shaderProgram;
        currentNode->material->prepareOpenGLForMaterial();
        //m_material.prepareOpenGLForMaterial();



        glDrawArrays(GL_TRIANGLES, 0, currentNode->sizeOfVBO);

    }
    glPopMatrix();
    for (unsigned int triFragIndex = 0; triFragIndex < currentNode->children.size(); triFragIndex++)
    {
        recursiveRender(currentNode->children[triFragIndex]);
    }

}
Пример #7
0
//----------------------------------------------------------------------------------------------
void DebugMultiPoly::render()
{
    if(m_depthTest)
    {
        glEnable(GL_DEPTH_TEST);
    }
    else
    {
        glDisable(GL_DEPTH_TEST);
    }

    for(unsigned int TriFragIterator = 0; TriFragIterator < m_rootTriFragNodes.size(); TriFragIterator++)
    {
        recursiveRender(m_rootTriFragNodes[TriFragIterator]);
    }

}
Пример #8
0
void
PhotonMapper::render(Scene &scene)
{
    int xRes = scene.camera.xRes();
    int yRes = scene.camera.yRes();
    setRes(xRes, yRes);
    
	//clear m_rgbaBuffer
    m_rgbaBuffer.reset(Math::Color4f(1.0,1,1,1.0));
	//setup progress reporting using Platform::Progress
    
	//for each pixel generate a camera ray
    
    if (scene.photonMap == NULL && scene.specularPhotonMap == NULL) {
        scene.emit_scatterPhotons();
    }
    Platform::Progress progress = Platform::Progress("Raytracing Image", xRes*yRes);    
    for (int i=0; i < xRes; i++) {

        #pragma omp parallel for
        for (int j=0; j<yRes; j++) {
            Ray r = Ray();
            scene.camera.generateRay(r, i, j);
            Math::Vec3f col = recursiveRender(r, *(scene.photonMap), *(scene.specularPhotonMap), scene, true);
            m_rgbaBuffer(i, j) = Math::Vec4f(col.x, col.y, col.z, 1.0);
        }
        progress.step(yRes);
    }
	
	//Copy the final rendering to the texture
    glBindTexture(GL_TEXTURE_2D, m_fbo.colorTextureID(0));
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, m_fbo.width(), m_fbo.height(), GL_RGBA, GL_FLOAT, &m_rgbaBuffer(0,0));
    glBindTexture(GL_TEXTURE_2D, 0);    //Render to Screen
	m_fbo.blitFramebuffer(FBO_COLOR0);
//    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
//    m_fbo.displayAlphaAsFullScreenTexture(FBO_COLOR0);

}
Пример #9
0
void Model::render(CommandBuffer* cmd) {
    cmd->bindVertexArrayObject(_vertexArrayObject.get());

    recursiveRender(cmd, _rootNode);
}
Пример #10
0
void Model::recursiveRender(const aiNode* node){
	LOGGER_ENTER("Model", "recursiveRender");
	glPushMatrix();
	int m = node->mNumMeshes;
	aiMatrix4x4 masterTransform = node->mTransformation;

	/* Iterate through the node's meshes */
	for(int i = 0; i < m; i++){
		aiMesh* mesh = model->mMeshes[node->mMeshes[i]];

		Mesh m;
		if(gettingVertsAndNormals){
			m.mNumVertices = mesh->mNumVertices;
			m.vertices = new glm::vec3[m.mNumVertices];
			m.normals = new glm::vec3[m.mNumVertices];
			m.numFaces = mesh->mNumFaces;
			m.faceVertexIndices = new int*[m.numFaces];
			m.name = mesh->mName.C_Str();
		}

		aiVector3D* vertices = mesh->mVertices;
		aiVector3D* normals = mesh->mNormals;

		/*** Calculate Skeleton Transformations and Resulting Vertex Trasformations ***/
		if(mesh->HasBones()){
			vertices = new aiVector3D[mesh->mNumVertices];
			normals = new aiVector3D[mesh->mNumVertices];
			
			for(unsigned int b = 0; b < mesh->mNumBones; b++){
				aiMatrix4x4 boneMatrix;
				const aiBone* bone = mesh->mBones[b];

				aiNode* boneNode = findNodeRecurse(model->mRootNode, bone->mName);

				boneMatrix = bone->mOffsetMatrix;
				const aiNode* tmpNode = boneNode;
				while(tmpNode){
					boneMatrix = tmpNode->mTransformation * boneMatrix;
					tmpNode = tmpNode->mParent;
				}

				const aiMatrix4x4& posTransform = boneMatrix;
				const aiMatrix3x3 normalTransform = aiMatrix3x3(posTransform);

				for(unsigned int w = 0; w < bone->mNumWeights; w++){
					const aiVertexWeight& weight = bone->mWeights[w];
					unsigned int vertexID = weight.mVertexId;
					const aiVector3D& srcPos = mesh->mVertices[vertexID];
					const aiVector3D& srcNormal = mesh->mNormals[vertexID];

					vertices[vertexID] += weight.mWeight * (posTransform * srcPos);
					normals[vertexID] += weight.mWeight * (normalTransform * srcNormal);
				}
			}
		}

		/* Bind the texture if a diffuse texture exists */
		aiMaterial* mat = model->mMaterials[mesh->mMaterialIndex];
		int texIndex = 0;
		aiString texPath;
		if(AI_SUCCESS == mat->GetTexture(aiTextureType_DIFFUSE, texIndex, &texPath))    {
			unsigned int texId = textureIdMap[texPath.data];
			glBindTexture(GL_TEXTURE_2D, texId);
		}
		
		aiString matName;
		mat->Get(AI_MATKEY_NAME,matName);

		aiColor3D matDiffuseColour(0,0,0);
		if(mat->Get(AI_MATKEY_COLOR_DIFFUSE,matDiffuseColour) == AI_SUCCESS){
			float fMatDiffuseColour[] = {matDiffuseColour.r, matDiffuseColour.g, matDiffuseColour.b};
			glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, fMatDiffuseColour);
		}

		aiColor3D matSpecularColour(0,0,0);
		if(mat->Get(AI_MATKEY_COLOR_SPECULAR,matSpecularColour) == AI_SUCCESS){
			float fMatSpecularColour[] = {matSpecularColour.r, matSpecularColour.g, matSpecularColour.b};
			glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, fMatSpecularColour);
		}

		aiColor3D matAmbientColour(0,0,0);
		if(mat->Get(AI_MATKEY_COLOR_AMBIENT,matAmbientColour) == AI_SUCCESS){
			float fMatAmbientColour[] = {matAmbientColour.r, matAmbientColour.g, matAmbientColour.b};
			glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, fMatAmbientColour);
		}
		
			/* Draw Mesh Faces (Textures) */
			aiVector3D* texCoords = mesh->mTextureCoords[0];
			for(unsigned int j = 0; j < mesh->mNumFaces; j++){
				unsigned int* indices = mesh->mFaces[j].mIndices;
				aiVector3D n1, n2, n3, v1, v2, v3;
				
				if(mesh->HasBones()){
					n1 = normals[indices[0]];
					n2 = normals[indices[1]];
					n3 = normals[indices[2]];
					v1 = vertices[indices[0]];
					v2 = vertices[indices[1]];
					v3 = vertices[indices[2]];
				}else{
					n1 = MODEL_ROT_MAT * (masterTransform * normals[indices[0]]);
					n2 = MODEL_ROT_MAT * (masterTransform * normals[indices[1]]);
					n3 = MODEL_ROT_MAT * (masterTransform * normals[indices[2]]);
					v1 = MODEL_ROT_MAT * (masterTransform * vertices[indices[0]]);
					v2 = MODEL_ROT_MAT * (masterTransform * vertices[indices[1]]);
					v3 = MODEL_ROT_MAT * (masterTransform * vertices[indices[2]]);
				}

				glm::vec3 tmpV1(v1.x,v1.y,v1.z);
				glm::vec3 tmpV2(v2.x,v2.y,v2.z);
				glm::vec3 tmpV3(v3.x,v3.y,v3.z);
				glm::vec3 faceNormal = glm::normalize(glm::cross(tmpV3 - tmpV2, tmpV1 - tmpV2));

				if(gettingVertsAndNormals){
					glm::vec3 tmpN1(n1.x,n1.y,n1.z);
					glm::vec3 tmpN2(n2.x,n2.y,n2.z);
					glm::vec3 tmpN3(n3.x,n3.y,n3.z);

					m.vertices[indices[0]] = tmpV1;
					m.vertices[indices[1]] = tmpV2;
					m.vertices[indices[2]] = tmpV3;
					m.normals[indices[0]] = faceNormal;
					m.normals[indices[1]] = faceNormal;
					m.normals[indices[2]] = faceNormal;

					m.faceVertexIndices[j] = new int[3];
					m.faceVertexIndices[j][0] = indices[0];
					m.faceVertexIndices[j][1] = indices[1];
					m.faceVertexIndices[j][2] = indices[2];

					meshesMap[matName.C_Str()] = m;
				}else{
					glBegin(GL_POLYGON);
					
					if(mesh->HasTextureCoords(0)) glTexCoord2f(texCoords[indices[0]].x, 1 - texCoords[indices[0]].y);
					glNormal3f(faceNormal.x, faceNormal.y, faceNormal.z);
					glVertex3f(v1.x, v1.y, v1.z);
					if(mesh->HasTextureCoords(0)) glTexCoord2f(texCoords[indices[1]].x, 1 - texCoords[indices[1]].y);
					glVertex3f(v2.x, v2.y, v2.z);
					if(mesh->HasTextureCoords(0)) glTexCoord2f(texCoords[indices[2]].x, 1 - texCoords[indices[2]].y);
					glVertex3f(v3.x, v3.y, v3.z);
					glEnd();
				}
			}

			/* Free the memory that was used for the animated vertices and normals */
			if(mesh->HasBones()){
				free(normals);
				free(vertices);
			}

		/* Remove any texture binding */
		glBindTexture(GL_TEXTURE_2D, NULL);
	}

	/* Recurse Through Child Nodes */
	for(unsigned int i = 0; i < node->mNumChildren; i++){
		recursiveRender(node->mChildren[i]);
	}
	glPopMatrix();
	LOGGER_EXIT;
}