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

add lummask pixfmt

Browse Source
This commit is contained in:
georges 2000-12-19 06:55:03 +00:00
parent f3f4f877e8
commit 09be56009d
4 changed files with 230 additions and 227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
panda/src/egg/eggTexture.cxx
View File

@ -195,17 +195,17 @@ is_equivalent_to(const EggTexture &other, int eq) const {
if (eq & E_basename) {
if (a.get_basename_wo_extension() != b.get_basename_wo_extension()) {
return false;
return false;
}
}
if (eq & E_extension) {
if (a.get_extension() != b.get_extension()) {
return false;
return false;
}
}
if (eq & E_dirname) {
if (a.get_dirname() != b.get_dirname()) {
return false;
return false;
}
}
}
@ -217,21 +217,21 @@ is_equivalent_to(const EggTexture &other, int eq) const {
if (has_transform() && other.has_transform()) {
if (!_transform.almost_equal(other._transform, 0.0001)) {
return false;
return false;
}
}
}
if (eq & E_attributes) {
if (_format != other._format ||
_wrap_mode != other._wrap_mode ||
_wrap_u != other._wrap_u ||
_wrap_v != other._wrap_v ||
_minfilter != other._minfilter ||
_magfilter != other._magfilter ||
_magfilteralpha != other._magfilteralpha ||
_magfiltercolor != other._magfiltercolor ||
_env_type != other._env_type) {
_wrap_mode != other._wrap_mode ||
_wrap_u != other._wrap_u ||
_wrap_v != other._wrap_v ||
_minfilter != other._minfilter ||
_magfilter != other._magfilter ||
_magfilteralpha != other._magfilteralpha ||
_magfiltercolor != other._magfiltercolor ||
_env_type != other._env_type) {
return false;
}
if (EggAlphaMode::operator != (other)) {
@ -269,17 +269,17 @@ sorts_less_than(const EggTexture &other, int eq) const {
if (eq & E_basename) {
if (a.get_basename_wo_extension() != b.get_basename_wo_extension()) {
return a.get_basename_wo_extension() < b.get_basename_wo_extension();
return a.get_basename_wo_extension() < b.get_basename_wo_extension();
}
}
if (eq & E_extension) {
if (a.get_extension() != b.get_extension()) {
return a.get_extension() < b.get_extension();
return a.get_extension() < b.get_extension();
}
}
if (eq & E_dirname) {
if (a.get_dirname() != b.get_dirname()) {
return a.get_dirname() < b.get_dirname();
return a.get_dirname() < b.get_dirname();
}
}
}
@ -294,7 +294,7 @@ sorts_less_than(const EggTexture &other, int eq) const {
if (has_transform() && other.has_transform()) {
int compare = _transform.compare_to(other._transform);
if (compare != 0) {
return compare < 0;
return compare < 0;
}
}
}
@ -354,7 +354,7 @@ sorts_less_than(const EggTexture &other, int eq) const {
bool EggTexture::
has_alpha_channel(int num_components) const {
return (num_components == 2 || num_components == 4 ||
(num_components == 1 && _format == F_alpha));
(num_components == 1 && _format == F_alpha));
}
////////////////////////////////////////////////////////////////////
@ -389,10 +389,6 @@ string_format(const string &string) {
return F_rgba5;
} else if (cmp_nocase_uh(string, "rgb332") == 0) {
return F_rgb332;
} else if (cmp_nocase_uh(string, "luminance_alpha") == 0) {
return F_luminance_alpha;
} else if (cmp_nocase_uh(string, "red") == 0) {
return F_red;
} else if (cmp_nocase_uh(string, "green") == 0) {
@ -403,6 +399,10 @@ string_format(const string &string) {
return F_alpha;
} else if (cmp_nocase_uh(string, "luminance") == 0) {
return F_luminance;
} else if (cmp_nocase_uh(string, "luminance_alpha") == 0) {
return F_luminance_alpha;
} else if (cmp_nocase_uh(string, "luminance_alphamask") == 0) {
return F_luminance_alphamask;
} else {
return F_unspecified;
}
@ -523,9 +523,6 @@ ostream &operator << (ostream &out, EggTexture::Format format) {
case EggTexture::F_rgb332:
return out << "rgb332";
case EggTexture::F_luminance_alpha:
return out << "luminance-alpha";
case EggTexture::F_red:
return out << "red";
case EggTexture::F_green:
@ -536,6 +533,10 @@ ostream &operator << (ostream &out, EggTexture::Format format) {
return out << "alpha";
case EggTexture::F_luminance:
return out << "luminance";
case EggTexture::F_luminance_alpha:
return out << "luminance_alpha";
case EggTexture::F_luminance_alphamask:
return out << "luminance_alphamask";
}
nassertr(false, out);

10
panda/src/egg/eggTexture.h
View File

@ -15,7 +15,7 @@
////////////////////////////////////////////////////////////////////
// Class : EggTexture
// Class : EggTexture
// Description : Defines a texture map that may be applied to
// geometry.
////////////////////////////////////////////////////////////////////
@ -46,8 +46,8 @@ public:
F_unspecified,
F_rgba, F_rgbm, F_rgba12, F_rgba8, F_rgba4, F_rgba5,
F_rgb, F_rgb12, F_rgb8, F_rgb5, F_rgb332,
F_luminance_alpha,
F_red, F_green, F_blue, F_alpha, F_luminance,
F_luminance_alpha, F_luminance_alphamask
};
enum WrapMode {
WM_unspecified, WM_repeat, WM_clamp
@ -150,7 +150,7 @@ public:
EggAlphaMode::init_type();
register_type(_type_handle, "EggTexture",
EggFilenameNode::get_class_type(),
EggAlphaMode::get_class_type());
EggAlphaMode::get_class_type());
}
virtual TypeHandle get_type() const {
return get_class_type();
@ -162,7 +162,7 @@ private:
};
///////////////////////////////////////////////////////////////////
// Class : UniqueEggTextures
// Class : UniqueEggTextures
// Description : An STL function object for sorting textures into
// order by properties. Returns true if the two
// referenced EggTexture pointers are in sorted order,
@ -177,7 +177,7 @@ public:
};
///////////////////////////////////////////////////////////////////
// Class : TRefEggTextures
// Class : TRefEggTextures
// Description : An STL function object for sorting textures into
// order by TRef name.
////////////////////////////////////////////////////////////////////

387
panda/src/glgsg/glGraphicsStateGuardian.cxx
View File

@ -114,7 +114,7 @@ issue_texcoord_gl(const Geom *geom, Geom::TexCoordIterator &tciterator) {
static void
issue_color_gl(const Geom *geom, Geom::ColorIterator &citerator,
const GraphicsStateGuardianBase *) {
const GraphicsStateGuardianBase *) {
const Colorf &color = geom->get_next_color(citerator);
// glgsg_cat.debug() << "Issuing color " << color << "\n";
glColor4fv(color.get_data());
@ -122,7 +122,7 @@ issue_color_gl(const Geom *geom, Geom::ColorIterator &citerator,
static void
issue_transformed_color_gl(const Geom *geom, Geom::ColorIterator &citerator,
const GraphicsStateGuardianBase *gsg) {
const GraphicsStateGuardianBase *gsg) {
const GLGraphicsStateGuardian *glgsg = DCAST(GLGraphicsStateGuardian, gsg);
const Colorf &color = geom->get_next_color(citerator);
@ -194,9 +194,9 @@ reset() {
// All GL implementations have the following buffers. (?)
_buffer_mask = (RenderBuffer::T_color |
RenderBuffer::T_depth |
RenderBuffer::T_stencil |
RenderBuffer::T_accum);
RenderBuffer::T_depth |
RenderBuffer::T_stencil |
RenderBuffer::T_accum);
// Check to see if we have double-buffering.
GLboolean has_back;
@ -344,11 +344,11 @@ clear(const RenderBuffer &buffer) {
if (buffer_type & RenderBuffer::T_color) {
call_glClearColor(_color_clear_value[0],
_color_clear_value[1],
_color_clear_value[2],
_color_clear_value[3]);
_color_clear_value[1],
_color_clear_value[2],
_color_clear_value[3]);
state.set_attribute(ColorMaskTransition::get_class_type(),
new ColorMaskAttribute);
new ColorMaskAttribute);
mask |= GL_COLOR_BUFFER_BIT;
set_draw_buffer(buffer);
@ -362,7 +362,7 @@ clear(const RenderBuffer &buffer) {
// writing to the depth buffer.
if (!_depth_mask) {
state.set_attribute(DepthWriteTransition::get_class_type(),
new DepthWriteAttribute);
new DepthWriteAttribute);
}
}
@ -373,9 +373,9 @@ clear(const RenderBuffer &buffer) {
if (buffer_type & RenderBuffer::T_accum) {
call_glClearAccum(_accum_clear_value[0],
_accum_clear_value[1],
_accum_clear_value[2],
_accum_clear_value[3]);
_accum_clear_value[1],
_accum_clear_value[2],
_accum_clear_value[3]);
mask |= GL_ACCUM_BUFFER_BIT;
}
@ -418,7 +418,7 @@ clear(const RenderBuffer &buffer, const DisplayRegion *region) {
// Function: GLGraphicsStateGuardian::prepare_display_region
// Access: Public, Virtual
// Description: Prepare a display region for rendering (set up
// scissor region and viewport)
// scissor region and viewport)
////////////////////////////////////////////////////////////////////
void GLGraphicsStateGuardian::
prepare_display_region() {
@ -482,31 +482,31 @@ render_frame(const AllAttributesWrapper &initial_state) {
if (_win->is_channel_defined(c)) {
GraphicsChannel *chan = _win->get_channel(c);
if (chan->is_active()) {
int num_layers = chan->get_num_layers();
for (int l = 0; l < num_layers; l++) {
GraphicsLayer *layer = chan->get_layer(l);
if (layer->is_active()) {
int num_drs = layer->get_num_drs();
for (int d = 0; d < num_drs; d++) {
DisplayRegion *dr = layer->get_dr(d);
if (dr == (DisplayRegion*)NULL)
{
cerr << "null camera layer " << endl;
exit(0);
}
Camera *cam = dr->get_camera();
// For each display region, render from the camera's view.
if (dr->is_active() && cam != (Camera *)NULL &&
cam->is_active() && cam->get_scene() != (Node *)NULL) {
DisplayRegionStack old_dr = push_display_region(dr);
prepare_display_region();
render_scene(cam->get_scene(), cam, initial_state);
pop_display_region(old_dr);
}
}
}
}
int num_layers = chan->get_num_layers();
for (int l = 0; l < num_layers; l++) {
GraphicsLayer *layer = chan->get_layer(l);
if (layer->is_active()) {
int num_drs = layer->get_num_drs();
for (int d = 0; d < num_drs; d++) {
DisplayRegion *dr = layer->get_dr(d);
if (dr == (DisplayRegion*)NULL)
{
cerr << "null camera layer " << endl;
exit(0);
}
Camera *cam = dr->get_camera();
// For each display region, render from the camera's view.
if (dr->is_active() && cam != (Camera *)NULL &&
cam->is_active() && cam->get_scene() != (Node *)NULL) {
DisplayRegionStack old_dr = push_display_region(dr);
prepare_display_region();
render_scene(cam->get_scene(), cam, initial_state);
pop_display_region(old_dr);
}
}
}
}
}
}
}
@ -555,7 +555,7 @@ render_frame(const AllAttributesWrapper &initial_state) {
////////////////////////////////////////////////////////////////////
void GLGraphicsStateGuardian::
render_scene(Node *root, const ProjectionNode *projnode,
const AllAttributesWrapper &initial_state) {
const AllAttributesWrapper &initial_state) {
#ifdef GSG_VERBOSE
_pass_number = 0;
glgsg_cat.debug()
@ -565,7 +565,7 @@ render_scene(Node *root, const ProjectionNode *projnode,
_current_root_node = root;
render_subgraph(_render_traverser, root, projnode, initial_state,
AllTransitionsWrapper());
AllTransitionsWrapper());
#ifdef GSG_VERBOSE
glgsg_cat.debug()
@ -584,9 +584,9 @@ render_scene(Node *root, const ProjectionNode *projnode,
////////////////////////////////////////////////////////////////////
void GLGraphicsStateGuardian::
render_subgraph(RenderTraverser *traverser,
Node *subgraph, const ProjectionNode *projnode,
const AllAttributesWrapper &initial_state,
const AllTransitionsWrapper &net_trans) {
Node *subgraph, const ProjectionNode *projnode,
const AllAttributesWrapper &initial_state,
const AllTransitionsWrapper &net_trans) {
// Calling activate() frequently seems to be intolerably expensive
// on some platforms. We'll limit ourselves for now to calling it
// only during the clear().
@ -662,8 +662,8 @@ render_subgraph(RenderTraverser *traverser,
////////////////////////////////////////////////////////////////////
void GLGraphicsStateGuardian::
render_subgraph(RenderTraverser *traverser, Node *subgraph,
const AllAttributesWrapper &initial_state,
const AllTransitionsWrapper &net_trans) {
const AllAttributesWrapper &initial_state,
const AllTransitionsWrapper &net_trans) {
#ifdef GSG_VERBOSE
glgsg_cat.debug()
<< "begin subgraph (pass " << ++_pass_number
@ -713,10 +713,10 @@ draw_point(const GeomPoint *geom) {
}
GeomIssuer issuer(geom, this,
issue_vertex_gl,
issue_normal_gl,
issue_texcoord_gl,
issue_color);
issue_vertex_gl,
issue_normal_gl,
issue_texcoord_gl,
issue_color);
// Draw overall
issuer.issue_color(G_OVERALL, ci);
@ -897,7 +897,7 @@ public:
// this struct exists because the STL can sort faster than i can.
struct draw_sprite_vertex_less {
INLINE bool operator ()(const WrappedSprite& v0,
const WrappedSprite& v1) const {
const WrappedSprite& v1) const {
return v0._v[2] < v1._v[2]; }
};
@ -1071,7 +1071,7 @@ draw_sprite(const GeomSprite *geom) {
ws._y_ratio = *y_walk++;
if (theta_on) {
if (theta_overall == false)
ws._theta = *theta_walk++;
ws._theta = *theta_walk++;
}
cameraspace_vector.push_back(ws);
@ -1083,7 +1083,7 @@ draw_sprite(const GeomSprite *geom) {
// if you want accuracy, use billboards and take the speed hit.
if (alpha) {
sort(cameraspace_vector.begin(), cameraspace_vector.end(),
draw_sprite_vertex_less());
draw_sprite_vertex_less());
}
int tex_bottom = 0, tex_top = 1, tex_right = 1, tex_left = 0;
@ -1116,11 +1116,11 @@ draw_sprite(const GeomSprite *geom) {
// if not G_OVERALL, do some trig for this z rotate
if (theta_on) {
if (theta_overall == false)
theta = cur_image._theta;
theta = cur_image._theta;
// create the rotated points
LMatrix3f xform_mat = LMatrix3f::rotate_mat(theta) *
LMatrix3f::scale_mat(scaled_width, scaled_height);
LMatrix3f::scale_mat(scaled_width, scaled_height);
ur = (xform_mat * LVector3f(1, 1, 0)) + cur_image._v;
ul = (xform_mat * LVector3f(-1, 1, 0)) + cur_image._v;
@ -1192,10 +1192,10 @@ draw_polygon(const GeomPolygon *geom) {
}
GeomIssuer issuer(geom, this,
issue_vertex_gl,
issue_normal_gl,
issue_texcoord_gl,
issue_color);
issue_vertex_gl,
issue_normal_gl,
issue_texcoord_gl,
issue_color);
// If we have per-vertex colors or normals, we need smooth shading.
// Otherwise we want flat shading for performance reasons.
@ -1262,10 +1262,10 @@ draw_tri(const GeomTri *geom) {
}
GeomIssuer issuer(geom, this,
issue_vertex_gl,
issue_normal_gl,
issue_texcoord_gl,
issue_color);
issue_vertex_gl,
issue_normal_gl,
issue_texcoord_gl,
issue_color);
// If we have per-vertex colors or normals, we need smooth shading.
// Otherwise we want flat shading for performance reasons.
@ -1328,10 +1328,10 @@ draw_quad(const GeomQuad *geom) {
}
GeomIssuer issuer(geom, this,
issue_vertex_gl,
issue_normal_gl,
issue_texcoord_gl,
issue_color);
issue_vertex_gl,
issue_normal_gl,
issue_texcoord_gl,
issue_color);
// If we have per-vertex colors or normals, we need smooth shading.
// Otherwise we want flat shading for performance reasons.
@ -1395,10 +1395,10 @@ draw_tristrip(const GeomTristrip *geom) {
}
GeomIssuer issuer(geom, this,
issue_vertex_gl,
issue_normal_gl,
issue_texcoord_gl,
issue_color);
issue_vertex_gl,
issue_normal_gl,
issue_texcoord_gl,
issue_color);
// If we have per-vertex colors or normals, we need smooth shading.
// Otherwise we want flat shading for performance reasons.
@ -1483,10 +1483,10 @@ draw_trifan(const GeomTrifan *geom) {
}
GeomIssuer issuer(geom, this,
issue_vertex_gl,
issue_normal_gl,
issue_texcoord_gl,
issue_color);
issue_vertex_gl,
issue_normal_gl,
issue_texcoord_gl,
issue_color);
// If we have per-vertex colors or normals, we need smooth shading.
// Otherwise we want flat shading for performance reasons.
@ -1713,7 +1713,7 @@ static int binary_log_cap(const int x) {
// Function: GLGraphicsStateGuardian::copy_texture
// Access: Public, Virtual
// Description: Copy the pixel region indicated by the display
// region from the framebuffer into texture memory
// region from the framebuffer into texture memory
////////////////////////////////////////////////////////////////////
void GLGraphicsStateGuardian::
copy_texture(TextureContext *tc, const DisplayRegion *dr) {
@ -1745,9 +1745,9 @@ copy_texture(TextureContext *tc, const DisplayRegion *dr) {
bind_texture(tc);
glCopyTexImage2D( GL_TEXTURE_2D, tex->get_level(),
get_internal_image_format(pb->get_format()),
pb->get_xorg(), pb->get_yorg(),
pb->get_xsize(), pb->get_ysize(), pb->get_border() );
get_internal_image_format(pb->get_format()),
pb->get_xorg(), pb->get_yorg(),
pb->get_xsize(), pb->get_ysize(), pb->get_border() );
}
////////////////////////////////////////////////////////////////////
@ -1790,17 +1790,17 @@ draw_texture(TextureContext *tc, const DisplayRegion *dr) {
taa->set_mode(TextureApplyProperty::M_decal);
state.set_attribute(LightTransition::get_class_type(),
new LightAttribute);
new LightAttribute);
state.set_attribute(ColorMaskTransition::get_class_type(),
new ColorMaskAttribute);
new ColorMaskAttribute);
state.set_attribute(RenderModeTransition::get_class_type(),
new RenderModeAttribute);
new RenderModeAttribute);
state.set_attribute(TexMatrixTransition::get_class_type(),
new TexMatrixAttribute);
new TexMatrixAttribute);
state.set_attribute(TransformTransition::get_class_type(),
new TransformAttribute);
new TransformAttribute);
state.set_attribute(ColorBlendTransition::get_class_type(),
new ColorBlendAttribute);
new ColorBlendAttribute);
state.set_attribute(CullFaceTransition::get_class_type(), cfa);
state.set_attribute(DepthTestTransition::get_class_type(), dta);
state.set_attribute(DepthWriteTransition::get_class_type(), dwa);
@ -1886,7 +1886,7 @@ texture_to_pixel_buffer(TextureContext *tc, PixelBuffer *pb) {
////////////////////////////////////////////////////////////////////
void GLGraphicsStateGuardian::
texture_to_pixel_buffer(TextureContext *tc, PixelBuffer *pb,
const DisplayRegion *dr) {
const DisplayRegion *dr) {
nassertv(tc != NULL && pb != NULL && dr != NULL);
// activate();
@ -1924,7 +1924,7 @@ copy_pixel_buffer(PixelBuffer *pb, const DisplayRegion *dr) {
// NOTE: reading the depth buffer is *much* slower than reading the
// color buffer
state.set_attribute(TextureTransition::get_class_type(),
new TextureAttribute);
new TextureAttribute);
set_state(state, false);
int xo, yo, w, h;
@ -1965,10 +1965,10 @@ copy_pixel_buffer(PixelBuffer *pb, const DisplayRegion *dr) {
#endif
glReadPixels( pb->get_xorg() + xo, pb->get_yorg() + yo,
pb->get_xsize(), pb->get_ysize(),
get_external_image_format(pb->get_format()),
get_image_type(pb->get_image_type()),
pb->_image.p() );
pb->get_xsize(), pb->get_ysize(),
get_external_image_format(pb->get_format()),
get_image_type(pb->get_image_type()),
pb->_image.p() );
nassertv(!pb->_image.empty());
}
@ -1980,7 +1980,7 @@ copy_pixel_buffer(PixelBuffer *pb, const DisplayRegion *dr) {
////////////////////////////////////////////////////////////////////
void GLGraphicsStateGuardian::
copy_pixel_buffer(PixelBuffer *pb, const DisplayRegion *dr,
const RenderBuffer &rb) {
const RenderBuffer &rb) {
// activate();
set_read_buffer(rb);
copy_pixel_buffer(pb, dr);
@ -1993,7 +1993,7 @@ copy_pixel_buffer(PixelBuffer *pb, const DisplayRegion *dr,
////////////////////////////////////////////////////////////////////
void GLGraphicsStateGuardian::
draw_pixel_buffer(PixelBuffer *pb, const DisplayRegion *dr,
const NodeAttributes& na) {
const NodeAttributes& na) {
nassertv(pb != NULL && dr != NULL);
nassertv(!pb->_image.empty());
// activate();
@ -2003,15 +2003,15 @@ draw_pixel_buffer(PixelBuffer *pb, const DisplayRegion *dr,
NodeAttributes state(na);
state.set_attribute(LightTransition::get_class_type(),
new LightAttribute);
new LightAttribute);
state.set_attribute(TextureTransition::get_class_type(),
new TextureAttribute);
new TextureAttribute);
state.set_attribute(TransformTransition::get_class_type(),
new TransformAttribute);
new TransformAttribute);
//state.set_attribute(ColorBlendTransition::get_class_type(),
// new ColorBlendAttribute);
// new ColorBlendAttribute);
state.set_attribute(StencilTransition::get_class_type(),
new StencilAttribute);
new StencilAttribute);
switch (pb->get_format()) {
case PixelBuffer::F_depth_component:
@ -2101,9 +2101,9 @@ draw_pixel_buffer(PixelBuffer *pb, const DisplayRegion *dr,
glRasterPos2i( pb->get_xorg(), pb->get_yorg() );
glDrawPixels( pb->get_xsize(), pb->get_ysize(),
get_external_image_format(pb->get_format()),
get_image_type(pb->get_image_type()),
pb->_image.p() );
get_external_image_format(pb->get_format()),
get_image_type(pb->get_image_type()),
pb->_image.p() );
glMatrixMode( GL_PROJECTION );
glPopMatrix();
@ -2134,11 +2134,11 @@ void GLGraphicsStateGuardian::apply_material( Material* material )
call_glMaterialAmbient( material->get_twoside(), material->get_ambient() );
call_glMaterialDiffuse( material->get_twoside(), material->get_diffuse() );
call_glMaterialSpecular( material->get_twoside(),
material->get_specular() );
material->get_specular() );
call_glMaterialShininess( material->get_twoside(),
material->get_shininess() );
material->get_shininess() );
call_glMaterialEmission( material->get_twoside(),
material->get_emission() );
material->get_emission() );
call_glLightModelLocal( material->get_local() );
call_glLightModelTwoSide( material->get_twoside() );
@ -2189,7 +2189,7 @@ void GLGraphicsStateGuardian::apply_light( PointLight* light )
glPushMatrix();
glLoadMatrixf(LMatrix4f::convert_mat(_coordinate_system, CS_yup_right)
.get_data());
.get_data());
GLenum id = get_light_id( _cur_light_id );
Colorf black(0, 0, 0, 1);
@ -2247,7 +2247,7 @@ void GLGraphicsStateGuardian::apply_light( DirectionalLight* light )
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadMatrixf(LMatrix4f::convert_mat(_coordinate_system, CS_yup_right)
.get_data());
.get_data());
GLenum id = get_light_id( _cur_light_id );
Colorf black(0, 0, 0, 1);
@ -2258,7 +2258,7 @@ void GLGraphicsStateGuardian::apply_light( DirectionalLight* light )
// Position needs to specify x, y, z, and w
// w == 0 implies light is at infinity
LPoint3f dir = get_rel_forward( light, _current_projection_node,
_coordinate_system );
_coordinate_system );
LPoint4f pos( -dir[0], -dir[1], -dir[2], 0 );
glLightfv( id, GL_POSITION, pos.get_data() );
@ -2304,7 +2304,7 @@ void GLGraphicsStateGuardian::apply_light( Spotlight* light )
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadMatrixf(LMatrix4f::convert_mat(_coordinate_system, CS_yup_right)
.get_data());
.get_data());
GLenum id = get_light_id( _cur_light_id );
Colorf black(0, 0, 0, 1);
@ -2319,17 +2319,17 @@ void GLGraphicsStateGuardian::apply_light( Spotlight* light )
glLightfv( id, GL_POSITION, fpos.get_data() );
glLightfv( id, GL_SPOT_DIRECTION,
get_rel_forward( light, _current_projection_node,
_coordinate_system ).get_data() );
get_rel_forward( light, _current_projection_node,
_coordinate_system ).get_data() );
glLightf( id, GL_SPOT_EXPONENT, light->get_exponent() );
glLightf( id, GL_SPOT_CUTOFF,
light->get_cutoff_angle() );
light->get_cutoff_angle() );
glLightf( id, GL_CONSTANT_ATTENUATION,
light->get_constant_attenuation() );
light->get_constant_attenuation() );
glLightf( id, GL_LINEAR_ATTENUATION,
light->get_linear_attenuation() );
light->get_linear_attenuation() );
glLightf( id, GL_QUADRATIC_ATTENUATION,
light->get_quadratic_attenuation() );
light->get_quadratic_attenuation() );
glPopMatrix();
#ifdef GSG_VERBOSE
@ -2630,23 +2630,23 @@ void GLGraphicsStateGuardian::issue_light(const LightAttribute *attrib )
// Check to see if this light has already been bound to an id
for (i = 0; i < _max_lights; i++) {
if (_available_light_ids[i] == light) {
// Light has already been bound to an id, we only need
// to enable the light, not apply it
_cur_light_id = -2;
enable_light(i, true);
_cur_light_enabled[i] = true;
break;
// Light has already been bound to an id, we only need
// to enable the light, not apply it
_cur_light_id = -2;
enable_light(i, true);
_cur_light_enabled[i] = true;
break;
}
}
// See if there are any unbound light ids
if (_cur_light_id == -1) {
for (i = 0; i < _max_lights; i++) {
if (_available_light_ids[i] == NULL) {
_available_light_ids[i] = light;
_cur_light_id = i;
break;
}
if (_available_light_ids[i] == NULL) {
_available_light_ids[i] = light;
_cur_light_id = i;
break;
}
}
}
@ -2654,11 +2654,11 @@ void GLGraphicsStateGuardian::issue_light(const LightAttribute *attrib )
// a currently unused but previously bound id
if (_cur_light_id == -1) {
for (i = 0; i < _max_lights; i++) {
if (attrib->is_off(_available_light_ids[i])) {
_available_light_ids[i] = light;
_cur_light_id = i;
break;
}
if (attrib->is_off(_available_light_ids[i])) {
_available_light_ids[i] = light;
_cur_light_id = i;
break;
}
}
}
@ -2670,7 +2670,7 @@ void GLGraphicsStateGuardian::issue_light(const LightAttribute *attrib )
light->apply(this);
} else if (_cur_light_id == -1) {
glgsg_cat.error()
<< "issue_light() - failed to bind light to id" << endl;
<< "issue_light() - failed to bind light to id" << endl;
}
}
@ -2748,9 +2748,9 @@ void GLGraphicsStateGuardian::
issue_color_mask(const ColorMaskAttribute *attrib) {
// activate();
glColorMask(attrib->is_write_r(),
attrib->is_write_g(),
attrib->is_write_b(),
attrib->is_write_a());
attrib->is_write_g(),
attrib->is_write_b(),
attrib->is_write_a());
}
////////////////////////////////////////////////////////////////////
@ -2865,23 +2865,23 @@ issue_clip_plane(const ClipPlaneAttribute *attrib)
// Check to see if this clip plane has already been bound to an id
for (i = 0; i < _max_clip_planes; i++) {
if (_available_clip_plane_ids[i] == plane_node) {
// Clip plane has already been bound to an id, we only need
// to enable the clip plane, not apply it
_cur_clip_plane_id = -2;
enable_clip_plane(i, true);
_cur_clip_plane_enabled[i] = true;
break;
// Clip plane has already been bound to an id, we only need
// to enable the clip plane, not apply it
_cur_clip_plane_id = -2;
enable_clip_plane(i, true);
_cur_clip_plane_enabled[i] = true;
break;
}
}
// See if there are any unbound clip plane ids
if (_cur_clip_plane_id == -1) {
for (i = 0; i < _max_clip_planes; i++) {
if (_available_clip_plane_ids[i] == NULL) {
_available_clip_plane_ids[i] = plane_node;
_cur_clip_plane_id = i;
break;
}
if (_available_clip_plane_ids[i] == NULL) {
_available_clip_plane_ids[i] = plane_node;
_cur_clip_plane_id = i;
break;
}
}
}
@ -2889,11 +2889,11 @@ issue_clip_plane(const ClipPlaneAttribute *attrib)
// a currently unused but previously bound id
if (_cur_clip_plane_id == -1) {
for (i = 0; i < _max_clip_planes; i++) {
if (attrib->is_off(_available_clip_plane_ids[i])) {
_available_clip_plane_ids[i] = plane_node;
_cur_clip_plane_id = i;
break;
}
if (attrib->is_off(_available_clip_plane_ids[i])) {
_available_clip_plane_ids[i] = plane_node;
_cur_clip_plane_id = i;
break;
}
}
}
@ -2914,7 +2914,7 @@ issue_clip_plane(const ClipPlaneAttribute *attrib)
glPopMatrix();
} else if (_cur_clip_plane_id == -1) {
glgsg_cat.error()
<< "issue_clip_plane() - failed to bind clip plane to id" << endl;
<< "issue_clip_plane() - failed to bind clip plane to id" << endl;
}
}
@ -3194,27 +3194,27 @@ end_decal(GeomNode *base_geom) {
// Disable the writing to the color buffer, however we have to
// do this.
if (gl_decal_type == GDT_blend) {
// For the early nVidia Linux driver, at least, we don't seem
// to have a working glColorMask. So we have to disable the
// color writes through the use of a blend function.
// Expensive.
// For the early nVidia Linux driver, at least, we don't seem
// to have a working glColorMask. So we have to disable the
// color writes through the use of a blend function.
// Expensive.
enable_blend(true);
call_glBlendFunc(GL_ZERO, GL_ONE);
enable_blend(true);
call_glBlendFunc(GL_ZERO, GL_ONE);
} else {
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
}
// No need to have texturing on for this.
enable_texturing(false);
base_geom->draw(this);
// Finally, restore the depth write and color mask states to the
// way they're supposed to be.
DepthWriteAttribute *depth_write;
if (get_attribute_into(depth_write, _state,
DepthWriteTransition::get_class_type())) {
DepthWriteTransition::get_class_type())) {
issue_depth_write(depth_write);
}
@ -3379,20 +3379,20 @@ bind_texture(TextureContext *tc) {
void GLGraphicsStateGuardian::
specify_texture(Texture *tex) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
get_texture_wrap_mode(tex->get_wrapu()));
get_texture_wrap_mode(tex->get_wrapu()));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
get_texture_wrap_mode(tex->get_wrapv()));
get_texture_wrap_mode(tex->get_wrapv()));
if (gl_force_mipmaps) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_LINEAR);
GL_LINEAR_MIPMAP_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
} else {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
get_texture_filter_type(tex->get_minfilter()));
get_texture_filter_type(tex->get_minfilter()));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
get_texture_filter_type(tex->get_magfilter()));
get_texture_filter_type(tex->get_magfilter()));
}
}
@ -3436,20 +3436,20 @@ apply_texture_immediate(Texture *tex) {
if (use_mipmaps || gl_force_mipmaps) {
#ifndef NDEBUG
if (gl_show_mipmaps) {
build_phony_mipmaps(tex);
return;
build_phony_mipmaps(tex);
return;
}
#endif
gluBuild2DMipmaps(GL_TEXTURE_2D, internal_format,
pb->get_xsize(), pb->get_ysize(),
external_format, type, pb->_image);
pb->get_xsize(), pb->get_ysize(),
external_format, type, pb->_image);
return;
}
}
glTexImage2D( GL_TEXTURE_2D, 0, internal_format,
pb->get_xsize(), pb->get_ysize(), pb->get_border(),
external_format, type, pb->_image );
pb->get_xsize(), pb->get_ysize(), pb->get_border(),
external_format, type, pb->_image );
}
////////////////////////////////////////////////////////////////////
@ -3573,6 +3573,7 @@ get_external_image_format(PixelBuffer::Format format) {
return GL_RGBA;
case PixelBuffer::F_luminance:
return GL_LUMINANCE;
case PixelBuffer::F_luminance_alphamask:
case PixelBuffer::F_luminance_alpha:
return GL_LUMINANCE_ALPHA;
}
@ -3614,9 +3615,6 @@ get_internal_image_format(PixelBuffer::Format format) {
case PixelBuffer::F_rgb332:
return GL_R3_G3_B2;
case PixelBuffer::F_luminance_alpha:
return GL_LUMINANCE_ALPHA;
case PixelBuffer::F_alpha:
return GL_ALPHA;
@ -3625,6 +3623,9 @@ get_internal_image_format(PixelBuffer::Format format) {
case PixelBuffer::F_blue:
case PixelBuffer::F_luminance:
return GL_LUMINANCE;
case PixelBuffer::F_luminance_alpha:
case PixelBuffer::F_luminance_alphamask:
return GL_LUMINANCE_ALPHA;
default:
glgsg_cat.error()
@ -3638,18 +3639,18 @@ get_internal_image_format(PixelBuffer::Format format) {
// Function: GLGraphicsStateGuardian::get_texture_apply_mode_type
// Access: Protected
// Description: Maps from the texture environment's mode types
// to the corresponding OpenGL ids
// to the corresponding OpenGL ids
////////////////////////////////////////////////////////////////////
GLint GLGraphicsStateGuardian::
get_texture_apply_mode_type( TextureApplyProperty::Mode am ) const
{
switch( am )
{
case TextureApplyProperty::M_modulate: return GL_MODULATE;
case TextureApplyProperty::M_decal: return GL_DECAL;
case TextureApplyProperty::M_blend: return GL_BLEND;
case TextureApplyProperty::M_replace: return GL_REPLACE;
case TextureApplyProperty::M_add: return GL_ADD;
case TextureApplyProperty::M_modulate: return GL_MODULATE;
case TextureApplyProperty::M_decal: return GL_DECAL;
case TextureApplyProperty::M_blend: return GL_BLEND;
case TextureApplyProperty::M_replace: return GL_REPLACE;
case TextureApplyProperty::M_add: return GL_ADD;
}
glgsg_cat.error()
<< "Invalid TextureApplyProperty::Mode value" << endl;
@ -3780,13 +3781,13 @@ print_gfx_visual() {
glGetIntegerv( GL_STENCIL_BITS, &i ); cout << "Stencil: " << i << endl;
glGetBooleanv( GL_DOUBLEBUFFER, &j ); cout << "DoubleBuffer? "
<< (int)j << endl;
<< (int)j << endl;
glGetBooleanv( GL_STEREO, &j ); cout << "Stereo? " << (int)j << endl;
#ifdef GL_MULTISAMPLE_SGIS
glGetBooleanv( GL_MULTISAMPLE_SGIS, &j ); cout << "Multisample? "
<< (int)j << endl;
<< (int)j << endl;
#endif
#ifdef GL_SAMPLES_SGIS
glGetIntegerv( GL_SAMPLES_SGIS, &i ); cout << "Samples: " << i << endl;
@ -3794,9 +3795,9 @@ print_gfx_visual() {
glGetBooleanv( GL_BLEND, &j ); cout << "Blend? " << (int)j << endl;
glGetBooleanv( GL_POINT_SMOOTH, &j ); cout << "Point Smooth? "
<< (int)j << endl;
<< (int)j << endl;
glGetBooleanv( GL_LINE_SMOOTH, &j ); cout << "Line Smooth? "
<< (int)j << endl;
<< (int)j << endl;
glGetIntegerv( GL_AUX_BUFFERS, &i ); cout << "Aux Buffers: " << i << endl;
}
@ -3839,14 +3840,14 @@ free_pointers() {
////////////////////////////////////////////////////////////////////
PT(SavedFrameBuffer) GLGraphicsStateGuardian::
save_frame_buffer(const RenderBuffer &buffer,
CPT(DisplayRegion) dr) {
CPT(DisplayRegion) dr) {
GLSavedFrameBuffer *sfb = new GLSavedFrameBuffer(buffer, dr);
if (buffer._buffer_type & RenderBuffer::T_depth) {
// Save the depth buffer.
sfb->_depth =
new PixelBuffer(PixelBuffer::depth_buffer(dr->get_pixel_width(),
dr->get_pixel_height()));
dr->get_pixel_height()));
copy_pixel_buffer(sfb->_depth, dr, buffer);
}
@ -3872,7 +3873,7 @@ restore_frame_buffer(SavedFrameBuffer *frame_buffer) {
(sfb->_buffer._buffer_type & RenderBuffer::T_back) != 0) {
// Restore the color buffer.
draw_texture(sfb->_back_rgba->prepare(this),
sfb->_display_region, sfb->_buffer);
sfb->_display_region, sfb->_buffer);
}
if (sfb->_depth != (PixelBuffer *)NULL &&
@ -3978,8 +3979,8 @@ build_phony_mipmap_level(int level, int xsize, int ysize) {
glgsg_cat.info(false)
<< " " << filename << " cannot be read, making solid color mipmap.\n";
image_sized.fill(level_colors[level][0],
level_colors[level][1],
level_colors[level][2]);
level_colors[level][1],
level_colors[level][2]);
}
PixelBuffer *pb = new PixelBuffer;
@ -3990,8 +3991,8 @@ build_phony_mipmap_level(int level, int xsize, int ysize) {
GLenum type = get_image_type(pb->get_image_type());
glTexImage2D(GL_TEXTURE_2D, level, internal_format,
pb->get_xsize(), pb->get_ysize(), pb->get_border(),
external_format, type, pb->_image );
pb->get_xsize(), pb->get_ysize(), pb->get_border(),
external_format, type, pb->_image );
delete pb;
}
@ -4023,7 +4024,7 @@ TypeHandle GLGraphicsStateGuardian::get_class_type(void) {
void GLGraphicsStateGuardian::init_type(void) {
GraphicsStateGuardian::init_type();
register_type(_type_handle, "GLGraphicsStateGuardian",
GraphicsStateGuardian::get_class_type());
GraphicsStateGuardian::get_class_type());
}
@ -4136,7 +4137,7 @@ ostream &output_gl_enum(ostream &out, GLenum v) {
case GL_EDGE_FLAG:
return out << "GL_EDGE_FLAG";
/* Vertex Arrays */
/* Vertex Arrays */
case GL_VERTEX_ARRAY:
return out << "GL_VERTEX_ARRAY";
case GL_NORMAL_ARRAY:
@ -5193,7 +5194,7 @@ ostream &output_gl_enum(ostream &out, GLenum v) {
case GL_OUT_OF_MEMORY:
return out << "GL_OUT_OF_MEMORY";
/* OpenGL 1.2 */
/* OpenGL 1.2 */
case GL_RESCALE_NORMAL:
return out << "GL_RESCALE_NORMAL";
case GL_CLAMP_TO_EDGE:

11
panda/src/gobj/pixelBuffer.h
View File

@ -56,12 +56,13 @@ public:
F_rgba8, // 8 bits per R,G,B,A channel
F_rgba12, // 12 bits per R,G,B,A channel
F_luminance,
F_luminance_alpha
F_luminance_alpha, // 8 bits luminance, 8 bits alpha
F_luminance_alphamask // 8 bits luminance, only needs 1 bit of alpha
};
INLINE PixelBuffer(void);
INLINE PixelBuffer(int xsize, int ysize, int components,
int component_width, Type type, Format format);
int component_width, Type type, Format format);
INLINE PixelBuffer(const PixelBuffer &copy);
INLINE void operator = (const PixelBuffer &copy);
@ -85,11 +86,11 @@ public:
virtual void copy(GraphicsStateGuardianBase *gsg, const DisplayRegion *dr);
virtual void copy(GraphicsStateGuardianBase *gsg, const DisplayRegion *dr,
const RenderBuffer &rb);
const RenderBuffer &rb);
virtual void draw(GraphicsStateGuardianBase *gsg);
virtual void draw(GraphicsStateGuardianBase *gsg, const DisplayRegion *dr);
virtual void draw(GraphicsStateGuardianBase *gsg, const DisplayRegion *dr,
const RenderBuffer &rb);
const RenderBuffer &rb);
INLINE void set_xsize(int size);
INLINE void set_ysize(int size);
@ -108,7 +109,7 @@ public:
INLINE Type get_image_type() const;
INLINE void set_uchar_rgb_texel(const uchar color[3],
int x, int y, int width);
int x, int y, int width);
private:
INLINE void store_unsigned_byte(int &index, double value);