void PointHandleHighlightFigure::render(Vbo& vbo, RenderContext& context) {
            float factor = context.camera().distanceTo(m_position) * m_scalingFactor;
            
            Mat4f billboardMatrix = context.camera().billboardMatrix();
            Mat4f matrix = Mat4f::Identity;
            matrix.translate(m_position);
            matrix *= billboardMatrix;
            matrix.scale(Vec3f(factor, factor, 0.0f));
            ApplyMatrix applyBillboard(context.transformation(), matrix);

            ActivateShader shader(context.shaderManager(), Shaders::HandleShader);
            shader.currentShader().setUniformVariable("Color", m_color);
            
            CircleFigure circle(Axis::AZ, 0.0f, 2.0f * Math::Pi, 2.0f * m_radius, 16, false);
            circle.render(vbo, context);
        }
        void DefaultPointHandleRenderer::render(Vbo& vbo, RenderContext& context) {
            const Vec4f::List& positionList = positions();
            if (positionList.empty())
                return;

            SetVboState activateVbo(vbo, Vbo::VboActive);
            
            if (m_vertexArray == NULL) {
                Vec3f::List vertices = sphere();
                
                unsigned int vertexCount = static_cast<unsigned int>(vertices.size());
                m_vertexArray = new VertexArray(vbo, GL_TRIANGLES, vertexCount,
                                                Attribute::position3f());
                
                SetVboState mapVbo(vbo, Vbo::VboMapped);
                Vec3f::List::const_iterator vIt, vEnd;
                for (vIt = vertices.begin(), vEnd = vertices.end(); vIt != vEnd; ++vIt) {
                    const Vec3f& vertex = *vIt;
                    m_vertexArray->addAttribute(vertex);
                }
            }
            
            Renderer::ActivateShader shader(context.shaderManager(), Renderer::Shaders::PointHandleShader);
            shader.currentShader().setUniformVariable("Color", color());
            shader.currentShader().setUniformVariable("CameraPosition", context.camera().position());
            shader.currentShader().setUniformVariable("ScalingFactor", scalingFactor());
            shader.currentShader().setUniformVariable("MaximumDistance", maximumDistance());
            
            Vec4f::List::const_iterator pIt, pEnd;
            for (pIt = positionList.begin(), pEnd = positionList.end(); pIt != pEnd; ++pIt) {
                const Vec4f& position = *pIt;
                shader.currentShader().setUniformVariable("Position", position);
                m_vertexArray->render();
            }
        }
Example #3
0
        void Compass::doRender(RenderContext& renderContext) {
            const Camera& camera = renderContext.camera();
            const Camera::Viewport& viewport = camera.unzoomedViewport();
            const int viewWidth = viewport.width;
            const int viewHeight = viewport.height;
            
            const Mat4x4f projection = orthoMatrix(0.0f, 1000.0f, -viewWidth / 2.0f, viewHeight / 2.0f, viewWidth / 2.0f, -viewHeight / 2.0f);
            const Mat4x4f view = viewMatrix(Vec3f::PosY, Vec3f::PosZ) * translationMatrix(500.0f * Vec3f::PosY);
            const ReplaceTransformation ortho(renderContext.transformation(), projection, view);
            
            const Mat4x4f compassTransformation = translationMatrix(Vec3f(-viewWidth / 2.0f + 55.0f, 0.0f, -viewHeight / 2.0f + 55.0f)) * scalingMatrix<4>(2.0f);
            const MultiplyModelMatrix compass(renderContext.transformation(), compassTransformation);
            const Mat4x4f cameraTransformation = cameraRotationMatrix(camera);

            glAssert(glClear(GL_DEPTH_BUFFER_BIT));
            renderBackground(renderContext);
            glAssert(glClear(GL_DEPTH_BUFFER_BIT));
            doRenderCompass(renderContext, cameraTransformation);
        }
 void InstancedPointHandleRenderer::render(Vbo& vbo, RenderContext& context) {
     SetVboState activateVbo(vbo, Vbo::VboActive);
     
     if (!valid()) {
         delete m_vertexArray;
         m_vertexArray = NULL;
         
         const Vec4f::List& positionList = positions();
         
         if (!positionList.empty()) {
             Vec3f::List vertices = sphere();
             
             unsigned int vertexCount = static_cast<unsigned int>(vertices.size());
             unsigned int instanceCount = static_cast<unsigned int>(positionList.size());
             m_vertexArray = new InstancedVertexArray(vbo, GL_TRIANGLES, vertexCount, instanceCount,
                                                      Attribute::position3f());
             
             SetVboState mapVbo(vbo, Vbo::VboMapped);
             Vec3f::List::iterator it, end;
             for (it = vertices.begin(), end = vertices.end(); it != end; ++it)
                 m_vertexArray->addAttribute(*it);
             
             m_vertexArray->addAttributeArray("position", positionList);
         }
         validate();
     }
     
     if (m_vertexArray != NULL) {
         Renderer::ActivateShader shader(context.shaderManager(), Renderer::Shaders::InstancedPointHandleShader);
         shader.currentShader().setUniformVariable("Color", color());
         shader.currentShader().setUniformVariable("CameraPosition", context.camera().position());
         shader.currentShader().setUniformVariable("ScalingFactor", scalingFactor());
         shader.currentShader().setUniformVariable("MaximumDistance", maximumDistance());
         m_vertexArray->render(shader.currentShader());
     }
 }
