253 lines
7.4 KiB
Text
253 lines
7.4 KiB
Text
/**
|
|
* 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 drawableRegion.I
|
|
* @author drose
|
|
* @date 2002-07-11
|
|
*/
|
|
|
|
/**
|
|
*
|
|
*/
|
|
INLINE DrawableRegion::
|
|
DrawableRegion() :
|
|
_screenshot_buffer_type(RenderBuffer::T_front),
|
|
_draw_buffer_type(RenderBuffer::T_back),
|
|
_clear_mask(0)
|
|
{
|
|
for (int i = 0; i < RTP_COUNT; ++i) {
|
|
_clear_value[i] = LColor(0.0f, 0.0f, 0.0f, 0.0f);
|
|
}
|
|
_clear_value[RTP_depth] = LColor(1.0f,1.0f,1.0f,1.0f);
|
|
_pixel_zoom = 1.0f;
|
|
_pixel_factor = 1.0f;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
INLINE DrawableRegion::
|
|
DrawableRegion(const DrawableRegion ©) :
|
|
_screenshot_buffer_type(copy._screenshot_buffer_type),
|
|
_draw_buffer_type(copy._draw_buffer_type),
|
|
_clear_mask(copy._clear_mask),
|
|
_pixel_zoom(copy._pixel_zoom),
|
|
_pixel_factor(copy._pixel_factor)
|
|
{
|
|
for (int i = 0; i < RTP_COUNT; ++i) {
|
|
_clear_value[i] = copy._clear_value[i];
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
INLINE void DrawableRegion::
|
|
operator = (const DrawableRegion ©) {
|
|
_screenshot_buffer_type = copy._screenshot_buffer_type;
|
|
_draw_buffer_type = copy._draw_buffer_type;
|
|
_clear_mask = copy._clear_mask;
|
|
for (int i = 0; i < RTP_COUNT; ++i) {
|
|
_clear_value[i] = copy._clear_value[i];
|
|
}
|
|
_pixel_zoom = copy._pixel_zoom;
|
|
_pixel_factor = copy._pixel_factor;
|
|
}
|
|
|
|
/**
|
|
* Copies only the clear settings from the other drawable region.
|
|
*/
|
|
INLINE void DrawableRegion::
|
|
copy_clear_settings(const DrawableRegion ©) {
|
|
_clear_mask = copy._clear_mask;
|
|
for (int i = 0; i < RTP_COUNT; ++i) {
|
|
_clear_value[i] = copy._clear_value[i];
|
|
}
|
|
update_pixel_factor();
|
|
}
|
|
|
|
/**
|
|
* Toggles the flag that indicates whether the color buffer should be cleared
|
|
* every frame. If this is true, the color buffer will be cleared to the
|
|
* color indicated by set_clear_color(); otherwise, it will be left alone.
|
|
*/
|
|
INLINE void DrawableRegion::
|
|
set_clear_color_active(bool clear_color_active) {
|
|
set_clear_active(RTP_color, clear_color_active);
|
|
}
|
|
|
|
/**
|
|
* Returns the current setting of the flag that indicates whether the color
|
|
* buffer should be cleared every frame. See set_clear_color_active().
|
|
*/
|
|
INLINE bool DrawableRegion::
|
|
get_clear_color_active() const {
|
|
return get_clear_active(RTP_color);
|
|
}
|
|
|
|
/**
|
|
* Toggles the flag that indicates whether the depth buffer should be cleared
|
|
* every frame. If this is true, the depth buffer will be cleared to the
|
|
* depth value indicated by set_clear_depth(); otherwise, it will be left
|
|
* alone.
|
|
*/
|
|
INLINE void DrawableRegion::
|
|
set_clear_depth_active(bool clear_depth_active) {
|
|
set_clear_active(RTP_depth, clear_depth_active);
|
|
}
|
|
|
|
/**
|
|
* Returns the current setting of the flag that indicates whether the depth
|
|
* buffer should be cleared every frame. See set_clear_depth_active().
|
|
*/
|
|
INLINE bool DrawableRegion::
|
|
get_clear_depth_active() const {
|
|
return get_clear_active(RTP_depth);
|
|
}
|
|
|
|
/**
|
|
* Toggles the flag that indicates whether the stencil buffer should be
|
|
* cleared every frame. If this is true, the stencil buffer will be cleared
|
|
* to the value indicated by set_clear_stencil(); otherwise, it will be left
|
|
* alone.
|
|
*/
|
|
INLINE void DrawableRegion::
|
|
set_clear_stencil_active(bool clear_stencil_active) {
|
|
set_clear_active(RTP_stencil, clear_stencil_active);
|
|
}
|
|
|
|
/**
|
|
* Returns the current setting of the flag that indicates whether the color
|
|
* buffer should be cleared every frame. See set_clear_stencil_active().
|
|
*/
|
|
INLINE bool DrawableRegion::
|
|
get_clear_stencil_active() const {
|
|
return get_clear_active(RTP_stencil);
|
|
}
|
|
|
|
/**
|
|
* Sets the clear color to the indicated value. This is the value that will
|
|
* be used to clear the color buffer every frame, but only if
|
|
* get_clear_color_active() returns true. If get_clear_color_active() returns
|
|
* false, this is meaningless.
|
|
*/
|
|
INLINE void DrawableRegion::
|
|
set_clear_color(const LColor &color) {
|
|
set_clear_value(RTP_color, color);
|
|
}
|
|
|
|
/**
|
|
* Returns the current clear color value. This is the value that will be used
|
|
* to clear the color buffer every frame, but only if get_clear_color_active()
|
|
* returns true. If get_clear_color_active() returns false, this is
|
|
* meaningless.
|
|
*/
|
|
INLINE const LColor &DrawableRegion::
|
|
get_clear_color() const {
|
|
return get_clear_value(RTP_color);
|
|
}
|
|
|
|
/**
|
|
* Sets the clear depth to the indicated value. This is the value that will
|
|
* be used to clear the depth buffer every frame, but only if
|
|
* get_clear_depth_active() returns true. If get_clear_depth_active() returns
|
|
* false, this is meaningless.
|
|
*/
|
|
INLINE void DrawableRegion::
|
|
set_clear_depth(PN_stdfloat depth) {
|
|
set_clear_value(RTP_depth, LColor(depth,depth,depth,depth));
|
|
}
|
|
|
|
/**
|
|
* Returns the current clear depth value. This is the value that will be used
|
|
* to clear the depth buffer every frame, but only if get_clear_depth_active()
|
|
* returns true. If get_clear_depth_active() returns false, this is
|
|
* meaningless.
|
|
*/
|
|
INLINE PN_stdfloat DrawableRegion::
|
|
get_clear_depth() const {
|
|
return get_clear_value(RTP_depth)[0];
|
|
}
|
|
/**
|
|
* Sets the clear stencil to the indicated value. This is the value that will
|
|
* be used to clear the stencil buffer every frame, but only if
|
|
* get_clear_color_active() returns true. If get_clear_stencil_active()
|
|
* returns false, this is meaningless.
|
|
*/
|
|
INLINE void DrawableRegion::
|
|
set_clear_stencil(const unsigned int stencil) {
|
|
set_clear_value(RTP_stencil, LColor(stencil,stencil,stencil,stencil));
|
|
}
|
|
|
|
/**
|
|
* Returns the current clear stencil value. This is the value that will be
|
|
* used to clear the stencil buffer every frame, but only if
|
|
* get_clear_stencil_active() returns true. If get_clear_stencil_active()
|
|
* returns false, this is meaningless.
|
|
*/
|
|
INLINE unsigned int DrawableRegion::
|
|
get_clear_stencil() const {
|
|
return (unsigned int)(get_clear_value(RTP_stencil)[0]);
|
|
}
|
|
|
|
/**
|
|
* Returns the value set by set_pixel_zoom(), regardless of whether it is
|
|
* being respected or not. Also see get_pixel_factor().
|
|
*/
|
|
INLINE PN_stdfloat DrawableRegion::
|
|
get_pixel_zoom() const {
|
|
return _pixel_zoom;
|
|
}
|
|
|
|
/**
|
|
* Returns the amount by which the height and width of the region will be
|
|
* scaled internally, based on the zoom factor set by set_pixel_zoom(). This
|
|
* will return 1.0 if the pixel_zoom was not set or if it is not being
|
|
* respected (for instance, because the underlying renderer doesn't support it
|
|
* --see supports_pixel_zoom).
|
|
*/
|
|
INLINE PN_stdfloat DrawableRegion::
|
|
get_pixel_factor() const {
|
|
return _pixel_factor;
|
|
}
|
|
|
|
/**
|
|
* Returns the RenderBuffer that should be used for capturing screenshots from
|
|
* this particular DrawableRegion.
|
|
*/
|
|
INLINE int DrawableRegion::
|
|
get_screenshot_buffer_type() const {
|
|
return _screenshot_buffer_type;
|
|
}
|
|
|
|
/**
|
|
* Returns the RenderBuffer into which the GSG should issue draw commands.
|
|
* Normally, this is the back buffer for double-buffered windows, and the
|
|
* front buffer for single-buffered windows.
|
|
*/
|
|
INLINE int DrawableRegion::
|
|
get_draw_buffer_type() const {
|
|
return _draw_buffer_type;
|
|
}
|
|
|
|
/**
|
|
* Internal function to reset pixel_factor after it may have changed.
|
|
*/
|
|
INLINE void DrawableRegion::
|
|
update_pixel_factor() {
|
|
PN_stdfloat new_pixel_factor;
|
|
if (supports_pixel_zoom()) {
|
|
new_pixel_factor = (PN_stdfloat)1 / sqrt(std::max(_pixel_zoom, (PN_stdfloat)1.0));
|
|
} else {
|
|
new_pixel_factor = 1;
|
|
}
|
|
if (new_pixel_factor != _pixel_factor) {
|
|
_pixel_factor = new_pixel_factor;
|
|
pixel_factor_changed();
|
|
}
|
|
}
|