diff options
Diffstat (limited to 'src/classes/com/sun')
55 files changed, 7665 insertions, 3595 deletions
diff --git a/src/classes/com/sun/opengl/impl/nurbs/Arc.java b/src/classes/com/sun/opengl/impl/nurbs/Arc.java new file mode 100755 index 000000000..717edbb33 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Arc.java @@ -0,0 +1,258 @@ +package com.sun.opengl.impl.nurbs; + +/* +** License Applicability. Except to the extent portions of this file are +** made subject to an alternative license as permitted in the SGI Free +** Software License B, Version 1.1 (the "License"), the contents of this +** file are subject only to the provisions of the License. You may not use +** this file except in compliance with the License. You may obtain a copy +** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 +** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: +** +** http://oss.sgi.com/projects/FreeB +** +** Note that, as provided in the License, the Software is distributed on an +** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS +** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND +** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A +** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. +** +** Original Code. The Original Code is: OpenGL Sample Implementation, +** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, +** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. +** Copyright in any portions created by third parties is as indicated +** elsewhere herein. All Rights Reserved. +** +** Additional Notice Provisions: The application programming interfaces +** established by SGI in conjunction with the Original Code are The +** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released +** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version +** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X +** Window System(R) (Version 1.3), released October 19, 1998. This software +** was created using the OpenGL(R) version 1.2.1 Sample Implementation +** published by SGI, but has not been independently verified as being +** compliant with the OpenGL(R) version 1.2.1 Specification. +*/ + +/** + * Trimming arc + * @author Tomas Hrasky + * + */ +class Arc { + /** + * Corresponding picewise-linear arc + */ + public PwlArc pwlArc; + + /** + * Arc type + */ + private long type; + + /** + * Arc link in linked list + */ + public Arc link; + + /** + * Previous arc + */ + Arc prev; + + /** + * Next arc + */ + Arc next; + + /** + * Corresponding berizer type arc + */ + private BezierArc bezierArc; + + /** + * Makes new arc at specified side + * + * @param side + * which side doeas this arc form + */ + public Arc(int side) { + bezierArc = null; + pwlArc = null; + type = 0; + setside(side); + // nuid=_nuid + } + + /** + * Sets side the arc is at + * + * @param side + * arc side + */ + private void setside(int side) { + // DONE + clearside(); + type |= side << 8; + } + + /** + * Unsets side + */ + private void clearside() { + // DONE + type &= ~(0x7 << 8); + } + + // this one replaces enum arc_side + /** + * Side not specified + */ + public static final int ARC_NONE = 0; + + /** + * Arc on right + */ + public static final int ARC_RIGHT = 1; + + /** + * Arc on top + */ + public static final int ARC_TOP = 2; + + /** + * Arc on left + */ + public static final int ARC_LEFT = 3; + + /** + * Arc on bottom + */ + public static final int ARC_BOTTOM = 4; + + /** + * Bezier type flag + */ + private static final long BEZIER_TAG = 1 << 13; + + /** + * Arc type flag + */ + private static final long ARC_TAG = 1 << 3; + + /** + * Tail type tag + */ + private static final long TAIL_TAG = 1 << 6; + + /** + * Appends arc to the list + * + * @param jarc + * arc to be append + * @return this + */ + public Arc append(Arc jarc) { + // DONE + if (jarc != null) { + next = jarc.next; + prev = jarc; + next.prev = this; + prev.next = this; + } else { + next = this; + prev = this; + } + + return this; + } + + /** + * Unused + * + * @return true + */ + public boolean check() { + return true; + } + + /** + * Sets bezier type flag + */ + public void setbezier() { + // DONE + type |= BEZIER_TAG; + + } + + /** + * Returns tail of linked list coords + * + * @return tail coords + */ + public float[] tail() { + // DONE + return pwlArc.pts[0].param; + } + + /** + * Returns head of linked list coords + * + * @return head coords + */ + public float[] head() { + // DONE + return next.pwlArc.pts[0].param; + } + + /** + * Returns whether arc is marked with arc_tag + * + * @return is arc marked with arc_tag + */ + public boolean ismarked() { + // DONE + return ((type & ARC_TAG) > 0) ? true : false; + } + + /** + * Cleans arc_tag flag + */ + public void clearmark() { + // DONE + type &= (~ARC_TAG); + } + + /** + * Sets arc_tag flag + */ + public void setmark() { + // DONE + type |= ARC_TAG; + } + + /** + * sets tail tag + */ + public void setitail() { + // DONE + type |= TAIL_TAG; + } + + /** + * Returns whether arc is marked tail + * + * @return is tail + */ + public boolean getitail() { + return false; + } + + /** + * Unsets tail tag + */ + public void clearitail() { + // DONE + type &= (~TAIL_TAG); + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/ArcSdirSorter.java b/src/classes/com/sun/opengl/impl/nurbs/ArcSdirSorter.java new file mode 100755 index 000000000..cc420b48c --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/ArcSdirSorter.java @@ -0,0 +1,63 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Class for sorting list of Arcs + * @author Tomas Hrasky + * + */ +class ArcSdirSorter { + + /** + * Makes new ArcSdirSorter with Subdivider + * @param subdivider subdivider + */ + public ArcSdirSorter(Subdivider subdivider) { + //TODO + // System.out.println("TODO arcsdirsorter.constructor"); + } + + /** + * Sorts list of arcs + * @param list arc list to be sorted + * @param count size of list + */ + public void qsort(CArrayOfArcs list, int count) { + // TODO + // System.out.println("TODO arcsdirsorter.qsort"); + } + +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/ArcTdirSorter.java b/src/classes/com/sun/opengl/impl/nurbs/ArcTdirSorter.java new file mode 100755 index 000000000..88b6e3285 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/ArcTdirSorter.java @@ -0,0 +1,60 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Class for sorting list of Arcs + * @author Tomas Hrasky + * + */ +class ArcTdirSorter { + /** + * Makes new ArcSdirSorter with Subdivider + * @param subdivider subdivider + */ + public ArcTdirSorter(Subdivider subdivider) { + // TODO Auto-generated constructor stub + // System.out.println("TODO arcTsorter.konstruktor"); + } + /** + * Sorts list of arcs + * @param list arc list to be sorted + * @param count size of list + */ + public void qsort(CArrayOfArcs list, int count) { + // TODO Auto-generated method stub + // System.out.println("TODO arcTsorter.qsort"); + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/ArcTesselator.java b/src/classes/com/sun/opengl/impl/nurbs/ArcTesselator.java new file mode 100755 index 000000000..61cd969ea --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/ArcTesselator.java @@ -0,0 +1,90 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Class for arc tesselation + * @author Tomas Hrasky + * + */ +class ArcTesselator { + + /** + * Makes given arc an bezier arc + * @param arc arc to work with + * @param s1 minimum s param + * @param s2 maximum s param + * @param t1 minimum t param + * @param t2 maximum s param + */ + public void bezier(Arc arc, float s1, float s2, float t1, float t2) { + // DONE + TrimVertex[] p = new TrimVertex[2]; + p[0] = new TrimVertex(); + p[1] = new TrimVertex(); + arc.pwlArc = new PwlArc(2, p); + p[0].param[0] = s1; + p[0].param[1] = s2; + p[1].param[0] = t1; + p[1].param[1] = t2; + arc.setbezier(); + } + + /** + * Empty method + * @param newright arc to work with + * @param s first tail + * @param t2 second tail + * @param t1 third tail + * @param f stepsize + */ + public void pwl_right(Arc newright, float s, float t1, float t2, float f) { + // TODO Auto-generated method stub + // System.out.println("TODO arctesselator.pwl_right"); + } + + /** + * Empty method + * @param newright arc to work with + * @param s first tail + * @param t2 second tail + * @param t1 third tail + * @param f stepsize + */ + public void pwl_left(Arc newright, float s, float t2, float t1, float f) { + // TODO Auto-generated method stub + // System.out.println("TODO arctesselator.pwl_left"); + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Backend.java b/src/classes/com/sun/opengl/impl/nurbs/Backend.java new file mode 100755 index 000000000..aff484b04 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Backend.java @@ -0,0 +1,217 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Class responsible for rendering + * @author Tomas Hrasky + * + */ +class Backend { + + /** + * Fill surface + */ + public static final int N_MESHFILL = 0; + + /** + * Draw surface as wire model + */ + public static final int N_MESHLINE = 1; + + /** + * Draw surface with points + */ + public static final int N_MESHPOINT = 2; + + /** + * Object rendering curves + */ + private OpenGLCurveEvaluator curveEvaluator; + + /** + * Object rendering surfaces + */ + private OpenGLSurfaceEvaluator surfaceEvaluator; + + /** + * Makes new backend + */ + public Backend() { + curveEvaluator = new OpenGLCurveEvaluator(); + surfaceEvaluator = new OpenGLSurfaceEvaluator(); + } + + /** + * Begin a curve + */ + public void bgncurv() { + // DONE + curveEvaluator.bgnmap1f(); + + } + + /** + * End a curve + */ + public void endcurv() { + // DONE + curveEvaluator.endmap1f(); + + } + + /** + * Make cuve with given parameters + * @param type curve type + * @param ps control points + * @param stride control points coordinates number + * @param order order of curve + * @param ulo smallest u + * @param uhi highest u + */ + public void curvpts(int type, CArrayOfFloats ps, int stride, int order, + float ulo, float uhi) { + // DONE + curveEvaluator.map1f(type, ulo, uhi, stride, order, ps); + curveEvaluator.enable(type); + } + + /** + * Draw curve + * @param u1 smallest u + * @param u2 highest u + * @param nu number of pieces + */ + public void curvgrid(float u1, float u2, int nu) { + // DONE + curveEvaluator.mapgrid1f(nu, u1, u2); + + } + + /** + * Evaluates curve mesh + * @param from low param + * @param n step + */ + public void curvmesh(int from, int n) { + // DONE + curveEvaluator.mapmesh1f(N_MESHFILL, from, from + n); + } + + /** + * Begin surface + * @param wiretris use triangles + * @param wirequads use quads + */ + public void bgnsurf(int wiretris, int wirequads) { + // DONE + surfaceEvaluator.bgnmap2f(); + + if (wiretris > 0) + surfaceEvaluator.polymode(NurbsConsts.N_MESHLINE); + else + surfaceEvaluator.polymode(NurbsConsts.N_MESHFILL); + } + + /** + * End surface + */ + public void endsurf() { + // DONE + surfaceEvaluator.endmap2f(); + } + + /** + * Empty method + * @param ulo low u param + * @param uhi hig u param + * @param vlo low v param + * @param vhi high v param + */ + public void patch(float ulo, float uhi, float vlo, float vhi) { + // DONE + surfaceEvaluator.domain2f(ulo, uhi, vlo, vhi); + } + + /** + * Draw surface + * @param u0 lowest u + * @param u1 highest u + * @param nu number of pieces in u direction + * @param v0 lowest v + * @param v1 highest v + * @param nv number of pieces in v direction + */ + public void surfgrid(float u0, float u1, int nu, float v0, float v1, int nv) { + // DONE + surfaceEvaluator.mapgrid2f(nu, u0, u1, nv, v0, v1); + + } + + /** + * Evaluates surface mesh + * @param u u param + * @param v v param + * @param n step in u direction + * @param m step in v direction + */ + public void surfmesh(int u, int v, int n, int m) { + // System.out.println("TODO backend.surfmesh wireframequads"); + // TODO wireframequads + surfaceEvaluator.mapmesh2f(NurbsConsts.N_MESHFILL, u, u + n, v, v + m); + } + + /** + * Make surface + * @param type surface type + * @param pts control points + * @param ustride control points coordinates in u direction + * @param vstride control points coordinates in v direction + * @param uorder surface order in u direction + * @param vorder surface order in v direction + * @param ulo lowest u + * @param uhi hightest u + * @param vlo lowest v + * @param vhi hightest v + */ + public void surfpts(int type, CArrayOfFloats pts, int ustride, int vstride, + int uorder, int vorder, float ulo, float uhi, float vlo, float vhi) { + // DONE + surfaceEvaluator.map2f(type, ulo, uhi, ustride, uorder, vlo, vhi, + vstride, vorder, pts); + surfaceEvaluator.enable(type); + + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/BezierArc.java b/src/classes/com/sun/opengl/impl/nurbs/BezierArc.java new file mode 100755 index 000000000..ed05f33c6 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/BezierArc.java @@ -0,0 +1,44 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Empty class + * @author Tomas Hrasky + * + */ +class BezierArc { + +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Bin.java b/src/classes/com/sun/opengl/impl/nurbs/Bin.java new file mode 100755 index 000000000..2b23c34ab --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Bin.java @@ -0,0 +1,155 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Class holding trimming arcs + * @author Tomas Hrasky + * + */ +class Bin { + + /** + * Head of linked list of arcs + */ + private Arc head; + + /** + * Current arc + */ + private Arc current; + + /** + * Indicates whether there are any Arcs in linked list + * @return true if there are any Arcs in linked list + */ + public boolean isnonempty() { + // DONE + return this.head != null ? true : false; + } + + /** + * Adds and arc to linked list + * @param jarc added arc + */ + public void addarc(Arc jarc) { + // DONE + // if (head == null) + // head = jarc; + // else { + jarc.link = head; + head = jarc; + // } + + } + + /** + * Returns number of arcs in linked list + * @return number of arcs + */ + public int numarcs() { + // DONE + int count = 0; + for (Arc jarc = firstarc(); jarc != null; jarc = nextarc()) + count++; + return count; + } + + /** + * Removes first arc in list + * @return new linked list head + */ + public Arc removearc() { + // DONE + Arc jarc = head; + if (jarc != null) + head = jarc.link; + return jarc; + + } + + /** + * Consolidates linked list + */ + public void adopt() { + // DONE + markall(); + + Arc orphan; + while ((orphan = removearc()) != null) { + for (Arc parent = orphan.next; !parent.equals(orphan); parent = parent.next) { + if (!parent.ismarked()) { + orphan.link = parent.link; + parent.link = orphan; + orphan.clearmark(); + break; + } + } + } + + } + + /** + * Marks all arc in linked list + */ + private void markall() { + // DONE + for (Arc jarc = firstarc(); jarc != null; jarc = nextarc()) + jarc.setmark(); + } + + /** + * Returns first arc in linked list + * @return first arc in linked list + */ + private Arc firstarc() { + // DONE + current = head; + return nextarc(); + } + + /** + * Returns next arc in linked list + * @return next arc + * + */ + private Arc nextarc() { + // DONE + Arc jarc = current; + if (jarc != null) + current = jarc.link; + return jarc; + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Breakpt.java b/src/classes/com/sun/opengl/impl/nurbs/Breakpt.java new file mode 100755 index 000000000..a62a8bb80 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Breakpt.java @@ -0,0 +1,59 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Class holding break point parameters + * + * @author Tomas Hrasky + * + */ +class Breakpt { + + /** + * Breakpoint multiplicity + */ + public int multi; + + /** + * Breakpint value + */ + public float value; + + /** + * Breakpoint deficit (how many times it has to be added) + */ + public int def; +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/CArrayOfArcs.java b/src/classes/com/sun/opengl/impl/nurbs/CArrayOfArcs.java new file mode 100755 index 000000000..3d803f09c --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/CArrayOfArcs.java @@ -0,0 +1,194 @@ +package com.sun.opengl.impl.nurbs; + +/** + * Class replacing C language pointer + * + * @author Tomas Hrasky + * + */ +class CArrayOfArcs { + /** + * Underlaying array + */ + private Arc[] array; + + /** + * Pointer to array member + */ + private int pointer; + + /** + * Don't check for array borders? + */ + private boolean noCheck = true; + + /** + * Makes new CArray + * + * @param array + * underlaying array + * @param pointer + * pointer (index) to array + */ + public CArrayOfArcs(Arc[] array, int pointer) { + this.array = array; + // this.pointer=pointer; + setPointer(pointer); + } + + /** + * Makes new CArray from other CArray + * + * @param carray + * reference array + */ + public CArrayOfArcs(CArrayOfArcs carray) { + this.array = carray.array; + // this.pointer=carray.pointer; + setPointer(carray.pointer); + } + + /** + * Makes new CArray with pointer set to 0 + * + * @param ctlarray + * underlaying array + */ + public CArrayOfArcs(Arc[] ctlarray) { + this.array = ctlarray; + this.pointer = 0; + } + + /** + * Returns element at pointer + * + * @return element at pointer + */ + public Arc get() { + return array[pointer]; + } + + /** + * Increases pointer by one (++) + */ + public void pp() { + // pointer++; + setPointer(pointer + 1); + } + + /** + * Sets element at pointer + * + * @param f + * desired value + */ + public void set(Arc f) { + array[pointer] = f; + + } + + /** + * Returns array element at specified index + * + * @param i + * array index + * @return element at index + */ + public Arc get(int i) { + return array[i]; + } + + /** + * Returns array element at specified index relatively to pointer + * + * @param i + * relative index + * @return element at relative index + */ + public Arc getRelative(int i) { + return array[pointer + i]; + } + + /** + * Sets value of element at specified index relatively to pointer + * + * @param i + * relative index + * @param value + * value to be set + */ + public void setRelative(int i, Arc value) { + array[pointer + i] = value; + } + + /** + * Lessens pointer by value + * + * @param i + * lessen by + */ + public void lessenPointerBy(int i) { + // pointer-=i; + setPointer(pointer - i); + } + + /** + * Returns pointer value + * + * @return pointer value + */ + public int getPointer() { + return pointer; + } + + /** + * Sets ponter value + * + * @param pointer + * pointer value to be set + */ + public void setPointer(int pointer) { + if (!noCheck && pointer > array.length) + throw new IllegalArgumentException("Pointer " + pointer + + " out of bounds " + array.length); + this.pointer = pointer; + } + + /** + * Raises pointer by value + * + * @param i + * raise by + */ + public void raisePointerBy(int i) { + // pointer+=i; + setPointer(pointer + i); + } + + /** + * Lessens ponter by one (--) + */ + public void mm() { + // pointer--; + setPointer(pointer - 1); + } + + /** + * Returns underlaying array + * + * @return underlaying array + */ + public Arc[] getArray() { + return array; + } + + /** + * Sets underlaying array + * + * @param array + * underlaying array + */ + public void setArray(Arc[] array) { + this.array = array; + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/CArrayOfBreakpts.java b/src/classes/com/sun/opengl/impl/nurbs/CArrayOfBreakpts.java new file mode 100755 index 000000000..c4c14b66c --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/CArrayOfBreakpts.java @@ -0,0 +1,130 @@ +package com.sun.opengl.impl.nurbs; + +/** + * Class replacing C language pointer + * + * @author Tomas Hrasky + * + */ +class CArrayOfBreakpts { + /** + * Underlaying array + */ + private Breakpt[] pole; + + /** + * Pointer to array member + */ + private int pointer; + + /** + * Makes new CArray + * + * @param array + * underlaying array + * @param pointer + * pointer (index) to array + */ + public CArrayOfBreakpts(Breakpt[] array, int pointer) { + this.pole = array; + this.pointer = pointer; + } + + /** + * Makes new CArray from other CArray + * + * @param carray + * reference array + */ + public CArrayOfBreakpts(CArrayOfBreakpts carray) { + this.pole = carray.pole; + this.pointer = carray.pointer; + } + + /** + * Returns element at pointer + * + * @return element at pointer + */ + public Breakpt get() { + return pole[pointer]; + } + + /** + * Increases pointer by one (++) + */ + public void pp() { + pointer++; + } + + /** + * Sets element at pointer + * + * @param f + * desired value + */ + public void set(Breakpt f) { + pole[pointer] = f; + + } + + /** + * Returns array element at specified index + * + * @param i + * array index + * @return element at index + */ + public Breakpt get(int i) { + return pole[i]; + } + + /** + * Lessens pointer by value + * + * @param i + * lessen by + */ + public void lessenPointerBy(int i) { + pointer -= i; + + } + + /** + * Returns pointer value + * + * @return pointer value + */ + public int getPointer() { + return pointer; + } + + /** + * Sets ponter value + * + * @param pointer + * pointer value to be set + */ + public void setPointer(int pointer) { + this.pointer = pointer; + } + + /** + * Raises pointer by value + * + * @param i + * raise by + */ + public void raisePointerBy(int i) { + pointer += i; + + } + + /** + * Lessens ponter by one (--) + */ + public void mm() { + pointer--; + + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/CArrayOfFloats.java b/src/classes/com/sun/opengl/impl/nurbs/CArrayOfFloats.java new file mode 100755 index 000000000..237715a01 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/CArrayOfFloats.java @@ -0,0 +1,195 @@ +package com.sun.opengl.impl.nurbs; + +/** + * Class replacing C language pointer + * + * @author Tomas Hrasky + * + */ +class CArrayOfFloats { + + /** + * Underlaying array + */ + private float[] array; + + /** + * Pointer to array member + */ + private int pointer; + + /** + * Don't check for array borders? + */ + private boolean noCheck = true; + + /** + * Makes new CArray + * + * @param array + * underlaying array + * @param pointer + * pointer (index) to array + */ + public CArrayOfFloats(float[] array, int pointer) { + this.array = array; + // this.pointer=pointer; + setPointer(pointer); + } + + /** + * Makes new CArray from other CArray + * + * @param carray + * reference array + */ + public CArrayOfFloats(CArrayOfFloats carray) { + this.array = carray.array; + // this.pointer=carray.pointer; + setPointer(carray.pointer); + } + + /** + * Makes new CArray with pointer set to 0 + * + * @param ctlarray + * underlaying array + */ + public CArrayOfFloats(float[] ctlarray) { + this.array = ctlarray; + this.pointer = 0; + } + + /** + * Returns element at pointer + * + * @return element at pointer + */ + public float get() { + return array[pointer]; + } + + /** + * Increases pointer by one (++) + */ + public void pp() { + // pointer++; + setPointer(pointer + 1); + } + + /** + * Sets element at pointer + * + * @param f + * desired value + */ + public void set(float f) { + array[pointer] = f; + + } + + /** + * Returns array element at specified index + * + * @param i + * array index + * @return element at index + */ + public float get(int i) { + return array[i]; + } + + /** + * Returns array element at specified index relatively to pointer + * + * @param i + * relative index + * @return element at relative index + */ + public float getRelative(int i) { + return array[pointer + i]; + } + + /** + * Sets value of element at specified index relatively to pointer + * + * @param i + * relative index + * @param value + * value to be set + */ + public void setRelative(int i, float value) { + array[pointer + i] = value; + } + + /** + * Lessens pointer by value + * + * @param i + * lessen by + */ + public void lessenPointerBy(int i) { + // pointer-=i; + setPointer(pointer - i); + } + + /** + * Returns pointer value + * + * @return pointer value + */ + public int getPointer() { + return pointer; + } + + /** + * Sets ponter value + * + * @param pointer + * pointer value to be set + */ + public void setPointer(int pointer) { + if (!noCheck && pointer > array.length) + throw new IllegalArgumentException("Pointer " + pointer + + " out of bounds " + array.length); + this.pointer = pointer; + } + + /** + * Raises pointer by value + * + * @param i + * raise by + */ + public void raisePointerBy(int i) { + // pointer+=i; + setPointer(pointer + i); + } + + /** + * Lessens ponter by one (--) + */ + public void mm() { + // pointer--; + setPointer(pointer - 1); + } + + /** + * Returns underlaying array + * + * @return underlaying array + */ + public float[] getArray() { + return array; + } + + /** + * Sets underlaying array + * + * @param array + * underlaying array + */ + public void setArray(float[] array) { + this.array = array; + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/CArrayOfQuiltspecs.java b/src/classes/com/sun/opengl/impl/nurbs/CArrayOfQuiltspecs.java new file mode 100755 index 000000000..40559fe6b --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/CArrayOfQuiltspecs.java @@ -0,0 +1,160 @@ +package com.sun.opengl.impl.nurbs; + +/** + * Class replacing C language pointer + * + * @author Tomas Hrasky + * + */ +class CArrayOfQuiltspecs { + /** + * Underlaying array + */ + private Quiltspec[] array; + + /** + * Pointer to array member + */ + private int pointer; + + /** + * Makes new CArray + * + * @param array + * underlaying array + * @param pointer + * pointer (index) to array + */ + public CArrayOfQuiltspecs(Quiltspec[] array, int pointer) { + this.array = array; + this.pointer = pointer; + } + + /** + * Makes new CArray from other CArray + * + * @param carray + * reference array + */ + public CArrayOfQuiltspecs(CArrayOfQuiltspecs carray) { + this.array = carray.array; + this.pointer = carray.pointer; + } + + /** + * Makes new CArray with pointer set to 0 + * + * @param array + * underlaying array + */ + public CArrayOfQuiltspecs(Quiltspec[] array) { + this.array = array; + this.pointer = 0; + } + + /** + * Returns element at pointer + * + * @return element at pointer + */ + public Quiltspec get() { + return array[pointer]; + } + + /** + * Increases pointer by one (++) + */ + public void pp() { + pointer++; + } + + /** + * Sets element at pointer + * + * @param f + * desired value + */ + public void set(Quiltspec f) { + array[pointer] = f; + + } + + /** + * Returns array element at specified index + * + * @param i + * array index + * @return element at index + */ + public Quiltspec get(int i) { + return array[i]; + } + + /** + * Lessens pointer by value + * + * @param i + * lessen by + */ + public void lessenPointerBy(int i) { + pointer -= i; + + } + + /** + * Returns pointer value + * + * @return pointer value + */ + public int getPointer() { + return pointer; + } + + /** + * Sets ponter value + * + * @param pointer + * pointer value to be set + */ + public void setPointer(int pointer) { + this.pointer = pointer; + } + + /** + * Raises pointer by value + * + * @param i + * raise by + */ + public void raisePointerBy(int i) { + pointer += i; + + } + + /** + * Lessens ponter by one (--) + */ + public void mm() { + pointer--; + + } + + /** + * Returns underlaying array + * + * @return underlaying array + */ + public Quiltspec[] getArray() { + return array; + } + + /** + * Sets underlaying array + * + * @param array + * underlaying array + */ + public void setArray(Quiltspec[] array) { + this.array = array; + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Curve.java b/src/classes/com/sun/opengl/impl/nurbs/Curve.java new file mode 100755 index 000000000..0fe7418f2 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Curve.java @@ -0,0 +1,238 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Class holding curve definition + * @author Tomáš Hráský + * + */ +class Curve { + + /** + * Maximum coordinates per control point + */ + private static final int MAXCOORDS = 5; + + /** + * Max curve order + */ + private static final int MAXORDER = 24; + + /** + * Next curve in linked list + */ + public Curve next; + + /** + * OpenGL maps + */ + private Mapdesc mapdesc; + + /** + * Does the curve need sampling + */ + private boolean needsSampling; + + /** + * Culling + */ + private int cullval; + + /** + * Number of coords + */ + private int stride; + + /** + * Curve order + */ + private int order; + + /** + * Holds conversion range borders + */ + private float[] range; + + /** + * Subdivision stepsize + */ + public float stepsize; + + /** + * Minimal subdivision stepsize + */ + private float minstepsize; + + /** + * Sampling points + */ + float[] spts; + + /** + * Makes new Curve + * + * @param geo + * @param pta + * @param ptb + * @param c + * next curve in linked list + */ + public Curve(Quilt geo, float[] pta, float[] ptb, Curve c) { + + spts = new float[MAXORDER * MAXCOORDS]; + + mapdesc = geo.mapdesc; + + next = c; + needsSampling = mapdesc.isRangeSampling() ? true : false; + + cullval = mapdesc.isCulling() ? Subdivider.CULL_ACCEPT + : Subdivider.CULL_TRIVIAL_REJECT; + order = geo.qspec.get(0).order; + stride = MAXCOORDS; + + // CArrayOfFloats ps = geo.cpts; + CArrayOfFloats ps = new CArrayOfFloats(geo.cpts.getArray(), 0); + CArrayOfQuiltspecs qs = geo.qspec; + ps.raisePointerBy(qs.get().offset); + ps.raisePointerBy(qs.get().index * qs.get().order * qs.get().stride); + + if (needsSampling) { + mapdesc.xformSampling(ps, qs.get().order, qs.get().stride, spts, + stride); + } + if (cullval == Subdivider.CULL_ACCEPT) { + // System.out.println("TODO curve.Curve-cullval"); + // mapdesc.xformCulling(ps,qs.get().order,qs.get().stride,cpts,stride); + } + + range = new float[3]; + range[0] = qs.get().breakpoints[qs.get().index]; + range[1] = qs.get().breakpoints[qs.get().index + 1]; + range[2] = range[1] - range[0]; + // TODO it is necessary to solve problem with "this" pointer here + if (range[0] != pta[0]) { + // System.out.println("TODO curve.Curve-range0"); + // Curve lower=new Curve(this,pta,0); + // lower.next=next; + // this=lower; + } + if (range[1] != ptb[0]) { + // System.out.println("TODO curve.Curve-range1"); + // Curve lower=new Curve(this,ptb,0); + } + } + + /** + * Checks culling type + * @return Subdivider.CULL_ACCEPT + */ + public int cullCheck() { + if (cullval == Subdivider.CULL_ACCEPT) { + // System.out.println("TODO curve.cullval"); + // cullval=mapdesc.cullCheck(cpts,order,stride); + } + // TODO compute cullval and return the computed value + // return cullval; + return Subdivider.CULL_ACCEPT; + } + + /** + * Computes subdivision step size + */ + public void getStepSize() { + minstepsize = 0; + if (mapdesc.isConstantSampling()) { + setstepsize(mapdesc.maxrate); + } else if (mapdesc.isDomainSampling()) { + setstepsize(mapdesc.maxrate * range[2]); + } else { + assert (order <= MAXORDER); + + float tmp[][] = new float[MAXORDER][MAXCOORDS]; + + int tstride = (MAXORDER); + + int val = 0; + // mapdesc.project(spts,stride,tmp,tstride,order); + + // System.out.println("TODO curve.getsptepsize mapdesc.project"); + + if (val == 0) { + setstepsize(mapdesc.maxrate); + } else { + float t = mapdesc.getProperty(NurbsConsts.N_PIXEL_TOLERANCE); + if (mapdesc.isParametricDistanceSampling()) { + // System.out.println("TODO curve.getstepsize - parametric"); + } else if (mapdesc.isPathLengthSampling()) { + // System.out.println("TODO curve.getstepsize - pathlength"); + } else { + setstepsize(mapdesc.maxrate); + } + } + + } + + } + + /** + * Sets maximum subdivision step size + * @param max maximum subdivision step size + */ + private void setstepsize(float max) { + // DONE + stepsize = (max >= 1) ? (range[2] / max) : range[2]; + minstepsize = stepsize; + } + + /** + * Clamps the curve + */ + public void clamp() { + // DONE + if (stepsize < minstepsize) + stepsize = mapdesc.clampfactor * minstepsize; + } + + /** + * Tells whether curve needs subdivision + * + * @return curve needs subdivison + */ + public boolean needsSamplingSubdivision() { + return (stepsize < minstepsize); + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Curvelist.java b/src/classes/com/sun/opengl/impl/nurbs/Curvelist.java new file mode 100755 index 000000000..b37aac927 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Curvelist.java @@ -0,0 +1,121 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Class for woking with linked list of curves + * @author Tomas Hrasky + * + */ +class Curvelist { + + /** + * Head of linked list + */ + private Curve curve; + + /** + * Holds conversion range borders + */ + float[] range; + + /** + * Subdivision step size + */ + public float stepsize; + + /** + * Do curves need subdivision? + */ + private boolean needsSubdivision; + + /** + * Makes new instance on top of specified lis of Quilts + * @param qlist underlaying list of quilts + * @param pta range start + * @param ptb range end + */ + public Curvelist(Quilt qlist, float[] pta, float[] ptb) { + // DONE + curve = null; + range = new float[3]; + + for (Quilt q = qlist; q != null; q = q.next) { + curve = new Curve(q, pta, ptb, curve); + } + range[0] = pta[0]; + range[1] = ptb[0]; + range[2] = range[1] - range[0]; + } + + /** + * Compute step size + */ + public void getstepsize() { + // DONE + stepsize = range[2]; + Curve c; + for (c = curve; c != null; c = c.next) { + c.getStepSize(); + c.clamp(); + stepsize = (c.stepsize < stepsize) ? c.stepsize : stepsize; + if (c.needsSamplingSubdivision()) + break; + } + needsSubdivision = (c != null) ? true : false; + + } + + /** + * Indicates whether curves need subdivision + * @return curves need subdivision + */ + public boolean needsSamplingSubdivision() { + // DONE + return needsSubdivision; + } + + /** + * Checks for culling + * @return Subdivider.CULL_TRIVIAL_REJECT or Subdivider.CULL_ACCEPT + */ + public int cullCheck() { + // DONE + for (Curve c = curve; c != null; c = c.next) + if (c.cullCheck() == Subdivider.CULL_TRIVIAL_REJECT) + return Subdivider.CULL_TRIVIAL_REJECT; + return Subdivider.CULL_ACCEPT; + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/DisplayList.java b/src/classes/com/sun/opengl/impl/nurbs/DisplayList.java new file mode 100755 index 000000000..8ea8392b3 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/DisplayList.java @@ -0,0 +1,56 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +import java.lang.reflect.Method; + +/** + * Display list + * @author Tomas Hrasky + * + */ +class DisplayList { + + /** + * Append action to the display list + * @param src source object to invoke method on + * @param m invoked method + * @param arg method argument + */ + public void append(Object src, Method m, Object arg) { + // TODO Auto-generated method stub + // System.out.println("TODO displaylist append"); + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Flist.java b/src/classes/com/sun/opengl/impl/nurbs/Flist.java new file mode 100755 index 000000000..bf1b45986 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Flist.java @@ -0,0 +1,130 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +import java.util.Arrays; + +/** + * List of breakpoints + * @author Tomas Hrasky + * + */ +class Flist { + + /** + * Data elements end index + * + */ + public int end; + + /** + *Data elements start index + */ + public int start; + + /** + * Breakpoint values + */ + public float[] pts; + + /** + * Number of array fields + */ + private int npts; + + /** + * Grows list + * @param maxpts maximum desired size + */ + public void grow(int maxpts) { + // DONE + if (npts < maxpts) { + // npts=2*maxpts; + npts = maxpts; + pts = new float[npts]; + } + start = 0; + end = 0; + } + + /** + * Removes duplicate array elemnts + */ + public void filter() { + // INFO the aim of this method is to remove duplicates from array + + Arrays.sort(pts); + + start = 0; + + int j = 0; + + for (int i = 1; i < end; i++) { + if (pts[i] == pts[i - j - 1]) + j++; + pts[i - j] = pts[i]; + } + + end -= j; + + } + + /** + * Sets start and and to real start and end of array elements + * @param from start from + * @param to end at + */ + public void taper(float from, float to) { + // DONE + + while (pts[start] != from) { + start++; + } + + while (pts[end - 1] != to) { + end--; + } + + } + + /** + * Adds breakpoint value + * @param f value + */ + public void add(float f) { + //DONE + pts[end++] = f; + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/GLUnurbsImpl.java b/src/classes/com/sun/opengl/impl/nurbs/GLUnurbsImpl.java new file mode 100755 index 000000000..fd277744e --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/GLUnurbsImpl.java @@ -0,0 +1,860 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +import java.lang.reflect.Method; + +import javax.media.opengl.GL; +import javax.media.opengl.glu.GLUnurbs; + +/** + * Base object for working with NURBS curves and surfaces + * + * @author Tomas Hrasky + * + */ +public class GLUnurbsImpl implements GLUnurbs { + + /** + * Curve type - no type + */ + public static final int CT_NONE = 0; + + /** + * Curve type - NURBS curve + */ + public static final int CT_NURBSCURVE = 1; + + /** + * Curve type - picewise linear curve + */ + public static final int CT_NPWLCURVE = 2; + + /** + * Matrixes autoloading + */ + private boolean autoloadmode; + + /** + * Using callback + */ + private int callBackFlag; + + /** + * Object for error call backs + */ + private Object errorCallback; + + /** + * List of map definitions + */ + Maplist maplist; + + /** + * Indicates validity of data + */ + private int isDataValid; + + /** + * Are we in the middle of curve processing + */ + private int inCurve; + + /** + * Current curve + */ + private O_curve currentCurve; + + /** + * Are we in trim + */ + private boolean inTrim; + + /** + * Are we playbacking curve/surface rendering + */ + private boolean playBack; + + /** + * Next curve in linked list + */ + private O_curve nextCurve; + + /** + * Is curve modified + */ + private int isCurveModified; + + /** + * Object holding rendering settings + */ + private Renderhints renderhints; + + /** + * Display list + */ + private DisplayList dl; + + /** + * Object for subdividing curves and surfaces + */ + private Subdivider subdivider; + + /** + * Object responsible for rendering + */ + private Backend backend; + + /** + * Next picewise linear curve in linked list + */ + private O_pwlcurve nextPwlcurve; + + /** + * Next trimming NURBS curve in linked list + */ + private O_nurbscurve nextNurbscurve; + + /** + * Are we in the middle of surface processing + */ + private int inSurface; + + /** + * Are there any changes in trimming + */ + private boolean isTrimModified; + + /** + * Are there any changes in surface data + */ + private boolean isDataSurfaceModified; + + /** + * Nurber of trmims of processed surface + */ + private int numTrims; + + /** + * Current processed surface + */ + private O_surface currentSurface; + + /** + * Next trimming curve + */ + private O_trim nextTrim; + + /** + * Nextr surface in linked list + */ + private O_nurbssurface nextNurbssurface; + + /** + * Are there any changes in surface + */ + private boolean isSurfaceModified; + + /** + * Initializes default GLUnurbs object + */ + public GLUnurbsImpl() { + // DONE + maplist = new Maplist(backend); + renderhints = new Renderhints(); + subdivider = new Subdivider(); + // original code + + redefineMaps(); + + defineMap(GL.GL_MAP2_NORMAL, 0, 3); + defineMap(GL.GL_MAP1_NORMAL, 0, 3); + defineMap(GL.GL_MAP2_TEXTURE_COORD_1, 0, 1); + defineMap(GL.GL_MAP1_TEXTURE_COORD_1, 0, 1); + defineMap(GL.GL_MAP2_TEXTURE_COORD_2, 0, 2); + defineMap(GL.GL_MAP1_TEXTURE_COORD_2, 0, 2); + defineMap(GL.GL_MAP2_TEXTURE_COORD_3, 0, 3); + defineMap(GL.GL_MAP1_TEXTURE_COORD_3, 0, 3); + defineMap(GL.GL_MAP2_TEXTURE_COORD_4, 1, 4); + defineMap(GL.GL_MAP1_TEXTURE_COORD_4, 1, 4); + defineMap(GL.GL_MAP2_VERTEX_4, 1, 4); + defineMap(GL.GL_MAP1_VERTEX_4, 1, 4); + defineMap(GL.GL_MAP2_VERTEX_3, 0, 3); + defineMap(GL.GL_MAP1_VERTEX_3, 0, 3); + defineMap(GL.GL_MAP2_COLOR_4, 0, 4); + defineMap(GL.GL_MAP1_COLOR_4, 0, 4); + defineMap(GL.GL_MAP2_INDEX, 0, 1); + defineMap(GL.GL_MAP1_INDEX, 0, 1); + + setnurbsproperty(GL.GL_MAP1_VERTEX_3, NurbsConsts.N_SAMPLINGMETHOD, + (float) NurbsConsts.N_PATHLENGTH); + setnurbsproperty(GL.GL_MAP1_VERTEX_4, NurbsConsts.N_SAMPLINGMETHOD, + (float) NurbsConsts.N_PATHLENGTH); + setnurbsproperty(GL.GL_MAP2_VERTEX_3, NurbsConsts.N_SAMPLINGMETHOD, + (float) NurbsConsts.N_PATHLENGTH); + setnurbsproperty(GL.GL_MAP2_VERTEX_4, NurbsConsts.N_SAMPLINGMETHOD, + (float) NurbsConsts.N_PATHLENGTH); + + setnurbsproperty(GL.GL_MAP1_VERTEX_3, NurbsConsts.N_PIXEL_TOLERANCE, + (float) 50.0); + setnurbsproperty(GL.GL_MAP1_VERTEX_4, NurbsConsts.N_PIXEL_TOLERANCE, + (float) 50.0); + setnurbsproperty(GL.GL_MAP2_VERTEX_3, NurbsConsts.N_PIXEL_TOLERANCE, + (float) 50.0); + setnurbsproperty(GL.GL_MAP2_VERTEX_4, NurbsConsts.N_PIXEL_TOLERANCE, + (float) 50.0); + + setnurbsproperty(GL.GL_MAP1_VERTEX_3, NurbsConsts.N_ERROR_TOLERANCE, + (float) 0.50); + setnurbsproperty(GL.GL_MAP1_VERTEX_4, NurbsConsts.N_ERROR_TOLERANCE, + (float) 0.50); + setnurbsproperty(GL.GL_MAP2_VERTEX_3, NurbsConsts.N_ERROR_TOLERANCE, + (float) 0.50); + setnurbsproperty(GL.GL_MAP2_VERTEX_4, NurbsConsts.N_ERROR_TOLERANCE, + (float) 0.50); + + setnurbsproperty(GL.GL_MAP1_VERTEX_3, NurbsConsts.N_S_STEPS, + (float) 100.0); + setnurbsproperty(GL.GL_MAP1_VERTEX_4, NurbsConsts.N_S_STEPS, + (float) 100.0); + setnurbsproperty(GL.GL_MAP2_VERTEX_3, NurbsConsts.N_S_STEPS, + (float) 100.0); + setnurbsproperty(GL.GL_MAP2_VERTEX_4, NurbsConsts.N_S_STEPS, + (float) 100.0); + + setnurbsproperty(GL.GL_MAP1_VERTEX_3, NurbsConsts.N_SAMPLINGMETHOD, + NurbsConsts.N_PATHLENGTH); + + set_domain_distance_u_rate(100.0); + set_domain_distance_v_rate(100.0); + set_is_domain_distance_sampling(0); + + this.autoloadmode = true; + + this.callBackFlag = 0; + + this.errorCallback = null; + } + + /** + * Sets domain distance for dom.dist. sampling in u direction + * + * @param d + * distance + */ + private void set_domain_distance_u_rate(double d) { + // DONE + subdivider.set_domain_distance_u_rate(d); + } + + /** + * Sets domain distance for dom.dist. sampling in v direction + * + * @param d + * distance + */ + private void set_domain_distance_v_rate(double d) { + // DONE + subdivider.set_domain_distance_v_rate(d); + } + + /** + * Begins new NURBS curve + */ + public void bgncurve() { + // DONE + O_curve o_curve = new O_curve(); + thread("do_bgncurve", o_curve); + } + + /** + * Calls a method with given name and passes argumet + * + * @param name + * name of a method to be called + * @param arg + * parameter to be passed to called method + */ + private void thread(String name, Object arg) { + // DONE + Class partype[] = new Class[1]; + partype[0] = arg.getClass(); + Method m; + try { + m = this.getClass().getMethod(name, partype); + if (dl != null) { + dl.append(this, m, arg); + } else { + m.invoke(this, new Object[] { arg }); + } + } catch (Throwable e) { + e.printStackTrace(); + } + + } + + /** + * Calls a method with given name + * + * @param name + * name of a method to be called + */ + private void thread2(String name) { + // DONE + try { + Method m = this.getClass().getMethod(name, (Class[]) null); + if (dl != null) { + dl.append(this, m, null); + } else { + m.invoke(this, (Object[]) null); + } + } catch (Throwable e) { + e.printStackTrace(); + } + } + + /** + * Begins a NURBS curve + * + * @param o_curve + * curve object + */ + public void do_bgncurve(O_curve o_curve) { + if (inCurve > 0) { + do_nurbserror(6); + endcurve(); + } + inCurve = 1; + currentCurve = o_curve; + + currentCurve.curvetype = CT_NONE; + + if (inTrim) { + if (!nextCurve.equals(o_curve)) { + isCurveModified = 1; + nextCurve = o_curve; + } + } else { + if (!playBack) + bgnrender(); + isDataValid = 1; + } + nextCurve = o_curve.next; + // kind of solution of union + nextPwlcurve = o_curve.o_pwlcurve; + nextNurbscurve = o_curve.o_nurbscurve; + } + + /** + * Begins new surface + * + * @param o_surface + * surface object + */ + public void do_bgnsurface(O_surface o_surface) { + // DONE + if (inSurface > 0) { + do_nurbserror(27); + endsurface(); + } + inSurface = 1; + if (!playBack) + bgnrender(); + + isTrimModified = false; + isDataSurfaceModified = false; + isDataValid = 1; + numTrims = 0; + currentSurface = o_surface; + nextTrim = o_surface.o_trim; + nextNurbssurface = o_surface.o_nurbssurface; + } + + /** + * End a curve + */ + public void endcurve() { + // DONE + thread2("do_endcurve"); + } + + /** + * Ends surface + */ + public void do_endsurface() { + // DONE + if (inTrim) { + do_nurbserror(12); + endtrim(); + } + + if (inSurface <= 0) { + do_nurbserror(13); + return; + } + + inSurface = 0; + + nextNurbssurface = null; + + if (isDataValid <= 0) { + return; + } + + if (nextTrim != null) { + isTrimModified = true; + nextTrim = null; + } + + // TODO errval ?? + if (numTrims > 0) { + // System.out.println("TODO glunurbs.do_endsurface - numtrims > 0"); + } + + subdivider.beginQuilts(); + for (O_nurbssurface n = currentSurface.o_nurbssurface; n != null; n = n.next) { + subdivider.addQuilt(n.bezier_patches); + } + subdivider.endQuilts(); + subdivider.drawSurfaces(); + if (!playBack) + endrender(); + + } + + /** + * Ends a curve + */ + public void do_endcurve() { + // DONE + // // System.out.println("do_endcurve"); + if (inCurve <= 0) { + do_nurbserror(7); + return; + } + inCurve = 0; + + nextCurve = null; + + if (currentCurve.curvetype == CT_NURBSCURVE) { + // nextNurbscurve = null; + // currentCurve.o_nurbscurve=null; + } else { + // nextPwlcurve = null; + // currentCurve.o_pwlcurve=null; + } + if (!inTrim) { + if (isDataValid <= 0) { + return; + } + // TODO errval? + if (currentCurve.curvetype == CT_NURBSCURVE) { + subdivider.beginQuilts(); + + for (O_nurbscurve n = currentCurve.o_nurbscurve; n != null; n = n.next) + subdivider.addQuilt(n.bezier_curves); + + subdivider.endQuilts(); + subdivider.drawCurves(); + if (!playBack) + endrender(); + } else { + if (!playBack) + endrender(); + do_nurbserror(9); + } + } + + } + + /** + * Method for handling error codes + * + * @param i + * error code + */ + private void do_nurbserror(int i) { + // TODO nurberror + // System.out.println("TODO nurbserror " + i); + } + + /** + * Begin rendering + */ + private void bgnrender() { + // DONE + if (autoloadmode) { + loadGLMatrices(); + } + } + + /** + * Load matrices from OpenGL state machine + */ + private void loadGLMatrices() { + // TODO Auto-generated method stub + // System.out.println("TODO glunurbs.loadGLMatrices"); + } + + /** + * End rendering + */ + private void endrender() { + // DONE + } + + /** + * Make a NURBS curve + * + * @param nknots + * number of knots in knot vector + * @param knot + * knot vector + * @param stride + * number of control points coordinates + * @param ctlarray + * control points + * @param order + * order of the curve + * @param realType + * type of the curve + */ + public void nurbscurve(int nknots, float[] knot, int stride, + float[] ctlarray, int order, int realType) { + // DONE + Mapdesc mapdesc = maplist.locate(realType); + if (mapdesc == null) { + do_nurbserror(35); + isDataValid = 0; + return; + } + if (ctlarray == null) { + do_nurbserror(36); + isDataValid = 0; + return; + } + if (stride < 0) { + do_nurbserror(34); + isDataValid = 0; + return; + } + Knotvector knots = new Knotvector(nknots, stride, order, knot); + + if (!do_check_knots(knots, "curve")) + return; + + O_nurbscurve o_nurbscurve = new O_nurbscurve(realType); + o_nurbscurve.bezier_curves = new Quilt(mapdesc); + CArrayOfFloats ctrlcarr = new CArrayOfFloats(ctlarray); + o_nurbscurve.bezier_curves.toBezier(knots, ctrlcarr, mapdesc + .getNCoords()); + thread("do_nurbscurve", o_nurbscurve); + } + + /** + * Check knot vector specification + * + * @param knots + * knot vector + * @param msg + * error message + * @return knot vector is / is not valid + */ + public boolean do_check_knots(Knotvector knots, String msg) { + // DONE + int status = knots.validate(); + if (status > 0) { + do_nurbserror(status); + if (renderhints.errorchecking != NurbsConsts.N_NOMSG) + knots.show(msg); + } + return (status > 0) ? false : true; + } + + /** + * Draw a curve + * + * @param o_nurbscurve + * NURBS curve object + */ + public void do_nurbscurve(O_nurbscurve o_nurbscurve) { + // DONE + + if (inCurve <= 0) { + bgncurve(); + inCurve = 2; + } + + if (o_nurbscurve.used) { + do_nurbserror(23); + isDataValid = 0; + return; + } else + o_nurbscurve.used = true; + + if (currentCurve.curvetype == CT_NONE) { + currentCurve.curvetype = CT_NURBSCURVE; + } else if (currentCurve.curvetype != CT_NURBSCURVE) { + do_nurbserror(24); + isDataValid = 0; + return; + } + + // it was necessary to overcome problem with pointer to pointer here + + // if(!o_nurbscurve.equals(nextNurbscurve)){ + if (!o_nurbscurve.equals(currentCurve.o_nurbscurve)) { + isCurveModified = 1; + currentCurve.o_nurbscurve = o_nurbscurve; + // nextNurbscurve=o_nurbscurve; + + } + + nextNurbscurve = o_nurbscurve.next; + + if (!currentCurve.equals(o_nurbscurve.owner)) { + isCurveModified = 1; + o_nurbscurve.owner = currentCurve; + } + + if (o_nurbscurve.owner == null) + isCurveModified = 1; + + if (inCurve == 2) + endcurve(); + } + + /** + * Draw NURBS surface + * + * @param o_nurbssurface + * NURBS surface object + */ + public void do_nurbssurface(O_nurbssurface o_nurbssurface) { + // DONE + if (inSurface <= 0) { + bgnsurface(); + inSurface = 2; + } + if (o_nurbssurface.used) { + do_nurbserror(25); + isDataValid = 0; + return; + } else + o_nurbssurface.used = true; + + if (!o_nurbssurface.equals(nextNurbscurve)) { + isSurfaceModified = true; + // nextNurbssurface=o_nurbssurface; + currentSurface.o_nurbssurface = o_nurbssurface; + } + + if (!currentSurface.equals(o_nurbssurface.owner)) { + isSurfaceModified = true; + o_nurbssurface.owner = currentSurface; + } + + nextNurbssurface = o_nurbssurface.next; + + if (inSurface == 2) + endsurface(); + } + + /** + * (Re)Inicialize maps + */ + public void redefineMaps() { + // DONE + maplist.initialize(); + } + + /** + * Define a map of given properties + * + * @param type + * map type + * @param rational + * is rational + * @param ncoords + * number of control point coordinates + */ + public void defineMap(int type, int rational, int ncoords) { + // DONE + maplist.define(type, rational, ncoords); + } + + /** + * Set NURBS property + * + * @param type + * property type + * @param tag + * property tag + * @param value + * property value + */ + public void setnurbsproperty(int type, int tag, float value) { + // DONE + Mapdesc mapdesc = maplist.locate(type); + if (mapdesc == null) { + do_nurbserror(35); + return; + } + if (!mapdesc.isProperty(tag)) { + do_nurbserror(26); + return; + } + Property prop = new Property(type, tag, value); + thread("do_setnurbsproperty2", prop); + } + + /** + * Set parameters of existing property + * + * @param prop + * property + */ + public void do_setnurbsproperty2(Property prop) { + Mapdesc mapdesc = maplist.find(prop.type); + mapdesc.setProperty(prop.tag, prop.value); + } + + /** + * Set given property to rendering hints + * + * @param prop + * property to be set + */ + public void do_setnurbsproperty(Property prop) { + // DONE + renderhints.setProperty(prop); + // TODO freeproperty? + } + + /** + * Sets wheteher we use domain distance sampling + * + * @param i + * domain distance sampling flag + */ + public void set_is_domain_distance_sampling(int i) { + // DONE + subdivider.set_is_domain_distance_sampling(i); + } + + /** + * Begin new surface + */ + public void bgnsurface() { + // DONE + O_surface o_surface = new O_surface(); + // TODO nuid + // System.out.println("TODO glunurbs.bgnsurface nuid"); + thread("do_bgnsurface", o_surface); + } + + /** + * End current surface + */ + public void endsurface() { + // DONE + thread2("do_endsurface"); + } + + /** + * End surface trimming + */ + private void endtrim() { + // TODO Auto-generated method stub + // System.out.println("TODO glunurbs.endtrim"); + } + + /** + * Make NURBS surface + * + * @param sknot_count + * number of knots in s direction + * @param sknot + * knot vector in s direction + * @param tknot_count + * number of knots in t direction + * @param tknot + * knot vector in t direction + * @param s_stride + * number of coords of control points in s direction + * @param t_stride + * number of coords of control points in t direction + * @param ctlarray + * control points + * @param sorder + * order of curve in s direction + * @param torder + * order of curve in t direction + * @param type + * NURBS surface type (rational,...) + */ + public void nurbssurface(int sknot_count, float[] sknot, int tknot_count, + float[] tknot, int s_stride, int t_stride, float[] ctlarray, + int sorder, int torder, int type) { + // DONE + Mapdesc mapdesc = maplist.locate(type); + if (mapdesc == null) { + do_nurbserror(35); + isDataValid = 0; + return; + } + if (s_stride < 0 || t_stride < 0) { + do_nurbserror(34); + isDataValid = 0; + return; + } + Knotvector sknotvector = new Knotvector(sknot_count, s_stride, sorder, + sknot); + if (!do_check_knots(sknotvector, "surface")) + return; + Knotvector tknotvector = new Knotvector(tknot_count, t_stride, torder, + tknot); + if (!do_check_knots(tknotvector, "surface")) + return; + + O_nurbssurface o_nurbssurface = new O_nurbssurface(type); + o_nurbssurface.bezier_patches = new Quilt(mapdesc); + + CArrayOfFloats ctrlarr = new CArrayOfFloats(ctlarray); + o_nurbssurface.bezier_patches.toBezier(sknotvector, tknotvector, + ctrlarr, mapdesc.getNCoords()); + thread("do_nurbssurface", o_nurbssurface); + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Knotspec.java b/src/classes/com/sun/opengl/impl/nurbs/Knotspec.java new file mode 100755 index 000000000..9739e353c --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Knotspec.java @@ -0,0 +1,557 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Knot vector specification + * + * @author Tomas Hrasky + * + */ +class Knotspec { + + /** + * Begin of input knots + */ + public CArrayOfFloats inkbegin; + + /** + * End of input knots + */ + public CArrayOfFloats inkend; + + /** + * Stride before knot operations + */ + public int prestride; + + /** + * Curve order + */ + public int order; + + /** + * Next knot specification in linked list (used in surfaces) + */ + public Knotspec next; + + /** + * Last knot + */ + public CArrayOfFloats klast; + + /** + * First knot + */ + CArrayOfFloats kfirst; + + /** + * Beginning of breakpoints + */ + CArrayOfBreakpts bbegin; + + /** + * End of breakpoints + */ + CArrayOfBreakpts bend; + + /** + * Considered left end knot + */ + CArrayOfFloats kleft; + + /** + * Considered right end knot + */ + CArrayOfFloats kright; + + /** + * Offset before knot operations + */ + int preoffset; + + /** + * Control points array Length after knot operations + */ + int postwidth; + + /** + * Beginning of coeficients array + */ + private CArrayOfFloats sbegin; + + /** + * Beginning of output knots + */ + private CArrayOfFloats outkbegin; + + /** + * End of output knots + */ + private CArrayOfFloats outkend; + + /** + * Control points aray length before knot operations + */ + int prewidth; + + /** + * Offset after knot operations + */ + int postoffset; + + /** + * Number of control points' coordinates after knot operations + */ + public int poststride; + + /** + * Number of control points' coordinates + */ + public int ncoords; + + /** + * Tell whether knotspec has already benn transformed + */ + public boolean istransformed; + + /** + * Knotspec to be transformed + */ + public Knotspec kspectotrans; + + /** + * Finds knot border of knot insertion and required multiplicities + */ + public void preselect() { + // DONE + float kval; + + klast = new CArrayOfFloats(inkend); + klast.lessenPointerBy(order); + for (kval = klast.get(); klast.getPointer() != inkend.getPointer(); klast + .pp()) { + if (!Knotvector.identical(klast.get(), kval)) + break; + } + + kfirst = new CArrayOfFloats(inkbegin); + kfirst.raisePointerBy(order - 1); + for (kval = kfirst.get(); kfirst.getPointer() != inkend.getPointer(); kfirst + .pp()) { + if (!Knotvector.identical(kfirst.get(), kval)) + break; + } + + CArrayOfFloats k = new CArrayOfFloats(kfirst); + k.mm(); + + for (; k.getPointer() >= inkbegin.getPointer(); k.mm()) + if (!Knotvector.identical(kval, k.get())) + break; + k.pp(); + + Breakpt[] bbeginArray = new Breakpt[(klast.getPointer() - kfirst + .getPointer()) + 1]; + for (int i = 0; i < bbeginArray.length; i++) + bbeginArray[i] = new Breakpt(); + bbegin = new CArrayOfBreakpts(bbeginArray, 0); + bbegin.get().multi = kfirst.getPointer() - k.getPointer(); + bbegin.get().value = kval; + + bend = new CArrayOfBreakpts(bbegin); + kleft = new CArrayOfFloats(kfirst); + kright = new CArrayOfFloats(kfirst); + + } + + /** + * Perpares knotspec for transformation + */ + public void select() { + // DONE + breakpoints(); + knots(); + factors(); + + preoffset = kleft.getPointer() - (inkbegin.getPointer() + order); + postwidth = ((bend.getPointer() - bbegin.getPointer()) * order); + prewidth = (outkend.getPointer() - outkbegin.getPointer()) - order; + postoffset = (bbegin.get().def > 1) ? (bbegin.get().def - 1) : 0; + + } + + /** + * Computes alpha factors for computing new control points + */ + private void factors() { + // DONE + CArrayOfFloats mid = new CArrayOfFloats(outkend.getArray(), (outkend + .getPointer() - 1) + - order + bend.get().multi); + + CArrayOfFloats fptr = null; + if (sbegin != null) + fptr = new CArrayOfFloats(sbegin); + + for (CArrayOfBreakpts bpt = new CArrayOfBreakpts(bend); bpt + .getPointer() >= bbegin.getPointer(); bpt.mm()) { + mid.lessenPointerBy(bpt.get().multi); + int def = bpt.get().def - 1; + if (def < 0) + continue; + float kv = bpt.get().value; + + CArrayOfFloats kf = new CArrayOfFloats(mid.getArray(), (mid + .getPointer() - def) + + (order - 1)); + for (CArrayOfFloats kl = new CArrayOfFloats(kf.getArray(), kf + .getPointer() + + def); kl.getPointer() != kf.getPointer(); kl.mm()) { + CArrayOfFloats kh, kt; + for (kt = new CArrayOfFloats(kl), kh = new CArrayOfFloats(mid); kt + .getPointer() != kf.getPointer(); kh.mm(), kt.mm()) { + fptr.set((kv - kh.get()) / (kt.get() - kh.get())); + fptr.pp(); + } + kl.set(kv); + } + } + + } + + /** + * Makes new knot vector + */ + private void knots() { + // DONE + CArrayOfFloats inkpt = new CArrayOfFloats(kleft.getArray(), kleft + .getPointer() + - order); + CArrayOfFloats inkend = new CArrayOfFloats(kright.getArray(), kright + .getPointer() + + bend.get().def); + + outkbegin = new CArrayOfFloats(new float[inkend.getPointer() + - inkpt.getPointer()], 0); + CArrayOfFloats outkpt; + for (outkpt = new CArrayOfFloats(outkbegin); inkpt.getPointer() != inkend + .getPointer(); inkpt.pp(), outkpt.pp()) { + outkpt.set(inkpt.get()); + } + outkend = new CArrayOfFloats(outkpt); + } + + /** + * Analyzes breakpoints + */ + private void breakpoints() { + // DONE + CArrayOfBreakpts ubpt = new CArrayOfBreakpts(bbegin); + CArrayOfBreakpts ubend = new CArrayOfBreakpts(bend); + int nfactors = 0; + + ubpt.get().value = ubend.get().value; + ubpt.get().multi = ubend.get().multi; + + kleft = new CArrayOfFloats(kright); + + for (; kright.getPointer() != klast.getPointer(); kright.pp()) { + if (Knotvector.identical(kright.get(), ubpt.get().value)) { + ubpt.get().multi++; + } else { + ubpt.get().def = order - ubpt.get().multi; + nfactors += (ubpt.get().def * (ubpt.get().def - 1)) / 2; + ubpt.pp(); + ubpt.get().value = kright.get(); + ubpt.get().multi = 1; + } + } + ubpt.get().def = order - ubpt.get().multi; + nfactors += (ubpt.get().def * (ubpt.get().def - 1)) / 2; + + bend = new CArrayOfBreakpts(ubpt); + + if (nfactors > 0) { + sbegin = new CArrayOfFloats(new float[nfactors], 0); + } else { + sbegin = null; + } + + } + + /** + * Copies control points + * + * @param _inpt + * input control points + * @param _outpt + * output control points + */ + public void copy(CArrayOfFloats _inpt, CArrayOfFloats _outpt) { + CArrayOfFloats inpt = new CArrayOfFloats(_inpt); + CArrayOfFloats outpt = new CArrayOfFloats(_outpt); + + inpt.raisePointerBy(preoffset); + if (next != null) { + for (CArrayOfFloats lpt = new CArrayOfFloats(outpt.getArray(), + outpt.getPointer() + prewidth); outpt.getPointer() != lpt + .getPointer(); outpt.raisePointerBy(poststride)) { + next.copy(inpt, outpt); + inpt.raisePointerBy(prestride); + } + + } else { + for (CArrayOfFloats lpt = new CArrayOfFloats(outpt.getArray(), + outpt.getPointer() + prewidth); outpt.getPointer() != lpt + .getPointer(); outpt.raisePointerBy(poststride)) { + pt_io_copy(outpt, inpt); + inpt.raisePointerBy(prestride); + } + } + + } + + /** + * Copies one control point to other + * + * @param topt + * source control point + * @param frompt + * destination control point + */ + private void pt_io_copy(CArrayOfFloats topt, CArrayOfFloats frompt) { + // DONE + switch (ncoords) { + case 4: + topt.setRelative(3, frompt.getRelative(3)); + case 3: + topt.setRelative(2, frompt.getRelative(2)); + case 2: + topt.setRelative(1, frompt.getRelative(1)); + case 1: + topt.set(frompt.get()); + break; + default: + // TODO break with copying in general case + // System.out.println("TODO knotspec.pt_io_copy"); + break; + } + + } + + /** + * Inserts a knot + * + * @param _p + * inserted knot + */ + public void transform(CArrayOfFloats _p) { + CArrayOfFloats p = new CArrayOfFloats(_p); + // DONE + if (next != null) {//surface code + if (this.equals(kspectotrans)) { + next.transform(p); + } else { + if (istransformed) { + p.raisePointerBy(postoffset); + for (CArrayOfFloats pend = new CArrayOfFloats(p.getArray(), + p.getPointer() + postwidth); p.getPointer() != pend + .getPointer(); p.raisePointerBy(poststride)) + next.transform(p); + + } else { + CArrayOfFloats pend = new CArrayOfFloats(p.getArray(), p + .getPointer() + + prewidth); + for (; p.getPointer() != pend.getPointer(); p + .raisePointerBy(poststride)) + next.transform(p); + } + } + + } else {//code for curve + if (this.equals(kspectotrans)) { + insert(p); + } else { + if (istransformed) { + p.raisePointerBy(postoffset); + for (CArrayOfFloats pend = new CArrayOfFloats(p.getArray(), + p.getPointer() + postwidth); p.getPointer() != pend + .getPointer(); p.raisePointerBy(poststride)) { + kspectotrans.insert(p); + } + } else { + CArrayOfFloats pend = new CArrayOfFloats(p.getArray(), p + .getPointer() + + prewidth); + for (; p.getPointer() != pend.getPointer(); p + .raisePointerBy(poststride)) + kspectotrans.insert(p); + } + } + } + + } + + /** + * Inserts a knot and computes new control points + * + * @param p + * inserted knot + */ + private void insert(CArrayOfFloats p) { + // DONE + CArrayOfFloats fptr = null; + if (sbegin != null) + fptr = new CArrayOfFloats(sbegin); + CArrayOfFloats srcpt = new CArrayOfFloats(p.getArray(), p.getPointer() + + prewidth - poststride); + // CArrayOfFloats srcpt = new CArrayOfFloats(p.getArray(), prewidth - + // poststride); + CArrayOfFloats dstpt = new CArrayOfFloats(p.getArray(), p.getPointer() + + postwidth + postoffset - poststride); + // CArrayOfFloats dstpt = new CArrayOfFloats(p.getArray(), postwidth + + // postoffset - poststride); + CArrayOfBreakpts bpt = new CArrayOfBreakpts(bend); + + for (CArrayOfFloats pend = new CArrayOfFloats(srcpt.getArray(), srcpt + .getPointer() + - poststride * bpt.get().def); srcpt.getPointer() != pend + .getPointer(); pend.raisePointerBy(poststride)) { + CArrayOfFloats p1 = new CArrayOfFloats(srcpt); + for (CArrayOfFloats p2 = new CArrayOfFloats(srcpt.getArray(), srcpt + .getPointer() + - poststride); p2.getPointer() != pend.getPointer(); p1 + .setPointer(p2.getPointer()), p2 + .lessenPointerBy(poststride)) { + pt_oo_sum(p1, p1, p2, fptr.get(), 1.0 - fptr.get()); + fptr.pp(); + } + } + bpt.mm(); + for (; bpt.getPointer() >= bbegin.getPointer(); bpt.mm()) { + + for (int multi = bpt.get().multi; multi > 0; multi--) { + pt_oo_copy(dstpt, srcpt); + dstpt.lessenPointerBy(poststride); + srcpt.lessenPointerBy(poststride); + } + for (CArrayOfFloats pend = new CArrayOfFloats(srcpt.getArray(), + srcpt.getPointer() - poststride * bpt.get().def); srcpt + .getPointer() != pend.getPointer(); pend + .raisePointerBy(poststride), dstpt + .lessenPointerBy(poststride)) { + pt_oo_copy(dstpt, srcpt); + CArrayOfFloats p1 = new CArrayOfFloats(srcpt); + + for (CArrayOfFloats p2 = new CArrayOfFloats(srcpt.getArray(), + srcpt.getPointer() - poststride); p2.getPointer() != pend + .getPointer(); p1.setPointer(p2.getPointer()), p2 + .lessenPointerBy(poststride)) { + pt_oo_sum(p1, p1, p2, fptr.get(), 1.0 - fptr.get()); + fptr.pp(); + } + } + } + } + + /** + * Copies one control point to another + * + * @param topt + * source ctrl point + * @param frompt + * distance ctrl point + */ + private void pt_oo_copy(CArrayOfFloats topt, CArrayOfFloats frompt) { + // DONE + // this is a "trick" with case - "break" is omitted so it comes through all cases + switch (ncoords) { + case 4: + topt.setRelative(3, frompt.getRelative(3)); + case 3: + topt.setRelative(2, frompt.getRelative(2)); + case 2: + topt.setRelative(1, frompt.getRelative(1)); + case 1: + topt.setRelative(0, frompt.getRelative(0)); + break; + default: + // default uses memcpy but it is not needed (we probably won't have more than 4 coords) + // TODO not sure about it + break; + } + + } + + /** + * Computes new control point + * + * @param x + * first point + * @param y + * second point + * @param z + * third pont + * @param a + * alpha + * @param b + * 1 - alpha + */ + private void pt_oo_sum(CArrayOfFloats x, CArrayOfFloats y, + CArrayOfFloats z, float a, double b) { + // DONE + switch (ncoords) { + case 4: + x.setRelative(3, (float) (a * y.getRelative(3) + b + * z.getRelative(3))); + case 3: + x.setRelative(2, (float) (a * y.getRelative(2) + b + * z.getRelative(2))); + case 2: + x.setRelative(1, (float) (a * y.getRelative(1) + b + * z.getRelative(1))); + case 1: + x.setRelative(0, (float) (a * y.getRelative(0) + b + * z.getRelative(0))); + break; + default: + //no need of default - see previous method and its case statement + // System.out.println("TODO pt_oo_sum default"); + break; + } + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Knotvector.java b/src/classes/com/sun/opengl/impl/nurbs/Knotvector.java new file mode 100755 index 000000000..1442fe17d --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Knotvector.java @@ -0,0 +1,179 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Knot vector used in curve specification + * + * @author Tomas Hrasky + * + */ +class Knotvector { + + /** + * Tolerance used when comparing knots - when difference is smaller, knots + * are considered equal + */ + public static final float TOLERANCE = 1.0e-5f; + + /** + * Maximum curve order + */ + private static final int MAXORDER = 24; + + /** + * Number of knots + */ + int knotcount; + + /** + * Number of control points' coordinates + */ + int stride; + + /** + * Curve order + */ + int order; + + /** + * Knots + */ + float[] knotlist; + + /** + * Makes new knotvector + * + * @param nknots + * number of knots + * @param stride + * number of ctrl points' corrdinates + * @param order + * curve order + * @param knot + * knots + */ + public Knotvector(int nknots, int stride, int order, float[] knot) { + // DONE + init(nknots, stride, order, knot); + } + + /** + * Initializes knotvector + * + * @param nknots + * number of knots + * @param stride + * number of ctrl points' corrdinates + * @param order + * curve order + * @param knot + * knots + */ + public void init(int nknots, int stride, int order, float[] knot) { + // DONE + this.knotcount = nknots; + this.stride = stride; + this.order = order; + this.knotlist = new float[nknots]; + for (int i = 0; i < nknots; i++) { + this.knotlist[i] = knot[i]; + } + + } + + /** + * Validates knot vector parameters + * + * @return knot vector validity + */ + public int validate() { + int kindex = knotcount - 1; + if (order < 1 || order > MAXORDER) { + return 1; + } + if (knotcount < 2 * order) { + return 2; + } + if (identical(knotlist[kindex - (order - 1)], knotlist[order - 1])) { + return 3; + } + for (int i = 0; i < kindex; i++) { + if (knotlist[i] > knotlist[i + 1]) + return 4; + } + int multi = 1; + for (; kindex >= 1; kindex--) { + if (knotlist[kindex] - knotlist[kindex - 1] < TOLERANCE) { + multi++; + continue; + } + if (multi > order) { + return 5; + } + multi = 1; + } + if (multi > order) { + return 5; + } + + return 0; + } + + /** + * Show specified message + * + * @param msg + * message to be shown + */ + public void show(String msg) { + // TODO Auto-generated method stub + // System.out.println("TODO knotvector.show"); + + } + + /** + * Compares two knots for equality + * + * @param a + * first knot + * @param b + * second knot + * @return knots are/are not equal + */ + public static boolean identical(float a, float b) { + return ((a - b) < TOLERANCE) ? true : false; + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Mapdesc.java b/src/classes/com/sun/opengl/impl/nurbs/Mapdesc.java new file mode 100755 index 000000000..a6536dcb8 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Mapdesc.java @@ -0,0 +1,442 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Class holding properties of OpenGL map + * @author Tomas Hrasky + * + */ +class Mapdesc { + + /** + * Maximum control point coords + */ + private static final int MAXCOORDS = 5; + + /** + * Next description in list + */ + public Mapdesc next; + + /** + * Is map rational + */ + public int isrational; + + /** + * Number of control point coords + */ + public int ncoords; + + /** + * Map type + */ + private int type; + + /** + * Number of homogenous coords + */ + private int hcoords; + + /** + * Number of inhomogenous coords + */ + private int inhcoords; + + /** + * Not used + */ + private int mask; + + /** + * Value of N_PIXEL_TOLERANCE property + */ + private float pixel_tolerance; + + /** + * Value of N_ERROR_TOLERANCE property + */ + private float error_tolerance; + + /** + * Value of N_BBOX_SUBDIVIDING property + */ + private float bbox_subdividing; + + /** + * Value of N_CULLING property + */ + private float culling_method; + + /** + * Value of N_SAMPLINGMETHOD property + */ + private float sampling_method; + + /** + * Value of N_CLAMPFACTOR property + */ + float clampfactor; + + /** + * Value of N_MINSAVINGS property + */ + private float minsavings; + + /** + * Steps in u direction + */ + private float s_steps; + + /** + * Steps in v direction + */ + private float t_steps; + + /** + * Maximal step + */ + float maxrate; + + /** + * Maximal u direction step + */ + private float maxsrate; + + /** + * Maximal v direction step + */ + private float maxtrate; + + /** + * Not used + */ + private float[][] bmat; + + /** + * Sampling matrix + */ + private float[][] smat; + + /** + * Not used + */ + private float[][] cmat; + + /** + * Not used + */ + private float[] bboxsize; + + /** + * Makes new mapdesc + * @param type map type + * @param rational is rational + * @param ncoords number of control points coords + * @param backend backend object + */ + public Mapdesc(int type, int rational, int ncoords, Backend backend) { + // DONE + this.type = type; + this.isrational = rational; + this.ncoords = ncoords; + this.hcoords = ncoords + (isrational > 0 ? 0 : 1); + this.inhcoords = ncoords - (isrational > 0 ? 1 : 0); + this.mask = ((1 << (inhcoords * 2)) - 1); + next = null; + + assert (hcoords <= MAXCOORDS); + assert (inhcoords >= 1); + + pixel_tolerance = 1f; + error_tolerance = 1f; + bbox_subdividing = NurbsConsts.N_NOBBOXSUBDIVISION; + culling_method = NurbsConsts.N_NOCULLING; + sampling_method = NurbsConsts.N_NOSAMPLING; + clampfactor = NurbsConsts.N_NOCLAMPING; + minsavings = NurbsConsts.N_NOSAVINGSSUBDIVISION; + s_steps = 0f; + t_steps = 0f; + + maxrate = (s_steps < 0) ? 0 : s_steps; + maxsrate = (s_steps < 0) ? 0 : s_steps; + maxtrate = (t_steps < 0) ? 0 : t_steps; + bmat = new float[MAXCOORDS][MAXCOORDS]; + cmat = new float[MAXCOORDS][MAXCOORDS]; + smat = new float[MAXCOORDS][MAXCOORDS]; + + identify(bmat); + identify(cmat); + identify(smat); + bboxsize = new float[MAXCOORDS]; + for (int i = 0; i < inhcoords; i++) + bboxsize[i] = 1; + } + + /** + * Make matrix identity matrix + * @param arr matrix + */ + private void identify(float[][] arr) { + // DONE + for (int i = 0; i < MAXCOORDS; i++) + for (int j = 0; j < MAXCOORDS; j++) + arr[i][j] = 0; + for (int i = 0; i < MAXCOORDS; i++) + arr[i][i] = 1; + + } + + /** + * Tells whether tag is property tag + * @param tag property tag + * @return is/is not property + */ + public boolean isProperty(int tag) { + boolean ret; + switch (tag) { + case NurbsConsts.N_PIXEL_TOLERANCE: + case NurbsConsts.N_ERROR_TOLERANCE: + case NurbsConsts.N_CULLING: + case NurbsConsts.N_BBOX_SUBDIVIDING: + case NurbsConsts.N_S_STEPS: + case NurbsConsts.N_T_STEPS: + case NurbsConsts.N_SAMPLINGMETHOD: + case NurbsConsts.N_CLAMPFACTOR: + case NurbsConsts.N_MINSAVINGS: + ret = true; + break; + default: + ret = false; + break; + } + return ret; + } + + /** + * Returns number of control points' coords + * @return number of control points' coords + */ + public int getNCoords() { + return ncoords; + } + + /** + * Returns map type + * @return map type + */ + public int getType() { + return type; + } + + /** + * Tells whether map is range sampling + * @return is map range sampling + */ + public boolean isRangeSampling() { + // DONE + return (isParametricDistanceSampling() || isPathLengthSampling() + || isSurfaceAreaSampling() || isObjectSpaceParaSampling() || isObjectSpacePathSampling()); + } + + /** + * Tells whether map is object space sampling + * @return is map object space sampling + */ + private boolean isObjectSpacePathSampling() { + // DONE + return sampling_method == NurbsConsts.N_OBJECTSPACE_PATH; + } + + /** + * Tells whether map is object space parasampling + * @return is map object space parasampling + */ + private boolean isObjectSpaceParaSampling() { + // DONE + return sampling_method == NurbsConsts.N_OBJECTSPACE_PARA; + } + + /** + * Tells whether map is area sampling surface + * @return is map area sampling surface + */ + private boolean isSurfaceAreaSampling() { + // DONE + return sampling_method == NurbsConsts.N_SURFACEAREA; + } + + /** + * Tells whether map is path length sampling + * @return is map path length sampling + */ + boolean isPathLengthSampling() { + // DONE + return sampling_method == NurbsConsts.N_PATHLENGTH; + } + + /** + * Tells whether map is parametric distance sampling + * @return is map parametric distance sampling + */ + boolean isParametricDistanceSampling() { + // DONE + return sampling_method == NurbsConsts.N_PARAMETRICDISTANCE; + } + + /** + * Tells whether map is culling + * @return is map culling + */ + public boolean isCulling() { + // DONE + return culling_method != NurbsConsts.N_NOCULLING ? true : false; + } + + /** + * Tells whether map is constantly sampling + * @return is map constant sampling + */ + public boolean isConstantSampling() { + return (sampling_method == NurbsConsts.N_FIXEDRATE) ? true : false; + } + + /** + * Tells whether map is domain sampling + * @return is map domain sampling + */ + public boolean isDomainSampling() { + return (sampling_method == NurbsConsts.N_DOMAINDISTANCE) ? true : false; + } + + /** + * Returns property of specified tag value + * @param tag property tag + * @return property value + */ + public float getProperty(int tag) { + // TODO Auto-generated method stub + // System.out.println("TODO mapdesc.getproperty"); + return 0; + } + + /** + * Sets property with given tag + * @param tag property tag + * @param value desired value + */ + public void setProperty(int tag, float value) { + // TODO Auto-generated method stub + switch (tag) { + case NurbsConsts.N_PIXEL_TOLERANCE: + pixel_tolerance = value; + break; + case NurbsConsts.N_ERROR_TOLERANCE: + error_tolerance = value; + break; + case NurbsConsts.N_CULLING: + culling_method = value; + break; + case NurbsConsts.N_BBOX_SUBDIVIDING: + if (value <= 0) + value = NurbsConsts.N_NOBBOXSUBDIVISION; + bbox_subdividing = value; + break; + case NurbsConsts.N_S_STEPS: + if (value < 0) + value = 0; + s_steps = value; + maxrate = value; + maxsrate = value; + break; + case NurbsConsts.N_T_STEPS: + if (value < 0) + value = 0; + t_steps = value; + maxtrate = value; + break; + case NurbsConsts.N_SAMPLINGMETHOD: + sampling_method = value; + break; + case NurbsConsts.N_CLAMPFACTOR: + if (value < 0) + value = 0; + clampfactor = value; + break; + case NurbsConsts.N_MINSAVINGS: + if (value <= 0) + value = NurbsConsts.N_NOSAVINGSSUBDIVISION; + minsavings = value; + break; + } + } + + /** + * Samples curve + * @param pts control points + * @param order curve order + * @param stride number of control points' coordinates + * @param sp breakpoints + * @param outstride output number of control points' coordinates + */ + public void xformSampling(CArrayOfFloats pts, int order, int stride, + float[] sp, int outstride) { + // DONE + xFormMat(smat, pts, order, stride, sp, outstride); + } + + /** + * Empty method + * @param mat sampling matrix + * @param pts ontrol points + * @param order curve order + * @param stride number of control points' coordinates + * @param cp breakpoints + * @param outstride output number of control points' coordinates + */ + private void xFormMat(float[][] mat, CArrayOfFloats pts, int order, + int stride, float[] cp, int outstride) { + // TODO Auto-generated method stub + + // System.out.println("TODO mapdsc.xformmat ; change cp from float[] to carrayoffloats"); + + if (isrational > 0) { + + } else { + + } + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Maplist.java b/src/classes/com/sun/opengl/impl/nurbs/Maplist.java new file mode 100755 index 000000000..e6450f75d --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Maplist.java @@ -0,0 +1,122 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Class holding list of Mapdescs + * @author Tomáš Hráský + * + */ +class Maplist { + /** + * Head of linked list + */ + private Mapdesc maps; + + /** + * Backend class + */ + private Backend backend; + + /** + * Makes new Maplist + * @param backend Backend class + */ + public Maplist(Backend backend) { + this.backend = backend; + } + + /** + * Sets linked list beginning to null + */ + public void initialize() { + // TODO mapdespool.clear ? + maps = null; + } + + /** + * Defines new Mapdesc if it is not defined and appends it to linked list + * @param type map type + * @param rational is map rational + * @param ncoords number of coords + */ + public void define(int type, int rational, int ncoords) { + // DONE + Mapdesc m = locate(type); + assert (m == null || (m.isrational == rational && m.ncoords == ncoords)); + add(type, rational, ncoords); + + } + + /** + * Adds new Mapdesc to linked list + * @param type map type + * @param rational is map rational + * @param ncoords number of coords + */ + private void add(int type, int rational, int ncoords) { + // DONE + Mapdesc map = new Mapdesc(type, rational, ncoords, backend); + if (maps == null) { + maps = map; + } else { + map.next = maps; + maps = map; + } + } + + /** + * Tries to find Mapdesc in linked list + * @param type map type + * @return Mapdesc of type or null if there is no such map + */ + public Mapdesc locate(int type) { + // DONE + Mapdesc m = null; + for (m = maps; m != null; m = m.next) + if (m.getType() == type) + break; + return m; + } + + /** + * Alias for locate + * @param type maptype + * @return Mapdesc of type or null if there is no such map + */ + public Mapdesc find(int type) { + return locate(type); + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/NurbsConsts.java b/src/classes/com/sun/opengl/impl/nurbs/NurbsConsts.java new file mode 100755 index 000000000..0ff77069b --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/NurbsConsts.java @@ -0,0 +1,184 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Class hodling NURBS constants as seen in OpenGL GLU documentation + * @author JOGL project + * + */ +class NurbsConsts { + /* + * NURBS Properties - one set per map, each takes a single INREAL arg + */ + public static final int N_SAMPLING_TOLERANCE = 1; + + public static final int N_S_RATE = 6; + + public static final int N_T_RATE = 7; + + public static final int N_CLAMPFACTOR = 13; + + public static final float N_NOCLAMPING = 0.0f; + + public static final int N_MINSAVINGS = 14; + + public static final float N_NOSAVINGSSUBDIVISION = 0.0f; + + /* + * NURBS Properties - one set per map, each takes an enumerated value + */ + public static final int N_CULLING = 2; + + public static final float N_NOCULLING = 0.0f; + + public static final float N_CULLINGON = 1.0f; + + public static final int N_SAMPLINGMETHOD = 10; + + public static final float N_NOSAMPLING = 0.0f; + + public static final float N_FIXEDRATE = 3.0f; + + public static final float N_DOMAINDISTANCE = 2.0f; + + public static final float N_PARAMETRICDISTANCE = 5.0f; + + public static final float N_PATHLENGTH = 6.0f; + + public static final float N_SURFACEAREA = 7.0f; + + public static final float N_OBJECTSPACE_PARA = 8.0f; + + public static final float N_OBJECTSPACE_PATH = 9.0f; + + public static final int N_BBOX_SUBDIVIDING = 17; + + public static final float N_NOBBOXSUBDIVISION = 0.0f; + + public static final float N_BBOXTIGHT = 1.0f; + + public static final float N_BBOXROUND = 2.0f; + + /* + * NURBS Rendering Properties - one set per renderer each takes an + * enumerated value + */ + public static final int N_DISPLAY = 3; + + public static final int N_FILL = 1; + + public static final int N_OUTLINE_POLY = 2; + + public static final int N_OUTLINE_TRI = 3; + + public static final int N_OUTLINE_QUAD = 4; + + public static final int N_OUTLINE_PATCH = 5; + + public static final int N_OUTLINE_PARAM = 6; + + public static final int N_OUTLINE_PARAM_S = 7; + + public static final int N_OUTLINE_PARAM_ST = 8; + + public static final int N_OUTLINE_SUBDIV = 9; + + public static final int N_OUTLINE_SUBDIV_S = 10; + + public static final int N_OUTLINE_SUBDIV_ST = 11; + + public static final int N_ISOLINE_S = 12; + + public static final int N_ERRORCHECKING = 4; + + public static final int N_NOMSG = 0; + + public static final int N_MSG = 1; + + /* GL 4.0 propeties not defined above */ + + public static final int N_PIXEL_TOLERANCE = N_SAMPLING_TOLERANCE; + + public static final int N_ERROR_TOLERANCE = 20; + + public static final int N_SUBDIVISIONS = 5; + + public static final int N_TILES = 8; + + public static final int N_TMP1 = 9; + + public static final int N_TMP2 = N_SAMPLINGMETHOD; + + public static final int N_TMP3 = 11; + + public static final int N_TMP4 = 12; + + public static final int N_TMP5 = N_CLAMPFACTOR; + + public static final int N_TMP6 = N_MINSAVINGS; + + public static final int N_S_STEPS = N_S_RATE; + + public static final int N_T_STEPS = N_T_RATE; + + /* + * NURBS Rendering Properties - one set per map, each takes an INREAL matrix + * argument + */ + public static final int N_CULLINGMATRIX = 1; + + public static final int N_SAMPLINGMATRIX = 2; + + public static final int N_BBOXMATRIX = 3; + + /* + * NURBS Rendering Properties - one set per map, each takes an INREAL vector + * argument + */ + public static final int N_BBOXSIZE = 4; + + /* type argument for trimming curves */ + + public static final int N_P2D = 0x8; + + public static final int N_P2DR = 0xd; + + public static final int N_MESHLINE = 1; + + public static final int N_MESHFILL = 0; + + public static final int N_MESHPOINT = 2; +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/O_curve.java b/src/classes/com/sun/opengl/impl/nurbs/O_curve.java new file mode 100755 index 000000000..1a88d427f --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/O_curve.java @@ -0,0 +1,63 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Struct holding curve links + * @author Tomáš Hráský + * + */ +class O_curve { + + /** + * Curve type + */ + public int curvetype; + + /** + * Next curve in linked list + */ + public O_curve next; + + /** + * Curve of picewiselinear type + */ + public O_pwlcurve o_pwlcurve; + + /** + * NURBS curve + */ + public O_nurbscurve o_nurbscurve; +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/O_nurbscurve.java b/src/classes/com/sun/opengl/impl/nurbs/O_nurbscurve.java new file mode 100755 index 000000000..634558815 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/O_nurbscurve.java @@ -0,0 +1,80 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * NURBS curve object + * @author Tomáš Hráský + * + */ +class O_nurbscurve { + + /** + * List of bezier curves + */ + public Quilt bezier_curves; + + /** + * Curve type + */ + public int type; + + /** + * Was curve used ? + */ + boolean used; + + /** + * Parent curve + */ + O_curve owner; + + /** + * Next curve in list + */ + O_nurbscurve next; + + /** + * Makes new O_nurbscurve + * @param realType type of curve + */ + public O_nurbscurve(int realType) { + // DONE + this.type = realType; + this.owner = null; + this.next = null; + this.used = false; + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/O_nurbssurface.java b/src/classes/com/sun/opengl/impl/nurbs/O_nurbssurface.java new file mode 100755 index 000000000..7497b8c0f --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/O_nurbssurface.java @@ -0,0 +1,79 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * NURBS surface object + * @author Tomáš Hráský + * + */ +class O_nurbssurface { + + /** + * List of bezier patches forming NURBS surface + */ + public Quilt bezier_patches; + + /** + * Was surface used + */ + public boolean used; + + /** + * Parent O_surface + */ + public O_surface owner; + + /** + * Next surface in list + */ + public O_nurbssurface next; + + /** + * Surface type + */ + private int type; + + /** + * Makes new O_nurbssurface of type + * @param type surface type + */ + public O_nurbssurface(int type) { + this.type = type; + this.owner = null; + this.next = null; + this.used = false; + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/O_pwlcurve.java b/src/classes/com/sun/opengl/impl/nurbs/O_pwlcurve.java new file mode 100755 index 000000000..460136d49 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/O_pwlcurve.java @@ -0,0 +1,44 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Empty class + * @author Tomáš Hráský + * + */ +class O_pwlcurve { + +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/O_surface.java b/src/classes/com/sun/opengl/impl/nurbs/O_surface.java new file mode 100755 index 000000000..009953147 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/O_surface.java @@ -0,0 +1,52 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Surface object + * @author Tomáš Hráský + * + */ +class O_surface { + /** + * NURBS surface + */ + O_nurbssurface o_nurbssurface; + + /** + * Trims + */ + O_trim o_trim; +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/O_trim.java b/src/classes/com/sun/opengl/impl/nurbs/O_trim.java new file mode 100755 index 000000000..ccbcc12f0 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/O_trim.java @@ -0,0 +1,44 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Empty class + * @author Tomáš Hráský + * + */ +class O_trim { + +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/OpenGLCurveEvaluator.java b/src/classes/com/sun/opengl/impl/nurbs/OpenGLCurveEvaluator.java new file mode 100755 index 000000000..65ec983c4 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/OpenGLCurveEvaluator.java @@ -0,0 +1,202 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +import javax.media.opengl.GL; +import javax.media.opengl.glu.GLU; + +/** + * Class rendering curves with OpenGL + * @author Tomáš Hráský + * + */ +class OpenGLCurveEvaluator { + + /** + * Output triangles (for callback) or render curve + */ + private boolean output_triangles; + + /** + * OpenGL object + */ + private GL gl; + + /** + * Not used + */ + private int vertex_flag; + + /** + * Not used + */ + private int normal_flag; + + /** + * Not used + */ + private int color_flag; + + /** + * Not used + */ + private int texcoord_flag; + + /** + * Number of bezier arc - used for color distinguishing of arcs forming NURBS curve + */ + private int poradi; + + /** + * Makes new Evaluator + */ + public OpenGLCurveEvaluator() { + gl = GLU.getCurrentGL(); + } + + /** + * Pushes eval bit + */ + public void bgnmap1f() { + // DONE + if (output_triangles) { + vertex_flag = 0; + normal_flag = 0; + color_flag = 0; + texcoord_flag = 0; + } else { + gl.glPushAttrib(GL.GL_EVAL_BIT); + } + + } + + /** + * Pops all OpenGL attributes + */ + public void endmap1f() { + // DONE + if (output_triangles) { + + } else { + gl.glPopAttrib(); + } + + } + + /** + * Initializes opengl evaluator + * @param type curve type + * @param ulo lowest u + * @param uhi highest u + * @param stride control point coords + * @param order curve order + * @param ps control points + */ + public void map1f(int type, float ulo, float uhi, int stride, int order, + CArrayOfFloats ps) { + if (output_triangles) { + // TODO code for callback (output_triangles probably indicates callback) + // System.out.println("TODO curveevaluator.map1f-output_triangles"); + } else { + gl.glMap1f(type, ulo, uhi, stride, order, ps.getArray(), ps + .getPointer()); + + // DEBUG - drawing bézier control points + // gl.glColor3d(.5,.5,.5); + // gl.glPointSize(5); + // gl.glBegin(GL.GL_POINTS); + // float[] ctrlpoints=ps.getArray(); + // for(int i=ps.getPointer();i<ps.getPointer()+order;i++){ + // gl.glVertex3d(ctrlpoints[i * 4], ctrlpoints[i * 4 + 1],0); + // } + // gl.glEnd(); + } + + } + + /** + * Calls opengl enable + * @param type what to enable + */ + public void enable(int type) { + // DONE + gl.glEnable(type); + } + + /** + * Calls glMapGrid1f + * @param nu steps + * @param u1 low u + * @param u2 high u + */ + public void mapgrid1f(int nu, float u1, float u2) { + if (output_triangles) { + // System.out.println("TODO curveevaluator.mapgrid1f"); + } else + gl.glMapGrid1f(nu, u1, u2); + // // System.out.println("upravit NU"); + // gl.glMapGrid1f(50,u1,u2); + } + + /** + * Evaluates a curve using glEvalMesh1f + * @param style Backend.N_MESHFILL/N_MESHLINE/N_MESHPOINT + * @param from lowest param + * @param to highest param + */ + public void mapmesh1f(int style, int from, int to) { + /* //DEBUG drawing control points + this.poradi++; + if (poradi % 2 == 0) + gl.glColor3f(1, 0, 0); + else + gl.glColor3f(0, 1, 0); + */ + if (output_triangles) { + // TODO code for callback + // System.out.println("TODO openglcurveevaluator.mapmesh1f output_triangles"); + } else { + switch (style) { + case Backend.N_MESHFILL: + case Backend.N_MESHLINE: + gl.glEvalMesh1(GL.GL_LINE, from, to); + break; + case Backend.N_MESHPOINT: + gl.glEvalMesh1(GL.GL_POINT, from, to); + break; + } + } + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/OpenGLSurfaceEvaluator.java b/src/classes/com/sun/opengl/impl/nurbs/OpenGLSurfaceEvaluator.java new file mode 100755 index 000000000..2c31bc2bc --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/OpenGLSurfaceEvaluator.java @@ -0,0 +1,214 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +import javax.media.opengl.GL; +import javax.media.opengl.glu.GLU; + +/** + * Class rendering surfaces with OpenGL + * @author Tomas Hrasky + * + */ +class OpenGLSurfaceEvaluator { + + /** + * JOGL OpenGL object + */ + private GL gl; + + /** + * Output triangles (callback) + */ + private boolean output_triangles; + + /** + * Number of patch - used for distinguishing bezier plates forming NURBS surface with different colors + */ + private int poradi; + + /** + * Creates new evaluator + */ + public OpenGLSurfaceEvaluator() { + gl = GLU.getCurrentGL(); + } + + /** + * Pushes eval bit + */ + public void bgnmap2f() { + + if (output_triangles) { + // TODO outp triangles surfaceevaluator bgnmap2f + // System.out.println("TODO surfaceevaluator.bgnmap2f output triangles"); + } else { + gl.glPushAttrib(GL.GL_EVAL_BIT); + // System.out.println("TODO surfaceevaluator.bgnmap2f glgetintegerv"); + } + + } + + /** + * Sets glPolygonMode + * @param style polygon mode (N_MESHFILL/N_MESHLINE/N_MESHPOINT) + */ + public void polymode(int style) { + if (!output_triangles) { + switch (style) { + default: + case NurbsConsts.N_MESHFILL: + gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_FILL); + break; + case NurbsConsts.N_MESHLINE: + gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_LINE); + break; + case NurbsConsts.N_MESHPOINT: + gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_POINT); + break; + } + } + + } + + /** + * Pops all attributes + */ + public void endmap2f() { + // TODO Auto-generated method stub + if (output_triangles) { + // System.out.println("TODO surfaceevaluator.endmap2f output triangles"); + } else { + gl.glPopAttrib(); + // TODO use LOD + } + } + + /** + * Empty method + * @param ulo + * @param uhi + * @param vlo + * @param vhi + */ + public void domain2f(float ulo, float uhi, float vlo, float vhi) { + // DONE + } + + /** + * Defines 2D mesh + * @param nu number of steps in u direction + * @param u0 lowest u + * @param u1 highest u + * @param nv number of steps in v direction + * @param v0 lowest v + * @param v1 highest v + */ + public void mapgrid2f(int nu, float u0, float u1, int nv, float v0, float v1) { + + if (output_triangles) { + // System.out.println("TODO openglsurfaceavaluator.mapgrid2f output_triangles"); + } else { + gl.glMapGrid2d(nu, u0, u1, nv, v0, v1); + } + + } + + /** + * Evaluates surface + * @param style surface style + * @param umin minimum U + * @param umax maximum U + * @param vmin minimum V + * @param vmax maximum V + */ + public void mapmesh2f(int style, int umin, int umax, int vmin, int vmax) { + if (output_triangles) { + // System.out.println("TODO openglsurfaceavaluator.mapmesh2f output_triangles"); + } else { + /* //DEBUG - draw control points + this.poradi++; + if (poradi % 2 == 0) + gl.glColor3f(1, 0, 0); + else if (poradi % 2 == 1) + gl.glColor3f(0, 1, 0); + */ + switch (style) { + case NurbsConsts.N_MESHFILL: + gl.glEvalMesh2(GL.GL_FILL, umin, umax, vmin, vmax); + break; + case NurbsConsts.N_MESHLINE: + gl.glEvalMesh2(GL.GL_LINE, umin, umax, vmin, vmax); + break; + case NurbsConsts.N_MESHPOINT: + gl.glEvalMesh2(GL.GL_POINT, umin, umax, vmin, vmax); + break; + } + } + } + + /** + * Initializes evaluator + * @param type surface type + * @param ulo lowest u + * @param uhi highest u + * @param ustride number of objects between control points in u direction + * @param uorder surface order in u direction + * @param vlo lowest v + * @param vhi highest v + * @param vstride number of control points' coords + * @param vorder surface order in v direction + * @param pts control points + */ + public void map2f(int type, float ulo, float uhi, int ustride, int uorder, + float vlo, float vhi, int vstride, int vorder, CArrayOfFloats pts) { + // TODO Auto-generated method stub + if (output_triangles) { + // System.out.println("TODO openglsurfaceevaluator.map2f output_triangles"); + } else { + gl.glMap2f(type, ulo, uhi, ustride, uorder, vlo, vhi, vstride, + vorder, pts.getArray(), pts.getPointer()); + } + } + + /** + * Calls opengl enable + * @param type what to enable + */ + public void enable(int type) { + //DONE + gl.glEnable(type); + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Patch.java b/src/classes/com/sun/opengl/impl/nurbs/Patch.java new file mode 100755 index 000000000..176f58cbf --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Patch.java @@ -0,0 +1,54 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Empty class + * @author Tomas Hrasky + * + */ +class Patch { + + /** + * Empty constructor + * @param q + * @param pta + * @param ptb + * @param patch + */ + public Patch(Quilt q, float[] pta, float[] ptb, Patch patch) { + // System.out.println("TODO patch.constructor"); + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Patchlist.java b/src/classes/com/sun/opengl/impl/nurbs/Patchlist.java new file mode 100755 index 000000000..0eba45b34 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Patchlist.java @@ -0,0 +1,145 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * List of patches + * @author Tomáš Hráský + * + */ +class Patchlist { + + /** + * Array of ranges + */ + public Pspec[] pspec; + + /** + * head of list of patches + */ + private Patch patch; + + /** + * Makes new list of patches + * @param quilts list of quilts + * @param pta low border + * @param ptb high border + */ + public Patchlist(Quilt quilts, float[] pta, float[] ptb) { + // DONE + patch = null; + + for (Quilt q = quilts; q != null; q = q.next) + patch = new Patch(q, pta, ptb, patch); + pspec[0] = new Pspec(); + pspec[0].range[0] = pta[0]; + pspec[0].range[1] = ptb[0]; + pspec[0].range[2] = ptb[0] - pta[0]; + pspec[1] = new Pspec(); + pspec[1].range[0] = pta[1]; + pspec[1].range[1] = ptb[1]; + pspec[1].range[2] = ptb[1] - pta[1]; + + } + + /** + * Empty constructor + * @param patchlist + * @param param + * @param mid + */ + public Patchlist(Patchlist patchlist, int param, float mid) { + // TODO Auto-generated constructor stub + // System.out.println("TODO patchlist.konstruktor 2"); + } + + /** + * Empty method + * @return 0 + */ + public int cullCheck() { + // TODO Auto-generated method stub + // System.out.println("TODO patchlist.cullcheck"); + return 0; + } + + /** + * Empty method + */ + public void getstepsize() { + // System.out.println("TODO patchlist.getsptepsize"); + // TODO Auto-generated method stub + + } + + /** + * Empty method + * @return false + */ + public boolean needsSamplingSubdivision() { + // TODO Auto-generated method stub + // System.out.println("patchlist.needsSamplingSubdivision"); + return false; + } + + /** + * Empty method + * @param i + * @return false + */ + public boolean needsSubdivision(int i) { + // TODO Auto-generated method stub + // System.out.println("TODO patchlist.needsSubdivision"); + return false; + } + + /** + * Empty method + * @return false + */ + public boolean needsNonSamplingSubdivision() { + // TODO Auto-generated method stub + // System.out.println("TODO patchlist.needsNonSamplingSubdivision"); + return false; + } + + /** + * Empty method + */ + public void bbox() { + // TODO Auto-generated method stub + // System.out.println("TODO patchlist.bbox"); + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Property.java b/src/classes/com/sun/opengl/impl/nurbs/Property.java new file mode 100755 index 000000000..2304973ab --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Property.java @@ -0,0 +1,75 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Class representing property + * + * @author Tomas Hrasky + * + */ +class Property { + + /** + * Property type + */ + int type; + + /** + * Property id + */ + int tag; + + /** + * Property value + */ + float value; + + /** + * Makes new property with given parameters + * + * @param type + * property type + * @param tag + * property id + * @param value + * property value + */ + public Property(int type, int tag, float value) { + this.type = type; + this.tag = tag; + this.value = value; + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Pspec.java b/src/classes/com/sun/opengl/impl/nurbs/Pspec.java new file mode 100755 index 000000000..b6439a73d --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Pspec.java @@ -0,0 +1,47 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Class holding range + * @author Tomáš Hráský + * + */ +class Pspec { + /** + * Range + */ + public float[] range; +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/PwlArc.java b/src/classes/com/sun/opengl/impl/nurbs/PwlArc.java new file mode 100755 index 000000000..d6c2bbbdb --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/PwlArc.java @@ -0,0 +1,71 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Picewiselinar trimming arc + * @author Tomáš Hráský + * + */ +class PwlArc { + + /** + * Number of points + */ + private int npts; + + /** + * Vertexes + */ + public TrimVertex[] pts; + + /** + * Arc type + */ + private int type; + + /** + * Makes new trimming arc + * @param i num ber of vertexes + * @param p trimming vertexes array + */ + public PwlArc(int i, TrimVertex[] p) { + // DONE + this.npts = i; + this.pts = p; + type = NurbsConsts.N_P2D; + + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Quilt.java b/src/classes/com/sun/opengl/impl/nurbs/Quilt.java new file mode 100755 index 000000000..f5b566e76 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Quilt.java @@ -0,0 +1,282 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Class for converting NURBS curves and surfaces to list of bezier arcs or patches repectively + * @author Tomáš Hráský + * + */ +class Quilt { + /** + * Maximum quilt dimension + */ + private static final int MAXDIM = 2; + + /** + * List of map descriptions + */ + Mapdesc mapdesc; + + /** + * Array of quiltspecs pointer + */ + public CArrayOfQuiltspecs qspec; + + /** + * End array of quilt specs pointer + */ + public CArrayOfQuiltspecs eqspec; + + /** + * Control points + */ + public CArrayOfFloats cpts; + + /** + * Next quilt in list + */ + public Quilt next; + + /** + * Makes new quilt with mapdesc + * @param mapdesc map description + */ + public Quilt(Mapdesc mapdesc) { + // DONE + this.mapdesc = mapdesc; + Quiltspec[] tmpquilts = new Quiltspec[MAXDIM]; + for (int i = 0; i < tmpquilts.length; i++) + tmpquilts[i] = new Quiltspec(); + this.qspec = new CArrayOfQuiltspecs(tmpquilts); + + } + + /** + * Converts NURBS surface to bezier patches + * @param sknotvector knots in u direction + * @param tknotvector knots in v direction + * @param ctrlarr control points + * @param coords control points coords + */ + public void toBezier(Knotvector sknotvector, Knotvector tknotvector, + CArrayOfFloats ctrlarr, int coords) { + Splinespec spline = new Splinespec(2); + spline.kspecinit(sknotvector, tknotvector); + spline.select(); + spline.layout(coords); + spline.setupquilt(this); + spline.copy(ctrlarr); + spline.transform(); + } + + /** + * Converts NURBS curve to list of bezier curves + * @param knots knot vector + * @param ctlarray control points + * @param ncoords number of coordinates + */ + public void toBezier(Knotvector knots, CArrayOfFloats ctlarray, int ncoords) { + // DONE + Splinespec spline = new Splinespec(1); + spline.kspecinit(knots); + spline.select(); + spline.layout(ncoords); + spline.setupquilt(this); + spline.copy(ctlarray); + spline.transform(); + } + + /** + * Walks thru all arcs/patches + * @param pta low border + * @param ptb high border + * @param backend Backend + */ + public void downloadAll(float[] pta, float[] ptb, Backend backend) { + // DONE + for (Quilt m = this; m != null; m = m.next) { + m.select(pta, ptb); + m.download(backend); + } + + } + + /** + * Renders arcs/patches + * @param backend Backend for rendering + */ + private void download(Backend backend) { + // DONE + if (getDimension() == 2) { + + CArrayOfFloats ps = new CArrayOfFloats(cpts); + ps.raisePointerBy(qspec.get(0).offset); + ps.raisePointerBy(qspec.get(1).offset); + ps.raisePointerBy(qspec.get(0).index * qspec.get(0).order + * qspec.get(0).stride); + ps.raisePointerBy(qspec.get(1).index * qspec.get(1).order + * qspec.get(1).stride); + + backend.surfpts(mapdesc.getType(), ps, qspec.get(0).stride, qspec + .get(1).stride, qspec.get(0).order, qspec.get(1).order, + qspec.get(0).breakpoints[qspec.get(0).index], + qspec.get(0).breakpoints[qspec.get(0).index + 1], qspec + .get(1).breakpoints[qspec.get(1).index], qspec + .get(1).breakpoints[qspec.get(1).index + 1]); + + } else {// code for curves + // CArrayOfFloats ps=new CArrayOfFloats(cpts); + CArrayOfFloats ps = new CArrayOfFloats(cpts.getArray(), 0); + ps.raisePointerBy(qspec.get(0).offset); + ps.raisePointerBy(qspec.get(0).index * qspec.get(0).order + * qspec.get(0).stride); + backend.curvpts(mapdesc.getType(), ps, qspec.get(0).stride, qspec + .get(0).order, + qspec.get(0).breakpoints[qspec.get(0).index], + qspec.get(0).breakpoints[qspec.get(0).index + 1]); + } + + } + + /** + * Returns quilt dimension + * @return quilt dimesion + */ + private int getDimension() { + // DONE + return eqspec.getPointer() - qspec.getPointer(); + } + + /** + * Finds Quiltspec.index + * @param pta range + * @param ptb range + */ + private void select(float[] pta, float[] ptb) { + // DONE + int dim = eqspec.getPointer() - qspec.getPointer(); + int i, j; + for (i = 0; i < dim; i++) { + for (j = qspec.get(i).width - 1; j >= 0; j--) + if (qspec.get(i).breakpoints[j] <= pta[i] + && ptb[i] <= qspec.get(i).breakpoints[j + 1]) + break; + assert (j != -1); + qspec.get(i).index = j; + } + } + + /** + * Find range according to breakpoints + * @param from low param + * @param to high param + * @param bpts breakpoints + */ + public void getRange(float[] from, float[] to, Flist bpts) { + // DONE + getRange(from, to, 0, bpts); + + } + + /** + * Find range according to breakpoints + * @param from low param + * @param to high param + * @param i from/to array index + * @param list breakpoints + */ + private void getRange(float[] from, float[] to, int i, Flist list) { + // DONE + Quilt maps = this; + from[i] = maps.qspec.get(i).breakpoints[0]; + to[i] = maps.qspec.get(i).breakpoints[maps.qspec.get(i).width]; + int maxpts = 0; + Quilt m; + for (m = maps; m != null; m = m.next) { + if (m.qspec.get(i).breakpoints[0] > from[i]) + from[i] = m.qspec.get(i).breakpoints[0]; + if (m.qspec.get(i).breakpoints[m.qspec.get(i).width] < to[i]) + to[i] = m.qspec.get(i).breakpoints[m.qspec.get(i).width]; + maxpts += m.qspec.get(i).width + 1; + } + list.grow(maxpts); + for (m = maps; m != null; m = m.next) { + for (int j = 0; j <= m.qspec.get(i).width; j++) { + list.add(m.qspec.get(i).breakpoints[j]); + } + } + list.filter(); + list.taper(from[i], to[i]); + } + + /** + * Is this quilt culled + * @return 0 or Subdivider.CULL_ACCEPT + */ + public int isCulled() { + if (mapdesc.isCulling()) { + // System.out.println("TODO quilt.isculled mapdesc.isculling"); + return 0; + } else { + return Subdivider.CULL_ACCEPT; + } + } + + /** + * Finds range for surface + * @param from low param + * @param to high param + * @param slist u direction breakpoints + * @param tlist v direction breakpoints + */ + public void getRange(float[] from, float[] to, Flist slist, Flist tlist) { + // DONE + getRange(from, to, 0, slist); + getRange(from, to, 1, tlist); + + } + + /** + * Empty method + * @param sbrkpts + * @param tbrkpts + * @param rate + */ + public void findRates(Flist sbrkpts, Flist tbrkpts, float[] rate) { + // TODO Auto-generated method stub + // System.out.println("TODO quilt.findrates"); + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Quiltspec.java b/src/classes/com/sun/opengl/impl/nurbs/Quiltspec.java new file mode 100755 index 000000000..1b41c5168 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Quiltspec.java @@ -0,0 +1,85 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Quilt definition + * @author Tomas Hrasky + * + */ +class Quiltspec { + + /** + * Stride between control points + */ + public int stride; + + /** + * Quilt width in breakpoints + */ + public int width; + + /** + * Quilt order + */ + public int order; + + /** + * Start offset + */ + public int offset; + + /** + * Breakpoint index + */ + public int index; + + /** + * Boundary + */ + public int[] bdry; + + /** + * Breakpoints + */ + public float[] breakpoints; + + /** + * Makes new quiltspec + */ + public Quiltspec() { + this.bdry = new int[2]; + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/README-PORTING.txt b/src/classes/com/sun/opengl/impl/nurbs/README-PORTING.txt deleted file mode 100644 index df5f41782..000000000 --- a/src/classes/com/sun/opengl/impl/nurbs/README-PORTING.txt +++ /dev/null @@ -1,40 +0,0 @@ -This is a currently incomplete port of SGI's GLU NURBS library from -C++ to Java. There are a few reasons for doing such a port: - - - The C interface is structured around function pointers. It is - generally difficult to bind such interfaces up to Java. - - - Some people have reported crashes on certain Linux distributions - when trying to use any routines out of the C GLU library. To date - we have not been able to diagnose the root cause of these failures. - Porting the code involved from C++ to Java has solved these - problems. - -The port so far has been started in the internals/ directory. The C++ -sources have been gone through roughly alphabetically and -transliterated into the appropriate files. The large Subdivider class -was the current focus of attention at the time of this writing, and a -closer look indicates that at least a few classes were skipped on the -way down to some of the Subdivider's sources like intersect.cc. It may -be a good idea to continue the port in this directory first, since it -looks like the other directories' sources are built on top of these -and it would be good to firm up the Java interfaces for the internals -(and perhaps get the sources to compile) before porting lots of code -built on top of them. - -A couple of notes on the translation: - - - All object pool classes have been removed. The intention is to have - a static allocate() method on the appropriate classes which will - instantiate populated arrays of these types (not just arrays of - null references). See uses of TrimVertex.allocate(). - - - There are a significant number of places in the original C++ code - where pointer arithmetic is used. Some of these are not obvious - until the code has been ported and examined. Bin.java was a good - example of this where the algorithms needed some restructuring. At - the time of this writing intersect.cc was in the process of being - ported and it wasn't clear whether we would need to change some of - the APIs or add more utility routines to be able to do pointer - arithmetic on, for example, the TrimVertex arrays returned from the - allocate() routine. diff --git a/src/classes/com/sun/opengl/impl/nurbs/README.txt b/src/classes/com/sun/opengl/impl/nurbs/README.txt new file mode 100755 index 000000000..89630c71e --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/README.txt @@ -0,0 +1,59 @@ +Unimplemented functionality + - tesselation and callbacks + - trimming + - setting NURBS properties (-> sampling etc.) +Differences from C++ source + - no pooling + - pointers to arrays are replaced by CArrayOf... classes and their methods +Unimplemented or incomplete "calltree top" methods (according to glu.def in Mesa 6.5) + gluBeginTrim + gluDeleteNurbsRenderer - won't be needed + gluEndTrim + gluGetNurbsProperty + gluLoadSamplingMatrices + gluNurbsCallback + gluNurbsCallbackData + gluNurbsCallbackDataEXT + gluNurbsCurve - TODO type switch + gluNurbsProperty + gluPwlCurve + gluQuadricCallback - not a NURBS method +As of files + - Arc[ST]dirSorter.java - unimplemented (part of tesselation) + - Backend.java:194 - wireframe quads - part of tesselation/callback + - Curve.java:141-204 - culling + - DisplayList.java:57 - append to DL - not sure whether it will be needed + - GLUnurbs.java :443,484 - error values + :445 - trimming + :512 - error handling (callback) + :530 - loadGLmatrices + :786 - nuid - nurbs object id - won't be needed I think + :803 - end trim + - GLUwNURBS.java:68,176 - NUBRS properties + - Knotspec.java :371 - copying in general case (more than 4 coords) + :517 - copying with more than 4 coords + :556 - pt_oo_sum default + - Knotvector.java:165 - show method (probably debugging) + - Mapdesc.java :354 - get property + :435 - xFormMat - change param cp to CArrayOfFloats; probably sampling functionality + - Maplist.java:68 - clear ? + - OpenGLCurveEvaluator.java :132 - tess./callback code + :168 - mapgrid1f + :190 - tess./callback code (output triangles) + - OpenGLSurfaceEvaluator.java :77 . tess./callback code + :81 - glGetIntegerValue + :114 - tess./callback code + :117 - Level of detail + :144,161,201 - tess./callback code - output triangles + - Patch.java:55 - constructor stuff ? + - Patchlist.java:55 - constructor stuff ? + :97 - cull check + :105 - step size + :115 - need of sampling subdivision + :126 - need of subdivision + :137 - need of non sampling subd. + :146 - bbox (??) + -Quilt.java :254 - culling + :282 - rates + -Subdivider.java - all TODOs - it's stuff about trimming probably + :545 - jumpbuffer - not sure purpose it exactly served in original source diff --git a/src/classes/com/sun/opengl/impl/nurbs/Renderhints.java b/src/classes/com/sun/opengl/impl/nurbs/Renderhints.java new file mode 100755 index 000000000..02bc4c5bd --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Renderhints.java @@ -0,0 +1,128 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Class holding rendering params + * @author Tomas Hrasky + * + */ +class Renderhints { + + /** + * Check for errors + */ + public int errorchecking; + + /** + * Maximum subdivisions + */ + public int maxsubdivisions; + + /** + * Number of subdivisions + */ + private int subdivisions; + + /** + * Display method + */ + int display_method; + + /** + * Output triangles + */ + int wiretris; + + /** + * Output quads + */ + int wirequads; + + /** + * Makes new Renderinghints + */ + public Renderhints() { + display_method = NurbsConsts.N_FILL; + errorchecking = NurbsConsts.N_MSG; + subdivisions = 6; + // tmp1=0; + } + + /** + * Set property value + * @param prop property + */ + public void setProperty(Property prop) { + switch (prop.type) { + case NurbsConsts.N_DISPLAY: + display_method = (int) prop.value; + break; + case NurbsConsts.N_ERRORCHECKING: + errorchecking = (int) prop.value; + break; + case NurbsConsts.N_SUBDIVISIONS: + subdivisions = (int) prop.value; + break; + default: + // abort - end program + break; + } + } + + /** + * Initialization + */ + public void init() { + // DONE + maxsubdivisions = subdivisions; + if (maxsubdivisions < 0) + maxsubdivisions = 0; + + if (display_method == NurbsConsts.N_FILL) { + wiretris = 0; + wirequads = 0; + } else if (display_method == NurbsConsts.N_OUTLINE_TRI) { + wiretris = 1; + wirequads = 0; + } else if (display_method == NurbsConsts.N_OUTLINE_QUAD) { + wiretris = 0; + wirequads = 1; + } else { + wiretris = 1; + wirequads = 1; + } + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Splinespec.java b/src/classes/com/sun/opengl/impl/nurbs/Splinespec.java new file mode 100755 index 000000000..5e7d31ff3 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Splinespec.java @@ -0,0 +1,204 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * NURBS definition + * @author Tomas Hrasky + * + */ +class Splinespec { + + /** + * Dimension + */ + private int dim; + + /** + * Knot vector specs + */ + private Knotspec kspec; + + /** + * Control points after conversion + */ + private CArrayOfFloats outcpts; + + /** + * Makes new Splinespec with given dimension + * @param i dimension + */ + public Splinespec(int i) { + // DONE + this.dim = i; + } + + /** + * Initializes knotspec according to knotvector + * @param knotvector basic knotvector + */ + public void kspecinit(Knotvector knotvector) { + // DONE + this.kspec = new Knotspec(); + kspec.inkbegin = new CArrayOfFloats(knotvector.knotlist, 0); + kspec.inkend = new CArrayOfFloats(knotvector.knotlist, + knotvector.knotcount); + kspec.prestride = knotvector.stride; + kspec.order = knotvector.order; + kspec.next = null; + } + + /** + * Initializes knotspec according to knotvector - SURFACE + * @param sknotvector knotvector in u dir + * @param tknotvector knotvector in v dir + */ + public void kspecinit(Knotvector sknotvector, Knotvector tknotvector) { + // DONE + this.kspec = new Knotspec(); + Knotspec tkspec = new Knotspec(); + + kspec.inkbegin = new CArrayOfFloats(sknotvector.knotlist, 0); + kspec.inkend = new CArrayOfFloats(sknotvector.knotlist, + sknotvector.knotcount); + kspec.prestride = sknotvector.stride; + kspec.order = sknotvector.order; + kspec.next = tkspec; + + tkspec.inkbegin = new CArrayOfFloats(tknotvector.knotlist, 0); + tkspec.inkend = new CArrayOfFloats(tknotvector.knotlist, + tknotvector.knotcount); + tkspec.prestride = tknotvector.stride; + tkspec.order = tknotvector.order; + tkspec.next = null; + } + + /** + * Preselect and select knotspecs + */ + public void select() { + // DONE + for (Knotspec knotspec = kspec; knotspec != null; knotspec = knotspec.next) { + knotspec.preselect(); + knotspec.select(); + } + + } + + /** + * Prepares for conversion + * @param ncoords number of coords + */ + public void layout(int ncoords) { + // DONE + int stride = ncoords; + for (Knotspec knotspec = kspec; knotspec != null; knotspec = knotspec.next) { + knotspec.poststride = stride; + stride *= (knotspec.bend.getPointer() - knotspec.bbegin + .getPointer()) + * knotspec.order + knotspec.postoffset; + knotspec.preoffset *= knotspec.prestride; + knotspec.prewidth *= knotspec.poststride; + knotspec.postwidth *= knotspec.poststride; + knotspec.postoffset *= knotspec.poststride; + knotspec.ncoords = ncoords; + } + outcpts = new CArrayOfFloats(new float[stride]); + + } + + /** + * Prepares quilt for conversion + * @param quilt quilt to work with + */ + public void setupquilt(Quilt quilt) { + // DONE + CArrayOfQuiltspecs qspec = new CArrayOfQuiltspecs(quilt.qspec); + quilt.eqspec = new CArrayOfQuiltspecs(qspec.getArray(), dim); + for (Knotspec knotspec = kspec; knotspec != null;) { + qspec.get().stride = knotspec.poststride; + qspec.get().width = knotspec.bend.getPointer() + - knotspec.bbegin.getPointer(); + qspec.get().order = knotspec.order; + qspec.get().offset = knotspec.postoffset; + qspec.get().index = 0; + qspec.get().bdry[0] = (knotspec.kleft.getPointer() == knotspec.kfirst + .getPointer()) ? 1 : 0; + qspec.get().bdry[1] = (knotspec.kright.getPointer() == knotspec.klast + .getPointer()) ? 1 : 0; + qspec.get().breakpoints = new float[qspec.get().width + 1]; + CArrayOfFloats k = new CArrayOfFloats(qspec.get().breakpoints, 0); + for (CArrayOfBreakpts bk = new CArrayOfBreakpts(knotspec.bbegin); bk + .getPointer() <= knotspec.bend.getPointer(); bk.pp()) { + k.set(bk.get().value); + k.pp(); + } + knotspec = knotspec.next; + if (knotspec != null) + qspec.pp(); + } + quilt.cpts = new CArrayOfFloats(outcpts); + quilt.next = null; + } + + /** + * Copies array of control points to output array + * @param ctlarray control points array + */ + public void copy(CArrayOfFloats ctlarray) { + // DONE + kspec.copy(ctlarray, outcpts); + + } + + /** + * Transforms knotspecs - conversion + */ + public void transform() { + // DONE + Knotspec knotspec; + outcpts.setPointer(0); + for (knotspec = kspec; knotspec != null; knotspec = knotspec.next) + knotspec.istransformed = false; + + for (knotspec = kspec; knotspec != null; knotspec = knotspec.next) { + for (Knotspec kspec2 = kspec; kspec2 != null; kspec2 = kspec2.next) + kspec2.kspectotrans = knotspec; + kspec.transform(outcpts); + knotspec.istransformed = true; + } + + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/Subdivider.java b/src/classes/com/sun/opengl/impl/nurbs/Subdivider.java new file mode 100755 index 000000000..4e5116106 --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/Subdivider.java @@ -0,0 +1,1167 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Class working with curves and surfaces + * @author Tomas Hrasky + * + */ +class Subdivider { + /** + * Cull type + */ + public static final int CULL_TRIVIAL_REJECT = 0; + + /** + * Cull type + */ + public static final int CULL_ACCEPT = 1; + + /** + * Maximum trimming arcs + */ + private static final int MAXARCS = 10; + + /** + * Linked list of Quilts + */ + Quilt qlist; + + /** + * Object holding rendering honts information + */ + private Renderhints renderhints; + + /** + * Backend object + */ + private Backend backend; + + /** + * Number of subdivisions + */ + private int subdivisions; + + /** + * U step when using domain distance sampling + */ + private float domain_distance_u_rate; + + /** + * Use domain distance sampling + */ + private int is_domain_distance_sampling; + + /** + * Initial class holding trimming arcs + */ + private Bin initialbin; + + /** + * Not used + */ + private boolean showDegenerate; + + /** + * Is triming arc type bezier arc + */ + private boolean isArcTypeBezier; + + /** + * Breakpoints in v direction + */ + private Flist tpbrkpts; + + /** + * Breakpoints in u direction + */ + private Flist spbrkpts; + + /** + * Unused + */ + private int s_index; + + /** + * Head of linked list of trimming arcs + */ + private Arc pjarc; + + /** + * Class tesselating trimming arcs + */ + private ArcTesselator arctesselator; + + /** + * Unused + */ + private int t_index; + + /** + * Breakpoints + */ + private Flist smbrkpts; + + /** + * Not used + */ + private float[] stepsizes; + + /** + * Domain distance in V direction + */ + private float domain_distance_v_rate; + + /** + * Initializes quilt list + */ + public void beginQuilts() { + // DONE + qlist = null; + renderhints = new Renderhints(); + backend = new Backend(); + + initialbin = new Bin(); + arctesselator = new ArcTesselator(); + } + + /** + * Adds quilt to linked list + * @param quilt added quilt + */ + public void addQuilt(Quilt quilt) { + // DONE + if (qlist == null) + qlist = quilt; + else { + quilt.next = qlist; + qlist = quilt; + } + + } + + /** + * Empty method + */ + public void endQuilts() { + // DONE + } + + /** + * Draws a surface + */ + public void drawSurfaces() { + renderhints.init(); + + if (qlist == null) { + // System.out.println("qlist is null"); + return; + } + + for (Quilt q = qlist; q != null; q = q.next) { + if (q.isCulled() == CULL_TRIVIAL_REJECT) { + freejarcs(initialbin); + return; + } + } + + float[] from = new float[2]; + float[] to = new float[2]; + + spbrkpts = new Flist(); + tpbrkpts = new Flist(); + qlist.getRange(from, to, spbrkpts, tpbrkpts); + + boolean optimize = (is_domain_distance_sampling > 0 && (renderhints.display_method != NurbsConsts.N_OUTLINE_PATCH)); + + // TODO decide whether to optimize (when there is gluNurbsProperty implemented) + optimize = true; + + if (!initialbin.isnonempty()) { + if (!optimize) { + makeBorderTrim(from, to); + } + } else { + float[] rate = new float[2]; + qlist.findRates(spbrkpts, tpbrkpts, rate); + // System.out.println("subdivider.drawsurfaces decompose"); + } + + backend.bgnsurf(renderhints.wiretris, renderhints.wirequads); + + // TODO partition test + + if (!initialbin.isnonempty() && optimize) { + + int i, j; + int num_u_steps; + int num_v_steps; + for (i = spbrkpts.start; i < spbrkpts.end - 1; i++) { + for (j = tpbrkpts.start; j < tpbrkpts.end - 1; j++) { + float[] pta = new float[2]; + float[] ptb = new float[2]; + + pta[0] = spbrkpts.pts[i]; + ptb[0] = spbrkpts.pts[i + 1]; + pta[1] = tpbrkpts.pts[j]; + ptb[1] = tpbrkpts.pts[j + 1]; + qlist.downloadAll(pta, ptb, backend); + + num_u_steps = (int) (domain_distance_u_rate * (ptb[0] - pta[0])); + num_v_steps = (int) (domain_distance_v_rate * (ptb[1] - pta[1])); + + if (num_u_steps <= 0) + num_u_steps = 1; + if (num_v_steps <= 0) + num_v_steps = 1; + + backend.surfgrid(pta[0], ptb[0], num_u_steps, ptb[1], + pta[1], num_v_steps); + backend.surfmesh(0, 0, num_u_steps, num_v_steps); + + } + } + + } else + + subdivideInS(initialbin); + + backend.endsurf(); + } + + /** + * Empty method + * @param initialbin2 + */ + private void freejarcs(Bin initialbin2) { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.freejarcs"); + } + + /** + * Subdivide in U direction + * @param source Trimming arcs source + */ + private void subdivideInS(Bin source) { + // DONE + if (renderhints.display_method == NurbsConsts.N_OUTLINE_PARAM) { + outline(source); + freejarcs(source); + } else { + setArcTypeBezier(); + setNonDegenerate(); + splitInS(source, spbrkpts.start, spbrkpts.end); + } + + } + + /** + * Split in U direction + * @param source Trimming arcs source + * @param start breakpoints start + * @param end breakpoints end + */ + private void splitInS(Bin source, int start, int end) { + // DONE + if (source.isnonempty()) { + if (start != end) { + int i = start + (end - start) / 2; + Bin left = new Bin(); + Bin right = new Bin(); + + split(source, left, right, 0, spbrkpts.pts[i]); + splitInS(left, start, i); + splitInS(right, i + 1, end); + } else { + if (start == spbrkpts.start || start == spbrkpts.end) { + freejarcs(source); + } else if (renderhints.display_method == NurbsConsts.N_OUTLINE_PARAM_S) { + outline(source); + freejarcs(source); + } else { + setArcTypeBezier(); + setNonDegenerate(); + s_index = start; + splitInT(source, tpbrkpts.start, tpbrkpts.end); + } + } + } else{ + // System.out.println("Source is empty - subdivider.splitins"); + } + } + + /** + * Split in V direction + * @param source + * @param start + * @param end + */ + private void splitInT(Bin source, int start, int end) { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.splitint"); + + if (source.isnonempty()) { + if (start != end) { + int i = start + (end - start) / 2; + Bin left = new Bin(); + Bin right = new Bin(); + split(source, left, right, 1, tpbrkpts.pts[i + 1]); + splitInT(left, start, i); + splitInT(right, i + 1, end); + } else { + if (start == tpbrkpts.start || start == tpbrkpts.end) { + freejarcs(source); + } else if (renderhints.display_method == NurbsConsts.N_OUTLINE_PARAM_ST) { + outline(source); + freejarcs(source); + } else { + t_index = start; + setArcTypeBezier(); + setDegenerate(); + + float[] pta = new float[2]; + float[] ptb = new float[2]; + + pta[0] = spbrkpts.pts[s_index - 1]; + pta[1] = tpbrkpts.pts[t_index - 1]; + + ptb[0] = spbrkpts.pts[s_index]; + ptb[1] = tpbrkpts.pts[t_index]; + qlist.downloadAll(pta, ptb, backend); + + Patchlist patchlist = new Patchlist(qlist, pta, ptb); + + samplingSplit(source, patchlist, + renderhints.maxsubdivisions, 0); + setNonDegenerate(); + setArcTypeBezier(); + } + } + } + + } + + /** + * Sample + * @param source + * @param patchlist + * @param subdivisions + * @param param + */ + private void samplingSplit(Bin source, Patchlist patchlist, + int subdivisions, int param) { + // DONE + if (!source.isnonempty()) + return; + if (patchlist.cullCheck() == CULL_TRIVIAL_REJECT) { + freejarcs(source); + return; + } + + patchlist.getstepsize(); + if (renderhints.display_method == NurbsConsts.N_OUTLINE_PATCH) { + tesselation(source, patchlist); + outline(source); + freejarcs(source); + return; + } + + tesselation(source, patchlist); + if (patchlist.needsSamplingSubdivision() && subdivisions > 0) { + if (!patchlist.needsSubdivision(0)) { + param = 1; + } else if (patchlist.needsSubdivision(1)) + param = 0; + else + param = 1 - param; + + Bin left = new Bin(); + Bin right = new Bin(); + + float mid = (float) ((patchlist.pspec[param].range[0] + patchlist.pspec[param].range[1]) * .5); + + split(source, left, right, param, mid); + Patchlist subpatchlist = new Patchlist(patchlist, param, mid); + samplingSplit(left, subpatchlist, subdivisions - 1, param); + samplingSplit(right, subpatchlist, subdivisions - 1, param); + } else { + setArcTypePwl(); + setDegenerate(); + nonSamplingSplit(source, patchlist, subdivisions, param); + setDegenerate(); + setArcTypeBezier(); + } + } + + /** + * Not used + * @param source + * @param patchlist + * @param subdivisions + * @param param + */ + private void nonSamplingSplit(Bin source, Patchlist patchlist, + int subdivisions, int param) { + // DONE + if (patchlist.needsNonSamplingSubdivision() && subdivisions > 0) { + param = 1 - param; + + Bin left = new Bin(); + Bin right = new Bin(); + + float mid = (float) ((patchlist.pspec[param].range[0] + patchlist.pspec[param].range[1]) * .5); + split(source, left, right, param, mid); + Patchlist subpatchlist = new Patchlist(patchlist, param, mid); + if (left.isnonempty()) { + if (subpatchlist.cullCheck() == CULL_TRIVIAL_REJECT) + freejarcs(left); + else + nonSamplingSplit(left, subpatchlist, subdivisions - 1, + param); + } + if (right.isnonempty()) { + if (patchlist.cullCheck() == CULL_TRIVIAL_REJECT) + freejarcs(right); + else + nonSamplingSplit(right, subpatchlist, subdivisions - 1, + param); + } + } else { + patchlist.bbox(); + backend.patch(patchlist.pspec[0].range[0], + patchlist.pspec[0].range[1], patchlist.pspec[1].range[0], + patchlist.pspec[1].range[1]); + if (renderhints.display_method == NurbsConsts.N_OUTLINE_SUBDIV) { + outline(source); + freejarcs(source); + } else { + setArcTypePwl(); + setDegenerate(); + findIrregularS(source); + monosplitInS(source, smbrkpts.start, smbrkpts.end); + } + } + + } + + /** + * Not used + * @param source + * @param start + * @param end + */ + private void monosplitInS(Bin source, int start, int end) { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.monosplitins"); + } + + /** + * Not used + * @param source + */ + private void findIrregularS(Bin source) { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.findIrregularS"); + } + + /** + * Not used + */ + private void setArcTypePwl() { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.setarctypepwl"); + } + + /** + * Not used + * @param source + * @param patchlist + */ + private void tesselation(Bin source, Patchlist patchlist) { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.tesselation"); + } + + /** + * Not used + */ + private void setDegenerate() { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.setdegenerate"); + } + + /** + * Not used + * @param bin + * @param left + * @param right + * @param param + * @param value + */ + private void split(Bin bin, Bin left, Bin right, int param, float value) { + // DONE + Bin intersections = new Bin(); + Bin unknown = new Bin(); + + partition(bin, left, intersections, right, unknown, param, value); + + int count = intersections.numarcs(); + // TODO jumpbuffer ?? + + if (count % 2 == 0) { + + Arc[] arclist = new Arc[MAXARCS]; + CArrayOfArcs list; + if (count >= MAXARCS) { + list = new CArrayOfArcs(new Arc[count]); + } else { + list = new CArrayOfArcs(arclist); + } + + CArrayOfArcs last, lptr; + Arc jarc; + + for (last = new CArrayOfArcs(list); (jarc = intersections + .removearc()) != null; last.pp()) + last.set(jarc); + + if (param == 0) {// sort into incrasing t order + ArcSdirSorter sorter = new ArcSdirSorter(this); + sorter.qsort(list, count); + + for (lptr = new CArrayOfArcs(list); lptr.getPointer() < last + .getPointer(); lptr.raisePointerBy(2)) + check_s(lptr.get(), lptr.getRelative(1)); + for (lptr = new CArrayOfArcs(list); lptr.getPointer() < last + .getPointer(); lptr.raisePointerBy(2)) + join_s(left, right, lptr.get(), lptr.getRelative(1)); + for (lptr = new CArrayOfArcs(list); lptr.getPointer() != last + .getPointer(); lptr.pp()) { + if (lptr.get().head()[0] <= value + && lptr.get().tail()[0] <= value) + left.addarc(lptr.get()); + else + right.addarc(lptr.get()); + } + + } else {// sort into decreasing s order + ArcTdirSorter sorter = new ArcTdirSorter(this); + sorter.qsort(list, count); + + for (lptr = new CArrayOfArcs(list); lptr.getPointer() < last + .getPointer(); lptr.raisePointerBy(2)) + check_t(lptr.get(), lptr.getRelative(1)); + for (lptr = new CArrayOfArcs(list); lptr.getPointer() < last + .getPointer(); lptr.raisePointerBy(2)) + join_t(left, right, lptr.get(), lptr.getRelative(1)); + for (lptr = new CArrayOfArcs(list); lptr.getPointer() != last + .getPointer(); lptr.raisePointerBy(2)) { + if (lptr.get().head()[0] <= value + && lptr.get().tail()[0] <= value) + left.addarc(lptr.get()); + else + right.addarc(lptr.get()); + } + + } + + unknown.adopt(); + } + } + + /** + * Not used + * @param left + * @param right + * @param arc + * @param relative + */ + private void join_t(Bin left, Bin right, Arc arc, Arc relative) { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.join_t"); + } + + /** + * Not used + * @param arc + * @param relative + */ + private void check_t(Arc arc, Arc relative) { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.check_t"); + } + + /** + * Not used + * @param left + * @param right + * @param jarc1 + * @param jarc2 + */ + private void join_s(Bin left, Bin right, Arc jarc1, Arc jarc2) { + // DONE + if (!jarc1.getitail()) + jarc1 = jarc1.next; + if (!jarc2.getitail()) + jarc2 = jarc2.next; + + float s = jarc1.tail()[0]; + float t1 = jarc1.tail()[1]; + float t2 = jarc2.tail()[1]; + + if (t1 == t2) { + simplelink(jarc1, jarc2); + } else { + Arc newright = new Arc(Arc.ARC_RIGHT); + Arc newleft = new Arc(Arc.ARC_LEFT); + if (isBezierArcType()) { + arctesselator.bezier(newright, s, s, t1, t2); + arctesselator.bezier(newleft, s, s, t2, t1); + } else { + arctesselator.pwl_right(newright, s, t1, t2, stepsizes[0]); + arctesselator.pwl_left(newright, s, t2, t1, stepsizes[2]); + } + link(jarc1, jarc2, newright, newleft); + left.addarc(newright); + right.addarc(newleft); + } + + } + + /** + * Not used + * @param jarc1 + * @param jarc2 + * @param newright + * @param newleft + */ + private void link(Arc jarc1, Arc jarc2, Arc newright, Arc newleft) { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.link"); + } + + /** + * Not used + * @return true + */ + private boolean isBezierArcType() { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.isbezierarc"); + return true; + } + + /** + * Not used + * @param jarc1 + * @param jarc2 + */ + private void simplelink(Arc jarc1, Arc jarc2) { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.simplelink"); + } + + /** + * Not used + * @param arc + * @param relative + */ + private void check_s(Arc arc, Arc relative) { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.check_s"); + + } + + /** + * Not used + * @param bin + * @param left + * @param intersections + * @param right + * @param unknown + * @param param + * @param value + */ + private void partition(Bin bin, Bin left, Bin intersections, Bin right, + Bin unknown, int param, float value) { + + Bin headonleft = new Bin(); + Bin headonright = new Bin(); + Bin tailonleft = new Bin(); + Bin tailonright = new Bin(); + + for (Arc jarc = bin.removearc(); jarc != null; jarc = bin.removearc()) { + float tdiff = jarc.tail()[param] - value; + float hdiff = jarc.head()[param] - value; + + if (tdiff > 0) { + if (hdiff > 0) { + right.addarc(jarc); + } else if (hdiff == 0) { + tailonright.addarc(jarc); + } else { + Arc jtemp; + switch (arc_split(jarc, param, value, 0)) { + case 2: + tailonright.addarc(jarc); + headonleft.addarc(jarc.next); + break; + // TODO rest cases + default: + System.out + .println("TODO subdivider.partition rest cases"); + break; + } + } + } else if (tdiff == 0) { + if (hdiff > 0) { + headonright.addarc(jarc); + } else if (hdiff == 0) { + unknown.addarc(jarc); + } else { + headonright.addarc(jarc); + } + } else { + if (hdiff > 0) { + // TODO rest + // System.out.println("TODO subdivider.partition rest of else"); + } else if (hdiff == 0) { + tailonleft.addarc(jarc); + } else { + left.addarc(jarc); + } + } + + } + if (param == 0) { + classify_headonleft_s(headonleft, intersections, left, value); + classify_tailonleft_s(tailonleft, intersections, left, value); + classify_headonright_s(headonright, intersections, right, value); + classify_tailonright_s(tailonright, intersections, right, value); + } else { + classify_headonleft_t(headonleft, intersections, left, value); + classify_tailonleft_t(tailonleft, intersections, left, value); + classify_headonright_t(headonright, intersections, right, value); + classify_tailonright_t(tailonright, intersections, right, value); + } + } + + /** + * Not used + * @param tailonright + * @param intersections + * @param right + * @param value + */ + private void classify_tailonright_t(Bin tailonright, Bin intersections, + Bin right, float value) { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.classify_tailonright_t"); + + } + + /** + * Not used + * @param bin + * @param in + * @param out + * @param val + */ + private void classify_tailonleft_s(Bin bin, Bin in, Bin out, float val) { + + // DONE + Arc j; + while ((j = bin.removearc()) != null) { + j.clearitail(); + + float diff = j.next.head()[0] - val; + if (diff > 0) { + in.addarc(j); + } else if (diff < 0) { + if (ccwTurn_sl(j, j.next)) + out.addarc(j); + else + in.addarc(j); + } else { + if (j.next.tail()[1] > j.next.head()[1]) + in.addarc(j); + else + out.addarc(j); + } + } + + } + + /** + * Not used + * @param bin + * @param in + * @param out + * @param val + */ + private void classify_headonright_s(Bin bin, Bin in, Bin out, float val) { + // DONE + Arc j; + while ((j = bin.removearc()) != null) { + j.setitail(); + + float diff = j.prev.tail()[0] - val; + if (diff > 0) { + if (ccwTurn_sr(j.prev, j)) + out.addarc(j); + else + in.addarc(j); + } else if (diff < 0) { + out.addarc(j); + } else { + if (j.prev.tail()[1] > j.prev.head()[1]) + out.addarc(j); + else + in.addarc(j); + } + } + } + + /** + * Not used + * @param prev + * @param j + * @return false + */ + private boolean ccwTurn_sr(Arc prev, Arc j) { + // TODO Auto-generated method stub + // System.out.println("TODO ccwTurn_sr"); + return false; + } + + /** + * Not used + * @param headonright + * @param intersections + * @param right + * @param value + */ + private void classify_headonright_t(Bin headonright, Bin intersections, + Bin right, float value) { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.classify_headonright_t"); + } + + /** + * Not used + * @param tailonleft + * @param intersections + * @param left + * @param value + */ + private void classify_tailonleft_t(Bin tailonleft, Bin intersections, + Bin left, float value) { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.classify_tailonleft_t"); + } + + /** + * Not used + * @param bin + * @param in + * @param out + * @param val + */ + private void classify_headonleft_t(Bin bin, Bin in, Bin out, float val) { + // DONE + Arc j; + while ((j = bin.removearc()) != null) { + j.setitail(); + + float diff = j.prev.tail()[1] - val; + if (diff > 0) { + out.addarc(j); + } else if (diff < 0) { + if (ccwTurn_tl(j.prev, j)) + out.addarc(j); + else + in.addarc(j); + } else { + if (j.prev.tail()[0] > j.prev.head()[0]) + out.addarc(j); + else + in.addarc(j); + } + } + } + + /** + * Not used + * @param prev + * @param j + * @return false + */ + private boolean ccwTurn_tl(Arc prev, Arc j) { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.ccwTurn_tl"); + return false; + } + + /** + * Not used + * @param bin + * @param in + * @param out + * @param val + */ + private void classify_tailonright_s(Bin bin, Bin in, Bin out, float val) { + // DONE + Arc j; + while ((j = bin.removearc()) != null) { + j.clearitail(); + + float diff = j.next.head()[0] - val; + if (diff > 0) { + if (ccwTurn_sr(j, j.next)) + out.addarc(j); + else + in.addarc(j); + } else if (diff < 0) { + in.addarc(j); + } else { + if (j.next.tail()[1] > j.next.head()[1]) + out.addarc(j); + else + in.addarc(j); + } + } + + } + + /** + * Not used + * @param bin + * @param in + * @param out + * @param val + */ + private void classify_headonleft_s(Bin bin, Bin in, Bin out, float val) { + // DONE + Arc j; + while ((j = bin.removearc()) != null) { + j.setitail(); + + float diff = j.prev.tail()[0] - val; + if (diff > 0) { + out.addarc(j); + } else if (diff < 0) { + if (ccwTurn_sl(j.prev, j)) + out.addarc(j); + else + in.addarc(j); + } else { + if (j.prev.tail()[1] > j.prev.head()[1]) + in.addarc(j); + else + out.addarc(j); + } + } + + } + + /** + * Not used + * @param prev + * @param j + * @return false + */ + private boolean ccwTurn_sl(Arc prev, Arc j) { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.ccwTurn_sl"); + return false; + } + + /** + * Not used + * @param jarc + * @param param + * @param value + * @param i + * @return 0 + */ + private int arc_split(Arc jarc, int param, float value, int i) { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.arc_split"); + return 0; + } + + /** + * Not used + */ + private void setNonDegenerate() { + // DONE + this.showDegenerate = false; + + } + + /** + * sets trimming arc default type to bezier + */ + private void setArcTypeBezier() { + // DONE + isArcTypeBezier = true; + } + + /** + * Not used + * @param source + */ + private void outline(Bin source) { + // TODO Auto-generated method stub + // System.out.println("TODO subdivider.outline"); + } + + /** + * Makes default trim along surface borders + * @param from range beginnings + * @param to range ends + */ + private void makeBorderTrim(float[] from, float[] to) { + // DONE + float smin = from[0]; + float smax = to[0]; + + float tmin = from[1]; + float tmax = to[1]; + + pjarc = null; + Arc jarc = null; + + jarc = new Arc(Arc.ARC_BOTTOM); + arctesselator.bezier(jarc, smin, smax, tmin, tmin); + initialbin.addarc(jarc); + pjarc = jarc.append(pjarc); + + jarc = new Arc(Arc.ARC_RIGHT); + arctesselator.bezier(jarc, smax, smax, tmin, tmax); + initialbin.addarc(jarc); + pjarc = jarc.append(pjarc); + + jarc = new Arc(Arc.ARC_TOP); + arctesselator.bezier(jarc, smax, smin, tmax, tmax); + initialbin.addarc(jarc); + pjarc = jarc.append(pjarc); + + jarc = new Arc(Arc.ARC_LEFT); + arctesselator.bezier(jarc, smin, smin, tmax, tmin); + initialbin.addarc(jarc); + jarc = jarc.append(pjarc); + + // assert (jarc.check() == true); + } + + /** + * Draws NURBS curve + */ + public void drawCurves() { + // DONE + float[] from = new float[1]; + float[] to = new float[1]; + + Flist bpts = new Flist(); + qlist.getRange(from, to, bpts); + + renderhints.init(); + + backend.bgncurv(); + + for (int i = bpts.start; i < bpts.end - 1; i++) { + float[] pta = new float[1]; + float[] ptb = new float[1]; + pta[0] = bpts.pts[i]; + ptb[0] = bpts.pts[i + 1]; + + qlist.downloadAll(pta, ptb, backend); + Curvelist curvelist = new Curvelist(qlist, pta, ptb); + samplingSplit(curvelist, renderhints.maxsubdivisions); + } + backend.endcurv(); + } + + /** + * Samples a curve in case of need, or sends curve to backend + * @param curvelist list of curves + * @param maxsubdivisions maximum number of subdivisions + */ + private void samplingSplit(Curvelist curvelist, int maxsubdivisions) { + if (curvelist.cullCheck() == CULL_TRIVIAL_REJECT) + return; + + curvelist.getstepsize(); + + if (curvelist.needsSamplingSubdivision() && (subdivisions > 0)) { + // TODO kód + // System.out.println("TODO subdivider-needsSamplingSubdivision"); + } else { + int nu = (int) (1 + curvelist.range[2] / curvelist.stepsize); + backend.curvgrid(curvelist.range[0], curvelist.range[1], nu); + backend.curvmesh(0, nu); + } + + } + + /** + * Sets new domain_distance_u_rate value + * @param d new domain_distance_u_rate value + + */ + public void set_domain_distance_u_rate(double d) { + // DONE + domain_distance_u_rate = (float) d; + } + + /** + * Sets new domain_distance_v_rate value + * @param d new domain_distance_v_rate value + */ + public void set_domain_distance_v_rate(double d) { + // DONE + domain_distance_v_rate = (float) d; + } + + /** + * Sets new is_domain_distance_sampling value + * @param i new is_domain_distance_sampling value + */ + public void set_is_domain_distance_sampling(int i) { + // DONE + this.is_domain_distance_sampling = i; + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/TrimVertex.java b/src/classes/com/sun/opengl/impl/nurbs/TrimVertex.java new file mode 100755 index 000000000..e57c5ffbf --- /dev/null +++ b/src/classes/com/sun/opengl/impl/nurbs/TrimVertex.java @@ -0,0 +1,56 @@ +package com.sun.opengl.impl.nurbs; + +/* + ** License Applicability. Except to the extent portions of this file are + ** made subject to an alternative license as permitted in the SGI Free + ** Software License B, Version 1.1 (the "License"), the contents of this + ** file are subject only to the provisions of the License. You may not use + ** this file except in compliance with the License. You may obtain a copy + ** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 + ** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: + ** + ** http://oss.sgi.com/projects/FreeB + ** + ** Note that, as provided in the License, the Software is distributed on an + ** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS + ** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND + ** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A + ** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. + ** + ** Original Code. The Original Code is: OpenGL Sample Implementation, + ** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, + ** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. + ** Copyright in any portions created by third parties is as indicated + ** elsewhere herein. All Rights Reserved. + ** + ** Additional Notice Provisions: The application programming interfaces + ** established by SGI in conjunction with the Original Code are The + ** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released + ** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version + ** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X + ** Window System(R) (Version 1.3), released October 19, 1998. This software + ** was created using the OpenGL(R) version 1.2.1 Sample Implementation + ** published by SGI, but has not been independently verified as being + ** compliant with the OpenGL(R) version 1.2.1 Specification. + */ + +/** + * Holds vertex used in trim + * + * @author Tomas Hrasky + * + */ +class TrimVertex { + + /** + * Trim vertex coords + */ + public float[] param; + + /** + * Makes new empty trim vertex + */ + public TrimVertex() { + param = new float[2]; + } +} diff --git a/src/classes/com/sun/opengl/impl/nurbs/internals/Arc.java b/src/classes/com/sun/opengl/impl/nurbs/internals/Arc.java deleted file mode 100644 index e5d77b74a..000000000 --- a/src/classes/com/sun/opengl/impl/nurbs/internals/Arc.java +++ /dev/null @@ -1,284 +0,0 @@ -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** NOTE: The Original Code (as defined below) has been licensed to Sun -** Microsystems, Inc. ("Sun") under the SGI Free Software License B -** (Version 1.1), shown above ("SGI License"). Pursuant to Section -** 3.2(3) of the SGI License, Sun is distributing the Covered Code to -** you under an alternative license ("Alternative License"). This -** Alternative License includes all of the provisions of the SGI License -** except that Section 2.2 and 11 are omitted. Any differences between -** the Alternative License and the SGI License are offered solely by Sun -** and not by SGI. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -*/ - -/* an arc, in two list, the trim list and bin */ -public class Arc { - public static final int SIDE_NONE = 0; - public static final int SIDE_RIGHT = 1; - public static final int SIDE_TOP = 2; - public static final int SIDE_LEFT = 3; - public static final int SIDE_BOTTOM = 4; - - public static final int bezier_tag = (1 << 13); - public static final int arc_tag = (1 << 3); - public static final int tail_tag = (1 << 6); - public Arc prev; /* trim list pointer */ - public Arc next; /* trim list pointer */ - public Arc link; /* bin pointers */ - public BezierArc bezierArc; /* associated bezier arc */ - public PwlArc pwlArc; /* associated pwl arc */ - public long type; /* curve type */ - public long nuid; - - private static final float ZERO = 0.00001f; - - public Arc(Arc j, PwlArc p) { - pwlArc = p; - type = j.type; - nuid = j.nuid; - } - - public Arc(int arcSide, long nuid) { - type = 0; - setside(arcSide); - this.nuid = nuid; - } - - public Arc append(Arc jarc) { - if ( jarc != null ) { - next = jarc.next; - prev = jarc; - next.prev = prev.next = this; - } else { - next = prev = this; - } - return this; - } - - public boolean check() { - Arc jarc = this; - do { - assert( (jarc.pwlArc != null) || (jarc.bezierArc != null) ); - - if (jarc.prev == 0 || jarc.next == 0) { - System.out.println( "checkjarc:null next/prev pointer"); - jarc.print( ); - return false; - } - - if (jarc.next.prev != jarc) { - System.out.println( "checkjarc: pointer linkage screwed up"); - jarc.print( ); - return false; - } - - if( jarc.pwlArc != null ) { - assert( jarc.pwlArc.npts >= 1 ); - assert( jarc.pwlArc.npts < 100000 ); - if( jarc.prev.pwlArc != null ) { - if( jarc.tail()[1] != jarc.prev.rhead()[1] ) { - System.out.println( "checkjarc: geometric linkage screwed up 1"); - jarc.prev.show(); - jarc.show(); - return false; - } - if( jarc.tail()[0] != jarc.prev.rhead()[0] ) { - System.out.println( "checkjarc: geometric linkage screwed up 2"); - jarc.prev.show(); - jarc.show(); - return false; - } - } - if( jarc.next.pwlArc ) { - if( jarc.next.tail()[0] != jarc.rhead()[0] ) { - System.out.println( "checkjarc: geometric linkage screwed up 3"); - jarc.show(); - jarc.next.show(); - return false; - } - if( jarc.next.tail()[1] != jarc.rhead()[1] ) { - System.out.println( "checkjarc: geometric linkage screwed up 4"); - jarc.show(); - jarc.next.show(); - return false; - } - } - if( jarc.isbezier() ) { - assert( jarc.pwlArc.npts == 2 ); - assert( (jarc.pwlArc.pts[0].param[0] == - jarc.pwlArc.pts[1].param[0]) || - (jarc.pwlArc.pts[0].param[1] == - jarc.pwlArc.pts[1].param[1]) ); - } - } - jarc = jarc.next; - } while (jarc != this); - return true; - } - - /** - * Checks if tail of arc and head of prev meet. - */ - public boolean isDisconnected() { - if( pwlArc == 0 ) return 0; - if( prev.pwlArc == 0 ) return 0; - - float[] p0 = tail(); - float[] p1 = prev.rhead(); - - if( ((p0[0] - p1[0]) > ZERO) || ((p1[0] - p0[0]) > ZERO) || - ((p0[1] - p1[1]) > ZERO) || ((p1[1] - p0[1]) > ZERO) ) { - return true; - } else { - /* average two points together */ - p0[0] = p1[0] = (p1[0] + p0[0]) * 0.5f; - p0[1] = p1[1] = (p1[1] + p0[1]) * 0.5f; - return false; - } - } - - /** - * Counts number of points on arc loop. - */ - public int numpts( ) { - Arc jarc = this; - int npts = 0; - do { - npts += jarc.pwlArc.npts; - jarc = jarc.next; - } while( jarc != this ); - return npts; - } - - /** - * Marks each point with id of arc. - */ - public void markverts( void ) { - Arc jarc = this; - - do { - TrimVertex p = jarc.pwlArc.pts; - for( int i=0; i<jarc.pwlArc.npts; i++ ) - p[i].nuid = jarc.nuid; - jarc = jarc.next; - } while( jarc != this ); - } - - /** - * Finds axis extrema on arc loop. - */ - public void getextrema( Arc[4] ) { - float leftpt, botpt, rightpt, toppt; - - extrema[0] = extrema[1] = extrema[2] = extrema[3] = this; - - leftpt = rightpt = this.tail()[0]; - botpt = toppt = this.tail()[1]; - - for( Arc jarc = this.next; jarc != this; jarc = jarc.next ) { - if ( jarc.tail()[0] < leftpt || - (jarc.tail()[0] <= leftpt && jarc.rhead()[0]<=leftpt)) { - leftpt = jarc.pwlArc.pts.param[0]; - extrema[1] = jarc; - } - if ( jarc.tail()[0] > rightpt || - (jarc.tail()[0] >= rightpt && jarc.rhead()[0] >= rightpt)) { - rightpt = jarc.pwlArc.pts.param[0]; - extrema[3] = jarc; - } - if ( jarc.tail()[1] < botpt || - (jarc.tail()[1] <= botpt && jarc.rhead()[1] <= botpt )) { - botpt = jarc.pwlArc.pts.param[1]; - extrema[2] = jarc; - } - if ( jarc.tail()[1] > toppt || - (jarc.tail()[1] >= toppt && jarc.rhead()[1] >= toppt)) { - toppt = jarc.pwlArc.pts.param[1]; - extrema[0] = jarc; - } - } - } - - /** - * Prints out the vertices of all pwl arcs on a loop. - */ - public void print( ) { - Arc jarc = this; - - do { - jarc.show( ); - jarc = jarc.next; - } while (jarc != this); - } - - public void show( ) { - System.out.println( "\tPWLARC NP: " + pwlArc.npts + " FL: 1"); - for( int i = 0; i < pwlArc.npts; i++ ) { - System.out.println( "\t\tVERTEX " + pwlArc.pts[i].param[0] + " " + - pwlArc.pts[i].param[1] ); - } - } - - /** - * Attaches a pwl arc to an arc and mark it as a border arc. - */ - public void makeSide( PwlArc pwl, int arcSide ) { - assert( pwl != 0); - assert( pwlArc == 0 ); - assert( pwl.npts > 0 ); - assert( pwl.pts != 0); - pwlArc = pwl; - clearbezier(); - setside( arcSide ); - } - - public boolean isTessellated() { return (pwlArc != null); } - public boolean isbezier() { return (type & bezier_tag) != 0; } - public void setbezier() { type |= bezier_tag; } - public void clearbezier() { type &= ~bezier_tag; } - public long npts() { return pwlArc.npts; } - public TrimVertex[] pts() { return pwlArc.pts; } - public float[] tail() { return pwlArc.pts[0].param; } - public float[] head() { return next.pwlArc.pts[0].param; } - public float[] rhead() { return pwlArc.pts[pwlArc.npts-1].param; } - public long ismarked() { return type & arc_tag; } - public void setmark() { type |= arc_tag; } - public void clearmark() { type &= (~arc_tag); } - public void clearside() { type &= ~(0x7 << 8); } - public void setside( int arcSide ) { clearside(); type |= (((long)arcSide)<<8); } - public int getside() { return ((type>>8) & 0x7); } - public int getitail() { return type & tail_tag; } - public void setitail() { type |= tail_tag; } - public void clearitail() { type &= (~tail_tag); } -} diff --git a/src/classes/com/sun/opengl/impl/nurbs/internals/ArcTesselator.java b/src/classes/com/sun/opengl/impl/nurbs/internals/ArcTesselator.java deleted file mode 100644 index e8757b7cb..000000000 --- a/src/classes/com/sun/opengl/impl/nurbs/internals/ArcTesselator.java +++ /dev/null @@ -1,459 +0,0 @@ -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** NOTE: The Original Code (as defined below) has been licensed to Sun -** Microsystems, Inc. ("Sun") under the SGI Free Software License B -** (Version 1.1), shown above ("SGI License"). Pursuant to Section -** 3.2(3) of the SGI License, Sun is distributing the Covered Code to -** you under an alternative license ("Alternative License"). This -** Alternative License includes all of the provisions of the SGI License -** except that Section 2.2 and 11 are omitted. Any differences between -** the Alternative License and the SGI License are offered solely by Sun -** and not by SGI. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -*/ - -public class ArcTessellator { - /** - * Constructs a bezier arc and attaches it to an Arc. - */ - public void bezier( Arc arc, float s1, float s2, float t1, float t2 ) { - assert( arc != null ); - assert( ! arc.isTessellated() ); - - switch( arc.getside() ) { - case Arc.SIDE_LEFT: - assert( s1 == s2 ); - assert( t2 < t1 ); - break; - case Arc.SIDE_RIGHT: - assert( s1 == s2 ); - assert( t1 < t2 ); - break; - case Arc.SIDE_TOP: - assert( t1 == t2 ); - assert( s2 < s1 ); - break; - case Arc.SIDE_BOTTOM: - assert( t1 == t2 ); - assert( s1 < s2 ); - break; - case Arc.SIDE_NONE: - throw new InternalError(); - break; - } - - TrimVertex[] p = TrimVertex.allocate(2); - arc.pwlArc = new PwlArc( p ); - p[0].param[0] = s1; - p[0].param[1] = t1; - p[1].param[0] = s2; - p[1].param[1] = t2; - assert( (s1 == s2) || (t1 == t2) ); - arc.setbezier(); - } - - /** - * Constructs a pwl arc and attaches it to an arc. - */ - public void pwl( Arc arc, float s1, float s2, float t1, float t2, float rate ) { - int snsteps = 1 + (int) (Math.abs(s2 - s1) / rate ); - int tnsteps = 1 + (int) (Math.abs(t2 - t1) / rate ); - int nsteps = (int) Math.max(1, Math.max( snsteps, tnsteps )); - - float sstepsize = (s2 - s1) / (float) nsteps; - float tstepsize = (t2 - t1) / (float) nsteps; - TrimVertex[] newvert = TrimVertex.allocate( nsteps+1 ); - long i; - for( i = 0; i < nsteps; i++ ) { - newvert[i].param[0] = s1; - newvert[i].param[1] = t1; - s1 += sstepsize; - t1 += tstepsize; - } - newvert[i].param[0] = s2; - newvert[i].param[1] = t2; - - arc.pwlArc = new PwlArc( newvert ); - - arc.clearbezier(); - arc.clearside( ); - } - - /** - * Constructs a left boundary pwl arc and attaches it to an arc. - */ - public void pwl_left( Arc arc, float s, float t1, float t2, float rate ) { - assert( t2 < t1 ); - - int nsteps = steps_function(t1, t2, rate); - - float stepsize = (t1 - t2) / (float) nsteps; - - TrimVertex[] newvert = TrimVertex.allocate( nsteps+1 ); - int i; - for( i = nsteps; i > 0; i-- ) { - newvert[i].param[0] = s; - newvert[i].param[1] = t2; - t2 += stepsize; - } - newvert[i].param[0] = s; - newvert[i].param[1] = t1; - - arc.makeSide( new PwlArc( newvert ), Arc.SIDE_LEFT ); - } - - /** - * Constructs a right boundary pwl arc and attaches it to an arc. - */ - public void pwl_right( Arc arc, float s, float t1, float t2, float rate ) { - assert( t1 < t2 ); - - int nsteps = steps_function(t2,t1,rate); - float stepsize = (t2 - t1) / (float) nsteps; - - TrimVertex[] newvert = TrimVertex.allocate( nsteps+1 ); - int i; - for( i = 0; i < nsteps; i++ ) { - newvert[i].param[0] = s; - newvert[i].param[1] = t1; - t1 += stepsize; - } - newvert[i].param[0] = s; - newvert[i].param[1] = t2; - - arc.makeSide( new PwlArc( newvert ), Arc.SIDE_RIGHT ); - } - - /** - * Constructs a top boundary pwl arc and attaches it to an arc. - */ - public void pwl_top( Arc arc, float t, float s1, float s2, float rate ) { - assert( s2 < s1 ); - - int nsteps = steps_function(s1,s2,rate); - float stepsize = (s1 - s2) / (float) nsteps; - - TrimVertex[] newvert = TrimVertex.allocate( nsteps+1 ); - int i; - for( i = nsteps; i > 0; i-- ) { - newvert[i].param[0] = s2; - newvert[i].param[1] = t; - s2 += stepsize; - } - newvert[i].param[0] = s1; - newvert[i].param[1] = t; - - arc.makeSide( new PwlArc( newvert ), Arc.SIDE_TOP ); - } - - /** - * Constructs a bottom boundary pwl arc and attaches it to an arc. - */ - public void pwl_bottom( Arc arc, float t, float s1, float s2, float rate ) { - assert( s1 < s2 ); - - int nsteps = steps_function(s2,s1,rate); - float stepsize = (s2 - s1) / (float) nsteps; - - TrimVertex[] newvert = TrimVertex.allocate( nsteps+1 ); - int i; - for( i = 0; i < nsteps; i++ ) { - newvert[i].param[0] = s1; - newvert[i].param[1] = t; - s1 += stepsize; - } - newvert[i].param[0] = s2; - newvert[i].param[1] = t; - - arc.makeSide( new PwlArc( newvert ), Arc.SIDE_BOTTOM ); - } - - /** - * Constucts a linear pwl arc and attaches it to an Arc. - */ - public void tessellateLinear( Arc arc, float geo_stepsize, float arc_stepsize, boolean isrational ) { - assert( arc.pwlArc == null ); - float s1, s2, t1, t2; - - //we don't need to scale by arc_stepsize if the trim curve - //is piecewise linear. Reason: In pwl_right, pwl_left, pwl_top, pwl_left, - //and pwl, the nsteps is computed by deltaU (or V) /stepsize. - //The quantity deltaU/arc_stepsize doesn't have any meaning. And - //it causes problems: see bug 517641 - float stepsize = geo_stepsize; /* * arc_stepsize*/; - - BezierArc b = arc.bezierArc; - - if( isrational ) { - s1 = b.cpts[0] / b.cpts[2]; - t1 = b.cpts[1] / b.cpts[2]; - s2 = b.cpts[b.stride+0] / b.cpts[b.stride+2]; - t2 = b.cpts[b.stride+1] / b.cpts[b.stride+2]; - } else { - s1 = b.cpts[0]; - t1 = b.cpts[1]; - s2 = b.cpts[b.stride+0]; - t2 = b.cpts[b.stride+1]; - } - if( s1 == s2 ) - if( t1 < t2 ) - pwl_right( arc, s1, t1, t2, stepsize ); - else - pwl_left( arc, s1, t1, t2, stepsize ); - else if( t1 == t2 ) - if( s1 < s2 ) - pwl_bottom( arc, t1, s1, s2, stepsize ); - else - pwl_top( arc, t1, s1, s2, stepsize ); - else - pwl( arc, s1, s2, t1, t2, stepsize ); - } - - /** - * Constucts a nonlinear pwl arc and attaches it to an Arc. - */ - public void tessellateNonlinear( Arc arc, float geo_stepsize, float arc_stepsize, int isrational ) { - assert( arc.pwlArc == null ); - - float stepsize = geo_stepsize * arc_stepsize; - - BezierArc *bezierArc = arc.bezierArc; - - float size; //bounding box size of the curve in UV - { - int i,j; - float min_u, min_v, max_u,max_v; - min_u = max_u = bezierArc.cpts[0]; - min_v = max_v = bezierArc.cpts[1]; - for(i=1, j=2; i<bezierArc.order; i++, j+= bezierArc.stride) - { - if(bezierArc.cpts[j] < min_u) - min_u = bezierArc.cpts[j]; - if(bezierArc.cpts[j] > max_u) - max_u = bezierArc.cpts[j]; - if(bezierArc.cpts[j+1] < min_v) - min_v = bezierArc.cpts[j+1]; - if(bezierArc.cpts[j+1] > max_v) - max_v = bezierArc.cpts[j+1]; - } - - size = max_u - min_u; - if(size < max_v - min_v) - size = max_v - min_v; - } - - /*int nsteps = 1 + (int) (1.0/stepsize);*/ - - int nsteps = (int) (size/stepsize); - if(nsteps <=0) - nsteps=1; - - TrimVertex[] vert = TrimVertex.allocate( nsteps+1 ); - float dp = 1.0/nsteps; - int vi = 0; // vertIdx - - arc.pwlArc = new PwlArc(); - arc.pwlArc.pts = vert; - - if( isrational ) { - float[] pow_u = new float[Defines.MAXORDER]; - float[] pow_v = new float[Defines.MAXORDER]; - float[] pow_w = new float[Defines.MAXORDER]; - trim_power_coeffs( bezierArc, pow_u, 0 ); - trim_power_coeffs( bezierArc, pow_v, 1 ); - trim_power_coeffs( bezierArc, pow_w, 2 ); - - /* compute first point exactly */ - float[] b = bezierArc.cpts; - vert[vi].param[0] = b[0]/b[2]; - vert[vi].param[1] = b[1]/b[2]; - - /* strength reduction on p = dp * step would introduce error */ - long order = bezierArc.order; - for( int step=1, ++vi; step<nsteps; step++, vi++ ) { - float p = dp * step; - float u = pow_u[0]; - float v = pow_v[0]; - float w = pow_w[0]; - for( int i = 1; i < order; i++ ) { - u = u * p + pow_u[i]; - v = v * p + pow_v[i]; - w = w * p + pow_w[i]; - } - vert[vi].param[0] = u/w; - vert[vi].param[1] = v/w; - } - - /* compute last point exactly */ - b += (order - 1) * bezierArc.stride; - vert[vi].param[0] = b[0]/b[2]; - vert[vi].param[1] = b[1]/b[2]; - - } else { - float[] pow_u = new float[Defines.MAXORDER]; - float[] pow_v = new float[Defines.MAXORDER]; - trim_power_coeffs( bezierArc, pow_u, 0 ); - trim_power_coeffs( bezierArc, pow_v, 1 ); - - /* compute first point exactly */ - float[] b = bezierArc.cpts; - vert[vi].param[0] = b[0]; - vert[vi].param[1] = b[1]; - - /* strength reduction on p = dp * step would introduce error */ - long order = bezierArc.order; - for( int step=1, ++vi; step<nsteps; step++, vi++ ) { - float p = dp * step; - float u = pow_u[0]; - float v = pow_v[0]; - for( int i = 1; i < bezierArc.order; i++ ) { - u = u * p + pow_u[i]; - v = v * p + pow_v[i]; - } - vert[vi].param[0] = u; - vert[vi].param[1] = v; - } - - /* compute last point exactly */ - b += (order - 1) * bezierArc.stride; - vert[vi].param[0] = b[0]; - vert[vi].param[1] = b[1]; - } - arc.pwlArc.npts = vi + 1; - } - - private static final float gl_Bernstein[][Defines.MAXORDER][Defines.MAXORDER] = { - { - {1, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 } - }, - { - {-1, 1, 0, 0, 0, 0, 0, 0 }, - {1, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 } - }, - { - {1, -2, 1, 0, 0, 0, 0, 0 }, - {-2, 2, 0, 0, 0, 0, 0, 0 }, - {1, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 } - }, - { - {-1, 3, -3, 1, 0, 0, 0, 0 }, - {3, -6, 3, 0, 0, 0, 0, 0 }, - {-3, 3, 0, 0, 0, 0, 0, 0 }, - {1, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 } - }, - { - {1, -4, 6, -4, 1, 0, 0, 0 }, - {-4, 12, -12, 4, 0, 0, 0, 0 }, - {6, -12, 6, 0, 0, 0, 0, 0 }, - {-4, 4, 0, 0, 0, 0, 0, 0 }, - {1, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 } - }, - { - {-1, 5, -10, 10, -5, 1, 0, 0 }, - {5, -20, 30, -20, 5, 0, 0, 0 }, - {-10, 30, -30, 10, 0, 0, 0, 0 }, - {10, -20, 10, 0, 0, 0, 0, 0 }, - {-5, 5, 0, 0, 0, 0, 0, 0 }, - {1, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 } - }, - { - {1, -6, 15, -20, 15, -6, 1, 0 }, - {-6, 30, -60, 60, -30, 6, 0, 0 }, - {15, -60, 90, -60, 15, 0, 0, 0 }, - {-20, 60, -60, 20, 0, 0, 0, 0 }, - {15, -30, 15, 0, 0, 0, 0, 0 }, - {-6, 6, 0, 0, 0, 0, 0, 0 }, - {1, 0, 0, 0, 0, 0, 0, 0 }, - {0, 0, 0, 0, 0, 0, 0, 0 } - }, - { - {-1, 7, -21, 35, -35, 21, -7, 1 }, - {7, -42, 105, -140, 105, -42, 7, 0 }, - {-21, 105, -210, 210, -105, 21, 0, 0 }, - {35, -140, 210, -140, 35, 0, 0, 0 }, - {-35, 105, -105, 35, 0, 0, 0, 0 }, - {21, -42, 21, 0, 0, 0, 0, 0 }, - {-7, 7, 0, 0, 0, 0, 0, 0 }, - {1, 0, 0, 0, 0, 0, 0, 0 } - } - }; - - /** - * Computes power basis coefficients from bezier coeffients. - */ - private static void trim_power_coeffs( BezierArc bez_arc, float[] p, int coord ) { - int stride = bez_arc.stride; - int order = bez_arc.order; - float[] base = bez_arc.cpts; - int baseIdx = coord; - - float[][] mat = gl_Bernstein[order-1]; - - for (int i = 0; i < order; i++) { - float[] row = mat[i]; - float s = 0.0f; - int pointIdx = baseIdx; - for (int j = 0; j < order; j++, pointIdx += stride) { - s += row[j] * base[pointIdx]; - } - p[i] = s; - } - } -} diff --git a/src/classes/com/sun/opengl/impl/nurbs/internals/Backend.java b/src/classes/com/sun/opengl/impl/nurbs/internals/Backend.java deleted file mode 100644 index ec0856322..000000000 --- a/src/classes/com/sun/opengl/impl/nurbs/internals/Backend.java +++ /dev/null @@ -1,387 +0,0 @@ -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** NOTE: The Original Code (as defined below) has been licensed to Sun -** Microsystems, Inc. ("Sun") under the SGI Free Software License B -** (Version 1.1), shown above ("SGI License"). Pursuant to Section -** 3.2(3) of the SGI License, Sun is distributing the Covered Code to -** you under an alternative license ("Alternative License"). This -** Alternative License includes all of the provisions of the SGI License -** except that Section 2.2 and 11 are omitted. Any differences between -** the Alternative License and the SGI License are offered solely by Sun -** and not by SGI. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -*/ - -public class Backend { - private BasicCurveEvaluator curveEvaluator; - private BasicSurfaceEvaluator surfaceEvaluator; - - public Backend( BasicCurveEvaluator c, BasicSurfaceEvaluator e ) { - this.c = c; - this.e = e; - } - - /* surface backend routines */ - - /** - * bgnsurf - preamble to surface definition and evaluations - */ - public void bgnsurf( boolean wiretris, boolean wirequads, long nuid ) { - wireframetris = wiretris; - wireframequads = wirequads; - - /*in the spec, GLU_DISPLAY_MODE is either - * GLU_FILL - * GLU_OUTLINE_POLY - * GLU_OUTLINE_PATCH. - *In fact, GLU_FLL is has the same effect as - * set GL_FRONT_AND_BACK to be GL_FILL - * and GLU_OUTLINE_POLY is the same as set - * GL_FRONT_AND_BACK to be GL_LINE - *It is more efficient to do this once at the beginning of - *each surface than to do it for each primitive. - * The internal has more options: outline_triangle and outline_quad - *can be seperated. But since this is not in spec, and more importantly, - *this is not so useful, so we don't need to keep this option. - */ - - surfaceEvaluator.bgnmap2f( nuid ); - - if(wiretris) - surfaceEvaluator.polymode(N_MESHLINE); - else - surfaceEvaluator.polymode(N_MESHFILL); - } - - public void patch( float ulo, float uhi, float vlo, float vhi ) { - surfaceEvaluator.domain2f( ulo, uhi, vlo, vhi ); - } - - /** - * surfpts - pass a desription of a surface map - */ - public void surfpts(long type, /* geometry, color, texture, normal */ - float[] pts, /* control points */ - long ustride, /* distance to next point in u direction */ - long vstride, /* distance to next point in v direction */ - int uorder, /* u parametric order */ - int vorder, /* v parametric order */ - float ulo, /* u lower bound */ - float uhi, /* u upper bound */ - float vlo, /* v lower bound */ - float vhi /* v upper bound */ ) { - surfaceEvaluator.map2f( type,ulo,uhi,ustride,uorder,vlo,vhi,vstride,vorder,pts ); - surfaceEvaluator.enable( type ); - } - public void surfbbox( long type, float[] from, float[] to ) { - surfaceEvaluator.range2f( type, from, to ); - } - /** - * surfgrid - define a lattice of points with origin and offset - */ - public void surfgrid( float u0, float u1, long nu, float v0, float v1, long nv ) { - surfaceEvaluator.mapgrid2f( nu, u0, u1, nv, v0, v1 ); - } - /** - * surfmesh - evaluate a mesh of points on lattice - */ - public void surfmesh( long u, long v, long n, long m ) { - if( wireframequads ) { - long v0, v1; - long u0f = u, u1f = u+n; - long v0f = v, v1f = v+m; - long parity = (u & 1); - - for( v0 = v0f, v1 = v0f++ ; v0<v1f; v0 = v1, v1++ ) { - surfaceEvaluator.bgnline(); - for( long u = u0f; u<=u1f; u++ ) { - if( parity ) { - surfaceEvaluator.evalpoint2i( u, v0 ); - surfaceEvaluator.evalpoint2i( u, v1 ); - } else { - surfaceEvaluator.evalpoint2i( u, v1 ); - surfaceEvaluator.evalpoint2i( u, v0 ); - } - parity = 1 - parity; - } - surfaceEvaluator.endline(); - } - } else { - surfaceEvaluator.mapmesh2f( N_MESHFILL, u, u+n, v, v+m ); - } - } - /** - * bgntmesh - preamble to a triangle mesh - */ - public void bgntmesh() { - meshindex = 0; /* I think these need to be initialized to zero */ - npts = 0; - - if( !wireframetris ) { - surfaceEvaluator.bgntmesh(); - } - } - /** - * endtmesh - postamble to triangle mesh - */ - public void endtmesh( ) { - if( ! wireframetris ) - surfaceEvaluator.endtmesh(); - } - /** - * swaptmesh - perform a swap of the triangle mesh pointers - */ - public void swaptmesh( ) { - if( wireframetris ) { - meshindex = 1 - meshindex; - } else { - surfaceEvaluator.swaptmesh(); - } - } - public void tmeshvert( GridTrimVertex v ) { - if( v.isGridVert() ) { - tmeshvert( v.g ); - } else { - tmeshvert( v.t ); - } - } - /** - * tmeshvert - evaluate a point on a triangle mesh - */ - public void tmeshvert( TrimVertex t ) { - long nuid = t.nuid; - float u = t.param[0]; - float v = t.param[1]; - - npts++; - if( wireframetris ) { - if( npts >= 3 ) { - surfaceEvaluator.bgnclosedline(); - if( mesh[0][2] == 0 ) - surfaceEvaluator.evalcoord2f( mesh[0][3], mesh[0][0], mesh[0][1] ); - else - surfaceEvaluator.evalpoint2i( (long) mesh[0][0], (long) mesh[0][1] ); - if( mesh[1][2] == 0 ) - surfaceEvaluator.evalcoord2f( mesh[1][3], mesh[1][0], mesh[1][1] ); - else - surfaceEvaluator.evalpoint2i( (long) mesh[1][0], (long) mesh[1][1] ); - surfaceEvaluator.evalcoord2f( nuid, u, v ); - surfaceEvaluator.endclosedline(); - } - mesh[meshindex][0] = u; - mesh[meshindex][1] = v; - mesh[meshindex][2] = 0; - mesh[meshindex][3] = nuid; - meshindex = (meshindex+1) % 2; - } else { - surfaceEvaluator.evalcoord2f( nuid, u, v ); - } - } - /** - * tmeshvert - evaluate a grid point of a triangle mesh - */ - public void tmeshvert( GridVertex g ) { - long u = g->gparam[0]; - long v = g->gparam[1]; - - npts++; - if( wireframetris ) { - if( npts >= 3 ) { - surfaceEvaluator.bgnclosedline(); - if( mesh[0][2] == 0 ) - surfaceEvaluator.evalcoord2f( (long) mesh[0][3], mesh[0][0], mesh[0][1] ); - else - surfaceEvaluator.evalpoint2i( (long) mesh[0][0], (long) mesh[0][1] ); - if( mesh[1][2] == 0 ) - surfaceEvaluator.evalcoord2f( (long) mesh[1][3], mesh[1][0], mesh[1][1] ); - else - surfaceEvaluator.evalpoint2i( (long) mesh[1][0], (long) mesh[1][1] ); - surfaceEvaluator.evalpoint2i( u, v ); - surfaceEvaluator.endclosedline(); - } - mesh[meshindex][0] = u; - mesh[meshindex][1] = v; - mesh[meshindex][2] = 1; - meshindex = (meshindex+1) % 2; - } else { - surfaceEvaluator.evalpoint2i( u, v ); - } - } - /** the same as tmeshvert(trimvertex), for efficiency purpose */ - public void tmeshvert( float u, float v ) { - long nuid = 0; - - npts++; - if( wireframetris ) { - if( npts >= 3 ) { - surfaceEvaluator.bgnclosedline(); - if( mesh[0][2] == 0 ) - surfaceEvaluator.evalcoord2f( mesh[0][3], mesh[0][0], mesh[0][1] ); - else - surfaceEvaluator.evalpoint2i( (long) mesh[0][0], (long) mesh[0][1] ); - if( mesh[1][2] == 0 ) - surfaceEvaluator.evalcoord2f( mesh[1][3], mesh[1][0], mesh[1][1] ); - else - surfaceEvaluator.evalpoint2i( (long) mesh[1][0], (long) mesh[1][1] ); - surfaceEvaluator.evalcoord2f( nuid, u, v ); - surfaceEvaluator.endclosedline(); - } - mesh[meshindex][0] = u; - mesh[meshindex][1] = v; - mesh[meshindex][2] = 0; - mesh[meshindex][3] = nuid; - meshindex = (meshindex+1) % 2; - } else { - surfaceEvaluator.evalcoord2f( nuid, u, v ); - } - } - /** - * linevert - evaluate a point on an outlined contour - */ - public void linevert( TrimVertex t ) { - surfaceEvaluator.evalcoord2f( t.nuid, t.param[0], t.param[1] ); - } - /** - * linevert - evaluate a grid point of an outlined contour - */ - public void linevert( GridVertex g ) { - surfaceEvaluator.evalpoint2i( g.gparam[0], g.gparam[1] ); - } - /** - * bgnoutline - preamble to outlined rendering - */ - public void bgnoutline( ) { - surfaceEvaluator.bgnline(); - } - /** - * endoutline - postamble to outlined rendering - */ - public void endoutline( ) { - surfaceEvaluator.endline(); - } - /** - * endsurf - postamble to surface - */ - public void endsurf( ) { - surfaceEvaluator.endmap2f(); - } - /** - * triangle - output a triangle - */ - public void triangle( TrimVertex a, TrimVertex b, TrimVertex c ) { - bgntfan(); - tmeshvert( a ); - tmeshvert( b ); - tmeshvert( c ); - endtfan(); - } - - public void bgntfan() { - surfaceEvaluator.bgntfan(); - } - public void endtfan() { - surfaceEvaluator.endtfan(); - } - public void bgnqstrip() { - surfaceEvaluator.bgnqstrip(); - } - public void endqstrip() { - surfaceEvaluator.endqstrip(); - } - public void evalUStrip(int n_upper, float v_upper, float[] upper_val, - int n_lower, float v_lower, float[] lower_val) { - surfaceEvaluator.evalUStrip(n_upper, v_upper, upper_val, - n_lower, v_lower, lower_val); - } - public void evalVStrip(int n_left, float u_left, float[] left_val, - int n_right, float v_right, float[] right_val) { - surfaceEvaluator.evalVStrip(n_left, u_left, left_val, - n_right, u_right, right_val); - } - public void tmeshvertNOGE(TrimVertex *t) { - // NOTE: under undefined USE_OPTTT #ifdef - } - public void tmeshvertNOGE_BU(TrimVertex *t) { - // NOTE: under undefined USE_OPTTT #ifdef - } - public void tmeshvertNOGE_BV(TrimVertex *t) { - // NOTE: under undefined USE_OPTTT #ifdef - } - public void preEvaluateBU(float u) { - surfaceEvaluator.inPreEvaluateBU_intfac(u); - } - public void preEvaluateBV(float v) { - surfaceEvaluator.inPreEvaluateBV_intfac(v); - } - - /* curve backend routines */ - public void bgncurv( void ) { - curveEvaluator.bgnmap1f( 0 ); - } - public void segment( float ulo, float uhi ) { - curveEvaluator.domain1f( ulo, uhi ); - } - public void curvpts(long type, /* geometry, color, texture, normal */ - float[] pts, /* control points */ - long stride, /* distance to next point */ - int order, /* parametric order */ - float ulo, /* lower parametric bound */ - float uhi ) /* upper parametric bound */ { - curveEvaluator.map1f( type, ulo, uhi, stride, order, pts ); - curveEvaluator.enable( type ); - } - public void curvgrid( float u0, float u1, long nu ) { - curveEvaluator.mapgrid1f( nu, u0, u1 ); - } - public void curvmesh( long from, long n ) { - curveEvaluator.mapmesh1f( N_MESHFILL, from, from+n ); - } - public void curvpt( float u ) { - curveEvaluator.evalcoord1f( 0, u ); - } - public void bgnline( ) { - curveEvaluator.bgnline(); - } - public void endline( ) { - curveEvaluator.endline(); - } - public void endcurv( ) { - curveEvaluator.endmap1f(); - } - - private boolean wireframetris; - private boolean wireframequads; - private int npts; - private float[][] mesh = new float[3][4]; - private int meshindex; -} diff --git a/src/classes/com/sun/opengl/impl/nurbs/internals/BasicCurveEvaluator.java b/src/classes/com/sun/opengl/impl/nurbs/internals/BasicCurveEvaluator.java deleted file mode 100644 index 24f2a682a..000000000 --- a/src/classes/com/sun/opengl/impl/nurbs/internals/BasicCurveEvaluator.java +++ /dev/null @@ -1,60 +0,0 @@ -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** NOTE: The Original Code (as defined below) has been licensed to Sun -** Microsystems, Inc. ("Sun") under the SGI Free Software License B -** (Version 1.1), shown above ("SGI License"). Pursuant to Section -** 3.2(3) of the SGI License, Sun is distributing the Covered Code to -** you under an alternative license ("Alternative License"). This -** Alternative License includes all of the provisions of the SGI License -** except that Section 2.2 and 11 are omitted. Any differences between -** the Alternative License and the SGI License are offered solely by Sun -** and not by SGI. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -*/ - -public class BasicCurveEvaluator extends CachingEvaluator { - public void domain1f(float ulo, float uhi) {} - public void range1f(long type, float[] from, float[] to) {} - - public void enable(long type) {} - public void disable(long type) {} - public void bgnmap1f(long type) {} - public void map1f(long type, float ulo, float uhi, long stride, long order, float[] pts) {} - public void mapgrid1f(long nu, float u0, float u1) {} - public void mapmesh1f(long style, long from, long to) {} - public void evalcoord1f(long type, float u) {} - public void endmap1f() {} - - public void bgnline() {} - public void endline() {} -} diff --git a/src/classes/com/sun/opengl/impl/nurbs/internals/BasicSurfaceEvaluator.java b/src/classes/com/sun/opengl/impl/nurbs/internals/BasicSurfaceEvaluator.java deleted file mode 100644 index 191874d32..000000000 --- a/src/classes/com/sun/opengl/impl/nurbs/internals/BasicSurfaceEvaluator.java +++ /dev/null @@ -1,86 +0,0 @@ -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** NOTE: The Original Code (as defined below) has been licensed to Sun -** Microsystems, Inc. ("Sun") under the SGI Free Software License B -** (Version 1.1), shown above ("SGI License"). Pursuant to Section -** 3.2(3) of the SGI License, Sun is distributing the Covered Code to -** you under an alternative license ("Alternative License"). This -** Alternative License includes all of the provisions of the SGI License -** except that Section 2.2 and 11 are omitted. Any differences between -** the Alternative License and the SGI License are offered solely by Sun -** and not by SGI. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -*/ - -public abstract class BasicSurfaceEvaluator extends CachingEvaluator { - public void range2f(long, float[] from, float[] to) {} - public void domain2f(float ulo, float uhi, float vlo, float vhi) {} - - public void enable(long type) {} - public void disable(long type) {} - public void bgnmap2f(long type) {} - public void map2f(long type, float ulower, float uupper, long ustride, long uorder, - float vlower, float vupper, long vstride, long vorder, - float[] pts) {} - public void mapgrid2f(long nu, float u0, float u1, - long nv, float v0, float v1) {} - public void mapmesh2f(long style, long umin, long umax, - long vmin, long vmax) {} - public void evalcoord2f(long type, float u, float v) {} - public void evalpoint2i(long u, long v) {} - public void endmap2f() {} - - public void polymode(long style) {} - public void bgnline() {} - public void endline() {} - public void bgnclosedline() {} - public void endclosedline() {} - public void bgntmesh() {} - public void swaptmesh() {} - public void endtmesh() {} - public void bgnqstrip() {} - public void endqstrip() {} - - public void bgntfan() {} - public void endtfan() {} - - public abstract void evalUStrip(int n_upper, float v_upper, float[] upper_val, - int n_lower, float v_lower, float[] lower_val); - public abstract void evalVStrip(int n_left, float u_left, float[] left_val, - int n_right, float u_right, float[] right_val); - public abstract void inDoEvalCoord2NOGE(float u, float v, float[] ret_point, float[] ret_normal); - public abstract void inDoEvalCoord2NOGE_BU(float u, float v, float[] ret_point, float[] ret_normal); - public abstract void inDoEvalCoord2NOGE_BV(float u, float v, float[] ret_point, float[] ret_normal); - public abstract void inPreEvaluateBV_intfac(float v); - public abstract void inPreEvaluateBU_intfac(float u); -} diff --git a/src/classes/com/sun/opengl/impl/nurbs/internals/BezierArc.java b/src/classes/com/sun/opengl/impl/nurbs/internals/BezierArc.java deleted file mode 100644 index 30607c0f2..000000000 --- a/src/classes/com/sun/opengl/impl/nurbs/internals/BezierArc.java +++ /dev/null @@ -1,52 +0,0 @@ -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** NOTE: The Original Code (as defined below) has been licensed to Sun -** Microsystems, Inc. ("Sun") under the SGI Free Software License B -** (Version 1.1), shown above ("SGI License"). Pursuant to Section -** 3.2(3) of the SGI License, Sun is distributing the Covered Code to -** you under an alternative license ("Alternative License"). This -** Alternative License includes all of the provisions of the SGI License -** except that Section 2.2 and 11 are omitted. Any differences between -** the Alternative License and the SGI License are offered solely by Sun -** and not by SGI. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -*/ - -/** A bezier arc. */ -class BezierArc { - public float[] cpts; /* control points of arc */ - public int order; /* order of arc */ - public int stride; /* REAL distance between points */ - public long type; /* curve type */ - public Mapdesc mapdesc; -} diff --git a/src/classes/com/sun/opengl/impl/nurbs/internals/Bin.java b/src/classes/com/sun/opengl/impl/nurbs/internals/Bin.java deleted file mode 100644 index 42306c1ff..000000000 --- a/src/classes/com/sun/opengl/impl/nurbs/internals/Bin.java +++ /dev/null @@ -1,157 +0,0 @@ -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** NOTE: The Original Code (as defined below) has been licensed to Sun -** Microsystems, Inc. ("Sun") under the SGI Free Software License B -** (Version 1.1), shown above ("SGI License"). Pursuant to Section -** 3.2(3) of the SGI License, Sun is distributing the Covered Code to -** you under an alternative license ("Alternative License"). This -** Alternative License includes all of the provisions of the SGI License -** except that Section 2.2 and 11 are omitted. Any differences between -** the Alternative License and the SGI License are offered solely by Sun -** and not by SGI. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -*/ - -public class Bin { - private Arc head; /*first arc on list */ - private Arc current; /* current arc on list */ - - /** - * Sets current arc to first arc of bin; advances to next arc. - */ - public Arc firstarc( ) { - current = head; - return nextarc( ); - } - /** - * Returns current arc in bin and advances pointer to next arc. - */ - public Arc nextarc( ) { - Arc jarc = current; - - assert( (jarc == null) || jarc.check() ); - - if( jarc != null ) current = jarc.link; - return jarc; - } - /** - * Removes first Arc from bin. - */ - public Arc removearc( ) { - Arc jarc = head; - - if( jarc != null ) head = jarc.link; - return jarc; - } - public boolean isnonempty( ) { return (head != null); } - /** - * Adds an Arc to head of the linked list of Arcs. - */ - public void addarc( Arc jarc ) { - jarc.link = head; - head = jarc; - } - /** - * Removes given Arc from bin. - */ - public void remove_this_arc( Arc arc ) { - Arc j, prev; - for( j = head; (j != null) && (j != arc); prev = j, j = j.link ); - - if( j != null ) { - if( j == current ) - current = j.link; - if ( prev != null ) - prev.link = j.link; - } - } - /** - * Counts number of arcs in bin. - */ - public int numarcs( ) { - long count = 0; - for( Arc jarc = firstarc(); jarc != null; jarc = nextarc() ) - count++; - return count; - } - /** - * Places an orphaned arc into its new parent's bin. - */ - public void adopt( ) { - markall(); - - Arc orphan; - while( (orphan = removearc()) != null ) { - for( Arc parent = orphan.next; parent != orphan; parent = parent.next ) { - if (! parent.ismarked() ) { - orphan.link = parent.link; - parent.link = orphan; - orphan.clearmark(); - break; - } - } - } - } - /** - * Marks all arcs with an identifying tag. - */ - public void markall( ) { - for( Arc jarc = firstarc(); jarc != null; jarc = nextarc() ) - jarc.setmark(); - } - /** - * Prints out descriptions of the arcs in the bin. - */ - public void show( String name ) { - System.out.println( name ); - for( Arc jarc = firstarc(); jarc != null; jarc = nextarc() ) - jarc.show( ); - } - /** - * Prints out all arcs that are untessellated border arcs. - */ - public void listBezier( ) { - for( Arc jarc = firstarc(); jarc != null; jarc = nextarc() ) { - if( jarc.isbezier( ) ) { - assert( jarc.pwlArc.npts == 2 ); - TrimVertex[] pts = jarc.pwlArc.pts; - float s1 = pts[0].param[0]; - float t1 = pts[0].param[1]; - float s2 = pts[1].param[0]; - float t2 = pts[1].param[1]; - System.out.println( "arc ( " + s1 + "," + t1 + ") (" + - s2 + "," + t2 + ")"); - } - } - } -} diff --git a/src/classes/com/sun/opengl/impl/nurbs/internals/CachingEvaluator.java b/src/classes/com/sun/opengl/impl/nurbs/internals/CachingEvaluator.java deleted file mode 100644 index 98baec3bf..000000000 --- a/src/classes/com/sun/opengl/impl/nurbs/internals/CachingEvaluator.java +++ /dev/null @@ -1,66 +0,0 @@ -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** NOTE: The Original Code (as defined below) has been licensed to Sun -** Microsystems, Inc. ("Sun") under the SGI Free Software License B -** (Version 1.1), shown above ("SGI License"). Pursuant to Section -** 3.2(3) of the SGI License, Sun is distributing the Covered Code to -** you under an alternative license ("Alternative License"). This -** Alternative License includes all of the provisions of the SGI License -** except that Section 2.2 and 11 are omitted. Any differences between -** the Alternative License and the SGI License are offered solely by Sun -** and not by SGI. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -*/ - -public class CachingEvaluator { - public int ServiceModePlay = 0; - public int ServiceModeRecord = 1; - public int ServiceModePlayAndRecord = 2; - - public int canRecord() { - return 0; - } - - public int canPlayAndRecord() { - return 0; - } - - public int createHandle( int handle ) { - return 0; - } - - public void beginOutput( int serviceMode, int handle ) {} - public void endOutput() {} - public void discardRecording(int handle) {} - public void playRecording(int handle) {} -} diff --git a/src/classes/com/sun/opengl/impl/nurbs/internals/Defines.java b/src/classes/com/sun/opengl/impl/nurbs/internals/Defines.java deleted file mode 100644 index 4b4f0ff7f..000000000 --- a/src/classes/com/sun/opengl/impl/nurbs/internals/Defines.java +++ /dev/null @@ -1,56 +0,0 @@ -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** NOTE: The Original Code (as defined below) has been licensed to Sun -** Microsystems, Inc. ("Sun") under the SGI Free Software License B -** (Version 1.1), shown above ("SGI License"). Pursuant to Section -** 3.2(3) of the SGI License, Sun is distributing the Covered Code to -** you under an alternative license ("Alternative License"). This -** Alternative License includes all of the provisions of the SGI License -** except that Section 2.2 and 11 are omitted. Any differences between -** the Alternative License and the SGI License are offered solely by Sun -** and not by SGI. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -*/ - -public class Defines { - /* culling constants */ - public static final int CULL_TRIVIAL_REJECT = 0; - public static final int CULL_TRIVIAL_ACCEPT = 1; - public static final int CULL_ACCEPT = 2; - - /* maximum order of a B-Spline */ - public static final int MAXORDER = 24; - - /* maximum dimension of any B-spline range space */ - public static final int MAXCOORDS = 5; -} diff --git a/src/classes/com/sun/opengl/impl/nurbs/internals/NurbsConsts.java b/src/classes/com/sun/opengl/impl/nurbs/internals/NurbsConsts.java deleted file mode 100644 index 20b45efba..000000000 --- a/src/classes/com/sun/opengl/impl/nurbs/internals/NurbsConsts.java +++ /dev/null @@ -1,127 +0,0 @@ -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** NOTE: The Original Code (as defined below) has been licensed to Sun -** Microsystems, Inc. ("Sun") under the SGI Free Software License B -** (Version 1.1), shown above ("SGI License"). Pursuant to Section -** 3.2(3) of the SGI License, Sun is distributing the Covered Code to -** you under an alternative license ("Alternative License"). This -** Alternative License includes all of the provisions of the SGI License -** except that Section 2.2 and 11 are omitted. Any differences between -** the Alternative License and the SGI License are offered solely by Sun -** and not by SGI. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -*/ - -public class NurbsConsts { - /* NURBS Properties - one set per map, - each takes a single INREAL arg */ - public static final int N_SAMPLING_TOLERANCE = 1; - public static final int N_S_RATE = 6; - public static final int N_T_RATE = 7; - public static final int N_CLAMPFACTOR = 13; - public static final float N_NOCLAMPING = 0.0f; - public static final int N_MINSAVINGS = 14; - public static final float N_NOSAVINGSSUBDIVISION = 0.0f; - - /* NURBS Properties - one set per map, - each takes an enumerated value */ - public static final int N_CULLING = 2; - public static final float N_NOCULLING = 0.0f; - public static final float N_CULLINGON = 1.0f; - public static final int N_SAMPLINGMETHOD 10; - public static final float N_NOSAMPLING = 0.0f; - public static final float N_FIXEDRATE = 3.0f; - public static final float N_DOMAINDISTANCE = 2.0f; - public static final float N_PARAMETRICDISTANCE = 5.0f; - public static final float N_PATHLENGTH = 6.0f; - public static final float N_SURFACEAREA = 7.0f; - public static final float N_OBJECTSPACE_PARA = 8.0f; - public static final float N_OBJECTSPACE_PATH = 9.0f; - public static final int N_BBOX_SUBDIVIDING = 17; - public static final float N_NOBBOXSUBDIVISION = 0.0f; - public static final float N_BBOXTIGHT = 1.0f; - public static final float N_BBOXROUND = 2.0f; - - /* NURBS Rendering Properties - one set per renderer - each takes an enumerated value */ -public static final int N_DISPLAY 3 -public static final int N_FILL 1.0 -public static final int N_OUTLINE_POLY 2.0 -public static final int N_OUTLINE_TRI 3.0 -public static final int N_OUTLINE_QUAD 4.0 -public static final int N_OUTLINE_PATCH 5.0 -public static final int N_OUTLINE_PARAM 6.0 -public static final int N_OUTLINE_PARAM_S 7.0 -public static final int N_OUTLINE_PARAM_ST 8.0 -public static final int N_OUTLINE_SUBDIV 9.0 -public static final int N_OUTLINE_SUBDIV_S 10.0 -public static final int N_OUTLINE_SUBDIV_ST 11.0 -public static final int N_ISOLINE_S 12.0 -public static final int N_ERRORCHECKING 4 -public static final int N_NOMSG 0.0 -public static final int N_MSG 1.0 - -/* GL 4.0 propeties not defined above */ -#ifndef N_PIXEL_TOLERANCE -public static final int N_PIXEL_TOLERANCE N_SAMPLING_TOLERANCE -public static final int N_ERROR_TOLERANCE 20 -public static final int N_SUBDIVISIONS 5 -public static final int N_TILES 8 -public static final int N_TMP1 9 -public static final int N_TMP2 N_SAMPLINGMETHOD -public static final int N_TMP3 11 -public static final int N_TMP4 12 -public static final int N_TMP5 N_CLAMPFACTOR -public static final int N_TMP6 N_MINSAVINGS -public static final int N_S_STEPS N_S_RATE -public static final int N_T_STEPS N_T_RATE -#endif - -/* NURBS Rendering Properties - one set per map, - each takes an INREAL matrix argument */ -public static final int N_CULLINGMATRIX 1 -public static final int N_SAMPLINGMATRIX 2 -public static final int N_BBOXMATRIX 3 - - -/* NURBS Rendering Properties - one set per map, - each takes an INREAL vector argument */ -public static final int N_BBOXSIZE 4 - -/* type argument for trimming curves */ -#ifndef N_P2D -public static final int N_P2D 0x8 -public static final int N_P2DR 0xd -#endif - -} diff --git a/src/classes/com/sun/opengl/impl/nurbs/internals/NurbsException.java b/src/classes/com/sun/opengl/impl/nurbs/internals/NurbsException.java deleted file mode 100644 index 5453807cd..000000000 --- a/src/classes/com/sun/opengl/impl/nurbs/internals/NurbsException.java +++ /dev/null @@ -1,30 +0,0 @@ -/** Encapsulates functionality of the C GLU NURBS implementation's - setjmp/longjmp wrappers. */ - -public class NurbsException extends RuntimeException { - private int errorCode; - - public NurbsException(int code) { - super(); - errorCode = code; - } - - public NurbsException(String message, int code) { - super(message); - errorCode = code; - } - - public NurbsException(String message, Throwable cause, int code) { - super(message, cause); - errorCode = code; - } - - public NurbsException(Throwable cause, int code) { - super(cause); - errorCode = code; - } - - public int errorCode() { - return errorCode; - } -} diff --git a/src/classes/com/sun/opengl/impl/nurbs/internals/Subdivider.java b/src/classes/com/sun/opengl/impl/nurbs/internals/Subdivider.java deleted file mode 100644 index 85b569e25..000000000 --- a/src/classes/com/sun/opengl/impl/nurbs/internals/Subdivider.java +++ /dev/null @@ -1,1791 +0,0 @@ -/* -** License Applicability. Except to the extent portions of this file are -** made subject to an alternative license as permitted in the SGI Free -** Software License B, Version 1.1 (the "License"), the contents of this -** file are subject only to the provisions of the License. You may not use -** this file except in compliance with the License. You may obtain a copy -** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 -** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: -** -** http://oss.sgi.com/projects/FreeB -** -** Note that, as provided in the License, the Software is distributed on an -** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS -** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND -** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A -** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. -** -** NOTE: The Original Code (as defined below) has been licensed to Sun -** Microsystems, Inc. ("Sun") under the SGI Free Software License B -** (Version 1.1), shown above ("SGI License"). Pursuant to Section -** 3.2(3) of the SGI License, Sun is distributing the Covered Code to -** you under an alternative license ("Alternative License"). This -** Alternative License includes all of the provisions of the SGI License -** except that Section 2.2 and 11 are omitted. Any differences between -** the Alternative License and the SGI License are offered solely by Sun -** and not by SGI. -** -** Original Code. The Original Code is: OpenGL Sample Implementation, -** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, -** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc. -** Copyright in any portions created by third parties is as indicated -** elsewhere herein. All Rights Reserved. -** -** Additional Notice Provisions: The application programming interfaces -** established by SGI in conjunction with the Original Code are The -** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released -** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version -** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X -** Window System(R) (Version 1.3), released October 19, 1998. This software -** was created using the OpenGL(R) version 1.2.1 Sample Implementation -** published by SGI, but has not been independently verified as being -** compliant with the OpenGL(R) version 1.2.1 Specification. -*/ - -public class Subdivider { - - /** - * Constructs a subdivider. - */ - public Subdivider(RenderHints hints, Backend b) { - renderhints = hints; - arctessellator = new ArcTesselator(); - backend = b; - slicer = new Slicer(b); - } - - /** - * Resets all state after possible error condition. - */ - public void clear() { - // FIXME: looks like nothing to do given that we have no object pools - } - public void beginTrims() {} - public void beginLoop() { - pjarc = 0; - } - - /** - * Adds a bezier arc to a trim loop and to a bin. - */ - public void addArc(float[] cpts, Quilt quilt, long _nuid) { - BezierArc bezierArc = new BezierArc(); - Arc jarc = new Arc(Arc.SIDE_NONE, _nuid); - jarc.bezierArc = bezierArc; - bezierArc.order = quilt.qspec.order; - bezierArc.stride = quilt.qspec.stride; - bezierArc.mapdesc = quilt.mapdesc; - bezierArc.cpts = cpts; - initialbin.addarc( jarc ); - pjarc = jarc.append( pjarc ); - } - - /** - * Adds a pwl arc to a trim loop and to a bin. - */ - public void addArc(int npts, TrimVertex[] pts, long _nuid) { - Arc jarc = new Arc( Arc.SIDE_NONE, _nuid ); - jarc.pwlArc = new PwlArc( npts, pts ); - initialbin.addarc( jarc ); - pjarc = jarc.append( pjarc ); - } - public void endLoop() {} - public void endTrims() {} - - public void beginQuilts() { - qlist = null; - } - public void addQuilt( Quilt quilt ) { - quilt.next = qlist; - qlist = quilt; - } - public void endQuilts() {} - - /** - * Main curve rendering entry point - */ - public void drawCurves() { - float[] from = new float[1]; - float[] to = new float[1]; - Flist bpts = new Flist(); - qlist.getRange( from, to, bpts ); - - renderhints.init( ); - - backend.bgncurv(); - float[] pta = new float[0]; - float[] ptb = new float[1]; - for( int i=bpts.start; i<bpts.end-1; i++ ) { - pta[0] = bpts.pts[i]; - ptb[0] = bpts.pts[i+1]; - - qlist.downloadAll( pta, ptb, backend ); - - Curvelist curvelist = new Curvelist( qlist, pta, ptb ); - samplingSplit( curvelist, renderhints.maxsubdivisions ); - } - backend.endcurv(); - } - public void drawSurfaces(long nuid) { - renderhints.init( ); - - if (qlist == null) { - //initialbin could be nonempty due to some errors - freejarcs(initialbin); - return; - } - - for( Quilt q = qlist; q != null; q = q.next ) { - if( q.isCulled( ) == Defines.CULL_TRIVIAL_REJECT ) { - freejarcs( initialbin ); - return; - } - } - - - float[] from = new float[2]; - float[] to = new float[2]; - qlist.getRange( from, to, spbrkpts, tpbrkpts ); - //perform optimization only when the samplng method is - //DOMAIN_DISTANCE and the display methdo is either - //fill or outline_polygon. - bool optimize = (is_domain_distance_sampling && (renderhints.display_method != N_OUTLINE_PATCH)); - - if( ! initialbin.isnonempty() ) { - if(! optimize ) - { - makeBorderTrim( from, to ); - } - } else { - float[] rate = new float[2]; - qlist.findRates( spbrkpts, tpbrkpts, rate ); - - if( decompose( initialbin, Math.min(rate[0], rate[1]) ) ) - throw new NurbsException( 31 ); - } - - backend.bgnsurf( renderhints.wiretris, renderhints.wirequads, nuid ); - - if( (!initialbin.isnonempty()) && optimize ) - { - int i,j; - int num_u_steps; - int num_v_steps; - for(i=spbrkpts.start; i<spbrkpts.end-1; i++){ - for(j=tpbrkpts.start; j<tpbrkpts.end-1; j++){ - float[] pta = new float[2]; - float[] ptb = new float[2]; - pta[0] = spbrkpts.pts[i]; - ptb[0] = spbrkpts.pts[i+1]; - pta[1] = tpbrkpts.pts[j]; - ptb[1] = tpbrkpts.pts[j+1]; - qlist.downloadAll(pta, ptb, backend); - - num_u_steps = (int) (domain_distance_u_rate * (ptb[0]-pta[0])); - num_v_steps = (int) (domain_distance_v_rate * (ptb[1]-pta[1])); - - if(num_u_steps <= 0) num_u_steps = 1; - if(num_v_steps <= 0) num_v_steps = 1; - - backend.surfgrid(pta[0], ptb[0], num_u_steps, - ptb[1], pta[1], num_v_steps); - backend.surfmesh(0,0,num_u_steps,num_v_steps); - - continue; - } - } - } - else - subdivideInS( initialbin ); - - backend.endsurf(); - } - - public int ccwTurn_sl(Arc j1, Arc j2 ) { - int v1i = j1.pwlArc.npts-1; - int v1lasti = 0; - int v2i = 0; - int v2lasti = j2.pwlArc.npts-1; - int v1nexti = v1i-1; - int v2nexti = v2i+1; - TrimVertex v1 = j1.pwlArc.pts[v1i]; - TrimVertex v1last = j1.pwlArc.pts[v1lasti]; - TrimVertex v2 = j2.pwlArc.pts[v2i]; - TrimVertex v2last = j2.pwlArc.pts[v2lasti]; - TrimVertex v1next = j1.pwlArc.pts[v1nexti]; - TrimVertex v2next = j2.pwlArc.pts[v2nexti]; - int sgn; - - assert( v1 != v1last ); - assert( v2 != v2last ); - - // the arcs lie on the line (0 == v1.param[0]) - if( v1.param[0] == v1next.param[0] && v2.param[0] == v2next.param[0] ) - return 0; - - if( v2next.param[0] > v2.param[0] || v1next.param[0] > v1.param[0] ) - throw new NurbsException(28); - - if( v1.param[1] < v2.param[1] ) - return 1; - else if( v1.param[1] > v2.param[1] ) - return 0; - - while( true ) { - if( v1next.param[0] > v2next.param[0] ) { - assert( v1.param[0] >= v1next.param[0] ); - assert( v2.param[0] >= v1next.param[0] ); - switch( bbox( v2next, v2, v1next, 1 ) ) { - case -1: - return 1; - case 0: - sgn = ccw( v1next, v2, v2next ); - if( sgn != -1 ) - return sgn; - else { - v1i = v1nexti--; - v1 = j1.pwlArc.pts[v1i]; - v1next = j1.pwlArc.pts[v1nexti]; - if( v1 == v1last ) { - return 0; // ill-conditioned, guess answer - } - } - break; - case 1: - return 0; - } - } else if( v1next.param[0] < v2next.param[0] ) { - assert( v1.param[0] >= v2next.param[0] ); - assert( v2.param[0] >= v2next.param[0] ); - switch( bbox( v1next, v1, v2next, 1 ) ) { - case -1: - return 0; - case 0: - sgn = ccw( v1next, v1, v2next ); - if( sgn != -1 ) - return sgn; - else { - v2i = v2nexti++; - v2 = j2.pwlArc.pts[v2i]; - v2next = j2.pwlArc.pts[v2nexti]; - if( v2 == v2last ) { - return 0; // ill-conditioned, guess answer - } - } - break; - case 1: - return 1; - } - } else { - if( v1next.param[1] < v2next.param[1] ) - return 1; - else if( v1next.param[1] > v2next.param[1] ) - return 0; - else { - v2i = v2nexti++; - v2 = j2.pwlArc.pts[v2i]; - v2next = j2.pwlArc.pts[v2nexti]; - if( v2 == v2last ) { - return 0; // ill-conditioned, guess answer - } - } - } - } - } - - public int ccwTurn_sr(Arc j1, Arc j2 ) { - // dir = 1 - int v1i = j1.pwlArc.npts-1; - int v1lasti = 0; - int v2i = 0; - int v2lasti = j2.pwlArc.npts-1; - int v1nexti = v1i-1; - int v2nexti = v2i+1; - TrimVertex v1 = j1.pwlArc.pts[v1i]; - TrimVertex v1last = j1.pwlArc.pts[v1lasti]; - TrimVertex v2 = j2.pwlArc.pts[v2i]; - TrimVertex v2last = j2.pwlArc.pts[v2lasti]; - TrimVertex v1next = j1.pwlArc.pts[v1nexti]; - TrimVertex v2next = j2.pwlArc.pts[v2nexti]; - int sgn; - - assert( v1 != v1last ); - assert( v2 != v2last ); - - // the arcs lie on the line (0 == v1.param[0]) - if( v1.param[0] == v1next.param[0] && v2.param[0] == v2next.param[0] ) - return 0; - - if( v2next.param[0] < v2.param[0] || v1next.param[0] < v1.param[0] ) - throw new NurbsException(28); - - if( v1.param[1] < v2.param[1] ) - return 0; - else if( v1.param[1] > v2.param[1] ) - return 1; - - while( true ) { - if( v1next.param[0] < v2next.param[0] ) { - assert( v1.param[0] <= v1next.param[0] ); - assert( v2.param[0] <= v1next.param[0] ); - switch( bbox( v2, v2next, v1next, 1 ) ) { - case -1: - return 0; - case 0: - sgn = ccw( v1next, v2, v2next ); - if( sgn != -1 ) { - return sgn; - } else { - v1i = v1nexti--; - v1 = j1.pwlArc.pts[v1i]; - v1next = j1.pwlArc.pts[v1nexti]; - if( v1 == v1last ) { - return 0; // ill-conditioned, guess answer - } - } - break; - case 1: - return 1; - } - } else if( v1next.param[0] > v2next.param[0] ) { - assert( v1.param[0] <= v2next.param[0] ); - assert( v2.param[0] <= v2next.param[0] ); - switch( bbox( v1, v1next, v2next, 1 ) ) { - case -1: - return 1; - case 0: - sgn = ccw( v1next, v1, v2next ); - if( sgn != -1 ) { - return sgn; - } else { - v2i = v2nexti++; - v2 = j2.pwlArc.pts[v2i]; - v2next = j2.pwlArc.pts[v2nexti]; - if( v2 == v2last ) { - return 0; // ill-conditioned, guess answer - } - } - break; - case 1: - return 0; - } - } else { - if( v1next.param[1] < v2next.param[1] ) - return 0; - else if( v1next.param[1] > v2next.param[1] ) - return 1; - else { - v2i = v2nexti++; - v2 = j2.pwlArc.pts[v2i]; - v2next = j2.pwlArc.pts[v2nexti]; - if( v2 == v2last ) { - return 0; // ill-conditioned, guess answer - } - } - } - } - } - - public int ccwTurn_tl(Arc j1, Arc j2 ) { - int v1i = j1.pwlArc.npts-1; - int v1lasti = 0; - int v2i = 0; - int v2lasti = j2.pwlArc.npts-1; - int v1nexti = v1i-1; - int v2nexti = v2i+1; - TrimVertex v1 = j1.pwlArc.pts[v1i]; - TrimVertex v1last = j1.pwlArc.pts[v1lasti]; - TrimVertex v2 = j2.pwlArc.pts[v2i]; - TrimVertex v2last = j2.pwlArc.pts[v2lasti]; - TrimVertex v1next = j1.pwlArc.pts[v1nexti]; - TrimVertex v2next = j2.pwlArc.pts[v2nexti]; - int sgn; - - assert( v1 != v1last ); - assert( v2 != v2last ); - - // the arcs lie on the line (1 == v1.param[1]) - if( v1.param[1] == v1next.param[1] && v2.param[1] == v2next.param[1] ) - return 0; - - if( v2next.param[1] > v2.param[1] || v1next.param[1] > v1.param[1] ) - throw new NurbsException(28 ); - - if( v1.param[0] < v2.param[0] ) - return 0; - else if( v1.param[0] > v2.param[0] ) - return 1; - - while( true ) { - if( v1next.param[1] > v2next.param[1] ) { - assert( v1.param[1] >= v1next.param[1] ); - assert( v2.param[1] >= v1next.param[1] ); - switch( bbox( v2next, v2, v1next, 0 ) ) { - case -1: - return 0; - case 0: - sgn = ccw( v1next, v2, v2next ); - if( sgn != -1 ) - return sgn; - else { - v1i = v1nexti--; - v1 = j1.pwlArc.pts[v1i]; - v1next = j1.pwlArc.pts[v1nexti]; - if( v1 == v1last ) { - return 0; // ill-conditioned, guess answer - } - } - break; - case 1: - return 1; - } - } else if( v1next.param[1] < v2next.param[1] ) { - switch( bbox( v1next, v1, v2next, 0 ) ) { - case -1: - return 1; - case 0: - sgn = ccw( v1next, v1, v2next ); - if( sgn != -1 ) - return sgn; - else { - v2i = v2nexti++; - v2 = j2.pwlArc.pts[v2i]; - v2next = j2.pwlArc.pts[v2nexti]; - if( v2 == v2last ) { - return 0; // ill-conditioned, guess answer - } - } - break; - case 1: - return 0; - } - } else { - if( v1next.param[0] < v2next.param[0] ) - return 0; - else if( v1next.param[0] > v2next.param[0] ) - return 1; - else { - v2i = v2nexti++; - v2 = j2.pwlArc.pts[v2i]; - v2next = j2.pwlArc.pts[v2nexti]; - if( v2 == v2last ) { - return 0; // ill-conditioned, guess answer - } - } - } - } - } - - public int ccwTurn_tr(Arc j1, Arc j2) { - int v1i = j1.pwlArc.npts-1; - int v1lasti = 0; - int v2i = 0; - int v2lasti = j2.pwlArc.npts-1; - int v1nexti = v1i-1; - int v2nexti = v2i+1; - TrimVertex v1 = j1.pwlArc.pts[v1i]; - TrimVertex v1last = j1.pwlArc.pts[v1lasti]; - TrimVertex v2 = j2.pwlArc.pts[v2i]; - TrimVertex v2last = j2.pwlArc.pts[v2lasti]; - TrimVertex v1next = j1.pwlArc.pts[v1nexti]; - TrimVertex v2next = j2.pwlArc.pts[v2nexti]; - int sgn; - - assert( v1 != v1last ); - assert( v2 != v2last ); - - // the arcs lie on the line (1 == v1.param[1]) - if( v1.param[1] == v1next.param[1] && v2.param[1] == v2next.param[1] ) - return 0; - - if( v2next.param[1] < v2.param[1] || v1next.param[1] < v1.param[1] ) - throw new NurbsException( 28 ); - - if( v1.param[0] < v2.param[0] ) - return 1; - else if( v1.param[0] > v2.param[0] ) - return 0; - - while( 1 ) { - if( v1next.param[1] < v2next.param[1] ) { - assert( v1.param[1] <= v1next.param[1] ); - assert( v2.param[1] <= v1next.param[1] ); - switch( bbox( v2, v2next, v1next, 0 ) ) { - case -1: - return 1; - case 0: - sgn = ccw( v1next, v2, v2next ); - if( sgn != -1 ) { - return sgn; - } else { - v1i = v1nexti--; - v1 = j1.pwlArc.pts[v1i]; - v1next = j1.pwlArc.pts[v1nexti]; - if( v1 == v1last ) { - return 0; // ill-conditioned, guess answer - } - } - break; - case 1: - return 0; - } - } else if( v1next.param[1] > v2next.param[1] ) { - assert( v1.param[1] <= v2next.param[1] ); - assert( v2.param[1] <= v2next.param[1] ); - switch( bbox( v1, v1next, v2next, 0 ) ) { - case -1: - return 0; - case 0: - sgn = ccw( v1next, v1, v2next ); - if( sgn != -1 ) { - return sgn; - } else { - v2i = v2nexti++; - v2 = j2.pwlArc.pts[v2i]; - v2next = j2.pwlArc.pts[v2nexti]; - if( v2 == v2last ) { - return 0; // ill-conditioned, guess answer - } - } - break; - case 1: - return 1; - } - } else { - if( v1next.param[0] < v2next.param[0] ) - return 1; - else if( v1next.param[0] > v2next.param[0] ) - return 0; - else { - v2i = v2nexti++; - v2 = j2.pwlArc.pts[v2i]; - v2next = j2.pwlArc.pts[v2nexti]; - if( v2 == v2last ) { - return 0; // ill-conditioned, guess answer - } - } - } - } - } - - public void set_domain_distance_u_rate(float u_rate) { - domain_distance_u_rate = u_rate; - } - - public void set_domain_distance_v_rate(float v_rate) { - domain_distance_v_rate = v_rate; - } - - public void set_is_domain_distance_sampling(int flag) { - is_domain_distance_sampling = flag; - } - - //---------------------------------------------------------------------- - // Internals only below this point - // - - /** - * Determine which side of a line a jarc lies (for debugging only) - */ - private int arc_classify( Arc jarc, int param, float value ) - { - float tdiff, hdiff; - if( param == 0 ) { - tdiff = jarc.tail()[0] - value; - hdiff = jarc.head()[0] - value; - } else { - tdiff = jarc.tail()[1] - value; - hdiff = jarc.head()[1] - value; - } - - if( tdiff > 0.0 ) { - if( hdiff > 0.0 ) { - return 0x11; - } else if( hdiff == 0.0 ) { - return 0x12; - } else { - return 0x10; - } - } else if( tdiff == 0.0 ) { - if( hdiff > 0.0 ) { - return 0x21; - } else if( hdiff == 0.0 ) { - return 0x22; - } else { - return 0x20; - } - } else { - if( hdiff > 0.0 ) { - return 0x01; - } else if( hdiff == 0.0 ) { - return 0x02; - } else { - return 0; - } - } - } - - private void classify_headonleft_s( Bin bin, Bin in, Bin out, float val ) { - /* tail on line, head at left */ - Arc j; - - while( (j = bin.removearc()) != null ) { - assert( arc_classify( j, 0, val ) == 0x20 ); - - j.setitail(); - - float diff = j.prev.tail()[0] - val; - if( diff > 0.0 ) { - out.addarc( j ); - } else if( diff < 0.0 ) { - if( ccwTurn_sl( j.prev, j ) != 0 ) - out.addarc( j ); - else - in.addarc( j ); - } else { - if( j.prev.tail()[1] > j.prev.head()[1] ) - in.addarc( j ); - else - out.addarc( j ); - } - } - } - - private void classify_tailonleft_s( Bin bin, Bin in, Bin out, float val ) { - /* tail at left, head on line */ - Arc j; - - while( (j = bin.removearc()) != null ) { - assert( arc_classify( j, 1, val ) == 0x02 ); - j.clearitail(); - - float diff = j.next.head()[1] - val; - if( diff > 0.0 ) { - in.addarc( j ); - } else if( diff < 0.0 ) { - if( ccwTurn_tl( j, j.next ) != 0 ) - out.addarc( j ); - else - in.addarc( j ); - } else { - if (j.next.tail()[0] > j.next.head()[0] ) - out.addarc( j ); - else - in.addarc( j ); - } - } - } - - private void classify_headonright_s( Bin bin, Bin in, Bin out, float val ) { - /* tail on line, head at right */ - Arc j; - - while( (j = bin.removearc()) != null ) { - assert( arc_classify( j, 0, val ) == 0x21 ); - - j.setitail(); - - float diff = j.prev.tail()[0] - val; - if( diff > 0.0 ) { - if( ccwTurn_sr( j.prev, j ) != 0 ) - out.addarc( j ); - else - in.addarc( j ); - } else if( diff < 0.0 ) { - out.addarc( j ); - } else { - if( j.prev.tail()[1] > j.prev.head()[1] ) - out.addarc( j ); - else - in.addarc( j ); - } - } - } - - private void classify_tailonright_s( Bin bin, Bin in, Bin out, float val ) { - /* tail at right, head on line */ - Arc j; - - while( (j = bin.removearc()) != null ) { - assert( arc_classify( j, 0, val ) == 0x12); - - j.clearitail(); - - float diff = j.next.head()[0] - val; - if( diff > 0.0 ) { - if( ccwTurn_sr( j, j.next ) != 0 ) - out.addarc( j ); - else - in.addarc( j ); - } else if( diff < 0.0 ) { - in.addarc( j ); - } else { - if( j.next.tail()[1] > j.next.head()[1] ) - out.addarc( j ); - else - in.addarc( j ); - } - } - } - - private void classify_headonleft_t( Bin bin, Bin in, Bin out, float val ) { - /* tail on line, head at left */ - Arc j; - - while( (j = bin.removearc()) != null ) { - assert( arc_classify( j, 1, val ) == 0x20 ); - j.setitail(); - - float diff = j.prev.tail()[1] - val; - if( diff > 0.0 ) { - out.addarc( j ); - } else if( diff < 0.0 ) { - if( ccwTurn_tl( j.prev, j ) != 0 ) - out.addarc( j ); - else - in.addarc( j ); - } else { - if( j.prev.tail()[0] > j.prev.head()[0] ) - out.addarc( j ); - else - in.addarc( j ); - } - } - } - - private void classify_tailonleft_t( Bin bin, Bin in, Bin out, float val ) { - /* tail at left, head on line */ - Arc j; - - while( (j = bin.removearc()) != null ) { - assert( arc_classify( j, 1, val ) == 0x02 ); - j.clearitail(); - - float diff = j.next.head()[1] - val; - if( diff > 0.0 ) { - in.addarc( j ); - } else if( diff < 0.0 ) { - if( ccwTurn_tl( j, j.next ) != 0 ) - out.addarc( j ); - else - in.addarc( j ); - } else { - if (j.next.tail()[0] > j.next.head()[0] ) - out.addarc( j ); - else - in.addarc( j ); - } - } - } - - private void classify_headonright_t( Bin bin, Bin in, Bin out, float val ) { - /* tail on line, head at right */ - Arc j; - - while( (j = bin.removearc()) != null ) { - assert( arc_classify( j, 1, val ) == 0x21 ); - - j.setitail(); - - float diff = j.prev.tail()[1] - val; - if( diff > 0.0 ) { - if( ccwTurn_tr( j.prev, j ) != 0 ) - out.addarc( j ); - else - in.addarc( j ); - } else if( diff < 0.0 ) { - out.addarc( j ); - } else { - if( j.prev.tail()[0] > j.prev.head()[0] ) - in.addarc( j ); - else - out.addarc( j ); - } - } - } - - private void classify_tailonright_t( Bin bin, Bin in, Bin out, float val ) { - /* tail at right, head on line */ - Arc j; - - while( (j = bin.removearc()) != null ) { - assert( arc_classify( j, 1, val ) == 0x12); - - j.clearitail(); - - float diff = j.next.head()[1] - val; - if( diff > 0.0 ) { - if( ccwTurn_tr( j, j.next ) != 0 ) - out.addarc( j ); - else - in.addarc( j ); - } else if( diff < 0.0 ) { - in.addarc( j ); - } else { - if( j.next.tail()[0] > j.next.head()[0] ) - in.addarc( j ); - else - out.addarc( j ); - } - } - } - - private int DIR_DOWN = 0; - private int DIR_SAME = 1; - private int DIR_UP = 2; - private int DIR_NONE = 3; - - private void tessellate( Arc_ptr, float ); - private void monotonize( Arc_ptr , Bin & ); - private int isMonotone( Arc_ptr ); - private int decompose( Bin &, float ); - - - private Slicer slicer; - private ArcTessellator arctessellator; - // private Pool arcpool; - // private Pool bezierarcpool; - // private Pool pwlarcpool; - // private TrimVertexPool trimvertexpool; - - private JumpBuffer* jumpbuffer; - private Renderhints& renderhints; - private Backend& backend; - - private Bin initialbin; - private Arc pjarc; - private int s_index; - private int t_index; - private Quilt *qlist; - private Flist spbrkpts; - private Flist tpbrkpts; - private Flist smbrkpts; - private Flist tmbrkpts; - private float stepsizes[4]; - private int showDegenerate; - private int isArcTypeBezier; - - // FIXME: NOT FINISHED - private void samplingSplit( Curvelist&, int ); - - private void subdivideInS( Bin source ) { - if( renderhints.display_method == N_OUTLINE_PARAM ) { - outline( source ); - freejarcs( source ); - } else { - setArcTypeBezier(); - setNonDegenerate(); - splitInS( source, spbrkpts.start, spbrkpts.end ); - } - } - - /** - * Splits a patch and a bin by an isoparametric line. - */ - private void splitInS( Bin source, int start, int end ) { - if( source.isnonempty() ) { - if( start != end ) { - int i = start + (end - start) / 2; - Bin left = new Bin(); - Bin right = new Bin(); - split( source, left, right, 0, spbrkpts.pts[i] ); - splitInS( left, start, i ); - splitInS( right, i+1, end ); - } else { - if( start == spbrkpts.start || start == spbrkpts.end ) { - freejarcs( source ); - } else if( renderhints.display_method == NurbsConsts.N_OUTLINE_PARAM_S ) { - outline( source ); - freejarcs( source ); - } else { - setArcTypeBezier(); - setNonDegenerate(); - s_index = start; - splitInT( source, tpbrkpts.start, tpbrkpts.end ); - } - } - } - } - - /** - * Splits a patch and a bin by an isoparametric line. - */ - private void splitInT( Bin source, int start, int end ) { - if( source.isnonempty() ) { - if( start != end ) { - int i = start + (end - start) / 2; - Bin left = new Bin(); - Bin right = new Bin(); - split( source, left, right, 1, tpbrkpts.pts[i] ); - splitInT( left, start, i ); - splitInT( right, i+1, end ); - } else { - if( start == tpbrkpts.start || start == tpbrkpts.end ) { - freejarcs( source ); - } else if( renderhints.display_method == NurbsConsts.N_OUTLINE_PARAM_ST ) { - outline( source ); - freejarcs( source ); - } else { - t_index = start; - setArcTypeBezier(); - setDegenerate(); - - float[] pta = new float[2]; - float[] ptb = new float[2]; - pta[0] = spbrkpts.pts[s_index-1]; - pta[1] = tpbrkpts.pts[t_index-1]; - - ptb[0] = spbrkpts.pts[s_index]; - ptb[1] = tpbrkpts.pts[t_index]; - qlist.downloadAll( pta, ptb, backend ); - - Patchlist patchlist = new Patchlist( qlist, pta, ptb ); - /* - printf("-------samplingSplit-----\n"); - source.show("samplingSplit source"); - */ - samplingSplit( source, patchlist, renderhints.maxsubdivisions, 0 ); - setNonDegenerate(); - setArcTypeBezier(); - } - } - } - } - - /** - * Recursively subdivides patch, cull checks each subpatch - */ - private void samplingSplit( Bin source, Patchlist patchlist, int subdivisions, int param ) { - if( ! source.isnonempty() ) return; - - if( patchlist.cullCheck() == Defines.CULL_TRIVIAL_REJECT ) { - freejarcs( source ); - return; - } - - patchlist.getstepsize(); - - if( renderhints.display_method == NurbsConsts.N_OUTLINE_PATCH ) { - tessellation( source, patchlist ); - outline( source ); - freejarcs( source ); - return; - } - - //patchlist.clamp(); - - tessellation( source, patchlist ); - - if( patchlist.needsSamplingSubdivision() && (subdivisions > 0) ) { - if( ! patchlist.needsSubdivision( 0 ) ) - param = 1; - else if( ! patchlist.needsSubdivision( 1 ) ) - param = 0; - else - param = 1 - param; - - Bin left = new Bin(); - Bin right = new Bin(); - float mid = ( patchlist.pspec[param].range[0] + - patchlist.pspec[param].range[1] ) * 0.5; - split( source, left, right, param, mid ); - Patchlist subpatchlist = new Patchlist( patchlist, param, mid ); - samplingSplit( left, subpatchlist, subdivisions-1, param ); - samplingSplit( right, patchlist, subdivisions-1, param ); - } else { - setArcTypePwl(); - setDegenerate(); - nonSamplingSplit( source, patchlist, subdivisions, param ); - setDegenerate(); - setArcTypeBezier(); - } - } - - private void nonSamplingSplit( Bin source, Patchlist patchlist, int subdivisions, int param ) { - if( patchlist.needsNonSamplingSubdivision() && (subdivisions > 0) ) { - param = 1 - param; - - Bin left = new Bin(); - Bin right = new Bin(); - float mid = ( patchlist.pspec[param].range[0] + - patchlist.pspec[param].range[1] ) * 0.5; - split( source, left, right, param, mid ); - Patchlist subpatchlist = new Patchlist( patchlist, param, mid ); - if( left.isnonempty() ) - if( subpatchlist.cullCheck() == Defines.CULL_TRIVIAL_REJECT ) - freejarcs( left ); - else - nonSamplingSplit( left, subpatchlist, subdivisions-1, param ); - if( right.isnonempty() ) - if( patchlist.cullCheck() == Defines.CULL_TRIVIAL_REJECT ) - freejarcs( right ); - else - nonSamplingSplit( right, patchlist, subdivisions-1, param ); - - } else { - // make bbox calls - patchlist.bbox(); - backend.patch( patchlist.pspec[0].range[0], patchlist.pspec[0].range[1], - patchlist.pspec[1].range[0], patchlist.pspec[1].range[1] ); - - if( renderhints.display_method == NurbsConsts.N_OUTLINE_SUBDIV ) { - outline( source ); - freejarcs( source ); - } else { - setArcTypePwl(); - setDegenerate(); - findIrregularS( source ); - monosplitInS( source, smbrkpts.start, smbrkpts.end ); - } - } - } - - /** - * Sets tessellation of interior and boundary of patch. - */ - private void tessellation( Bin bin, Patchlist patchlist ) { - // tessellate unsampled trim curves - tessellate( bin, patchlist.pspec[1].sidestep[1], patchlist.pspec[0].sidestep[1], - patchlist.pspec[1].sidestep[0], patchlist.pspec[0].sidestep[0] ); - - // set interior sampling rates - slicer.setstriptessellation( patchlist.pspec[0].stepsize, patchlist.pspec[1].stepsize ); - - //added by zl: set the order which will be used in slicer.c++ - slicer.set_ulinear( (patchlist.get_uorder() == 2)); - slicer.set_vlinear( (patchlist.get_vorder() == 2)); - - // set boundary sampling rates - stepsizes[0] = patchlist.pspec[1].stepsize; - stepsizes[1] = patchlist.pspec[0].stepsize; - stepsizes[2] = patchlist.pspec[1].stepsize; - stepsizes[3] = patchlist.pspec[0].stepsize; - } - - /** - * Splits a patch and a bin by an isoparametric line. - */ - private void monosplitInS( Bin source, int start, int end ) { - if( source.isnonempty() ) { - if( start != end ) { - int i = start + (end - start) / 2; - Bin left = new Bin(); - Bin right = new Bin(); - split( source, left, right, 0, smbrkpts.pts[i] ); - monosplitInS( left, start, i ); - monosplitInS( right, i+1, end ); - } else { - if( renderhints.display_method == NurbsConsts.N_OUTLINE_SUBDIV_S ) { - outline( source ); - freejarcs( source ); - } else { - setArcTypePwl(); - setDegenerate(); - findIrregularT( source ); - monosplitInT( source, tmbrkpts.start, tmbrkpts.end ); - } - } - } - } - - /** - * Splits a patch and a bin by an isoparametric line. - */ - private void monosplitInT( Bin source, int start, int end ) { - if( source.isnonempty() ) { - if( start != end ) { - int i = start + (end - start) / 2; - Bin left = new Bin(); - Bin right = new Bin(); - split( source, left, right, 1, tmbrkpts.pts[i] ); - monosplitInT( left, start, i ); - monosplitInT( right, i+1, end ); - } else { - if( renderhints.display_method == NurbsConsts.N_OUTLINE_SUBDIV_ST ) { - outline( source ); - freejarcs( source ); - } else { - /* - printf("*******render\n"); - source.show("source\n"); - */ - render( source ); - freejarcs( source ); - } - } - } - } - - /** - * Renders the trimmed patch by outlining the boundary . - */ - private void outline( Bin bin ) { - bin.markall(); - for( Arc jarc=bin.firstarc(); jarc != null; jarc=bin.nextarc() ) { - if( jarc.ismarked() ) { - assert( jarc.check( ) ); - Arc jarchead = jarc; - do { - slicer.outline( jarc ); - jarc.clearmark(); - jarc = jarc.prev; - } while (jarc != jarchead); - } - } - } - - /** - * Frees all arcs in a bin. - */ - private void freejarcs( Bin & ) { - bin.adopt(); /* XXX - should not be necessary */ - - Arc jarc; - while( (jarc = bin.removearc()) != null ) { - if( jarc.pwlArc != null ) jarc.pwlArc.deleteMe( ); jarc.pwlArc = null; - if( jarc.bezierArc != null) jarc.bezierArc.deleteMe( ); jarc.bezierArc = null; - jarc.deleteMe( ); - } - } - - /** - * Renders all monotone regions in a bin and frees the bin. - */ - private void render( Bin bin ) { - bin.markall(); - - slicer.setisolines( ( renderhints.display_method == N_ISOLINE_S ) ? 1 : 0 ); - - for( Arc jarc=bin.firstarc(); jarc != null; jarc=bin.nextarc() ) { - if( jarc.ismarked() ) { - assert( jarc.check( ) != 0 ); - Arc jarchead = jarc; - do { - jarc.clearmark(); - jarc = jarc.next; - } while (jarc != jarchead); - slicer.slice( jarc ); - } - } - } - - private void split( Bin &, Bin &, Bin &, int, float ); - - /** - * Tessellates all Bezier arcs in a bin. - * <ol> - * <li> only accepts linear Bezier arcs as input - * <li> the Bezier arcs are stored in the pwlArc structure - * <li> only vertical or horizontal lines work - * </ol> - * should: - * <ol> - * <li> represent Bezier arcs in BezierArc structure - * (this requires a multitude of changes to the code) - * <li> accept high degree Bezier arcs (hard) - * <il> map the curve onto the surface to determine tessellation - * <li> work for curves of arbitrary geometry - * </ol> - *---------------------------------------------------------------------------- - */ - private void tessellate( Bin bin, float rrate, float trate, float lrate, float brate ) { - for( Arc jarc=bin.firstarc(); jarc != null; jarc=bin.nextarc() ) { - if( jarc.isbezier( ) ) { - assert( jarc.pwlArc.npts == 2 ); - TrimVertex[] pts = jarc.pwlArc.pts; - float s1 = pts[0].param[0]; - float t1 = pts[0].param[1]; - float s2 = pts[1].param[0]; - float t2 = pts[1].param[1]; - - jarc.pwlArc.deleteMe( ); - jarc.pwlArc = null; - - switch( jarc.getside() ) { - case Arc.SIDE_LEFT: - assert( s1 == s2 ); - arctessellator.pwl_left( jarc, s1, t1, t2, lrate ); - break; - case Arc.SIDE_RIGHT: - assert( s1 == s2 ); - arctessellator.pwl_right( jarc, s1, t1, t2, rrate ); - break; - case Arc.SIDE_TOP: - assert( t1 == t2 ); - arctessellator.pwl_top( jarc, t1, s1, s2, trate ); - break; - case Arc.SIDE_BOTTOM: - assert( t1 == t2 ); - arctessellator.pwl_bottom( jarc, t1, s1, s2, brate ); - break; - case Arc.SIDE_NONE: - throw new InternalError("Incorrect tesselation state"); - break; - } - assert( ! jarc.isbezier() ); - assert( jarc.check() != 0 ); - } - } - } - - private inline void setDegenerate( void ) { showDegenerate = 1; } - private inline void setNonDegenerate( void ) { showDegenerate = 0; } - private inline int showingDegenerate( void ) { return showDegenerate; } - private inline void setArcTypeBezier( void ) { isArcTypeBezier = 1; } - private inline void setArcTypePwl( void ) { isArcTypeBezier = 0; } - private inline int isBezierArcType( void ) { return isArcTypeBezier; } - - /** - * If no user input trimming data, then create a trimming curve - * around the boundaries of the Quilt. The curve consists of four - * Jordan arcs, one for each side of the Quilt, connected, of - * course, head to tail. - */ - private void makeBorderTrim( float[] from, float[] to ) { - float smin = from[0]; - float smax = to[0]; - float tmin = from[1]; - float tmax = to[1]; - - pjarc = null; - - Arc jarc = new Arc( Arc.SIDE_BOTTOM, 0 ); - arctessellator.bezier( jarc, smin, smax, tmin, tmin ); - initialbin.addarc( jarc ); - pjarc = jarc.append( pjarc ); - - jarc = new Arc( Arc.SIDE_RIGHT, 0 ); - arctessellator.bezier( jarc, smax, smax, tmin, tmax ); - initialbin.addarc( jarc ); - pjarc = jarc.append( pjarc ); - - jarc = new Arc( Arc.SIDE_TOP, 0 ); - arctessellator.bezier( jarc, smax, smin, tmax, tmax ); - initialbin.addarc( jarc ); - pjarc = jarc.append( pjarc ); - - jarc = new Arc( Arc.SIDE_LEFT, 0 ); - arctessellator.bezier( jarc, smin, smin, tmax, tmin ); - initialbin.addarc( jarc ); - jarc.append( pjarc ); - - assert( jarc.check() ); - } - - private void split( Bin &, int, const float *, int, int ); - private void partition( Bin bin, Bin left, Bin intersections, Bin right, Bin unknown, int param, float value ) { - Bin headonleft = new Bin(); - Bin headonright = new Bin(); - Bin tailonleft = new Bin(); - Bin tailonright = new Bin(); - - for( Arc jarc = bin.removearc(); jarc != null; jarc = bin.removearc() ) { - - float tdiff = jarc.tail()[param] - value; - float hdiff = jarc.head()[param] - value; - - if( tdiff > 0.0 ) { - if( hdiff > 0.0 ) { - right.addarc( jarc ); - } else if( hdiff == 0.0 ) { - tailonright.addarc( jarc ); - } else { - Arc jtemp; - switch( arc_split(jarc, param, value, 0) ) { - case 2: - tailonright.addarc( jarc ); - headonleft.addarc( jarc.next ); - break; - case 31: - assert( jarc.head()[param] > value ); - right.addarc( jarc ); - tailonright.addarc( jtemp = jarc.next ); - headonleft.addarc( jtemp.next ); - break; - case 32: - assert( jarc.head()[param] <= value ); - tailonright .addarc( jarc ); - headonleft.addarc( jtemp = jarc.next ); - left.addarc( jtemp.next ); - break; - case 4: - right.addarc( jarc ); - tailonright.addarc( jtemp = jarc.next ); - headonleft.addarc( jtemp = jtemp.next ); - left.addarc( jtemp.next ); - } - } - } else if( tdiff == 0.0 ) { - if( hdiff > 0.0 ) { - headonright.addarc( jarc ); - } else if( hdiff == 0.0 ) { - unknown.addarc( jarc ); - } else { - headonleft.addarc( jarc ); - } - } else { - if( hdiff > 0.0 ) { - Arc jtemp; - switch( arc_split(jarc, param, value, 1) ) { - case 2: - tailonleft.addarc( jarc ); - headonright.addarc( jarc.next ); - break; - case 31: - assert( jarc.head()[param] < value ); - left.addarc( jarc ); - tailonleft.addarc( jtemp = jarc.next ); - headonright.addarc( jtemp.next ); - break; - case 32: - assert( jarc.head()[param] >= value ); - tailonleft.addarc( jarc ); - headonright.addarc( jtemp = jarc.next ); - right.addarc( jtemp.next ); - break; - case 4: - left.addarc( jarc ); - tailonleft.addarc( jtemp = jarc.next ); - headonright.addarc( jtemp = jtemp.next ); - right.addarc( jtemp.next ); - } - } else if( hdiff == 0.0 ) { - tailonleft.addarc( jarc ); - } else { - left.addarc( jarc ); - } - } - } - if( param == 0 ) { - classify_headonleft_s( headonleft, intersections, left, value ); - classify_tailonleft_s( tailonleft, intersections, left, value ); - classify_headonright_s( headonright, intersections, right, value ); - classify_tailonright_s( tailonright, intersections, right, value ); - } else { - classify_headonleft_t( headonleft, intersections, left, value ); - classify_tailonleft_t( tailonleft, intersections, left, value ); - classify_headonright_t( headonright, intersections, right, value ); - classify_tailonright_t( tailonright, intersections, right, value ); - } - } - - /** - * Determine points of non-monotonicity in s direction. - */ - private void findIrregularS( Bin bin ) { - assert( bin.firstarc() == null || bin.firstarc().check() ); - - smbrkpts.grow( bin.numarcs() ); - - for( Arc jarc=bin.firstarc(); jarc != null; jarc=bin.nextarc() ) { - float[] a = jarc.prev.tail(); - float[] b = jarc.tail(); - float[] c = jarc.head(); - - if( b[1] == a[1] && b[1] == c[1] ) continue; - - //corrected code - if((b[1]<=a[1] && b[1] <= c[1]) || - (b[1]>=a[1] && b[1] >= c[1])) - { - //each arc (jarc, jarc.prev, jarc.next) is a - //monotone arc consisting of multiple line segements. - //it may happen that jarc.prev and jarc.next are the same, - //that is, jarc.prev and jarc form a closed loop. - //In such case, a and c will be the same. - if(a[0]==c[0] && a[1] == c[1]) - { - if(jarc.pwlArc.npts >2) - { - c = jarc.pwlArc.pts[jarc.pwlArc.npts-2].param; - } - else - { - assert(jarc.prev.pwlArc.npts>2); - a = jarc.prev.pwlArc.pts[jarc.prev.pwlArc.npts-2].param; - } - - } - if(area(a,b,c) < 0) - { - smbrkpts.add(b[0]); - } - - } - - /* old code, - if( b[1] <= a[1] && b[1] <= c[1] ) { - if( ! ccwTurn_tr( jarc.prev, jarc ) ) - smbrkpts.add( b[0] ); - } else if( b[1] >= a[1] && b[1] >= c[1] ) { - if( ! ccwTurn_tl( jarc.prev, jarc ) ) - smbrkpts.add( b[0] ); - } - */ - - } - - smbrkpts.filter(); - } - - /** - * Determines points of non-monotonicity in t direction where one - * arc is parallel to the s axis. - */ - private void findIrregularT( Bin bin ) { - assert( bin.firstarc() == null || bin.firstarc().check() ); - - tmbrkpts.grow( bin.numarcs() ); - - for( Arc jarc=bin.firstarc(); jarc != null; jarc=bin.nextarc() ) { - float[] a = jarc.prev.tail(); - float[] b = jarc.tail(); - float[] c = jarc.head(); - - if( b[0] == a[0] && b[0] == c[0] ) continue; - - if( b[0] <= a[0] && b[0] <= c[0] ) { - if( a[1] != b[1] && b[1] != c[1] ) continue; - if( ccwTurn_sr( jarc.prev, jarc ) == 0) - tmbrkpts.add( b[1] ); - } else if ( b[0] >= a[0] && b[0] >= c[0] ) { - if( a[1] != b[1] && b[1] != c[1] ) continue; - if( ccwTurn_sl( jarc.prev, jarc ) == 0) - tmbrkpts.add( b[1] ); - } - } - tmbrkpts.filter( ); - } - - - private int bbox( TrimVertex a, TrimVertex b, TrimVertex c, int p ) { - return bbox( a.param[p], b.param[p], c.param[p], - a.param[1-p], b.param[1-p], c.param[1-p] ); - } - - private static int bbox( float sa, float sb, float sc, float ta, float tb, float tc ) { - assert( tc >= ta ); - assert( tc <= tb ); - - if( sa < sb ) { - if( sc <= sa ) { - return -1; - } else if( sb <= sc ) { - return 1; - } else { - return 0; - } - } else if( sa > sb ) { - if( sc >= sa ) { - return 1; - } else if( sb >= sc ) { - return -1; - } else { - return 0; - } - } else { - if( sc > sa ) { - return 1; - } else if( sb > sc ) { - return -1; - } else { - return 0; - } - } - } - /** - * Determines how three points are oriented by computing their - * determinant. - * - * @return 1 if the vertices are ccw oriented, 0 if they are cw - * oriented, or -1 if the computation is ill-conditioned. - */ - private static int ccw( TrimVertex a, TrimVertex b, TrimVertex c ) { - float d = TrimVertex.det3( a, b, c ); - if( Math.abs(d) < 0.0001 ) return -1; - return (d < 0.0) ? 0 : 1; - } - private void join_s( Bin &, Bin &, Arc_ptr, Arc_ptr ); - private void join_t( Bin &, Bin &, Arc_ptr , Arc_ptr ); - - private static void vert_interp( TrimVertex n, TrimVertex l, TrimVertex r, int p, float val ) { - assert( val > l.param[p]); - assert( val < r.param[p]); - - n.nuid = l.nuid; - - n.param[p] = val; - if( l.param[1-p] != r.param[1-p] ) { - float ratio = (val - l.param[p]) / (r.param[p] - l.param[p]); - n.param[1-p] = l.param[1-p] + - ratio * (r.param[1-p] - l.param[1-p]); - } else { - n.param[1-p] = l.param[1-p]; - } - } - - private static final int INTERSECT_VERTEX = 1; - private static final int INTERSECT_EDGE = 2; - - /** - * Finds intersection of pwlArc and isoparametric line. - */ - private static int pwlarc_intersect( PwlArc pwlArc, int param, float value, int dir, int[] loc ) { - assert( pwlArc.npts > 0 ); - - if( dir != 0 ) { - TrimVertex[] v = pwlArc.pts; - int imin = 0; - int imax = pwlArc.npts - 1; - assert( value > v[imin].param[param] ); - assert( value < v[imax].param[param] ); - while( (imax - imin) > 1 ) { - int imid = (imax + imin)/2; - if( v[imid].param[param] > value ) - imax = imid; - else if( v[imid].param[param] < value ) - imin = imid; - else { - loc[1] = imid; - return INTERSECT_VERTEX; - } - } - loc[0] = imin; - loc[2] = imax; - return INTERSECT_EDGE; - } else { - TrimVertex[] v = pwlArc.pts; - int imax = 0; - int imin = pwlArc.npts - 1; - assert( value > v[imin].param[param] ); - assert( value < v[imax].param[param] ); - while( (imin - imax) > 1 ) { - int imid = (imax + imin)/2; - if( v[imid].param[param] > value ) - imax = imid; - else if( v[imid].param[param] < value ) - imin = imid; - else { - loc[1] = imid; - return INTERSECT_VERTEX; - } - } - loc[0] = imin; - loc[2] = imax; - return INTERSECT_EDGE; - } - } - - private int arc_split( Arc jarc , int param, float value, int dir ) { - int maxvertex = jarc.pwlArc.npts; - Arc jarc1, jarc2, jarc3; - TrimVertex v = jarc.pwlArc.pts; - - int[] loc = new int[3]; - switch( pwlarc_intersect( jarc.pwlArc, param, value, dir, loc ) ) { - - // When the parameter value lands on a vertex, life is sweet - case INTERSECT_VERTEX: { - jarc1 = new Arc( jarc, new PwlArc( maxvertex-loc[1], /* &v[loc[1]] */ v, loc[1] ) ); - jarc.pwlArc.npts = loc[1] + 1; - jarc1.next = jarc.next; - jarc1.next.prev = jarc1; - jarc.next = jarc1; - jarc1.prev = jarc; - assert(jarc.check()); - return 2; - } - - // When the parameter value intersects an edge, we have to - // interpolate a new vertex. There are special cases - // if the new vertex is adjacent to one or both of the - // endpoints of the arc. - case INTERSECT_EDGE: { - int i, j; - if( dir == 0 ) { - i = loc[0]; - j = loc[2]; - } else { - i = loc[2]; - j = loc[0]; - } - - // The split is between vertices at index j and i, in that - // order (j < i) - - // JEB: This code is my idea of how to do the split without - // increasing the number of links. I'm doing this so that - // the is_rect routine can recognize rectangles created by - // subdivision. In exchange for simplifying the curve list, - // however, it costs in allocated space and vertex copies. - - TrimVertex[] newjunk = TrimVertex.allocate(maxvertex -i+1 /*-j*/); - int k; - for(k=0; k<maxvertex-i; k++) - { - newjunk[k+1] = v[i+k]; - newjunk[k+1].nuid = jarc.nuid; - } - - TrimVertex[] vcopy = TrimVertex.allocate(maxvertex); - for(k=0; k<maxvertex; k++) - { - vcopy[k].param[0] = v[k].param[0]; - vcopy[k].param[1] = v[k].param[1]; - } - jarc.pwlArc.pts=vcopy; - - v[i].nuid = jarc.nuid; - v[j].nuid = jarc.nuid; - vert_interp( newjunk[0], v[loc[0]], v[loc[2]], param, value ); - - if( showingDegenerate() ) - backend.triangle( v[i], newjunk[0], v[j] ); - - vcopy[j+1].param[0]=newjunk[0].param[0]; - vcopy[j+1].param[1]=newjunk[0].param[1]; - - - jarc1 = new Arc( jarc, - new PwlArc(maxvertex-i+1 , newjunk ) ); - - jarc.pwlArc.npts = j+2; - jarc1.next = jarc.next; - jarc1.next.prev = jarc1; - jarc.next = jarc1; - jarc1.prev = jarc; - assert(jarc.check()); - - return 2; - - /*** - // JEB: This is the original version: - - TrimVertex[] newjunk = TrimVertex.allocate(3); - v[i].nuid = jarc.nuid; - v[j].nuid = jarc.nuid; - newjunk[0] = v[j]; - newjunk[2] = v[i]; - vert_interp( &newjunk[1], &v[loc[0]], &v[loc[2]], param, value ); - - if( showingDegenerate() ) - backend.triangle( &newjunk[2], &newjunk[1], &newjunk[0] ); - - // New vertex adjacent to both endpoints - if (maxvertex == 2) { - jarc1 = new(arcpool) Arc( jarc, new(pwlarcpool) PwlArc( 2, newjunk+1 ) ); - jarc.pwlArc.npts = 2; - jarc.pwlArc.pts = newjunk; - jarc1.next = jarc.next; - jarc1.next.prev = jarc1; - jarc.next = jarc1; - jarc1.prev = jarc; - assert(jarc.check() != 0); - - return 2; - - // New vertex adjacent to ending point of arc - } else if (maxvertex - j == 2) { - jarc1 = new(arcpool) Arc( jarc, new(pwlarcpool) PwlArc( 2, newjunk ) ); - jarc2 = new(arcpool) Arc( jarc, new(pwlarcpool) PwlArc( 2, newjunk+1 ) ); - jarc.pwlArc.npts = maxvertex-1; - jarc2.next = jarc.next; - jarc2.next.prev = jarc2; - jarc.next = jarc1; - jarc1.prev = jarc; - jarc1.next = jarc2; - jarc2.prev = jarc1; - assert(jarc.check() != 0); - return 31; - - // New vertex adjacent to starting point of arc - } else if (i == 1) { - jarc1 = new(arcpool) Arc( jarc, new(pwlarcpool) PwlArc( 2, newjunk+1 ) ); - jarc2 = new(arcpool) Arc( jarc, - new(pwlarcpool) PwlArc( maxvertex-1, &jarc.pwlArc.pts[1] ) ); - jarc.pwlArc.npts = 2; - jarc.pwlArc.pts = newjunk; - jarc2.next = jarc.next; - jarc2.next.prev = jarc2; - jarc.next = jarc1; - jarc1.prev = jarc; - jarc1.next = jarc2; - jarc2.prev = jarc1; - assert(jarc.check() != 0); - return 32; - - // It's somewhere in the middle - } else { - jarc1 = new(arcpool) Arc( jarc, new(pwlarcpool) PwlArc( 2, newjunk ) ); - jarc2 = new(arcpool) Arc( jarc, new(pwlarcpool) PwlArc( 2, newjunk+1 ) ); - jarc3 = new(arcpool) Arc( jarc, new(pwlarcpool) PwlArc( maxvertex-i, v+i ) ); - jarc.pwlArc.npts = j + 1; - jarc3.next = jarc.next; - jarc3.next.prev = jarc3; - jarc.next = jarc1; - jarc1.prev = jarc; - jarc1.next = jarc2; - jarc2.prev = jarc1; - jarc2.next = jarc3; - jarc3.prev = jarc2; - assert(jarc.check() != 0); - return 4; - } - ***/ - } - default: - return -1; //picked -1 since it's not used - } - } - - private void check_s( Arc_ptr , Arc_ptr ); - private void check_t( Arc_ptr , Arc_ptr ); - private inline void link( Arc_ptr , Arc_ptr , Arc_ptr , Arc_ptr ); - private inline void simple_link( Arc_ptr , Arc_ptr ); - - private Bin makePatchBoundary( const float[] from, const float[] to ) { - Bin ret = new Bin(); - float smin = from[0]; - float smax = to[0]; - float tmin = from[1]; - float tmax = to[1]; - - pjarc = 0; - - Arc jarc = new Arc( arc_bottom, 0 ); - arctessellator.bezier( jarc, smin, smax, tmin, tmin ); - ret.addarc( jarc ); - pjarc = jarc.append( pjarc ); - - jarc = new(arcpool) Arc( arc_right, 0 ); - arctessellator.bezier( jarc, smax, smax, tmin, tmax ); - ret.addarc( jarc ); - pjarc = jarc.append( pjarc ); - - jarc = new(arcpool) Arc( arc_top, 0 ); - arctessellator.bezier( jarc, smax, smin, tmax, tmax ); - ret.addarc( jarc ); - pjarc = jarc.append( pjarc ); - - jarc = new(arcpool) Arc( arc_left, 0 ); - arctessellator.bezier( jarc, smin, smin, tmax, tmin ); - ret.addarc( jarc ); - jarc.append( pjarc ); - - assert( jarc.check() != 0 ); - return ret; - } - - /*in domain distance method, the tessellation is controled by two numbers: - *GLU_U_STEP: number of u-segments per unit u length of domain - *GLU_V_STEP: number of v-segments per unit v length of domain - *These two numbers are normally stored in mapdesc.maxs(t)rate. - *I (ZL) put these two numbers here so that I can optimize the untrimmed - *case in the case of domain distance sampling. - *These two numbers are set by set_domain_distance_u_rate() and ..._v_..(). - */ - private float domain_distance_u_rate; - private float domain_distance_v_rate; - private int is_domain_distance_sampling; - -} |