Loading...
Searching...
No Matches
Ogre::PatchSurface Class Reference
Core » Level of Detail

A surface which is defined by curves of some kind to form a patch, e.g. More...

`#include <OgrePatchSurface.h>`

Inheritance diagram for Ogre::PatchSurface:
[legend]

## Public Types

enum | { AUTO_LEVEL = -1 }
| Constant for indicating automatic determination of subdivision level for patches. More...
enum | PatchSurfaceType { PST_BEZIER }
enum | VisibleSide { VS_FRONT , VS_BACK , VS_BOTH }

## Public Member Functions

| PatchSurface ()
| ~PatchSurface ()
void | build (HardwareVertexBufferSharedPtr destVertexBuffer, size_t vertexStart, HardwareIndexBufferSharedPtr destIndexBuffer, size_t indexStart)
| Tells the system to build the mesh relating to the surface into externally created buffers.
void | defineSurface (void *controlPointBuffer, VertexDeclaration *declaration, size_t width, size_t height, PatchSurfaceType pType=PST_BEZIER, size_t uMaxSubdivisionLevel=AUTO_LEVEL, size_t vMaxSubdivisionLevel=AUTO_LEVEL, VisibleSide visibleSide=VS_FRONT)
| Sets up the surface by defining it's control points, type and initial subdivision level.
Real | getBoundingSphereRadius (void) const
| Gets the radius of the bounding sphere for this patch, only valid after defineSurface has been called.
const AxisAlignedBox & | getBounds (void) const
| Gets the bounds of this patch, only valid after calling defineSurface.
void * | getControlPointBuffer (void) const
size_t | getCurrentIndexCount (void) const
| Gets the current index count based on the current subdivision level.
size_t | getIndexOffset (void) const
| Returns the index offset used by this buffer to write data into the buffer.
size_t | getRequiredIndexCount (void) const
| Based on a previous call to defineSurface, establishes the number of indexes required to hold this patch at the maximum detail level.
size_t | getRequiredVertexCount (void) const
| Based on a previous call to defineSurface, establishes the number of vertices required to hold this patch at the maximum detail level.
Real | getSubdivisionFactor (void) const
| Gets the current level of subdivision.
size_t | getVertexOffset (void) const
| Returns the vertex offset used by this buffer to write data into the buffer.
void | notifyControlPointBufferDeallocated (void)
| Convenience method for telling the patch that the control points have been deleted, since once the patch has been built they are not required.
void | setSubdivisionFactor (Real factor)
| Alters the level of subdivision for this surface.

## Detailed Description

A surface which is defined by curves of some kind to form a patch, e.g.

a Bezier patch.

This object will take a list of control points with various assorted data, and will subdivide it into a patch mesh. Currently only Bezier curves are supported for defining the surface, but other techniques such as NURBS would follow the same basic approach.

## Member Enumeration Documentation

## PatchSurfaceType

enum Ogre::PatchSurface::PatchSurfaceType

Enumerator
PST_BEZIER | A patch defined by a set of bezier curves.

## anonymous enum

anonymous enum

Constant for indicating automatic determination of subdivision level for patches.

Enumerator
AUTO_LEVEL |

## VisibleSide

enum Ogre::PatchSurface::VisibleSide

Enumerator
VS_FRONT | The side from which u goes right and v goes up (as in texture coords).
VS_BACK | The side from which u goes right and v goes down (reverse of texture coords).
VS_BOTH | Both sides are visible - warning this creates 2x the number of triangles and adds extra overhead for calculating normals.

## Constructor & Destructor Documentation

## PatchSurface()

Ogre::PatchSurface::PatchSurface | ( |  | ) |

## ~PatchSurface()

Ogre::PatchSurface::~PatchSurface | ( |  | ) |

## Member Function Documentation

## defineSurface()

void Ogre::PatchSurface::defineSurface | ( | void * | controlPointBuffer,
|  | VertexDeclaration * | declaration,
|  | size_t | width,
|  | size_t | height,
|  | PatchSurfaceType | pType = PST_BEZIER,
|  | size_t | uMaxSubdivisionLevel = AUTO_LEVEL,
|  | size_t | vMaxSubdivisionLevel = AUTO_LEVEL,
|  | VisibleSide | visibleSide = VS_FRONT )

Sets up the surface by defining it's control points, type and initial subdivision level.

