Quad3D (flexbatch 1.1.1 API)

java.lang.Object
- com.cyphercove.gdx.flexbatch.Batchable
- - com.cyphercove.gdx.flexbatch.Batchable.FixedSizeBatchable
  - - com.cyphercove.gdx.flexbatch.batchable.Quad
    - - com.cyphercove.gdx.flexbatch.batchable.Quad3D

All Implemented Interfaces:

com.badlogic.gdx.utils.Pool.Poolable, SortableBatchable<Quad3D>

Direct Known Subclasses:

LitQuad3D
```
public class Quad3D
extends Quad
implements SortableBatchable<Quad3D>
```
A Quad Batchable that supports a single texture at a time, with two-dimensional position and color. It is designed to be drawn in 3D space, and is commonly called a decal.
The default origin of a Quad3D is its center. Its origin is used for positioning, and as the center of rotation and scaling.
Quad3D manages its own blending, so calls to the FlexBatch's blend function setters will be ineffective.
It may be subclassed to create a Batchable class that supports multiple textures and additional attributes--see Quad.getNumberOfTextures() and addVertexAttributes(). Such a subclass would not be compatible with a FlexBatch that was instantiated for the base Sprite type.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Quad3D.Blending
Commonly used blend function factor pairs, for convenience.
- Nested classes/interfaces inherited from class com.cyphercove.gdx.flexbatch.Batchable
  Batchable.FixedSizeBatchable

Nested Classes
Modifier and Type	Class and Description
`static class`	`Quad3D.Blending` Commonly used blend function factor pairs, for convenience.

Field Summary

Fields
Modifier and Type Field and Description

int dstBlendFactor

boolean opaque

com.badlogic.gdx.math.Quaternion rotation

int srcBlendFactor

float z
- Fields inherited from class com.cyphercove.gdx.flexbatch.batchable.Quad
  color, coordinatesRotation, height, originX, originY, regions, scaleX, scaleY, sizeSet, textures, WHITE, width, x, y

Fields
Modifier and Type	Field and Description
`int`	`dstBlendFactor`
`boolean`	`opaque`
`com.badlogic.gdx.math.Quaternion`	`rotation`
`int`	`srcBlendFactor`
`float`	`z`

Constructor Summary

