geomEnums.h

Go to the documentation of this file.

/**
 * 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