This method initialises the surface by passing it a set of control points. The type of curves to be used are also defined here, although the only supported option currently is a bezier patch. You can also specify a global subdivision level here if you like, although it is recommended that the parameter is left as AUTO_LEVEL, which means the system decides how much subdivision is required (based on the curvature of the surface)

Parameters

  controlPointBuffer | A pointer to a buffer containing the vertex data which defines control points of the curves rather than actual vertices. Note that you are expected to provide not just position information, but potentially normals and texture coordinates too. The format of the buffer is defined in the VertexDeclaration parameter
  declaration | VertexDeclaration describing the contents of the buffer. Note this declaration must only draw on buffer source 0!
  width | Specifies the width of the patch in control points.
  height | Specifies the height of the patch in control points.
  pType | The type of surface - currently only PST_BEZIER is supported
  uMaxSubdivisionLevel,vMaxSubdivisionLevel | If you want to manually set the top level of subdivision, do it here, otherwise let the system decide.
  visibleSide | Determines which side of the patch (or both) triangles are generated for.

References AUTO_LEVEL, PST_BEZIER, and VS_FRONT.

## getRequiredVertexCount()

size_t Ogre::PatchSurface::getRequiredVertexCount | ( | void |  | ) | const

Based on a previous call to defineSurface, establishes the number of vertices required to hold this patch at the maximum detail level.

Remarks
  This is useful when you wish to build the patch into external vertex / index buffers.

## getRequiredIndexCount()

size_t Ogre::PatchSurface::getRequiredIndexCount | ( | void |  | ) | const

Based on a previous call to defineSurface, establishes the number of indexes required to hold this patch at the maximum detail level.

Remarks
  This is useful when you wish to build the patch into external vertex / index buffers.

## getCurrentIndexCount()

size_t Ogre::PatchSurface::getCurrentIndexCount | ( | void |  | ) | const

Gets the current index count based on the current subdivision level.

## getIndexOffset()

size_t Ogre::PatchSurface::getIndexOffset | ( | void |  | ) | const

inline

Returns the index offset used by this buffer to write data into the buffer.

## getVertexOffset()

size_t Ogre::PatchSurface::getVertexOffset | ( | void |  | ) | const

inline

Returns the vertex offset used by this buffer to write data into the buffer.

## getBounds()

const AxisAlignedBox & Ogre::PatchSurface::getBounds | ( | void |  | ) | const

Gets the bounds of this patch, only valid after calling defineSurface.

## getBoundingSphereRadius()

Real Ogre::PatchSurface::getBoundingSphereRadius | ( | void |  | ) | const

Gets the radius of the bounding sphere for this patch, only valid after defineSurface has been called.

## build()

void Ogre::PatchSurface::build | ( | HardwareVertexBufferSharedPtr | destVertexBuffer,
|  | size_t | vertexStart,
|  | HardwareIndexBufferSharedPtr | destIndexBuffer,
|  | size_t | indexStart )

Tells the system to build the mesh relating to the surface into externally created buffers.

The VertexDeclaration of the vertex buffer must be identical to the one passed into defineSurface. In addition, there must be enough space in the buffer to accommodate the patch at full detail level; you should call getRequiredVertexCount and getRequiredIndexCount to determine this. This method does not create an internal mesh for this patch and so getMesh will return null if you call it after building the patch this way.

Parameters

  destVertexBuffer | The destination vertex buffer in which to build the patch.
  vertexStart | The offset at which to start writing vertices for this patch
  destIndexBuffer | The destination index buffer in which to build the patch.
  indexStart | The offset at which to start writing indexes for this patch

## setSubdivisionFactor()

void Ogre::PatchSurface::setSubdivisionFactor | ( | Real | factor | ) |

Alters the level of subdivision for this surface.

This method changes the proportionate detail level of the patch; since the U and V directions can have different subdivision levels, this method takes a single Real value where 0 is the minimum detail (the control points) and 1 is the maximum detail level as supplied to the original call to defineSurface.

## getSubdivisionFactor()

Real Ogre::PatchSurface::getSubdivisionFactor | ( | void |  | ) | const

Gets the current level of subdivision.

## getControlPointBuffer()

void * Ogre::PatchSurface::getControlPointBuffer | ( | void |  | ) | const

inline

## notifyControlPointBufferDeallocated()

void Ogre::PatchSurface::notifyControlPointBufferDeallocated | ( | void |  | ) |

inline

Convenience method for telling the patch that the control points have been deleted, since once the patch has been built they are not required.

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

- OgrePatchSurface.h