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

Simplify oddly redundant StencilAttrib implementation.

Browse Source 
Also add RenderState::compare_mask().
This commit is contained in:
rdb 2014-12-03 22:44:07 +01:00
parent 15b88283b2
commit 0473fa7ead
15 changed files with 370 additions and 865 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
panda/src/display/Sources.pp
View File

@ -43,7 +43,6 @@
windowHandle.I windowHandle.h \
windowProperties.I windowProperties.h \
renderBuffer.h \
stencilRenderStates.h \
stereoDisplayRegion.I stereoDisplayRegion.h \
displaySearchParameters.h \
displayInformation.h \
@ -80,7 +79,6 @@
parasiteBuffer.cxx \
windowHandle.cxx \
windowProperties.cxx \
stencilRenderStates.cxx \
stereoDisplayRegion.cxx \
subprocessWindow.cxx \
touchInfo.cxx
@ -118,7 +116,6 @@
windowHandle.I windowHandle.h \
windowProperties.I windowProperties.h \
renderBuffer.h \
stencilRenderStates.h \
stereoDisplayRegion.I stereoDisplayRegion.h \
subprocessWindow.h subprocessWindow.I \
subprocessWindowBuffer.h subprocessWindowBuffer.I \

13
panda/src/display/graphicsStateGuardian.cxx
View File

