251 lines
8.4 KiB
C++
251 lines
8.4 KiB
C++
/**
|
|
* 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 sceneGraphAnalyzerMeter.cxx
|
|
* @author pratt
|
|
* @date 2007-02-14
|
|
*/
|
|
|
|
#include "sceneGraphAnalyzerMeter.h"
|
|
#include "camera.h"
|
|
#include "displayRegion.h"
|
|
#include "orthographicLens.h"
|
|
#include "config_grutil.h"
|
|
#include "depthTestAttrib.h"
|
|
#include "depthWriteAttrib.h"
|
|
#include "pStatTimer.h"
|
|
#include "omniBoundingVolume.h"
|
|
#include <stdio.h> // For sprintf/snprintf
|
|
|
|
PStatCollector SceneGraphAnalyzerMeter::_show_analyzer_pcollector("*:Show scene graph analysis");
|
|
|
|
TypeHandle SceneGraphAnalyzerMeter::_type_handle;
|
|
|
|
/**
|
|
*
|
|
*/
|
|
SceneGraphAnalyzerMeter::
|
|
SceneGraphAnalyzerMeter(const std::string &name, PandaNode *node) :
|
|
TextNode(name),
|
|
_last_aspect_ratio(-1) {
|
|
|
|
set_cull_callback();
|
|
|
|
// Don't do frustum culling, as the text will always be in view.
|
|
set_bounds(new OmniBoundingVolume());
|
|
set_final(true);
|
|
|
|
Thread *current_thread = Thread::get_current_thread();
|
|
|
|
_update_interval = scene_graph_analyzer_meter_update_interval;
|
|
_last_update = 0.0f;
|
|
_node = node;
|
|
_clock_object = ClockObject::get_global_clock();
|
|
|
|
set_align(A_left);
|
|
set_transform(LMatrix4::scale_mat(scene_graph_analyzer_meter_scale) *
|
|
LMatrix4::translate_mat(LVector3::rfu(scene_graph_analyzer_meter_side_margins * scene_graph_analyzer_meter_scale, 0.0f, -scene_graph_analyzer_meter_scale)));
|
|
set_card_color(0.0f, 0.0f, 0.0f, 0.4);
|
|
set_card_as_margin(scene_graph_analyzer_meter_side_margins, scene_graph_analyzer_meter_side_margins, 0.1f, 0.0f);
|
|
set_usage_hint(Geom::UH_client);
|
|
|
|
do_update(current_thread);
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
SceneGraphAnalyzerMeter::
|
|
~SceneGraphAnalyzerMeter() {
|
|
clear_window();
|
|
}
|
|
|
|
/**
|
|
* Sets up the frame rate meter to create a DisplayRegion to render itself
|
|
* into the indicated window.
|
|
*/
|
|
void SceneGraphAnalyzerMeter::
|
|
setup_window(GraphicsOutput *window) {
|
|
clear_window();
|
|
|
|
_window = window;
|
|
|
|
_root = NodePath("scene_graph_analyzer_root");
|
|
_root.attach_new_node(this);
|
|
|
|
CPT(RenderAttrib) dt = DepthTestAttrib::make(DepthTestAttrib::M_none);
|
|
CPT(RenderAttrib) dw = DepthWriteAttrib::make(DepthWriteAttrib::M_off);
|
|
_root.node()->set_attrib(dt, 1);
|
|
_root.node()->set_attrib(dw, 1);
|
|
_root.set_material_off(1);
|
|
_root.set_two_sided(1, 1);
|
|
|
|
// If we don't set this explicitly, Panda will cause it to be rendered
|
|
// in a back-to-front cull bin, which will cause the bounding volume
|
|
// to be computed unnecessarily. Saves a little bit of overhead.
|
|
_root.set_bin("unsorted", 0);
|
|
|
|
// Create a display region that covers the entire window.
|
|
_display_region = _window->make_display_region();
|
|
_display_region->set_sort(scene_graph_analyzer_meter_layer_sort);
|
|
|
|
// Finally, we need a camera to associate with the display region.
|
|
PT(Camera) camera = new Camera("scene_graph_analyzer_camera");
|
|
NodePath camera_np = _root.attach_new_node(camera);
|
|
|
|
PT(Lens) lens = new OrthographicLens;
|
|
|
|
// We choose these values such that we can place the text against (0, 0).
|
|
static const PN_stdfloat left = 0.0f;
|
|
static const PN_stdfloat right = 2.0f;
|
|
static const PN_stdfloat bottom = -2.0f;
|
|
static const PN_stdfloat top = 0.0f;
|
|
lens->set_film_size(right - left, top - bottom);
|
|
lens->set_film_offset((right + left) * 0.5, (top + bottom) * 0.5);
|
|
lens->set_near_far(-1000, 1000);
|
|
|
|
camera->set_lens(lens);
|
|
camera->set_scene(_root);
|
|
_display_region->set_camera(camera_np);
|
|
}
|
|
|
|
/**
|
|
* Undoes the effect of a previous call to setup_window().
|
|
*/
|
|
void SceneGraphAnalyzerMeter::
|
|
clear_window() {
|
|
if (_window != nullptr) {
|
|
_window->remove_display_region(_display_region);
|
|
_window = nullptr;
|
|
_display_region = nullptr;
|
|
}
|
|
_root = NodePath();
|
|
}
|
|
|
|
/**
|
|
* This function will be called during the cull traversal to perform any
|
|
* additional operations that should be performed at cull time. This may
|
|
* include additional manipulation of render state or additional
|
|
* visible/invisible decisions, or any other arbitrary operation.
|
|
*
|
|
* Note that this function will *not* be called unless set_cull_callback() is
|
|
* called in the constructor of the derived class. It is necessary to call
|
|
* set_cull_callback() to indicated that we require cull_callback() to be
|
|
* called.
|
|
*
|
|
* By the time this function is called, the node has already passed the
|
|
* bounding-volume test for the viewing frustum, and the node's transform and
|
|
* state have already been applied to the indicated CullTraverserData object.
|
|
*
|
|
* The return value is true if this node should be visible, or false if it
|
|
* should be culled.
|
|
*/
|
|
bool SceneGraphAnalyzerMeter::
|
|
cull_callback(CullTraverser *trav, CullTraverserData &data) {
|
|
Thread *current_thread = trav->get_current_thread();
|
|
|
|
// Statistics
|
|
PStatTimer timer(_show_analyzer_pcollector, current_thread);
|
|
|
|
// This is probably a good time to check if the aspect ratio on the window
|
|
// has changed.
|
|
int width = _display_region->get_pixel_width();
|
|
int height = _display_region->get_pixel_height();
|
|
PN_stdfloat aspect_ratio = 1;
|
|
if (width != 0 && height != 0) {
|
|
aspect_ratio = (PN_stdfloat)height / (PN_stdfloat)width;
|
|
}
|
|
|
|
// Scale the transform by the calculated aspect ratio.
|
|
if (aspect_ratio != _last_aspect_ratio) {
|
|
_aspect_ratio_transform = TransformState::make_scale(LVecBase3(aspect_ratio, 1, 1));
|
|
_last_aspect_ratio = aspect_ratio;
|
|
}
|
|
data._net_transform = data._net_transform->compose(_aspect_ratio_transform);
|
|
|
|
// Check to see if it's time to update.
|
|
double now = _clock_object->get_frame_time(current_thread);
|
|
double elapsed = now - _last_update;
|
|
if (elapsed < 0.0 || elapsed >= _update_interval) {
|
|
do_update(current_thread);
|
|
}
|
|
|
|
return TextNode::cull_callback(trav, data);
|
|
}
|
|
|
|
/**
|
|
* Resets the text according to the current frame rate.
|
|
*/
|
|
void SceneGraphAnalyzerMeter::
|
|
do_update(Thread *current_thread) {
|
|
_last_update = _clock_object->get_frame_time(current_thread);
|
|
|
|
_scene_graph_analyzer.clear();
|
|
_scene_graph_analyzer.add_node( _node );
|
|
|
|
static const size_t buffer_size = 1024;
|
|
char buffer[buffer_size];
|
|
|
|
const char *pattern = "Nodes: %d\n"
|
|
"Instances: %d\n"
|
|
"Transforms: %d\n"
|
|
"Nodes with Attribs: %d\n"
|
|
"GeomNodes: %d\n"
|
|
"Geoms: %d\n"
|
|
"GeomVertexDatas: %d\n"
|
|
"Vertices: %d\n"
|
|
"Normals: %d\n"
|
|
"TexCoords: %d\n"
|
|
"Tris: %d\n"
|
|
"Lines: %d\n"
|
|
"Points: %d\n"
|
|
"Texture memory: %.1f KB\n";
|
|
|
|
#ifdef _WIN32
|
|
_snprintf(buffer, buffer_size, pattern,
|
|
_scene_graph_analyzer.get_num_nodes(),
|
|
_scene_graph_analyzer.get_num_instances(),
|
|
_scene_graph_analyzer.get_num_transforms(),
|
|
_scene_graph_analyzer.get_num_nodes_with_attribs(),
|
|
_scene_graph_analyzer.get_num_geom_nodes(),
|
|
_scene_graph_analyzer.get_num_geoms(),
|
|
_scene_graph_analyzer.get_num_geom_vertex_datas(),
|
|
_scene_graph_analyzer.get_num_vertices(),
|
|
_scene_graph_analyzer.get_num_normals(),
|
|
_scene_graph_analyzer.get_num_texcoords(),
|
|
_scene_graph_analyzer.get_num_tris(),
|
|
_scene_graph_analyzer.get_num_lines(),
|
|
_scene_graph_analyzer.get_num_points(),
|
|
_scene_graph_analyzer.get_texture_bytes()/1024.0);
|
|
#else
|
|
snprintf(buffer, buffer_size, pattern,
|
|
_scene_graph_analyzer.get_num_nodes(),
|
|
_scene_graph_analyzer.get_num_instances(),
|
|
_scene_graph_analyzer.get_num_transforms(),
|
|
_scene_graph_analyzer.get_num_nodes_with_attribs(),
|
|
_scene_graph_analyzer.get_num_geom_nodes(),
|
|
_scene_graph_analyzer.get_num_geoms(),
|
|
_scene_graph_analyzer.get_num_geom_vertex_datas(),
|
|
_scene_graph_analyzer.get_num_vertices(),
|
|
_scene_graph_analyzer.get_num_normals(),
|
|
_scene_graph_analyzer.get_num_texcoords(),
|
|
_scene_graph_analyzer.get_num_tris(),
|
|
_scene_graph_analyzer.get_num_lines(),
|
|
_scene_graph_analyzer.get_num_points(),
|
|
_scene_graph_analyzer.get_texture_bytes()/1024.0);
|
|
#endif
|
|
nassertv(strlen(buffer) < buffer_size);
|
|
|
|
if (get_text() == buffer) {
|
|
// Never mind; the data hasn't changed.
|
|
return;
|
|
}
|
|
|
|
set_text(buffer);
|
|
}
|