package jogamp.opengl.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.
*/
/**
* Class holding properties of OpenGL map
* @author Tomas Hrasky
*
*/
public 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 final int type;
/**
* Number of homogenous coords
*/
private final int hcoords;
/**
* Number of inhomogenous coords
*/
private final int inhcoords;
/**
* Not used
*/
private final 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 final float[][] bmat;
/**
* Sampling matrix
*/
private final float[][] smat;
/**
* Not used
*/
private final float[][] cmat;
/**
* Not used
*/
private final float[] bboxsize;
/**
* Makes new mapdesc
* @param type map type
* @param rational is rational
* @param ncoords number of control points coords
*/
public Mapdesc(final int type, final int rational, final int ncoords) {
// 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(final 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(final 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(final 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(final 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(final CArrayOfFloats pts, final int order, final int stride,
final float[] sp, final 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(final float[][] mat, final CArrayOfFloats pts, final int order,
final int stride, final float[] cp, final int outstride) {
// TODO Auto-generated method stub
// System.out.println("TODO mapdsc.xformmat ; change cp from float[] to carrayoffloats");
if (isrational > 0) {
} else {
}
}
}