@ -258,8 +258,6 @@ GraphicsStateGuardian(CoordinateSystem internal_coordinate_system,
// it is rendered.
_runtime_color_scale = false;
_stencil_render_states = 0;
// The default is no shader support.
_auto_detect_shader_model = SM_00;
_shader_model = SM_00;
@ -279,11 +277,6 @@ GraphicsStateGuardian::
~GraphicsStateGuardian() {
remove_gsg(this);
if (_stencil_render_states) {
delete _stencil_render_states;
_stencil_render_states = 0;
}
if (_shader_generator) {
delete _shader_generator;
_shader_generator = 0;
@ -1988,12 +1981,6 @@ reset() {
_last_max_stage_index = 0;
_is_valid = true;
if (_stencil_render_states) {
delete _stencil_render_states;
_stencil_render_states = 0;
}
_stencil_render_states = new StencilRenderStates(this);
}
////////////////////////////////////////////////////////////////////

3
panda/src/display/graphicsStateGuardian.h
View File

@ -45,7 +45,6 @@
#include "texture.h"
#include "occlusionQueryContext.h"
#include "timerQueryContext.h"
#include "stencilRenderStates.h"
#include "loader.h"
#include "shaderAttrib.h"
#include "texGenAttrib.h"
@ -532,8 +531,6 @@ protected:
int _stereo_buffer_mask;
StencilRenderStates *_stencil_render_states;
int _auto_detect_shader_model;
int _shader_model;

1
panda/src/display/p3display_composite2.cxx
View File

@ -12,7 +12,6 @@
#include "nativeWindowHandle.cxx"
#include "parasiteBuffer.cxx"
#include "standardMunger.cxx"
#include "stencilRenderStates.cxx"
#include "touchInfo.cxx"
#include "stereoDisplayRegion.cxx"
#include "subprocessWindow.cxx"

111
panda/src/display/stencilRenderStates.cxx
View File

@ -1,111 +0,0 @@
// Filename: stencilRenderStates.cxx
// Created by: aignacio (17May06)
//
////////////////////////////////////////////////////////////////////
//
// 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 "graphicsStateGuardian.h"
#include "stencilRenderStates.h"
////////////////////////////////////////////////////////////////////
// Function: StencilRenderStates::Constructor
// Description: Constructor. All data is set to the default.
////////////////////////////////////////////////////////////////////
StencilRenderStates::
StencilRenderStates (GraphicsStateGuardian *gsg) {
int index;
// clear all
for (index = 0; index < SRS_total; index++) {
_stencil_render_state_array [index] = 0;
_stencil_function_array [index] = 0;
}
// set default render states
set_stencil_render_state (false, SRS_reference, 0);
set_stencil_render_state (false, SRS_read_mask, ~0);
set_stencil_render_state (false, SRS_write_mask, ~0);
set_stencil_render_state (false, SRS_front_enable, 0);
set_stencil_render_state (false, SRS_front_comparison_function, SCF_always);
set_stencil_render_state (false, SRS_front_stencil_fail_operation, SO_keep);
set_stencil_render_state (false, SRS_front_stencil_pass_z_fail_operation, SO_keep);
set_stencil_render_state (false, SRS_front_stencil_pass_z_pass_operation, SO_keep);
set_stencil_render_state (false, SRS_back_enable, 0);
set_stencil_render_state (false, SRS_back_comparison_function, SCF_always);
set_stencil_render_state (false, SRS_back_stencil_fail_operation, SO_keep);
set_stencil_render_state (false, SRS_back_stencil_pass_z_fail_operation, SO_keep);
set_stencil_render_state (false, SRS_back_stencil_pass_z_pass_operation, SO_keep);
_gsg = gsg;
}
////////////////////////////////////////////////////////////////////
// Function: StencilRenderStates::Destructor
// Description:
////////////////////////////////////////////////////////////////////
StencilRenderStates::
~StencilRenderStates (void) {
}
////////////////////////////////////////////////////////////////////
// Function: StencilRenderStates::set_stencil_render_state
// Description: Sets the current render state for the specified
// stencil render state. The execute_function
// parameter can be used to defer the actual setting
// of the render state at the API level. This is
// useful for the OpenGL API where certain render
// states are not independent/atomic (i.e.
// glStencilFunc and glStencilOp).
////////////////////////////////////////////////////////////////////
void StencilRenderStates::
set_stencil_render_state (bool execute_function, StencilRenderStates::StencilRenderState stencil_render_state, StencilType value) {
// DEBUG
if (false) {
printf ("SRS %d %d %d \n", execute_function, stencil_render_state, value);
}
_stencil_render_state_array [stencil_render_state] = value;
if (execute_function) {
StencilFunction stencil_function;
stencil_function = _stencil_function_array [stencil_render_state];
if (stencil_function) {
stencil_function (stencil_render_state, this);
}
}
}
////////////////////////////////////////////////////////////////////
// Function: StencilRenderStates::get_stencil_render_state
// Description: Gets the current render state for the specified
// stencil render state.
////////////////////////////////////////////////////////////////////
StencilType StencilRenderStates::
get_stencil_render_state (StencilRenderStates::StencilRenderState stencil_render_state) {
return _stencil_render_state_array [stencil_render_state];
}
////////////////////////////////////////////////////////////////////
// Function: StencilRenderStates::set_stencil_function
// Description: Registers an API specific callback for setting a
// specified stencil render state.
////////////////////////////////////////////////////////////////////
void StencilRenderStates::
set_stencil_function (StencilRenderStates::StencilRenderState stencil_render_state, StencilFunction stencil_function) {
_stencil_function_array [stencil_render_state] = stencil_function;
}

101
panda/src/display/stencilRenderStates.h
View File

@ -1,101 +0,0 @@
// Filename: stencilRenderStates.h
// Created by: aignacio (17May06)
//
////////////////////////////////////////////////////////////////////
//
// 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."
//
////////////////////////////////////////////////////////////////////
#ifndef STENCILRENDERSTATES_H
#define STENCILRENDERSTATES_H
class GraphicsStateGuardian;
typedef unsigned int StencilType;
////////////////////////////////////////////////////////////////////
// Class : StencilRenderStates
// Description : An abstract cross-platform class for setting stencil
// buffer render states. Each gsg needs to create its
// own low-level API specific functions on how to set
// each render state. The "set_stencil_render_state"
// function can be used in an immediate-mode fashion.
////////////////////////////////////////////////////////////////////
class EXPCL_PANDA_DISPLAY StencilRenderStates {
PUBLISHED:
enum StencilRenderState
{
SRS_front_enable,
SRS_back_enable,
SRS_front_comparison_function,
SRS_front_stencil_fail_operation,
SRS_front_stencil_pass_z_fail_operation,
SRS_front_stencil_pass_z_pass_operation,
SRS_reference,
SRS_read_mask,
SRS_write_mask,
SRS_back_comparison_function,
SRS_back_stencil_fail_operation,
SRS_back_stencil_pass_z_fail_operation,
SRS_back_stencil_pass_z_pass_operation,
SRS_clear,
SRS_clear_value,
SRS_total,
SRS_first = 0,
};
enum StencilComparisonFunction
{
SCF_never,
SCF_less_than,
SCF_equal,
SCF_less_than_or_equal,
SCF_greater_than,
SCF_not_equal,
SCF_greater_than_or_equal,
SCF_always,
};
enum StencilOperation
{
SO_keep,
SO_zero,
SO_replace,
SO_increment,
SO_decrement,
SO_invert,
SO_increment_saturate,
SO_decrement_saturate,
};
public:
typedef void (*StencilFunction) (StencilRenderStates::StencilRenderState stencil_render_state, StencilRenderStates *stencil_render_states);
StencilRenderStates (GraphicsStateGuardian *gsg);
~StencilRenderStates (void);
void set_stencil_render_state (bool execute_function, StencilRenderStates::StencilRenderState stencil_render_state, StencilType value);
StencilType get_stencil_render_state (StencilRenderStates::StencilRenderState stencil_render_state);
void set_stencil_function (StencilRenderStates::StencilRenderState stencil_render_state, StencilFunction stencil_function);
GraphicsStateGuardian *_gsg;
private:
StencilType _stencil_render_state_array [SRS_total];
StencilFunction _stencil_function_array [SRS_total];
};
#endif

136
panda/src/dxgsg8/dxGraphicsStateGuardian8.cxx
View File

@ -2074,9 +2074,6 @@ reset() {
PRINT_REFCNT(dxgsg8, _d3d_device);
void dx_set_stencil_functions (StencilRenderStates *stencil_render_states);
dx_set_stencil_functions (_stencil_render_states);
// Now that the GSG has been initialized, make it available for
// optimizations.
add_gsg(this);
@ -4310,9 +4307,7 @@ draw_indexed_primitive_up(D3DPRIMITIVETYPE primitive_type,
////////////////////////////////////////////////////////////////////
// DX stencil code section
////////////////////////////////////////////////////////////////////
static int dx_stencil_comparison_function_array [ ] =
{
static int dx_stencil_comparison_function_array[] = {
D3DCMP_NEVER,
D3DCMP_LESS,
D3DCMP_EQUAL,
@ -4323,8 +4318,7 @@ static int dx_stencil_comparison_function_array [ ] =
D3DCMP_ALWAYS,
};
static int dx_stencil_operation_array [ ] =
{
static int dx_stencil_operation_array[] = {
D3DSTENCILOP_KEEP,
D3DSTENCILOP_ZERO,
D3DSTENCILOP_REPLACE,
@ -4336,84 +4330,6 @@ static int dx_stencil_operation_array [ ] =
D3DSTENCILOP_DECRSAT,
};
void dx_stencil_function (StencilRenderStates::StencilRenderState stencil_render_state, StencilRenderStates *stencil_render_states) {
StencilType render_state_value;
DXGraphicsStateGuardian8 *gsg;
LPDIRECT3DDEVICE8 device;
gsg = (DXGraphicsStateGuardian8 *) stencil_render_states -> _gsg;
device = gsg->get_d3d_device();
render_state_value = stencil_render_states -> get_stencil_render_state (stencil_render_state);
if (dxgsg8_cat.is_debug()) {
dxgsg8_cat.debug()
<< "SRS: " << StencilAttrib::stencil_render_state_name_array [stencil_render_state] << ", " << render_state_value << "\n";
}
switch (stencil_render_state)
{
case StencilRenderStates::SRS_front_enable:
device->SetRenderState (D3DRS_STENCILENABLE, render_state_value);
break;
case StencilRenderStates::SRS_back_enable:
// not supported in DX8
break;
case StencilRenderStates::SRS_front_comparison_function:
device->SetRenderState (D3DRS_STENCILFUNC, dx_stencil_comparison_function_array [render_state_value]);
break;
case StencilRenderStates::SRS_front_stencil_fail_operation:
device->SetRenderState (D3DRS_STENCILFAIL, dx_stencil_operation_array [render_state_value]);
break;
case StencilRenderStates::SRS_front_stencil_pass_z_fail_operation:
device->SetRenderState (D3DRS_STENCILZFAIL, dx_stencil_operation_array [render_state_value]);
break;
case StencilRenderStates::SRS_front_stencil_pass_z_pass_operation:
device->SetRenderState (D3DRS_STENCILPASS, dx_stencil_operation_array [render_state_value]);
break;
case StencilRenderStates::SRS_reference:
device->SetRenderState (D3DRS_STENCILREF, render_state_value);
break;
case StencilRenderStates::SRS_read_mask:
device->SetRenderState (D3DRS_STENCILMASK, render_state_value);
break;
case StencilRenderStates::SRS_write_mask:
device->SetRenderState (D3DRS_STENCILWRITEMASK, render_state_value);
break;
case StencilRenderStates::SRS_back_comparison_function:
// not supported in DX8
break;
case StencilRenderStates::SRS_back_stencil_fail_operation:
// not supported in DX8
break;
case StencilRenderStates::SRS_back_stencil_pass_z_fail_operation:
// not supported in DX8
break;
case StencilRenderStates::SRS_back_stencil_pass_z_pass_operation:
// not supported in DX8
break;
default:
break;
}
}
void dx_set_stencil_functions (StencilRenderStates *stencil_render_states) {
if (stencil_render_states) {
StencilRenderStates::StencilRenderState stencil_render_state;
for (stencil_render_state = StencilRenderStates::SRS_first; stencil_render_state < StencilRenderStates::SRS_total; stencil_render_state = (StencilRenderStates::StencilRenderState) ((int) stencil_render_state + 1)) {
stencil_render_states -> set_stencil_function (stencil_render_state, dx_stencil_function);
}
}
}
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian8::do_issue_stencil
// Access: Protected
@ -4421,20 +4337,17 @@ void dx_set_stencil_functions (StencilRenderStates *stencil_render_states) {
////////////////////////////////////////////////////////////////////
void DXGraphicsStateGuardian8::
do_issue_stencil() {
if (!_supports_stencil) {
return;
}
StencilRenderStates *stencil_render_states;
const StencilAttrib *stencil = DCAST(StencilAttrib, _target_rs->get_attrib_def(StencilAttrib::get_class_slot()));
stencil_render_states = this -> _stencil_render_states;
if (stencil && stencil_render_states) {
const StencilAttrib *stencil = DCAST(StencilAttrib, _target_rs->get_attrib(StencilAttrib::get_class_slot()));
if (dxgsg8_cat.is_debug()) {
if (stencil != (const StencilAttrib *)NULL) {
// DEBUG
if (false) {
dxgsg8_cat.debug() << "STENCIL STATE CHANGE\n";
dxgsg8_cat.debug() << "\n"
<< "SRS_front_enable " << stencil -> get_render_state (StencilAttrib::SRS_front_enable) << "\n"
<< "SRS_front_comparison_function " << stencil->get_render_state(StencilAttrib::SRS_front_comparison_function) << "\n"
<< "SRS_front_stencil_fail_operation " << stencil->get_render_state(StencilAttrib::SRS_front_stencil_fail_operation) << "\n"
<< "SRS_front_stencil_pass_z_fail_operation " << stencil->get_render_state(StencilAttrib::SRS_front_stencil_pass_z_fail_operation) << "\n"
@ -4444,25 +4357,36 @@ do_issue_stencil() {
<< "SRS_write_mask " << stencil->get_render_state(StencilAttrib::SRS_write_mask) << "\n";
}
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_enable, stencil -> get_render_state (StencilAttrib::SRS_front_enable));
if (stencil -> get_render_state (StencilAttrib::SRS_front_enable)) {
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_comparison_function, stencil -> get_render_state (StencilAttrib::SRS_front_comparison_function));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_stencil_fail_operation, stencil -> get_render_state (StencilAttrib::SRS_front_stencil_fail_operation));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_stencil_pass_z_fail_operation, stencil -> get_render_state (StencilAttrib::SRS_front_stencil_pass_z_fail_operation));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_stencil_pass_z_pass_operation, stencil -> get_render_state (StencilAttrib::SRS_front_stencil_pass_z_pass_operation));
unsigned int front_compare;
front_compare = stencil->get_render_state(StencilAttrib::SRS_front_comparison_function);
if (front_compare != RenderAttrib::M_none) {
set_render_state(D3DRS_STENCILENABLE, TRUE);
set_render_state(D3DRS_STENCILFUNC, dx_stencil_comparison_function_array[front_compare]);
set_render_state(D3DRS_STENCILFAIL, dx_stencil_operation_array[
stencil->get_render_state(StencilAttrib::SRS_front_stencil_fail_operation)]);
set_render_state(D3DRS_STENCILZFAIL, dx_stencil_operation_array[
stencil->get_render_state(StencilAttrib::SRS_front_stencil_pass_z_fail_operation)]);
set_render_state(D3DRS_STENCILPASS, dx_stencil_operation_array[
stencil->get_render_state(StencilAttrib::SRS_front_stencil_pass_z_pass_operation)]);
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_reference, stencil -> get_render_state (StencilAttrib::SRS_reference));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_read_mask, stencil -> get_render_state (StencilAttrib::SRS_read_mask));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_write_mask, stencil -> get_render_state (StencilAttrib::SRS_write_mask));
set_render_state(D3DRS_STENCILREF, stencil->get_render_state(StencilAttrib::SRS_reference));
set_render_state(D3DRS_STENCILMASK, stencil->get_render_state(StencilAttrib::SRS_read_mask));
set_render_state(D3DRS_STENCILWRITEMASK, stencil->get_render_state(StencilAttrib::SRS_write_mask));
} else {
set_render_state(D3DRS_STENCILENABLE, FALSE);
}
}
else {
if (dxgsg8_cat.is_debug()) {
if (stencil->get_render_state(StencilAttrib::SRS_clear)) {
_d3d_device->Clear(0, NULL, D3DCLEAR_STENCIL, 0, 0.0f, stencil->get_render_state(StencilAttrib::SRS_clear_value));
}
} else {
// DEBUG
if (false) {
dxgsg8_cat.debug() << "STENCIL STATE CHANGE TO OFF\n";
}
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_enable, 0);
set_render_state(D3DRS_STENCILENABLE, FALSE);
}
}

165
panda/src/dxgsg9/dxGraphicsStateGuardian9.cxx
View File

@ -2769,9 +2769,6 @@ reset() {
PRINT_REFCNT(dxgsg9, _d3d_device);
void dx_set_stencil_functions (StencilRenderStates *stencil_render_states);
dx_set_stencil_functions (_stencil_render_states);
// Now that the GSG has been initialized, make it available for
// optimizations.
add_gsg(this);
@ -5261,9 +5258,7 @@ check_dx_allocation (HRESULT result, int allocation_size, int attempts)
////////////////////////////////////////////////////////////////////
// DX stencil code section
////////////////////////////////////////////////////////////////////
static int dx_stencil_comparison_function_array [ ] =
{
static int dx_stencil_comparison_function_array[] = {
D3DCMP_NEVER,
D3DCMP_LESS,
D3DCMP_EQUAL,
@ -5274,8 +5269,7 @@ static int dx_stencil_comparison_function_array [ ] =
D3DCMP_ALWAYS,
};
static int dx_stencil_operation_array [ ] =
{
static int dx_stencil_operation_array[] = {
D3DSTENCILOP_KEEP,
D3DSTENCILOP_ZERO,
D3DSTENCILOP_REPLACE,
@ -5287,93 +5281,6 @@ static int dx_stencil_operation_array [ ] =
D3DSTENCILOP_DECRSAT,
};
void dx_stencil_function (StencilRenderStates::StencilRenderState stencil_render_state, StencilRenderStates *stencil_render_states) {
StencilType render_state_value;
DXGraphicsStateGuardian9 *gsg;
gsg = (DXGraphicsStateGuardian9 *) stencil_render_states -> _gsg;
render_state_value = stencil_render_states -> get_stencil_render_state (stencil_render_state);
// DEBUG
if (false) {
dxgsg9_cat.debug()
<< "SRS: " << StencilAttrib::stencil_render_state_name_array [stencil_render_state] << ", " << render_state_value << "\n";
}
switch (stencil_render_state)
{
case StencilRenderStates::SRS_front_enable:
gsg -> set_render_state (D3DRS_STENCILENABLE, render_state_value);
break;
case StencilRenderStates::SRS_back_enable:
if (gsg -> get_supports_two_sided_stencil()) {
gsg -> set_render_state (D3DRS_TWOSIDEDSTENCILMODE, render_state_value);
}
break;
case StencilRenderStates::SRS_front_comparison_function:
gsg -> set_render_state (D3DRS_STENCILFUNC, dx_stencil_comparison_function_array [render_state_value]);
break;
case StencilRenderStates::SRS_front_stencil_fail_operation:
gsg -> set_render_state (D3DRS_STENCILFAIL, dx_stencil_operation_array [render_state_value]);
break;
case StencilRenderStates::SRS_front_stencil_pass_z_fail_operation:
gsg -> set_render_state (D3DRS_STENCILZFAIL, dx_stencil_operation_array [render_state_value]);
break;
case StencilRenderStates::SRS_front_stencil_pass_z_pass_operation:
gsg -> set_render_state (D3DRS_STENCILPASS, dx_stencil_operation_array [render_state_value]);
break;
case StencilRenderStates::SRS_reference:
gsg -> set_render_state (D3DRS_STENCILREF, render_state_value);
break;
case StencilRenderStates::SRS_read_mask:
gsg -> set_render_state (D3DRS_STENCILMASK, render_state_value);
break;
case StencilRenderStates::SRS_write_mask:
gsg -> set_render_state (D3DRS_STENCILWRITEMASK, render_state_value);
break;
case StencilRenderStates::SRS_back_comparison_function:
if (gsg -> get_supports_two_sided_stencil()) {
gsg -> set_render_state (D3DRS_CCW_STENCILFUNC, dx_stencil_comparison_function_array [render_state_value]);
}
break;
case StencilRenderStates::SRS_back_stencil_fail_operation:
if (gsg -> get_supports_two_sided_stencil()) {
gsg -> set_render_state (D3DRS_CCW_STENCILFAIL, dx_stencil_operation_array [render_state_value]);
}
break;
case StencilRenderStates::SRS_back_stencil_pass_z_fail_operation:
if (gsg -> get_supports_two_sided_stencil()) {
gsg -> set_render_state (D3DRS_CCW_STENCILZFAIL, dx_stencil_operation_array [render_state_value]);
}
break;
case StencilRenderStates::SRS_back_stencil_pass_z_pass_operation:
if (gsg -> get_supports_two_sided_stencil()) {
gsg -> set_render_state (D3DRS_CCW_STENCILPASS, dx_stencil_operation_array [render_state_value]);
}
break;
default:
break;
}
}
void dx_set_stencil_functions (StencilRenderStates *stencil_render_states) {
if (stencil_render_states) {
StencilRenderStates::StencilRenderState stencil_render_state;
for (stencil_render_state = StencilRenderStates::SRS_first; stencil_render_state < StencilRenderStates::SRS_total; stencil_render_state = (StencilRenderStates::StencilRenderState) ((int) stencil_render_state + 1)) {
stencil_render_states -> set_stencil_function (stencil_render_state, dx_stencil_function);
}
}
}
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian9::do_issue_stencil
// Access: Protected
@ -5385,17 +5292,13 @@ do_issue_stencil() {
return;
}
StencilRenderStates *stencil_render_states;
const StencilAttrib *stencil = DCAST(StencilAttrib, _target_rs->get_attrib_def(StencilAttrib::get_class_slot()));
stencil_render_states = this -> _stencil_render_states;
if (stencil && stencil_render_states) {
const StencilAttrib *stencil = DCAST(StencilAttrib, _target_rs->get_attrib(StencilAttrib::get_class_slot()));
if (stencil != (const StencilAttrib *)NULL) {
// DEBUG
if (false) {
dxgsg9_cat.debug() << "STENCIL STATE CHANGE\n";
dxgsg9_cat.debug() << "\n"
<< "SRS_front_enable " << stencil -> get_render_state (StencilAttrib::SRS_front_enable) << "\n"
<< "SRS_back_enable " << stencil -> get_render_state (StencilAttrib::SRS_back_enable) << "\n"
<< "SRS_front_comparison_function " << stencil->get_render_state(StencilAttrib::SRS_front_comparison_function) << "\n"
<< "SRS_front_stencil_fail_operation " << stencil->get_render_state(StencilAttrib::SRS_front_stencil_fail_operation) << "\n"
<< "SRS_front_stencil_pass_z_fail_operation " << stencil->get_render_state(StencilAttrib::SRS_front_stencil_pass_z_fail_operation) << "\n"
@ -5409,46 +5312,64 @@ do_issue_stencil() {
<< "SRS_back_stencil_pass_z_pass_operation " << stencil->get_render_state(StencilAttrib::SRS_back_stencil_pass_z_pass_operation) << "\n";
}
bool on;
bool on = false;
on = false;
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_enable, stencil -> get_render_state (StencilAttrib::SRS_front_enable));
if (stencil -> get_render_state (StencilAttrib::SRS_front_enable)) {
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_comparison_function, stencil -> get_render_state (StencilAttrib::SRS_front_comparison_function));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_stencil_fail_operation, stencil -> get_render_state (StencilAttrib::SRS_front_stencil_fail_operation));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_stencil_pass_z_fail_operation, stencil -> get_render_state (StencilAttrib::SRS_front_stencil_pass_z_fail_operation));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_stencil_pass_z_pass_operation, stencil -> get_render_state (StencilAttrib::SRS_front_stencil_pass_z_pass_operation));
unsigned int front_compare;
front_compare = stencil->get_render_state(StencilAttrib::SRS_front_comparison_function);
if (front_compare != RenderAttrib::M_none) {
set_render_state(D3DRS_STENCILENABLE, TRUE);
set_render_state(D3DRS_STENCILFUNC, dx_stencil_comparison_function_array[front_compare]);
set_render_state(D3DRS_STENCILFAIL, dx_stencil_operation_array[
stencil->get_render_state(StencilAttrib::SRS_front_stencil_fail_operation)]);
set_render_state(D3DRS_STENCILZFAIL, dx_stencil_operation_array[
stencil->get_render_state(StencilAttrib::SRS_front_stencil_pass_z_fail_operation)]);
set_render_state(D3DRS_STENCILPASS, dx_stencil_operation_array[
stencil->get_render_state(StencilAttrib::SRS_front_stencil_pass_z_pass_operation)]);
on = true;
} else {
set_render_state(D3DRS_STENCILENABLE, FALSE);
}
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_back_enable, stencil -> get_render_state (StencilAttrib::SRS_back_enable));
if (stencil -> get_render_state (StencilAttrib::SRS_back_enable)) {
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_back_comparison_function, stencil -> get_render_state (StencilAttrib::SRS_back_comparison_function));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_back_stencil_fail_operation, stencil -> get_render_state (StencilAttrib::SRS_back_stencil_fail_operation));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_back_stencil_pass_z_fail_operation, stencil -> get_render_state (StencilAttrib::SRS_back_stencil_pass_z_fail_operation));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_back_stencil_pass_z_pass_operation, stencil -> get_render_state (StencilAttrib::SRS_back_stencil_pass_z_pass_operation));
if (_supports_two_sided_stencil) {
unsigned int back_compare;
back_compare = stencil->get_render_state(StencilAttrib::SRS_back_comparison_function);
if (back_compare != RenderAttrib::M_none) {
set_render_state(D3DRS_TWOSIDEDSTENCILMODE, TRUE);
set_render_state(D3DRS_CCW_STENCILFUNC, dx_stencil_comparison_function_array[back_compare]);
set_render_state(D3DRS_CCW_STENCILFAIL, dx_stencil_operation_array[
stencil->get_render_state(StencilAttrib::SRS_back_stencil_fail_operation)]);
set_render_state(D3DRS_CCW_STENCILZFAIL, dx_stencil_operation_array[
stencil->get_render_state(StencilAttrib::SRS_back_stencil_pass_z_fail_operation)]);
set_render_state(D3DRS_CCW_STENCILPASS, dx_stencil_operation_array[
stencil->get_render_state(StencilAttrib::SRS_back_stencil_pass_z_pass_operation)]);
on = true;
} else {
set_render_state(D3DRS_TWOSIDEDSTENCILMODE, FALSE);
}
}
if (on) {
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_reference, stencil -> get_render_state (StencilAttrib::SRS_reference));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_read_mask, stencil -> get_render_state (StencilAttrib::SRS_read_mask));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_write_mask, stencil -> get_render_state (StencilAttrib::SRS_write_mask));
set_render_state(D3DRS_STENCILREF, stencil->get_render_state(StencilAttrib::SRS_reference));
set_render_state(D3DRS_STENCILMASK, stencil->get_render_state(StencilAttrib::SRS_read_mask));
set_render_state(D3DRS_STENCILWRITEMASK, stencil->get_render_state(StencilAttrib::SRS_write_mask));
}
if (stencil->get_render_state(StencilAttrib::SRS_clear)) {
_d3d_device->Clear(0, NULL, D3DCLEAR_STENCIL, 0, 0.0f, stencil->get_render_state(StencilAttrib::SRS_clear_value));
}
}
else {
} else {
// DEBUG
if (false) {
dxgsg9_cat.debug() << "STENCIL STATE CHANGE TO OFF\n";
}
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_enable, 0);
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_back_enable, 0);
set_render_state(D3DRS_STENCILENABLE, FALSE);
if (_supports_two_sided_stencil) {
set_render_state(D3DRS_TWOSIDEDSTENCILMODE, FALSE);
}
}
}

