Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
jogamp.opengl.glu.nurbs.Subdivider Maven / Gradle / Ivy
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 working with curves and surfaces
* @author Tomas Hrasky
*
*/
public 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(Backend backend) {
// DONE
qlist = null;
renderhints = new Renderhints();
this.backend = 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;
}
}
