Man Linux: Main Page and Category List

NAME

       SoTextureCombine -

       The SoTextureCombine class is a node for setting texture combine
       functions.

       This node is more or less an exact mapping of the OpenGL
       ARB_texture_env_combine extension (included in OpenGL in OpenGL v1.3).
       See http://oss.sgi.com/projects/ogl-
       sample/registry/ARB/texture_env_combine.txt for more information about
       this extension.

SYNOPSIS

       #include <Inventor/nodes/SoTextureCombine.h>

       Inherits SoNode.

   Public Types
       enum Source { PRIMARY_COLOR =  SoTextureCombineElement::PRIMARY_COLOR,
           TEXTURE =  SoTextureCombineElement::TEXTURE, CONSTANT =
           SoTextureCombineElement::CONSTANT, PREVIOUS =
           SoTextureCombineElement::PREVIOUS }
       enum Operand { SRC_COLOR =  SoTextureCombineElement::SRC_COLOR,
           ONE_MINUS_SRC_COLOR =
           SoTextureCombineElement::ONE_MINUS_SRC_COLOR, SRC_ALPHA =
           SoTextureCombineElement::SRC_ALPHA, ONE_MINUS_SRC_ALPHA =
           SoTextureCombineElement::ONE_MINUS_SRC_ALPHA }
       enum Operation { REPLACE =  SoTextureCombineElement::REPLACE, MODULATE
           =  SoTextureCombineElement::MODULATE, ADD =
           SoTextureCombineElement::ADD, ADD_SIGNED =
           SoTextureCombineElement::ADD_SIGNED, SUBTRACT =
           SoTextureCombineElement::SUBTRACT, INTERPOLATE =
           SoTextureCombineElement::INTERPOLATE, DOT3_RGB =
           SoTextureCombineElement::DOT3_RGB, DOT3_RGBA =
           SoTextureCombineElement::DOT3_RGBA }

   Public Member Functions
       SoTextureCombine (void)
       virtual void doAction (SoAction *action)
       virtual void callback (SoCallbackAction *action)
       virtual void GLRender (SoGLRenderAction *action)
       virtual void pick (SoPickAction *action)

   Static Public Member Functions
       static void initClass (void)

   Public Attributes
       SoMFEnum rgbSource
       SoMFEnum alphaSource
       SoMFEnum rgbOperand
       SoMFEnum alphaOperand
       SoSFEnum rgbOperation
       SoSFEnum alphaOperation
       SoSFFloat rgbScale
       SoSFFloat alphaScale
       SoSFVec4f constantColor

   Protected Member Functions
       virtual ~SoTextureCombine ()

Detailed Description

       The SoTextureCombine class is a node for setting texture combine
       functions.

       This node is more or less an exact mapping of the OpenGL
       ARB_texture_env_combine extension (included in OpenGL in OpenGL v1.3).
       See http://oss.sgi.com/projects/ogl-
       sample/registry/ARB/texture_env_combine.txt for more information about
       this extension.

       Basically this node lets you specify up to three sources, and a
       function to combine those sources. In addition to the function, it’s
       possible to apply simple operands on the sources. In the documentation
       below, the sources will be called Arg0, Arg1, and Arg2, just like in
       the ARB_texture_env_mode specification.

       It’s possible to specify both a color and an alpha operation.

       This node has many fields, but usually it is sufficient to set only one
       or very few fields. The selected operation decides which values you
       need to set. One common example is to add a light map to textured
       geometry. A lightmap can look like this:

       The example below just shows how to apply the lightmap to a cube, with
       one light source on each side of the cube. Usually the texture
       coordinates are calculated so that a spot light or a point light is
       simulated.

         Texture2 { filename "wood.jpg" }

         Switch {
           whichChild -3   # use to toggle lightmap on/off
           TextureUnit {
             unit 1
           }
           TextureCombine {
             rgbOperation ADD_SIGNED
             rgbSource [PREVIOUS, TEXTURE]
             rgbOperand [SRC_COLOR, SRC_COLOR ]
             alphaOperation REPLACE
             alphaSource [TEXTURE]
             alphaOperand [SRC_ALPHA]
           }
           Texture2 { filename "lightmap.jpg" }
           TextureUnit { unit 0 }
         }
         Cube { }

         .fi

       The scene above in a viewer:

       In addition to the functions you can set in rgbOperation (or alphaOperation), it’s possible to create more complex texture functions by combining two textures that have already been combined. You can use the SoSceneTexture2 node to create those textures. Below is an example that shows how to implement Arg0*Arg1 + Arg2*Arg0, where Arg0 = texture1 RGB, Arg1 = texture2 RGB, Arg2 = texture 2 alpha:

         ShapeHints { vertexOrdering COUNTERCLOCKWISE shapeType SOLID }

         Separator {
           SceneTexture2 {
             size 256 256
             transparencyFunction NONE
             scene Separator {
               OrthographicCamera {
                 height 2
                 aspectRatio 1
                 position 0 0 1
                 viewportMapping LEAVE_ALONE
               }
               LightModel { model BASE_COLOR }
               Coordinate3 {
                 point [ -1 -1 0, 1 -1 0, 1 1 0, -1 1 0 ]
               }
               DEF texture1 Texture2 { filename "texture1.png" }
               TextureUnit { unit 1 }
               TextureCombine {
                 rgbOperation MODULATE
                 rgbSource [ PREVIOUS, TEXTURE ]
                 rgbOperand [ SRC_COLOR, SRC_COLOR ]
                 alphaOperation REPLACE
                 alphaSource [TEXTURE]
                 alphaOperand [ SRC_ALPHA ]
               }
               DEF texture2 Texture2 { filename "texture2_with_alpha.png" }
               TextureCoordinate2 {
                 point [0 0, 1 0, 1 1, 0 1]
               }
               FaceSet { numVertices 4 }
             }
           }
           TextureUnit { unit 1 }
           TextureCombine {
             rgbOperation ADD
             rgbSource [ PREVIOUS, TEXTURE ]
             rgbOperand [ SRC_COLOR, SRC_COLOR ]
             alphaOperation REPLACE
             alphaSource [TEXTURE]
             alphaOperand [ SRC_ALPHA ]
           }
           SceneTexture2 {
             size 256 256
             transparencyFunction NONE
             scene Separator {
               OrthographicCamera {
                 height 2
                 aspectRatio 1
                 position 0 0 1
                 viewportMapping LEAVE_ALONE
               }
               LightModel { model BASE_COLOR }
               Coordinate3 {
                 point [ -1 -1 0, 1 -1 0, 1 1 0, -1 1 0 ]
               }
               USE texture1
               TextureUnit { unit 1 }
               TextureCombine {
                 rgbOperation MODULATE
                 rgbSource [ PREVIOUS, TEXTURE ]
                 rgbOperand [ SRC_COLOR, SRC_ALPHA ]
                 alphaOperation REPLACE
                 alphaSource [TEXTURE]
                 alphaOperand [ SRC_ALPHA ]
               }
               USE texture2
               TextureCoordinate2 {
                 point [0 0, 1 0, 1 1, 0 1]
               }
               FaceSet { numVertices 4 }
             }
           }
           # map resulting texture onto a Cube
           Cube { }
         }
         .fi

       It should be possible to create almost any kind of texture function using this scheme, at the cost of extra texture memory usage (the intermediate textures), of course.

       FILE FORMAT/DEFAULTS:

           TextureCombine {
               rgbSource [  ]
               alphaSource [  ]
               rgbOperand [  ]
               alphaOperand [  ]
               rgbOperation MODULATE
               alphaOperation MODULATE
               rgbScale 1
               alphaScale 1
               constantColor 1 1 1 1
           }

       Since:
           Coin 2.3

