quadrics.java

JAVA3D矩陈的相关类

                    gbuf.vertex3d(px*radius, qy, pz*radius);
                    
                    gbuf.normal3d(px*sign, 0.0, pz*sign);
                    if (texCoordYUp) {
                        gbuf.texCoord2d(s, 1.0 - t);                        
                    }
                    else {
                        gbuf.texCoord2d(s, t);
                    }
                    gbuf.vertex3d(px*radius, py, pz*radius);
                    
                    s += du;
                }
                
            }
            s = 0.0;
            t += dv;
            py += dy;
        }
        
        gbuf.end();
        
        return gbuf;
    }
    
    // new coneBody method to remove transform in the Cone primitive
    // and to optimize by using triangle strip
    GeomBuffer coneBody(double bottom, double top, double bottomR, double topR,
            int xdiv, int ydiv, double dv, boolean outside, boolean texCoordYUp) {
        
        double r, sign;
        
        if (outside) sign = 1.0;
        else sign = -1.0;
        
        // compute the deltas
        double dtheta = 2.0*Math.PI/(double)xdiv;
        double dr = (topR-bottomR)/(double)ydiv;
        double height = top-bottom;
        double dy = height/(double)ydiv;
        double ynormal = (bottomR-topR)/height;
        double du = 1.0/(double)xdiv;
// 	double dv = 1.0/(double)(ydiv+1);
        
        GeomBuffer gbuf = new GeomBuffer(ydiv*2*(xdiv+1));
        
        double s = 0.0, t = 0.0;
        double px, pz, qx, qz;
        double py = bottom;
        double qy;
        r = bottomR;
        
        gbuf.begin(GeomBuffer.QUAD_STRIP);
        
        for (int i = 0; i < ydiv; i++) {
            qy = py+dy;
            if (outside) {
                px = Math.cos(xdiv*dtheta - Math.PI/2.0);
                pz = Math.sin(xdiv*dtheta - Math.PI/2.0);
                qx = Math.cos((xdiv-1)*dtheta - Math.PI/2.0);
                qz = Math.sin((xdiv-1)*dtheta - Math.PI/2.0);
                
                // vert2
                gbuf.normal3d(px*sign, ynormal*sign, pz*sign);
                if (texCoordYUp) {
                    gbuf.texCoord2d(s, 1.0 - (t + dv));                    
                }
                else {
                    gbuf.texCoord2d(s, t+dv);
                }
                gbuf.vertex3d(px*(r+dr), qy, pz*(r+dr));
                
                // vert1
                gbuf.normal3d(px*sign, ynormal*sign, pz*sign);
                if (texCoordYUp) {
                    gbuf.texCoord2d(s, 1.0 - t);                
                }
                else {
                    gbuf.texCoord2d(s, t);
                }
                gbuf.vertex3d(px*r, py, pz*r);
                
                // vert4
                gbuf.normal3d(qx*sign, ynormal*sign, qz*sign);
                if (texCoordYUp) {
                    gbuf.texCoord2d(s+du, 1.0 - (t + dv));                    
                }
                else {
                    gbuf.texCoord2d(s+du, t+dv);
                }
                gbuf.vertex3d(qx*(r+dr), qy, qz*(r+dr));
                
                // vert3
                gbuf.normal3d(qx*sign, ynormal*sign, qz*sign);
                if (texCoordYUp) {
                    gbuf.texCoord2d(s+du, 1.0 - t);
                }
                else {
                    gbuf.texCoord2d(s+du, t);
                }
                gbuf.vertex3d(qx*r, py, qz*r);
                
                s += (du*2.0);
                
                for (int j = xdiv-2; j >= 0; j--) {
                    px = Math.cos(j*dtheta - Math.PI/2.0);
                    pz = Math.sin(j*dtheta - Math.PI/2.0);
                    
                    // vert 6
                    gbuf.normal3d(px*sign, ynormal*sign, pz*sign);
                    if (texCoordYUp) {
                        gbuf.texCoord2d(s, 1.0 - (t + dv));
                    } else {
                        gbuf.texCoord2d(s, t+dv);
                    }
                    gbuf.vertex3d(px*(r+dr), qy, pz*(r+dr));
                    
                    // vert 5
                    gbuf.normal3d(px*sign, ynormal*sign, pz*sign);
                    if (texCoordYUp) {
                        gbuf.texCoord2d(s, 1.0 - t);                        
                    }
                    else {
                        gbuf.texCoord2d(s, t);
                    }
                    gbuf.vertex3d(px*r, py, pz*r);
                    
                    s += du;
                }
            } else {
                px = Math.cos(-Math.PI/2.0);
                pz = Math.sin(-Math.PI/2.0);
                qx = Math.cos(dtheta - Math.PI/2.0);
                qz = Math.sin(dtheta - Math.PI/2.0);
                
                // vert1
                gbuf.normal3d(px*sign, ynormal*sign, pz*sign);
                if (texCoordYUp) {
                   gbuf.texCoord2d(s, 1.0 - (t + dv));                    
                }
                else {
                    gbuf.texCoord2d(s, t+dv);
                }
                gbuf.vertex3d(px*(r+dr), qy, pz*(r+dr));
                
                gbuf.normal3d(px*sign, ynormal*sign, pz*sign);
                if (texCoordYUp) {
                    gbuf.texCoord2d(s, 1.0 - t);                    
                }
                else {
                    gbuf.texCoord2d(s, t);
                }
                gbuf.vertex3d(px*r, py, pz*r);
                
                gbuf.normal3d(qx*sign, ynormal*sign, qz*sign);
                if (texCoordYUp) {
                    gbuf.texCoord2d(s+du, 1.0 - (t + dv));
                }
                else {
                    gbuf.texCoord2d(s+du, t+dv);
                }
                gbuf.vertex3d(qx*(r+dr), qy, qz*(r+dr));
                
                gbuf.normal3d(qx*sign, ynormal*sign, qz*sign);
                if (texCoordYUp) {                
                    gbuf.texCoord2d(s+du, 1.0 - t);
                }
                else {
                    gbuf.texCoord2d(s+du, t);                    
                }
                gbuf.vertex3d(qx*r, py, qz*r);
                
                s += (du*2.0);
                
                for (int j = 2; j <= xdiv; j++) {
                    px = Math.cos(j*dtheta - Math.PI/2.0);
                    pz = Math.sin(j*dtheta - Math.PI/2.0);
                    
                    gbuf.normal3d(px*sign, ynormal*sign, pz*sign);
                    if (texCoordYUp) {
                        gbuf.texCoord2d(s, 1.0 - (t + dv));                        
                    }
                    else {
                        gbuf.texCoord2d(s, t+dv);
                    }
                    gbuf.vertex3d(px*(r+dr), qy, pz*(r+dr));
                    
                    gbuf.normal3d(px*sign, ynormal*sign, pz*sign);
                    if (texCoordYUp) {
                        gbuf.texCoord2d(s, 1.0 - t);
                    }
                    else {
                        gbuf.texCoord2d(s, t);
                    }
                    gbuf.vertex3d(px*r, py, pz*r);
                    
                    s += du;
                }
            }
            s = 0.0;
            t += dv;
            py += dy;
            r += dr;
        }
        gbuf.end();
        
        return gbuf;
    }
    
    // new coneTop method to remove transforms in the cone code
    GeomBuffer coneTop(double bottom, double radius, double height,
            int xdiv,double t, boolean outside, boolean texCoordYUp) {
        
        double sign;
        
        if (outside) sign = 1.0;
        else sign = -1.0;
        
        // compute the deltas
        double dtheta = 2.0*Math.PI/(double)xdiv;
        double ynormal = radius/height;
        double du = 1.0/(double)xdiv;
        double top = bottom + height;
        
        // initialize the geometry buffer
        GeomBuffer gbuf = new GeomBuffer(xdiv + 2);
        gbuf.begin(GeomBuffer.TRIANGLE_FAN);
        
        // add the tip, which is the center of the fan
        gbuf.normal3d(0.0, ynormal*sign, 0.0);
        if (texCoordYUp) {
            gbuf.texCoord2d(.5, 0.0);            
        }
        else {
            gbuf.texCoord2d(.5, 1.0);
        }
        gbuf.vertex3d(0.0, top, 0.0);
        
        // go around the circle and add the rest of the fan
        double s = 0.0;
        double px, pz;
        if (outside) {
            for (int i = xdiv; i >= 0; i--) {
                px = Math.cos(i*dtheta - Math.PI/2.0);
                pz = Math.sin(i*dtheta - Math.PI/2.0);
                gbuf.normal3d(px*sign, ynormal*sign, pz*sign);
                if (texCoordYUp) {
                    gbuf.texCoord2d(s, 1.0 - t);                    
                } else {
                    gbuf.texCoord2d(s, t);
                }
                gbuf.vertex3d(px*radius, bottom, pz*radius);
                
                s += du;
            }
        } else {
            for (int i = 0; i <= xdiv; i++) {
                px = Math.cos(i*dtheta - Math.PI/2.0);
                pz = Math.sin(i*dtheta - Math.PI/2.0);
                gbuf.normal3d(px*sign, ynormal*sign, pz*sign);
                if (texCoordYUp) {
                    gbuf.texCoord2d(s, 1.0 - t);
                } else {
                    gbuf.texCoord2d(s, t);
                }
                gbuf.vertex3d(px*radius, bottom, pz*radius);
                s += du;
            }
        }
        gbuf.end();
        return gbuf;
    }
}