Examples with RenderList maspack.render.RenderList used on opensource projects

Example 11 with RenderList

use of maspack.render.RenderList in project artisynth_core by artisynth.

the class MeshColliderTest method displayContacts.

void displayContacts(PolygonalMesh m0, PolygonalMesh m1) {
    final PolygonalMesh mesh0 = m0;
    final PolygonalMesh mesh1 = m1;
    MeshCollider collider = new MeshCollider();
    final ContactInfo info = collider.getContacts(mesh0, mesh1);
    // final ContactInfo info = new ContactInfo(mesh0, mesh1);
    // System.out.println("intersections " + info.intersections.size());
    // System.out.println("regions " + info.regions.size());
    GLViewerFrame frame = new GLViewerFrame("", 512, 512);
    frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
    mesh0.getRenderProps().setDrawEdges(true);
    // mesh0.getRenderProps().setAlpha(0.3);
    mesh1.getRenderProps().setDrawEdges(true);
    // mesh1.getRenderProps().setAlpha(0.3);
    frame.getViewer().addRenderable(mesh0);
    frame.getViewer().addRenderable(mesh1);
    frame.getViewer().addRenderable(new IsRenderable() {

        public int getRenderHints() {
            // TODO Auto-generated method stub
            return 0;
        }

        public void prerender(RenderList list) {
        }

        public void render(Renderer renderer, int flags) {
            renderer.setShading(Shading.NONE);
            if (info != null) {
                renderer.setColor(0, 0, 1);
                renderer.setPointSize(6);
                ArrayList<TriTriIntersection> intersections = info.getIntersections();
                if (intersections != null) {
                    renderer.beginDraw(DrawMode.POINTS);
                    for (TriTriIntersection isect : intersections) {
                        for (Point3d p : isect.points) {
                            renderer.addVertex(p);
                        }
                    }
                    renderer.endDraw();
                }
                renderer.setColor(1, 0, 0);
                renderer.beginDraw(DrawMode.LINES);
                for (ContactPlane region : info.getContactPlanes()) {
                    Point3d avg = new Point3d();
                    int np = 0;
                    for (Point3d rp : region.points) {
                        avg.add(rp);
                        np++;
                    }
                    avg.scale(1.0 / np);
                    renderer.addVertex(avg);
                    avg.add(region.normal);
                    renderer.addVertex(avg);
                }
                renderer.endDraw();
            }
            ;
            // mesh0.getObbtree().render(renderer);
            // mesh1.getObbtree().render(renderer);
            // ////////////////////////////
            // draw mesh numbers
            Vector3d avg0 = new Vector3d();
            Vector3d avg1 = new Vector3d();
            for (Vertex3d v : mesh0.getVertices()) avg0.add(v.pnt);
            avg0.scale(1.0 / mesh0.getVertices().size());
            avg0.add(mesh0.getMeshToWorld().p);
            for (Vertex3d v : mesh1.getVertices()) avg1.add(v.pnt);
            avg1.scale(1.0 / mesh1.getVertices().size());
            avg1.add(mesh1.getMeshToWorld().p);
            // GLUT glut = new GLUT();
            renderer.setColor(1, 1, 1);
            // gl.glRasterPos3d (avg0.x, avg0.y, avg0.z);
            // glut.glutBitmapString (GLUT.BITMAP_HELVETICA_18, "0");
            // gl.glRasterPos3d (avg1.x, avg1.y, avg1.z);
            // glut.glutBitmapString (GLUT.BITMAP_HELVETICA_18, "1");
            // draw mesh normals
            // //////////////////////////////
            renderer.setShading(Shading.FLAT);
        }

        public void updateBounds(Vector3d pmin, Vector3d pmax) {
        // TODO Auto-generated method stub
        }
    });
    frame.getViewer().rerender();
    frame.getViewer().autoFit();
    frame.setVisible(true);
}

Example 12 with RenderList

use of maspack.render.RenderList in project artisynth_core by artisynth.

the class GL2Viewer method doDisplay.

