コード例 #1
0
//绘制点云
void DcGp::DcGpPointCloud::DrawMyselfOnly(DcGpDrawContext& context)
{	
	//如果数据隐藏,则返回上层数据
	if (!IsVisible())
	{
		return;
	}

	//是否存在点数据,否则返回上层函数
	if (m_pDcGpPointCloudImpl->m_points.empty())
		return;

	//判断是否是绘制三维物体
	if (MACRO_Draw3D(context))
	{
		glPushAttrib(GL_ALL_ATTRIB_BITS);
		if (!m_pDcGpPointCloudImpl->m_generalDrawShader.getProgramIndex())
		{
			//! 初始化一个shader program,用来处理快速渲染时候点隐藏的问题
			char* byteGlVersion  = (char*)glGetString(GL_VERSION);
			if (byteGlVersion[0] < '3' )
			{
				return;
			}
			else
			{
				m_pDcGpPointCloudImpl->SetupGeneralDrawShaders();
			}

		}

		if (m_pDcGpPointCloudImpl->m_generalDrawShader.getProgramIndex())
		{
			glUseProgram(m_pDcGpPointCloudImpl->m_generalDrawShader.getProgramIndex());

			//! 为block量赋值
			double matrixProjection[16];
			double matrixView[16];
			glGetDoublev(GL_PROJECTION_MATRIX, matrixProjection);
			glGetDoublev(GL_MODELVIEW_MATRIX, matrixView);

			DCCore::mat4 matPro;
			DCCore::mat4 matView;
			for (int i = 0; i != 16; ++i)
			{
				matPro.ptr()[i] = matrixProjection[i];
				matView.ptr()[i] = matrixView[i];
			}

			DCCore::mat4 pvm = matPro * matView;

			m_pDcGpPointCloudImpl->m_generalDrawShader.setUniform("pvm", pvm.ptr());
			float isSingleColor = 0;
			m_pDcGpPointCloudImpl->m_generalDrawShader.setUniform("isSingleColor", &isSingleColor);
		}


		//获取显示参数
		glDrawParameters glParams;
		GetDrawingParameters(glParams);
		glParams.showNormals &= bool(MACRO_LightIsEnabled(context));	//是否使用光照


		//! 计算纯色值
		std::vector<float > singleColor;
		if (glParams.showColors && IsColorOverriden())
		{
			singleColor.push_back(GetTempColor()[0]);
			singleColor.push_back(GetTempColor()[1]);
			singleColor.push_back(GetTempColor()[2]);
			glParams.showColors = false;
		}
		else
		{
			singleColor.push_back(context.pointsDefaultCol[0]);
			singleColor.push_back(context.pointsDefaultCol[1]);
			singleColor.push_back(context.pointsDefaultCol[2]);
		}


		// L.O.D.
		unsigned numberOfPoints = Size();
		unsigned decimStep = 0;

		if (m_pDcGpPointCloudImpl->m_pointSize != 0)
			glPointSize((GLfloat)m_pDcGpPointCloudImpl->m_pointSize);


		//! 渲染绘制,因为为shader传入了可见性变量,所以不管什么情况只要控制传入
		//! 顶点、颜色、法向量即可。顶点是不变的,颜色是变化的(纯色、标量色、选取色),法向量是不变的(存在或者不存在)
		//!开启alpha测试
		glEnable(GL_ALPHA_TEST);
		glAlphaFunc(GL_GREATER, 0.0f);

		int sample = 0;

		

		//! 1、每帧中顶点不变
		glEnableVertexAttribArray(VSShaderLib::VERTEX_COORD_ATTRIB);
		glVertexAttribPointer(VSShaderLib::VERTEX_COORD_ATTRIB, 3, GL_FLOAT, 0, sample * 3 * sizeof(PointCoordinateType), 
			&(m_pDcGpPointCloudImpl->m_points[0][0]));

		//! 2、每帧中顶点可见性不变,传递顶点的可见性变量到shader中
		glEnableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB1);
		glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB1, 1, GL_INT, 0, sample * 1 * sizeof(int), 
			&(m_pDcGpPointCloudImpl->m_pointsVisibility[0]));

		//! 3、确定颜色值怎么选择(只存在纯色、真彩色、标量色三种)
		if (glParams.showColors)
		{
			glEnableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB2);
			
			if (IsChoosed())
			{
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_choosedColors[0][0]));
			}
			else
			{
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_rgbColors[0][0]));
			}
		}
		else if (glParams.showScalarField) 
		{
			glEnableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB2);
			if (IsChoosed())
			{
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_choosedColors[0][0]));
			}
			else
			{
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_scalarColors[0][0]));
			}
		}
		else
		{
			if (IsChoosed())
			{
				float isSingleColor = 0;
				m_pDcGpPointCloudImpl->m_generalDrawShader.setUniform("isSingleColor", &isSingleColor);
				
				glEnableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB2);
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_choosedColors[0][0]));
			}
			else
			{
				//! 纯色处理,由于纯色不是颜色数组,所以采用uniform实现
				float isSingleColor = 1;
				m_pDcGpPointCloudImpl->m_generalDrawShader.setUniform("isSingleColor", &isSingleColor);

				//!传入纯色值
				m_pDcGpPointCloudImpl->m_generalDrawShader.setUniform("singleColor", &singleColor[0]);
			}
			
		}

		
		//! 渲染
		//glDrawArrays(GL_POINTS, 0, numberOfPoints);

		//绘制顶点数组时候均采用循环处理,采用数据定长处理,每次处理100000数据
		if (GetChunk() > 1)
		{
			for (long i = 0; i != GetChunk(); ++i)
			{
				if (i == GetChunk()-1)
				{
					glDrawArrays(GL_POINTS, DC_CHUNK_COUNT * i, Size() - DC_CHUNK_COUNT * i);
				}
				else
				{
					glDrawArrays(GL_POINTS, DC_CHUNK_COUNT * i, DC_CHUNK_COUNT);
				}
			}
		} 
		else
		{
			glDrawArrays(GL_POINTS, 0, Size());
		}

		glDisableVertexAttribArray(VSShaderLib::VERTEX_COORD_ATTRIB);
		glDisableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB1);
		glDisableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB2);

		
		glDisable(GL_ALPHA_TEST);

		
		glPopAttrib();
		glUseProgram(0);
	}
	else if (MACRO_Draw2D(context))
	{
		if (MACRO_Foreground(context) && !context.sfColorScaleToDisplay)
		{
			if (IsSfColorbarVisible()  && ScalarFieldShown())
			{
				//drawScale(context);
				AddColorBarInfo(context);
			}
		}
	}
	//绘制文本
	//context._win->Display3DLabel( "Qt", GetPoint(0) + DCVector3D(context.pickedPointsTextShift), DCColor::MAGENTA, QFont());
}
コード例 #2
0
ファイル: ccGenericMesh.cpp プロジェクト: Aerochip7/trunk
void ccGenericMesh::drawMeOnly(CC_DRAW_CONTEXT& context)
{
	ccGenericPointCloud* vertices = getAssociatedCloud();
	if (!vertices)
		return;

	handleColorRamp(context);

	//3D pass
	if (MACRO_Draw3D(context))
	{
		//any triangle?
		unsigned triNum = size();
		if (triNum == 0)
			return;

		//L.O.D.
		bool lodEnabled = (triNum > GET_MAX_LOD_FACES_NUMBER() && context.decimateMeshOnMove && MACRO_LODActivated(context));
		unsigned decimStep = (lodEnabled ? (unsigned)ceil((float)triNum*3 / (float)GET_MAX_LOD_FACES_NUMBER()) : 1);
		unsigned displayedTriNum = triNum / decimStep;

		//display parameters
		glDrawParams glParams;
		getDrawingParameters(glParams);
		glParams.showNorms &= bool(MACRO_LightIsEnabled(context));

		//vertices visibility
		const ccGenericPointCloud::VisibilityTableType* verticesVisibility = vertices->getTheVisibilityArray();
		bool visFiltering = (verticesVisibility && verticesVisibility->isAllocated());

		//wireframe ? (not compatible with LOD)
		bool showWired = isShownAsWire() && !lodEnabled;

		//per-triangle normals?
		bool showTriNormals = (hasTriNormals() && triNormsShown());
		//fix 'showNorms'
		glParams.showNorms = showTriNormals || (vertices->hasNormals() && m_normalsDisplayed);

		//materials & textures
		bool applyMaterials = (hasMaterials() && materialsShown());
		bool showTextures = (hasTextures() && materialsShown() && !lodEnabled);

		//GL name pushing
		bool pushName = MACRO_DrawEntityNames(context);
		//special case: triangle names pushing (for picking)
		bool pushTriangleNames = MACRO_DrawTriangleNames(context);
		pushName |= pushTriangleNames;

		if (pushName)
		{
			//not fast at all!
			if (MACRO_DrawFastNamesOnly(context))
				return;
			glPushName(getUniqueIDForDisplay());
			//minimal display for picking mode!
			glParams.showNorms = false;
			glParams.showColors = false;
			//glParams.showSF --> we keep it only if SF 'NaN' values are hidden
			showTriNormals = false;
			applyMaterials = false;
			showTextures = false;
		}

		//in the case we need to display scalar field colors
		ccScalarField* currentDisplayedScalarField = 0;
		bool greyForNanScalarValues = true;
		unsigned colorRampSteps = 0;
		ccColorScale::Shared colorScale(0);

		if (glParams.showSF)
		{
			assert(vertices->isA(CC_TYPES::POINT_CLOUD));
			ccPointCloud* cloud = static_cast<ccPointCloud*>(vertices);

			greyForNanScalarValues = (cloud->getCurrentDisplayedScalarField() && cloud->getCurrentDisplayedScalarField()->areNaNValuesShownInGrey());
			if (greyForNanScalarValues && pushName)
			{
				//in picking mode, no need to take SF into account if we don't hide any points!
				glParams.showSF = false;
			}
			else
			{
				currentDisplayedScalarField = cloud->getCurrentDisplayedScalarField();
				colorScale = currentDisplayedScalarField->getColorScale();
				colorRampSteps = currentDisplayedScalarField->getColorRampSteps();

				assert(colorScale);
				//get default color ramp if cloud has no scale associated?!
				if (!colorScale)
					colorScale = ccColorScalesManager::GetUniqueInstance()->getDefaultScale(ccColorScalesManager::BGYR);
			}
		}

		//materials or color?
		bool colorMaterial = false;
		if (glParams.showSF || glParams.showColors)
		{
			applyMaterials = false;
			colorMaterial = true;
			glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
			glEnable(GL_COLOR_MATERIAL);
		}

		//in the case we need to display vertex colors
		ColorsTableType* rgbColorsTable = 0;
		if (glParams.showColors)
		{
			if (isColorOverriden())
			{
				glColor3ubv(m_tempColor);
				glParams.showColors = false;
			}
			else
			{
				assert(vertices->isA(CC_TYPES::POINT_CLOUD));
				rgbColorsTable = static_cast<ccPointCloud*>(vertices)->rgbColors();
			}
		}
		else
		{
			glColor3fv(context.defaultMat.diffuseFront);
		}

		if (glParams.showNorms)
		{
			//DGM: Strangely, when Qt::renderPixmap is called, the OpenGL version can fall to 1.0!
			glEnable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE));
			glEnable(GL_LIGHTING);
			context.defaultMat.applyGL(true,colorMaterial);
		}

		//in the case we need normals (i.e. lighting)
		NormsIndexesTableType* normalsIndexesTable = 0;
		ccNormalVectors* compressedNormals = 0;
		if (glParams.showNorms)
		{
			assert(vertices->isA(CC_TYPES::POINT_CLOUD));
			normalsIndexesTable = static_cast<ccPointCloud*>(vertices)->normals();
			compressedNormals = ccNormalVectors::GetUniqueInstance();
		}

		//stipple mask
		if (stipplingEnabled())
			EnableGLStippleMask(true);

		if (!pushTriangleNames && !visFiltering && !(applyMaterials || showTextures) && (!glParams.showSF || greyForNanScalarValues))
		{
			//the GL type depends on the PointCoordinateType 'size' (float or double)
			GLenum GL_COORD_TYPE = sizeof(PointCoordinateType) == 4 ? GL_FLOAT : GL_DOUBLE;
			
			glEnableClientState(GL_VERTEX_ARRAY);
			glVertexPointer(3,GL_COORD_TYPE,0,GetVertexBuffer());

			if (glParams.showNorms)
			{
				glEnableClientState(GL_NORMAL_ARRAY);
				glNormalPointer(GL_COORD_TYPE,0,GetNormalsBuffer());
			}
			if (glParams.showSF || glParams.showColors)
			{
				glEnableClientState(GL_COLOR_ARRAY);
				glColorPointer(3,GL_UNSIGNED_BYTE,0,GetColorsBuffer());
			}

			//we can scan and process each chunk separately in an optimized way
			//we mimic the way ccMesh beahves by using virtual chunks!
			unsigned chunks = static_cast<unsigned>(ceil((double)displayedTriNum/(double)MAX_NUMBER_OF_ELEMENTS_PER_CHUNK));
			unsigned chunkStart = 0;
			const colorType* col = 0;
			for (unsigned k=0; k<chunks; ++k, chunkStart += MAX_NUMBER_OF_ELEMENTS_PER_CHUNK)
			{
				//virtual chunk size
				const unsigned chunkSize = k+1 < chunks ? MAX_NUMBER_OF_ELEMENTS_PER_CHUNK : (displayedTriNum % MAX_NUMBER_OF_ELEMENTS_PER_CHUNK);

				//vertices
				PointCoordinateType* _vertices = GetVertexBuffer();
				for (unsigned n=0; n<chunkSize; n+=decimStep)
				{
					const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n);
					memcpy(_vertices,vertices->getPoint(ti->i1)->u,sizeof(PointCoordinateType)*3);
					_vertices+=3;
					memcpy(_vertices,vertices->getPoint(ti->i2)->u,sizeof(PointCoordinateType)*3);
					_vertices+=3;
					memcpy(_vertices,vertices->getPoint(ti->i3)->u,sizeof(PointCoordinateType)*3);
					_vertices+=3;
				}

				//scalar field
				if (glParams.showSF)
				{
					colorType* _rgbColors = GetColorsBuffer();
					assert(colorScale);
					for (unsigned n=0; n<chunkSize; n+=decimStep)
					{
						const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n);
						col = currentDisplayedScalarField->getValueColor(ti->i1);
						memcpy(_rgbColors,col,sizeof(colorType)*3);
						_rgbColors += 3;
						col = currentDisplayedScalarField->getValueColor(ti->i2);
						memcpy(_rgbColors,col,sizeof(colorType)*3);
						_rgbColors += 3;
						col = currentDisplayedScalarField->getValueColor(ti->i3);
						memcpy(_rgbColors,col,sizeof(colorType)*3);
						_rgbColors += 3;
					}
				}
				//colors
				else if (glParams.showColors)
				{
					colorType* _rgbColors = GetColorsBuffer();

					for (unsigned n=0; n<chunkSize; n+=decimStep)
					{
						const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n);
						memcpy(_rgbColors,rgbColorsTable->getValue(ti->i1),sizeof(colorType)*3);
						_rgbColors += 3;
						memcpy(_rgbColors,rgbColorsTable->getValue(ti->i2),sizeof(colorType)*3);
						_rgbColors += 3;
						memcpy(_rgbColors,rgbColorsTable->getValue(ti->i3),sizeof(colorType)*3);
						_rgbColors += 3;
					}
				}

				//normals
				if (glParams.showNorms)
				{
					PointCoordinateType* _normals = GetNormalsBuffer();
					if (showTriNormals)
					{
						for (unsigned n=0; n<chunkSize; n+=decimStep)
						{
							CCVector3 Na, Nb, Nc;
							getTriangleNormals(chunkStart + n, Na, Nb, Nc);
							memcpy(_normals,Na.u,sizeof(PointCoordinateType)*3);
							_normals+=3;
							memcpy(_normals,Nb.u,sizeof(PointCoordinateType)*3);
							_normals+=3;
							memcpy(_normals,Nc.u,sizeof(PointCoordinateType)*3);
							_normals+=3;
						}
					}
					else
					{
						for (unsigned n=0; n<chunkSize; n+=decimStep)
						{
							const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n);
							memcpy(_normals,vertices->getPointNormal(ti->i1).u,sizeof(PointCoordinateType)*3);
							_normals+=3;
							memcpy(_normals,vertices->getPointNormal(ti->i2).u,sizeof(PointCoordinateType)*3);
							_normals+=3;
							memcpy(_normals,vertices->getPointNormal(ti->i3).u,sizeof(PointCoordinateType)*3);
							_normals+=3;
						}
					}
				}

				if (!showWired)
				{
					glDrawArrays(lodEnabled ? GL_POINTS : GL_TRIANGLES,0,(chunkSize/decimStep)*3);
				}
				else
				{
					glDrawElements(GL_LINES,(chunkSize/decimStep)*6,GL_UNSIGNED_INT,GetWireVertexIndexes());
				}
			}

			//disable arrays
			glDisableClientState(GL_VERTEX_ARRAY);
			if (glParams.showNorms)
				glDisableClientState(GL_NORMAL_ARRAY);
			if (glParams.showSF || glParams.showColors)
				glDisableClientState(GL_COLOR_ARRAY);
		}
		else
		{
			//current vertex color
			const colorType *col1=0,*col2=0,*col3=0;
			//current vertex normal
			const PointCoordinateType *N1=0,*N2=0,*N3=0;
			//current vertex texture coordinates
			float *Tx1=0,*Tx2=0,*Tx3=0;

			//loop on all triangles
			int lasMtlIndex = -1;

			if (showTextures)
			{
				//#define TEST_TEXTURED_BUNDLER_IMPORT
#ifdef TEST_TEXTURED_BUNDLER_IMPORT
				glPushAttrib(GL_COLOR_BUFFER_BIT);
				glEnable(GL_BLEND);
				glBlendFunc(context.sourceBlend, context.destBlend);
#endif

				glEnable(GL_TEXTURE_2D);
			}

			if (pushTriangleNames)
				glPushName(0);

			GLenum triangleDisplayType = lodEnabled ? GL_POINTS : showWired ? GL_LINE_LOOP : GL_TRIANGLES;
			glBegin(triangleDisplayType);

			//per-triangle normals
			const NormsIndexesTableType* triNormals = getTriNormsTable();
			//materials
			const ccMaterialSet* materials = getMaterialSet();

			for (unsigned n=0; n<triNum; ++n)
			{
				//current triangle vertices
				const CCLib::TriangleSummitsIndexes* tsi = getTriangleIndexes(n);

				//LOD: shall we display this triangle?
				if (n % decimStep)
					continue;

				if (visFiltering)
				{
					//we skip the triangle if at least one vertex is hidden
					if ((verticesVisibility->getValue(tsi->i1) != POINT_VISIBLE) ||
						(verticesVisibility->getValue(tsi->i2) != POINT_VISIBLE) ||
						(verticesVisibility->getValue(tsi->i3) != POINT_VISIBLE))
						continue;
				}

				if (glParams.showSF)
				{
					assert(colorScale);
					col1 = currentDisplayedScalarField->getValueColor(tsi->i1);
					if (!col1)
						continue;
					col2 = currentDisplayedScalarField->getValueColor(tsi->i2);
					if (!col2)
						continue;
					col3 = currentDisplayedScalarField->getValueColor(tsi->i3);
					if (!col3)
						continue;
				}
				else if (glParams.showColors)
				{
					col1 = rgbColorsTable->getValue(tsi->i1);
					col2 = rgbColorsTable->getValue(tsi->i2);
					col3 = rgbColorsTable->getValue(tsi->i3);
				}

				if (glParams.showNorms)
				{
					if (showTriNormals)
					{
						assert(triNormals);
						int n1,n2,n3;
						getTriangleNormalIndexes(n,n1,n2,n3);
						N1 = (n1>=0 ? ccNormalVectors::GetNormal(triNormals->getValue(n1)).u : 0);
						N2 = (n1==n2 ? N1 : n1>=0 ? ccNormalVectors::GetNormal(triNormals->getValue(n2)).u : 0);
						N3 = (n1==n3 ? N1 : n3>=0 ? ccNormalVectors::GetNormal(triNormals->getValue(n3)).u : 0);

					}
					else
					{
						N1 = compressedNormals->getNormal(normalsIndexesTable->getValue(tsi->i1)).u;
						N2 = compressedNormals->getNormal(normalsIndexesTable->getValue(tsi->i2)).u;
						N3 = compressedNormals->getNormal(normalsIndexesTable->getValue(tsi->i3)).u;
					}
				}

				if (applyMaterials || showTextures)
				{
					assert(materials);
					int newMatlIndex = this->getTriangleMtlIndex(n);

					//do we need to change material?
					if (lasMtlIndex != newMatlIndex)
					{
						assert(newMatlIndex<(int)materials->size());
						glEnd();
						if (showTextures)
						{
							GLuint texID = (newMatlIndex>=0 ? (*materials)[newMatlIndex].texID : 0);
							if (texID>0)
								assert(glIsTexture(texID));
							glBindTexture(GL_TEXTURE_2D, texID);
						}

						//if we don't have any current material, we apply default one
						(newMatlIndex>=0 ? (*materials)[newMatlIndex] : context.defaultMat).applyGL(glParams.showNorms,false);
						glBegin(triangleDisplayType);
						lasMtlIndex=newMatlIndex;
					}

					if (showTextures)
					{
						getTriangleTexCoordinates(n,Tx1,Tx2,Tx3);
					}
				}

				if (pushTriangleNames)
				{
					glEnd();
					glLoadName(n);
					glBegin(triangleDisplayType);
				}
				else if (showWired)
				{
					glEnd();
					glBegin(triangleDisplayType);
				}

				//vertex 1
				if (N1)
					ccGL::Normal3v(N1);
				if (col1)
					glColor3ubv(col1);
				if (Tx1)
					glTexCoord2fv(Tx1);
				ccGL::Vertex3v(vertices->getPoint(tsi->i1)->u);

				//vertex 2
				if (N2)
					ccGL::Normal3v(N2);
				if (col2)
					glColor3ubv(col2);
				if (Tx2)
					glTexCoord2fv(Tx2);
				ccGL::Vertex3v(vertices->getPoint(tsi->i2)->u);

				//vertex 3
				if (N3)
					ccGL::Normal3v(N3);
				if (col3)
					glColor3ubv(col3);
				if (Tx3)
					glTexCoord2fv(Tx3);
				ccGL::Vertex3v(vertices->getPoint(tsi->i3)->u);
			}

			glEnd();

			if (pushTriangleNames)
				glPopName();

			if (showTextures)
			{
#ifdef TEST_TEXTURED_BUNDLER_IMPORT
				glPopAttrib(); //GL_COLOR_BUFFER_BIT 
#endif
				glBindTexture(GL_TEXTURE_2D, 0);
				glDisable(GL_TEXTURE_2D);
			}
		}

		if (stipplingEnabled())
			EnableGLStippleMask(false);

		if (colorMaterial)
			glDisable(GL_COLOR_MATERIAL);

		if (glParams.showNorms)
		{
			glDisable(GL_LIGHTING);
			glDisable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE));
		}

		if (pushName)
			glPopName();
	}
}
コード例 #3
0
void DcGp::DcGpPointCloud::FastDrawMyselfOnly(DcGpDrawContext& context)
{

	//如果数据隐藏,则返回上层数据
	if (!IsVisible())
	{
		return;
	}

	//是否存在点数据,否则返回上层函数
	if (m_pDcGpPointCloudImpl->m_points.empty())
		return;

	//判断是否是绘制三维物体
	if (MACRO_Draw3D(context))
	{
		glPushAttrib(GL_ALL_ATTRIB_BITS);
		if (!m_pDcGpPointCloudImpl->m_fastDrawShader.getProgramIndex())
		{
			//! 初始化一个shader program,用来处理快速渲染时候点隐藏的问题
			char* byteGlVersion  = (char*)glGetString(GL_VERSION);
			if (byteGlVersion[0] < '3' )
			{
				return;
			}
			else
			{
				m_pDcGpPointCloudImpl->SetupFastDrawShaders();
			}

		}

		if (m_pDcGpPointCloudImpl->m_fastDrawShader.getProgramIndex())
		{
			glUseProgram(m_pDcGpPointCloudImpl->m_fastDrawShader.getProgramIndex());

			//! 为block量赋值
			double matrixProjection[16];
			double matrixView[16];
			glGetDoublev(GL_PROJECTION_MATRIX, matrixProjection);
			glGetDoublev(GL_MODELVIEW_MATRIX, matrixView);

			DCCore::mat4 matPro;
			DCCore::mat4 matView;
			for (int i = 0; i != 16; ++i)
			{
				matPro.ptr()[i] = matrixProjection[i];
				matView.ptr()[i] = matrixView[i];
			}

			DCCore::mat4 pvm = matPro * matView;

			m_pDcGpPointCloudImpl->m_fastDrawShader.setUniform("pvm", pvm.ptr());
			float isSingleColor = 0;
			m_pDcGpPointCloudImpl->m_fastDrawShader.setUniform("isSingleColor", &isSingleColor);
		}


		//获取显示参数
		glDrawParameters glParams;
		GetDrawingParameters(glParams);
		glParams.showNormals &= bool(MACRO_LightIsEnabled(context));	//是否使用光照


		//! 计算纯色值
		std::vector<float > singleColor;
		if (glParams.showColors && IsColorOverriden())
		{
			singleColor.push_back(GetTempColor()[0]);
			singleColor.push_back(GetTempColor()[1]);
			singleColor.push_back(GetTempColor()[2]);
			glParams.showColors = false;
		}
		else
		{
			singleColor.push_back(context.pointsDefaultCol[0]);
			singleColor.push_back(context.pointsDefaultCol[1]);
			singleColor.push_back(context.pointsDefaultCol[2]);
		}


		// L.O.D.
		unsigned numberOfPoints = Size();
		unsigned sample = 1;//标准的显示全部点
		unsigned totalSamplePoints = numberOfPoints;
		if (numberOfPoints >= DCCore::MAX_FACE_NUM)
		{
			sample = static_cast<int>(ceil(static_cast<float>(numberOfPoints) / DCCore::MAX_FACE_NUM));
		}

		if (m_pDcGpPointCloudImpl->m_pointSize != 0)
			glPointSize((GLfloat)m_pDcGpPointCloudImpl->m_pointSize);


		//! 渲染绘制,因为为shader传入了可见性变量,所以不管什么情况只要控制传入
		//! 顶点、颜色、法向量即可。顶点是不变的,颜色是变化的(纯色、标量色、选取色),法向量是不变的(存在或者不存在)
		//!开启alpha测试
		glEnable(GL_ALPHA_TEST);
		glAlphaFunc(GL_GREATER, 0.0f);
		

		//! 1、每帧中顶点不变
		glEnableVertexAttribArray(VSShaderLib::VERTEX_COORD_ATTRIB);
		glVertexAttribPointer(VSShaderLib::VERTEX_COORD_ATTRIB, 3, GL_FLOAT, 0, sample * 3 * sizeof(PointCoordinateType), 
			&(m_pDcGpPointCloudImpl->m_points[0][0]));

		//! 2、每帧中顶点可见性不变,传递顶点的可见性变量到shader中
		glEnableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB1);
		glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB1, 1, GL_INT, 0, sample * 1 * sizeof(int), 
			&(m_pDcGpPointCloudImpl->m_pointsVisibility[0]));

		//! 3、确定颜色值怎么选择(只存在纯色、真彩色、标量色三种)
		if (glParams.showColors)
		{
			glEnableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB2);
			
			if (IsChoosed())
			{
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_choosedColors[0][0]));
			}
			else
			{
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_rgbColors[0][0]));
			}
		}
		else if (glParams.showScalarField) 
		{
			glEnableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB2);
			if (IsChoosed())
			{
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_choosedColors[0][0]));
			}
			else
			{
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_scalarColors[0][0]));
			}
		}
		else
		{
			if (IsChoosed())
			{
				float isSingleColor = 0;
				m_pDcGpPointCloudImpl->m_fastDrawShader.setUniform("isSingleColor", &isSingleColor);
				
				glEnableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB2);
				glVertexAttribPointer(VSShaderLib::VERTEX_ATTRIB2, 3, GL_UNSIGNED_BYTE, 0, sample * 3 * sizeof(ColorType), 
					&(m_pDcGpPointCloudImpl->m_choosedColors[0][0]));
			}
			else
			{
				//! 纯色处理,由于纯色不是颜色数组,所以采用uniform实现
				float isSingleColor = 1;
				m_pDcGpPointCloudImpl->m_fastDrawShader.setUniform("isSingleColor", &isSingleColor);

				//!传入纯色值
				m_pDcGpPointCloudImpl->m_fastDrawShader.setUniform("singleColor", &singleColor[0]);
			}
			
		}

		
		//! 渲染
		long lodNum = Size();
		if (sample > 1)
		{
			float numFloat = static_cast<float >(lodNum) / sample;
			lodNum = static_cast<unsigned>(floor(numFloat));
		}
		glDrawArrays(GL_POINTS, 0, lodNum);


		glDisableVertexAttribArray(VSShaderLib::VERTEX_COORD_ATTRIB);
		glDisableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB1);
		glDisableVertexAttribArray(VSShaderLib::VERTEX_ATTRIB2);

		
		glDisable(GL_ALPHA_TEST);

		
		glPopAttrib();
		glUseProgram(0);
	}
}