241
panda/src/glstuff/glGraphicsStateGuardian_src.cxx
View File

@ -337,11 +337,6 @@ CLP(GraphicsStateGuardian)::
}
close_gsg();
if (_stencil_render_states) {
delete _stencil_render_states;
_stencil_render_states = 0;
}
}
////////////////////////////////////////////////////////////////////
@ -2103,9 +2098,6 @@ reset() {
report_my_gl_errors();
void gl_set_stencil_functions (StencilRenderStates *stencil_render_states);
gl_set_stencil_functions(_stencil_render_states);
#if defined(HAVE_CG) && !defined(OPENGLES)
typedef struct {
@ -11511,17 +11503,6 @@ bind_fbo(GLuint fbo) {
// GL stencil code section
////////////////////////////////////////////////////////////////////
static int gl_stencil_comparison_function_array [ ] = {
GL_NEVER,
GL_LESS,
GL_EQUAL,
GL_LEQUAL,
GL_GREATER,
GL_NOTEQUAL,
GL_GEQUAL,
GL_ALWAYS,
};
static int gl_stencil_operations_array[] = {
GL_KEEP,
GL_ZERO,
@ -11539,144 +11520,6 @@ static int gl_stencil_operations_array [ ] = {
GL_DECR,
};
void __glActiveStencilFace (GraphicsStateGuardian *gsg, GLenum face) {
CLP(GraphicsStateGuardian) *glgsg;
glgsg = (CLP(GraphicsStateGuardian) *) gsg;
if (gsg -> get_supports_two_sided_stencil ( ) &&
glgsg -> _glActiveStencilFaceEXT) {
if (face == GL_FRONT) {
// glActiveStencilFaceEXT (GL_FRONT);
glgsg -> _glActiveStencilFaceEXT (GL_FRONT);
}
else {
// glActiveStencilFaceEXT (GL_BACK);
glgsg -> _glActiveStencilFaceEXT (GL_BACK);
}
}
}
void gl_front_stencil_function (StencilRenderStates::StencilRenderState stencil_render_state, StencilRenderStates *stencil_render_states) {
__glActiveStencilFace (stencil_render_states -> _gsg, GL_FRONT);
glStencilFunc
(
gl_stencil_comparison_function_array [stencil_render_states -> get_stencil_render_state (StencilRenderStates::SRS_front_comparison_function)],
stencil_render_states -> get_stencil_render_state (StencilRenderStates::SRS_reference),
stencil_render_states -> get_stencil_render_state (StencilRenderStates::SRS_read_mask)
);
}
void gl_front_stencil_operation (StencilRenderStates::StencilRenderState stencil_render_state, StencilRenderStates *stencil_render_states) {
__glActiveStencilFace (stencil_render_states -> _gsg, GL_FRONT);
glStencilOp
(
gl_stencil_operations_array [stencil_render_states -> get_stencil_render_state (StencilRenderStates::SRS_front_stencil_fail_operation)],
gl_stencil_operations_array [stencil_render_states -> get_stencil_render_state (StencilRenderStates::SRS_front_stencil_pass_z_fail_operation)],
gl_stencil_operations_array [stencil_render_states -> get_stencil_render_state (StencilRenderStates::SRS_front_stencil_pass_z_pass_operation)]
);
}
void gl_back_stencil_function (StencilRenderStates::StencilRenderState stencil_render_state, StencilRenderStates *stencil_render_states) {
bool supports_two_sided_stencil;
supports_two_sided_stencil = stencil_render_states -> _gsg -> get_supports_two_sided_stencil ( );
if (supports_two_sided_stencil) {
__glActiveStencilFace (stencil_render_states -> _gsg, GL_BACK);
glStencilFunc
(
gl_stencil_comparison_function_array [stencil_render_states -> get_stencil_render_state (StencilRenderStates::SRS_back_comparison_function)],
stencil_render_states -> get_stencil_render_state (StencilRenderStates::SRS_reference),
stencil_render_states -> get_stencil_render_state (StencilRenderStates::SRS_read_mask)
);
}
}
void gl_back_stencil_operation (StencilRenderStates::StencilRenderState stencil_render_state, StencilRenderStates *stencil_render_states) {
bool supports_two_sided_stencil;
supports_two_sided_stencil = stencil_render_states -> _gsg -> get_supports_two_sided_stencil ( );
if (supports_two_sided_stencil) {
__glActiveStencilFace (stencil_render_states -> _gsg, GL_BACK);
glStencilOp
(
gl_stencil_operations_array [stencil_render_states -> get_stencil_render_state (StencilRenderStates::SRS_back_stencil_fail_operation)],
gl_stencil_operations_array [stencil_render_states -> get_stencil_render_state (StencilRenderStates::SRS_back_stencil_pass_z_fail_operation)],
gl_stencil_operations_array [stencil_render_states -> get_stencil_render_state (StencilRenderStates::SRS_back_stencil_pass_z_pass_operation)]
);
}
}
void gl_front_back_stencil_function (StencilRenderStates::StencilRenderState stencil_render_state, StencilRenderStates *stencil_render_states) {
gl_front_stencil_function (stencil_render_state, stencil_render_states);
gl_back_stencil_function (stencil_render_state, stencil_render_states);
}
void gl_stencil_function (StencilRenderStates::StencilRenderState stencil_render_state, StencilRenderStates *stencil_render_states) {
StencilType render_state_value;
bool supports_two_sided_stencil;
supports_two_sided_stencil = stencil_render_states -> _gsg -> get_supports_two_sided_stencil ( );
render_state_value = stencil_render_states -> get_stencil_render_state (stencil_render_state);
switch (stencil_render_state) {
case StencilRenderStates::SRS_front_enable:
if (render_state_value) {
glEnable (GL_STENCIL_TEST);
}
else {
glDisable (GL_STENCIL_TEST);
}
break;
#ifndef OPENGLES
case StencilRenderStates::SRS_back_enable:
if (supports_two_sided_stencil) {
if (render_state_value) {
glEnable (GL_STENCIL_TEST_TWO_SIDE_EXT);
}
else {
glDisable (GL_STENCIL_TEST_TWO_SIDE_EXT);
}
}
break;
#endif
case StencilRenderStates::SRS_write_mask:
glStencilMask (render_state_value);
break;
default:
break;
}
}
void gl_set_stencil_functions (StencilRenderStates *stencil_render_states) {
if (stencil_render_states) {
stencil_render_states -> set_stencil_function (StencilRenderStates::SRS_front_enable, gl_stencil_function);
stencil_render_states -> set_stencil_function (StencilRenderStates::SRS_back_enable, gl_stencil_function);
stencil_render_states -> set_stencil_function (StencilRenderStates::SRS_front_comparison_function, gl_front_stencil_function);
stencil_render_states -> set_stencil_function (StencilRenderStates::SRS_front_stencil_fail_operation, gl_front_stencil_operation);
stencil_render_states -> set_stencil_function (StencilRenderStates::SRS_front_stencil_pass_z_fail_operation, gl_front_stencil_operation);
stencil_render_states -> set_stencil_function (StencilRenderStates::SRS_front_stencil_pass_z_pass_operation, gl_front_stencil_operation);
// GL seems to support different read masks and/or reference values for front and back, but DX does not.
// This needs to be cross-platform so do it the DX way by setting the same read mask and reference for both front and back.
stencil_render_states -> set_stencil_function (StencilRenderStates::SRS_reference, gl_front_back_stencil_function);
stencil_render_states -> set_stencil_function (StencilRenderStates::SRS_read_mask, gl_front_back_stencil_function);
stencil_render_states -> set_stencil_function (StencilRenderStates::SRS_write_mask, gl_stencil_function);
stencil_render_states -> set_stencil_function (StencilRenderStates::SRS_back_comparison_function, gl_back_stencil_function);
stencil_render_states -> set_stencil_function (StencilRenderStates::SRS_back_stencil_fail_operation, gl_back_stencil_operation);
stencil_render_states -> set_stencil_function (StencilRenderStates::SRS_back_stencil_pass_z_fail_operation, gl_back_stencil_operation);
stencil_render_states -> set_stencil_function (StencilRenderStates::SRS_back_stencil_pass_z_pass_operation, gl_back_stencil_operation);
}
}
////////////////////////////////////////////////////////////////////
// Function: GLGraphicsStateGuardian::do_issue_stencil
// Access: Protected
@ -11688,18 +11531,13 @@ do_issue_stencil() {
return;
}
const StencilAttrib *stencil = DCAST(StencilAttrib, _target_rs->get_attrib_def(StencilAttrib::get_class_slot()));
StencilRenderStates *stencil_render_states;
stencil_render_states = this -> _stencil_render_states;
if (stencil && stencil_render_states) {
const StencilAttrib *stencil = DCAST(StencilAttrib, _target_rs->get_attrib(StencilAttrib::get_class_slot()));
if (stencil != (const StencilAttrib *)NULL) {
// DEBUG
if (false) {
GLCAT.debug() << "STENCIL STATE CHANGE\n";
GLCAT.debug() << "\n"
<< "SRS_front_enable " << (int)stencil -> get_render_state (StencilAttrib::SRS_front_enable) << "\n"
<< "SRS_back_enable " << (int)stencil -> get_render_state (StencilAttrib::SRS_back_enable) << "\n"
<< "SRS_front_comparison_function " << (int)stencil->get_render_state(StencilAttrib::SRS_front_comparison_function) << "\n"
<< "SRS_front_stencil_fail_operation " << (int)stencil->get_render_state(StencilAttrib::SRS_front_stencil_fail_operation) << "\n"
<< "SRS_front_stencil_pass_z_fail_operation " << (int)stencil->get_render_state(StencilAttrib::SRS_front_stencil_pass_z_fail_operation) << "\n"
@ -11713,47 +11551,64 @@ do_issue_stencil() {
<< "SRS_back_stencil_pass_z_pass_operation " << (int)stencil->get_render_state(StencilAttrib::SRS_back_stencil_pass_z_pass_operation) << "\n";
}
{
bool on;
if (_supports_two_sided_stencil) {
//TODO: add support for OpenGL 2.0-style glStencilFuncSeparate.
unsigned int back_compare;
back_compare = stencil->get_render_state(StencilAttrib::SRS_back_comparison_function);
on = false;
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_enable, stencil -> get_render_state (StencilAttrib::SRS_front_enable));
if (stencil -> get_render_state (StencilAttrib::SRS_front_enable)) {
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_comparison_function, stencil -> get_render_state (StencilAttrib::SRS_front_comparison_function));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_stencil_fail_operation, stencil -> get_render_state (StencilAttrib::SRS_front_stencil_fail_operation));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_stencil_pass_z_fail_operation, stencil -> get_render_state (StencilAttrib::SRS_front_stencil_pass_z_fail_operation));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_stencil_pass_z_pass_operation, stencil -> get_render_state (StencilAttrib::SRS_front_stencil_pass_z_pass_operation));
on = true;
if (back_compare != RenderAttrib::M_none) {
glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
_glActiveStencilFaceEXT(GL_BACK);
glStencilFunc(
PANDA_TO_GL_COMPAREFUNC(back_compare),
stencil->get_render_state(StencilAttrib::SRS_reference),
stencil->get_render_state(StencilAttrib::SRS_read_mask));
glStencilOp(
gl_stencil_operations_array[stencil->get_render_state(StencilAttrib::SRS_back_stencil_fail_operation)],
gl_stencil_operations_array[stencil->get_render_state(StencilAttrib::SRS_back_stencil_pass_z_fail_operation)],
gl_stencil_operations_array[stencil->get_render_state(StencilAttrib::SRS_back_stencil_pass_z_pass_operation)]
);
glStencilMask(stencil->get_render_state(StencilAttrib::SRS_write_mask));
} else {
glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
}
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_back_enable, stencil -> get_render_state (StencilAttrib::SRS_back_enable));
if (stencil -> get_render_state (StencilAttrib::SRS_back_enable)) {
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_back_comparison_function, stencil -> get_render_state (StencilAttrib::SRS_back_comparison_function));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_back_stencil_fail_operation, stencil -> get_render_state (StencilAttrib::SRS_back_stencil_fail_operation));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_back_stencil_pass_z_fail_operation, stencil -> get_render_state (StencilAttrib::SRS_back_stencil_pass_z_fail_operation));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_back_stencil_pass_z_pass_operation, stencil -> get_render_state (StencilAttrib::SRS_back_stencil_pass_z_pass_operation));
on = true;
_glActiveStencilFaceEXT(GL_FRONT);
}
if (on) {
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_reference, stencil -> get_render_state (StencilAttrib::SRS_reference));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_read_mask, stencil -> get_render_state (StencilAttrib::SRS_read_mask));
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_write_mask, stencil -> get_render_state (StencilAttrib::SRS_write_mask));
}
unsigned int front_compare;
front_compare = stencil->get_render_state(StencilAttrib::SRS_front_comparison_function);
if (front_compare != RenderAttrib::M_none) {
glEnable(GL_STENCIL_TEST);
glStencilFunc(
PANDA_TO_GL_COMPAREFUNC(front_compare),
stencil->get_render_state(StencilAttrib::SRS_reference),
stencil->get_render_state(StencilAttrib::SRS_read_mask));
glStencilOp(
gl_stencil_operations_array[stencil->get_render_state(StencilAttrib::SRS_front_stencil_fail_operation)],
gl_stencil_operations_array[stencil->get_render_state(StencilAttrib::SRS_front_stencil_pass_z_fail_operation)],
gl_stencil_operations_array[stencil->get_render_state(StencilAttrib::SRS_front_stencil_pass_z_pass_operation)]
);
glStencilMask(stencil->get_render_state(StencilAttrib::SRS_write_mask));
} else {
glDisable(GL_STENCIL_TEST);
}
if (stencil->get_render_state(StencilAttrib::SRS_clear)) {
GLbitfield mask = 0;
// clear stencil buffer
glClearStencil(stencil->get_render_state(StencilAttrib::SRS_clear_value));
mask |= GL_STENCIL_BUFFER_BIT;
glClear(mask);
glClear(GL_STENCIL_BUFFER_BIT);
}
} else {
glDisable(GL_STENCIL_TEST);
if (_supports_two_sided_stencil) {
glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
}
else {
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_front_enable, 0);
stencil_render_states -> set_stencil_render_state (true, StencilRenderStates::SRS_back_enable, 0);
}
}

