TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-10-01 17:35:34 -04:00
Code Issues Packages Projects Releases Wiki Activity

remove unneeded call_gl* methods, reset viewport between frames

Browse Source
This commit is contained in:
David Rose 2004-09-24 17:57:34 +00:00
parent 5fa326cbe5
commit 5a74bb7f3a
3 changed files with 54 additions and 703 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -82,553 +82,6 @@ report_my_errors(int line, const char *source_file) {
#endif
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glClearColor
// Access: Public
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glClearColor(GLclampf red, GLclampf green, GLclampf blue,
GLclampf alpha) {
if (red != _clear_color_red ||
green != _clear_color_green ||
blue != _clear_color_blue ||
alpha != _clear_color_alpha) {
GLP(ClearColor)(red, green, blue, alpha);
_clear_color_red = red;
_clear_color_green = green;
_clear_color_blue = blue;
_clear_color_alpha = alpha;
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glClearDepth
// Access: Public
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glClearDepth(GLclampd depth) {
if (depth != _clear_depth) {
#ifdef GSG_VERBOSE
GLCAT.spam()
<< "glClearDepth(" << (double)depth << ")" << endl;
#endif
GLP(ClearDepth)(depth);
_clear_depth = depth;
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glClearStencil
// Access: Public
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glClearStencil(GLint s) {
if (s != _clear_stencil) {
GLP(ClearStencil)(s);
_clear_stencil = s;
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glClearAccum
// Access: Public
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glClearAccum(GLclampf red, GLclampf green, GLclampf blue,
GLclampf alpha) {
if (red != _clear_accum_red ||
green != _clear_accum_green ||
blue != _clear_accum_blue ||
alpha != _clear_accum_alpha) {
GLP(ClearAccum)(red, green, blue, alpha);
_clear_accum_red = red;
_clear_accum_green = green;
_clear_accum_blue = blue;
_clear_accum_alpha = alpha;
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glShadeModel
// Access:
// Description: Set the shading model to be either GL_FLAT or GL_SMOOTH
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glShadeModel(GLenum mode) {
if (_shade_model_mode != mode) {
GLP(ShadeModel)(mode);
_shade_model_mode = mode;
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glScissor
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
{
if ( _scissor_x != x || _scissor_y != y ||
_scissor_width != width || _scissor_height != height )
{
_scissor_x = x; _scissor_y = y;
_scissor_width = width; _scissor_height = height;
GLP(Scissor)( x, y, width, height );
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glViewport
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
{
if ( _viewport_x != x || _viewport_y != y ||
_viewport_width != width || _viewport_height != height )
{
_viewport_x = x; _viewport_y = y;
_viewport_width = width; _viewport_height = height;
GLP(Viewport)( x, y, width, height );
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glLightModelLocal
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glLightModelLocal(GLboolean local)
{
if ( _lmodel_local != local )
{
_lmodel_local = local;
GLP(LightModeli)( GL_LIGHT_MODEL_LOCAL_VIEWER, local );
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glLightModelLocal
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glLightModelTwoSide(GLboolean twoside)
{
if (_lmodel_twoside != twoside) {
_lmodel_twoside = twoside;
#ifdef GSG_VERBOSE
GLCAT.spam()
<< "glLightModel(GL_LIGHT_MODEL_TWO_SIDE, " << (int)twoside << ")" << endl;
#endif
GLP(LightModeli)(GL_LIGHT_MODEL_TWO_SIDE, twoside);
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glStencilFunc
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glStencilFunc(GLenum func,GLint ref,GLuint mask) {
#ifdef GSG_VERBOSE
GLCAT.spam() << "glStencilFunc(";
switch (func) {
case GL_NEVER:
GLCAT.spam(false) << "GL_NEVER, ";
break;
case GL_LESS:
GLCAT.spam(false) << "GL_LESS, ";
break;
case GL_EQUAL:
GLCAT.spam(false) << "GL_EQUAL, ";
break;
case GL_LEQUAL:
GLCAT.spam(false) << "GL_LEQUAL, ";
break;
case GL_GREATER:
GLCAT.spam(false) << "GL_GREATER, ";
break;
case GL_NOTEQUAL:
GLCAT.spam(false) << "GL_NOTEQUAL, ";
break;
case GL_GEQUAL:
GLCAT.spam(false) << "GL_GEQUAL, ";
break;
case GL_ALWAYS:
GLCAT.spam(false) << "GL_ALWAYS, ";
break;
default:
GLCAT.spam(false) << "unknown, ";
break;
}
GLCAT.spam(false) << (int)ref << ", " << (int)mask << ")\n";
#endif
GLP(StencilFunc)(func, ref, mask);
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glStencilOp
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glStencilOp(GLenum fail,GLenum zfail,GLenum zpass) {
#ifdef GSG_VERBOSE
GLCAT.spam() << "glStencilOp(fail, zfail, ";
switch (zpass) {
case GL_KEEP:
GLCAT.spam(false) << "GL_KEEP)";
break;
case GL_ZERO:
GLCAT.spam(false) << "GL_ZERO)";
break;
case GL_REPLACE:
GLCAT.spam(false) << "GL_REPLACE)";
break;
case GL_INCR:
GLCAT.spam(false) << "GL_INCR)";
break;
case GL_DECR:
GLCAT.spam(false) << "GL_DECR)";
break;
case GL_INVERT:
GLCAT.spam(false) << "GL_INVERT)";
break;
default:
GLCAT.spam(false) << "unknown)";
break;
}
GLCAT.spam(false) << endl;
#endif
GLP(StencilOp)(fail,zfail,zpass);
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glLineWidth
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glLineWidth(GLfloat width) {
if (_line_width != width) {
_line_width = width;
#ifdef GSG_VERBOSE
GLCAT.spam()
<< "glLineWidth(" << width << ")" << endl;
#endif
GLP(LineWidth)(width);
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glPointSize
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glPointSize(GLfloat size) {
if (_point_size != size) {
_point_size = size;
#ifdef GSG_VERBOSE
GLCAT.spam()
<< "glPointSize(" << size << ")" << endl;
#endif
GLP(PointSize)(size);
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glBlendFunc
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glBlendFunc(GLenum sfunc, GLenum dfunc) {
if (_blend_source_func != sfunc || _blend_dest_func != dfunc) {
_blend_source_func = sfunc;
_blend_dest_func = dfunc;
#ifdef GSG_VERBOSE
GLCAT.spam() << "glBlendFunc(";
switch (sfunc) {
case GL_ZERO:
GLCAT.spam(false) << "GL_ZERO, ";
break;
case GL_ONE:
GLCAT.spam(false) << "GL_ONE, ";
break;
case GL_DST_COLOR:
GLCAT.spam(false) << "GL_DST_COLOR, ";
break;
case GL_ONE_MINUS_DST_COLOR:
GLCAT.spam(false) << "GL_ONE_MINUS_DST_COLOR, ";
break;
case GL_SRC_ALPHA:
GLCAT.spam(false) << "GL_SRC_ALPHA, ";
break;
case GL_ONE_MINUS_SRC_ALPHA:
GLCAT.spam(false) << "GL_ONE_MINUS_SRC_ALPHA, ";
break;
case GL_DST_ALPHA:
GLCAT.spam(false) << "GL_DST_ALPHA, ";
break;
case GL_ONE_MINUS_DST_ALPHA:
GLCAT.spam(false) << "GL_ONE_MINUS_DST_ALPHA, ";
break;
case GL_SRC_ALPHA_SATURATE:
GLCAT.spam(false) << "GL_SRC_ALPHA_SATURATE, ";
break;
default:
GLCAT.spam(false) << "unknown, ";
break;
}
switch (dfunc) {
case GL_ZERO:
GLCAT.spam(false) << "GL_ZERO)";
break;
case GL_ONE:
GLCAT.spam(false) << "GL_ONE)";
break;
case GL_SRC_COLOR:
GLCAT.spam(false) << "GL_SRC_COLOR)";
break;
case GL_ONE_MINUS_SRC_COLOR:
GLCAT.spam(false) << "GL_ONE_MINUS_SRC_COLOR)";
break;
case GL_SRC_ALPHA:
GLCAT.spam(false) << "GL_SRC_ALPHA)";
break;
case GL_ONE_MINUS_SRC_ALPHA:
GLCAT.spam(false) << "GL_ONE_MINUS_SRC_ALPHA)";
break;
case GL_DST_ALPHA:
GLCAT.spam(false) << "GL_DST_ALPHA)";
break;
case GL_ONE_MINUS_DST_ALPHA:
GLCAT.spam(false) << "GL_ONE_MINUS_DST_ALPHA)";
break;
default:
GLCAT.spam(false) << "unknown)";
break;
}
GLCAT.spam(false) << endl;
#endif
GLP(BlendFunc)(sfunc, dfunc);
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glFogMode
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glFogMode(GLint mode) {
if (_fog_mode != mode) {
_fog_mode = mode;
#ifdef GSG_VERBOSE
GLCAT.spam() << "glFog(GL_FOG_MODE, ";
switch(mode) {
case GL_LINEAR:
GLCAT.spam(false) << "GL_LINEAR)" << endl;
break;
case GL_EXP:
GLCAT.spam(false) << "GL_EXP)" << endl;
break;
case GL_EXP2:
GLCAT.spam(false) << "GL_EXP2)" << endl;
break;
#ifdef GL_FOG_FUNC_SGIS
case GL_FOG_FUNC_SGIS:
GLCAT.spam(false) << "GL_FOG_FUNC_SGIS)" << endl;
break;
#endif
default:
GLCAT.spam(false) << "unknown)" << endl;
break;
}
#endif
GLP(Fogi)(GL_FOG_MODE, mode);
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glFogStart
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glFogStart(GLfloat start) {
if (_fog_start != start) {
_fog_start = start;
#ifdef GSG_VERBOSE
GLCAT.spam()
<< "glFog(GL_FOG_START, " << start << ")" << endl;
#endif
GLP(Fogf)(GL_FOG_START, start);
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glFogEnd
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glFogEnd(GLfloat end) {
if (_fog_end != end) {
_fog_end = end;
#ifdef GSG_VERBOSE
GLCAT.spam()
<< "glFog(GL_FOG_END, " << end << ")" << endl;
#endif
GLP(Fogf)(GL_FOG_END, end);
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glFogDensity
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glFogDensity(GLfloat density) {
if (_fog_density != density) {
_fog_density = density;
#ifdef GSG_VERBOSE
GLCAT.spam()
<< "glFog(GL_FOG_DENSITY, " << density << ")" << endl;
#endif
GLP(Fogf)(GL_FOG_DENSITY, density);
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glFogColor
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glFogColor(const Colorf &color) {
if (_fog_color != color) {
_fog_color = color;
#ifdef GSG_VERBOSE
GLCAT.spam()
<< "glFog(GL_FOG_COLOR, " << color << ")" << endl;
#endif
GLP(Fogfv)(GL_FOG_COLOR, color.get_data());
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glAlphaFunc
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glAlphaFunc(GLenum func, GLclampf ref) {
if (_alpha_func != func || _alpha_func_ref != ref) {
_alpha_func = func;
_alpha_func_ref = ref;
#ifdef GSG_VERBOSE
GLCAT.spam() << "glAlphaFunc(";
switch (func) {
case GL_NEVER:
GLCAT.spam(false) << "GL_NEVER, ";
break;
case GL_LESS:
GLCAT.spam(false) << "GL_LESS, ";
break;
case GL_EQUAL:
GLCAT.spam(false) << "GL_EQUAL, ";
break;
case GL_LEQUAL:
GLCAT.spam(false) << "GL_LEQUAL, ";
break;
case GL_GREATER:
GLCAT.spam(false) << "GL_GREATER, ";
break;
case GL_NOTEQUAL:
GLCAT.spam(false) << "GL_NOTEQUAL, ";
break;
case GL_GEQUAL:
GLCAT.spam(false) << "GL_GEQUAL, ";
break;
case GL_ALWAYS:
GLCAT.spam(false) << "GL_ALWAYS, ";
break;
}
GLCAT.spam() << ref << ")" << endl;
#endif
GLP(AlphaFunc)(func, ref);
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::call_glPolygonMode
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
call_glPolygonMode(GLenum mode) {
if (_polygon_mode != mode) {
_polygon_mode = mode;
#ifdef GSG_VERBOSE
GLCAT.spam() << "glPolygonMode(GL_BACK_AND_FRONT, ";
switch (mode) {
case GL_POINT:
GLCAT.spam(false) << "GL_POINT)" << endl;
break;
case GL_LINE:
GLCAT.spam(false) << "GL_LINE)" << endl;
break;
case GL_FILL:
GLCAT.spam(false) << "GL_FILL)" << endl;
break;
}
#endif
GLP(PolygonMode)(GL_FRONT_AND_BACK, mode);
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::set_pack_alignment
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
set_pack_alignment(GLint alignment) {
if (_pack_alignment != alignment) {
GLP(PixelStorei)(GL_PACK_ALIGNMENT, alignment);
_pack_alignment = alignment;
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::set_unpack_alignment
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void CLP(GraphicsStateGuardian)::
set_unpack_alignment(GLint alignment) {
if (_unpack_alignment != alignment) {
GLP(PixelStorei)(GL_UNPACK_ALIGNMENT, alignment);
_unpack_alignment = alignment;
}
}
////////////////////////////////////////////////////////////////////
// Function: CLP(GraphicsStateGuardian)::enable_multisample
// Access:

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

@ -396,48 +396,9 @@ reset() {
}
#endif
// Set up our clear values to invalid values, so the GLP(Clear)* calls
// will be made initially.
_clear_color_red = -1.0f;
_clear_color_green = -1.0f;
_clear_color_blue = -1.0f;
_clear_color_alpha = -1.0f;
_clear_depth = -1.0f;
_clear_stencil = -1;
_clear_accum_red = -1.0f;
_clear_accum_green = -1.0f;
_clear_accum_blue = -1.0f;
_clear_accum_alpha = -1.0f;
// Set up the specific state values to GL's known initial values.
_shade_model_mode = GL_SMOOTH;
GLP(FrontFace)(GL_CCW);
_scissor_x = 0;
_scissor_y = 0;
_scissor_width = -1;
_scissor_height = -1;
_viewport_x = 0;
_viewport_y = 0;
_viewport_width = -1;
_viewport_height = -1;
_lmodel_local = 0;
_lmodel_twoside = 0;
_line_width = 1.0f;
_point_size = 1.0f;
_blend_source_func = GL_ONE;
_blend_dest_func = GL_ZERO;
_depth_mask = false;
_fog_mode = GL_EXP;
_fog_density = 1.0f;
_fog_color.set(0.0f, 0.0f, 0.0f, 0.0f);
_alpha_func = GL_ALWAYS;
_alpha_func_ref = 0;
_polygon_mode = GL_FILL;
_pack_alignment = 4;
_unpack_alignment = 4;
// Set up all the enabled/disabled flags to GL's known initial
// values: everything off.
_multisample_enabled = false;
@ -555,10 +516,10 @@ do_clear(const RenderBuffer &buffer) {
CPT(RenderState) state = RenderState::make_empty();
if (buffer_type & RenderBuffer::T_color) {
call_glClearColor(_color_clear_value[0],
_color_clear_value[1],
_color_clear_value[2],
_color_clear_value[3]);
GLP(ClearColor)(_color_clear_value[0],
_color_clear_value[1],
_color_clear_value[2],
_color_clear_value[3]);
state = state->add_attrib(ColorWriteAttrib::make(ColorWriteAttrib::M_on));
mask |= GL_COLOR_BUFFER_BIT;
@ -566,26 +527,24 @@ do_clear(const RenderBuffer &buffer) {
}
if (buffer_type & RenderBuffer::T_depth) {
call_glClearDepth(_depth_clear_value);
GLP(ClearDepth)(_depth_clear_value);
mask |= GL_DEPTH_BUFFER_BIT;
// In order to clear the depth buffer, the depth mask must enable
// writing to the depth buffer.
if (!_depth_mask) {
state = state->add_attrib(DepthWriteAttrib::make(DepthWriteAttrib::M_on));
}
state = state->add_attrib(DepthWriteAttrib::make(DepthWriteAttrib::M_on));
}
if (buffer_type & RenderBuffer::T_stencil) {
call_glClearStencil(_stencil_clear_value != false);
GLP(ClearStencil)(_stencil_clear_value != false);
mask |= GL_STENCIL_BUFFER_BIT;
}
if (buffer_type & RenderBuffer::T_accum) {
call_glClearAccum(_accum_clear_value[0],
_accum_clear_value[1],
_accum_clear_value[2],
_accum_clear_value[3]);
GLP(ClearAccum)(_accum_clear_value[0],
_accum_clear_value[1],
_accum_clear_value[2],
_accum_clear_value[3]);
mask |= GL_ACCUM_BUFFER_BIT;
}
@ -636,8 +595,8 @@ prepare_display_region() {
GLsizei height = GLsizei(h);
enable_scissor( true );
call_glScissor( x, y, width, height );
call_glViewport( x, y, width, height );
GLP(Scissor)( x, y, width, height );
GLP(Viewport)( x, y, width, height );
}
report_my_gl_errors();
}
@ -712,6 +671,8 @@ begin_frame() {
_vertices_display_list_pcollector.clear_level();
#endif
_actual_display_region = NULL;
report_my_gl_errors();
return true;
}
@ -762,7 +723,7 @@ draw_point(GeomPoint *geom, GeomContext *gc) {
_vertices_other_pcollector.add_level(geom->get_num_vertices());
#endif
call_glPointSize(geom->get_size());
GLP(PointSize)(geom->get_size());
issue_scene_graph_color();
int nprims = geom->get_num_prims();
@ -831,7 +792,7 @@ draw_line(GeomLine *geom, GeomContext *gc) {
_vertices_other_pcollector.add_level(geom->get_num_vertices());
#endif
call_glLineWidth(geom->get_width());
GLP(LineWidth)(geom->get_width());
issue_scene_graph_color();
int nprims = geom->get_num_prims();
@ -862,9 +823,9 @@ draw_line(GeomLine *geom, GeomContext *gc) {
// Otherwise we want flat shading for performance reasons.
if ((geom->get_binding(G_COLOR) == G_PER_VERTEX && wants_colors()) ||
(geom->get_binding(G_NORMAL) == G_PER_VERTEX && wants_normals())) {
call_glShadeModel(GL_SMOOTH);
GLP(ShadeModel)(GL_SMOOTH);
} else {
call_glShadeModel(GL_FLAT);
GLP(ShadeModel)(GL_FLAT);
}
// Draw overall
@ -913,7 +874,7 @@ draw_linestrip(GeomLinestrip *geom, GeomContext *gc) {
_vertices_other_pcollector.add_level(geom->get_num_vertices());
#endif
call_glLineWidth(geom->get_width());
GLP(LineWidth)(geom->get_width());
issue_scene_graph_color();
int nprims = geom->get_num_prims();
@ -945,9 +906,9 @@ draw_linestrip(GeomLinestrip *geom, GeomContext *gc) {
// Otherwise we want flat shading for performance reasons.
if ((geom->get_binding(G_COLOR) == G_PER_VERTEX && wants_colors()) ||
(geom->get_binding(G_NORMAL) == G_PER_VERTEX && wants_normals())) {
call_glShadeModel(GL_SMOOTH);
GLP(ShadeModel)(GL_SMOOTH);
} else {
call_glShadeModel(GL_FLAT);
GLP(ShadeModel)(GL_FLAT);
}
// Draw overall
@ -1323,9 +1284,9 @@ draw_polygon(GeomPolygon *geom, GeomContext *gc) {
// Otherwise we want flat shading for performance reasons.
if ((geom->get_binding(G_COLOR) == G_PER_VERTEX && wants_colors()) ||
(geom->get_binding(G_NORMAL) == G_PER_VERTEX && wants_normals())) {
call_glShadeModel(GL_SMOOTH);
GLP(ShadeModel)(GL_SMOOTH);
} else {
call_glShadeModel(GL_FLAT);
GLP(ShadeModel)(GL_FLAT);
}
// Draw overall
@ -1409,9 +1370,9 @@ draw_tri(GeomTri *geom, GeomContext *gc) {
// Otherwise we want flat shading for performance reasons.
if ((geom->get_binding(G_COLOR) == G_PER_VERTEX && wants_colors()) ||
(geom->get_binding(G_NORMAL) == G_PER_VERTEX && wants_normals())) {
call_glShadeModel(GL_SMOOTH);
GLP(ShadeModel)(GL_SMOOTH);
} else {
call_glShadeModel(GL_FLAT);
GLP(ShadeModel)(GL_FLAT);
}
// Draw overall
@ -1493,9 +1454,9 @@ draw_quad(GeomQuad *geom, GeomContext *gc) {
// Otherwise we want flat shading for performance reasons.
if ((geom->get_binding(G_COLOR) == G_PER_VERTEX && wants_colors()) ||
(geom->get_binding(G_NORMAL) == G_PER_VERTEX && wants_normals())) {
call_glShadeModel(GL_SMOOTH);
GLP(ShadeModel)(GL_SMOOTH);
} else {
call_glShadeModel(GL_FLAT);
GLP(ShadeModel)(GL_FLAT);
}
// Draw overall
@ -1577,9 +1538,9 @@ draw_tristrip(GeomTristrip *geom, GeomContext *gc) {
// Otherwise we want flat shading for performance reasons.
if ((geom->get_binding(G_COLOR) == G_PER_VERTEX && wants_colors()) ||
(geom->get_binding(G_NORMAL) == G_PER_VERTEX && wants_normals())) {
call_glShadeModel(GL_SMOOTH);
GLP(ShadeModel)(GL_SMOOTH);
} else {
call_glShadeModel(GL_FLAT);
GLP(ShadeModel)(GL_FLAT);
}
// Draw overall
@ -1683,9 +1644,9 @@ draw_trifan(GeomTrifan *geom, GeomContext *gc) {
// Otherwise we want flat shading for performance reasons.
if ((geom->get_binding(G_COLOR) == G_PER_VERTEX && wants_colors()) ||
(geom->get_binding(G_NORMAL) == G_PER_VERTEX && wants_normals())) {
call_glShadeModel(GL_SMOOTH);
GLP(ShadeModel)(GL_SMOOTH);
} else {
call_glShadeModel(GL_FLAT);
GLP(ShadeModel)(GL_FLAT);
}
// Draw overall
@ -1783,9 +1744,9 @@ draw_sphere(GeomSphere *geom, GeomContext *gc) {
ti);
if (wants_normals()) {
call_glShadeModel(GL_SMOOTH);
GLP(ShadeModel)(GL_SMOOTH);
} else {
call_glShadeModel(GL_FLAT);
GLP(ShadeModel)(GL_FLAT);
}
// Draw overall
@ -2145,7 +2106,7 @@ texture_to_pixel_buffer(TextureContext *tc, PixelBuffer *pb,
bool CLP(GraphicsStateGuardian)::
copy_pixel_buffer(PixelBuffer *pb, const DisplayRegion *dr) {
nassertr(pb != NULL && dr != NULL, false);
set_pack_alignment(1);
GLP(PixelStorei)(GL_PACK_ALIGNMENT, 1);
// Bug fix for RE, RE2, and VTX - need to disable texturing in order
// for GLP(ReadPixels)() to work
@ -2267,8 +2228,8 @@ void CLP(GraphicsStateGuardian)::apply_material(const Material *material) {
GLP(Enable)(GL_COLOR_MATERIAL);
}
call_glLightModelLocal(material->get_local());
call_glLightModelTwoSide(material->get_twoside());
GLP(LightModeli)(GL_LIGHT_MODEL_LOCAL_VIEWER, material->get_local());
GLP(LightModeli)(GL_LIGHT_MODEL_TWO_SIDE, material->get_twoside());
report_my_gl_errors();
}
@ -2280,20 +2241,20 @@ void CLP(GraphicsStateGuardian)::apply_material(const Material *material) {
void CLP(GraphicsStateGuardian)::
apply_fog(Fog *fog) {
Fog::Mode fmode = fog->get_mode();
call_glFogMode(get_fog_mode_type(fmode));
GLP(Fogi)(GL_FOG_MODE, get_fog_mode_type(fmode));
if (fmode == Fog::M_linear) {
float onset, opaque;
fog->get_linear_range(onset, opaque);
call_glFogStart(onset);
call_glFogEnd(opaque);
GLP(Fogf)(GL_FOG_START, onset);
GLP(Fogf)(GL_FOG_END, opaque);
} else {
// Exponential fog is always camera-relative.
call_glFogDensity(fog->get_exp_density());
GLP(Fogf)(GL_FOG_DENSITY, fog->get_exp_density());
}
call_glFogColor(fog->get_color());
GLP(Fogfv)(GL_FOG_COLOR, fog->get_color().get_data());
report_my_gl_errors();
}
@ -2543,12 +2504,12 @@ issue_render_mode(const RenderModeAttrib *attrib) {
switch (mode) {
case RenderModeAttrib::M_filled:
call_glPolygonMode(GL_FILL);
GLP(PolygonMode)(GL_FRONT_AND_BACK, GL_FILL);
break;
case RenderModeAttrib::M_wireframe:
call_glLineWidth(attrib->get_line_width());
call_glPolygonMode(GL_LINE);
GLP(LineWidth)(attrib->get_line_width());
GLP(PolygonMode)(GL_FRONT_AND_BACK, GL_LINE);
break;
default:
@ -2630,7 +2591,7 @@ issue_alpha_test(const AlphaTestAttrib *attrib) {
enable_alpha_test(false);
} else {
assert(GL_NEVER==(AlphaTestAttrib::M_never-1+0x200));
call_glAlphaFunc(PANDA_TO_GL_COMPAREFUNC(mode), attrib->get_reference_alpha());
GLP(AlphaFunc)(PANDA_TO_GL_COMPAREFUNC(mode), attrib->get_reference_alpha());
enable_alpha_test(true);
}
}
@ -3353,7 +3314,7 @@ apply_texture_immediate(CLP(TextureContext) *gtc, Texture *tex) {
nassertr(wanted_size == (int)pb->_image.size(), false);
#endif // NDEBUG
set_unpack_alignment(1);
GLP(PixelStorei)(GL_UNPACK_ALIGNMENT, 1);
#ifdef GSG_VERBOSE
GLCAT.debug()
@ -3598,7 +3559,7 @@ draw_pixel_buffer(PixelBuffer *pb, const DisplayRegion *dr) {
}
set_transform(TransformState::make_identity());
set_unpack_alignment(1);
GLP(PixelStorei)(GL_UNPACK_ALIGNMENT, 1);
WindowProperties props = _win->get_properties();
@ -4276,7 +4237,7 @@ set_blend_mode(ColorWriteAttrib::Mode color_write_mode,
enable_multisample_alpha_one(false);
enable_multisample_alpha_mask(false);
enable_blend(true);
call_glBlendFunc(GL_ZERO, GL_ONE);
GLP(BlendFunc)(GL_ZERO, GL_ONE);
return;
}
@ -4289,21 +4250,21 @@ set_blend_mode(ColorWriteAttrib::Mode color_write_mode,
enable_multisample_alpha_one(false);
enable_multisample_alpha_mask(false);
enable_blend(true);
call_glBlendFunc(GL_DST_COLOR, GL_ZERO);
GLP(BlendFunc)(GL_DST_COLOR, GL_ZERO);
return;
case ColorBlendAttrib::M_add:
enable_multisample_alpha_one(false);
enable_multisample_alpha_mask(false);
enable_blend(true);
call_glBlendFunc(GL_ONE, GL_ONE);
GLP(BlendFunc)(GL_ONE, GL_ONE);
return;
case ColorBlendAttrib::M_multiply_add:
enable_multisample_alpha_one(false);
enable_multisample_alpha_mask(false);
enable_blend(true);
call_glBlendFunc(GL_DST_COLOR, GL_ONE);
GLP(BlendFunc)(GL_DST_COLOR, GL_ONE);
return;
default:
@ -4331,7 +4292,7 @@ set_blend_mode(ColorWriteAttrib::Mode color_write_mode,
enable_multisample_alpha_one(false);
enable_multisample_alpha_mask(false);
enable_blend(true);
call_glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
GLP(BlendFunc)(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
return;
case TransparencyAttrib::M_multisample:
@ -4747,7 +4708,7 @@ save_mipmap_images(Texture *tex) {
int ysize = pb->get_ysize();
// Specify byte-alignment for the pixels on output.
set_pack_alignment(1);
GLP(PixelStorei)(GL_PACK_ALIGNMENT, 1);
int mipmap_level = 0;
do {

63
panda/src/glstuff/glGraphicsStateGuardian_src.h
View File

@ -174,35 +174,6 @@ protected:
CPT(DisplayRegion) dr);
virtual void restore_frame_buffer(SavedFrameBuffer *frame_buffer);
INLINE void call_glClearColor(GLclampf red, GLclampf green, GLclampf blue,
GLclampf alpha);
INLINE void call_glClearDepth(GLclampd depth);
INLINE void call_glClearStencil(GLint s);
INLINE void call_glClearAccum(GLclampf red, GLclampf green, GLclampf blue,
GLclampf alpha);
INLINE void call_glShadeModel(GLenum mode);
INLINE void call_glBlendFunc(GLenum sfunc, GLenum dfunc);
INLINE void call_glCullFace(GLenum mode);
INLINE void call_glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
INLINE void call_glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
INLINE void call_glLightModelLocal(GLboolean local);
INLINE void call_glLightModelTwoSide(GLboolean twoside);
INLINE void call_glStencilFunc(GLenum func,GLint refval,GLuint mask);
INLINE void call_glStencilOp(GLenum fail,GLenum zfail,GLenum pass);
INLINE void call_glClipPlane(GLenum plane, const double equation[4]);
INLINE void call_glLineWidth(GLfloat width);
INLINE void call_glPointSize(GLfloat size);
INLINE void call_glFogMode(GLint mode);
INLINE void call_glFogStart(GLfloat start);
INLINE void call_glFogEnd(GLfloat end);
INLINE void call_glFogDensity(GLfloat density);
INLINE void call_glFogColor(const Colorf &color);
INLINE void call_glAlphaFunc(GLenum func, GLclampf ref);
INLINE void call_glPolygonMode(GLenum mode);
INLINE void set_pack_alignment(GLint alignment);
INLINE void set_unpack_alignment(GLint alignment);
INLINE void enable_multisample(bool val);
INLINE void enable_line_smooth(bool val);
INLINE void enable_point_smooth(bool val);
@ -254,40 +225,6 @@ protected:
void save_mipmap_images(Texture *tex);
#endif
GLclampf _clear_color_red, _clear_color_green, _clear_color_blue,
_clear_color_alpha;
GLclampd _clear_depth;
GLint _clear_stencil;
GLclampf _clear_accum_red, _clear_accum_green, _clear_accum_blue,
_clear_accum_alpha;
GLenum _shade_model_mode;
GLint _scissor_x;
GLint _scissor_y;
GLsizei _scissor_width;
GLsizei _scissor_height;
GLint _viewport_x;
GLint _viewport_y;
GLsizei _viewport_width;
GLsizei _viewport_height;
GLboolean _lmodel_local;
GLboolean _lmodel_twoside;
GLfloat _line_width;
GLfloat _point_size;
GLenum _blend_source_func;
GLenum _blend_dest_func;
GLboolean _depth_mask;
GLint _fog_mode;
GLfloat _fog_start;
GLfloat _fog_end;
GLfloat _fog_density;
Colorf _fog_color;
GLenum _alpha_func;
GLclampf _alpha_func_ref;
GLenum _polygon_mode;
GLint _pack_alignment;
GLint _unpack_alignment;
bool _multisample_enabled;
bool _line_smooth_enabled;
bool _point_smooth_enabled;