326 lines
13 KiB
Plaintext
326 lines
13 KiB
Plaintext
// Filename: eggNurbsSurface.I
|
|
// Created by: drose (15Feb00)
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
//
|
|
// PANDA 3D SOFTWARE
|
|
// Copyright (c) Carnegie Mellon University. All rights reserved.
|
|
//
|
|
// All use of this software is subject to the terms of the revised BSD
|
|
// license. You should have received a copy of this license along
|
|
// with this source code in a file named "LICENSE."
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::Constructor
|
|
// Access: Public
|
|
// Description:
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE EggNurbsSurface::
|
|
EggNurbsSurface(const string &name) : EggSurface(name) {
|
|
_u_order = 0;
|
|
_v_order = 0;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::Copy constructor
|
|
// Access: Public
|
|
// Description:
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE EggNurbsSurface::
|
|
EggNurbsSurface(const EggNurbsSurface ©) :
|
|
EggSurface(copy),
|
|
_u_knots(copy._u_knots),
|
|
_v_knots(copy._v_knots),
|
|
_u_order(copy._u_order),
|
|
_v_order(copy._v_order)
|
|
{
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::Copy assignment operator
|
|
// Access: Public
|
|
// Description:
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE EggNurbsSurface &EggNurbsSurface::
|
|
operator = (const EggNurbsSurface ©) {
|
|
EggSurface::operator = (copy);
|
|
_u_knots = copy._u_knots;
|
|
_v_knots = copy._v_knots;
|
|
_u_order = copy._u_order;
|
|
_v_order = copy._v_order;
|
|
return *this;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::set_u_order
|
|
// Access: Public
|
|
// Description: Directly changes the order in the U direction to the
|
|
// indicated value (which must be an integer in the
|
|
// range 1 <= u_order <= 4). If possible, it is
|
|
// preferable to use the setup() method instead of this
|
|
// method, since changing the order directly may result
|
|
// in an invalid surface.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void EggNurbsSurface::
|
|
set_u_order(int u_order) {
|
|
nassertv(u_order >= 1 && u_order <= 4);
|
|
_u_order = u_order;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::set_v_order
|
|
// Access: Public
|
|
// Description: Directly changes the order in the V direction to the
|
|
// indicated value (which must be an integer in the
|
|
// range 1 <= v_order <= 4). If possible, it is
|
|
// preferable to use the setup() method instead of this
|
|
// method, since changing the order directly may result
|
|
// in an invalid surface.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void EggNurbsSurface::
|
|
set_v_order(int v_order) {
|
|
nassertv(v_order >= 1 && v_order <= 4);
|
|
_v_order = v_order;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::set_u_knot
|
|
// Access: Public
|
|
// Description: Resets the value of the indicated knot as indicated.
|
|
// k must be in the range 0 <= k < get_num_u_knots(),
|
|
// and the value must be in the range get_u_knot(k - 1)
|
|
// <= value <= get_u_knot(k + 1).
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void EggNurbsSurface::
|
|
set_u_knot(int k, double value) {
|
|
nassertv(k >= 0 && k < (int)_u_knots.size());
|
|
_u_knots[k] = value;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::set_v_knot
|
|
// Access: Public
|
|
// Description: Resets the value of the indicated knot as indicated.
|
|
// k must be in the range 0 <= k < get_num_v_knots(),
|
|
// and the value must be in the range get_v_knot(k - 1)
|
|
// <= value <= get_v_knot(k + 1).
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void EggNurbsSurface::
|
|
set_v_knot(int k, double value) {
|
|
nassertv(k >= 0 && k < (int)_v_knots.size());
|
|
_v_knots[k] = value;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::set_cv
|
|
// Access: Public
|
|
// Description: Redefines the control vertex associated with a
|
|
// particular u, v coordinate pair. This is just a
|
|
// shorthand to access the EggPrimitive's normal vertex
|
|
// assignment for a 2-d control vertex.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE void EggNurbsSurface::
|
|
set_cv(int ui, int vi, EggVertex *vertex) {
|
|
int vertex_index = get_vertex_index(ui, vi);
|
|
set_vertex(vertex_index, vertex);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::get_u_order
|
|
// Access: Public
|
|
// Description: Returns the order of the surface in the U direction.
|
|
// The order is the degree of the NURBS equation plus 1;
|
|
// for a typical NURBS, the order is 4. With this
|
|
// implementation of NURBS, the order must be in the
|
|
// range [1, 4].
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE int EggNurbsSurface::
|
|
get_u_order() const {
|
|
return _u_order;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::get_v_order
|
|
// Access: Public
|
|
// Description: Returns the order of the surface in the V direction.
|
|
// The order is the degree of the NURBS equation plus 1;
|
|
// for a typical NURBS, the order is 4. With this
|
|
// implementation of NURBS, the order must be in the
|
|
// range [1, 4].
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE int EggNurbsSurface::
|
|
get_v_order() const {
|
|
return _v_order;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::get_u_degree
|
|
// Access: Public
|
|
// Description: Returns the degree of the surface in the U direction.
|
|
// For a typical NURBS, the degree is 3.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE int EggNurbsSurface::
|
|
get_u_degree() const {
|
|
return _u_order - 1;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::get_v_degree
|
|
// Access: Public
|
|
// Description: Returns the degree of the surface in the V direction.
|
|
// for a typical NURBS, the degree is 3.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE int EggNurbsSurface::
|
|
get_v_degree() const {
|
|
return _v_order - 1;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::get_num_u_knots
|
|
// Access: Public
|
|
// Description: Returns the number of knots in the U direction.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE int EggNurbsSurface::
|
|
get_num_u_knots() const {
|
|
return _u_knots.size();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::get_num_v_knots
|
|
// Access: Public
|
|
// Description: Returns the number of knots in the V direction.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE int EggNurbsSurface::
|
|
get_num_v_knots() const {
|
|
return _v_knots.size();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::get_num_u_cvs
|
|
// Access: Public
|
|
// Description: Returns the number of control vertices that should be
|
|
// present in the U direction. This is determined by
|
|
// the number of knots and the order; it does not
|
|
// necessarily reflect the number of vertices that have
|
|
// actually been added to the surface. (However, if the
|
|
// number of vertices in the surface are wrong, the
|
|
// surface is invalid.)
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE int EggNurbsSurface::
|
|
get_num_u_cvs() const {
|
|
return get_num_u_knots() - get_u_order();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::get_num_v_cvs
|
|
// Access: Public
|
|
// Description: Returns the number of control vertices that should be
|
|
// present in the V direction. This is determined by
|
|
// the number of knots and the order; it does not
|
|
// necessarily reflect the number of vertices that have
|
|
// actually been added to the surface. (However, if the
|
|
// number of vertices in the surface are wrong, the
|
|
// surface is invalid.)
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE int EggNurbsSurface::
|
|
get_num_v_cvs() const {
|
|
return get_num_v_knots() - get_v_order();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::get_num_cvs
|
|
// Access: Public
|
|
// Description: Returns the total number of control vertices that
|
|
// *should* be defined for the surface. This is
|
|
// determined by the number of knots and the order, in
|
|
// each direction; it does not necessarily reflect the
|
|
// number of vertices that have actually been added to
|
|
// the surface. (However, if the number of vertices in
|
|
// the surface are wrong, the surface is invalid.)
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE int EggNurbsSurface::
|
|
get_num_cvs() const {
|
|
return get_num_u_cvs() * get_num_v_cvs();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::get_u_index
|
|
// Access: Public
|
|
// Description: Returns the U index number of the given vertex within
|
|
// the EggPrimitive's linear list of vertices. An
|
|
// EggNurbsSurface maps a linear list of vertices to its
|
|
// 2-d mesh; this returns the U index number that
|
|
// corresponds to the nth vertex in the list.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE int EggNurbsSurface::
|
|
get_u_index(int vertex_index) const {
|
|
nassertr(vertex_index >= 0 && vertex_index < get_num_cvs(), 0);
|
|
return vertex_index % get_num_u_cvs();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::get_v_index
|
|
// Access: Public
|
|
// Description: Returns the V index number of the given vertex within
|
|
// the EggPrimitive's linear list of vertices. An
|
|
// EggNurbsSurface maps a linear list of vertices to its
|
|
// 2-d mesh; this returns the V index number that
|
|
// corresponds to the nth vertex in the list.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE int EggNurbsSurface::
|
|
get_v_index(int vertex_index) const {
|
|
nassertr(vertex_index >= 0 && vertex_index < get_num_cvs(), 0);
|
|
return vertex_index / get_num_u_cvs();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::get_vertex_index
|
|
// Access: Public
|
|
// Description: Returns the index number within the EggPrimitive's
|
|
// list of the control vertex at position ui, vi.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE int EggNurbsSurface::
|
|
get_vertex_index(int ui, int vi) const {
|
|
nassertr(ui >= 0 && ui < get_num_u_cvs(), 0);
|
|
nassertr(vi >= 0 && vi < get_num_v_cvs(), 0);
|
|
return vi * get_num_u_cvs() + ui;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::get_u_knot
|
|
// Access: Public
|
|
// Description: Returns the nth knot value defined in the U
|
|
// direction.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE double EggNurbsSurface::
|
|
get_u_knot(int k) const {
|
|
nassertr(k >= 0 && k < (int)_u_knots.size(), 0.0);
|
|
return _u_knots[k];
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::get_v_knot
|
|
// Access: Public
|
|
// Description: Returns the nth knot value defined in the V
|
|
// direction.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE double EggNurbsSurface::
|
|
get_v_knot(int k) const {
|
|
nassertr(k >= 0 && k < (int)_v_knots.size(), 0.0);
|
|
return _v_knots[k];
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: EggNurbsSurface::get_cv
|
|
// Access: Public
|
|
// Description: Returns the control vertex at the indicate U, V
|
|
// position.
|
|
////////////////////////////////////////////////////////////////////
|
|
INLINE EggVertex *EggNurbsSurface::
|
|
get_cv(int ui, int vi) const {
|
|
int vertex_index = get_vertex_index(ui, vi);
|
|
return get_vertex(vertex_index);
|
|
}
|