Constructors
Constructor and Description
`Quad3D()` A Quad3D that starts opaque.
`Quad3D(int srcBlendFactor, int dstBlendFactor)` A Quad3D that starts with blending enabled, with the specified blend factors.
`Quad3D(Quad3D.Blending blending)` A Quad3D that starts with blending enabled, and a common set of blend factors.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected int`	`apply(float[] vertices, int vertexStartingIndex, AttributeOffsets offsets, int vertexSize)` Called by FlexBatch.
`Quad3D`	`billboard(com.badlogic.gdx.graphics.Camera camera)` Sets the rotation to look at the camera, relative to the current position.
`Quad3D`	`billboard(com.badlogic.gdx.graphics.Camera camera, com.badlogic.gdx.math.Vector3 up)` Sets the rotation to look at the camera, relative to the current position.
`Quad3D`	`blend()` Enables blending.
`Quad3D`	`blend(int srcBlendFactor, int dstBlendFactor)` Enables blending and sets the blend function parameters.
`Quad3D`	`blend(Quad3D.Blending blending)` Enables blending and sets the blend function parameters to a commonly used pair.
`float`	`calculateDistanceSquared(com.badlogic.gdx.math.Vector3 camPosition)`
`Quad3D`	`color(com.badlogic.gdx.graphics.Color color)`
`Quad3D`	`color(float floatBits)`
`Quad3D`	`color(float r, float g, float b, float a)`
`Quad3D`	`flip(boolean flipX, boolean flipY)` Flips the UV region of the most recently applied texture.
`boolean`	`hasEquivalentTextures(Quad3D other)`
`boolean`	`isOpaque()`
`protected boolean`	`isPosition3D()` Determines whether the position data has a Z component.
`protected boolean`	`isTextureCoordinate3D()` Determines whether the texture coordinate data has a third component (for TextureArray layers).
`Quad3D`	`lookAt(com.badlogic.gdx.math.Vector3 position, com.badlogic.gdx.math.Vector3 up)` Sets the rotation to look at the give position, relative to the current position.
`Quad3D`	`opaque()` Disables blending.
`Quad3D`	`origin(float originX, float originY)` Sets the center point for transformations (rotation and scale).
`Quad3D`	`position(float x, float y, float z)` Sets the position of the center (plus current origin offset) of the texture region in world space.
`Quad3D`	`position(com.badlogic.gdx.math.Vector3 position)` Sets the position of the center (plus current origin offset) of the texture region in world space.
`protected boolean`	`prepareContext(RenderContextAccumulator renderContext, int remainingVertices, int remainingTriangles)` Called before `Batchable.apply(float[], int, AttributeOffsets, int)` to set render context states and texture bindings, and to determine if a flush is necessary before this Batchable can be drawn.
`protected void`	`prepareSharedContext(RenderContextAccumulator renderContext)` Prepares the rendering context for this type of Batchable to be drawn.
`void`	`refresh()` Resets the state and default parameters of the Batchable so it can be reused for an entirely new image.
`Quad3D`	`region(float u, float v, float u2, float v2)` Sets the UV region of the most recently applied texture.
`Quad3D`	`rotate(com.badlogic.gdx.math.Quaternion rotation)` Rotates the current orientation by a specific Quaternion.
`Quad3D`	`rotateCoordinates90(boolean clockwise)` Rotates the texture region(s) 90 degrees in place by rotating the texture coordinates.
`Quad3D`	`rotateX(float angle)` Rotates from the current orientation by a specific angle about the X axis.
`Quad3D`	`rotateY(float angle)` Rotates from the current orientation by a specific angle about the Y axis.
`Quad3D`	`rotateZ(float angle)` Rotates from the current orientation by a specific angle about the Z axis.
`Quad3D`	`rotation(float yaw, float pitch, float roll)` Sets the rotation to specific Euler angles.
`Quad3D`	`rotation(float x, float y, float z, float w)` Sets the rotation to a specific Quaternion.
`Quad3D`	`rotation(float directionX, float directionY, float directionZ, float upX, float upY, float upZ)` Sets the rotation based on a direction vector and up vector.
`Quad3D`	`rotation(com.badlogic.gdx.math.Quaternion rotation)` Sets the rotation to a specific Quaternion.
`Quad3D`	`rotation(com.badlogic.gdx.math.Vector3 axis, float angle)` Sets the rotation to a specific angle about an axis.
`Quad3D`	`rotation(com.badlogic.gdx.math.Vector3 direction, com.badlogic.gdx.math.Vector3 up)` Sets the rotation based on a direction vector and up vector.
`Quad3D`	`scale(float scaleX, float scaleY)`
`Quad3D`	`size(float width, float height)`
`Quad3D`	`texture(com.badlogic.gdx.graphics.Texture texture)`
`Quad3D`	`textureRegion(com.badlogic.gdx.graphics.g2d.TextureRegion region)` Sets the texture region.
`Quad3D`	`translate(float x, float y, float z)` Translates the current position by the given amount.
`Quad3D`	`translate(com.badlogic.gdx.math.Vector3 amount)` Translates the current position by the given amount.

Methods inherited from class com.cyphercove.gdx.flexbatch.batchable.Quad
addVertexAttributes, flipAll, getNumberOfTextures, getTrianglesPerBatchable, getVerticesPerBatchable, populateTriangleIndices, regionTexels, reset, texture

Methods inherited from class com.cyphercove.gdx.flexbatch.Batchable.FixedSizeBatchable
apply, prepareIndices

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - z
```
public float z
```
  - rotation
```
public final com.badlogic.gdx.math.Quaternion rotation
```
  - opaque
```
public boolean opaque
```
  - srcBlendFactor
```
public int srcBlendFactor
```
  - dstBlendFactor
```
public int dstBlendFactor
```
- Constructor Detail
  - Quad3D
```
public Quad3D()
```
    A Quad3D that starts opaque.
  - Quad3D
```
public Quad3D(int srcBlendFactor,
              int dstBlendFactor)
