joglpolyhedralboundedsolidrenderer.java

基于java的3d开发库。对坐java3d的朋友有很大的帮助。

//===========================================================================
//=-------------------------------------------------------------------------=
//= Module history:                                                         =
//= - January 3 2007 - Oscar Chavarro: Original base version                =
//=-------------------------------------------------------------------------=
//= References:                                                             =
//= [MANT1988] Mantyla Martti. "An Introduction To Solid Modeling",         =
//=     Computer Science Press, 1988.                                       =
//===========================================================================

package vsdk.toolkit.render.jogl;

// JOGL clases
import javax.media.opengl.GL;
import javax.media.opengl.glu.GLU;
import javax.media.opengl.glu.GLUtessellator;
import com.sun.opengl.cg.CgGL;
import com.sun.opengl.cg.CGparameter;

// VitralSDK classes
import vsdk.toolkit.common.ColorRgb;
import vsdk.toolkit.common.Vector3D;
import vsdk.toolkit.common.Vertex;
import vsdk.toolkit.common.VSDK;
import vsdk.toolkit.common.RendererConfiguration;
import vsdk.toolkit.environment.Camera;
import vsdk.toolkit.environment.geometry.InfinitePlane;
import vsdk.toolkit.environment.geometry.PolyhedralBoundedSolid;
import vsdk.toolkit.environment.geometry.polyhedralBoundedSolidNodes._PolyhedralBoundedSolidFace;
import vsdk.toolkit.environment.geometry.polyhedralBoundedSolidNodes._PolyhedralBoundedSolidLoop;
import vsdk.toolkit.environment.geometry.polyhedralBoundedSolidNodes._PolyhedralBoundedSolidHalfEdge;
import vsdk.toolkit.environment.geometry.polyhedralBoundedSolidNodes._PolyhedralBoundedSolidEdge;
import vsdk.toolkit.environment.geometry.polyhedralBoundedSolidNodes._PolyhedralBoundedSolidVertex;

public class JoglPolyhedralBoundedSolidRenderer extends JoglRenderer
{
    private static GLU glu;
    private static _JoglPolygonTesselatorRoutines tesselatorProcessor;
    static {
        glu = null;
        tesselatorProcessor = null;
    }

    private static double
    curveFactor(double param, double factor)
    {
        double percent = param/factor;
        return 0.1 * factor * Math.sin(0.5*percent*Math.PI);
    }

    private static void
    drawHalfEdge(GL gl, _PolyhedralBoundedSolidHalfEdge he, 
                 Vector3D startP, Vector3D endP, InfinitePlane loopPlane)
    {
        // Algorithm parameters
        int N = 10;

        // Local variables
        Vector3D u, v;
        double factor, t;
        int i;
        Vector3D P, n;

        n = loopPlane.getNormal();
        v = endP.substract(startP);
        factor = v.length()/2;
        v.normalize();
        u = v.crossProduct(n);
        double delta = factor/((double)N);

        gl.glPushMatrix();

        gl.glBegin(gl.GL_LINES);
            for ( i = 0, t = 0; i < N; i++, t += delta ) {
                P = startP.add(v.multiply(t).add(u.multiply(curveFactor(t, factor))));
                gl.glVertex3d(P.x, P.y, P.z);
                P = startP.add(v.multiply(t+delta).add(u.multiply(curveFactor(t+delta, factor))));
                gl.glVertex3d(P.x, P.y, P.z);
            }
        gl.glEnd();
        P = startP.add(v.multiply(factor).add(u.multiply(0)));
        Vector3D Pi = u.multiply(factor*0.1);
        gl.glTranslated(Pi.x, Pi.y, Pi.z);

        gl.glBegin(gl.GL_LINES);
            gl.glVertex3d(P.x, P.y, P.z);
            P = startP.add(v.multiply(factor*0.9).add(u.multiply(factor*0.05)));
            gl.glVertex3d(P.x, P.y, P.z);

            P = startP.add(v.multiply(factor).add(u.multiply(0)));
            gl.glVertex3d(P.x, P.y, P.z);
            P = startP.add(v.multiply(factor*0.9).add(u.multiply(-factor*0.05)));
            gl.glVertex3d(P.x, P.y, P.z);

        gl.glEnd();

        gl.glPopMatrix();
    }