Member Enumeration Documentation

   enum SoTextureCombine::Source For enumerating combiner sources.
       Enumerator:

       PRIMARY_COLOR
              Choose primary color as source.

       TEXTURE
              Choose texture as source.

       CONSTANT
              Choose the constantColor field as source.

       PREVIOUS
              Choose the previous unit’s texture as source.

   enum SoTextureCombine::Operand For enumerating source operands.
       Enumerator:

       SRC_COLOR
              Use the source color as operand.

       ONE_MINUS_SRC_COLOR
              Use one minus source color as operand.

       SRC_ALPHA
              Use the source alpha as operand.

       ONE_MINUS_SRC_ALPHA
              Use one minus source alpha as operand.

   enum SoTextureCombine::Operation For enumerating combiner
       operations/functions.
       Enumerator:

       REPLACE
              dst = Arg0

       MODULATE
              dst = Arg0 * Arg1

       ADD    dst = Arg0 + Arg1

       ADD_SIGNED
              dst = Arg0 + Arg1 - 0.5

       SUBTRACT
              dst = Arg0 - Arg1

       INTERPOLATE
              dst = Arg0 * (Arg2) + Arg1 * (1-Arg2)

       DOT3_RGB
              Dot product of Arg0 and Arg1

       DOT3_RGBA
              Dot product (including alpha) of Arg0 and Arg1

Constructor & Destructor Documentation

   SoTextureCombine::SoTextureCombine (void) Constructor.
   SoTextureCombine::~SoTextureCombine () [protected, virtual] Destructor.

Member Function Documentation

   void SoTextureCombine::initClass (void) [static] Sets up initialization for
       data common to all instances of this class, like submitting necessary
       information to the Coin type system.
       Reimplemented from SoNode.

   void SoTextureCombine::doAction (SoAction * action) [virtual] This function
       performs the typical operation of a node for any action.
       Reimplemented from SoNode.

   void SoTextureCombine::callback (SoCallbackAction * action) [virtual]
       Action method for SoCallbackAction.
       Simply updates the state according to how the node behaves for the
       render action, so the application programmer can use the
       SoCallbackAction for extracting information about the scene graph.

       Reimplemented from SoNode.

   void SoTextureCombine::GLRender (SoGLRenderAction * action) [virtual]
       Action method for the SoGLRenderAction.
       This is called during rendering traversals. Nodes influencing the
       rendering state in any way or who wants to throw geometry primitives at
       OpenGL overrides this method.

       Reimplemented from SoNode.

   void SoTextureCombine::pick (SoPickAction * action) [virtual] Action method
       for SoPickAction.
       Does common processing for SoPickAction action instances.

       Reimplemented from SoNode.

Author

       Generated automatically by Doxygen for Coin from the source code.