```
    A Quad3D that starts with blending enabled, with the specified blend factors.
  - Quad3D
```
public Quad3D(Quad3D.Blending blending)
```
    A Quad3D that starts with blending enabled, and a common set of blend factors.
- Method Detail
  - isPosition3D
```
protected final boolean isPosition3D()
```
    Description copied from class: Quad
    
    Determines whether the position data has a Z component. Must return the same constant value for every instance of the class.
    Overriding this method will produce a subclass that is incompatible with a FlexBatch that was instantiated for the superclass type.
    
    Specified by:
    
    isPosition3D in class Quad
  - isTextureCoordinate3D
```
protected boolean isTextureCoordinate3D()
```
    Description copied from class: Quad
    
    Determines whether the texture coordinate data has a third component (for TextureArray layers). Must return the same constant value for every instance of the class.
    Overriding this method will produce a subclass that is incompatible with a FlexBatch that was instantiated for the superclass type.
    
    Specified by:
    
    isTextureCoordinate3D in class Quad
  - isOpaque
```
public boolean isOpaque()
```
    Specified by:
    
    isOpaque in interface SortableBatchable<Quad3D>
    
    Returns:
    
    Whether this Batchable is opaque.
  - calculateDistanceSquared
```
public float calculateDistanceSquared(com.badlogic.gdx.math.Vector3 camPosition)
```
    Specified by:
    
    calculateDistanceSquared in interface SortableBatchable<Quad3D>
    
    Returns:
    
    The squared distance from the given camera position.
  - prepareSharedContext
```
protected void prepareSharedContext(RenderContextAccumulator renderContext)
```
    Description copied from class: Batchable
    
    Prepares the rendering context for this type of Batchable to be drawn. This method should set state changes that will be the same for all instances of this Batchable type. It must not call begin(), executeChanges(), or end() on renderContext, as these are handled by the FlexBatch. It should not change anything in a way that is unique to any particular instance of this Batchable type.
    
    Overrides:
    
    prepareSharedContext in class Batchable
    
    Parameters:
    
    renderContext - The FlexBatch's manager of GL state changes and texture bindings.
  - prepareContext
```
protected boolean prepareContext(RenderContextAccumulator renderContext,
                                 int remainingVertices,
                                 int remainingTriangles)
```
    Description copied from class: Batchable
    
    Called before Batchable.apply(float[], int, AttributeOffsets, int) to set render context states and texture bindings, and to determine if a flush is necessary before this Batchable can be drawn. Overriding this method may produce a subclass that is incompatible with a FlexBatch that was instantiated for the superclass type.
    
    Overrides:
    
    prepareContext in class Quad
    
    Parameters:
    
    renderContext - The FlexBatch's manager of GL state changes and texture bindings. Pending state changes and texture bindings can be made on this context, and the context will return whether the context is now changed, which means a flush is required and this method needs to return true.
    
    remainingVertices - The number of vertices that can be drawn before the next flush is required.
    
    remainingTriangles - The number of triangle indices that can be drawn before the next flush is required. This value is undefined for Batchable.FixedSizeBatchable and should not be used or checked against.
    
    Returns:
    
    Whether FlexBatch needs to be flushed before this Batchable can be drawn. This may be true because it binds new textures, there isn't enough vertex or triangle capacity left, or because this Batchable uses new render context parameters.
  - hasEquivalentTextures
```
public boolean hasEquivalentTextures(Quad3D other)
```
    Specified by:
    
    hasEquivalentTextures in interface SortableBatchable<Quad3D>
    
    Parameters:
    
    other - Another instance of the same class type as this one, for comparison.
    
    Returns:
    
    Whether this Batchable and the other have the same texture configuration such that they could be drawn sequentially without forcing the FlexBatch to flush in between.
  - refresh
```
public void refresh()
```
    Description copied from class: Batchable
    
    Resets the state and default parameters of the Batchable so it can be reused for an entirely new image.
    
    Overrides:
    
    refresh in class Quad
  - opaque
```
public Quad3D opaque()
```
    Disables blending. Blending is disabled by default.
    
    Returns:
    
    This object for chaining.
  - blend
```
public Quad3D blend()
```
    Enables blending. Blending is disabled by default.
    
    Returns:
    
    This object for chaining.
  - blend
```
public Quad3D blend(int srcBlendFactor,
                    int dstBlendFactor)
```
    Enables blending and sets the blend function parameters. Blending is disabled by default.
    
    Returns:
    
    This object for chaining.
  - blend
```
public Quad3D blend(Quad3D.Blending blending)
```
    Enables blending and sets the blend function parameters to a commonly used pair. Blending is disabled by default.
    
    Returns:
    
    This object for chaining.
  - position
```
public Quad3D position(float x,
                       float y,
                       float z)
