org.distorted.library.mesh

Class MeshBase

java.lang.Object

org.distorted.library.mesh.MeshBase

Direct Known Subclasses:

MeshCubes, MeshFile, MeshJoined, MeshPolygon, MeshQuad, MeshSphere, MeshSquare, MeshTriangle

public abstract class MeshBase
extends java.lang.Object

Abstract class which represents a Mesh, ie an array of vertices (rendered as a TRIANGLE_STRIP).

If you want to render to a particular shape, extend from here, construct a float array containing per-vertex attributes, and call back setAttribs().

Field Summary

Fields

Modifier and Type	Field and Description
static int	MAX_EFFECT_COMPONENTS

Method Summary

Methods

Modifier and Type	Method and Description
void	addEmptyTexComponent() Adds an empty (no vertices) texture component to the end of the text component list.
void	apply(MatrixEffect effect, int andAssoc, int equAssoc) Apply a Matrix Effect to the components which match the (addAssoc,equAssoc) association.
void	apply(VertexEffect effect) Apply a Vertex Effect to the vertex mesh.
abstract MeshBase	copy(boolean deep) Copy the Mesh.
static int	getMaxEffComponents()
boolean	getShowNormals() When rendering this mesh, should we also draw the normal vectors?
Static4D	getTextureMap(int component) Return the texture map of one of the components.
static void	getUniforms(int programH, int variant)
static boolean	getUseCenters() Are we using per-component centers?
void	markForDeletion() Release all internal resources.
void	mergeEffComponents() Merge all effect components of this Mesh into a single one.
void	mergeTexComponents() Merge all texture components of this Mesh into a single one.
int	numEffComponents() Return the number of 'effect' components, i.e.
int	numTexComponents() Return the number of texture components, i.e.
void	setComponentCenter(int component, float centerX, float centerY, float centerZ) Set center of a Component.
void	setEffectAssociation(int component, int andAssociation, int equAssociation) Set Effect association.
void	setShowNormals(boolean show) When rendering this Mesh, do we want to render the Normal vectors as well?
void	setTextureMap(Static4D[] maps, int startComponent) Sets texture maps for (some of) the components of this mesh.
static void	setUseCenters() Are we going to need per-component centers (needed for correct postprocessing of concave meshes) Switching this on allocates 16*MAX_EFFECT_COMPONENTS bytes for uniforms in the vertex shader.
void	write(java.io.DataOutputStream stream) Write the Mesh to a File.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

MAX_EFFECT_COMPONENTS

public static final int MAX_EFFECT_COMPONENTS

See Also:

Constant Field Values

Method Detail

setUseCenters

public static void setUseCenters()

Are we going to need per-component centers (needed for correct postprocessing of concave meshes) Switching this on allocates 16*MAX_EFFECT_COMPONENTS bytes for uniforms in the vertex shader.

getUseCenters

public static boolean getUseCenters()

Are we using per-component centers?

getMaxEffComponents

public static int getMaxEffComponents()

getUniforms

public static void getUniforms(int programH,
               int variant)

write

public void write(java.io.DataOutputStream stream)

Write the Mesh to a File.

setShowNormals

public void setShowNormals(boolean show)

When rendering this Mesh, do we want to render the Normal vectors as well?

Will work only on OpenGL ES >= 3.0 devices.

Parameters:

show - Controls if we render the Normal vectors or not.

getShowNormals

public boolean getShowNormals()

When rendering this mesh, should we also draw the normal vectors?

Returns:

true if we do render normal vectors

mergeTexComponents

public void mergeTexComponents()

Merge all texture components of this Mesh into a single one.

mergeEffComponents

public void mergeEffComponents()

Merge all effect components of this Mesh into a single one.

markForDeletion

public void markForDeletion()

Release all internal resources.

apply

public void apply(MatrixEffect effect,
         int andAssoc,
         int equAssoc)

Apply a Matrix Effect to the components which match the (addAssoc,equAssoc) association.