    private static void setColor(GL gl, int i)
    {
        double r = 0.0, g = 0.0, b = 0.0;
        switch ( i%8 ) {
          case 0:  r = 1; g = 0; b = 0; break;
          case 1:  r = 0; g = 1; b = 0; break;
          case 2:  r = 0; g = 0; b = 1; break;
          case 3:  r = 0; g = 1; b = 1; break;
          case 4:  r = 1; g = 0; b = 1; break;
          case 5:  r = 0.5; g = 0; b = 0; break;
          case 6:  r = 0; g = 0.5; b = 0; break;
          default: r = .6; g = .5; b = .4; break;
        }
        gl.glColor3d(r, g, b);
    }

    private static void
    drawPoints(GL gl, PolyhedralBoundedSolid solid)
    {
        ColorRgb c;

        gl.glDisable(gl.GL_LIGHTING);
        gl.glDisable(gl.GL_TEXTURE_2D);
        // Warning: Change with configured color for point
        gl.glColor3d(1, 0, 0);
        gl.glPointSize(2.0f);

        int i;
        for ( i = 0; i < solid.verticesList.size(); i++ ) {
            _PolyhedralBoundedSolidVertex v = solid.verticesList.get(i);
            Vector3D p = v.position;

            c = v.debugColor;
            if ( c.r >= 1-VSDK.EPSILON &&
                 c.g <= VSDK.EPSILON &&
                 c.b <= VSDK.EPSILON ) {
                gl.glPointSize(5.0f);
            }
            else {
                gl.glPointSize(15.0f);
            }
            gl.glColor3d(c.r, c.g, c.b);

            gl.glBegin(gl.GL_POINTS);
                gl.glVertex3d(p.x, p.y, p.z);
            gl.glEnd();
        }
    }

    private static void
    drawEdges(GL gl, PolyhedralBoundedSolid solid)
    {
        int i;
        ColorRgb c;

        gl.glDisable(gl.GL_LIGHTING);
        gl.glDisable(gl.GL_CULL_FACE);
        gl.glShadeModel(gl.GL_FLAT);

        gl.glEnable(gl.GL_POLYGON_OFFSET_LINE);
        gl.glPolygonOffset(-0.5f, 1.0f);

        // Warning: Change with configured color for borders
        gl.glLineWidth(1.5f);
        gl.glColor3d(1, 1, 1);

        gl.glDisable(gl.GL_TEXTURE_2D);

        for ( i = 0; i < solid.edgesList.size(); i++ ) {
            _PolyhedralBoundedSolidEdge e = solid.edgesList.get(i);
            int start, end;
            start = e.getStartingVertexId();
            end = e.getEndingVertexId();

            c = e.debugColor;
            if ( c.r >= 1-VSDK.EPSILON &&
                 c.g >= 1-VSDK.EPSILON &&
                 c.b >= 1-VSDK.EPSILON ) {
                gl.glLineWidth(1.5f);
            }
            else {
                gl.glLineWidth(6f);
            }
            gl.glColor3d(c.r, c.g, c.b);

            if ( start >= 0 && end >= 0 ) {
                Vector3D startPosition;
                Vector3D endPosition;
                startPosition = e.rightHalf.startingVertex.position;
                endPosition = e.leftHalf.startingVertex.position;
                if ( startPosition != null && endPosition != null ) {
                    gl.glBegin(gl.GL_LINES);
                    gl.glVertex3d(startPosition.x, startPosition.y, 
                                  startPosition.z);
                    gl.glVertex3d(endPosition.x, endPosition.y, endPosition.z);
                    gl.glEnd();
                }
            }
        }

    }

