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();
}