25
panda/src/pgraph/renderState.cxx
View File

@ -230,6 +230,31 @@ compare_sort(const RenderState &other) const {
return 0;
}
////////////////////////////////////////////////////////////////////
// Function: RenderState::compare_mask
// Access: Published
// Description: This version of compare_to takes a slot mask that
// indicates which attributes to include in the
// comparison. Unlike compare_to, this method
// compares the attributes by pointer.
////////////////////////////////////////////////////////////////////
int RenderState::
compare_mask(const RenderState &other, SlotMask compare_mask) const {
SlotMask mask = (_filled_slots | other._filled_slots) & compare_mask;
int slot = mask.get_lowest_on_bit();
while (slot >= 0) {
const RenderAttrib *a = _attributes[slot]._attrib;
const RenderAttrib *b = other._attributes[slot]._attrib;
if (a != b) {
return a < b ? -1 : 1;
}
mask.clear_bit(slot);
slot = mask.get_lowest_on_bit();
}
return 0;
}
////////////////////////////////////////////////////////////////////
// Function: RenderState::cull_callback
// Access: Published

1
panda/src/pgraph/renderState.h
View File

@ -67,6 +67,7 @@ public:
PUBLISHED:
int compare_to(const RenderState &other) const;
int compare_sort(const RenderState &other) const;
int compare_mask(const RenderState &other, SlotMask compare_mask) const;
INLINE size_t get_hash() const;
INLINE bool is_empty() const;

