void ccOctree::drawMeOnly(CC_DRAW_CONTEXT& context) { if (m_thePointsAndTheirCellCodes.empty()) return; if (MACRO_Draw3D(context)) { bool pushName = MACRO_DrawEntityNames(context); if (pushName) { //not fast at all! if (MACRO_DrawFastNamesOnly(context)) return; glPushName(getUniqueIDForDisplay()); } assert(m_displayedLevel < 256); RenderOctreeAs(m_displayType,this,static_cast<uchar>(m_displayedLevel),m_theAssociatedCloudAsGPC,m_glListID,m_shouldBeRefreshed); if (m_shouldBeRefreshed) m_shouldBeRefreshed = false; if (pushName) glPopName(); } }
void ccPolyline::drawMeOnly(CC_DRAW_CONTEXT& context) { if (size() < 2) return; bool draw = false; if (MACRO_Draw3D(context)) { draw = !m_mode2D; } else if (m_mode2D) { bool drawFG = MACRO_Foreground(context); draw = ((drawFG && m_foreground) || (!drawFG && !m_foreground)); } if (draw) { if (colorsShown()) glColor3ubv(m_rgbColor); glBegin(m_isClosed ? GL_LINE_LOOP : GL_LINE_STRIP); unsigned count=size(); for (unsigned i=0;i<count;++i) glVertex3fv(m_theAssociatedCloud->getPoint(m_theIndexes->getValue(i))->u); glEnd(); } }
void ccIndexedTransformationBuffer::drawMeOnly(CC_DRAW_CONTEXT& context) { //no picking enabled on trans. buffers if (MACRO_DrawEntityNames(context)) return; //only in 3D if (!MACRO_Draw3D(context)) return; //get the set of OpenGL functions (version 2.1) QOpenGLFunctions_2_1 *glFunc = context.glFunctions<QOpenGLFunctions_2_1>(); assert( glFunc != nullptr ); if ( glFunc == nullptr ) return; size_t count = size(); //show path { ccGL::Color3v(glFunc, ccColor::green.rgba); glFunc->glBegin(count > 1 && m_showAsPolyline ? GL_LINE_STRIP : GL_POINTS); //show path as a polyline or points? for (ccIndexedTransformationBuffer::const_iterator it=begin(); it!=end(); ++it) glFunc->glVertex3fv(it->getTranslation()); glFunc->glEnd(); } //show trihedrons? if (m_showTrihedrons) { for (ccIndexedTransformationBuffer::const_iterator it=begin(); it!=end(); ++it) { glFunc->glMatrixMode(GL_MODELVIEW); glFunc->glPushMatrix(); glFunc->glMultMatrixf(it->data()); //force line width glFunc->glPushAttrib(GL_LINE_BIT); glFunc->glLineWidth(2.0f); glFunc->glBegin(GL_LINES); glFunc->glColor3f(1.0f,0.0f,0.0f); glFunc->glVertex3f(0.0f,0.0f,0.0f); glFunc->glVertex3f(m_trihedronsScale,0.0f,0.0f); glFunc->glColor3f(0.0f,1.0f,0.0f); glFunc->glVertex3f(0.0f,0.0f,0.0f); glFunc->glVertex3f(0.0f,m_trihedronsScale,0.0f); glFunc->glColor3f(0.0f,0.7f,1.0f); glFunc->glVertex3f(0.0f,0.0f,0.0f); glFunc->glVertex3f(0.0f,0.0f,m_trihedronsScale); glFunc->glEnd(); glFunc->glPopAttrib(); //GL_LINE_BIT glFunc->glPopMatrix(); } } }
void ccClipBox::drawMeOnly(CC_DRAW_CONTEXT& context) { if (!MACRO_Draw3D(context)) return; if (!m_box.isValid()) return; //m_box.draw(m_selected ? context.bbDefaultCol : ccColor::magenta); m_box.draw(ccColor::yellow); //standard case: list names pushing bool pushName = MACRO_DrawEntityNames(context); if (pushName) glPushName(getUniqueID()); if (m_selected) { //draw the interactors const CCVector3& minC = m_box.minCorner(); const CCVector3& maxC = m_box.maxCorner(); CCVector3 center = m_box.getCenter(); PointCoordinateType scale = computeArrowsScale(); //custom arrow 'context' CC_DRAW_CONTEXT componentContext = context; componentContext.flags &= (~CC_DRAW_ENTITY_NAMES); //we must remove the 'push name flag' so that the arows don't push their own! componentContext._win = 0; //1 if names shall be pushed, 0 otherwise int pushMod = (pushName ? 1 : 0); if (pushName) glPushName(0); //fake ID, will be replaced by the arrows one if any DrawUnitArrow(X_MINUS_ARROW*pushName,CCVector3(minC.x,center.y,center.z),CCVector3(-1.0, 0.0, 0.0),scale,ccColor::red,componentContext); DrawUnitArrow(X_PLUS_ARROW*pushName,CCVector3(maxC.x,center.y,center.z),CCVector3( 1.0, 0.0, 0.0),scale,ccColor::red,componentContext); DrawUnitArrow(Y_MINUS_ARROW*pushName,CCVector3(center.x,minC.y,center.z),CCVector3( 0.0,-1.0, 0.0),scale,ccColor::green,componentContext); DrawUnitArrow(Y_PLUS_ARROW*pushName,CCVector3(center.x,maxC.y,center.z),CCVector3( 0.0, 1.0, 0.0),scale,ccColor::green,componentContext); DrawUnitArrow(Z_MINUS_ARROW*pushName,CCVector3(center.x,center.y,minC.z),CCVector3( 0.0, 0.0,-1.0),scale,ccColor::blue,componentContext); DrawUnitArrow(Z_PLUS_ARROW*pushName,CCVector3(center.x,center.y,maxC.z),CCVector3( 0.0, 0.0, 1.0),scale,ccColor::blue,componentContext); DrawUnitCross(CROSS*pushName,minC-CCVector3(scale,scale,scale)/2.0,scale,ccColor::yellow,componentContext); //DrawUnitSphere(SPHERE*pushName,maxC+CCVector3(scale,scale,scale)/2.0,scale/2.0,ccColor::yellow,componentContext); DrawUnitTorus(X_MINUS_TORUS*pushName,CCVector3(minC.x,center.y,center.z),CCVector3(-1.0, 0.0, 0.0),scale,c_lightRed,componentContext); DrawUnitTorus(Y_MINUS_TORUS*pushName,CCVector3(center.x,minC.y,center.z),CCVector3( 0.0,-1.0, 0.0),scale,c_lightGreen,componentContext); DrawUnitTorus(Z_MINUS_TORUS*pushName,CCVector3(center.x,center.y,minC.z),CCVector3( 0.0, 0.0,-1.0),scale,c_lightBlue,componentContext); DrawUnitTorus(X_PLUS_TORUS*pushName,CCVector3(maxC.x,center.y,center.z),CCVector3( 1.0, 0.0, 0.0),scale,c_lightRed,componentContext); DrawUnitTorus(Y_PLUS_TORUS*pushName,CCVector3(center.x,maxC.y,center.z),CCVector3( 0.0, 1.0, 0.0),scale,c_lightGreen,componentContext); DrawUnitTorus(Z_PLUS_TORUS*pushName,CCVector3(center.x,center.y,maxC.z),CCVector3( 0.0, 0.0, 1.0),scale,c_lightBlue,componentContext); if (pushName) glPopName(); } if (pushName) glPopName(); }
void ccFacet::drawMeOnly(CC_DRAW_CONTEXT& context) { if (!MACRO_Draw3D(context)) return; if (m_showNormalVector && m_contourPolyline) { if (!c_unitNormalSymbol) { c_unitNormalSymbol = QSharedPointer<ccCylinder>(new ccCylinder(0.02f,0.9f,0,"UnitNormal",12)); c_unitNormalSymbol->showColors(true); c_unitNormalSymbol->setVisible(true); c_unitNormalSymbol->setEnabled(true); c_unitNormalSymbol->setTempColor(ccColor::green); } if (!c_unitNormalHeadSymbol) { c_unitNormalHeadSymbol = QSharedPointer<ccCone>(new ccCone(0.05f,0.0f,0.1f,0,0,0,"UnitNormalHead",12)); c_unitNormalHeadSymbol->showColors(true); c_unitNormalHeadSymbol->setVisible(true); c_unitNormalHeadSymbol->setEnabled(true); c_unitNormalHeadSymbol->setTempColor(ccColor::green); } //build-up point maker own 'context' CC_DRAW_CONTEXT markerContext = context; markerContext.flags &= (~CC_DRAW_ENTITY_NAMES); //we must remove the 'push name flag' so that the sphere doesn't push its own! markerContext._win = 0; c_unitNormalSymbol->setTempColor(m_contourPolyline->getColor()); PointCoordinateType scale = m_contourPolyline->getBB().getMinBoxDim(); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glTranslatef(m_center.x,m_center.y,m_center.z); ccGLMatrix mat = ccGLMatrix::FromToRotation(getNormal(),CCVector3(0,0,1)); glMultMatrixf(mat.data()); glScalef(scale,scale,scale); glTranslatef(0,0,0.45f); c_unitNormalSymbol->draw(markerContext); glTranslatef(0,0,0.45f); c_unitNormalHeadSymbol->draw(markerContext); glPopMatrix(); } }
void ccIndexedTransformationBuffer::drawMeOnly(CC_DRAW_CONTEXT& context) { //no picking enabled on trans. buffers if (MACRO_DrawNames(context)) return; //only in 3D if (!MACRO_Draw3D(context)) return; size_t count = size(); //show path { glColor3ubv(ccColor::green); glBegin(count > 1 && m_showAsPolyline ? GL_LINE_STRIP : GL_POINTS); //show path as a polyline or points? for (ccIndexedTransformationBuffer::const_iterator it=begin(); it!=end(); ++it) glVertex3fv(it->getTranslation()); glEnd(); } //show trihedrons? if (m_showTrihedrons) { for (ccIndexedTransformationBuffer::const_iterator it=begin(); it!=end(); ++it) { glMatrixMode(GL_MODELVIEW); glPushMatrix(); glMultMatrixf(it->data()); glBegin(GL_LINES); glColor3f(1.0f,0.0f,0.0f); glVertex3f(0.0f,0.0f,0.0f); glVertex3f(m_trihedronsScale,0.0f,0.0f); glColor3f(0.0f,1.0f,0.0f); glVertex3f(0.0f,0.0f,0.0f); glVertex3f(0.0f,m_trihedronsScale,0.0f); glColor3f(0.0f,0.7f,1.0f); glVertex3f(0.0f,0.0f,0.0f); glVertex3f(0.0f,0.0f,m_trihedronsScale); glEnd(); glPopMatrix(); } } }
void cc2DLabel::drawMeOnly(CC_DRAW_CONTEXT& context) { if (m_points.empty()) return; //2D foreground only if (!MACRO_Foreground(context)) return; //Not compatible with virtual transformation (see ccDrawableObject::enableGLTransformation) if (MACRO_VirtualTransEnabled(context)) return; if (MACRO_Draw3D(context)) drawMeOnly3D(context); else if (MACRO_Draw2D(context)) drawMeOnly2D(context); }
void ccFacet::drawMeOnly(CC_DRAW_CONTEXT& context) { if (!MACRO_Draw3D(context)) return; //show normal vector if (normalVectorIsShown() && m_contourPolyline) { PointCoordinateType scale = 0; if (m_surface > 0) //the surface might be 0 if Delaunay 2.5D triangulation is not supported { scale = sqrt(m_surface); } else { scale = sqrt(m_contourPolyline->computeLength()); } glDrawNormal(context, m_center, scale, &m_contourPolyline->getColor()); } }
void ccOctree::drawMeOnly(CC_DRAW_CONTEXT& context) { if (m_thePointsAndTheirCellCodes.empty()) return; if (MACRO_Draw3D(context)) { bool pushName = MACRO_DrawEntityNames(context); if (pushName) glPushName(getUniqueID()); RenderOctreeAs(displayType,this,displayedLevel,_associatedCloud,glID,shouldBeRefreshed); if (shouldBeRefreshed) shouldBeRefreshed = false; if (pushName) glPopName(); } }
void ccSample::drawStratPos(CC_DRAW_CONTEXT& context) { if (MACRO_Draw3D(context)) { QOpenGLFunctions_2_1* glFunc = context.glFunctions<QOpenGLFunctions_2_1>(); assert(glFunc != nullptr); QFont font(context.display->getTextDisplayFont()); // takes rendering zoom into // account! font.setPointSize(font.pointSize()); font.setBold(true); // // draw their name // glPushAttrib(GL_DEPTH_BUFFER_BIT); glFunc->glDisable(GL_DEPTH_TEST); QString name = QString::number(getSample()->getStratigraphicPosition(), 'g', 3); context.display->display3DLabel(name, CCVector3(getSample()->getPosition().data()), ccColor::red.rgb, font); // CCVector3 p (x,y,z); // QString title = (getName()); // context.display->display3DLabel( title, // p + CCVector3( // context.pickedPointsTextShift, // context.pickedPointsTextShift, // context.pickedPointsTextShift), // ccColor::magenta, // font ); // glPopAttrib(); glFunc->glEnable(GL_DEPTH_TEST); } }
void ccKdTree::drawMeOnly(CC_DRAW_CONTEXT& context) { if (!m_associatedGenericCloud || !m_root) return; if (MACRO_Draw3D(context)) { bool pushName = MACRO_DrawEntityNames(context); if (pushName) { //not fast at all! if (MACRO_DrawFastNamesOnly(context)) return; glPushName(getUniqueIDForDisplay()); } DrawMeOnlyVisitor(m_associatedGenericCloud->getBB()).visit(m_root); if (pushName) glPopName(); } }
void ccPolyline::drawMeOnly(CC_DRAW_CONTEXT& context) { //no picking enabled on polylines if (MACRO_DrawPointNames(context)) return; unsigned vertCount = size(); if (vertCount < 2) return; bool draw = false; if (MACRO_Draw3D(context)) { draw = !m_mode2D; } else if (m_mode2D) { bool drawFG = MACRO_Foreground(context); draw = ((drawFG && m_foreground) || (!drawFG && !m_foreground)); } if (draw) { //standard case: list names pushing bool pushName = MACRO_DrawEntityNames(context); if (pushName) glPushName(getUniqueIDForDisplay()); if (colorsShown()) glColor3ubv(m_rgbColor); //display polyline { if (m_width != 0) { glPushAttrib(GL_LINE_BIT); glLineWidth(static_cast<GLfloat>(m_width)); } glBegin(m_isClosed ? GL_LINE_LOOP : GL_LINE_STRIP); for (unsigned i=0; i<vertCount; ++i) { ccGL::Vertex3v(getPoint(i)->u); } glEnd(); if (m_width != 0) { glPopAttrib(); } } //display vertices if (m_showVertices) { glPushAttrib(GL_POINT_BIT); glPointSize((GLfloat)m_vertMarkWidth); glBegin(GL_POINTS); for (unsigned i=0; i<vertCount; ++i) { ccGL::Vertex3v(getPoint(i)->u); } glEnd(); glPopAttrib(); } if (pushName) glPopName(); } }
//================================================draw====================================================// void ccHObject::draw(CC_DRAW_CONTEXT& context) { if (!isEnabled())return; //是否开启 //are we currently drawing objects in 2D or 3D? bool draw3D = MACRO_Draw3D(context); //判断是在三维上绘制还是在二维上绘制? //the entity must be either visible and selected, and of course it should be displayed in this context //是否可视,是否被选择,是否在当前窗口下显示 bool drawInThisContext = ((m_visible || m_selected) && m_currentDisplay == context._win); //no need to display anything but clouds and meshes in "element picking mode" drawInThisContext &= ( ( !MACRO_DrawPointNames(context) || isKindOf(CC_TYPES::POINT_CLOUD) ) || ( !MACRO_DrawTriangleNames(context) || isKindOf(CC_TYPES::MESH) )); if (draw3D){ //apply 3D 'temporary' transformation (for display only) if (m_glTransEnabled){ //可以进行变换 glMatrixMode(GL_MODELVIEW); glPushMatrix(); glMultMatrixf(m_glTrans.data()); } if ( context.decimateCloudOnMove //LOD for clouds is enabled? && context.currentLODLevel >= context.minLODLevel //and we are currently rendering higher levels? ){ //only for real clouds drawInThisContext &= isA(CC_TYPES::POINT_CLOUD); //LOD只对点云有效?????????? } } //draw entity if (m_visible && drawInThisContext){ if (( !m_selected || !MACRO_SkipSelected(context) ) && ( m_selected || !MACRO_SkipUnselected(context) )) { //apply default color (in case of) ccGL::Color3v(context.pointsDefaultCol.rgb); //不同的物体绘制方式不同 drawMeOnly(context); //draw name in 3D (we display it in the 2D foreground layer in fact!) if (m_showNameIn3D && MACRO_Draw2D(context) && MACRO_Foreground(context) && !MACRO_DrawNames(context)) drawNameIn3D(context); } } //draw entity's children //绘制物体的子物体 for (Container::iterator it = m_children.begin(); it != m_children.end(); ++it) (*it)->draw(context); //绘制BB //if the entity is currently selected, we draw its bounding-box if (m_selected && draw3D && drawInThisContext && !MACRO_DrawNames(context) && context.currentLODLevel == 0){ drawBB(context.bbDefaultCol); } if (draw3D && m_glTransEnabled) glPopMatrix(); }
void ccSNECloud::drawMeOnly(CC_DRAW_CONTEXT& context) { if (!MACRO_Foreground(context)) //2D foreground only return; //do nothing //draw point cloud ccPointCloud::drawMeOnly(context); //draw normal vectors if (MACRO_Draw3D(context)) { if (size() == 0) //no points -> bail! return; //get the set of OpenGL functions (version 2.1) QOpenGLFunctions_2_1 *glFunc = context.glFunctions<QOpenGLFunctions_2_1>(); if (glFunc == nullptr) { assert(false); return; } //glDrawParams glParams; //getDrawingParameters(glParams); //get camera info ccGLCameraParameters camera; glFunc->glGetIntegerv(GL_VIEWPORT, camera.viewport); glFunc->glGetDoublev(GL_PROJECTION_MATRIX, camera.projectionMat.data()); glFunc->glGetDoublev(GL_MODELVIEW_MATRIX, camera.modelViewMat.data()); const ccViewportParameters& viewportParams = context.display->getViewportParameters(); //get point size for drawing float pSize; glFunc->glGetFloatv(GL_POINT_SIZE, &pSize); //draw normal vectors if highlighted //if ((m_isHighlighted | m_isAlternate | m_isActive)) //{ //setup if (pSize != 0) { glFunc->glPushAttrib(GL_LINE_BIT); glFunc->glLineWidth(static_cast<GLfloat>(pSize)); } glFunc->glMatrixMode(GL_MODELVIEW); glFunc->glPushMatrix(); glFunc->glEnable(GL_BLEND); //get normal vector properties int thickID = getScalarFieldIndexByName("Thickness"); //int weightID = getScalarFieldIndexByName("Weight"); //float weight; //float maxWeight = getScalarField( weightID )->getMax(); //draw normals glFunc->glBegin(GL_LINES); for (unsigned p = 0; p < size(); p++) { //get weight //weight = getScalarField(weightID)->getValue(p); //weight /= maxWeight; //push colour const ccColor::Rgb* col = m_currentDisplayedScalarField->getColor(m_currentDisplayedScalarField->getValue(p)); const ccColor::Rgba col4(col->r, col->g, col->b,200); glFunc->glColor4ubv(col4.rgba); //get length from thickness (if defined) float length = 1.0; if (thickID != -1) { length = getScalarField(thickID)->getValue(p); } //calculate start and end points of normal vector const CCVector3 start = *getPoint(p); CCVector3 end = start + (getPointNormal(p)*length); //push line to opengl ccGL::Vertex3v(glFunc, start.u); ccGL::Vertex3v(glFunc, end.u); } glFunc->glEnd(); //cleanup if (pSize != 0) { glFunc->glPopAttrib(); } glFunc->glPopMatrix(); } }
void ccHObject::draw(CC_DRAW_CONTEXT& context) { if (!isEnabled()) return; bool draw3D = MACRO_Draw3D(context); bool drawInThisContext = (!m_visible && !m_selected ? false : m_currentDisplay == context._win); //no need to display anything but clouds and meshes in "point picking mode" bool DrawMesh = false; if (MACRO_DrawTriangleNames(context) && isKindOf(CC_MESH)) { ccGenericMesh *mesh = static_cast<ccGenericMesh*>(this); ccGenericPointCloud *cloud = mesh->getAssociatedCloud(); DrawMesh = (cloud == NULL || !cloud->isEnabled()); } drawInThisContext &= ( (!MACRO_DrawPointNames(context) || isKindOf(CC_POINT_CLOUD)) || (!MACRO_DrawTriangleNames(context) || DrawMesh) ); //apply 3D 'temporary' transformation (for display only) if (draw3D && m_glTransEnabled) { glMatrixMode(GL_MODELVIEW); glPushMatrix(); glMultMatrixf(m_glTrans.data()); } //draw entity if (m_visible && drawInThisContext) { if ((!m_selected || !MACRO_SkipSelected(context)) && (m_selected || !MACRO_SkipUnselected(context))) { glColor3ubv(context.pointsDefaultCol); drawMeOnly(context); //draw name in 3D (we display it in the 2D foreground layer in fact!) if (m_showNameIn3D && MACRO_Draw2D(context) && MACRO_Foreground(context) && !MACRO_DrawNames(context)) drawNameIn3D(context); } } //draw entity's children for (Container::iterator it = m_children.begin(); it!=m_children.end(); ++it) (*it)->draw(context); //if the entity is currently selected if (m_selected && draw3D && drawInThisContext) { switch (m_selectionBehavior) { case SELECTION_AA_BBOX: drawBB(context.bbDefaultCol); break; case SELECTION_FIT_BBOX: { ccGLMatrix trans; ccBBox box = getFitBB(trans); if (box.isValid()) { glMatrixMode(GL_MODELVIEW); glPushMatrix(); glMultMatrixf(trans.data()); box.draw(context.bbDefaultCol); glPopMatrix(); } } break; case SELECTION_IGNORED: break; default: assert(false); } } if (draw3D && m_glTransEnabled) glPopMatrix(); }
void ccHObject::draw(CC_DRAW_CONTEXT& context) { if (!isEnabled()) return; //are we currently drawing objects in 2D or 3D? bool draw3D = MACRO_Draw3D(context); //the entity must be either visible and selected, and of course it should be displayed in this context bool drawInThisContext = ((m_visible || m_selected) && m_currentDisplay == context._win); //no need to display anything but clouds and meshes in "element picking mode" drawInThisContext &= ( ( !MACRO_DrawPointNames(context) || isKindOf(CC_TYPES::POINT_CLOUD) ) || ( !MACRO_DrawTriangleNames(context) || isKindOf(CC_TYPES::MESH) )); //apply 3D 'temporary' transformation (for display only) if (draw3D && m_glTransEnabled) { glMatrixMode(GL_MODELVIEW); glPushMatrix(); glMultMatrixf(m_glTrans.data()); } //draw entity if (m_visible && drawInThisContext) { if (( !m_selected || !MACRO_SkipSelected(context) ) && ( m_selected || !MACRO_SkipUnselected(context) )) { //apply default color (in case of) glColor3ubv(context.pointsDefaultCol); drawMeOnly(context); //draw name in 3D (we display it in the 2D foreground layer in fact!) if (m_showNameIn3D && MACRO_Draw2D(context) && MACRO_Foreground(context) && !MACRO_DrawNames(context)) drawNameIn3D(context); } } //draw entity's children for (Container::iterator it = m_children.begin(); it != m_children.end(); ++it) (*it)->draw(context); //if the entity is currently selected, we draw its bounding-box if (m_selected && draw3D && drawInThisContext && !MACRO_DrawNames(context)) { switch (m_selectionBehavior) { case SELECTION_AA_BBOX: drawBB(context.bbDefaultCol); break; case SELECTION_FIT_BBOX: { ccGLMatrix trans; ccBBox box = getFitBB(trans); if (box.isValid()) { glMatrixMode(GL_MODELVIEW); glPushMatrix(); glMultMatrixf(trans.data()); box.draw(context.bbDefaultCol); glPopMatrix(); } } break; case SELECTION_IGNORED: break; default: assert(false); } } if (draw3D && m_glTransEnabled) glPopMatrix(); }
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); } }
//绘制点云 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()); }
void ccSample::drawMeOnly(CC_DRAW_CONTEXT& context) { if (MACRO_Draw3D(context)) { if (!this->getSample()) return; QOpenGLFunctions_2_1* glFunc = context.glFunctions<QOpenGLFunctions_2_1>(); assert(glFunc != nullptr); bool pushName = MACRO_DrawEntityNames(context); if (pushName) { // not particularily fast if (MACRO_DrawFastNamesOnly(context)) return; glFunc->glPushName(getUniqueIDForDisplay()); } if (!c_unitPointMarker) { c_unitPointMarker = QSharedPointer<ccSphere>(new ccSphere(m_radius_, 0, "PointMarker", 12)); c_unitPointMarker->showColors(true); c_unitPointMarker->setVisible(true); c_unitPointMarker->setEnabled(true); } // build-up point maker own 'context' CC_DRAW_CONTEXT markerContext = context; markerContext.drawingFlags &= (~CC_DRAW_ENTITY_NAMES); // we must remove the 'push name flag' so // that the sphere doesn't push its own! markerContext.display = nullptr; if (isSelected() && !pushName) { c_unitPointMarker->setTempColor(ccColor::red); c_unitPointMarker->setRadius(2 * m_radius_); } else { c_unitPointMarker->setTempColor(ccColor::magenta); c_unitPointMarker->setRadius(m_radius_); } glFunc->glMatrixMode(GL_MODELVIEW); glFunc->glPushMatrix(); float x, y, z; Eigen::Vector3f p = this->getSample()->getPosition(); // const CCVector3* P = m_points[i].cloud->getPoint(m_points[i].index); // ccGL::Translate(); glFunc->glTranslatef(p(0), p(1), p(2)); glFunc->glScalef(context.labelMarkerSize, context.labelMarkerSize, context.labelMarkerSize); m_current_scaling_ = context.labelMarkerSize; c_unitPointMarker->draw(markerContext); glFunc->glPopMatrix(); drawStratPos(context); if (pushName) glFunc->glPopName(); } }
void ccPolyline::drawMeOnly(CC_DRAW_CONTEXT& context) { //no picking enabled on polylines if (MACRO_DrawPointNames(context)) return; unsigned vertCount = size(); if (vertCount < 2) return; bool draw = false; if (MACRO_Draw3D(context)) { draw = !m_mode2D; } else if (m_mode2D) { bool drawFG = MACRO_Foreground(context); draw = ((drawFG && m_foreground) || (!drawFG && !m_foreground)); } if (draw) { //standard case: list names pushing bool pushName = MACRO_DrawEntityNames(context); if (pushName) glPushName(getUniqueIDForDisplay()); if (colorsShown()) ccGL::Color3v(m_rgbColor.rgb); //display polyline if (vertCount > 1) { if (m_width != 0) { glPushAttrib(GL_LINE_BIT); glLineWidth(static_cast<GLfloat>(m_width)); } //DGM: we do the 'GL_LINE_LOOP' manually as I have a strange bug //on one on my graphic card with this mode! //glBegin(m_isClosed ? GL_LINE_LOOP : GL_LINE_STRIP); glBegin(GL_LINE_STRIP); for (unsigned i=0; i<vertCount; ++i) { ccGL::Vertex3v(getPoint(i)->u); } if (m_isClosed) { ccGL::Vertex3v(getPoint(0)->u); } glEnd(); //display arrow if (m_showArrow && m_arrowIndex < vertCount && (m_arrowIndex > 0 || m_isClosed)) { const CCVector3* P0 = getPoint(m_arrowIndex == 0 ? vertCount-1 : m_arrowIndex-1); const CCVector3* P1 = getPoint(m_arrowIndex); //direction of the last polyline chunk CCVector3 u = *P1 - *P0; u.normalize(); if (m_mode2D) { u *= -m_arrowLength; static const PointCoordinateType s_defaultArrowAngle = static_cast<PointCoordinateType>(15.0 * CC_DEG_TO_RAD); static const PointCoordinateType cost = cos(s_defaultArrowAngle); static const PointCoordinateType sint = sin(s_defaultArrowAngle); CCVector3 A(cost * u.x - sint * u.y, sint * u.x + cost * u.y, 0); CCVector3 B(cost * u.x + sint * u.y, -sint * u.x + cost * u.y, 0); glBegin(GL_POLYGON); ccGL::Vertex3v((A+*P1).u); ccGL::Vertex3v((B+*P1).u); ccGL::Vertex3v(( *P1).u); glEnd(); } else { if (!c_unitArrow) { c_unitArrow = QSharedPointer<ccCone>(new ccCone(0.5,0.0,1.0)); c_unitArrow->showColors(true); c_unitArrow->showNormals(false); c_unitArrow->setVisible(true); c_unitArrow->setEnabled(true); } if (colorsShown()) c_unitArrow->setTempColor(m_rgbColor); else c_unitArrow->setTempColor(context.pointsDefaultCol); //build-up unit arrow own 'context' CC_DRAW_CONTEXT markerContext = context; markerContext.flags &= (~CC_DRAW_ENTITY_NAMES); //we must remove the 'push name flag' so that the sphere doesn't push its own! markerContext._win = 0; glMatrixMode(GL_MODELVIEW); glPushMatrix(); ccGL::Translate(P1->x,P1->y,P1->z); ccGLMatrix rotMat = ccGLMatrix::FromToRotation(CCVector3(0,0,1),u); glMultMatrixf(rotMat.inverse().data()); glScalef(m_arrowLength,m_arrowLength,m_arrowLength); ccGL::Translate(0.0,0.0,-0.5); c_unitArrow->draw(markerContext); glPopMatrix(); } } if (m_width != 0) { glPopAttrib(); } } //display vertices if (m_showVertices) { glPushAttrib(GL_POINT_BIT); glPointSize((GLfloat)m_vertMarkWidth); glBegin(GL_POINTS); for (unsigned i=0; i<vertCount; ++i) { ccGL::Vertex3v(getPoint(i)->u); } glEnd(); glPopAttrib(); } if (pushName) glPopName(); } }
void ccClipBox::drawMeOnly(CC_DRAW_CONTEXT& context) { if (!MACRO_Draw3D(context)) return; if (!m_box.isValid()) return; //get the set of OpenGL functions (version 2.1) QOpenGLFunctions_2_1 *glFunc = context.glFunctions<QOpenGLFunctions_2_1>(); assert( glFunc != nullptr ); if ( glFunc == nullptr ) return; if (m_showBox) { //m_box.draw(m_selected ? context.bbDefaultCol : ccColor::magenta); m_box.draw(context, ccColor::yellow); } if (!m_selected) { //nothing to show return; } //standard case: list names pushing (1st level) bool pushName = MACRO_DrawEntityNames(context); if (pushName) { glFunc->glPushName(getUniqueIDForDisplay()); } //draw the interactors { const CCVector3& minC = m_box.minCorner(); const CCVector3& maxC = m_box.maxCorner(); const CCVector3 center = m_box.getCenter(); PointCoordinateType scale = computeArrowsScale(); //custom arrow 'context' CC_DRAW_CONTEXT componentContext = context; componentContext.drawingFlags &= (~CC_DRAW_ENTITY_NAMES); //we must remove the 'push name flag' so that the arows don't push their own! componentContext.display = 0; if (pushName) //2nd level = sub-item { glFunc->glPushName(0); //fake ID, will be replaced by the arrows one if any } DrawUnitArrow(X_MINUS_ARROW*pushName, CCVector3(minC.x, center.y, center.z), CCVector3(-1.0, 0.0, 0.0), scale, ccColor::red, componentContext); DrawUnitArrow(X_PLUS_ARROW*pushName, CCVector3(maxC.x, center.y, center.z), CCVector3(1.0, 0.0, 0.0), scale, ccColor::red, componentContext); DrawUnitArrow(Y_MINUS_ARROW*pushName, CCVector3(center.x, minC.y, center.z), CCVector3(0.0, -1.0, 0.0), scale, ccColor::green, componentContext); DrawUnitArrow(Y_PLUS_ARROW*pushName, CCVector3(center.x, maxC.y, center.z), CCVector3(0.0, 1.0, 0.0), scale, ccColor::green, componentContext); DrawUnitArrow(Z_MINUS_ARROW*pushName, CCVector3(center.x, center.y, minC.z), CCVector3(0.0, 0.0, -1.0), scale, ccColor::blue, componentContext); DrawUnitArrow(Z_PLUS_ARROW*pushName, CCVector3(center.x, center.y, maxC.z), CCVector3(0.0, 0.0, 1.0), scale, ccColor::blue, componentContext); DrawUnitCross(CROSS*pushName, minC - CCVector3(scale, scale, scale) / 2.0, scale, ccColor::yellow, componentContext); //DrawUnitSphere(SPHERE*pushName, maxC + CCVector3(scale, scale, scale) / 2.0, scale / 2.0, ccColor::yellow, componentContext); DrawUnitTorus(X_MINUS_TORUS*pushName, CCVector3(minC.x, center.y, center.z), CCVector3(-1.0, 0.0, 0.0), scale, c_lightRed, componentContext); DrawUnitTorus(Y_MINUS_TORUS*pushName, CCVector3(center.x, minC.y, center.z), CCVector3(0.0, -1.0, 0.0), scale, c_lightGreen, componentContext); DrawUnitTorus(Z_MINUS_TORUS*pushName, CCVector3(center.x, center.y, minC.z), CCVector3(0.0, 0.0, -1.0), scale, c_lightBlue, componentContext); DrawUnitTorus(X_PLUS_TORUS*pushName, CCVector3(maxC.x, center.y, center.z), CCVector3(1.0, 0.0, 0.0), scale, c_lightRed, componentContext); DrawUnitTorus(Y_PLUS_TORUS*pushName, CCVector3(center.x, maxC.y, center.z), CCVector3(0.0, 1.0, 0.0), scale, c_lightGreen, componentContext); DrawUnitTorus(Z_PLUS_TORUS*pushName, CCVector3(center.x, center.y, maxC.z), CCVector3(0.0, 0.0, 1.0), scale, c_lightBlue, componentContext); if (pushName) { glFunc->glPopName(); } } if (pushName) { glFunc->glPopName(); } }
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(); } }
void ccGBLSensor::drawMeOnly(CC_DRAW_CONTEXT& context) { //we draw here a little 3d representation of the sensor if (MACRO_Draw3D(context)) { bool pushName = MACRO_DrawEntityNames(context); if (pushName) { //not particulary fast if (MACRO_DrawFastNamesOnly(context)) return; glPushName(getUniqueIDForDisplay()); } //DGM FIXME: this display routine is crap! //apply rigid transformation glMatrixMode(GL_MODELVIEW); glPushMatrix(); { ccIndexedTransformation sensorPos; if (!getAbsoluteTransformation(sensorPos,m_activeIndex)) { //no visible position for this index! glPopMatrix(); if (pushName) glPopName(); return; } glMultMatrixf(sensorPos.data()); } //test: center as sphere /*{ ccSphere sphere(m_scale/10,0,"Center",12); sphere.showColors(true); sphere.setVisible(true); sphere.setEnabled(true); CC_DRAW_CONTEXT sphereContext = context; sphereContext.flags &= (~CC_DRAW_ENTITY_NAMES); //we must remove the 'push name flag' so that the sphere doesn't push its own! sphereContext._win = 0; sphere.setTempColor(ccColor::magenta); sphere.draw(sphereContext); } //*/ const PointCoordinateType halfHeadSize = static_cast<PointCoordinateType>(0.3); //sensor axes { //increased width glPushAttrib(GL_LINE_BIT); GLfloat width; glGetFloatv(GL_LINE_WIDTH,&width); glLineWidth(width+1); PointCoordinateType axisLength = halfHeadSize * m_scale; ccGL::Color3v(ccColor::red.rgba); CCVector3 C(0,0,0); glBegin(GL_LINES); ccGL::Vertex3v(C.u); ccGL::Vertex3(C.x+axisLength,C.y,C.z); glEnd(); ccGL::Color3v(ccColor::green.rgba); glBegin(GL_LINES); ccGL::Vertex3v(C.u); ccGL::Vertex3(C.x,C.y+axisLength,C.z); glEnd(); ccGL::Color3v(ccColor::blue.rgba); glBegin(GL_LINES); ccGL::Vertex3v(C.u); ccGL::Vertex3(C.x,C.y,C.z+axisLength); glEnd(); glPopAttrib(); } //sensor head { CCVector3 minCorner(-halfHeadSize,-halfHeadSize,-halfHeadSize); CCVector3 maxCorner( halfHeadSize, halfHeadSize, halfHeadSize); minCorner *= m_scale; maxCorner *= m_scale; ccBBox bbHead(minCorner,maxCorner); bbHead.draw(m_color); } //sensor legs { CCVector3 headConnect = /*headCenter*/ - CCVector3(0,0,static_cast<PointCoordinateType>(halfHeadSize)*m_scale); ccGL::Color3v(m_color.rgb); glBegin(GL_LINES); ccGL::Vertex3v(headConnect.u); ccGL::Vertex3(-m_scale,-m_scale,-m_scale); ccGL::Vertex3v(headConnect.u); ccGL::Vertex3(-m_scale,m_scale,-m_scale); ccGL::Vertex3v(headConnect.u); ccGL::Vertex3(m_scale,0,-m_scale); glEnd(); } if (pushName) glPopName(); glPopMatrix(); } }
void ccHObject::draw(CC_DRAW_CONTEXT& context) { if (!isEnabled()) return; //get the set of OpenGL functions (version 2.1) QOpenGLFunctions_2_1 *glFunc = context.glFunctions<QOpenGLFunctions_2_1>(); assert( glFunc != nullptr ); if ( glFunc == nullptr ) return; //are we currently drawing objects in 2D or 3D? bool draw3D = MACRO_Draw3D(context); //the entity must be either visible or selected, and of course it should be displayed in this context bool drawInThisContext = ((m_visible || m_selected) && m_currentDisplay == context.display); if (draw3D) { //apply 3D 'temporary' transformation (for display only) if (m_glTransEnabled) { glFunc->glMatrixMode(GL_MODELVIEW); glFunc->glPushMatrix(); glFunc->glMultMatrixf(m_glTrans.data()); } //LOD for clouds is enabled? if ( context.decimateCloudOnMove && context.currentLODLevel > 0) { //only for real clouds drawInThisContext &= isA(CC_TYPES::POINT_CLOUD); } } //draw entity if (m_visible && drawInThisContext) { if (( !m_selected || !MACRO_SkipSelected(context) ) && ( m_selected || !MACRO_SkipUnselected(context) )) { //apply default color (in case of) ccGL::Color3v(glFunc, context.pointsDefaultCol.rgb); //enable clipping planes (if any) bool useClipPlanes = (draw3D && !m_clipPlanes.empty()); if (useClipPlanes) { toggleClipPlanes(context, true); } drawMeOnly(context); //disable clipping planes (if any) if (useClipPlanes) { toggleClipPlanes(context, false); } //draw name in 3D (we display it in the 2D foreground layer in fact!) if (m_showNameIn3D && MACRO_Draw2D(context) && MACRO_Foreground(context) && !MACRO_DrawEntityNames(context)) drawNameIn3D(context); } } //draw entity's children for (Container::iterator it = m_children.begin(); it != m_children.end(); ++it) (*it)->draw(context); //if the entity is currently selected, we draw its bounding-box if (m_selected && draw3D && drawInThisContext && !MACRO_DrawEntityNames(context) && context.currentLODLevel == 0) { drawBB(context, context.bbDefaultCol); } if (draw3D && m_glTransEnabled) glFunc->glPopMatrix(); }
void ccHObject::draw(CC_DRAW_CONTEXT& context) { if (!isEnabled()) return; bool draw3D = MACRO_Draw3D(context); bool drawInThisContext = (!visible && !selected ? false : currentDisplay == context._win); //no need to display anything but clouds in "point picking mode" drawInThisContext &= (!MACRO_DrawPointNames(context) || isKindOf(CC_POINT_CLOUD)); //apply 3D 'temporary' transformation (for display only) if (draw3D && glTransEnabled) { glMatrixMode(GL_MODELVIEW); glPushMatrix(); glMultMatrixf(glTrans.data()); } //draw entity if (visible && drawInThisContext) { if ((!selected || !MACRO_SkipSelected(context)) && (selected || !MACRO_SkipUnselected(context))) { glColor3ubv(context.pointsDefaultCol); drawMeOnly(context); } } //draw entity's children for (Container::iterator it = m_children.begin(); it!=m_children.end(); ++it) (*it)->draw(context); //if the entity is currently selected if (selected && draw3D && drawInThisContext) { switch (m_selectionBehavior) { case SELECTION_AA_BBOX: drawBB(context.bbDefaultCol); break; case SELECTION_FIT_BBOX: { ccGLMatrix trans; ccBBox box = getFitBB(trans); if (box.isValid()) { glMatrixMode(GL_MODELVIEW); glPushMatrix(); glMultMatrixf(trans.data()); box.draw(context.bbDefaultCol); glPopMatrix(); } } break; case SELECTION_IGNORED: break; default: assert(false); } } if (draw3D && glTransEnabled) glPopMatrix(); }