/**
* 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."
*
* @file geomEnums.h
* @author drose
* @date 2005-04-14
*/
#ifndef GEOMENUMS_H
#define GEOMENUMS_H
#include "pandabase.h"
/**
* This class exists just to provide scoping for the various enumerated types
* used by Geom, GeomVertexData, GeomVertexArrayData, GeomPrimitive, and other
* related classes.
*/
class EXPCL_PANDA_GOBJ GeomEnums {
PUBLISHED:
// The usage hint describes to the rendering backend how often the data in
// question will be modified andor rendered. It allows the backend to make
// appropriate choices about what part of memory the data should be stored
// in.
// The hint is provided as a performance optimization only, and does not
// constrain actual usage; although it may be an important optimization.
enum UsageHint {
// The following are intentionally ordered from most dynamic to most
// static. In general, if usage_a < usage_b, then usage_a is more dynamic
// than usage_b.
// UH_client: don't attempt to upload the data; always keep it on the
// client.
UH_client,
// UH_stream: the data will be created once, used to render a few times,
// and then discarded. This should be used for short-lived temporary
// objects.
UH_stream,
// UH_dynamic: the data will be repeatedly modified and re-rendered. This
// is for data that will be modified at runtime, such as animated or soft-
// skinned vertices.
UH_dynamic,
// UH_static: the data will be created once, and used to render many
// times, without modification. This is the most common case, since
// typically vertex data is not directly animated (this is not related to
// scene graph animation, e.g. from adjusting transforms on a node).
UH_static,
// UH_unspecified: the usage is unspecified. This is intended as a "don't
// care" option for abstract objects; it should not be applied to any
// actual geometry to be rendered. You take your chances if a geom
// actually gets into the scene graph with this set.
UH_unspecified,
};
// This type specifies a number of bits that are used to represent the
// rendering requirements of a particular Geom, as well as the rendering
// capabilities of the GSG. The difference between the two indicates
// whether the Geom needs to be munged for the GSG.
enum GeomRendering {
// If there are indexed points.
GR_indexed_point = 0x00001,
// If there is indexed geometry of any other type.
GR_indexed_other = 0x10000,
// The union of all of the indexed attributes.
GR_indexed_bits = 0x10001,
// If there are any points at all.
GR_point = 0x00002,
// If the points are all the same size, other than 1 pixel.
GR_point_uniform_size = 0x00004,
// If the points have a per-vertex size designation.
GR_per_point_size = 0x00008,
// If the points' size is specified in camera units rather than screen
// pixels.
GR_point_perspective = 0x00010,
// If the points have a non-square aspect ratio.
GR_point_aspect_ratio = 0x00020,
// If the points are under a scale transform, uniform or non-uniform.
GR_point_scale = 0x00040,
// If the points are rotated off the orthonormal axis.
GR_point_rotate = 0x00080,
// If the points require texture coordinates interpolated across their
// face, to render textures as sprites.
GR_point_sprite = 0x00100,
// If there is a texture matrix applied to the sprite's generated texture
// coordinates.
GR_point_sprite_tex_matrix = 0x00200,
// The union of all the above point attributes, except GR_indexed_point.
GR_point_bits = 0x003fe,
// If there are any of these composite types.
GR_triangle_strip = 0x00400,
GR_triangle_fan = 0x00800,
GR_line_strip = 0x01000,
// The union of all of the above composite types.
GR_composite_bits = 0x01c00,
// If strip-cut indices are used to restart a composite primitive.
GR_strip_cut_index = 0x20000,
// If the shade model requires a particular vertex for flat shading.
GR_flat_first_vertex = 0x02000,
GR_flat_last_vertex = 0x04000,
// The union of the above shade model types.
GR_shade_model_bits = 0x06000,
// If a particular non-fill polygon mode is used.
GR_render_mode_wireframe= 0x40000,
GR_render_mode_point = 0x80000,
// The primitive has adjacency information.
GR_adjacency = 0x100000,
};
// The shade model specifies whether the per-vertex colors and normals
// indexed by a given primitive truly represent per-vertex colors and
// normals, or whether they actually represent per-triangle flat-shaded
// colors and normals.
enum ShadeModel {
// SM_uniform: all vertices across all faces have the same colors and
// normals. It doesn't really matter which ShadeModelAttrib mode is used
// to render this primitive.
SM_uniform,
// SM_smooth: vertices within a single face have different colorsnormals
// that should be smoothed across the face. This primitive should be
// rendered with SmoothModelAttrib::M_smooth.
SM_smooth,
// SM_flat_(first,last)_vertex: each face within the primitive might have
// a different colornormal than the other faces, but across a particular
// face there is only one colornormal. Each face's colornormal is taken
// from the (first, last) vertex of the face. This primitive should be
// rendered with SmoothModelAttrib::M_flat.
SM_flat_first_vertex,
SM_flat_last_vertex,
};
// The primitive type represents the core primitive type of a particular
// GeomPrimitive. It's used for determining what kind of antialiasing
// should be enabled.
enum PrimitiveType {
PT_none,
PT_polygons,
PT_lines,
PT_points,
PT_patches
};
// The numeric type determines what physical representation is used to
// encode a numeric value within the vertex data.
enum NumericType {
NT_uint8, // An integer 0..255
NT_uint16, // An integer 0..65535
NT_uint32, // An integer 0..4294967295
NT_packed_dcba, // DirectX style, four byte values packed in a uint32
NT_packed_dabc, // DirectX packed color order (ARGB)
NT_float32, // A single-precision float
NT_float64, // A double-precision float
NT_stdfloat, // Either single- or double-precision, according to vertices-float64.
NT_int8, // An integer -128..127
NT_int16, // An integer -32768..32767
NT_int32, // An integer -2147483648..2147483647
NT_packed_ufloat,// Three 10/11-bit float components packed in a uint32
};
// The contents determine the semantic meaning of a numeric value within the
// vertex data. This is also used to determine what automatic transforms
// might be applied to the various columns.
enum Contents {
C_other, // Arbitrary meaning, leave it alone
C_point, // A point in 3-space or 4-space
C_clip_point, // A point pre-transformed into clip coordinates
C_vector, // A surface tangent or binormal (see C_normal for normals)
C_texcoord, // A texture coordinate
C_color, // 3- or 4-component color, ordered R, G, B, [A]
C_index, // An index value into some other table
C_morph_delta, // A delta from some base value, defining a blend shape
// A transformation matrix. This is typically three or four columns, but
// we pretend it's only one for convenience.
C_matrix,
// A special version of C_vector that should be used for normal vectors,
// which are scaled differently from other vectors.
C_normal,
};
// The type of animation data that is represented by a particular
// GeomVertexFormat.
enum AnimationType {
AT_none, // No vertex animation.
AT_panda, // Vertex animation calculated on the CPU by Panda.
AT_hardware, // Hardware-accelerated animation on the graphics card.
};
};
EXPCL_PANDA_GOBJ std::ostream &operator << (std::ostream &out, GeomEnums::UsageHint usage_hint);
EXPCL_PANDA_GOBJ std::istream &operator >> (std::istream &in, GeomEnums::UsageHint &usage_hint);
EXPCL_PANDA_GOBJ std::ostream &operator << (std::ostream &out, GeomEnums::NumericType numeric_type);
EXPCL_PANDA_GOBJ std::ostream &operator << (std::ostream &out, GeomEnums::Contents contents);
#endif