This is a static, permanent modification of the vertices contained in this Mesh. If the effect contains any Dynamics, they will be evaluated at 0.

Parameters:

effect - List of Matrix Effects to apply to the Mesh.

andAssoc - 'Logical AND' association which defines which components will be affected.

equAssoc - 'equality' association which defines which components will be affected.

apply

public void apply(VertexEffect effect)

Apply a Vertex Effect to the vertex mesh.

This is a static, permanent modification of the vertices contained in this Mesh. If the effects contain any Dynamics, the Dynamics will be evaluated at 0. We would call this several times building up a list of Effects to do. This list of effects gets lazily executed only when the Mesh is used for rendering for the first time.

Parameters:

effect - Vertex Effect to apply to the Mesh.

setTextureMap

public void setTextureMap(Static4D[] maps,
                 int startComponent)

Sets texture maps for (some of) the components of this mesh.

Format: ( x of lower-left corner, y of lower-left corner, width, height ). For example maps[0] = new Static4D( 0.0, 0.5, 0.5, 0.5 ) sets the 0th component texture map to the upper-left quadrant of the texture.

Probably the most common user case would be sending as many maps as there are components in this Mesh. One can also send less, or more (the extraneous ones will be ignored) and set some of them to null (those will be ignored as well). So if there are 5 components, and we want to set the map of the 2nd and 4rd one, call this with maps = new Static4D[4] maps[0] = null maps[1] = the map for the 2nd component maps[2] = null maps[3] = the map for the 4th component A map's width and height have to be non-zero (but can be negative!)

Parameters:

maps - List of texture maps to apply to the texture's components.

startComponent - the component the first of the maps refers to.

getTextureMap

public Static4D getTextureMap(int component)

Return the texture map of one of the components.

Parameters:

component - The component number whose texture map we want to retrieve.

setEffectAssociation

public void setEffectAssociation(int component,
                        int andAssociation,
                        int equAssociation)

Set Effect association. This creates an association between a Component of this Mesh and a Vertex Effect. One can set two types of associations - an 'logical and' and a 'equal' associations and the Effect will only be active on vertices of Components such that (effect andAssoc) & (component andAssoc) != 0 || (effect equAssoc) == (mesh equAssoc) (see main_vertex_shader) The point: this way we can configure the system so that each Vertex Effect acts only on a certain subset of a Mesh, thus potentially significantly reducing the number of render calls.

setComponentCenter

public void setComponentCenter(int component,
                      float centerX,
                      float centerY,
                      float centerZ)

Set center of a Component. A 'center' of a (effect) component is a 3D point in space. The array of centers gets sent to the vertex shader as a Uniform Buffer Object; in the vertex shader we can then use it to compute the 'Inflation' of the whole Mesh per-component. 'Inflation' is needed by postprocess effects to add the 'halo' around an object. This is all 'per-component' so that a user has a chance to make the halo look right in case of non-convex meshes: then we need to ensure that each component of such a mesh is a convex sub-mesh with its center being more-or-less the center of gravity of the sub-mesh.

addEmptyTexComponent

public void addEmptyTexComponent()

Adds an empty (no vertices) texture component to the end of the text component list. Sometimes we want to do this to have several Meshes with equal number of tex components each.

numTexComponents

public int numTexComponents()

Return the number of texture components, i.e. individual subsets of the whole set of vertices which can be independently textured.

Returns:

The number of Texture Components of this Mesh.

numEffComponents

public int numEffComponents()

Return the number of 'effect' components, i.e. individual subsets of the whole set of vertices to which a VertexEffect can be addressed, independently of other vertices.

Returns:

The number of Effect Components of this Mesh.

copy

public abstract MeshBase copy(boolean deep)

Copy the Mesh.

Parameters:

deep - If to be a deep or shallow copy of mVertAttribs1, i.e. the array holding vertices, and normals (the rest, in particular the mVertAttribs2 containing texture coordinates and effect associations, is always deep copied)