Adding comments to the renderscript program classes.
Change-Id: I989575951df1218c1e753dfa12193d560266bf11
diff --git a/graphics/java/android/renderscript/Mesh.java b/graphics/java/android/renderscript/Mesh.java
index 59e3dd9..b77fe7d 100644
--- a/graphics/java/android/renderscript/Mesh.java
+++ b/graphics/java/android/renderscript/Mesh.java
@@ -23,10 +23,29 @@
/**
* @hide
+ * Mesh class is a container for geometric data displayed in
+ * renderscript.
+ *
+ * Internally, mesh is a collection of allocations that
+ * represent vertex data (positions, normals, texture
+ * coordinates) and index data such as triangles and lines.
+ *
+ * Vertex data could either be interlieved within one
+ * allocation, provided separately as multiple allocation
+ * objects or done as a combination of the above. When a
+ * vertex channel name matches an input in the vertex program,
+ * renderscript will automatically connect the two together.
+ *
+ * Parts of the mesh could be rendered with either explicit
+ * index sets or primitive types.
*
**/
public class Mesh extends BaseObj {
+ /**
+ * Describes the way mesh vertex data is interpreted when rendering
+ *
+ **/
public enum Primitive {
POINT (0),
LINE (1),
@@ -49,25 +68,50 @@
super(id, rs);
}
+ /**
+ * @return number of allocations containing vertex data
+ *
+ **/
public int getVertexAllocationCount() {
if(mVertexBuffers == null) {
return 0;
}
return mVertexBuffers.length;
}
+ /**
+ * @param slot index in the list of allocations to return
+ * @return vertex data allocation at the given index
+ *
+ **/
public Allocation getVertexAllocation(int slot) {
return mVertexBuffers[slot];
}
+ /**
+ * @return number of primitives or index sets in the mesh
+ *
+ **/
public int getPrimitiveCount() {
if(mIndexBuffers == null) {
return 0;
}
return mIndexBuffers.length;
}
+
+ /**
+ * @param slot locaton within the list of index set allocation
+ * @return allocation containing primtive index data or null if
+ * the index data is not specified explicitly
+ *
+ **/
public Allocation getIndexSetAllocation(int slot) {
return mIndexBuffers[slot];
}
+ /**
+ * @param slot locaiton within the list of index set primitives
+ * @return index set primitive type
+ *
+ **/
public Primitive getPrimitive(int slot) {
return mPrimitives[slot];
}
@@ -105,6 +149,12 @@
}
}
+ /**
+ * Mesh builder object. It starts empty and requires the user to
+ * add the types necessary to create vertex and index
+ * allocations
+ *
+ */
public static class Builder {
RenderScript mRS;
int mUsage;
@@ -121,6 +171,13 @@
Entry[] mVertexTypes;
Vector mIndexTypes;
+ /**
+ * Creates builder object
+ * @param rs
+ * @param usage specifies how the mesh allocations are to be
+ * handled, whether they need to be uploaded to a
+ * buffer on the gpu, maintain a cpu copy, etc
+ */
public Builder(RenderScript rs, int usage) {
mRS = rs;
mUsage = usage;
@@ -129,14 +186,29 @@
mIndexTypes = new Vector();
}
+ /**
+ * @return internal index of the last vertex buffer type added to
+ * builder
+ **/
public int getCurrentVertexTypeIndex() {
return mVertexTypeCount - 1;
}
+ /**
+ * @return internal index of the last index set added to the
+ * builder
+ **/
public int getCurrentIndexSetIndex() {
return mIndexTypes.size() - 1;
}
+ /**
+ * Adds a vertex data type to the builder object
+ *
+ * @param r type of the vertex data allocation to be created
+ *
+ * @return this
+ **/
public Builder addVertexType(Type t) throws IllegalStateException {
if (mVertexTypeCount >= mVertexTypes.length) {
throw new IllegalStateException("Max vertex types exceeded.");
@@ -149,6 +221,14 @@
return this;
}
+ /**
+ * Adds a vertex data type to the builder object
+ *
+ * @param e element describing the vertex data layout
+ * @param size number of elements in the buffer
+ *
+ * @return this
+ **/
public Builder addVertexType(Element e, int size) throws IllegalStateException {
if (mVertexTypeCount >= mVertexTypes.length) {
throw new IllegalStateException("Max vertex types exceeded.");
@@ -162,6 +242,14 @@
return this;
}
+ /**
+ * Adds an index set data type to the builder object
+ *
+ * @param t type of the index set data, could be null
+ * @param p primitive type
+ *
+ * @return this
+ **/
public Builder addIndexSetType(Type t, Primitive p) {
Entry indexType = new Entry();
indexType.t = t;
@@ -172,6 +260,13 @@
return this;
}
+ /**
+ * Adds an index set primitive type to the builder object
+ *
+ * @param p primitive type
+ *
+ * @return this
+ **/
public Builder addIndexSetType(Primitive p) {
Entry indexType = new Entry();
indexType.t = null;
@@ -182,6 +277,15 @@
return this;
}
+ /**
+ * Adds an index set data type to the builder object
+ *
+ * @param e element describing the index set data layout
+ * @param size number of elements in the buffer
+ * @param p primitive type
+ *
+ * @return this
+ **/
public Builder addIndexSetType(Element e, int size, Primitive p) {
Entry indexType = new Entry();
indexType.t = null;
@@ -237,6 +341,10 @@
return newMesh;
}
+ /**
+ * Create a Mesh object from the current state of the builder
+ *
+ **/
public Mesh create() {
mRS.validate();
Mesh sm = internalCreate(mRS, this);
@@ -244,6 +352,12 @@
}
}
+ /**
+ * Mesh builder object. It starts empty and requires the user to
+ * add all the vertex and index allocations that comprise the
+ * mesh
+ *
+ */
public static class AllocationBuilder {
RenderScript mRS;
@@ -264,14 +378,30 @@
mIndexTypes = new Vector();
}
+ /**
+ * @return internal index of the last vertex buffer type added to
+ * builder
+ **/
public int getCurrentVertexTypeIndex() {
return mVertexTypeCount - 1;
}
+ /**
+ * @return internal index of the last index set added to the
+ * builder
+ **/
public int getCurrentIndexSetIndex() {
return mIndexTypes.size() - 1;
}
+ /**
+ * Adds an allocation containing vertex buffer data to the
+ * builder
+ *
+ * @param a vertex data allocation
+ *
+ * @return this
+ **/
public AllocationBuilder addVertexAllocation(Allocation a) throws IllegalStateException {
if (mVertexTypeCount >= mVertexTypes.length) {
throw new IllegalStateException("Max vertex types exceeded.");
@@ -283,6 +413,15 @@
return this;
}
+ /**
+ * Adds an allocation containing index buffer data and index type
+ * to the builder
+ *
+ * @param a index set data allocation, could be null
+ * @param p index set primitive type
+ *
+ * @return this
+ **/
public AllocationBuilder addIndexSetAllocation(Allocation a, Primitive p) {
Entry indexType = new Entry();
indexType.a = a;
@@ -291,6 +430,13 @@
return this;
}
+ /**
+ * Adds an index set type to the builder
+ *
+ * @param p index set primitive type
+ *
+ * @return this
+ **/
public AllocationBuilder addIndexSetType(Primitive p) {
Entry indexType = new Entry();
indexType.a = null;
@@ -325,6 +471,10 @@
return newMesh;
}
+ /**
+ * Create a Mesh object from the current state of the builder
+ *
+ **/
public Mesh create() {
mRS.validate();
Mesh sm = internalCreate(mRS, this);
@@ -332,7 +482,11 @@
}
}
-
+ /**
+ * Builder that allows creation of a mesh object point by point
+ * and triangle by triangle
+ *
+ **/
public static class TriangleMeshBuilder {
float mVtxData[];
int mVtxCount;
@@ -358,6 +512,15 @@
public static final int NORMAL = 0x0002;
public static final int TEXTURE_0 = 0x0100;
+ /**
+ * @param rs
+ * @param vtxSize specifies whether the vertex is a float2 or
+ * float3
+ * @param flags bitfield that is a combination of COLOR, NORMAL,
+ * and TEXTURE_0 that specifies what vertex data
+ * channels are present in the mesh
+ *
+ **/
public TriangleMeshBuilder(RenderScript rs, int vtxSize, int flags) {
mRS = rs;
mVtxCount = 0;
@@ -401,6 +564,15 @@
}
}
+ /**
+ * Adds a float2 vertex to the mesh
+ *
+ * @param x position x
+ * @param y position y
+ *
+ * @return this
+ *
+ **/
public TriangleMeshBuilder addVertex(float x, float y) {
if (mVtxSize != 2) {
throw new IllegalStateException("add mistmatch with declared components.");
@@ -412,6 +584,16 @@
return this;
}
+ /**
+ * Adds a float3 vertex to the mesh
+ *
+ * @param x position x
+ * @param y position y
+ * @param z position z
+ *
+ * @return this
+ *
+ **/
public TriangleMeshBuilder addVertex(float x, float y, float z) {
if (mVtxSize != 3) {
throw new IllegalStateException("add mistmatch with declared components.");
@@ -424,6 +606,14 @@
return this;
}
+ /**
+ * Sets the texture coordinate for the last added vertex
+ *
+ * @param s texture coordinate s
+ * @param t texture coordinate t
+ *
+ * @return this
+ **/
public TriangleMeshBuilder setTexture(float s, float t) {
if ((mFlags & TEXTURE_0) == 0) {
throw new IllegalStateException("add mistmatch with declared components.");
@@ -433,6 +623,15 @@
return this;
}
+ /**
+ * Sets the normal vector for the last added vertex
+ *
+ * @param x normal vector x
+ * @param y normal vector y
+ * @param z normal vector z
+ *
+ * @return this
+ **/
public TriangleMeshBuilder setNormal(float x, float y, float z) {
if ((mFlags & NORMAL) == 0) {
throw new IllegalStateException("add mistmatch with declared components.");
@@ -443,6 +642,16 @@
return this;
}
+ /**
+ * Sets the color for the last added vertex
+ *
+ * @param r red component
+ * @param g green component
+ * @param b blue component
+ * @param a alpha component
+ *
+ * @return this
+ **/
public TriangleMeshBuilder setColor(float r, float g, float b, float a) {
if ((mFlags & COLOR) == 0) {
throw new IllegalStateException("add mistmatch with declared components.");
@@ -454,6 +663,15 @@
return this;
}
+ /**
+ * Adds a new triangle to the mesh builder
+ *
+ * @param idx1 index of the first vertex in the triangle
+ * @param idx2 index of the second vertex in the triangle
+ * @param idx3 index of the third vertex in the triangle
+ *
+ * @return this
+ **/
public TriangleMeshBuilder addTriangle(int idx1, int idx2, int idx3) {
if((idx1 >= mVtxCount) || (idx1 < 0) ||
(idx2 >= mVtxCount) || (idx2 < 0) ||
@@ -471,6 +689,20 @@
return this;
}
+ /**
+ * Creates the mesh object from the current state of the builder
+ *
+ * @param uploadToBufferObject specifies whether the vertex data
+ * is to be uploaded into the buffer
+ * object indicating that it's likely
+ * not going to be modified and
+ * rendered many times.
+ * Alternatively, it indicates the
+ * mesh data will be updated
+ * frequently and remain in script
+ * accessible memory
+ *
+ **/
public Mesh create(boolean uploadToBufferObject) {
Element.Builder b = new Element.Builder(mRS);
int floatCount = mVtxSize;
diff --git a/graphics/java/android/renderscript/Program.java b/graphics/java/android/renderscript/Program.java
index b07ae7d..fdd138c 100644
--- a/graphics/java/android/renderscript/Program.java
+++ b/graphics/java/android/renderscript/Program.java
@@ -28,6 +28,9 @@
/**
*
+ * Program is a base class for all the objects that modify
+ * various stages of the graphics pipeline
+ *
**/
public class Program extends BaseObj {
public static final int MAX_INPUT = 8;
@@ -35,6 +38,12 @@
public static final int MAX_CONSTANT = 8;
public static final int MAX_TEXTURE = 8;
+ /**
+ *
+ * TextureType specifies what textures are attached to Program
+ * objects
+ *
+ **/
public enum TextureType {
TEXTURE_2D (0),
TEXTURE_CUBE (1);
@@ -68,6 +77,14 @@
super(id, rs);
}
+ /**
+ * Binds a constant buffer to be used as uniform inputs to the
+ * program
+ *
+ * @param a allocation containing uniform data
+ * @param slot index within the program's list of constant
+ * buffer allocations
+ */
public void bindConstants(Allocation a, int slot) {
if (slot < 0 || slot >= mConstants.length) {
throw new IllegalArgumentException("Slot ID out of range.");
@@ -80,6 +97,13 @@
mRS.nProgramBindConstants(getID(), slot, id);
}
+ /**
+ * Binds a texture to be used in the program
+ *
+ * @param va allocation containing texture data
+ * @param slot index within the program's list of textures
+ *
+ */
public void bindTexture(Allocation va, int slot)
throws IllegalArgumentException {
mRS.validate();
@@ -95,6 +119,15 @@
mRS.nProgramBindTexture(getID(), slot, id);
}
+ /**
+ * Binds an object that describes how a texture at the
+ * corresponding location is sampled
+ *
+ * @param vs sampler for a corresponding texture
+ * @param slot index within the program's list of textures to
+ * use the sampler on
+ *
+ */
public void bindSampler(Sampler vs, int slot)
throws IllegalArgumentException {
mRS.validate();
@@ -133,11 +166,25 @@
mTextureTypes = new TextureType[MAX_TEXTURE];
}
+ /**
+ * Sets the GLSL shader code to be used in the program
+ *
+ * @param s GLSL shader string
+ * @return self
+ */
public BaseProgramBuilder setShader(String s) {
mShader = s;
return this;
}
+ /**
+ * Sets the GLSL shader code to be used in the program
+ *
+ * @param resources application resources
+ * @param resourceID id of the file containing GLSL shader code
+ *
+ * @return self
+ */
public BaseProgramBuilder setShader(Resources resources, int resourceID) {
byte[] str;
int strLength;
@@ -176,14 +223,29 @@
return this;
}
+ /**
+ * Queries the index of the last added constant buffer type
+ *
+ */
public int getCurrentConstantIndex() {
return mConstantCount - 1;
}
+ /**
+ * Queries the index of the last added texture type
+ *
+ */
public int getCurrentTextureIndex() {
return mTextureCount - 1;
}
+ /**
+ * Adds constant (uniform) inputs to the program
+ *
+ * @param t Type that describes the layout of the Allocation
+ * object to be used as constant inputs to the Program
+ * @return self
+ */
public BaseProgramBuilder addConstant(Type t) throws IllegalStateException {
// Should check for consistant and non-conflicting names...
if(mConstantCount >= MAX_CONSTANT) {
@@ -197,6 +259,13 @@
return this;
}
+ /**
+ * Adds a texture input to the Program
+ *
+ * @param texType describes that the texture to append it (2D,
+ * Cubemap, etc.)
+ * @return self
+ */
public BaseProgramBuilder addTexture(TextureType texType) throws IllegalArgumentException {
if(mTextureCount >= MAX_TEXTURE) {
throw new IllegalArgumentException("Max texture count exceeded.");
diff --git a/graphics/java/android/renderscript/ProgramFragment.java b/graphics/java/android/renderscript/ProgramFragment.java
index 7f12661..14c0c01 100644
--- a/graphics/java/android/renderscript/ProgramFragment.java
+++ b/graphics/java/android/renderscript/ProgramFragment.java
@@ -22,6 +22,9 @@
/**
+ * ProgramFragment, also know as a fragment shader, describes a
+ * stage in the graphics pipeline responsible for manipulating
+ * pixel data in a user-defined way.
*
**/
public class ProgramFragment extends Program {
@@ -30,10 +33,20 @@
}
public static class Builder extends BaseProgramBuilder {
+ /**
+ * Create a builder object.
+ *
+ * @param rs
+ */
public Builder(RenderScript rs) {
super(rs);
}
+ /**
+ * Creates ProgramFragment from the current state of the builder
+ *
+ * @return ProgramFragment
+ */
public ProgramFragment create() {
mRS.validate();
int[] tmp = new int[(mInputCount + mOutputCount + mConstantCount + mTextureCount) * 2];
diff --git a/graphics/java/android/renderscript/ProgramFragmentFixedFunction.java b/graphics/java/android/renderscript/ProgramFragmentFixedFunction.java
index f0040c6..663bc9f 100644
--- a/graphics/java/android/renderscript/ProgramFragmentFixedFunction.java
+++ b/graphics/java/android/renderscript/ProgramFragmentFixedFunction.java
@@ -22,6 +22,13 @@
/**
+ * ProgramFragmentFixedFunction is a helper class that provides
+ * a way to make a simple fragment shader without writing any
+ * GLSL code.
+ *
+ * This class allows for display of constant color, interpolated
+ * color from vertex shader, or combinations of the above
+ * blended with results of up to two texture lookups.
*
**/
public class ProgramFragmentFixedFunction extends ProgramFragment {
@@ -34,6 +41,12 @@
super(rs);
}
+ /**
+ * Creates ProgramFragmentFixedFunction from the current state
+ * of the builder
+ *
+ * @return ProgramFragmentFixedFunction
+ */
public ProgramFragmentFixedFunction create() {
mRS.validate();
int[] tmp = new int[(mInputCount + mOutputCount + mConstantCount + mTextureCount) * 2];
@@ -71,6 +84,11 @@
String mShader;
RenderScript mRS;
+ /**
+ * EnvMode describes how textures are combined with the existing
+ * color in the fixed function fragment shader
+ *
+ **/
public enum EnvMode {
REPLACE (1),
MODULATE (2),
@@ -82,6 +100,11 @@
}
}
+ /**
+ * Format describes the pixel format of textures in the fixed
+ * function fragment shader and how they are sampled
+ *
+ **/
public enum Format {
ALPHA (1),
LUMINANCE_ALPHA (2),
@@ -168,12 +191,30 @@
mShader += "}\n";
}
+ /**
+ * Creates a builder for fixed function fragment program
+ *
+ * @param rs
+ */
public Builder(RenderScript rs) {
mRS = rs;
mSlots = new Slot[MAX_TEXTURE];
mPointSpriteEnable = false;
}
+ /**
+ * Adds a texture to be fetched as part of the fixed function
+ * fragment program
+ *
+ * @param env specifies how the texture is combined with the
+ * current color
+ * @param fmt specifies the format of the texture and how its
+ * components will be used to combine with the
+ * current color
+ * @param slot index of the texture to apply the operations on
+ *
+ * @return this
+ */
public Builder setTexture(EnvMode env, Format fmt, int slot)
throws IllegalArgumentException {
if((slot < 0) || (slot >= MAX_TEXTURE)) {
@@ -183,16 +224,34 @@
return this;
}
+ /**
+ * Specifies whether the texture coordinate passed from the
+ * vertex program is replaced with an openGL internal point
+ * sprite texture coordinate
+ *
+ **/
public Builder setPointSpriteTexCoordinateReplacement(boolean enable) {
mPointSpriteEnable = enable;
return this;
}
+ /**
+ * Specifies whether the varying color passed from the vertex
+ * program or the constant color set on the fragment program is
+ * used in the final color calculation in the fixed function
+ * fragment shader
+ *
+ **/
public Builder setVaryingColor(boolean enable) {
mVaryingColorEnable = enable;
return this;
}
+ /**
+ * Creates the fixed function fragment program from the current
+ * state of the builder.
+ *
+ */
public ProgramFragmentFixedFunction create() {
InternalBuilder sb = new InternalBuilder(mRS);
mNumTextures = 0;
diff --git a/graphics/java/android/renderscript/ProgramVertex.java b/graphics/java/android/renderscript/ProgramVertex.java
index 13800ff..7ba8b82 100644
--- a/graphics/java/android/renderscript/ProgramVertex.java
+++ b/graphics/java/android/renderscript/ProgramVertex.java
@@ -23,6 +23,9 @@
/**
+ * ProgramVertex, also know as a vertex shader, describes a
+ * stage in the graphics pipeline responsible for manipulating
+ * geometric data in a user-defined way.
*
**/
public class ProgramVertex extends Program {
@@ -31,11 +34,31 @@
super(id, rs);
}
+ /**
+ * Builder class for creating ProgramVertex objects.
+ * The builder starts empty and the user must minimally provide
+ * the GLSL shader code, and the varying inputs. Constant, or
+ * uniform parameters to the shader may optionally be provided as
+ * well.
+ *
+ **/
public static class Builder extends BaseProgramBuilder {
+ /**
+ * Create a builder object.
+ *
+ * @param rs
+ */
public Builder(RenderScript rs) {
super(rs);
}
+ /**
+ * Add varying inputs to the program
+ *
+ * @param e element describing the layout of the varying input
+ * structure
+ * @return self
+ */
public Builder addInput(Element e) throws IllegalStateException {
// Should check for consistant and non-conflicting names...
if(mInputCount >= MAX_INPUT) {
@@ -48,6 +71,11 @@
return this;
}
+ /**
+ * Creates ProgramVertex from the current state of the builder
+ *
+ * @return ProgramVertex
+ */
public ProgramVertex create() {
mRS.validate();
int[] tmp = new int[(mInputCount + mOutputCount + mConstantCount + mTextureCount) * 2];
diff --git a/graphics/java/android/renderscript/ProgramVertexFixedFunction.java b/graphics/java/android/renderscript/ProgramVertexFixedFunction.java
index 1b69efe..b9537c7 100644
--- a/graphics/java/android/renderscript/ProgramVertexFixedFunction.java
+++ b/graphics/java/android/renderscript/ProgramVertexFixedFunction.java
@@ -23,6 +23,9 @@
/**
+ * ProgramVertexFixedFunction is a helper class that provides a
+ * simple way to create a fixed function emulation vertex shader
+ * without writing any GLSL code.
*
**/
public class ProgramVertexFixedFunction extends ProgramVertex {
@@ -31,6 +34,12 @@
super(id, rs);
}
+ /**
+ * Binds the constant buffer containing fixed function emulation
+ * matrices
+ *
+ * @param va allocation containing fixed function matrices
+ */
public void bindConstants(Constants va) {
mRS.validate();
bindConstants(va.getAllocation(), 0);
@@ -53,6 +62,12 @@
return this;
}
+ /**
+ * Creates ProgramVertexFixedFunction from the current state of
+ * the builder
+ *
+ * @return ProgramVertexFixedFunction
+ */
public ProgramVertexFixedFunction create() {
mRS.validate();
int[] tmp = new int[(mInputCount + mOutputCount + mConstantCount + mTextureCount) * 2];
@@ -87,10 +102,20 @@
String mShader;
RenderScript mRS;
+ /**
+ * Creates a builder for fixed function vertex program
+ *
+ * @param rs
+ */
public Builder(RenderScript rs) {
mRS = rs;
}
+ /**
+ * Specifies whether texture matrix calculations are to be added
+ * to the shader
+ *
+ */
public Builder setTextureMatrixEnable(boolean enable) {
mTextureMatrixEnable = enable;
return this;
@@ -126,6 +151,12 @@
mShader += "}\n";
}
+ /**
+ * Creates ProgramVertexFixedFunction from the current state of
+ * the builder
+ *
+ * @return Fixed function emulation ProgramVertex
+ */
public ProgramVertexFixedFunction create() {
buildShaderString();
@@ -144,6 +175,11 @@
}
}
+ /**
+ * Helper class to store modelview, projection and texture
+ * matrices for ProgramVertexFixedFunction
+ *
+ */
public static class Constants {
static final int MODELVIEW_OFFSET = 0;
static final int PROJECTION_OFFSET = 16;
@@ -159,6 +195,11 @@
}
private FieldPacker mIOBuffer;
+ /**
+ * Creates buffer to store fixed function emulation matrices
+ *
+ * @param rs
+ **/
public Constants(RenderScript rs) {
Type constInputType = ProgramVertexFixedFunction.Builder.getConstantInputType(rs);
mAlloc = Allocation.createTyped(rs, constInputType);
@@ -173,6 +214,11 @@
setTexture(new Matrix4f());
}
+ /**
+ * Forces deallocation of memory backing the contant matrices.
+ * Normally, this is unnecessary and will be garbage collected
+ *
+ */
public void destroy() {
mAlloc.destroy();
mAlloc = null;
@@ -186,16 +232,34 @@
mAlloc.copyFrom(mIOBuffer.getData());
}
+ /**
+ * Sets the modelview matrix in the fixed function matrix buffer
+ *
+ * @param m modelview matrix
+ */
public void setModelview(Matrix4f m) {
mModel.load(m);
addToBuffer(MODELVIEW_OFFSET*4, m);
}
+ /**
+ * Sets the projection matrix in the fixed function matrix buffer
+ *
+ * @param m projection matrix
+ */
public void setProjection(Matrix4f m) {
mProjection.load(m);
addToBuffer(PROJECTION_OFFSET*4, m);
}
+ /**
+ * Sets the texture matrix in the fixed function matrix buffer.
+ * Texture matrix must be enabled in the
+ * ProgramVertexFixedFunction builder for the shader to utilize
+ * it.
+ *
+ * @param m modelview matrix
+ */
public void setTexture(Matrix4f m) {
mTexture.load(m);
addToBuffer(TEXTURE_OFFSET*4, m);