```
    Sets the position of the center (plus current origin offset) of the texture region in world space.
    
    Returns:
    
    This object for chaining.
  - position
```
public Quad3D position(com.badlogic.gdx.math.Vector3 position)
```
    Sets the position of the center (plus current origin offset) of the texture region in world space.
    
    Returns:
    
    This object for chaining.
  - translate
```
public Quad3D translate(float x,
                        float y,
                        float z)
```
    Translates the current position by the given amount.
    
    Returns:
    
    This object for chaining.
  - translate
```
public Quad3D translate(com.badlogic.gdx.math.Vector3 amount)
```
    Translates the current position by the given amount.
    
    Returns:
    
    This object for chaining.
  - rotation
```
public Quad3D rotation(com.badlogic.gdx.math.Quaternion rotation)
```
    Sets the rotation to a specific Quaternion.
    
    Returns:
    
    This object for chaining.
  - rotation
```
public Quad3D rotation(float x,
                       float y,
                       float z,
                       float w)
```
    Sets the rotation to a specific Quaternion.
    
    Returns:
    
    This object for chaining.
  - rotation
```
public Quad3D rotation(com.badlogic.gdx.math.Vector3 axis,
                       float angle)
```
    Sets the rotation to a specific angle about an axis.
    
    Returns:
    
    This object for chaining.
  - rotation
```
public Quad3D rotation(float yaw,
                       float pitch,
                       float roll)
```
    Sets the rotation to specific Euler angles.
    
    Returns:
    
    This object for chaining.
  - rotation
```
public Quad3D rotation(float directionX,
                       float directionY,
                       float directionZ,
                       float upX,
                       float upY,
                       float upZ)
```
    Sets the rotation based on a direction vector and up vector. The input vectors do not need to be normalized.
    
    Returns:
    
    This object for chaining.
  - rotation
```
public Quad3D rotation(com.badlogic.gdx.math.Vector3 direction,
                       com.badlogic.gdx.math.Vector3 up)
```
    Sets the rotation based on a direction vector and up vector. The input vectors must be normalized.
    
    Returns:
    
    This object for chaining.
  - lookAt
```
public Quad3D lookAt(com.badlogic.gdx.math.Vector3 position,
                     com.badlogic.gdx.math.Vector3 up)
```
    Sets the rotation to look at the give position, relative to the current position.
    
    Parameters:
    
    up - The direction the top of the quad should be pointing.
    
    Returns:
    
    This object for chaining.
  - billboard
```
public Quad3D billboard(com.badlogic.gdx.graphics.Camera camera)
```
    Sets the rotation to look at the camera, relative to the current position. The quad's top side will be oriented to match the camera's.
    
    Returns:
    
    This object for chaining.
  - billboard
```
public Quad3D billboard(com.badlogic.gdx.graphics.Camera camera,
                        com.badlogic.gdx.math.Vector3 up)
```
    Sets the rotation to look at the camera, relative to the current position.
    
    Parameters:
    
    up - The direction the top of the quad should be pointing.
    
    Returns:
    
    This object for chaining.
  - rotate
```
public Quad3D rotate(com.badlogic.gdx.math.Quaternion rotation)
```
    Rotates the current orientation by a specific Quaternion.
    
    Returns:
    
    This object for chaining.
  - rotateX
```
public Quad3D rotateX(float angle)
```
    Rotates from the current orientation by a specific angle about the X axis.
    
    Returns:
    
    This object for chaining.
  - rotateY
```
public Quad3D rotateY(float angle)
```
    Rotates from the current orientation by a specific angle about the Y axis.
    
    Returns:
    
    This object for chaining.
  - rotateZ
```
public Quad3D rotateZ(float angle)
```
    Rotates from the current orientation by a specific angle about the Z axis.
    
    Returns:
    
    This object for chaining.
  - apply
```
protected int apply(float[] vertices,
                    int vertexStartingIndex,
                    AttributeOffsets offsets,
                    int vertexSize)
```
    Description copied from class: Batchable
    
    Called by FlexBatch. Applies the Batchable data to the vertex array that will be sent to the Mesh. Overriding this method may produce a subclass that is incompatible with a FlexBatch that was instantiated for the superclass type.
    
    Overrides:
    
    apply in class Quad
    
    offsets - The offsets of the vertex attributes.
    
    vertexSize - The size of a vertex in floats.
    
    Returns:
    
    The number of vertices that were added. The value is unused if this is a Batchable.FixedSizeBatchable, as it is assumed to match Batchable.FixedSizeBatchable.getVerticesPerBatchable().
  - texture
```
public Quad3D texture(com.badlogic.gdx.graphics.Texture texture)
```
  - region
```
public Quad3D region(float u,
                     float v,
                     float u2,
                     float v2)
