Wizt::RenderBasin Class Reference

Base class for abstract render operations. More...

#include </home/werner/origo/vish/ocean/Anemonia/RenderBasin.hpp>

List of all members.

Classes

• class Painter

  Base class for paint operations. More...
  

• class Program

  Base class for abstract shader/render programs. More...
  

• class RenderFlag

  Base class for render flags. More...
  

• class RenderParameter

  Base class for render parameters. More...
  

• struct TextureStorageFormat

  Enum for the storage type of the texture, which will affect memory utilization on the GPU. More...
  

• class TextureTentacle

  Base class for textures, child classes are implemented by Renderers. More...
  

• class VertexAttribute

  A Vertex Attribute is a set of data which sits available on each vertex of some rendering. More...
  

Public Types

• enum Primitive {
    POINTS, LINE_STRIP, LINE_LOOP, LINES,
    TRIANGLE_STRIP, TRIANGLE_FAN, TRIANGLES, QUAD_STRIP,
    QUADS, POLYGON
  }

  Enumeration type for primitives, similar to OpenGL (but numerically not identical). More...
  

• enum TextureFormat {
    LUMINANCE, LUMINANCE_ALPHA, RED, GREEN,
    BLUE, ALPHA, RGB, BGR,
    RGBA, BGRA
  }

  Enum for the type of texture to be used, implying the number of color channels and their meaning.
  

• enum VertexAttributeTypes {
    COORDINATES, NORMALS, COLORS, SECONDARY_COLORS,
    TEXTURE0, TEXTURE1, USER_DEFINED
  }

  Categories of vertex attributes. More...
  

Public Member Functions

• MemCore::RefPtr< VertexAttribute > createCoordinates (const MemCore::RefPtr< MemCore::ChunkBase > &VertexData)

  Convenience function to load coordinates as vertex attribute.
  

• virtual MemCore::RefPtr< Program > createProgram (const std::string &VertexShader, const std::string &FragmentShader)=0

  Create a shader program from GLGS source code.
  

• virtual MemCore::RefPtr
  < RenderParameter > createRenderParameter (const std::string &, const void *data, const std::type_info &type, int Multiplicity)=0

  Set a generic rendering parameter. The implementation of this function will have some intelligence built in with respect to what each parameter means. It might just set a uniform variable in a shader, or detect that it's name is "glLineWidth" and issue a special OpenGL call.
  

• template<int N, class Type > MemCore::RefPtr< RenderParameter > createRenderParameter (const std::string &what, const Eagle::FixedArray< Type, N > &Data)

  Set variable of type FixedArray.
  

• template<int N, class Type > MemCore::RefPtr< RenderParameter > createRenderParameter (const std::string &what, const Eagle::Vector< Type, N > &Data)

  Set variable of Vector<> type.
  

• template<class Type > MemCore::RefPtr< RenderParameter > createRenderParameter (const std::string &what, const Type &Data)

  Set variable of scalar type.
  

• virtual MemCore::RefPtr
  < TextureTentacle > createTexture (const MemCore::RefPtr< MemCore::ChunkBase > &TextureData, TextureFormat TF, int rank, size_t *Dimensions, int TextureUnit=0, TextureStorageFormat TSF=AutomaticTexture(), int level=0, int border=0)=0

  Application call to the Render Context to create a Texture.
  

• MemCore::RefPtr< VertexAttribute > createTextureCoordinates (const MemCore::RefPtr< MemCore::ChunkBase > &TextureCoordData, int TextureUnit=0)

  Convenience function to load texture coordinates as vertex attribute.
  

• virtual MemCore::RefPtr
  < VertexAttribute > createVertexAttribute (const MemCore::RefPtr< MemCore::ChunkBase > &VertexData, const std::string &name)=0
• MemCore::RefPtr< RenderFlag > Disable (const char *what)

  Disable some rendering flag.
  

• virtual MemCore::RefPtr< Painter > drawPrimitives (Primitive, size_t howmany=0)=0

  Return a painter object suitable for insertion to an Anemone.
  

• virtual MemCore::RefPtr
  < RenderFlag > Enable (const char *what, bool Yes=true)=0

  Enable some rendering flag Give some OpenGL flag as string, for instance:
  

• Seagrass & getSeagrass ()
• const SeagrassWeakPtr_t & getSeagrassPtr () const
• static TextureStorageFormat Intensity (TextureStorageFormat::BitPrecision theBits=TextureStorageFormat::Unspecified)

  gray scale and alpha same value (one channel)
  

• static TextureStorageFormat Luminance (TextureStorageFormat::BitPrecision theBits=TextureStorageFormat::Unspecified)

  gray scale only (one channel)
  

• static TextureStorageFormat LuminanceAlpha (TextureStorageFormat::BitPrecision theLuminanceBits=TextureStorageFormat::Unspecified, TextureStorageFormat::BitPrecision theAlphaBits=TextureStorageFormat::Unspecified)

  gray scale and alpha channel (two channels)
  

• static TextureStorageFormat MultichannelTexture (int nChannels, TextureStorageFormat::BitPrecision theBits=TextureStorageFormat::Unspecified)

  Create some texture matching the number of specified channels, it will be:
  

• RenderBasin (const SeagrassWeakPtr_t &mySeagrass)
• static TextureStorageFormat Rgb (TextureStorageFormat::BitPrecision theBits=TextureStorageFormat::Unspecified)

  color channels (three channels)
  

• static TextureStorageFormat RgbAlpha (TextureStorageFormat::BitPrecision theColorBits=TextureStorageFormat::Unspecified, TextureStorageFormat::BitPrecision theAlphaBits=TextureStorageFormat::Unspecified)

  color and alpha (four channels)
  

Static Public Member Functions

