TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-10-03 10:22:45 -04:00
Code Issues Packages Projects Releases Wiki Activity

compute _net_transform, not _modelview_transform, at each node of cull traversal

Browse Source
This commit is contained in:
David Rose 2006-03-24 23:41:09 +00:00
parent c8633086c3
commit ffb676cc9a
16 changed files with 87 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
panda/src/collide/collisionNode.cxx
View File

@ -250,8 +250,8 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
if (node != (PandaNode *)NULL) {
CullTraverserData next_data(data, node);
next_data._modelview_transform =
next_data._modelview_transform->compose(transform);
next_data._net_transform =
next_data._net_transform->compose(transform);
next_data._state = get_last_pos_state();
trav->traverse(next_data);
}

10
panda/src/collide/collisionVisualizer.cxx
View File

@ -135,7 +135,7 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
// whatever transforms were above the CollisionVisualizer node; it
// always renders its objects according to their appropriate net
// transform.
xform_data._modelview_transform = trav->get_world_transform();
xform_data._net_transform = TransformState::make_identity();
xform_data.apply_transform_and_state(trav, net_transform,
RenderState::make_empty(),
RenderEffects::make_empty(),
@ -212,7 +212,9 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
geom->add_primitive(points);
CullableObject *object =
new CullableObject(geom, point_state, xform_data._modelview_transform);
new CullableObject(geom, point_state,
xform_data.get_net_transform(trav),
xform_data.get_modelview_transform(trav));
trav->get_cull_handler()->record_object(object, trav);
}
@ -240,7 +242,9 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
geom->add_primitive(lines);
CullableObject *object =
new CullableObject(geom, empty_state, xform_data._modelview_transform);
new CullableObject(geom, empty_state,
xform_data.get_net_transform(trav),
xform_data.get_modelview_transform(trav));
trav->get_cull_handler()->record_object(object, trav);
}

8
panda/src/display/graphicsEngine.cxx
View File

@ -529,6 +529,13 @@ render_frame() {
}
#endif
ClockObject *global_clock = ClockObject::get_global_clock();
if (display_cat.is_spam()) {
display_cat.spam()
<< "render_frame() - frame " << global_clock->get_frame_count() << "\n";
}
// We hold the GraphicsEngine mutex while we wait for all of the
// threads. Doing this puts us at risk for deadlock if any of the
// threads tries to call any methods on the GraphicsEngine. So
@ -621,7 +628,6 @@ render_frame() {
}
#endif // THREADED_PIPELINE
ClockObject *global_clock = ClockObject::get_global_clock();
global_clock->tick();
if (global_clock->check_errors()) {
throw_event("clock_error");

16
panda/src/parametrics/ropeNode.cxx
View File

@ -362,7 +362,8 @@ render_thread(CullTraverser *trav, CullTraverserData &data,
CPT(RenderState) state = data._state->add_attrib(thick);
CullableObject *object = new CullableObject(geom, state,
data._modelview_transform);
data.get_net_transform(trav),
data.get_modelview_transform(trav));
trav->get_cull_handler()->record_object(object, trav);
}
@ -404,7 +405,8 @@ render_tape(CullTraverser *trav, CullTraverserData &data,
geom->add_primitive(strip);
CullableObject *object = new CullableObject(geom, data._state,
data._modelview_transform);
data.get_net_transform(trav),
data.get_modelview_transform(trav));
trav->get_cull_handler()->record_object(object, trav);
}
@ -421,11 +423,11 @@ render_tape(CullTraverser *trav, CullTraverserData &data,
void RopeNode::
render_billboard(CullTraverser *trav, CullTraverserData &data,
NurbsCurveResult *result) const {
const TransformState *net_transform = data._modelview_transform;
const TransformState *modelview_transform = data.get_modelview_transform(trav);
const TransformState *camera_transform = trav->get_camera_transform();
CPT(TransformState) rel_transform =
net_transform->invert_compose(camera_transform);
modelview_transform->invert_compose(camera_transform);
LVector3f camera_vec = LVector3f::forward() * rel_transform->get_mat();
CurveSegments curve_segments;
@ -453,7 +455,8 @@ render_billboard(CullTraverser *trav, CullTraverserData &data,
geom->add_primitive(strip);
CullableObject *object = new CullableObject(geom, data._state,
data._modelview_transform);
data.get_net_transform(trav),
data.get_modelview_transform(trav));
trav->get_cull_handler()->record_object(object, trav);
}
@ -509,7 +512,8 @@ render_tube(CullTraverser *trav, CullTraverserData &data,
geom->add_primitive(strip);
CullableObject *object = new CullableObject(geom, data._state,
data._modelview_transform);
data.get_net_transform(trav),
data.get_modelview_transform(trav));
trav->get_cull_handler()->record_object(object, trav);
}