```
    Description copied from class: Quad
    
    Sets the UV region of the most recently applied texture. This must be called after a texture or texture region has been set with Quad.texture(GLTexture) or Quad.textureRegion(TextureRegion). Note that TextureRegions have a Y-down coordinate system for UVs.
    This method must not be called in a Batchable that supports zero textures.
    
    Overrides:
    
    region in class Quad
    
    Parameters:
    
    u - The left side of the region.
    
    v - The top side of the region.
    
    u2 - The right side of the region.
    
    v2 - The bottom side of the region.
    
    Returns:
    
    This object for chaining.
  - textureRegion
```
public Quad3D textureRegion(com.badlogic.gdx.graphics.g2d.TextureRegion region)
```
    Description copied from class: Quad
    
    Sets the texture region. If this Batchable supports multi-texturing, multiple subsequent calls to this method or Quad.texture(GLTexture) will sequentially set the textures in order.
    This method must not be called in a Batchable that supports zero textures.
    
    Overrides:
    
    textureRegion in class Quad
    
    Returns:
    
    This object for chaining.
  - flip
```
public Quad3D flip(boolean flipX,
                   boolean flipY)
```
    Description copied from class: Quad
    
    Flips the UV region of the most recently applied texture. This must be called after a texture or region has been set with Quad.texture(GLTexture) or Quad.textureRegion(TextureRegion).
    
    Overrides:
    
    flip in class Quad
    
    Returns:
    
    This object for chaining.
  - size
```
public Quad3D size(float width,
                   float height)
```
    Overrides:
    
    size in class Quad
  - origin
```
public Quad3D origin(float originX,
                     float originY)
```
    Description copied from class: Quad
    
    Sets the center point for transformations (rotation and scale). For Quad2D, this is relative to the bottom left corner of the texture region. For Quad3D, this is relative to the center of the texture region and is in the local coordinate system.
    
    Overrides:
    
    origin in class Quad
    
    Returns:
    
    This object for chaining.
  - rotateCoordinates90
```
public Quad3D rotateCoordinates90(boolean clockwise)
```
    Description copied from class: Quad
    
    Rotates the texture region(s) 90 degrees in place by rotating the texture coordinates.
    
    Overrides:
    
    rotateCoordinates90 in class Quad
    
    Returns:
    
    This object for chaining.
  - color
```
public Quad3D color(com.badlogic.gdx.graphics.Color color)
```
    Overrides:
    
    color in class Quad
  - color
```
public Quad3D color(float r,
                    float g,
                    float b,
                    float a)
```
    Overrides:
    
    color in class Quad
  - color
```
public Quad3D color(float floatBits)
```
    Overrides:
    
    color in class Quad
  - scale
```
public Quad3D scale(float scaleX,
                    float scaleY)
```
    Overrides:
    
    scale in class Quad

Class Quad3D

Nested Class Summary

Nested classes/interfaces inherited from class com.cyphercove.gdx.flexbatch.Batchable

Field Summary

Fields inherited from class com.cyphercove.gdx.flexbatch.batchable.Quad

Constructor Summary

Method Summary

Methods inherited from class com.cyphercove.gdx.flexbatch.batchable.Quad

Methods inherited from class com.cyphercove.gdx.flexbatch.Batchable.FixedSizeBatchable

Methods inherited from class java.lang.Object

Field Detail

z

rotation

opaque

srcBlendFactor

dstBlendFactor

Constructor Detail

Quad3D

Quad3D

Quad3D

Method Detail

isPosition3D

isTextureCoordinate3D

isOpaque

calculateDistanceSquared

prepareSharedContext

prepareContext

hasEquivalentTextures

refresh

opaque

blend

blend

blend

position

position

translate

translate

rotation

rotation

rotation

rotation

rotation

rotation

lookAt

billboard

billboard

rotate

rotateX

rotateY

rotateZ

apply

texture

region

textureRegion

flip

size

origin

rotateCoordinates90

color

color

color

scale