4
panda/src/pgraph/stencilAttrib.I
View File

@ -18,6 +18,6 @@
// Description: Returns render state.
////////////////////////////////////////////////////////////////////
INLINE unsigned int StencilAttrib::
get_render_state(unsigned int render_state_identifier) const {
return _stencil_render_states [render_state_identifier];
get_render_state(StencilRenderState render_state_identifier) const {
return _stencil_render_states[(int)render_state_identifier];
}

143
panda/src/pgraph/stencilAttrib.cxx
View File

@ -26,9 +26,6 @@ int StencilAttrib::_attrib_slot;
const char *StencilAttrib::
stencil_render_state_name_array[StencilAttrib::SRS_total] =
{
"SRS_front_enable",
"SRS_back_enable",
"SRS_front_comparison_function",
"SRS_front_stencil_fail_operation",
"SRS_front_stencil_pass_z_fail_operation",
@ -55,11 +52,7 @@ stencil_render_state_name_array [StencilAttrib::SRS_total] =
////////////////////////////////////////////////////////////////////
StencilAttrib::
StencilAttrib() {
_stencil_render_states [SRS_front_enable] = 0;
_stencil_render_states [SRS_back_enable] = 0;
_stencil_render_states [SRS_front_comparison_function] = SCF_always;
_stencil_render_states [SRS_front_comparison_function] = M_none;
_stencil_render_states [SRS_front_stencil_fail_operation] = SO_keep;
_stencil_render_states [SRS_front_stencil_pass_z_fail_operation] = SO_keep;
_stencil_render_states [SRS_front_stencil_pass_z_pass_operation] = SO_keep;
@ -68,7 +61,7 @@ StencilAttrib() {
_stencil_render_states [SRS_read_mask] = ~0;
_stencil_render_states [SRS_write_mask] = ~0;
_stencil_render_states [SRS_back_comparison_function] = SCF_always;
_stencil_render_states [SRS_back_comparison_function] = M_none;
_stencil_render_states [SRS_back_stencil_fail_operation] = SO_keep;
_stencil_render_states [SRS_back_stencil_pass_z_fail_operation] = SO_keep;
_stencil_render_states [SRS_back_stencil_pass_z_pass_operation] = SO_keep;
@ -84,10 +77,8 @@ StencilAttrib() {
// turned off.
////////////////////////////////////////////////////////////////////
CPT(RenderAttrib) StencilAttrib::
make_off()
{
make_off() {
StencilAttrib *attrib = new StencilAttrib;
return return_new(attrib);
}
@ -110,19 +101,20 @@ make_default() {
////////////////////////////////////////////////////////////////////
CPT(RenderAttrib) StencilAttrib::
make(
unsigned int front_enable,
unsigned int front_comparison_function,
unsigned int stencil_fail_operation,
unsigned int stencil_pass_z_fail_operation,
unsigned int front_stencil_pass_z_pass_operation,
bool front_enable,
PandaCompareFunc front_comparison_function,
StencilOperation stencil_fail_operation,
StencilOperation stencil_pass_z_fail_operation,
StencilOperation front_stencil_pass_z_pass_operation,
unsigned int reference,
unsigned int read_mask,
unsigned int write_mask)
{
StencilAttrib *attrib = new StencilAttrib;
attrib->_stencil_render_states [SRS_front_enable] = front_enable;
attrib->_stencil_render_states [SRS_back_enable] = 0;
if (!front_enable) {
front_comparison_function = M_none;
}
attrib->_stencil_render_states [SRS_front_comparison_function] = front_comparison_function;
attrib->_stencil_render_states [SRS_front_stencil_fail_operation] = stencil_fail_operation;
@ -133,7 +125,7 @@ make(
attrib->_stencil_render_states [SRS_read_mask] = read_mask;
attrib->_stencil_render_states [SRS_write_mask] = write_mask;
attrib->_stencil_render_states [SRS_back_comparison_function] = SCF_always;
attrib->_stencil_render_states [SRS_back_comparison_function] = M_none;
attrib->_stencil_render_states [SRS_back_stencil_fail_operation] = SO_keep;
attrib->_stencil_render_states [SRS_back_stencil_pass_z_fail_operation] = SO_keep;
attrib->_stencil_render_states [SRS_back_stencil_pass_z_pass_operation] = SO_keep;
@ -148,24 +140,29 @@ make(
////////////////////////////////////////////////////////////////////
CPT(RenderAttrib) StencilAttrib::
make_2_sided(
unsigned int front_enable,
unsigned int back_enable,
unsigned int front_comparison_function,
unsigned int stencil_fail_operation,
unsigned int stencil_pass_z_fail_operation,
unsigned int front_stencil_pass_z_pass_operation,
bool front_enable,
bool back_enable,
PandaCompareFunc front_comparison_function,
StencilOperation stencil_fail_operation,
StencilOperation stencil_pass_z_fail_operation,
StencilOperation front_stencil_pass_z_pass_operation,
unsigned int reference,
unsigned int read_mask,
unsigned int write_mask,
unsigned int back_comparison_function,
unsigned int back_stencil_fail_operation,
unsigned int back_stencil_pass_z_fail_operation,
unsigned int back_stencil_pass_z_pass_operation)
PandaCompareFunc back_comparison_function,
StencilOperation back_stencil_fail_operation,
StencilOperation back_stencil_pass_z_fail_operation,
StencilOperation back_stencil_pass_z_pass_operation)
{
StencilAttrib *attrib = new StencilAttrib;
attrib->_stencil_render_states [SRS_front_enable] = front_enable;
attrib->_stencil_render_states [SRS_back_enable] = back_enable;
if (!front_enable) {
front_comparison_function = M_none;
}
if (!back_enable) {
back_comparison_function = M_none;
}
attrib->_stencil_render_states [SRS_front_comparison_function] = front_comparison_function;
attrib->_stencil_render_states [SRS_front_stencil_fail_operation] = stencil_fail_operation;
@ -191,21 +188,22 @@ make_2_sided(
////////////////////////////////////////////////////////////////////
CPT(RenderAttrib) StencilAttrib::
make_with_clear(
unsigned int front_enable,
unsigned int front_comparison_function,
unsigned int stencil_fail_operation,
unsigned int stencil_pass_z_fail_operation,
unsigned int front_stencil_pass_z_pass_operation,
bool front_enable,
PandaCompareFunc front_comparison_function,
StencilOperation stencil_fail_operation,
StencilOperation stencil_pass_z_fail_operation,
StencilOperation front_stencil_pass_z_pass_operation,
unsigned int reference,
unsigned int read_mask,
unsigned int write_mask,
unsigned int clear,
bool clear,
unsigned int clear_value)
{
StencilAttrib *attrib = new StencilAttrib;
attrib->_stencil_render_states [SRS_front_enable] = front_enable;
attrib->_stencil_render_states [SRS_back_enable] = 0;
if (!front_enable) {
front_comparison_function = M_none;
}
attrib->_stencil_render_states [SRS_front_comparison_function] = front_comparison_function;
attrib->_stencil_render_states [SRS_front_stencil_fail_operation] = stencil_fail_operation;
@ -216,7 +214,7 @@ make_with_clear(
attrib->_stencil_render_states [SRS_read_mask] = read_mask;
attrib->_stencil_render_states [SRS_write_mask] = write_mask;
attrib->_stencil_render_states [SRS_back_comparison_function] = SCF_always;
attrib->_stencil_render_states [SRS_back_comparison_function] = M_none;
attrib->_stencil_render_states [SRS_back_stencil_fail_operation] = SO_keep;
attrib->_stencil_render_states [SRS_back_stencil_pass_z_fail_operation] = SO_keep;
attrib->_stencil_render_states [SRS_back_stencil_pass_z_pass_operation] = SO_keep;
@ -234,26 +232,31 @@ make_with_clear(
////////////////////////////////////////////////////////////////////
CPT(RenderAttrib) StencilAttrib::
make_2_sided_with_clear(
unsigned int front_enable,
unsigned int back_enable,
unsigned int front_comparison_function,
unsigned int stencil_fail_operation,
unsigned int stencil_pass_z_fail_operation,
unsigned int front_stencil_pass_z_pass_operation,
bool front_enable,
bool back_enable,
PandaCompareFunc front_comparison_function,
StencilOperation stencil_fail_operation,
StencilOperation stencil_pass_z_fail_operation,
StencilOperation front_stencil_pass_z_pass_operation,
unsigned int reference,
unsigned int read_mask,
unsigned int write_mask,
unsigned int back_comparison_function,
unsigned int back_stencil_fail_operation,
unsigned int back_stencil_pass_z_fail_operation,
unsigned int back_stencil_pass_z_pass_operation,
unsigned int clear,
PandaCompareFunc back_comparison_function,
StencilOperation back_stencil_fail_operation,
StencilOperation back_stencil_pass_z_fail_operation,
StencilOperation back_stencil_pass_z_pass_operation,
bool clear,
unsigned int clear_value)
{
StencilAttrib *attrib = new StencilAttrib;
attrib->_stencil_render_states [SRS_front_enable] = front_enable;
attrib->_stencil_render_states [SRS_back_enable] = back_enable;
if (!front_enable) {
front_comparison_function = M_none;
}
if (!back_enable) {
back_comparison_function = M_none;
}
attrib->_stencil_render_states [SRS_front_comparison_function] = front_comparison_function;
attrib->_stencil_render_states [SRS_front_stencil_fail_operation] = stencil_fail_operation;
@ -316,7 +319,7 @@ compare_to_impl(const RenderAttrib *other) const {
int index;
int compare_result = 0;
for (index = 0; index < SRS_total; index++) {
for (index = 0; index < SRS_total; ++index) {
a = (int) sa -> _stencil_render_states[index];
b = (int) _stencil_render_states[index];
compare_result = (a - b);
@ -368,9 +371,8 @@ void StencilAttrib::
write_datagram(BamWriter *manager, Datagram &dg) {
RenderAttrib::write_datagram(manager, dg);
int index;
for (index = 0; index < SRS_total; index++) {
dg.add_int32(_stencil_render_states [index]);
for (int index = 0; index < SRS_total; ++index) {
dg.add_uint32(_stencil_render_states[index]);
}
}
@ -405,8 +407,29 @@ void StencilAttrib::
fillin(DatagramIterator &scan, BamReader *manager) {
RenderAttrib::fillin(scan, manager);
int index;
for (index = 0; index < SRS_total; index++) {
if (manager->get_file_minor_ver() < 35) {
unsigned int front_enable, back_enable;
front_enable = scan.get_int32();
back_enable = scan.get_int32();
for (int index = 0; index < SRS_total; ++index) {
_stencil_render_states[index] = scan.get_int32();
}
if (front_enable) {
_stencil_render_states[SRS_front_comparison_function]++;
} else {
_stencil_render_states[SRS_front_comparison_function] = M_none;
}
if (back_enable) {
_stencil_render_states[SRS_back_comparison_function]++;
} else {
_stencil_render_states[SRS_back_comparison_function] = M_none;
}
} else {
for (int index = 0; index < SRS_total; ++index) {
_stencil_render_states[index] = scan.get_uint32();
}
}
}

103
panda/src/pgraph/stencilAttrib.h
View File

@ -35,13 +35,8 @@ private:
StencilAttrib();
PUBLISHED:
// enums are duplicated here from class StencilRenderStates for use in Python
enum StencilRenderState
{
SRS_front_enable,
SRS_back_enable,
enum StencilRenderState {
SRS_front_comparison_function,
SRS_front_stencil_fail_operation,
SRS_front_stencil_pass_z_fail_operation,
@ -60,24 +55,21 @@ PUBLISHED:
SRS_clear_value,
SRS_total,
SRS_first = 0,
};
enum StencilComparisonFunction
{
SCF_never,
SCF_less_than,
SCF_equal,
SCF_less_than_or_equal,
SCF_greater_than,
SCF_not_equal,
SCF_greater_than_or_equal,
SCF_always,
// Exists purely for backward compatibility.
enum StencilComparisonFunction {
SCF_never = M_never,
SCF_less_than = M_less,
SCF_equal = M_equal,
SCF_less_than_or_equal = M_less_equal,
SCF_greater_than = M_greater,
SCF_not_equal = M_not_equal,
SCF_greater_than_or_equal = M_greater_equal,
SCF_always = M_always,
};
enum StencilOperation
{
enum StencilOperation {
SO_keep,
SO_zero,
SO_replace,
@ -88,69 +80,64 @@ PUBLISHED:
SO_decrement_saturate,
};
enum StencilMask
{
SM_default = ~0,
};
static CPT(RenderAttrib) make_off();
static CPT(RenderAttrib) make_default();
static CPT(RenderAttrib) make(
unsigned int front_enable,
unsigned int front_comparison_function,
unsigned int stencil_fail_operation,
unsigned int stencil_pass_z_fail_operation,
unsigned int front_stencil_pass_z_pass_operation,
bool front_enable,
PandaCompareFunc front_comparison_function,
StencilOperation stencil_fail_operation,
StencilOperation stencil_pass_z_fail_operation,
StencilOperation front_stencil_pass_z_pass_operation,
unsigned int reference,
unsigned int read_mask,
unsigned int write_mask);
static CPT(RenderAttrib) make_2_sided(
unsigned int front_enable,
unsigned int back_enable,
unsigned int front_comparison_function,
unsigned int stencil_fail_operation,
unsigned int stencil_pass_z_fail_operation,
unsigned int front_stencil_pass_z_pass_operation,
bool front_enable,
bool back_enable,
PandaCompareFunc front_comparison_function,
StencilOperation stencil_fail_operation,
StencilOperation stencil_pass_z_fail_operation,
StencilOperation front_stencil_pass_z_pass_operation,
unsigned int reference,
unsigned int read_mask,
unsigned int write_mask,
unsigned int back_comparison_function,
unsigned int back_stencil_fail_operation,
unsigned int back_stencil_pass_z_fail_operation,
unsigned int back_stencil_pass_z_pass_operation);
PandaCompareFunc back_comparison_function,
StencilOperation back_stencil_fail_operation,
StencilOperation back_stencil_pass_z_fail_operation,
StencilOperation back_stencil_pass_z_pass_operation);
static CPT(RenderAttrib) make_with_clear(
unsigned int front_enable,
unsigned int front_comparison_function,
unsigned int stencil_fail_operation,
unsigned int stencil_pass_z_fail_operation,
unsigned int front_stencil_pass_z_pass_operation,
bool front_enable,
PandaCompareFunc front_comparison_function,
StencilOperation stencil_fail_operation,
StencilOperation stencil_pass_z_fail_operation,
StencilOperation front_stencil_pass_z_pass_operation,
unsigned int reference,
unsigned int read_mask,
unsigned int write_mask,
unsigned int clear,
bool clear,
unsigned int clear_value);
static CPT(RenderAttrib) make_2_sided_with_clear(
unsigned int front_enable,
unsigned int back_enable,
unsigned int front_comparison_function,
unsigned int stencil_fail_operation,
unsigned int stencil_pass_z_fail_operation,
unsigned int front_stencil_pass_z_pass_operation,
bool front_enable,
bool back_enable,
PandaCompareFunc front_comparison_function,
StencilOperation stencil_fail_operation,
StencilOperation stencil_pass_z_fail_operation,
StencilOperation front_stencil_pass_z_pass_operation,
unsigned int reference,
unsigned int read_mask,
unsigned int write_mask,
unsigned int back_comparison_function,
unsigned int back_stencil_fail_operation,
unsigned int back_stencil_pass_z_fail_operation,
unsigned int back_stencil_pass_z_pass_operation,
unsigned int clear,
PandaCompareFunc back_comparison_function,
StencilOperation back_stencil_fail_operation,
StencilOperation back_stencil_pass_z_fail_operation,
StencilOperation back_stencil_pass_z_pass_operation,
bool clear,
unsigned int clear_value);
INLINE unsigned int get_render_state (unsigned int render_state_identifier) const;
INLINE unsigned int get_render_state(StencilRenderState render_state_identifier) const;
public:
static const char *stencil_render_state_name_array [SRS_total];

3
panda/src/putil/bam.h
View File

@ -33,7 +33,7 @@ static const unsigned short _bam_major_ver = 6;
// Bumped to major version 6 on 2/11/06 to factor out PandaNode::CData.
static const unsigned short _bam_first_minor_ver = 14;
static const unsigned short _bam_minor_ver = 34;
static const unsigned short _bam_minor_ver = 35;
// Bumped to minor version 14 on 12/19/07 to change default ColorAttrib.
// Bumped to minor version 15 on 4/9/08 to add TextureAttrib::_implicit_sort.
// Bumped to minor version 16 on 5/13/08 to add Texture::_quality_level.
@ -55,5 +55,6 @@ static const unsigned short _bam_minor_ver = 34;
// Bumped to minor version 32 on 6/11/12 to add Texture::_has_read_mipmaps.
// Bumped to minor version 33 on 8/17/13 to add UvScrollNode::_w_speed.
// Bumped to minor version 34 on 9/16/14 to add ScissorAttrib::_off.
// Bumped to minor version 35 on 12/3/14 to change StencilAttrib.
#endif