• static TextureStorageFormat Alpha (TextureStorageFormat::BitPrecision theBits=TextureStorageFormat::Unspecified)

  alpha channel only (one channel)
  

• static const char * AttributeNames (VertexAttributeTypes Type)
• static TextureStorageFormat AutomaticTexture ()

---

Detailed Description

Base class for abstract render operations.

---

Member Enumeration Documentation

enum Wizt::RenderBasin::Primitive

Enumeration type for primitives, similar to OpenGL (but numerically not identical).

See also:

http://www.opengl.org/sdk/docs/man/xhtml/glDrawArrays.xml

Enumerator:

POINTS	draw as points
LINE_STRIP	draw as one connected line
LINE_LOOP	draw as one closed line
LINES	draw as a set of line elements, bundling each two vertices independently
TRIANGLE_STRIP	draw a strip of connected triangles
TRIANGLE_FAN	draw a set of triangles that are all attached to the first vertex
TRIANGLES	draw a set of independent triangles, three vertices given for each
QUAD_STRIP	draw a strip of quads
QUADS	draw a set of quads, four vertices from one
POLYGON	draw a single polygon

enum Wizt::RenderBasin::VertexAttributeTypes

Categories of vertex attributes.

Enumerator:

COORDINATES	coordinate information for vertices
NORMALS	Normal vectors.
COLORS	Colors.
SECONDARY_COLORS	Secondary colors.
TEXTURE0	Texture coordinates for texture unit 0.
TEXTURE1	Texture coordinates for texture unit 1.
USER_DEFINED	User-defined attribute name.

---

Member Function Documentation

MemCore::RefPtr<VertexAttribute> Wizt::RenderBasin::createCoordinates

(

const MemCore::RefPtr< MemCore::ChunkBase > &

VertexData

)

[inline]

Convenience function to load coordinates as vertex attribute.

            RenderBasin&myContext;
            Anemone RenderAnemone;
                    RenderAnemone.insert( Context.createCoordinates( Data ) );

Calls the generic createVertexAttribute() function.

Examples:

AnemoneBoundingVolume.cpp, and SeagrassBoundingVolume.cpp.

virtual MemCore::RefPtr<TextureTentacle> Wizt::RenderBasin::createTexture	(	const MemCore::RefPtr< MemCore::ChunkBase > &	TextureData,
		TextureFormat	TF,
		int	rank,
		size_t *	Dimensions,
		int	TextureUnit = 0,
		TextureStorageFormat	TSF = AutomaticTexture(),
		int	level = 0,
		int	border = 0
	)		[pure virtual]

Application call to the Render Context to create a Texture.

Parameters:

TextureData	actual data to be loaded
TF	The type of the texture
rank	The dimensionality of the data
Dimensions	The extension of the data in each dimension, must match the provided TextureData
TextureUnit	The OpenGL texture unit in which to load these data
TSF	The internal storage format of the texture, affects memory utilization.

Implemented in Wizt::VGLRenderContext.

MemCore::RefPtr<VertexAttribute> Wizt::RenderBasin::createTextureCoordinates	(	const MemCore::RefPtr< MemCore::ChunkBase > &	TextureCoordData,
		int	TextureUnit = 0
	)		[inline]

Convenience function to load texture coordinates as vertex attribute.

            RenderBasin&myContext;
            Anemone RenderAnemone;
                    RenderAnemone.insert( Context.createTexture( Data ) );

virtual MemCore::RefPtr<VertexAttribute> Wizt::RenderBasin::createVertexAttribute	(	const MemCore::RefPtr< MemCore::ChunkBase > &	VertexData,
		const std::string &	name
	)		[pure virtual]

Parameters:

name	A name to be associated with this buffer RenderBasin&myContext; Anemone RenderAnemone; RenderAnemone.insert( Context.createVertexAttribute( Data , "myVariable" ) );

Implemented in Wizt::VGLRenderContext, and Wizt::WebGLRenderContext.

virtual MemCore::RefPtr<Painter> Wizt::RenderBasin::drawPrimitives	(	Primitive	,
		size_t	howmany = 0
	)		[pure virtual]

Return a painter object suitable for insertion to an Anemone.

It is supposed to draw all stored Tentacles once called through Anemone::wave().

        Anemone RenderAnemone;
        RenderBasin&MyRenderContext;

        RenderAnemone.insert( MyRenderContext.drawPrimitives(RenderBasin::POINTS) );

                RenderAnemone.wave();

Parameters:

howmany

The number of elements that will be shown. If none specified here, then all that have been loaded into the Anemone .

Implemented in Wizt::VGLRenderContext, and Wizt::WebGLRenderContext.

virtual MemCore::RefPtr<RenderFlag> Wizt::RenderBasin::Enable	(	const char *	what,
		bool	Yes = true
	)		[pure virtual]

Enable some rendering flag Give some OpenGL flag as string, for instance:

                Enable("GL_LIGHTING");

instead of

                glEnable(GL_LIGHTING);

Note that inclusion of OpenGL headers is not required to call this function.

Implemented in Wizt::VGLRenderContext, and Wizt::WebGLRenderContext.

RenderBasin::TextureStorageFormat Wizt::RenderBasin::MultichannelTexture	(	int	nChannels,
		TextureStorageFormat::BitPrecision	theBits = TextureStorageFormat::Unspecified
	)

Create some texture matching the number of specified channels, it will be:

1. One: Intensity
2. Two: LuminanceAlpha
3. Three: Rgb
4. Four: RgbAlpha

Parameters:

nChannels

The number of channels that shall be in the texture.

---

The documentation for this class was generated from the following files:

• ocean/Anemonia/RenderBasin.hpp
• ocean/Anemonia/RenderBasin.cpp