From 4cda4b70dbcd21cf57e1e253ddba32b88bcaec18 Mon Sep 17 00:00:00 2001
From: Sven Gothel <sgothel@jausoft.com>
Date: Tue, 8 Feb 2011 06:20:35 +0100
Subject: Move implementation private files from com.jogamp.<module>.impl. to
jogamp.<module> (1/2) - rename task
- com.jogamp.opengl.impl -> jogamp.opengl
- com.jogamp.opengl.util.glsl.fixedfunc.impl -> jogamp.opengl.util.glsl.fixedfunc
- com.jogamp.nativewindow.impl -> jogamp.nativewindow
- com.jogamp.newt.impl -> jogamp.newt
This sorts implementation details from the top level, ie skipping the public 'com',
allowing a better seperation of public classes and implementation details
and also reduces strings.
This approach of public/private seperation is also used in the OpenJDK.
---
.../jogamp/opengl/glu/nurbs/Splinespec.java | 204 +++++++++++++++++++++
1 file changed, 204 insertions(+)
create mode 100644 src/jogl/classes/jogamp/opengl/glu/nurbs/Splinespec.java
(limited to 'src/jogl/classes/jogamp/opengl/glu/nurbs/Splinespec.java')
diff --git a/src/jogl/classes/jogamp/opengl/glu/nurbs/Splinespec.java b/src/jogl/classes/jogamp/opengl/glu/nurbs/Splinespec.java
new file mode 100644
index 000000000..487b47f2d
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/glu/nurbs/Splinespec.java
@@ -0,0 +1,204 @@
+package com.jogamp.opengl.impl.glu.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 2.0 (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
+ *
+ */
+public 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;
+ }
+
+ }
+}
--
cgit v1.2.3