// public boolean isLightingEnabled() {
// return gl.glIsEnabled (GL2.GL_LIGHTING);
// }
private void doDisplay(GLAutoDrawable drawable, int flags) {
    GL2 gl = drawable.getGL().getGL2();
    // updates view matrix
    if (resetViewVolume && autoResizeEnabled) {
        resetViewVolume(gl);
        resetViewVolume = false;
    }
    if (resetViewport && autoViewportEnabled) {
        setViewport(gl, 0, 0, width, height);
        resetViewport = false;
    }
    gl.glClearColor(backgroundColor[0], backgroundColor[1], backgroundColor[2], backgroundColor[3]);
    gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
    // updates view matrix
    // RigidTransform3d X = new RigidTransform3d();
    // X.invert (XEyeToWorld);
    // enter view matrix
    // GLSupport.transformToGLMatrix (GLMatrix, X);
    // GLSupport.transformToGLMatrix (GLMatrix, viewMatrix);
    // gl.glLoadMatrixd(GLMatrix, 0);
    // viewMatrixValidP = true;  // view matrix now "committed"
    // update all state, including matrices
    maybeUpdateState(gl);
    setupLights(gl);
    if (!isSelecting()) {
        if (gridVisible) {
            myGrid.render(this, flags);
        }
        if (axisLength > 0) {
            if (solidAxes) {
                drawSolidAxes(null, axisLength, axisLength / 50.0, false);
            } else {
                drawAxes(gl, axisLength);
            }
        }
        // not clipped by the clipping plane
        for (Dragger3d dragger : myDraggers) {
            dragger.render(this, 0);
        }
        if (myDrawTool != null) {
            myDrawTool.render(this, 0);
        }
        for (GLClipPlane cp : myClipPlanes) {
            cp.render(this, flags);
        }
    }
    // enable clip planes
    // update matrices before activating clip planes
    maybeUpdateState(gl);
    int nclips = 0;
    int clipIdx = GL2.GL_CLIP_PLANE0;
    for (GLClipPlane cp : myClipPlanes) {
        if (cp.isClippingEnabled()) {
            cp.getPlaneValues(myClipPlaneValues);
            myClipPlaneValues[3] += cp.getOffset();
            gl.glClipPlane(clipIdx, myClipPlaneValues, 0);
            gl.glEnable(clipIdx);
            clipIdx++;
            nclips++;
            if (nclips >= maxClipPlanes) {
                break;
            }
            if (cp.isSlicingEnabled()) {
                myClipPlaneValues[0] = -myClipPlaneValues[0];
                myClipPlaneValues[1] = -myClipPlaneValues[1];
                myClipPlaneValues[2] = -myClipPlaneValues[2];
                myClipPlaneValues[3] = -myClipPlaneValues[3] + 2 * cp.getOffset();
                gl.glClipPlane(clipIdx, myClipPlaneValues, 0);
                gl.glEnable(clipIdx);
                clipIdx++;
                nclips++;
                if (nclips >= maxClipPlanes) {
                    break;
                }
            }
        }
    }
    if (!isSelecting()) {
        setFrontColor(DEFAULT_MATERIAL_COLOR);
    }
    int qid = 0;
    synchronized (myInternalRenderList) {
        qid = myInternalRenderList.renderOpaque(this, qid, flags);
    }
    RenderList elist = myExternalRenderList;
    if (elist != null) {
        synchronized (elist) {
            qid = elist.renderOpaque(this, qid, flags);
        }
    }
    if (hasTransparent3d()) {
        if (!isSelecting()) {
            enableTransparency();
        }
        synchronized (myInternalRenderList) {
            qid = myInternalRenderList.renderTransparent(this, qid, flags);
        }
        if (elist != null) {
            synchronized (elist) {
                qid = elist.renderTransparent(this, qid, flags);
            }
        }
        if (!isSelecting()) {
            disableTransparency();
        }
    }
    // disable clipping planes
    for (int i = GL2.GL_CLIP_PLANE0; i < clipIdx; ++i) {
        gl.glDisable(i);
    }
    // Draw 2D objects
    if (has2d()) {
        begin2DRendering(width, height);
        try {
            synchronized (myInternalRenderList) {
                qid = myInternalRenderList.renderOpaque2d(this, qid, 0);
            }
            if (elist != null) {
                synchronized (elist) {
                    qid = elist.renderOpaque2d(this, qid, 0);
                }
            }
            if (hasTransparent2d()) {
                if (!isSelecting()) {
                    enableTransparency();
                }
                synchronized (myInternalRenderList) {
                    qid = myInternalRenderList.renderTransparent2d(this, qid, 0);
                }
                if (elist != null) {
                    synchronized (elist) {
                        qid = elist.renderTransparent2d(this, qid, 0);
                    }
                }
                if (!isSelecting()) {
                    disableTransparency();
                }
            }
        } finally {
            // methods throws and exception
            if (isTransparencyEnabled()) {
                disableTransparency();
            }
            end2DRendering();
        }
    }
    if (!isSelecting()) {
        if (myDragBox != null) {
            drawDragBox(gl);
        }
        if (myEllipticCursorActive) {
            Point cursor = myMouseHandler.getCurrentCursor();
            if (cursor != null) {
                drawEllipticCursor(gl, cursor);
            }
        }
    }
    // trigger update of state (required for GLJPanel, which relies on
    // transparency to be off)
    maybeUpdateState(gl);
    gl.glFlush();
}