RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
open_toontown_panda3d/panda/src/gobj/geomPrimitive.cxx

2355 lines
71 KiB
C++
Raw Blame History

/**
* 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."
*
* @file geomPrimitive.cxx
* @author drose
* @date 2005-03-06
*/
#include "geomPrimitive.h"
#include "geom.h"
#include "geomPatches.h"
#include "geomVertexData.h"
#include "geomVertexArrayFormat.h"
#include "geomVertexColumn.h"
#include "geomVertexReader.h"
#include "geomVertexWriter.h"
#include "geomVertexRewriter.h"
#include "geomPoints.h"
#include "geomLines.h"
#include "geomTriangles.h"
#include "preparedGraphicsObjects.h"
#include "internalName.h"
#include "bamReader.h"
#include "bamWriter.h"
#include "ioPtaDatagramInt.h"
#include "indent.h"
#include "pStatTimer.h"
using std::max;
using std::min;
TypeHandle GeomPrimitive::_type_handle;
TypeHandle GeomPrimitive::CData::_type_handle;
TypeHandle GeomPrimitivePipelineReader::_type_handle;
PStatCollector GeomPrimitive::_decompose_pcollector("*:Munge:Decompose");
PStatCollector GeomPrimitive::_doubleside_pcollector("*:Munge:Doubleside");
PStatCollector GeomPrimitive::_reverse_pcollector("*:Munge:Reverse");
PStatCollector GeomPrimitive::_rotate_pcollector("*:Munge:Rotate");
/**
* Constructs an invalid object. Only used when reading from bam.
*/
GeomPrimitive::
GeomPrimitive() {
}
/**
* Required to implement CopyOnWriteObject.
*/
PT(CopyOnWriteObject) GeomPrimitive::
make_cow_copy() {
return make_copy();
}
/**
*
*/
GeomPrimitive::
GeomPrimitive(GeomPrimitive::UsageHint usage_hint) {
CDWriter cdata(_cycler, true);
cdata->_usage_hint = usage_hint;
}
/**
*
*/
GeomPrimitive::
GeomPrimitive(const GeomPrimitive &copy) :
CopyOnWriteObject(copy),
_cycler(copy._cycler)
{
}
/**
* The copy assignment operator is not pipeline-safe. This will completely
* obliterate all stages of the pipeline, so don't do it for a GeomPrimitive
* that is actively being used for rendering.
*/
void GeomPrimitive::
operator = (const GeomPrimitive &copy) {
CopyOnWriteObject::operator = (copy);
_cycler = copy._cycler;
}
/**
*
*/
GeomPrimitive::
~GeomPrimitive() {
release_all();
}
/**
* Returns the set of GeomRendering bits that represent the rendering
* properties required to properly render this primitive.
*/
int GeomPrimitive::
get_geom_rendering() const {
if (is_indexed()) {
return GR_indexed_other;
} else {
return 0;
}
}
/**
* Changes the UsageHint hint for this primitive. See get_usage_hint().
*
* Don't call this in a downstream thread unless you don't mind it blowing
* away other changes you might have recently made in an upstream thread.
*/
void GeomPrimitive::
set_usage_hint(GeomPrimitive::UsageHint usage_hint) {
CDWriter cdata(_cycler, true);
cdata->_usage_hint = usage_hint;
if (!cdata->_vertices.is_null()) {
cdata->_modified = Geom::get_next_modified();
cdata->_usage_hint = usage_hint;
}
}
/**
* Changes the numeric type of the index column. Normally, this should be
* either NT_uint16 or NT_uint32.
*
* The index type must be large enough to include all of the index values in
* the primitive. It may be automatically elevated, if necessary, to a larger
* index type, by a subsequent call to add_index() that names an index value
* that does not fit in the index type you specify.
*
* Don't call this in a downstream thread unless you don't mind it blowing
* away other changes you might have recently made in an upstream thread.
*/
void GeomPrimitive::
set_index_type(GeomPrimitive::NumericType index_type) {
nassertv(get_max_vertex() <= get_highest_index_value(index_type));
CDWriter cdata(_cycler, true);
if (cdata->_index_type != index_type) {
do_set_index_type(cdata, index_type);
}
}
/**
* Adds the indicated vertex to the list of vertex indices used by the
* graphics primitive type. To define a primitive, you must call add_vertex()
* for each vertex of the new primitive, and then call close_primitive() after
* you have specified the last vertex of each primitive.
*
* Don't call this in a downstream thread unless you don't mind it blowing
* away other changes you might have recently made in an upstream thread.
*/
void GeomPrimitive::
add_vertex(int vertex) {
CDWriter cdata(_cycler, true);
if (gobj_cat.is_spam()) {
gobj_cat.spam()
<< this << ".add_vertex(" << vertex << ")\n";
}
consider_elevate_index_type(cdata, vertex);
if (requires_unused_vertices()) {
int num_primitives = get_num_primitives();
if (num_primitives > 0 &&
get_num_vertices() == get_primitive_end(num_primitives - 1)) {
// If we are beginning a new primitive, give the derived class a chance to
// insert some degenerate vertices.
if (cdata->_vertices.is_null()) {
do_make_indexed(cdata);
}
append_unused_vertices(cdata->_vertices.get_write_pointer(), vertex);
}
}
if (cdata->_vertices.is_null()) {
// The nonindexed case. We can keep the primitive nonindexed only if the
// vertex number happens to be the next available vertex.
nassertv(cdata->_num_vertices != -1);
if (cdata->_num_vertices == 0) {
cdata->_first_vertex = vertex;
cdata->_num_vertices = 1;
cdata->_modified = Geom::get_next_modified();
cdata->_got_minmax = false;
return;
} else if (vertex == cdata->_first_vertex + cdata->_num_vertices) {
++cdata->_num_vertices;
cdata->_modified = Geom::get_next_modified();
cdata->_got_minmax = false;
return;
}
// Otherwise, we need to suddenly become an indexed primitive.
do_make_indexed(cdata);
}
{
GeomVertexArrayDataHandle handle(cdata->_vertices.get_write_pointer(),
Thread::get_current_thread());
int num_rows = handle.get_num_rows();
handle.set_num_rows(num_rows + 1);
unsigned char *ptr = handle.get_write_pointer();
switch (cdata->_index_type) {
case GeomEnums::NT_uint8:
((uint8_t *)ptr)[num_rows] = vertex;
break;
case GeomEnums::NT_uint16:
((uint16_t *)ptr)[num_rows] = vertex;
break;
case GeomEnums::NT_uint32:
((uint32_t *)ptr)[num_rows] = vertex;
break;
default:
nassert_raise("unsupported index type");
break;
}
}
cdata->_modified = Geom::get_next_modified();
cdata->_got_minmax = false;
}
/**
* Adds a consecutive sequence of vertices, beginning at start, to the
* primitive.
*
* Don't call this in a downstream thread unless you don't mind it blowing
* away other changes you might have recently made in an upstream thread.
*/
void GeomPrimitive::
add_consecutive_vertices(int start, int num_vertices) {
if (num_vertices == 0) {
return;
}
int end = (start + num_vertices) - 1;
CDWriter cdata(_cycler, true);
consider_elevate_index_type(cdata, end);
int num_primitives = get_num_primitives();
if (num_primitives > 0 &&
get_num_vertices() == get_primitive_end(num_primitives - 1)) {
// If we are beginning a new primitive, give the derived class a chance to
// insert some degenerate vertices.
if (cdata->_vertices.is_null()) {
do_make_indexed(cdata);
}
append_unused_vertices(cdata->_vertices.get_write_pointer(), start);
}
if (cdata->_vertices.is_null()) {
// The nonindexed case. We can keep the primitive nonindexed only if the
// vertex number happens to be the next available vertex.
nassertv(cdata->_num_vertices != -1);
if (cdata->_num_vertices == 0) {
cdata->_first_vertex = start;
cdata->_num_vertices = num_vertices;
cdata->_modified = Geom::get_next_modified();
cdata->_got_minmax = false;
return;
} else if (start == cdata->_first_vertex + cdata->_num_vertices) {
cdata->_num_vertices += num_vertices;
cdata->_modified = Geom::get_next_modified();
cdata->_got_minmax = false;
return;
}
// Otherwise, we need to suddenly become an indexed primitive.
do_make_indexed(cdata);
}
PT(GeomVertexArrayData) array_obj = cdata->_vertices.get_write_pointer();
int old_num_rows = array_obj->get_num_rows();
array_obj->set_num_rows(old_num_rows + num_vertices);
GeomVertexWriter index(array_obj, 0);
index.set_row_unsafe(old_num_rows);
for (int v = start; v <= end; ++v) {
index.set_data1i(v);
}
cdata->_modified = Geom::get_next_modified();
cdata->_got_minmax = false;
}
/**
* Adds the next n vertices in sequence, beginning from the last vertex added
* to the primitive + 1.
*
* This is most useful when you are building up a primitive and a
* GeomVertexData at the same time, and you just want the primitive to
* reference the first n vertices from the data, then the next n, and so on.
*/
void GeomPrimitive::
add_next_vertices(int num_vertices) {
if (get_num_vertices() == 0) {
add_consecutive_vertices(0, num_vertices);
} else {
add_consecutive_vertices(get_vertex(get_num_vertices() - 1) + 1, num_vertices);
}
}
/**
* This ensures that enough memory space for n vertices is allocated, so that
* you may increase the number of vertices to n without causing a new memory
* allocation. This is a performance optimization only; it is especially
* useful when you know ahead of time that you will be adding n vertices to
* the primitive.
*
* Note that the total you specify here should also include implicit vertices
* which may be added at each close_primitive() call, according to
* get_num_unused_vertices_per_primitive().
*
* Note also that making this call will implicitly make the primitive indexed
* if it is not already, which could result in a performance *penalty*. If
* you would prefer not to lose the nonindexed nature of your existing
* GeomPrimitives, check is_indexed() before making this call.
*/
void GeomPrimitive::
reserve_num_vertices(int num_vertices) {
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< this << ".reserve_num_vertices(" << num_vertices << ")\n";
}
CDWriter cdata(_cycler, true);
consider_elevate_index_type(cdata, num_vertices);
do_make_indexed(cdata);
PT(GeomVertexArrayData) array_obj = cdata->_vertices.get_write_pointer();
array_obj->reserve_num_rows(num_vertices);
}
/**
* Indicates that the previous n calls to add_vertex(), since the last call to
* close_primitive(), have fully defined a new primitive. Returns true if
* successful, false otherwise.
*
* Don't call this in a downstream thread unless you don't mind it blowing
* away other changes you might have recently made in an upstream thread.
*/
bool GeomPrimitive::
close_primitive() {
int num_vertices_per_primitive = get_num_vertices_per_primitive();
CDWriter cdata(_cycler, true);
if (num_vertices_per_primitive == 0) {
// This is a complex primitive type like a triangle strip: each primitive
// uses a different number of vertices.
#ifndef NDEBUG
int num_added;
if (cdata->_ends.empty()) {
num_added = get_num_vertices();
} else {
num_added = get_num_vertices() - cdata->_ends.back();
num_added -= get_num_unused_vertices_per_primitive();
}
nassertr(num_added >= get_min_num_vertices_per_primitive(), false);
#endif
if (cdata->_ends.get_ref_count() > 1) {
PTA_int new_ends;
new_ends.v() = cdata->_ends.v();
cdata->_ends = new_ends;
}
cdata->_ends.push_back(get_num_vertices());
} else {
#ifndef NDEBUG
// This is a simple primitive type like a triangle: each primitive uses
// the same number of vertices. Assert that we added the correct number
// of vertices.
int num_vertices_per_primitive = get_num_vertices_per_primitive();
int num_unused_vertices_per_primitive = get_num_unused_vertices_per_primitive();
int num_vertices = get_num_vertices();
nassertr((num_vertices + num_unused_vertices_per_primitive) % (num_vertices_per_primitive + num_unused_vertices_per_primitive) == 0, false)
#endif
}
cdata->_modified = Geom::get_next_modified();
return true;
}
/**
* Removes all of the vertices and primitives from the object, so they can be
* re-added.
*
* Don't call this in a downstream thread unless you don't mind it blowing
* away other changes you might have recently made in an upstream thread.
*/
void GeomPrimitive::
clear_vertices() {
CDWriter cdata(_cycler, true);
cdata->_first_vertex = 0;
cdata->_num_vertices = 0;
// Since we might have automatically elevated the index type by adding
// vertices, we should automatically lower it again when we call
// clear_vertices().
cdata->_index_type = NT_uint16;
cdata->_vertices.clear();
cdata->_ends.clear();
cdata->_mins.clear();
cdata->_maxs.clear();
cdata->_modified = Geom::get_next_modified();
cdata->_got_minmax = false;
}
/**
* Adds the indicated offset to all vertices used by the primitive.
*
* Don't call this in a downstream thread unless you don't mind it blowing
* away other changes you might have recently made in an upstream thread.
*/
void GeomPrimitive::
offset_vertices(int offset) {
if (offset == 0) {
return;
}
if (is_indexed()) {
CDWriter cdata(_cycler, true);
if (!cdata->_got_minmax) {
recompute_minmax(cdata);
nassertv(cdata->_got_minmax);
}
consider_elevate_index_type(cdata, cdata->_max_vertex + offset);
int strip_cut_index = get_strip_cut_index(cdata->_index_type);
GeomVertexRewriter index(do_modify_vertices(cdata), 0);
while (!index.is_at_end()) {
int vertex = index.get_data1i();
if (vertex != strip_cut_index) {
index.set_data1i(vertex + offset);
}
}
} else {
CDWriter cdata(_cycler, true);
cdata->_first_vertex += offset;
cdata->_modified = Geom::get_next_modified();
cdata->_got_minmax = false;
consider_elevate_index_type(cdata,
cdata->_first_vertex + cdata->_num_vertices - 1);
}
}
/**
* Adds the indicated offset to the indicated segment of vertices used by the
* primitive. Unlike the other version of offset_vertices, this makes the
* geometry indexed if it isn't already.
*
* Don't call this in a downstream thread unless you don't mind it blowing
* away other changes you might have recently made in an upstream thread.
*/
void GeomPrimitive::
offset_vertices(int offset, int begin_row, int end_row) {
if (offset == 0 || end_row <= begin_row) {
return;
}
nassertv(begin_row >= 0 && end_row >= 0);
nassertv(end_row <= get_num_vertices());
if (!is_indexed() && (begin_row > 0 || end_row < get_num_vertices())) {
// Make it indexed unless the whole array was specified.
make_indexed();
}
if (is_indexed()) {
CDWriter cdata(_cycler, true);
int strip_cut_index = get_strip_cut_index(cdata->_index_type);
// Calculate the maximum vertex over our range.
int max_vertex = 0;
{
GeomVertexReader index_r(cdata->_vertices.get_read_pointer(), 0);
index_r.set_row_unsafe(begin_row);
for (int j = begin_row; j < end_row; ++j) {
int vertex = index_r.get_data1i();
if (vertex != strip_cut_index) {
max_vertex = max(max_vertex, vertex);
}
}
}
consider_elevate_index_type(cdata, max_vertex + offset);
GeomVertexRewriter index(do_modify_vertices(cdata), 0);
index.set_row_unsafe(begin_row);
for (int j = begin_row; j < end_row; ++j) {
int vertex = index.get_data1i();
if (vertex != strip_cut_index) {
index.set_data1i(vertex + offset);
}
}
} else {
// The supplied values cover all vertices, so we don't need to make it
// indexed.
CDWriter cdata(_cycler, true);
cdata->_first_vertex += offset;
cdata->_modified = Geom::get_next_modified();
cdata->_got_minmax = false;
consider_elevate_index_type(cdata,
cdata->_first_vertex + cdata->_num_vertices - 1);
}
}
/**
* Converts the primitive from indexed to nonindexed by duplicating vertices
* as necessary into the indicated dest GeomVertexData. Note: does not
* support primitives with strip cut indices.
*/
void GeomPrimitive::
make_nonindexed(GeomVertexData *dest, const GeomVertexData *source) {
Thread *current_thread = Thread::get_current_thread();
int num_vertices, dest_start;
{
GeomPrimitivePipelineReader reader(this, current_thread);
num_vertices = reader.get_num_vertices();
int strip_cut_index = reader.get_strip_cut_index();
GeomVertexDataPipelineWriter data_writer(dest, false, current_thread);
data_writer.check_array_writers();
dest_start = data_writer.get_num_rows();
data_writer.set_num_rows(dest_start + num_vertices);
GeomVertexDataPipelineReader data_reader(source, current_thread);
data_reader.check_array_readers();
for (int i = 0; i < num_vertices; ++i) {
int v = reader.get_vertex(i);
nassertd(v != strip_cut_index) continue;
data_writer.copy_row_from(dest_start + i, data_reader, v);
}
}
set_nonindexed_vertices(dest_start, num_vertices);
}
/**
* Packs the vertices used by the primitive from the indicated source array
* onto the end of the indicated destination array.
*/
void GeomPrimitive::
pack_vertices(GeomVertexData *dest, const GeomVertexData *source) {
Thread *current_thread = Thread::get_current_thread();
if (!is_indexed()) {
// If the primitive is nonindexed, packing is the same as converting
// (again) to nonindexed.
make_nonindexed(dest, source);
} else {
// The indexed case: build up a new index as we go.
CPT(GeomVertexArrayData) orig_vertices = get_vertices();
PT(GeomVertexArrayData) new_vertices = make_index_data();
GeomVertexWriter index(new_vertices, 0);
typedef pmap<int, int> CopiedIndices;
CopiedIndices copied_indices;
int num_vertices = get_num_vertices();
int dest_start = dest->get_num_rows();
int strip_cut_index = get_strip_cut_index();
for (int i = 0; i < num_vertices; ++i) {
int v = get_vertex(i);
if (v == strip_cut_index) {
continue;
}
// Try to add the relation { v : size() }. If that succeeds, great; if
// it doesn't, look up whatever we previously added for v.
std::pair<CopiedIndices::iterator, bool> result =
copied_indices.insert(CopiedIndices::value_type(v, (int)copied_indices.size()));
int v2 = (*result.first).second + dest_start;
index.add_data1i(v2);
if (result.second) {
// This is the first time we've seen vertex v.
dest->copy_row_from(v2, source, v, current_thread);
}
}
set_vertices(new_vertices);
}
}
/**
* Converts the primitive from nonindexed form to indexed form. This will
* simply create an index table that is numbered consecutively from
* get_first_vertex(); it does not automatically collapse together identical
* vertices that may have been split apart by a previous call to
* make_nonindexed().
*
* Don't call this in a downstream thread unless you don't mind it blowing
* away other changes you might have recently made in an upstream thread.
*/
void GeomPrimitive::
make_indexed() {
CDWriter cdata(_cycler, true);
do_make_indexed(cdata);
}
/**
* Returns the element within the _vertices list at which the nth primitive
* starts.
*
* If i is one more than the highest valid primitive vertex, the return value
* will be one more than the last valid vertex. Thus, it is generally true
* that the vertices used by a particular primitive i are the set
* get_primitive_start(n) <= vi < get_primitive_start(n + 1) (although this
* range also includes the unused vertices between primitives).
*/
int GeomPrimitive::
get_primitive_start(int n) const {
int num_vertices_per_primitive = get_num_vertices_per_primitive();
int num_unused_vertices_per_primitive = get_num_unused_vertices_per_primitive();
if (num_vertices_per_primitive == 0) {
// This is a complex primitive type like a triangle strip: each primitive
// uses a different number of vertices.
CDReader cdata(_cycler);
nassertr(n >= 0 && n <= (int)cdata->_ends.size(), -1);
if (n == 0) {
return 0;
} else {
return cdata->_ends[n - 1] + num_unused_vertices_per_primitive;
}
} else {
// This is a simple primitive type like a triangle: each primitive uses
// the same number of vertices.
return n * (num_vertices_per_primitive + num_unused_vertices_per_primitive);
}
}
/**
* Returns the element within the _vertices list at which the nth primitive
* ends. This is one past the last valid element for the nth primitive.
*/
int GeomPrimitive::
get_primitive_end(int n) const {
int num_vertices_per_primitive = get_num_vertices_per_primitive();
if (num_vertices_per_primitive == 0) {
// This is a complex primitive type like a triangle strip: each primitive
// uses a different number of vertices.
CDReader cdata(_cycler);
nassertr(n >= 0 && n < (int)cdata->_ends.size(), -1);
return cdata->_ends[n];
} else {
// This is a simple primitive type like a triangle: each primitive uses
// the same number of vertices.
int num_unused_vertices_per_primitive = get_num_unused_vertices_per_primitive();
return n * (num_vertices_per_primitive + num_unused_vertices_per_primitive) + num_vertices_per_primitive;
}
}
/**
* Returns the number of vertices used by the nth primitive. This is the same
* thing as get_primitive_end(n) - get_primitive_start(n).
*/
int GeomPrimitive::
get_primitive_num_vertices(int n) const {
int num_vertices_per_primitive = get_num_vertices_per_primitive();
if (num_vertices_per_primitive == 0) {
// This is a complex primitive type like a triangle strip: each primitive
// uses a different number of vertices.
CDReader cdata(_cycler);
nassertr(n >= 0 && n < (int)cdata->_ends.size(), 0);
if (n == 0) {
return cdata->_ends[0];
} else {
int num_unused_vertices_per_primitive = get_num_unused_vertices_per_primitive();
return cdata->_ends[n] - cdata->_ends[n - 1] - num_unused_vertices_per_primitive;
}
} else {
// This is a simple primitive type like a triangle: each primitive uses
// the same number of vertices.
return num_vertices_per_primitive;
}
}
/**
* Returns the number of vertices used by all of the primitives. This is the
* same as summing get_primitive_num_vertices(n) for n in
* get_num_primitives(). It is like get_num_vertices except that it excludes
* all of the degenerate vertices and strip-cut indices.
*/
int GeomPrimitive::
get_num_used_vertices() const {
int num_primitives = get_num_primitives();
if (num_primitives > 0) {
return get_num_vertices() - ((num_primitives - 1) *
get_num_unused_vertices_per_primitive());
} else {
return 0;
}
}
/**
* Returns the minimum vertex index number used by the nth primitive in this
* object.
*/
int GeomPrimitive::
get_primitive_min_vertex(int n) const {
if (is_indexed()) {
CPT(GeomVertexArrayData) mins = get_mins();
nassertr(n >= 0 && n < mins->get_num_rows(), -1);
GeomVertexReader index(mins, 0);
index.set_row_unsafe(n);
return index.get_data1i();
} else {
return get_primitive_start(n);
}
}
/**
* Returns the maximum vertex index number used by the nth primitive in this
* object.
*/
int GeomPrimitive::
get_primitive_max_vertex(int n) const {
if (is_indexed()) {
CPT(GeomVertexArrayData) maxs = get_maxs();
nassertr(n >= 0 && n < maxs->get_num_rows(), -1);
GeomVertexReader index(maxs, 0);
index.set_row_unsafe(n);
return index.get_data1i();
} else {
return get_primitive_end(n) - 1;
}
}
/**
* Decomposes a complex primitive type into a simpler primitive type, for
* instance triangle strips to triangles, and returns a pointer to the new
* primitive definition. If the decomposition cannot be performed, this might
* return the original object.
*
* This method is useful for application code that wants to iterate through
* the set of triangles on the primitive without having to write handlers for
* each possible kind of primitive type.
*/
CPT(GeomPrimitive) GeomPrimitive::
decompose() const {
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< "Decomposing " << get_type() << ": " << (void *)this << "\n";
}
PStatTimer timer(_decompose_pcollector);
return decompose_impl();
}
/**
* Returns a new primitive with the shade_model reversed (if it is flat
* shaded), if possible. If the primitive type cannot be rotated, returns the
* original primitive, unrotated.
*
* If the current shade_model indicates flat_vertex_last, this should bring
* the last vertex to the first position; if it indicates flat_vertex_first,
* this should bring the first vertex to the last position.
*/
CPT(GeomPrimitive) GeomPrimitive::
rotate() const {
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< "Rotating " << get_type() << ": " << (void *)this << "\n";
}
PStatTimer timer(_rotate_pcollector);
CPT(GeomVertexArrayData) rotated_vertices = rotate_impl();
if (rotated_vertices == nullptr) {
// This primitive type can't be rotated.
return this;
}
PT(GeomPrimitive) new_prim = make_copy();
new_prim->set_vertices(rotated_vertices);
switch (get_shade_model()) {
case SM_flat_first_vertex:
new_prim->set_shade_model(SM_flat_last_vertex);
break;
case SM_flat_last_vertex:
new_prim->set_shade_model(SM_flat_first_vertex);
break;
default:
break;
}
return new_prim;
}
/**
* Duplicates triangles in the primitive so that each triangle is back-to-back
* with another triangle facing in the opposite direction. Note that this
* doesn't affect vertex normals, so this operation alone won't work in the
* presence of lighting (but see SceneGraphReducer::doubleside()).
*
* Also see CullFaceAttrib, which can enable rendering of both sides of a
* triangle without having to duplicate it (but which doesn't necessarily work
* in the presence of lighting).
*/
CPT(GeomPrimitive) GeomPrimitive::
doubleside() const {
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< "Doublesiding " << get_type() << ": " << (void *)this << "\n";
}
PStatTimer timer(_doubleside_pcollector);
return doubleside_impl();
}
/**
* Reverses the winding order in the primitive so that each triangle is facing
* in the opposite direction it was originally. Note that this doesn't affect
* vertex normals, so this operation alone won't work in the presence of
* lighting (but see SceneGraphReducer::reverse()).
*
* Also see CullFaceAttrib, which can change the visible direction of a
* triangle without having to duplicate it (but which doesn't necessarily work
* in the presence of lighting).
*/
CPT(GeomPrimitive) GeomPrimitive::
reverse() const {
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< "Reversing " << get_type() << ": " << (void *)this << "\n";
}
PStatTimer timer(_reverse_pcollector);
return reverse_impl();
}
/**
* Returns a new primitive that is compatible with the indicated shade model,
* if possible, or NULL if this is not possible.
*
* In most cases, this will return either NULL or the original primitive. In
* the case of a SM_flat_first_vertex vs. a SM_flat_last_vertex (or vice-
* versa), however, it will return a rotated primitive.
*/
CPT(GeomPrimitive) GeomPrimitive::
match_shade_model(GeomPrimitive::ShadeModel shade_model) const {
ShadeModel this_shade_model = get_shade_model();
if (this_shade_model == shade_model) {
// Trivially compatible.
return this;
}
if (this_shade_model == SM_uniform || shade_model == SM_uniform) {
// SM_uniform is compatible with anything.
return this;
}
if ((this_shade_model == SM_flat_first_vertex && shade_model == SM_flat_last_vertex) ||
(this_shade_model == SM_flat_last_vertex && shade_model == SM_flat_first_vertex)) {
// Needs to be rotated.
CPT(GeomPrimitive) rotated = rotate();
if (rotated.p() == this) {
// Oops, can't be rotated, sorry.
return nullptr;
}
return rotated;
}
// Not compatible, sorry.
return nullptr;
}
/**
* Returns a new GeomPoints primitive that represents each of the vertices in
* the original primitive, rendered exactly once. If the original primitive
* is already a GeomPoints primitive, returns the original primitive
* unchanged.
*/
CPT(GeomPrimitive) GeomPrimitive::
make_points() const {
if (is_exact_type(GeomPoints::get_class_type())) {
return this;
}
// First, get a list of all of the vertices referenced by the original
// primitive.
BitArray bits;
{
GeomPrimitivePipelineReader reader(this, Thread::get_current_thread());
reader.get_referenced_vertices(bits);
}
// Now construct a new index array with just those bits.
PT(GeomVertexArrayData) new_vertices = make_index_data();
new_vertices->unclean_set_num_rows(bits.get_num_on_bits());
GeomVertexWriter new_index(new_vertices, 0);
int p = bits.get_lowest_on_bit();
while (p != -1) {
while (bits.get_bit(p)) {
new_index.set_data1i(p);
++p;
}
int q = bits.get_next_higher_different_bit(p);
if (q == p) {
break;
}
p = q;
}
PT(GeomPrimitive) points = new GeomPoints(UH_dynamic);
points->set_vertices(new_vertices);
return points;
}
/**
* Returns a new GeomLines primitive that represents each of the edges in the
* original primitive rendered as a line. If the original primitive is
* already a GeomLines primitive, returns the original primitive unchanged.
*/
CPT(GeomPrimitive) GeomPrimitive::
make_lines() const {
if (is_exact_type(GeomLines::get_class_type())) {
return this;
}
PrimitiveType prim_type = get_primitive_type();
if (prim_type == PT_lines) {
// It's a line strip, just decompose it.
return decompose();
} else if (prim_type != PT_polygons && prim_type != PT_patches) {
// Don't know how to represent this in wireframe.
return this;
}
if (prim_type == PT_polygons && !is_exact_type(GeomTriangles::get_class_type())) {
// Decompose tristrips. We could probably make this more efficient by
// making a specific implementation of make_lines for GeomTristrips.
return decompose()->make_lines();
}
// Iterate through the primitives.
int num_primitives = get_num_primitives();
int verts_per_prim = get_num_vertices_per_primitive();
PT(GeomVertexArrayData) new_vertices = make_index_data();
new_vertices->unclean_set_num_rows(num_primitives * verts_per_prim * 2);
GeomVertexWriter new_index(new_vertices, 0);
for (int i = 0; i < num_primitives; ++i) {
int begin = get_primitive_start(i);
int end = get_primitive_end(i);
if (begin == end) {
continue;
}
for (int vi = begin; vi < end - 1; vi++) {
new_index.set_data1i(get_vertex(vi));
new_index.set_data1i(get_vertex(vi + 1));
}
new_index.set_data1i(get_vertex(end - 1));
new_index.set_data1i(get_vertex(begin));
}
PT(GeomPrimitive) lines = new GeomLines(UH_dynamic);
lines->set_vertices(new_vertices);
return lines;
}
/**
* Decomposes a complex primitive type into a simpler primitive type, for
* instance triangle strips to triangles, puts these in a new GeomPatches
* object and returns a pointer to the new primitive definition. If the
* decomposition cannot be performed, this might return the original object.
*
* This method is useful for application code that wants to use tesselation
* shaders on arbitrary geometry.
*/
CPT(GeomPrimitive) GeomPrimitive::
make_patches() const {
if (is_exact_type(GeomPatches::get_class_type())) {
return this;
}
CPT(GeomPrimitive) prim = decompose_impl();
int num_vertices_per_patch = prim->get_num_vertices_per_primitive();
PT(GeomPrimitive) patches = new GeomPatches(num_vertices_per_patch, get_usage_hint());
if (prim->is_indexed()) {
patches->set_vertices(prim->get_vertices());
} else {
patches->set_nonindexed_vertices(prim->get_first_vertex(),
prim->get_num_vertices());
}
return patches;
}
/**
* Adds adjacency information to this primitive. May return null if this type
* of geometry does not support adjacency information.
*
* @since 1.10.0
*/
CPT(GeomPrimitive) GeomPrimitive::
make_adjacency() const {
return nullptr;
}
/**
* Returns the number of bytes consumed by the primitive and its index
* table(s).
*/
int GeomPrimitive::
get_num_bytes() const {
CDReader cdata(_cycler);
int num_bytes = cdata->_ends.size() * sizeof(int) + sizeof(GeomPrimitive);
if (!cdata->_vertices.is_null()) {
num_bytes += cdata->_vertices.get_read_pointer()->get_data_size_bytes();
}
return num_bytes;
}
/**
* Returns true if the primitive data is currently resident in memory. If
* this returns false, the primitive data will be brought back into memory
* shortly; try again later.
*/
bool GeomPrimitive::
request_resident(Thread *current_thread) const {
CDReader cdata(_cycler, current_thread);
bool resident = true;
if (!cdata->_vertices.is_null() &&
!cdata->_vertices.get_read_pointer(current_thread)->request_resident(current_thread)) {
resident = false;
}
if (is_composite() && cdata->_got_minmax) {
if (!cdata->_mins.is_null() &&
!cdata->_mins.get_read_pointer(current_thread)->request_resident(current_thread)) {
resident = false;
}
if (!cdata->_maxs.is_null() &&
!cdata->_maxs.get_read_pointer(current_thread)->request_resident(current_thread)) {
resident = false;
}
}
return resident;
}
/**
*
*/
void GeomPrimitive::
output(std::ostream &out) const {
out << get_type() << ", " << get_num_primitives()
<< ", " << get_num_vertices();
}
/**
*
*/
void GeomPrimitive::
write(std::ostream &out, int indent_level) const {
indent(out, indent_level)
<< get_type();
if (is_indexed()) {
out << " (indexed)";
} else {
out << " (nonindexed)";
}
out << ":\n";
int num_primitives = get_num_primitives();
int num_vertices = get_num_vertices();
int num_unused_vertices_per_primitive = get_num_unused_vertices_per_primitive();
for (int i = 0; i < num_primitives; ++i) {
indent(out, indent_level + 2)
<< "[";
int begin = get_primitive_start(i);
int end = get_primitive_end(i);
for (int vi = begin; vi < end; vi++) {
out << " " << get_vertex(vi);
}
out << " ]";
if (end < num_vertices) {
for (int ui = 0; ui < num_unused_vertices_per_primitive; ++ui) {
if (end + ui < num_vertices) {
out << " " << get_vertex(end + ui);
} else {
out << " ?";
}
}
}
out << "\n";
}
}
/**
* Returns a modifiable pointer to the vertex index list, so application code
* can directly fiddle with this data. Use with caution, since there are no
* checks that the data will be left in a stable state.
*
* If this is called on a nonindexed primitive, it will implicitly be
* converted to an indexed primitive.
*
* If num_vertices is not -1, it specifies an artificial limit to the number
* of vertices in the array. Otherwise, all of the vertices in the array will
* be used.
*
* Don't call this in a downstream thread unless you don't mind it blowing
* away other changes you might have recently made in an upstream thread.
*
* This method is intended for low-level usage only. There are higher-level
* methods for more common usage. We recommend you do not use this method
* directly. If you do, be sure you know what you are doing!
*/
PT(GeomVertexArrayData) GeomPrimitive::
modify_vertices(int num_vertices) {
CDWriter cdata(_cycler, true);
PT(GeomVertexArrayData) vertices = do_modify_vertices(cdata);
cdata->_num_vertices = num_vertices;
return vertices;
}
/**
* Completely replaces the vertex index list with a new table. Chances are
* good that you should also replace the ends list with set_ends() at the same
* time.
*
* If num_vertices is not -1, it specifies an artificial limit to the number
* of vertices in the array. Otherwise, all of the vertices in the array will
* be used.
*
* Don't call this in a downstream thread unless you don't mind it blowing
* away other changes you might have recently made in an upstream thread.
*
* This method is intended for low-level usage only. There are higher-level
* methods for more common usage. We recommend you do not use this method
* directly. If you do, be sure you know what you are doing!
*/
void GeomPrimitive::
set_vertices(const GeomVertexArrayData *vertices, int num_vertices) {
CDWriter cdata(_cycler, true);
cdata->_vertices = (GeomVertexArrayData *)vertices;
cdata->_num_vertices = num_vertices;
// Validate the format and make sure to copy its numeric type.
const GeomVertexArrayFormat *format = vertices->get_array_format();
nassertv(format->get_num_columns() == 1);
cdata->_index_type = format->get_column(0)->get_numeric_type();
cdata->_modified = Geom::get_next_modified();
cdata->_got_minmax = false;
}
/**
* Sets the primitive up as a nonindexed primitive, using the indicated vertex
* range.
*
* Don't call this in a downstream thread unless you don't mind it blowing
* away other changes you might have recently made in an upstream thread.
*
* This method is intended for low-level usage only. There are higher-level
* methods for more common usage. We recommend you do not use this method
* directly. If you do, be sure you know what you are doing!
*/
void GeomPrimitive::
set_nonindexed_vertices(int first_vertex, int num_vertices) {
nassertv(num_vertices != -1);
CDWriter cdata(_cycler, true);
cdata->_vertices = nullptr;
cdata->_first_vertex = first_vertex;
cdata->_num_vertices = num_vertices;
cdata->_modified = Geom::get_next_modified();
cdata->_got_minmax = false;
// Force the minmax to be recomputed.
recompute_minmax(cdata);
}
/**
* Returns a modifiable pointer to the primitive ends array, so application
* code can directly fiddle with this data. Use with caution, since there are
* no checks that the data will be left in a stable state.
*
* Note that simple primitive types, like triangles, do not have a ends array:
* since all the primitives have the same number of vertices, it is not
* needed.
*
* Don't call this in a downstream thread unless you don't mind it blowing
* away other changes you might have recently made in an upstream thread.
*
* This method is intended for low-level usage only. There are higher-level
* methods for more common usage. We recommend you do not use this method
* directly. If you do, be sure you know what you are doing!
*/
PTA_int GeomPrimitive::
modify_ends() {
CDWriter cdata(_cycler, true);
cdata->_modified = Geom::get_next_modified();
cdata->_got_minmax = false;
if (cdata->_ends.get_ref_count() > 1) {
PTA_int new_ends;
new_ends.v() = cdata->_ends.v();
cdata->_ends = new_ends;
}
return cdata->_ends;
}
/**
* Completely replaces the primitive ends array with a new table. Chances are
* good that you should also replace the vertices list with set_vertices() at
* the same time.
*
* Note that simple primitive types, like triangles, do not have a ends array:
* since all the primitives have the same number of vertices, it is not
* needed.
*
* Don't call this in a downstream thread unless you don't mind it blowing
* away other changes you might have recently made in an upstream thread.
*
* This method is intended for low-level usage only. There are higher-level
* methods for more common usage. We recommend you do not use this method
* directly. If you do, be sure you know what you are doing!
*/
void GeomPrimitive::
set_ends(PTA_int ends) {
CDWriter cdata(_cycler, true);
cdata->_ends = ends;
cdata->_modified = Geom::get_next_modified();
cdata->_got_minmax = false;
}
/**
* Explicitly specifies the minimum and maximum vertices, as well as the lists
* of per-component min and max.
*
* Use this method with extreme caution. It's generally better to let the
* GeomPrimitive compute these explicitly, unless for some reason you can do
* it faster and you absolutely need the speed improvement.
*
* Note that any modification to the vertex array will normally cause this to
* be recomputed, unless you set it immediately again.
*
* This method is intended for low-level usage only. There are higher-level
* methods for more common usage. We recommend you do not use this method
* directly. If you do, be sure you know what you are doing!
*/
void GeomPrimitive::
set_minmax(int min_vertex, int max_vertex,
GeomVertexArrayData *mins, GeomVertexArrayData *maxs) {
CDWriter cdata(_cycler, true);
cdata->_min_vertex = min_vertex;
cdata->_max_vertex = max_vertex;
cdata->_mins = mins;
cdata->_maxs = maxs;
cdata->_modified = Geom::get_next_modified();
cdata->_got_minmax = true;
}
/**
* Undoes a previous call to set_minmax(), and allows the minimum and maximum
* values to be recomputed normally.
*
* This method is intended for low-level usage only. There are higher-level
* methods for more common usage. We recommend you do not use this method
* directly. If you do, be sure you know what you are doing!
*/
void GeomPrimitive::
clear_minmax() {
CDWriter cdata(_cycler, true);
cdata->_got_minmax = false;
}
/**
* If the primitive type is a simple type in which all primitives have the
* same number of vertices, like triangles, returns the number of vertices per
* primitive. If the primitive type is a more complex type in which different
* primitives might have different numbers of vertices, for instance a
* triangle strip, returns 0.
*
* This method is intended for low-level usage only. There are higher-level
* methods for more common usage. We recommend you do not use this method
* directly. If you do, be sure you know what you are doing!
*/
int GeomPrimitive::
get_num_vertices_per_primitive() const {
return 0;
}
/**
* Returns the minimum number of vertices that must be added before
* close_primitive() may legally be called.
*
* This method is intended for low-level usage only. There are higher-level
* methods for more common usage. We recommend you do not use this method
* directly. If you do, be sure you know what you are doing!
*/
int GeomPrimitive::
get_min_num_vertices_per_primitive() const {
return 3;
}
/**
* Returns the number of vertices that are added between primitives that
* aren't, strictly speaking, part of the primitives themselves. This is
* used, for instance, to define degenerate triangles to connect otherwise
* disconnected triangle strips.
*
* This method is intended for low-level usage only. There are higher-level
* methods for more common usage. We recommend you do not use this method
* directly. If you do, be sure you know what you are doing!
*/
int GeomPrimitive::
get_num_unused_vertices_per_primitive() const {
return 0;
}
/**
* Indicates that the data should be enqueued to be prepared in the indicated
* prepared_objects at the beginning of the next frame. This will ensure the
* data is already loaded into the GSG if it is expected to be rendered soon.
*
* Use this function instead of prepare_now() to preload datas from a user
* interface standpoint.
*/
void GeomPrimitive::
prepare(PreparedGraphicsObjects *prepared_objects) {
if (is_indexed()) {
prepared_objects->enqueue_index_buffer(this);
}
}
/**
* Returns true if the data has already been prepared or enqueued for
* preparation on the indicated GSG, false otherwise.
*/
bool GeomPrimitive::
is_prepared(PreparedGraphicsObjects *prepared_objects) const {
Contexts::const_iterator ci;
ci = _contexts.find(prepared_objects);
if (ci != _contexts.end()) {
return true;
}
return prepared_objects->is_index_buffer_queued(this);
}
/**
* Creates a context for the data on the particular GSG, if it does not
* already exist. Returns the new (or old) IndexBufferContext. This assumes
* that the GraphicsStateGuardian is the currently active rendering context
* and that it is ready to accept new datas. If this is not necessarily the
* case, you should use prepare() instead.
*
* Normally, this is not called directly except by the GraphicsStateGuardian;
* a data does not need to be explicitly prepared by the user before it may be
* rendered.
*/
IndexBufferContext *GeomPrimitive::
prepare_now(PreparedGraphicsObjects *prepared_objects,
GraphicsStateGuardianBase *gsg) {
nassertr(is_indexed(), nullptr);
Contexts::const_iterator ci;
ci = _contexts.find(prepared_objects);
if (ci != _contexts.end()) {
return (*ci).second;
}
IndexBufferContext *ibc = prepared_objects->prepare_index_buffer_now(this, gsg);
if (ibc != nullptr) {
_contexts[prepared_objects] = ibc;
}
return ibc;
}
/**
* Frees the data context only on the indicated object, if it exists there.
* Returns true if it was released, false if it had not been prepared.
*/
bool GeomPrimitive::
release(PreparedGraphicsObjects *prepared_objects) {
Contexts::iterator ci;
ci = _contexts.find(prepared_objects);
if (ci != _contexts.end()) {
IndexBufferContext *ibc = (*ci).second;
prepared_objects->release_index_buffer(ibc);
return true;
}
// Maybe it wasn't prepared yet, but it's about to be.
return prepared_objects->dequeue_index_buffer(this);
}
/**
* Frees the context allocated on all objects for which the data has been
* declared. Returns the number of contexts which have been freed.
*/
int GeomPrimitive::
release_all() {
// We have to traverse a copy of the _contexts list, because the
// PreparedGraphicsObjects object will call clear_prepared() in response to
// each release_index_buffer(), and we don't want to be modifying the
// _contexts list while we're traversing it.
Contexts temp = _contexts;
int num_freed = (int)_contexts.size();
Contexts::const_iterator ci;
for (ci = temp.begin(); ci != temp.end(); ++ci) {
PreparedGraphicsObjects *prepared_objects = (*ci).first;
IndexBufferContext *ibc = (*ci).second;
prepared_objects->release_index_buffer(ibc);
}
// Now that we've called release_index_buffer() on every known context, the
// _contexts list should have completely emptied itself.
nassertr(_contexts.empty(), num_freed);
return num_freed;
}
/**
* Returns a registered GeomVertexArrayFormat of the indicated unsigned
* integer numeric type for storing index values.
*/
const GeomVertexArrayFormat *GeomPrimitive::
get_index_format(NumericType index_type) {
switch (index_type) {
case NT_uint8:
{
static CPT(GeomVertexArrayFormat) cformat = nullptr;
if (cformat == nullptr) {
cformat = make_index_format(NT_uint8);
}
return cformat;
}
case NT_uint16:
{
static CPT(GeomVertexArrayFormat) cformat = nullptr;
if (cformat == nullptr) {
cformat = make_index_format(NT_uint16);
}
return cformat;
}
case NT_uint32:
{
static CPT(GeomVertexArrayFormat) cformat = nullptr;
if (cformat == nullptr) {
cformat = make_index_format(NT_uint32);
}
return cformat;
}
default:
gobj_cat.error()
<< "Not a valid index type: " << index_type << "\n";
return nullptr;
}
return nullptr;
}
/**
* Removes the indicated PreparedGraphicsObjects table from the data array's
* table, without actually releasing the data array. This is intended to be
* called only from PreparedGraphicsObjects::release_index_buffer(); it should
* never be called by user code.
*/
void GeomPrimitive::
clear_prepared(PreparedGraphicsObjects *prepared_objects) {
Contexts::iterator ci;
ci = _contexts.find(prepared_objects);
if (ci != _contexts.end()) {
_contexts.erase(ci);
} else {
// If this assertion fails, clear_prepared() was given a prepared_objects
// which the data array didn't know about.
nassert_raise("unknown PreparedGraphicsObjects");
}
}
/**
* Returns the largest index value that can be stored in an index of the
* indicated type, minus one (to leave room for a potential strip cut index)
*/
int GeomPrimitive::
get_highest_index_value(NumericType index_type) {
// Reserve the highest possible index because implementations use this as a
// strip-cut index.
switch (index_type) {
case NT_uint8:
return 0xff - 1;
case NT_uint16:
return 0xffff - 1;
case NT_uint32:
// We don't actually allow use of the sign bit, since all of our functions
// receive an "int" instead of an "unsigned int".
return 0x7fffffff - 1;
default:
return 0;
}
}
/**
* Returns the index of the indicated type that is reserved for use as a strip
* cut index, if enabled for the primitive. When the renderer encounters this
* index, it will restart the primitive. This is guaranteed not to point to
* an actual vertex.
*/
int GeomPrimitive::
get_strip_cut_index(NumericType index_type) {
// Reserve the highest possible index because implementations use this as a
// strip-cut index.
switch (index_type) {
case NT_uint8:
return 0xff;
case NT_uint16:
return 0xffff;
case NT_uint32:
default:
return -1;
}
}
/**
* Expands min_point and max_point to include all of the vertices in the Geom,
* if any (or the data of any point type, for instance, texture coordinates--
* based on the column name). found_any is set true if any points are found.
* It is the caller's responsibility to initialize min_point, max_point, and
* found_any before calling this function. It also sets sq_center_dist, which
* is the square of the maximum distance of the points to the center. This
* can be useful when deciding whether a sphere volume might be more
* appropriate.
*/
void GeomPrimitive::
calc_tight_bounds(LPoint3 &min_point, LPoint3 &max_point,
PN_stdfloat &sq_center_dist, bool &found_any,
const GeomVertexData *vertex_data,
bool got_mat, const LMatrix4 &mat,
const InternalName *column_name,
Thread *current_thread) const {
GeomVertexReader reader(vertex_data, column_name, current_thread);
if (!reader.has_column()) {
// No vertex data.
return;
}
CDReader cdata(_cycler, current_thread);
int i = 0;
if (cdata->_vertices.is_null()) {
// Nonindexed case.
nassertv(cdata->_num_vertices != -1);
if (cdata->_num_vertices == 0) {
return;
}
if (got_mat) {
// Find the first non-NaN vertex.
while (!found_any && i < cdata->_num_vertices) {
reader.set_row(cdata->_first_vertex + i);
LPoint3 first_vertex = mat.xform_point(reader.get_data3());
if (!first_vertex.is_nan()) {
min_point = first_vertex;
max_point = first_vertex;
sq_center_dist = first_vertex.length_squared();
found_any = true;
}
++i;
}
for (; i < cdata->_num_vertices; ++i) {
reader.set_row_unsafe(cdata->_first_vertex + i);
LPoint3 vertex = mat.xform_point(reader.get_data3());
min_point.set(min(min_point[0], vertex[0]),
min(min_point[1], vertex[1]),
min(min_point[2], vertex[2]));
max_point.set(max(max_point[0], vertex[0]),
max(max_point[1], vertex[1]),
max(max_point[2], vertex[2]));
sq_center_dist = max(sq_center_dist, vertex.length_squared());
}
} else {
// Find the first non-NaN vertex.
while (!found_any && i < cdata->_num_vertices) {
reader.set_row(cdata->_first_vertex + i);
LPoint3 first_vertex = reader.get_data3();
if (!first_vertex.is_nan()) {
min_point = first_vertex;
max_point = first_vertex;
sq_center_dist = first_vertex.length_squared();
found_any = true;
}
++i;
}
for (; i < cdata->_num_vertices; ++i) {
reader.set_row_unsafe(cdata->_first_vertex + i);
const LVecBase3 &vertex = reader.get_data3();
min_point.set(min(min_point[0], vertex[0]),
min(min_point[1], vertex[1]),
min(min_point[2], vertex[2]));
max_point.set(max(max_point[0], vertex[0]),
max(max_point[1], vertex[1]),
max(max_point[2], vertex[2]));
sq_center_dist = max(sq_center_dist, vertex.length_squared());
}
}
} else {
// Indexed case.
GeomVertexReader index(cdata->_vertices.get_read_pointer(), 0, current_thread);
if (index.is_at_end()) {
return;
}
int strip_cut_index = get_strip_cut_index(cdata->_index_type);
if (got_mat) {
// Find the first non-NaN vertex.
while (!found_any && !index.is_at_end()) {
int ii = index.get_data1i();
if (ii != strip_cut_index) {
reader.set_row(ii);
LPoint3 first_vertex = mat.xform_point(reader.get_data3());
if (!first_vertex.is_nan()) {
min_point = first_vertex;
max_point = first_vertex;
sq_center_dist = first_vertex.length_squared();
found_any = true;
}
}
}
while (!index.is_at_end()) {
int ii = index.get_data1i();
if (ii == strip_cut_index) {
continue;
}
reader.set_row_unsafe(ii);
LPoint3 vertex = mat.xform_point(reader.get_data3());
min_point.set(min(min_point[0], vertex[0]),
min(min_point[1], vertex[1]),
min(min_point[2], vertex[2]));
max_point.set(max(max_point[0], vertex[0]),
max(max_point[1], vertex[1]),
max(max_point[2], vertex[2]));
sq_center_dist = max(sq_center_dist, vertex.length_squared());
}
} else {
// Find the first non-NaN vertex.
while (!found_any && !index.is_at_end()) {
int ii = index.get_data1i();
if (ii != strip_cut_index) {
reader.set_row(ii);
LVecBase3 first_vertex = reader.get_data3();
if (!first_vertex.is_nan()) {
min_point = first_vertex;
max_point = first_vertex;
sq_center_dist = first_vertex.length_squared();
found_any = true;
}
}
}
while (!index.is_at_end()) {
int ii = index.get_data1i();
if (ii == strip_cut_index) {
continue;
}
reader.set_row_unsafe(ii);
const LVecBase3 &vertex = reader.get_data3();
min_point.set(min(min_point[0], vertex[0]),
min(min_point[1], vertex[1]),
min(min_point[2], vertex[2]));
max_point.set(max(max_point[0], vertex[0]),
max(max_point[1], vertex[1]),
max(max_point[2], vertex[2]));
sq_center_dist = max(sq_center_dist, vertex.length_squared());
}
}
}
}
/**
* Expands radius so that a sphere with the given center point fits all of the
* vertices.
*
* The center point is assumed to already have been transformed by the matrix,
* if one is given.
*/
void GeomPrimitive::
calc_sphere_radius(const LPoint3 &center, PN_stdfloat &sq_radius,
bool &found_any, const GeomVertexData *vertex_data,
Thread *current_thread) const {
GeomVertexReader reader(vertex_data, InternalName::get_vertex(), current_thread);
if (!reader.has_column()) {
// No vertex data.
return;
}
if (!found_any) {
sq_radius = 0.0;
}
CDReader cdata(_cycler, current_thread);
if (cdata->_vertices.is_null()) {
// Nonindexed case.
nassertv(cdata->_num_vertices != -1);
if (cdata->_num_vertices == 0) {
return;
}
found_any = true;
for (int i = 0; i < cdata->_num_vertices; ++i) {
reader.set_row_unsafe(cdata->_first_vertex + i);
const LVecBase3 &vertex = reader.get_data3();
sq_radius = max(sq_radius, (vertex - center).length_squared());
}
} else {
// Indexed case.
GeomVertexReader index(cdata->_vertices.get_read_pointer(), 0, current_thread);
if (index.is_at_end()) {
return;
}
found_any = true;
int strip_cut_index = get_strip_cut_index(cdata->_index_type);
while (!index.is_at_end()) {
int ii = index.get_data1i();
if (ii == strip_cut_index) {
continue;
}
reader.set_row_unsafe(ii);
const LVecBase3 &vertex = reader.get_data3();
sq_radius = max(sq_radius, (vertex - center).length_squared());
}
}
}
/**
* Decomposes a complex primitive type into a simpler primitive type, for
* instance triangle strips to triangles, and returns a pointer to the new
* primitive definition. If the decomposition cannot be performed, this might
* return the original object.
*
* This method is useful for application code that wants to iterate through
* the set of triangles on the primitive without having to write handlers for
* each possible kind of primitive type.
*/
CPT(GeomPrimitive) GeomPrimitive::
decompose_impl() const {
return this;
}
/**
* The virtual implementation of rotate().
*/
CPT(GeomVertexArrayData) GeomPrimitive::
rotate_impl() const {
// The default implementation doesn't even try to do anything.
nassertr(false, nullptr);
return nullptr;
}
/**
* The virtual implementation of doubleside().
*/
CPT(GeomPrimitive) GeomPrimitive::
doubleside_impl() const {
return this;
}
/**
* The virtual implementation of reverse().
*/
CPT(GeomPrimitive) GeomPrimitive::
reverse_impl() const {
return this;
}
/**
* Should be redefined to return true in any primitive that implements
* append_unused_vertices().
*/
bool GeomPrimitive::
requires_unused_vertices() const {
return false;
}
/**
* Called when a new primitive is begun (other than the first primitive), this
* should add some degenerate vertices between primitives, if the primitive
* type requires that. The second parameter is the first vertex that begins
* the new primitive.
*
* This method is only called if requires_unused_vertices(), above, returns
* true.
*/
void GeomPrimitive::
append_unused_vertices(GeomVertexArrayData *, int) {
}
/**
* Recomputes the _min_vertex and _max_vertex values if necessary.
*/
void GeomPrimitive::
recompute_minmax(GeomPrimitive::CData *cdata) {
if (cdata->_vertices.is_null()) {
// In the nonindexed case, we don't need to do much (the minmax is
// trivial).
nassertv(cdata->_num_vertices != -1);
cdata->_min_vertex = cdata->_first_vertex;
cdata->_max_vertex = cdata->_first_vertex + cdata->_num_vertices - 1;
cdata->_mins.clear();
cdata->_maxs.clear();
} else {
int num_vertices = cdata->_vertices.get_read_pointer()->get_num_rows();
if (num_vertices == 0) {
// Or if we don't have any vertices, the minmax is also trivial.
cdata->_min_vertex = 0;
cdata->_max_vertex = 0;
cdata->_mins.clear();
cdata->_maxs.clear();
} else if (get_num_vertices_per_primitive() == 0) {
// This is a complex primitive type like a triangle strip; compute the
// minmax of each primitive (as well as the overall minmax).
GeomVertexReader index(cdata->_vertices.get_read_pointer(), 0);
cdata->_mins = make_index_data();
cdata->_maxs = make_index_data();
GeomVertexArrayData *mins_data = cdata->_mins.get_write_pointer();
GeomVertexArrayData *maxs_data = cdata->_maxs.get_write_pointer();
mins_data->unclean_set_num_rows(cdata->_ends.size());
maxs_data->unclean_set_num_rows(cdata->_ends.size());
GeomVertexWriter mins(mins_data, 0);
GeomVertexWriter maxs(maxs_data, 0);
int pi = 0;
unsigned int vertex = index.get_data1i();
cdata->_min_vertex = vertex;
cdata->_max_vertex = vertex;
unsigned int min_prim = vertex;
unsigned int max_prim = vertex;
int num_unused_vertices = get_num_unused_vertices_per_primitive();
for (int vi = 1; vi < num_vertices; ++vi) {
nassertv(!index.is_at_end());
nassertv(pi < (int)cdata->_ends.size());
unsigned int vertex;
if (vi == cdata->_ends[pi]) {
// Skip unused vertices, since they won't be very relevant and may
// contain a strip-cut index, which would distort the result.
if (num_unused_vertices > 0) {
vi += num_unused_vertices;
index.set_row_unsafe(vi);
}
vertex = index.get_data1i();
mins.set_data1i(min_prim);
maxs.set_data1i(max_prim);
min_prim = vertex;
max_prim = vertex;
++pi;
} else {
vertex = index.get_data1i();
min_prim = min(min_prim, vertex);
max_prim = max(max_prim, vertex);
}
cdata->_min_vertex = min(cdata->_min_vertex, vertex);
cdata->_max_vertex = max(cdata->_max_vertex, vertex);
}
mins.set_data1i(min_prim);
maxs.set_data1i(max_prim);
nassertv(mins.get_array_data()->get_num_rows() == (int)cdata->_ends.size());
} else {
// This is a simple primitive type like a triangle; just compute the
// overall minmax.
GeomVertexReader index(cdata->_vertices.get_read_pointer(), 0);
cdata->_mins.clear();
cdata->_maxs.clear();
unsigned int vertex = index.get_data1i();
cdata->_min_vertex = vertex;
cdata->_max_vertex = vertex;
for (int vi = 1; vi < num_vertices; ++vi) {
nassertv(!index.is_at_end());
unsigned int vertex = index.get_data1i();
cdata->_min_vertex = min(cdata->_min_vertex, vertex);
cdata->_max_vertex = max(cdata->_max_vertex, vertex);
}
}
}
cdata->_got_minmax = true;
}
/**
* The private implementation of make_indexed().
*/
void GeomPrimitive::
do_make_indexed(CData *cdata) {
if (cdata->_vertices.is_null()) {
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< this << ".make_indexed()\n";
}
nassertv(cdata->_num_vertices != -1);
cdata->_vertices = make_index_data();
GeomVertexArrayData *array_data = cdata->_vertices.get_write_pointer();
array_data->unclean_set_num_rows(cdata->_num_vertices);
GeomVertexWriter index(array_data, 0);
for (int i = 0; i < cdata->_num_vertices; ++i) {
index.set_data1i(i + cdata->_first_vertex);
}
cdata->_num_vertices = -1;
}
}
/**
* If the indicated new vertex index won't fit in the specified index type,
* automatically elevates the index type to the next available size.
*/
void GeomPrimitive::
consider_elevate_index_type(CData *cdata, int vertex) {
// Note that we reserve the highest possible index of a particular index
// type (ie. -1) because this is commonly used as a strip-cut (also known
// as primitive restart) index.
switch (cdata->_index_type) {
case NT_uint8:
if (vertex >= 0xff) {
do_set_index_type(cdata, NT_uint16);
}
break;
case NT_uint16:
if (vertex >= 0xffff) {
do_set_index_type(cdata, NT_uint32);
}
break;
case NT_uint32:
// Not much we can do here.
nassertv(vertex < 0x7fffffff);
break;
default:
break;
}
}
/**
* The private implementation of set_index_type().
*/
void GeomPrimitive::
do_set_index_type(CData *cdata, GeomPrimitive::NumericType index_type) {
int old_strip_cut_index = get_strip_cut_index(cdata->_index_type);
int new_strip_cut_index = get_strip_cut_index(index_type);
cdata->_index_type = index_type;
if (gobj_cat.is_debug()) {
gobj_cat.debug()
<< this << ".set_index_type(" << index_type << ")\n";
}
if (!cdata->_vertices.is_null()) {
CPT(GeomVertexArrayFormat) new_format = get_index_format();
CPT(GeomVertexArrayData) array_obj = cdata->_vertices.get_read_pointer();
if (array_obj->get_array_format() != new_format) {
PT(GeomVertexArrayData) new_vertices = make_index_data();
new_vertices->set_num_rows(array_obj->get_num_rows());
GeomVertexReader from(array_obj, 0);
GeomVertexWriter to(new_vertices, 0);
while (!from.is_at_end()) {
int index = from.get_data1i();
if (index == old_strip_cut_index) {
index = new_strip_cut_index;
}
to.set_data1i(index);
}
cdata->_vertices = new_vertices;
cdata->_got_minmax = false;
}
}
}
/**
* The private implementation of modify_vertices().
*/
PT(GeomVertexArrayData) GeomPrimitive::
do_modify_vertices(GeomPrimitive::CData *cdata) {
if (cdata->_vertices.is_null()) {
do_make_indexed(cdata);
}
PT(GeomVertexArrayData) vertices = cdata->_vertices.get_write_pointer();
cdata->_modified = Geom::get_next_modified();
cdata->_got_minmax = false;
return vertices;
}
/**
* Writes the contents of this object to the datagram for shipping out to a
* Bam file.
*/
void GeomPrimitive::
write_datagram(BamWriter *manager, Datagram &dg) {
TypedWritable::write_datagram(manager, dg);
manager->write_cdata(dg, _cycler);
}
/**
* Called by the BamReader to perform any final actions needed for setting up
* the object after all objects have been read and all pointers have been
* completed.
*/
void GeomPrimitive::
finalize(BamReader *manager) {
const GeomVertexArrayData *vertices = get_vertices();
if (vertices != nullptr) {
set_usage_hint(vertices->get_usage_hint());
}
}
/**
* This internal function is called by make_from_bam to read in all of the
* relevant data from the BamFile for the new GeomPrimitive.
*/
void GeomPrimitive::
fillin(DatagramIterator &scan, BamReader *manager) {
TypedWritable::fillin(scan, manager);
manager->read_cdata(scan, _cycler);
manager->register_finalize(this);
}
/**
*
*/
CycleData *GeomPrimitive::CData::
make_copy() const {
return new CData(*this);
}
/**
* Writes the contents of this object to the datagram for shipping out to a
* Bam file.
*/
void GeomPrimitive::CData::
write_datagram(BamWriter *manager, Datagram &dg) const {
dg.add_uint8(_shade_model);
dg.add_int32(_first_vertex);
dg.add_int32(_num_vertices);
dg.add_uint8(_index_type);
dg.add_uint8(_usage_hint);
manager->write_pointer(dg, _vertices.get_read_pointer());
WRITE_PTA(manager, dg, IPD_int::write_datagram, _ends);
}
/**
* Receives an array of pointers, one for each time manager->read_pointer()
* was called in fillin(). Returns the number of pointers processed.
*/
int GeomPrimitive::CData::
complete_pointers(TypedWritable **p_list, BamReader *manager) {
int pi = CycleData::complete_pointers(p_list, manager);
_vertices = DCAST(GeomVertexArrayData, p_list[pi++]);
if (manager->get_file_minor_ver() < 6 && !_vertices.is_null()) {
// Older bam files might have a meaningless number in _num_vertices if the
// primitive is indexed. Nowadays, this number is always considered
// meaningful unless it is -1.
_num_vertices = -1;
}
return pi;
}
/**
* This internal function is called by make_from_bam to read in all of the
* relevant data from the BamFile for the new GeomPrimitive.
*/
void GeomPrimitive::CData::
fillin(DatagramIterator &scan, BamReader *manager) {
_shade_model = (ShadeModel)scan.get_uint8();
_first_vertex = scan.get_int32();
_num_vertices = scan.get_int32();
_index_type = (NumericType)scan.get_uint8();
_usage_hint = (UsageHint)scan.get_uint8();
manager->read_pointer(scan);
READ_PTA(manager, scan, IPD_int::read_datagram, _ends);
_modified = Geom::get_next_modified();
_got_minmax = false;
}
/**
* Ensures that the primitive's minmax cache has been computed.
*/
void GeomPrimitivePipelineReader::
check_minmax() const {
if (!_cdata->_got_minmax) {
// We'll need to get a fresh pointer, since another thread might already
// have modified the pointer on the object since we queried it.
{
#ifdef DO_PIPELINING
unref_delete((CycleData *)_cdata);
#endif
GeomPrimitive::CDWriter fresh_cdata(((GeomPrimitive *)_object.p())->_cycler,
false, _current_thread);
((GeomPrimitivePipelineReader *)this)->_cdata = fresh_cdata;
#ifdef DO_PIPELINING
_cdata->ref();
#endif
if (!fresh_cdata->_got_minmax) {
// The cache is still stale. We have to do the work of freshening it.
((GeomPrimitive *)_object.p())->recompute_minmax(fresh_cdata);
nassertv(fresh_cdata->_got_minmax);
}
// When fresh_cdata goes out of scope, its write lock is released, and
// _cdata reverts to our usual convention of an unlocked copy of the
// data.
}
}
nassertv(_cdata->_got_minmax);
}
/**
*
*/
int GeomPrimitivePipelineReader::
get_first_vertex() const {
if (_vertices.is_null()) {
return _cdata->_first_vertex;
}
size_t size = _vertices_cdata->_buffer.get_size();
if (size == 0) {
return 0;
}
GeomVertexReader index(_vertices, 0);
return index.get_data1i();
}
/**
* Returns the ith vertex index in the table.
*/
int GeomPrimitivePipelineReader::
get_vertex(int i) const {
if (!_vertices.is_null()) {
// The indexed case.
nassertr(i >= 0 && i < get_num_vertices(), -1);
const unsigned char *ptr = get_read_pointer(true);
switch (_cdata->_index_type) {
case GeomEnums::NT_uint8:
return ((uint8_t *)ptr)[i];
break;
case GeomEnums::NT_uint16:
return ((uint16_t *)ptr)[i];
break;
case GeomEnums::NT_uint32:
return ((uint32_t *)ptr)[i];
break;
default:
nassert_raise("unsupported index type");
return -1;
}
} else {
// The nonindexed case.
return _cdata->_first_vertex + i;
}
}
/**
*
*/
int GeomPrimitivePipelineReader::
get_num_primitives() const {
int num_vertices_per_primitive = _object->get_num_vertices_per_primitive();
if (num_vertices_per_primitive == 0) {
// This is a complex primitive type like a triangle strip: each primitive
// uses a different number of vertices.
return _cdata->_ends.size();
} else {
// This is a simple primitive type like a triangle: each primitive uses
// the same number of vertices.
return (get_num_vertices() / num_vertices_per_primitive);
}
}
/**
* Turns on all the bits corresponding to the vertices that are referenced
* by this GeomPrimitive.
*/
void GeomPrimitivePipelineReader::
get_referenced_vertices(BitArray &bits) const {
int num_vertices = get_num_vertices();
if (is_indexed()) {
int strip_cut_index = get_strip_cut_index();
const unsigned char *ptr = get_read_pointer(true);
switch (get_index_type()) {
case GeomEnums::NT_uint8:
for (int vi = 0; vi < num_vertices; ++vi) {
int index = ((const uint8_t *)ptr)[vi];
if (index != strip_cut_index) {
bits.set_bit(index);
}
}
break;
case GeomEnums::NT_uint16:
for (int vi = 0; vi < num_vertices; ++vi) {
int index = ((const uint16_t *)ptr)[vi];
if (index != strip_cut_index) {
bits.set_bit(index);
}
}
break;
case GeomEnums::NT_uint32:
for (int vi = 0; vi < num_vertices; ++vi) {
int index = ((const uint32_t *)ptr)[vi];
if (index != strip_cut_index) {
bits.set_bit(index);
}
}
break;
default:
nassert_raise("unsupported index type");
break;
}
} else {
// Nonindexed case.
bits.set_range(get_first_vertex(), num_vertices);
}
}
/**
*
*/
bool GeomPrimitivePipelineReader::
check_valid(const GeomVertexDataPipelineReader *data_reader) const {
if (get_num_vertices() != 0 &&
data_reader->get_num_arrays() > 0 &&
get_max_vertex() >= data_reader->get_num_rows()) {
#ifndef NDEBUG
gobj_cat.error()
<< get_object()->get_type() << " references vertices up to "
<< get_max_vertex() << ", but GeomVertexData has only "
<< data_reader->get_num_rows() << " rows!\n";
#endif
return false;
}
return true;
}
Reference in New Issue View Git Blame Copy Permalink