3
panda/src/parametrics/sheetNode.cxx
View File

@ -335,7 +335,8 @@ render_sheet(CullTraverser *trav, CullTraverserData &data,
geom->add_primitive(strip);
CullableObject *object = new CullableObject(geom, data._state,
data._modelview_transform);
data.get_net_transform(trav),
data.get_modelview_transform(trav));
trav->get_cull_handler()->record_object(object, trav);
}

8
panda/src/pgraph/billboardEffect.cxx
View File

@ -147,13 +147,13 @@ void BillboardEffect::
cull_callback(CullTraverser *trav, CullTraverserData &data,
CPT(TransformState) &node_transform,
CPT(RenderState) &) const {
CPT(TransformState) net_transform = data._modelview_transform;
if (net_transform->is_singular()) {
CPT(TransformState) modelview_transform = data.get_modelview_transform(trav);
if (modelview_transform->is_singular()) {
// If we're under a singular transform, never mind.
return;
}
// Since the "net" transform from the cull traverser already
// Since the "modelview" transform from the cull traverser already
// includes the inverse camera transform, the camera transform is
// identity.
CPT(TransformState) camera_transform = TransformState::make_identity();
@ -164,7 +164,7 @@ cull_callback(CullTraverser *trav, CullTraverserData &data,
camera_transform = trav->get_camera_transform()->invert_compose(_look_at.get_net_transform());
}
compute_billboard(node_transform, net_transform, camera_transform);
compute_billboard(node_transform, modelview_transform, camera_transform);
}
////////////////////////////////////////////////////////////////////

6
panda/src/pgraph/cullTraverser.I
View File

@ -97,9 +97,9 @@ get_camera_transform() const {
//
// Note that this value is always the position of the
// starting node, not the current node, even if it is
// sampled during a traversal. To get the world
// transform of the current node use
// CullTraverserData::_net_transform.
// sampled during a traversal. To get the transform of
// the current node use
// CullTraverserData::get_modelview_transform().
////////////////////////////////////////////////////////////////////
INLINE const TransformState *CullTraverser::
get_world_transform() const {

21
panda/src/pgraph/cullTraverser.cxx
View File

@ -110,7 +110,7 @@ traverse(const NodePath &root, bool python_cull_control) {
// store this pointer in this
set_portal_clipper(&portal_viewer);
CullTraverserData data(root, get_world_transform(),
CullTraverserData data(root, TransformState::make_identity(),
_initial_state, _view_frustum,
_guard_band);
@ -124,11 +124,11 @@ traverse(const NodePath &root, bool python_cull_control) {
CPT(TransformState) transform = cull_center.get_transform(root);
CullTraverserData my_data(data, portal_viewer._previous);
my_data._modelview_transform = my_data._modelview_transform->compose(transform);
my_data._net_transform = my_data._net_transform->compose(transform);
traverse(my_data);
} else {
CullTraverserData data(root, get_world_transform(),
CullTraverserData data(root, TransformState::make_identity(),
_initial_state, _view_frustum,
_guard_band);
@ -223,7 +223,7 @@ traverse_below(CullTraverserData &data) {
int num_geoms = geom_node->get_num_geoms();
_geoms_pcollector.add_level(num_geoms);
for (int i = 0; i < num_geoms; i++) {
CullableObject *object = new CullableObject(data, geom_node, i);
CullableObject *object = new CullableObject(this, data, geom_node, i);
if (object->_state->has_cull_callback() &&
!object->_state->cull_callback(this, data)) {
delete object;
@ -286,7 +286,8 @@ show_bounds(CullTraverserData &data, bool tight) {
_geoms_pcollector.add_level(1);
CullableObject *outer_viz =
new CullableObject(bounds_viz, get_bounds_outer_viz_state(),
data._modelview_transform);
data.get_net_transform(this),
data.get_modelview_transform(this));
_cull_handler->record_object(outer_viz, this);
}
@ -297,12 +298,14 @@ show_bounds(CullTraverserData &data, bool tight) {
_geoms_pcollector.add_level(2);
CullableObject *outer_viz =
new CullableObject(bounds_viz, get_bounds_outer_viz_state(),
data._modelview_transform);
data.get_net_transform(this),
data.get_modelview_transform(this));
_cull_handler->record_object(outer_viz, this);
CullableObject *inner_viz =
new CullableObject(bounds_viz, get_bounds_inner_viz_state(),
data._modelview_transform);
data.get_net_transform(this),
data.get_modelview_transform(this));
_cull_handler->record_object(inner_viz, this);
}
}
@ -549,7 +552,7 @@ start_decal(const CullTraverserData &data) {
_geoms_pcollector.add_level(num_geoms);
for (int i = num_geoms - 1; i >= 0; i--) {
CullableObject *next_object =
new CullableObject(data, geom_node, i, object);
new CullableObject(this, data, geom_node, i, object);
if (next_object->_state->has_cull_callback() &&
!next_object->_state->cull_callback(this, data)) {
next_object->_next = NULL;
@ -618,7 +621,7 @@ r_get_decals(CullTraverserData &data, CullableObject *decals) {
_geoms_pcollector.add_level(num_geoms);
for (int i = num_geoms - 1; i >= 0; i--) {
CullableObject *next_decals =
new CullableObject(data, geom_node, i, decals);
new CullableObject(this, data, geom_node, i, decals);
if (next_decals->_state->has_cull_callback() &&
!next_decals->_state->cull_callback(this, data)) {
next_decals->_next = NULL;

20
panda/src/pgraph/cullTraverserData.I
View File

@ -23,12 +23,12 @@
////////////////////////////////////////////////////////////////////
INLINE CullTraverserData::
CullTraverserData(const NodePath &start,
const TransformState *modelview_transform,
const TransformState *net_transform,
const RenderState *state,
GeometricBoundingVolume *view_frustum,
GeometricBoundingVolume *guard_band) :
_node_path(start),
_modelview_transform(modelview_transform),
_net_transform(net_transform),
_state(state),
_view_frustum(view_frustum),
_guard_band(guard_band),
@ -45,7 +45,7 @@ CullTraverserData(const NodePath &start,
INLINE CullTraverserData::
CullTraverserData(const CullTraverserData &copy) :
_node_path(copy._node_path),
_modelview_transform(copy._modelview_transform),
_net_transform(copy._net_transform),
_state(copy._state),
_view_frustum(copy._view_frustum),
_guard_band(copy._guard_band),
@ -62,7 +62,7 @@ CullTraverserData(const CullTraverserData &copy) :
INLINE void CullTraverserData::
operator = (const CullTraverserData &copy) {
_node_path = copy._node_path;
_modelview_transform = copy._modelview_transform;
_net_transform = copy._net_transform;
_state = copy._state;
_view_frustum = copy._view_frustum;
_guard_band = copy._guard_band;
@ -79,7 +79,7 @@ operator = (const CullTraverserData &copy) {
INLINE CullTraverserData::
CullTraverserData(const CullTraverserData &parent, PandaNode *child) :
_node_path(parent._node_path, child),
_modelview_transform(parent._modelview_transform),
_net_transform(parent._net_transform),
_state(parent._state),
_view_frustum(parent._view_frustum),
_guard_band(parent._guard_band),
@ -108,14 +108,14 @@ node() const {
}
////////////////////////////////////////////////////////////////////
// Function: CullTraverserData::get_modelview_transform
// Function: CullTraverserData::get_net_transform
// Access: Public
// Description: Returns the modelview transform: the relative
// transform from the camera to the model.
// Description: Returns the net transform: the relative transform
// from root of the scene graph to the current node.
////////////////////////////////////////////////////////////////////
INLINE const TransformState *CullTraverserData::
get_modelview_transform() const {
return _modelview_transform;
get_net_transform(const CullTraverser *) const {
return _net_transform;
}
////////////////////////////////////////////////////////////////////

12
panda/src/pgraph/cullTraverserData.cxx
View File

@ -32,14 +32,14 @@
////////////////////////////////////////////////////////////////////
// Function: CullTraverserData::get_net_transform
// Function: CullTraverserData::get_modelview_transform
// Access: Public
// Description: Returns the net transform: the relative
// transform from the root of the scene to the model.
// Description: Returns the modelview transform: the relative
// transform from the camera to the model.
////////////////////////////////////////////////////////////////////
CPT(TransformState) CullTraverserData::
get_net_transform(const CullTraverser *trav) const {
return trav->get_camera_transform()->compose(_modelview_transform);
get_modelview_transform(const CullTraverser *trav) const {
return trav->get_world_transform()->compose(_net_transform);
}
////////////////////////////////////////////////////////////////////
@ -87,7 +87,7 @@ apply_transform_and_state(CullTraverser *trav,
}
if (!node_transform->is_identity()) {
_modelview_transform = _modelview_transform->compose(node_transform);
_net_transform = _net_transform->compose(node_transform);
if ((_view_frustum != (GeometricBoundingVolume *)NULL) ||
(_guard_band != (GeometricBoundingVolume *)NULL) ||

8
panda/src/pgraph/cullTraverserData.h
View File

@ -48,7 +48,7 @@ class PandaNode;
class EXPCL_PANDA CullTraverserData {
public:
INLINE CullTraverserData(const NodePath &start,
const TransformState *modelview_transform,
const TransformState *net_transform,
const RenderState *state,
GeometricBoundingVolume *view_frustum,
GeometricBoundingVolume *guard_band);
@ -60,8 +60,8 @@ public:
INLINE PandaNode *node() const;
INLINE const TransformState *get_modelview_transform() const;
CPT(TransformState) get_net_transform(const CullTraverser *trav) const;
CPT(TransformState) get_modelview_transform(const CullTraverser *trav) const;
INLINE const TransformState *get_net_transform(const CullTraverser *trav) const;
INLINE bool is_in_view(const DrawMask &camera_mask);
INLINE bool is_this_node_hidden(const CullTraverser *trav) const;
@ -74,7 +74,7 @@ public:
const RenderAttrib *off_clip_planes);
WorkingNodePath _node_path;
CPT(TransformState) _modelview_transform;
CPT(TransformState) _net_transform;
CPT(RenderState) _state;
PT(GeometricBoundingVolume) _view_frustum;
PT(GeometricBoundingVolume) _guard_band;

9
panda/src/pgraph/cullableObject.I
View File

@ -36,12 +36,13 @@ CullableObject(CullableObject *next) :
// the indicated CullTraverserData.
////////////////////////////////////////////////////////////////////
INLINE CullableObject::
CullableObject(const CullTraverserData &data,
CullableObject(const CullTraverser *trav, const CullTraverserData &data,
GeomNode *geom_node, int i,
CullableObject *next) :
_geom(geom_node->get_geom(i)),
_state(data._state->compose(geom_node->get_geom_state(i))),
_modelview_transform(data._modelview_transform),
_net_transform(data.get_net_transform(trav)),
_modelview_transform(data.get_modelview_transform(trav)),
_next(next)
{
}
@ -54,10 +55,12 @@ CullableObject(const CullTraverserData &data,
////////////////////////////////////////////////////////////////////
INLINE CullableObject::
CullableObject(const Geom *geom, const RenderState *state,
const TransformState *net_transform,
const TransformState *modelview_transform,
CullableObject *next) :
_geom(geom),
_state(state),
_net_transform(net_transform),
_modelview_transform(modelview_transform),
_next(next)
{
@ -74,6 +77,7 @@ INLINE CullableObject::
CullableObject(const CullableObject &copy) :
_geom(copy._geom),
_state(copy._state),
_net_transform(copy._net_transform),
_modelview_transform(copy._modelview_transform),
_next((CullableObject *)NULL)
{
@ -89,6 +93,7 @@ INLINE void CullableObject::
operator = (const CullableObject &copy) {
_geom = copy._geom;
_state = copy._state;
_net_transform = copy._net_transform;
_modelview_transform = copy._modelview_transform;
}

6
panda/src/pgraph/cullableObject.cxx
View File

@ -479,13 +479,15 @@ void CullableObject::
munge_texcoord_light_vector(const CullTraverser *traverser) {
PStatTimer timer(_munge_light_vector_pcollector);
if (_modelview_transform->is_singular()) {
if (_net_transform->is_singular()) {
// If we're under a singular transform, never mind.
return;
}
/*
CPT(TransformState) net_transform =
traverser->get_camera_transform()->compose(_modelview_transform);
*/
if (!_munged_data->has_column(InternalName::get_vertex()) ||
!_munged_data->has_column(InternalName::get_normal())) {
@ -544,7 +546,7 @@ munge_texcoord_light_vector(const CullTraverser *traverser) {
// Get the transform from the light to the object.
CPT(TransformState) light_transform =
net_transform->invert_compose(light.get_net_transform());
_net_transform->invert_compose(light.get_net_transform());
const LMatrix4f &light_mat = light_transform->get_mat();
GeomVertexWriter texcoord(new_data, texcoord_name);

5
panda/src/pgraph/cullableObject.h
View File

@ -45,10 +45,12 @@ class CullTraverser;
class EXPCL_PANDA CullableObject {
public:
INLINE CullableObject(CullableObject *next = NULL);
INLINE CullableObject(const CullTraverserData &data,
INLINE CullableObject(const CullTraverser *trav,
const CullTraverserData &data,
GeomNode *geom_node, int i,
CullableObject *next = NULL);
INLINE CullableObject(const Geom *geom, const RenderState *state,
const TransformState *net_transform,
const TransformState *modelview_transform,
CullableObject *next = NULL);
@ -80,6 +82,7 @@ public:
PT(GeomMunger) _munger;
CPT(GeomVertexData) _munged_data;
CPT(RenderState) _state;
CPT(TransformState) _net_transform;
CPT(TransformState) _modelview_transform;
CullableObject *_next;

4
panda/src/pgraph/lodNode.cxx
View File

@ -244,7 +244,7 @@ is_lod_node() const {
////////////////////////////////////////////////////////////////////
int LODNode::
compute_child(CullTraverser *trav, CullTraverserData &data) {
if (data._modelview_transform->is_singular()) {
if (data.get_net_transform(trav)->is_singular()) {
// If we're under a singular transform, we can't compute the LOD;
// select none of them instead.
return -1;
@ -264,7 +264,7 @@ compute_child(CullTraverser *trav, CullTraverserData &data) {
// trav->get_scene()->get_cull_center().get_net_transform()->
// invert_compose(data._net_transform);
CPT(TransformState) rel_transform = data._modelview_transform;
CPT(TransformState) rel_transform = data.get_modelview_transform(trav);
LPoint3f center = cdata->_center * rel_transform->get_mat();
// Determine which child to traverse

5
panda/src/pgraph/planeNode.cxx
View File

@ -176,7 +176,8 @@ cull_callback(CullTraverser *trav, CullTraverserData &data) {
CullableObject *plane_viz =
new CullableObject(get_viz(trav, data), data._state,
data._modelview_transform);
data.get_net_transform(trav),
data.get_modelview_transform(trav));
trav->get_cull_handler()->record_object(plane_viz, trav);
// Now carry on to render our child nodes.
@ -225,7 +226,7 @@ get_viz(CullTraverser *trav, CullTraverserData &data) {
// Figure out whether we are looking at the front or the back of the
// plane.
const Lens *lens = trav->get_scene()->get_lens();
Planef eye_plane = cdata->_plane * data._modelview_transform->get_mat();
Planef eye_plane = cdata->_plane * data.get_modelview_transform(trav)->get_mat();
bool front = (eye_plane.dist_to_plane(lens->get_nodal_point()) >= 0.0f);
if (cdata->_front_viz != (Geom *)NULL) {