195 lines
7.8 KiB
C++
195 lines
7.8 KiB
C++
// Filename: drawableRegion.cxx
|
|
// Created by: drose (11Jul02)
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
//
|
|
// 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."
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
#include "drawableRegion.h"
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: DrawableRegion::Destructor
|
|
// Access: Public, Virtual
|
|
// Description:
|
|
////////////////////////////////////////////////////////////////////
|
|
DrawableRegion::
|
|
~DrawableRegion() {
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: DrawableRegion::set_clear_active
|
|
// Access: Published, Virtual
|
|
// Description: Sets the clear-active flag for any bitplane.
|
|
////////////////////////////////////////////////////////////////////
|
|
void DrawableRegion::
|
|
set_clear_active(int n, bool clear_active) {
|
|
nassertv((n >= 0)&&(n < RTP_COUNT));
|
|
_clear_active[n] = clear_active;
|
|
update_pixel_factor();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: DrawableRegion::get_clear_active
|
|
// Access: Published, Virtual
|
|
// Description: Gets the clear-active flag for any bitplane.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool DrawableRegion::
|
|
get_clear_active(int n) const {
|
|
nassertr((n >= 0)&&(n < RTP_COUNT), false);
|
|
return _clear_active[n];
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: DrawableRegion::set_clear_value
|
|
// Access: Published, Virtual
|
|
// Description: Sets the clear value for any bitplane.
|
|
////////////////////////////////////////////////////////////////////
|
|
void DrawableRegion::
|
|
set_clear_value(int n, const Colorf &clear_value) {
|
|
nassertv((n >= 0) && (n < RTP_COUNT));
|
|
_clear_value[n] = clear_value;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: DrawableRegion::get_clear_value
|
|
// Access: Published, Virtual
|
|
// Description: Returns the clear value for any bitplane.
|
|
////////////////////////////////////////////////////////////////////
|
|
const Colorf &DrawableRegion::
|
|
get_clear_value(int n) const {
|
|
static Colorf blank(0.5,0.5,0.5,0.0);
|
|
nassertr((n >= 0) && (n < RTP_COUNT), blank);
|
|
return _clear_value[n];
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: DrawableRegion::disable_clears
|
|
// Access: Published, Virtual
|
|
// Description: Disables both the color and depth clear. See
|
|
// set_clear_color_active and set_clear_depth_active.
|
|
////////////////////////////////////////////////////////////////////
|
|
void DrawableRegion::
|
|
disable_clears() {
|
|
for (int i = 0; i < RTP_COUNT; ++i) {
|
|
_clear_active[i] = false;
|
|
}
|
|
update_pixel_factor();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: DrawableRegion::is_any_clear_active
|
|
// Access: Published, Virtual
|
|
// Description: Returns true if any of the clear types (so far there
|
|
// are just color or depth) have been set active, or
|
|
// false if none of them are active and there is no need
|
|
// to clear.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool DrawableRegion::
|
|
is_any_clear_active() const {
|
|
for (int i = 0; i < RTP_COUNT; ++i) {
|
|
if (get_clear_active(i)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: DrawableRegion::set_pixel_zoom
|
|
// Access: Published, Virtual
|
|
// Description: Sets the amount by which the pixels of the region are
|
|
// scaled internally when filling the image interally.
|
|
// Setting this number larger makes the pixels blockier,
|
|
// but may make the rendering faster, particularly for
|
|
// software renderers. Setting this number to 2.0
|
|
// reduces the number of pixels that have to be filled
|
|
// by the renderer by a factor of 2.0. It doesn't make
|
|
// sense to set this lower than 1.0.
|
|
//
|
|
// It is possible to set this on either individual
|
|
// DisplayRegions or on overall GraphicsWindows, but you
|
|
// will get better performance for setting it on the
|
|
// window rather than its individual DisplayRegions.
|
|
// Also, you may not set it on a DisplayRegion that
|
|
// doesn't have both clear_color() and clear_depth()
|
|
// enabled.
|
|
//
|
|
// This property is only supported on renderers for
|
|
// which it is particularly useful--currently, this is
|
|
// the tinydisplay software renderer. Other kinds of
|
|
// renderers allow you to set this property, but ignore
|
|
// it.
|
|
////////////////////////////////////////////////////////////////////
|
|
void DrawableRegion::
|
|
set_pixel_zoom(float pixel_zoom) {
|
|
_pixel_zoom = pixel_zoom;
|
|
update_pixel_factor();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: DrawableRegion::supports_pixel_zoom
|
|
// Access: Published, Virtual
|
|
// Description: Returns true if a call to set_pixel_zoom() will be
|
|
// respected, false if it will be ignored. If this
|
|
// returns false, then get_pixel_factor() will always
|
|
// return 1.0, regardless of what value you specify for
|
|
// set_pixel_zoom().
|
|
//
|
|
// This may return false if the underlying renderer
|
|
// doesn't support pixel zooming, or if you have called
|
|
// this on a DisplayRegion that doesn't have both
|
|
// set_clear_color() and set_clear_depth() enabled.
|
|
////////////////////////////////////////////////////////////////////
|
|
bool DrawableRegion::
|
|
supports_pixel_zoom() const {
|
|
return false;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: DrawableRegion::get_renderbuffer_type
|
|
// Access: Static, Published
|
|
// Description: Returns the RenderBuffer::Type that corresponds
|
|
// to a RenderTexturePlane.
|
|
////////////////////////////////////////////////////////////////////
|
|
int DrawableRegion::
|
|
get_renderbuffer_type(int rtp) {
|
|
switch(rtp) {
|
|
case RTP_stencil: return RenderBuffer::T_stencil;
|
|
case RTP_depth: return RenderBuffer::T_depth;
|
|
case RTP_depth_stencil: return RenderBuffer::T_depth;
|
|
case RTP_color: return RenderBuffer::T_color;
|
|
case RTP_aux_rgba_0: return RenderBuffer::T_aux_rgba_0;
|
|
case RTP_aux_rgba_1: return RenderBuffer::T_aux_rgba_1;
|
|
case RTP_aux_rgba_2: return RenderBuffer::T_aux_rgba_2;
|
|
case RTP_aux_rgba_3: return RenderBuffer::T_aux_rgba_3;
|
|
case RTP_aux_hrgba_0: return RenderBuffer::T_aux_hrgba_0;
|
|
case RTP_aux_hrgba_1: return RenderBuffer::T_aux_hrgba_1;
|
|
case RTP_aux_hrgba_2: return RenderBuffer::T_aux_hrgba_2;
|
|
case RTP_aux_hrgba_3: return RenderBuffer::T_aux_hrgba_3;
|
|
case RTP_aux_float_0: return RenderBuffer::T_aux_float_0;
|
|
case RTP_aux_float_1: return RenderBuffer::T_aux_float_1;
|
|
case RTP_aux_float_2: return RenderBuffer::T_aux_float_2;
|
|
case RTP_aux_float_3: return RenderBuffer::T_aux_float_3;
|
|
default:
|
|
display_cat.error() << "DrawableRegion::get_renderbuffer_type unexpected case!\n";
|
|
return 0;
|
|
};
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
// Function: DrawableRegion::pixel_factor_changed
|
|
// Access: Protected, Virtual
|
|
// Description: Called internally when the pixel factor changes.
|
|
////////////////////////////////////////////////////////////////////
|
|
void DrawableRegion::
|
|
pixel_factor_changed() {
|
|
}
|