Example #5
0
        void EntityLinkDecorator::render(Vbo& vbo, RenderContext& context) {
            if (context.viewOptions().linkDisplayMode() == View::ViewOptions::LinkDisplayNone)
                return;

            const Model::EntityList& entities = map().entities();
            if (entities.empty())
                return;

            SetVboState activateVbo(vbo, Vbo::VboActive);
            
            if (m_doRebuild) {
                delete m_vertexArray;
                m_vertexArray = NULL;
                m_doRebuild = false;

                // for keeping track of which entities have already been visited by the link-gathering algorithm - should this be part of each entity instead ?
                Model::EntitySet visitedEntities;

                Vec4f::List vertsLocal; // links directly connected to a selected entity
                Vec4f::List vertsContext; // links not directly connected, but in the same context
                Vec4f::List vertsUnrelated; // links not related to the current selection

                Model::EntityList::const_iterator it, end;

                // first pass, outputs local or local+context links
                for (it = entities.begin(), end = entities.end(); it != end; ++it) {
                    Model::Entity& entity = **it;

                    if (entity.selected()) {
                        if (context.viewOptions().linkDisplayMode() == View::ViewOptions::LinkDisplayLocal) {
                            gatherLinksLocal(vertsLocal, context, entity);
                        } else {
                            gatherLinks(vertsLocal, vertsContext, context, entity, visitedEntities);
                        }
                    }
                }

                // second pass, only used in "display all" mode, outputs target links of entities the first pass didn't visit
                if (context.viewOptions().linkDisplayMode() == View::ViewOptions::LinkDisplayAll) {
                    Model::EntitySet::const_iterator vIt;
                    for (it = entities.begin(), end = entities.end(); it != end; ++it) {
                        Model::Entity& entity = **it;
                        vIt = visitedEntities.lower_bound( &entity );

                        if( *vIt != &entity )
                            gatherLinksUnrelated(vertsUnrelated, context, entity);
                    }
                }

                unsigned int vertexCount = static_cast<unsigned int>(vertsLocal.size() + vertsContext.size() + vertsUnrelated.size());
                if (vertexCount == 0)
                    return;
                
                //FIXME : doesn't need to be a color4f at the moment
                m_vertexArray = new VertexArray(vbo, GL_LINES, vertexCount, Attribute::position3f(), Attribute::color4f(), 0);
                
                SetVboState mapVbo(vbo, Vbo::VboMapped);

                // draw order : unrelated -> context -> local
                // vertData.y sets the type of link for the shader ( 0 = unrelated, 0.5 = context, 1.0 = local )
                Vec4f vertData(1.0f);

                vertData.y = 0.0f;
                for (int i = 0; i != vertsUnrelated.size(); ++i ) {
                    vertData.x = vertsUnrelated[i].w;
                    m_vertexArray->addAttribute(Vec3f(vertsUnrelated[i].x, vertsUnrelated[i].y, vertsUnrelated[i].z));
                    m_vertexArray->addAttribute(vertData);
                }
                vertData.y = 0.5f;
                for (int i = 0; i != vertsContext.size(); ++i) {
                    vertData.x = vertsContext[i].w;
                    m_vertexArray->addAttribute(Vec3f(vertsContext[i].x, vertsContext[i].y, vertsContext[i].z));
                    m_vertexArray->addAttribute(vertData);
                }
                vertData.y = 1.0f;
                for (int i = 0; i != vertsLocal.size(); ++i) {
                    vertData.x = vertsLocal[i].w;
                    m_vertexArray->addAttribute(Vec3f(vertsLocal[i].x, vertsLocal[i].y, vertsLocal[i].z));
                    m_vertexArray->addAttribute(vertData);
                }

                m_valid = true;
            }

            if (!m_valid || m_vertexArray == NULL)
                return;

            ActivateShader shader(context.shaderManager(), Shaders::EntityLinkShader );
            shader.currentShader().setUniformVariable("CameraPosition", context.camera().position());
            //shader.currentShader().setUniformVariable("Color", m_color); // unused at the moment, make color view-prefs for the different types of links ?
            shader.currentShader().setUniformVariable("Occluded", 1.0f);

            // render the "occluded" portion without depth-test
            glLineWidth(2.0f);
            glDepthMask(GL_FALSE);
            glDisable(GL_DEPTH_TEST);

            m_vertexArray->render();

            shader.currentShader().setUniformVariable("Occluded", 0.0f);
            glEnable(GL_DEPTH_TEST);

            m_vertexArray->render();

            glDepthMask(GL_TRUE);
            glLineWidth(1.0f);
        }