RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove use of CLP() macro for config variables

This commit is contained in:
rdb 2014-06-18 21:45:20 +00:00
parent 6454ddddc5
commit 8d3f7d62f4
7 changed files with 93 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
panda/src/glstuff/glGeomMunger_src.cxx
View File

@ -36,9 +36,9 @@ CLP(GeomMunger)(GraphicsStateGuardian *gsg, const RenderState *state) :
_flags = 0;
if (CLP(interleaved_arrays)) {
if (gl_interleaved_arrays) {
_flags |= F_interleaved_arrays;
} else if (CLP(parallel_arrays)) {
} else if (gl_parallel_arrays) {
_flags |= F_parallel_arrays;
}
}

2
panda/src/glstuff/glGraphicsStateGuardian_src.I
View File

@ -161,7 +161,7 @@ get_gl_version_minor() const {
INLINE void CLP(GraphicsStateGuardian)::
maybe_gl_finish() const {
#ifdef DO_PSTATS
if (CLP(finish)) {
if (gl_finish) {
glFinish();
}
#endif

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

@ -306,11 +306,11 @@ CLP(GraphicsStateGuardian)(GraphicsEngine *engine, GraphicsPipe *pipe) :
_is_hardware = true;
// calling glGetError() forces a sync, this turns it off if you want to.
_track_errors = !CLP(force_no_error);
_allow_flush = !CLP(force_no_flush);
_track_errors = !gl_force_no_error;
_allow_flush = !gl_force_no_flush;
#ifdef DO_PSTATS
if (CLP(finish)) {
if (gl_finish) {
GLCAT.warning()
<< "The config variable gl-finish is set True. This may have a substantial negative impact your render performance.\n";
}
@ -510,7 +510,7 @@ reset() {
In the meantime, you must put both "matrix-palette 1" and
"gl-matrix-palette 1" in your Config.prc to exercise the new
code. */
if (!CLP(matrix_palette)) {
if (!gl_matrix_palette) {
if (_supports_matrix_palette) {
if (GLCAT.is_debug()) {
GLCAT.debug() << "Forcing off matrix palette support.\n";
@ -777,7 +777,7 @@ reset() {
_supports_rescale_normal = true;
#else
_supports_rescale_normal =
CLP(support_rescale_normal) &&
gl_support_rescale_normal &&
(has_extension("GL_EXT_rescale_normal") || is_at_least_gl_version(1, 2));
#endif
@ -1269,7 +1269,7 @@ reset() {
#endif
_supports_occlusion_query = false;
if (CLP(support_occlusion_query)) {
if (gl_support_occlusion_query) {
if (is_at_least_gl_version(1, 5)) {
_supports_occlusion_query = true;
@ -1389,7 +1389,7 @@ reset() {
_border_clamp = _edge_clamp;
#ifndef OPENGLES
if (CLP(support_clamp_to_border) &&
if (gl_support_clamp_to_border &&
(has_extension("GL_ARB_texture_border_clamp") ||
is_at_least_gl_version(1, 3))) {
_border_clamp = GL_CLAMP_TO_BORDER;
@ -1756,7 +1756,7 @@ reset() {
report_my_gl_errors();
#ifndef OPENGLES_2
if (CLP(cheap_textures)) {
if (gl_cheap_textures) {
GLCAT.info()
<< "Setting glHint() for fastest textures.\n";
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
@ -1981,7 +1981,7 @@ clear(DrawableRegion *clearable) {
if (clearable->get_clear_color_active()) {
LColor v = clearable->get_clear_color();
glClearColor(v[0],v[1],v[2],v[3]);
if (CLP(color_mask)) {
if (gl_color_mask) {
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
}
_state_mask.clear_bit(ColorWriteAttrib::get_class_slot());
@ -2187,7 +2187,7 @@ begin_frame(Thread *current_thread) {
#ifndef NDEBUG
_show_texture_usage = false;
if (CLP(show_texture_usage)) {
if (gl_show_texture_usage) {
// When this is true, then every other second, we show the usage
// textures instead of the real textures.
double now = ClockObject::get_global_clock()->get_frame_time();
@ -2196,7 +2196,7 @@ begin_frame(Thread *current_thread) {
_show_texture_usage = true;
_show_texture_usage_index = this_second >> 1;
int max_size = CLP(show_texture_usage_max_size);
int max_size = gl_show_texture_usage_max_size;
if (max_size != _show_texture_usage_max_size) {
// Remove the cache of usage textures; we've changed the max
// size.
@ -2561,7 +2561,7 @@ begin_draw_primitives(const GeomPipelineReader *geom_reader,
// If it has been modified, or this is the first time, then we
// need to build the display list up.
if (CLP(compile_and_execute)) {
if (gl_compile_and_execute) {
glNewList(_geom_display_list, GL_COMPILE_AND_EXECUTE);
} else {
glNewList(_geom_display_list, GL_COMPILE);
@ -2884,7 +2884,7 @@ update_standard_vertex_arrays(bool force) {
void CLP(GraphicsStateGuardian)::
unbind_buffers() {
if (_current_vbuffer_index != 0) {
if (GLCAT.is_spam() && CLP(debug_buffers)) {
if (GLCAT.is_spam() && gl_debug_buffers) {
GLCAT.spam()
<< "unbinding vertex buffer\n";
}
@ -2892,7 +2892,7 @@ unbind_buffers() {
_current_vbuffer_index = 0;
}
if (_current_ibuffer_index != 0) {
if (GLCAT.is_spam() && CLP(debug_buffers)) {
if (GLCAT.is_spam() && gl_debug_buffers) {
GLCAT.spam()
<< "unbinding index buffer\n";
}
@ -3450,7 +3450,7 @@ end_draw_primitives() {
glEndList();
_load_display_list_pcollector.stop();
if (!CLP(compile_and_execute)) {
if (!gl_compile_and_execute) {
glCallList(_geom_display_list);
}
_primitive_batches_display_list_pcollector.add_level(1);
@ -3747,7 +3747,7 @@ prepare_vertex_buffer(GeomVertexArrayData *data) {
CLP(VertexBufferContext) *gvbc = new CLP(VertexBufferContext)(this, _prepared_objects, data);
_glGenBuffers(1, &gvbc->_index);
if (GLCAT.is_debug() && CLP(debug_buffers)) {
if (GLCAT.is_debug() && gl_debug_buffers) {
GLCAT.debug()
<< "creating vertex buffer " << (int)gvbc->_index << ": "
<< data->get_num_rows() << " vertices "
@ -3780,7 +3780,7 @@ apply_vertex_buffer(VertexBufferContext *vbc,
CLP(VertexBufferContext) *gvbc = DCAST(CLP(VertexBufferContext), vbc);
if (_current_vbuffer_index != gvbc->_index) {
if (GLCAT.is_spam() && CLP(debug_buffers)) {
if (GLCAT.is_spam() && gl_debug_buffers) {
GLCAT.spam()
<< "binding vertex buffer " << (int)gvbc->_index << "\n";
}
@ -3791,7 +3791,7 @@ apply_vertex_buffer(VertexBufferContext *vbc,
if (gvbc->was_modified(reader)) {
int num_bytes = reader->get_data_size_bytes();
if (GLCAT.is_debug() && CLP(debug_buffers)) {
if (GLCAT.is_debug() && gl_debug_buffers) {
GLCAT.debug()
<< "copying " << num_bytes
<< " bytes into vertex buffer " << (int)gvbc->_index << "\n";
@ -3836,7 +3836,7 @@ release_vertex_buffer(VertexBufferContext *vbc) {
CLP(VertexBufferContext) *gvbc = DCAST(CLP(VertexBufferContext), vbc);
if (GLCAT.is_debug() && CLP(debug_buffers)) {
if (GLCAT.is_debug() && gl_debug_buffers) {
GLCAT.debug()
<< "deleting vertex buffer " << (int)gvbc->_index << "\n";
}
@ -3846,7 +3846,7 @@ release_vertex_buffer(VertexBufferContext *vbc) {
// help out a flaky driver, and we need to keep our internal state
// consistent anyway.
if (_current_vbuffer_index == gvbc->_index) {
if (GLCAT.is_spam() && CLP(debug_buffers)) {
if (GLCAT.is_spam() && gl_debug_buffers) {
GLCAT.spam()
<< "unbinding vertex buffer\n";
}
@ -3890,11 +3890,11 @@ setup_array_data(const unsigned char *&client_pointer,
return (client_pointer != NULL);
}
if (!vertex_buffers || _geom_display_list != 0 ||
array_reader->get_usage_hint() < CLP(min_buffer_usage_hint)) {
array_reader->get_usage_hint() < gl_min_buffer_usage_hint) {
// The array specifies client rendering only, or buffer objects
// are configured off.
if (_current_vbuffer_index != 0) {
if (GLCAT.is_spam() && CLP(debug_buffers)) {
if (GLCAT.is_spam() && gl_debug_buffers) {
GLCAT.spam()
<< "unbinding vertex buffer\n";
}
@ -3936,7 +3936,7 @@ prepare_index_buffer(GeomPrimitive *data) {
CLP(IndexBufferContext) *gibc = new CLP(IndexBufferContext)(this, _prepared_objects, data);
_glGenBuffers(1, &gibc->_index);
if (GLCAT.is_debug() && CLP(debug_buffers)) {
if (GLCAT.is_debug() && gl_debug_buffers) {
GLCAT.debug()
<< "creating index buffer " << (int)gibc->_index << ": "
<< data->get_num_vertices() << " indices ("
@ -3972,7 +3972,7 @@ apply_index_buffer(IndexBufferContext *ibc,
CLP(IndexBufferContext) *gibc = DCAST(CLP(IndexBufferContext), ibc);
if (_current_ibuffer_index != gibc->_index) {
if (GLCAT.is_spam() && CLP(debug_buffers)) {
if (GLCAT.is_spam() && gl_debug_buffers) {
GLCAT.spam()
<< "binding index buffer " << (int)gibc->_index << "\n";
}
@ -3983,7 +3983,7 @@ apply_index_buffer(IndexBufferContext *ibc,
if (gibc->was_modified(reader)) {
int num_bytes = reader->get_data_size_bytes();
if (GLCAT.is_debug() && CLP(debug_buffers)) {
if (GLCAT.is_debug() && gl_debug_buffers) {
GLCAT.debug()
<< "copying " << num_bytes
<< " bytes into index buffer " << (int)gibc->_index << "\n";
@ -4028,7 +4028,7 @@ release_index_buffer(IndexBufferContext *ibc) {
CLP(IndexBufferContext) *gibc = DCAST(CLP(IndexBufferContext), ibc);
if (GLCAT.is_debug() && CLP(debug_buffers)) {
if (GLCAT.is_debug() && gl_debug_buffers) {
GLCAT.debug()
<< "deleting index buffer " << (int)gibc->_index << "\n";
}
@ -4038,7 +4038,7 @@ release_index_buffer(IndexBufferContext *ibc) {
// help out a flaky driver, and we need to keep our internal state
// consistent anyway.
if (_current_ibuffer_index == gibc->_index) {
if (GLCAT.is_spam() && CLP(debug_buffers)) {
if (GLCAT.is_spam() && gl_debug_buffers) {
GLCAT.spam()
<< "unbinding index buffer\n";
}
@ -4086,7 +4086,7 @@ setup_primitive(const unsigned char *&client_pointer,
// The array specifies client rendering only, or buffer objects
// are configured off.
if (_current_ibuffer_index != 0) {
if (GLCAT.is_spam() && CLP(debug_buffers)) {
if (GLCAT.is_spam() && gl_debug_buffers) {
GLCAT.spam()
<< "unbinding index buffer\n";
}
@ -4224,7 +4224,7 @@ framebuffer_copy_to_texture(Texture *tex, int view, int z,
const DisplayRegion *dr, const RenderBuffer &rb) {
nassertr(tex != NULL && dr != NULL, false);
set_read_buffer(rb._buffer_type);
if (CLP(color_mask)) {
if (gl_color_mask) {
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
}
@ -4315,7 +4315,7 @@ framebuffer_copy_to_texture(Texture *tex, int view, int z,
int height = tex->get_y_size();
int depth = tex->get_z_size();
bool uses_mipmaps = tex->uses_mipmaps() && !CLP(ignore_mipmaps);
bool uses_mipmaps = tex->uses_mipmaps() && !gl_ignore_mipmaps;
if (uses_mipmaps) {
#ifndef OPENGLES_2
if (_supports_generate_mipmap) {
@ -4414,7 +4414,7 @@ framebuffer_copy_to_ram(Texture *tex, int view, int z,
nassertr(tex != NULL && dr != NULL, false);
set_read_buffer(rb._buffer_type);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
if (CLP(color_mask)) {
if (gl_color_mask) {
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
}
@ -5121,7 +5121,7 @@ do_issue_material() {
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, material->get_local());
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, material->get_twoside());
if (CLP(separate_specular_color)) {
if (gl_separate_specular_color) {
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
} else {
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SINGLE_COLOR);
@ -5154,7 +5154,7 @@ do_issue_blending() {
int color_write_slot = ColorWriteAttrib::get_class_slot();
enable_multisample_alpha_one(false);
enable_multisample_alpha_mask(false);
if (CLP(color_mask)) {
if (gl_color_mask) {
enable_blend(false);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
} else {
@ -5164,7 +5164,7 @@ do_issue_blending() {
}
return;
} else {
if (CLP(color_mask)) {
if (gl_color_mask) {
glColorMask((color_channels & ColorWriteAttrib::C_red) != 0,
(color_channels & ColorWriteAttrib::C_green) != 0,
(color_channels & ColorWriteAttrib::C_blue) != 0,
@ -5526,7 +5526,7 @@ gl_get_error() const {
bool CLP(GraphicsStateGuardian)::
report_errors_loop(int line, const char *source_file, GLenum error_code,
int &error_count) {
while ((CLP(max_errors) < 0 || error_count < CLP(max_errors)) &&
while ((gl_max_errors < 0 || error_count < gl_max_errors) &&
(error_code != GL_NO_ERROR)) {
GLCAT.error()
<< "at " << line << " of " << source_file << " : "
@ -5946,7 +5946,7 @@ set_draw_buffer(int rbtype) {
#endif // OPENGLES
// Also ensure that any global color channels are masked out.
if (CLP(color_mask)) {
if (gl_color_mask) {
glColorMask((_color_write_mask & ColorWriteAttrib::C_red) != 0,
(_color_write_mask & ColorWriteAttrib::C_green) != 0,
(_color_write_mask & ColorWriteAttrib::C_blue) != 0,
@ -6136,7 +6136,7 @@ get_texture_target(Texture::TextureType texture_type) const {
////////////////////////////////////////////////////////////////////
GLenum CLP(GraphicsStateGuardian)::
get_texture_wrap_mode(Texture::WrapMode wm) const {
if (CLP(ignore_clamp)) {
if (gl_ignore_clamp) {
return GL_REPEAT;
}
switch (wm) {
@ -6206,7 +6206,7 @@ get_panda_wrap_mode(GLenum wm) {
////////////////////////////////////////////////////////////////////
GLenum CLP(GraphicsStateGuardian)::
get_texture_filter_type(Texture::FilterType ft, bool ignore_mipmaps) {
if (CLP(ignore_filters)) {
if (gl_ignore_filters) {
return GL_NEAREST;
} else if (ignore_mipmaps) {
@ -8696,10 +8696,10 @@ specify_texture(CLP(TextureContext) *gtc) {
Texture::FilterType minfilter = tex->get_effective_minfilter();
Texture::FilterType magfilter = tex->get_effective_magfilter();
bool uses_mipmaps = Texture::is_mipmap(minfilter) && !CLP(ignore_mipmaps);
bool uses_mipmaps = Texture::is_mipmap(minfilter) && !gl_ignore_mipmaps;
#ifndef NDEBUG
if (CLP(force_mipmaps)) {
if (gl_force_mipmaps) {
minfilter = Texture::FT_linear_mipmap_linear;
magfilter = Texture::FT_linear;
uses_mipmaps = true;
@ -8965,10 +8965,10 @@ upload_texture(CLP(TextureContext) *gtc, bool force) {
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
bool uses_mipmaps = (tex->uses_mipmaps() && !CLP(ignore_mipmaps)) || CLP(force_mipmaps);
bool uses_mipmaps = (tex->uses_mipmaps() && !gl_ignore_mipmaps) || gl_force_mipmaps;
#ifndef NDEBUG
if (CLP(force_mipmaps)) {
if (gl_force_mipmaps) {
uses_mipmaps = true;
}
#endif

2
panda/src/glstuff/glIndexBufferContext_src.cxx
View File

@ -35,7 +35,7 @@ evict_lru() {
// Make sure the buffer is unbound before we delete it.
if (_glgsg->_current_ibuffer_index == _index) {
if (GLCAT.is_debug() && CLP(debug_buffers)) {
if (GLCAT.is_debug() && gl_debug_buffers) {
GLCAT.debug()
<< "unbinding index buffer\n";
}

2
panda/src/glstuff/glVertexBufferContext_src.cxx
View File

@ -35,7 +35,7 @@ evict_lru() {
// Make sure the buffer is unbound before we delete it.
if (_glgsg->_current_vbuffer_index == _index) {
if (GLCAT.is_debug() && CLP(debug_buffers)) {
if (GLCAT.is_debug() && gl_debug_buffers) {
GLCAT.debug()
<< "unbinding vertex buffer\n";
}

48
panda/src/glstuff/glmisc_src.cxx
View File

@ -14,45 +14,45 @@
#include "pandaSystem.h"
ConfigVariableBool CLP(cheap_textures)
ConfigVariableBool gl_cheap_textures
("gl-cheap-textures", false,
PRC_DESC("Configure this true to glHint the textures into the cheapest "
"possible mode."));
ConfigVariableBool CLP(ignore_clamp)
ConfigVariableBool gl_ignore_clamp
("gl-ignore-clamp", false,
PRC_DESC("Configure this true to disable texture clamp mode (all textures "
"repeat, a little cheaper for software renderers)."));
ConfigVariableBool CLP(support_clamp_to_border)
ConfigVariableBool gl_support_clamp_to_border
("gl-support-clamp-to-border", true,
PRC_DESC("Configure this true to enable the use of the clamp_to_border "
"extension if the GL claims to support it, or false not to "
"use it even if it appears to be available. (On some OpenGL "
"drivers, enabling this mode can force software rendering.)"));
ConfigVariableBool CLP(support_rescale_normal)
ConfigVariableBool gl_support_rescale_normal
("gl-support-rescale-normal", true,
PRC_DESC("Configure this true to enable the use of the rescale_normal "
"extension if the GL claims to support it, or false not to use "
"it even if it appears to be available. (This appears to be "
"buggy on some drivers.)"));
ConfigVariableBool CLP(ignore_filters)
ConfigVariableBool gl_ignore_filters
("gl-ignore-filters", false,
PRC_DESC("Configure this true to disable any texture filters at all (forcing "
"point sampling)."));
ConfigVariableBool CLP(ignore_mipmaps)
ConfigVariableBool gl_ignore_mipmaps
("gl-ignore-mipmaps", false,
PRC_DESC("Configure this true to disable mipmapping only."));
ConfigVariableBool CLP(force_mipmaps)
ConfigVariableBool gl_force_mipmaps
("gl-force-mipmaps", false,
PRC_DESC("Configure this true to enable full trilinear mipmapping on every "
"texture, whether it asks for it or not."));
ConfigVariableBool CLP(show_texture_usage)
ConfigVariableBool gl_show_texture_usage
("gl-show-texture-usage", false,
PRC_DESC("If you set this true, the screen will flash with textures drawn "
"in a special mode that shows the mipmap detail level and texture "
@ -60,27 +60,27 @@ ConfigVariableBool CLP(show_texture_usage)
"mipmap level 0, yellow for mipmap level 1, and red for all higher "
"mipmap levels. Brighter colors represent larger textures."));
ConfigVariableInt CLP(show_texture_usage_max_size)
ConfigVariableInt gl_show_texture_usage_max_size
("gl-show-texture-usage-max-size", 1024,
PRC_DESC("Specifies the texture size (along one side) of the largest "
"texture expected to be loaded. This controls the assignment "
"of the texture color in gl-show-texture-usage mode; colors "
"will be fully bright for textures of this size or larger."));
ConfigVariableBool CLP(color_mask)
ConfigVariableBool gl_color_mask
("gl-color-mask", true,
PRC_DESC("Configure this false if your GL's implementation of glColorMask() "
"is broken (some are). This will force the use of a (presumably) "
"more expensive blending operation instead."));
ConfigVariableBool CLP(support_occlusion_query)
ConfigVariableBool gl_support_occlusion_query
("gl-support-occlusion-query", true,
PRC_DESC("Configure this true to enable the use of the occlusion_query "
"extension if the GL claims to support it, or false not to "
"use it even if it appears to be available. (On some OpenGL "
"drivers, enabling this mode can force software rendering.)"));
ConfigVariableBool CLP(compile_and_execute)
ConfigVariableBool gl_compile_and_execute
("gl-compile-and-execute", false,
PRC_DESC("Configure this true if you know your GL's implementation of "
"glNewList(n, GL_COMPILE_AND_EXECUTE) works. It is "
@ -90,7 +90,7 @@ ConfigVariableBool CLP(compile_and_execute)
"for the first time, by allowing the display list to be "
"rendered at the same time it is being compiled."));
ConfigVariableBool CLP(interleaved_arrays)
ConfigVariableBool gl_interleaved_arrays
("gl-interleaved-arrays", false,
PRC_DESC("Set this true to convert OpenGL geometry such that the "
"primary data columns vertex, normal, color, and texcoord "
@ -98,20 +98,20 @@ ConfigVariableBool CLP(interleaved_arrays)
"render geometry as it appears in the GeomVertexData. See "
"also gl-parallel-arrays."));
ConfigVariableBool CLP(parallel_arrays)
ConfigVariableBool gl_parallel_arrays
("gl-parallel-arrays", false,
PRC_DESC("Set this true to convert OpenGL geometry such that each "
"data column is a separate array, or false to "
"render geometry as it appears in the GeomVertexData. See "
"also gl-interleaved-arrays."));
ConfigVariableInt CLP(max_errors)
ConfigVariableInt gl_max_errors
("gl-max-errors", 20,
PRC_DESC("This is the limit on the number of OpenGL errors Panda will "
"detect and report before it shuts down rendering. Set it to "
"-1 for no limit."));
ConfigVariableEnum<GeomEnums::UsageHint> CLP(min_buffer_usage_hint)
ConfigVariableEnum<GeomEnums::UsageHint> gl_min_buffer_usage_hint
("gl-min-buffer-usage-hint", GeomEnums::UH_stream,
PRC_DESC("This specifies the first usage hint value that will be "
"loaded as a vertex buffer, instead of directly from the "
@ -126,13 +126,13 @@ ConfigVariableEnum<GeomEnums::UsageHint> CLP(min_buffer_usage_hint)
"of reusing the same buffers. Consider increasing "
"released-vbuffer-cache-size instead."));
ConfigVariableBool CLP(debug_buffers)
ConfigVariableBool gl_debug_buffers
("gl-debug-buffers", false,
PRC_DESC("Set this true, in addition to enabling debug notify for "
"glgsg, to enable debug messages about the creation and "
"destruction of OpenGL vertex buffers."));
ConfigVariableBool CLP(finish)
ConfigVariableBool gl_finish
("gl-finish", false,
PRC_DESC("Set this true to force a call to glFinish() after every major "
"graphics operation. This is likely to slow down rendering "
@ -140,23 +140,23 @@ ConfigVariableBool CLP(finish)
"more accurately reflect where the graphics bottlenecks are. "
"This variable is enabled only if PStats is compiled in."));
ConfigVariableBool CLP(force_depth_stencil)
ConfigVariableBool gl_force_depth_stencil
("gl-force-depth-stencil", false,
PRC_DESC("Temporary hack variable 7x00 vs 8x00 nVidia bug. See glGraphicsStateGuardian_src.cxx."));
ConfigVariableBool CLP(matrix_palette)
ConfigVariableBool gl_matrix_palette
("gl-matrix-palette", false,
PRC_DESC("Temporary hack variable protecting untested code. See glGraphicsStateGuardian_src.cxx."));
ConfigVariableBool CLP(force_no_error)
ConfigVariableBool gl_force_no_error
("gl-force-no-error", false,
PRC_DESC("Avoid reporting OpenGL errors, for a small performance benefit."));
ConfigVariableBool CLP(force_no_flush)
ConfigVariableBool gl_force_no_flush
("gl-force-no-flush", false,
PRC_DESC("Avoid calling glFlush(), for a potential performance benefit. This may be a little dangerous."));
ConfigVariableBool CLP(separate_specular_color)
ConfigVariableBool gl_separate_specular_color
("gl-separate-specular-color", true,
PRC_DESC("When separate specular mode is on, the specular component "
"will be written to the secondary instead of the primary "
@ -164,7 +164,7 @@ ConfigVariableBool CLP(separate_specular_color)
"words, the specular highlight will be unmodulated by the "
"color of the texture."));
extern ConfigVariableBool CLP(parallel_arrays);
extern ConfigVariableBool gl_parallel_arrays;
void CLP(init_classes)() {
CLP(GeomContext)::init_type();

44
panda/src/glstuff/glmisc_src.h
View File

@ -40,28 +40,28 @@
//#define GSG_VERBOSE 1
extern ConfigVariableBool CLP(cheap_textures);
extern ConfigVariableBool CLP(ignore_clamp);
extern ConfigVariableBool CLP(support_clamp_to_border);
extern ConfigVariableBool CLP(ignore_filters);
extern ConfigVariableBool CLP(ignore_mipmaps);
extern ConfigVariableBool CLP(force_mipmaps);
extern ConfigVariableBool CLP(show_texture_usage);
extern ConfigVariableInt CLP(show_texture_usage_max_size);
extern ConfigVariableBool CLP(color_mask);
extern ConfigVariableBool CLP(support_occlusion_query);
extern ConfigVariableBool CLP(compile_and_execute);
extern ConfigVariableBool CLP(interleaved_arrays);
extern ConfigVariableBool CLP(parallel_arrays);
extern ConfigVariableInt CLP(max_errors);
extern ConfigVariableEnum<GeomEnums::UsageHint> CLP(min_buffer_usage_hint);
extern ConfigVariableBool CLP(debug_buffers);
extern ConfigVariableBool CLP(finish);
extern ConfigVariableBool CLP(force_depth_stencil);
extern ConfigVariableBool CLP(matrix_palette);
extern ConfigVariableBool CLP(force_no_error);
extern ConfigVariableBool CLP(force_no_flush);
extern ConfigVariableBool CLP(separate_specular_color);
extern ConfigVariableBool gl_cheap_textures;
extern ConfigVariableBool gl_ignore_clamp;
extern ConfigVariableBool gl_support_clamp_to_border;
extern ConfigVariableBool gl_ignore_filters;
extern ConfigVariableBool gl_ignore_mipmaps;
extern ConfigVariableBool gl_force_mipmaps;
extern ConfigVariableBool gl_show_texture_usage;
extern ConfigVariableInt gl_show_texture_usage_max_size;
extern ConfigVariableBool gl_color_mask;
extern ConfigVariableBool gl_support_occlusion_query;
extern ConfigVariableBool gl_compile_and_execute;
extern ConfigVariableBool gl_interleaved_arrays;
extern ConfigVariableBool gl_parallel_arrays;
extern ConfigVariableInt gl_max_errors;
extern ConfigVariableEnum<GeomEnums::UsageHint> gl_min_buffer_usage_hint;
extern ConfigVariableBool gl_debug_buffers;
extern ConfigVariableBool gl_finish;
extern ConfigVariableBool gl_force_depth_stencil;
extern ConfigVariableBool gl_matrix_palette;
extern ConfigVariableBool gl_force_no_error;
extern ConfigVariableBool gl_force_no_flush;
extern ConfigVariableBool gl_separate_specular_color;
extern EXPCL_GL void CLP(init_classes)();