    public static void
    drawDebugEdges(GL gl, PolyhedralBoundedSolid solid, Camera c, int edgeIndex)
    {
        int i;

        gl.glPushAttrib(gl.GL_DEPTH_TEST);
        gl.glDisable(gl.GL_DEPTH_TEST);

        gl.glDisable(gl.GL_LIGHTING);
        gl.glDisable(gl.GL_CULL_FACE);
        gl.glShadeModel(gl.GL_FLAT);

        gl.glEnable(gl.GL_POLYGON_OFFSET_LINE);
        gl.glPolygonOffset(-0.5f, 0.0f);
        gl.glDisable(gl.GL_TEXTURE_2D);

        _PolyhedralBoundedSolidFace face1;
        _PolyhedralBoundedSolidFace face2;
        boolean f1, f2;

        for ( i = 0; edgeIndex >= -1 && i < solid.edgesList.size(); i++ ) {
            _PolyhedralBoundedSolidEdge e = solid.edgesList.get(i);

            if ( i != edgeIndex && edgeIndex > -1 ) {
                continue;
            }

            int start, end;
            start = e.getStartingVertexId();
            end = e.getEndingVertexId();
            if ( start >= 0 && end >= 0 ) {
                Vector3D startPosition;
                Vector3D endPosition;
                Vector3D middle;
                Vector3D n;

                startPosition = e.rightHalf.startingVertex.position;
                endPosition = e.leftHalf.startingVertex.position;
                if ( startPosition != null && endPosition != null ) {
                    //--------------------------------------------------------
                    face1 = e.leftHalf.parentLoop.parentFace;
                    face2 = e.rightHalf.parentLoop.parentFace;
                    f1 = face1.isVisibleFrom(c) >= 0;
                    f2 = face2.isVisibleFrom(c) >= 0;

/*
                    System.out.println("Edge [" + i + "]:");
                    if ( f1 ) {
                        System.out.println("  - Face 1 IS visible. (normal " +
                            face1.containingPlane.getNormal() + ")");
                    }
                    else {
                        System.out.println("  - Face 1 is NOT visible. (normal " +
                            face1.containingPlane.getNormal() + ")");
                    }
                    if ( f2 ) {
                        System.out.println("  - Face 2 IS visible. (normal " +
                            face2.containingPlane.getNormal() + ")");
                    }
                    else {
                        System.out.println("  - Face 2 is NOT visible. (normal " +
                            face2.containingPlane.getNormal() + ")");
                    }
*/

                    //--------------------------------------------------------
                    if ( !f1 && !f2 ) {
                        // Totally hidden lines
                        gl.glLineWidth(1.0f);
                        gl.glColor3d(0, 0, 0);
                    }
                    else if ( f1 && !f2 || !f1 && f2 ) {
                        // Contour lines
                        gl.glLineWidth(4.0f);
                        gl.glColor3d(1, 0, 0);
                    }
                    else {
                        // Visible non contour lines
                        gl.glLineWidth(1.0f);
                        gl.glColor3d(0.5, 0, 0);
                    }

                    //--------------------------------------------------------
                    gl.glBegin(gl.GL_LINES);
                    gl.glVertex3d(startPosition.x, startPosition.y, 
                                  startPosition.z);
                    gl.glVertex3d(endPosition.x, endPosition.y, endPosition.z);
                    gl.glEnd();

                    //--------------------------------------------------------
                    if ( edgeIndex > -1 ) {
                        middle = startPosition.add(endPosition).multiply(0.5);
                        n = face1.containingPlane.getNormal();
                        gl.glLineWidth(1.0f);
                        gl.glColor3d(1, 1, 0);
                        gl.glBegin(gl.GL_LINES);
                            gl.glVertex3d(middle.x, middle.y, middle.z);
                            gl.glVertex3d(middle.x + n.x/10,
                                          middle.y + n.y/10,
                                          middle.z + n.z/10);
                        gl.glEnd();
                        n = face2.containingPlane.getNormal();
                        gl.glLineWidth(1.0f);
                        gl.glColor3d(0, 1, 1);
                        gl.glBegin(gl.GL_LINES);
                            gl.glVertex3d(middle.x, middle.y, middle.z);
                            gl.glVertex3d(middle.x + n.x/10,
                                          middle.y + n.y/10,
                                          middle.z + n.z/10);
                        gl.glEnd();
                    }
                }
            }
        }
        gl.glPopAttrib();

    }

    private static void
    drawVertexNormals(GL gl, PolyhedralBoundedSolid solid)
    {
        gl.glDisable(gl.GL_LIGHTING);
        gl.glDisable(gl.GL_TEXTURE_2D);
        // Warning: Change with configured color for vertex normals
        gl.glColor3d(1, 1, 0);
        gl.glLineWidth(1.0f);
        int i, j;

        //-----------------------------------------------------------------
        Vector3D p0 = null, n;
        Vertex vertex = new Vertex(p0);

        gl.glBegin(gl.GL_LINES);
        for ( i = 0; i < solid.polygonsList.size(); i++ ) {
            // Logic
            _PolyhedralBoundedSolidFace face = solid.polygonsList.get(i);
            if ( face.containingPlane != null ) {
                vertex.normal = face.containingPlane.getNormal();
            }
            else {
                continue;
            }