public override void Present(float deltaTime)
{
IGL10 gl = _glGraphics.GL10;
gl.GlViewport(0, 0, _glGraphics.Width, _glGraphics.Height);
gl.GlClearColor(0, 0, 0, 1);
gl.GlClear(GL10.GlColorBufferBit);
gl.GlMatrixMode(GL10.GlProjection);
gl.GlLoadIdentity();
gl.GlOrthof(0, 540, 0, 960, 1, -1);
gl.GlEnable(GL10.GlTexture2d);
gl.GlBlendFunc(GL10.GlSrcAlpha, GL10.GlOneMinusSrcAlpha);
gl.GlEnable(GL10.GlBlend);
gl.GlBindTexture(GL10.GlTexture2d, _textureId);
gl.GlEnableClientState(GL10.GlVertexArray);
gl.GlEnableClientState(GL10.GlTextureCoordArray);
_vertices.Position(0);
gl.GlVertexPointer(2, GL10.GlFloat, _vertexSize, _vertices);
_vertices.Position(2);
gl.GlTexCoordPointer(2, GL10.GlFloat, _vertexSize, _vertices);
gl.GlDrawArrays(GL10.GlTriangles, 0, 3);
//gl.GlDisableClientState(GL10.GlVertexArray);
//gl.GlDisableClientState(GL10.GlTextureCoordArray);
}
public void DrawFrame(SurfaceTexture st)
{
CheckGlError("onDrawFrame start");
st.GetTransformMatrix(mSTMatrix);
GLES20.GlClearColor(0.0f, 1.0f, 0.0f, 1.0f);
GLES20.GlClear(GLES20.GlDepthBufferBit | GLES20.GlColorBufferBit);
GLES20.GlUseProgram(mProgram);
CheckGlError("glUseProgram");
GLES20.GlActiveTexture(GLES20.GlTexture0);
GLES20.GlBindTexture(GLES11Ext.GlTextureExternalOes, _textureID);
mTriangleVertices.Position(TRIANGLE_VERTICES_DATA_POS_OFFSET);
GLES20.GlVertexAttribPointer(maPositionHandle, 3, GLES20.GlFloat, false,
TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mTriangleVertices);
CheckGlError("glVertexAttribPointer maPosition");
GLES20.GlEnableVertexAttribArray(maPositionHandle);
CheckGlError("glEnableVertexAttribArray maPositionHandle");
mTriangleVertices.Position(TRIANGLE_VERTICES_DATA_UV_OFFSET);
GLES20.GlVertexAttribPointer(maTextureHandle, 2, GLES20.GlFloat, false,
TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mTriangleVertices);
CheckGlError("glVertexAttribPointer maTextureHandle");
GLES20.GlEnableVertexAttribArray(maTextureHandle);
CheckGlError("glEnableVertexAttribArray maTextureHandle");
Android.Opengl.Matrix.SetIdentityM(mMVPMatrix, 0);
GLES20.GlUniformMatrix4fv(muMVPMatrixHandle, 1, false, mMVPMatrix, 0);
GLES20.GlUniformMatrix4fv(muSTMatrixHandle, 1, false, mSTMatrix, 0);
GLES20.GlDrawArrays(GLES20.GlTriangleStrip, 0, 4);
CheckGlError("glDrawArrays");
GLES20.GlFinish();
}
public virtual void DrawElements(FloatBuffer vertices, ShortBuffer indices, int size)
{
vertices.Position(0);
AXy.VertexPointer(2, 4, vertices);
vertices.Position(2);
AUv.VertexPointer(2, 4, vertices);
GLES20.GlDrawElements(GLES20.GlTriangles, size, GLES20.GlUnsignedShort, indices);
}
public virtual void DrawQuad(FloatBuffer vertices)
{
vertices.Position(0);
AXy.VertexPointer(2, 4, vertices);
vertices.Position(2);
AUv.VertexPointer(2, 4, vertices);
GLES20.GlDrawElements(GLES20.GlTriangles, Quad.SIZE, GLES20.GlUnsignedShort, Quad.GetIndices(1));
}
public void OnDrawFrame(IGL10 gl)
{
GLES20.GlClear(GLES20.GlColorBufferBit | GLES20.GlDepthBufferBit);
// Draw the triangle facing straight on.
angleInDegrees += 1.0f;
float[] mModelMatrix = new float[16];
Matrix.SetIdentityM(mModelMatrix, 0);
Matrix.RotateM(mModelMatrix, 0, angleInDegrees, 0.0f, 0.0f, 1.0f);
// Matrix.ScaleM(mModelMatrix, 0, angleInDegrees / 1000.0f, 1.0f, 1.0f);
// Matrix.TranslateM(mModelMatrix, 0, angleInDegrees / 1000.0f, angleInDegrees / 1000.0f, 0.0f);
// Pass in the position information
mTriangle1Vertices.Position(mPositionOffset);
GLES20.GlVertexAttribPointer(mPositionHandle, mPositionDataSize, GLES20.GlFloat, false, mStrideBytes, mTriangle1Vertices);
GLES20.GlEnableVertexAttribArray(mPositionHandle);
// Pass in the color information
mTriangle1Vertices.Position(mColorOffset);
GLES20.GlVertexAttribPointer(mColorHandle, mColorDataSize, GLES20.GlFloat, false, mStrideBytes, mTriangle1Vertices);
GLES20.GlEnableVertexAttribArray(mColorHandle);
// This multiplies the view matrix by the model matrix, and stores the result in the MVP matrix
// (which currently contains model * view).
// Allocate storage for the final combined matrix. This will be passed into the shader program. */
float[] mMVPMatrix = new float[16];
Matrix.MultiplyMM(mMVPMatrix, 0, mViewMatrix, 0, mModelMatrix, 0);
// This multiplies the modelview matrix by the projection matrix, and stores the result in the MVP matrix
// (which now contains model * view * projection).
// THIS IS NOT WORK AT C# Matrix class -> Matrix.MultiplyMM(mMVPMatrix, 0, mProjectionMatrix, 0, mMVPMatrix, 0);
float[] _mMVPMatrix = new float[16];
Matrix.MultiplyMM(_mMVPMatrix, 0, mProjectionMatrix, 0, mMVPMatrix, 0);
GLES20.GlUniformMatrix4fv(mMVPMatrixHandle, 1, false, _mMVPMatrix, 0);
//GLES20.GlDrawArrays(GLES20.GlTriangles, 0, 3);
for (int y = 0; y < 10; y++)
{
for (int x = 0; x < 10; x++)
{
Matrix.SetIdentityM(mModelMatrix, 0);
Matrix.ScaleM(mModelMatrix, 0, 0.1f, 0.1f, 0.1f);
Matrix.TranslateM(mModelMatrix, 0, x * 2.0f, y * 2.0f, 0.0f);
Matrix.RotateM(mModelMatrix, 0, angleInDegrees, 1.0f, 0.0f, 0.0f);
Matrix.MultiplyMM(mMVPMatrix, 0, mViewMatrix, 0, mModelMatrix, 0);
Matrix.MultiplyMM(_mMVPMatrix, 0, mProjectionMatrix, 0, mMVPMatrix, 0);
GLES20.GlUniformMatrix4fv(mMVPMatrixHandle, 1, false, _mMVPMatrix, 0);
GLES20.GlDrawArrays(GLES20.GlTriangles, 0, 3);
}
}
}
public virtual void DrawQuadSet(FloatBuffer vertices, int size)
{
if (size == 0)
{
return;
}
vertices.Position(0);
AXy.VertexPointer(2, 4, vertices);
vertices.Position(2);
AUv.VertexPointer(2, 4, vertices);
GLES20.GlDrawElements(GLES20.GlTriangles, Quad.SIZE * size, GLES20.GlUnsignedShort, Quad.GetIndices(size));
}
public Square ()
{
// initialize vertex byte buffer for shape coordinates
ByteBuffer bb = ByteBuffer.AllocateDirect (
// (# of coordinate values * 4 bytes per float)
squareCoords.Length * 4);
bb.Order (ByteOrder.NativeOrder ());
vertexBuffer = bb.AsFloatBuffer ();
vertexBuffer.Put (squareCoords);
vertexBuffer.Position (0);
// initialize byte buffer for the draw list
ByteBuffer dlb = ByteBuffer.AllocateDirect (
// (# of coordinate values * 2 bytes per short)
drawOrder.Length * 2);
dlb.Order (ByteOrder.NativeOrder ());
drawListBuffer = dlb.AsShortBuffer ();
drawListBuffer.Put (drawOrder);
drawListBuffer.Position (0);
// prepare shaders and OpenGL program
int vertexShader = MyGLRenderer.LoadShader (GLES20.GlVertexShader,
vertexShaderCode);
int fragmentShader = MyGLRenderer.LoadShader (GLES20.GlFragmentShader,
fragmentShaderCode);
mProgram = GLES20.GlCreateProgram (); // create empty OpenGL Program
GLES20.GlAttachShader (mProgram, vertexShader); // add the vertex shader to program
GLES20.GlAttachShader (mProgram, fragmentShader); // add the fragment shader to program
GLES20.GlLinkProgram (mProgram); // create OpenGL program executables
}
protected internal virtual void UpdateVertices()
{
verticesBuffer.Position(0);
var Right = Width - marginRight;
var Bottom = Height - marginBottom;
Quad.Fill(vertices, 0, marginLeft, 0, marginTop, outterF.Left, innerF.Left, outterF.Top, innerF.Top);
verticesBuffer.Put(vertices);
Quad.Fill(vertices, marginLeft, Right, 0, marginTop, innerF.Left, innerF.Right, outterF.Top, innerF.Top);
verticesBuffer.Put(vertices);
Quad.Fill(vertices, Right, Width, 0, marginTop, innerF.Right, outterF.Right, outterF.Top, innerF.Top);
verticesBuffer.Put(vertices);
Quad.Fill(vertices, 0, marginLeft, marginTop, Bottom, outterF.Left, innerF.Left, innerF.Top, innerF.Bottom);
verticesBuffer.Put(vertices);
Quad.Fill(vertices, marginLeft, Right, marginTop, Bottom, innerF.Left, innerF.Right, innerF.Top, innerF.Bottom);
verticesBuffer.Put(vertices);
Quad.Fill(vertices, Right, Width, marginTop, Bottom, innerF.Right, outterF.Right, innerF.Top, innerF.Bottom);
verticesBuffer.Put(vertices);
Quad.Fill(vertices, 0, marginLeft, Bottom, Height, outterF.Left, innerF.Left, innerF.Bottom, outterF.Bottom);
verticesBuffer.Put(vertices);
Quad.Fill(vertices, marginLeft, Right, Bottom, Height, innerF.Left, innerF.Right, innerF.Bottom, outterF.Bottom);
verticesBuffer.Put(vertices);
Quad.Fill(vertices, Right, Width, Bottom, Height, innerF.Right, outterF.Right, innerF.Bottom, outterF.Bottom);
verticesBuffer.Put(vertices);
}
public Triangle ()
{
// initialize vertex byte buffer for shape coordinates
ByteBuffer bb = ByteBuffer.AllocateDirect (
// (number of coordinate values * 4 bytes per float)
triangleCoords.Length * 4);
// use the device hardware's native byte order
bb.Order (ByteOrder.NativeOrder ());
// create a floating point buffer from the ByteBuffer
vertexBuffer = bb.AsFloatBuffer ();
// add the coordinates to the FloatBuffer
vertexBuffer.Put (triangleCoords);
// set the buffer to read the first coordinate
vertexBuffer.Position (0);
// prepare shaders and OpenGL program
int vertexShader = MyGLRenderer.LoadShader (GLES30.GlVertexShader,
vertexShaderCode);
int fragmentShader = MyGLRenderer.LoadShader (GLES30.GlFragmentShader,
fragmentShaderCode);
mProgram = GLES30.GlCreateProgram (); // create empty OpenGL Program
GLES30.GlAttachShader (mProgram, vertexShader); // add the vertex shader to program
GLES30.GlAttachShader (mProgram, fragmentShader); // add the fragment shader to program
GLES30.GlLinkProgram (mProgram); // create OpenGL program executables
}
public CameraFrustum()
{
// Reset the model matrix to the identity
Matrix.SetIdentityM(ModelMatrix, 0);
// Load the vertices into a vertex buffer
ByteBuffer byteBuf = ByteBuffer.AllocateDirect(mVertices.Length * 4);
byteBuf.Order(ByteOrder.NativeOrder());
mVertexBuffer = byteBuf.AsFloatBuffer();
mVertexBuffer.Put(mVertices);
mVertexBuffer.Position(0);
// Load the colors into a color buffer
ByteBuffer cByteBuff = ByteBuffer.AllocateDirect(mColors.Length * 4);
cByteBuff.Order(ByteOrder.NativeOrder());
mColorBuffer = cByteBuff.AsFloatBuffer();
mColorBuffer.Put(mColors);
mColorBuffer.Position(0);
// Load the vertex and fragment shaders, then link the program
int vertexShader = RenderUtils.loadShader(GLES20.GlVertexShader, sVertexShaderCode);
int fragShader = RenderUtils.loadShader(GLES20.GlFragmentShader, sFragmentShaderCode);
mProgram = GLES20.GlCreateProgram();
GLES20.GlAttachShader(mProgram, vertexShader);
GLES20.GlAttachShader(mProgram, fragShader);
GLES20.GlLinkProgram(mProgram);
}
public Square()
{
// initialize vertex byte buffer for shape coordinates
ByteBuffer bb = ByteBuffer.AllocateDirect(
// (# of coordinate values * 4 bytes per float)
squareCoords.Length * 4);
bb.Order(ByteOrder.NativeOrder());
vertexBuffer = bb.AsFloatBuffer();
vertexBuffer.Put(squareCoords);
vertexBuffer.Position(0);
// initialize byte buffer for the draw list
ByteBuffer dlb = ByteBuffer.AllocateDirect(
// (# of coordinate values * 2 bytes per short)
drawOrder.Length * 2);
dlb.Order(ByteOrder.NativeOrder());
drawListBuffer = dlb.AsShortBuffer();
drawListBuffer.Put(drawOrder);
drawListBuffer.Position(0);
// prepare shaders and OpenGL program
int vertexShader = MyGLRenderer.LoadShader(GLES20.GlVertexShader,
vertexShaderCode);
int fragmentShader = MyGLRenderer.LoadShader(GLES20.GlFragmentShader,
fragmentShaderCode);
mProgram = GLES20.GlCreateProgram(); // create empty OpenGL Program
GLES20.GlAttachShader(mProgram, vertexShader); // add the vertex shader to program
GLES20.GlAttachShader(mProgram, fragmentShader); // add the fragment shader to program
GLES20.GlLinkProgram(mProgram); // create OpenGL program executables
}
/**
* Allocates and initializes OpenGL resources needed by the background renderer. Must be
* called on the OpenGL thread, typically in
* {@link GLSurfaceView.Renderer#onSurfaceCreated(GL10, EGLConfig)}.
*
* @param context Needed to access shader source.
*/
public void CreateOnGlThread(Context context)
{
// Generate the background texture.
var textures = new int[1];
//GLES20 = OpenGL ES 2.0
//Gibt eine bestimmte Anzahl an freien Texturnamen zurück.
GLES20.GlGenTextures(1, textures, 0);
TextureId = textures[0];
GLES20.GlBindTexture(mTextureTarget, TextureId);
GLES20.GlTexParameteri(mTextureTarget, GLES20.GlTextureWrapS, GLES20.GlClampToEdge);
GLES20.GlTexParameteri(mTextureTarget, GLES20.GlTextureWrapT, GLES20.GlClampToEdge);
GLES20.GlTexParameteri(mTextureTarget, GLES20.GlTextureMinFilter, GLES20.GlNearest);
GLES20.GlTexParameteri(mTextureTarget, GLES20.GlTextureMagFilter, GLES20.GlNearest);
int numVertices = 4;
if (numVertices != QUAD_COORDS.Length / COORDS_PER_VERTEX)
{
throw new Exception("Unexpected number of vertices in BackgroundRenderer.");
}
var bbVertices = ByteBuffer.AllocateDirect(QUAD_COORDS.Length * FLOAT_SIZE);
bbVertices.Order(ByteOrder.NativeOrder());
mQuadVertices = bbVertices.AsFloatBuffer();
mQuadVertices.Put(QUAD_COORDS);
mQuadVertices.Position(0);
var bbTexCoords = ByteBuffer.AllocateDirect(numVertices * TEXCOORDS_PER_VERTEX * FLOAT_SIZE);
bbTexCoords.Order(ByteOrder.NativeOrder());
mQuadTexCoord = bbTexCoords.AsFloatBuffer();
mQuadTexCoord.Put(QUAD_TEXCOORDS);
mQuadTexCoord.Position(0);
var bbTexCoordsTransformed = ByteBuffer.AllocateDirect(numVertices * TEXCOORDS_PER_VERTEX * FLOAT_SIZE);
bbTexCoordsTransformed.Order(ByteOrder.NativeOrder());
mQuadTexCoordTransformed = bbTexCoordsTransformed.AsFloatBuffer();
int vertexShader = ShaderUtil.LoadGLShader(TAG, context,
GLES20.GlVertexShader, Resource.Raw.screenquad_vertex);
int fragmentShader = ShaderUtil.LoadGLShader(TAG, context,
GLES20.GlFragmentShader, Resource.Raw.screenquad_fragment_oes);
mQuadProgram = GLES20.GlCreateProgram();
GLES20.GlAttachShader(mQuadProgram, vertexShader);
GLES20.GlAttachShader(mQuadProgram, fragmentShader);
GLES20.GlLinkProgram(mQuadProgram);
GLES20.GlUseProgram(mQuadProgram);
ShaderUtil.CheckGLError(TAG, "Program creation");
mQuadPositionParam = GLES20.GlGetAttribLocation(mQuadProgram, "a_Position");
mQuadTexCoordParam = GLES20.GlGetAttribLocation(mQuadProgram, "a_TexCoord");
ShaderUtil.CheckGLError(TAG, "Program parameters");
}
public Sky(bool dayTime)
: base(0, 0, 1, 1)
{
_texture = new Gradient(dayTime ? Day : Night);
var vertices = new float[16];
_verticesBuffer = Quad.Create();
vertices[2] = 0.25f;
vertices[6] = 0.25f;
vertices[10] = 0.75f;
vertices[14] = 0.75f;
vertices[3] = 0;
vertices[7] = 1;
vertices[11] = 1;
vertices[15] = 0;
vertices[0] = 0;
vertices[1] = 0;
vertices[4] = 1;
vertices[5] = 0;
vertices[8] = 1;
vertices[9] = 1;
vertices[12] = 0;
vertices[13] = 1;
_verticesBuffer.Position(0);
_verticesBuffer.Put(vertices);
}
/**
* Sets up the drawing object data for use in an OpenGL ES context.
*/
public Triangle()
{
// initialize vertex byte buffer for shape coordinates
ByteBuffer bb = ByteBuffer.AllocateDirect(
// (number of coordinate values * 4 bytes per float)
triangleCoords.Length * 4);
// use the device hardware's native byte order
bb.Order(ByteOrder.NativeOrder());
// create a floating point buffer from the ByteBuffer
vertexBuffer = bb.AsFloatBuffer();
// add the coordinates to the FloatBuffer
vertexBuffer.Put(triangleCoords);
// set the buffer to read the first coordinate
vertexBuffer.Position(0);
// prepare shaders and OpenGL program
int vertexShader = MainRenderer.loadShader(GLES20.GlVertexShader, vertexShaderCode);
int fragmentShader = MainRenderer.loadShader(GLES20.GlFragmentShader, fragmentShaderCode);
mProgram = GLES20.GlCreateProgram(); // create empty OpenGL Program
GLES20.GlAttachShader(mProgram, vertexShader); // add the vertex shader to program
GLES20.GlAttachShader(mProgram, fragmentShader); // add the fragment shader to program
GLES20.GlLinkProgram(mProgram); // create OpenGL program executables
}
/// <summary>
/// Obtain Texture buffer.
/// </summary>
/// <param name="obj">Texture list from .obj file</param>
/// <param name="dimensions">Dimension of Texture</param>
/// <returns>FloatBuffer</returns>
public static FloatBuffer GetTexturesFloatBuffer(IList <Texture> obj, int dimensions)
{
FloatBuffer buffer = CreateDirectFloatBuffer(obj.Count * dimensions);
GetTextures(obj, buffer);
buffer.Position(0);
return(buffer);
}
/// <summary>
/// Obtain Vertices buffer.
/// </summary>
/// <param name="obj">Vertex list from .obj file</param>
/// <returns>FloatBuffer</returns>
public static FloatBuffer GetVerticesFloatBuffer(IList <Vertex> obj)
{
FloatBuffer buffer = CreateDirectFloatBuffer(obj.Count * 3);
GetVertices(obj, buffer);
buffer.Position(0);
return(buffer);
}
/// <summary>
/// Obtain Normal buffer.
/// </summary>
/// <param name="obj">Normal list from .obj file</param>
/// <returns>FloatBuffer</returns>
public static FloatBuffer GetNormalsFloatBuffer(IList <Normal> obj)
{
FloatBuffer buffer = CreateDirectFloatBuffer(obj.Count * 3);
GetNormals(obj, buffer);
buffer.Position(0);
return(buffer);
}
public virtual void updateTrajectory(float[] translation)
{
mVertexBuffer.Position(mTrajectoryCount * 3);
if (((mTrajectoryCount + 1) * 3) >= MAX_VERTICES)
{
Log.Warn(TAG, "Clearing float buffer");
resetPath();
}
float dx = 0, dy = 0, dz = 0;
try
{
dx = mVertexBuffer.Get(mVertexBuffer.Position() - 3) - translation[0];
dy = mVertexBuffer.Get(mVertexBuffer.Position() - 2) - translation[2];
dz = mVertexBuffer.Get(mVertexBuffer.Position() - 1) - (-translation[1]);
}
catch (System.IndexOutOfRangeException)
{
mVertexBuffer.Put(new float[] { translation[0], translation[2], -translation[1] });
mTrajectoryCount++;
}
float distance = (float)Math.Sqrt(dx * dx + dy * dy + dz * dz);
if (distance > MIN_DISTANCE_CHECK)
{
mVertexBuffer.Put(new float[] { translation[0], translation[2], -translation[1] });
mTrajectoryCount++;
}
}
public override void Present(float delta)
{
IGL10 gl = _glGraphics.GL10;
gl.GlViewport(0, 0, _glGraphics.Width, _glGraphics.Height);
gl.GlClear(GL10.GlColorBufferBit);
gl.GlMatrixMode(GL10.GlProjection);
gl.GlLoadIdentity();
gl.GlOrthof(0, 540, 0, 960, 1, -1);
//gl.GlColor4f (1,0,0,1);
gl.GlEnableClientState(GL10.GlVertexArray);
gl.GlEnableClientState(GL10.GlColorArray);
_vertices.Position(0);
gl.GlVertexPointer(2, GL10.GlFloat, _vertexSize, _vertices);
_vertices.Position(2);
gl.GlColorPointer(4, GL10.GlFloat, _vertexSize, _vertices);
gl.GlDrawArrays(GL10.GlTriangles, 0, 3);
gl.GlDrawArrays(GL10.GlTriangles, 0, 3);
}
/**
* Draws the external texture in SurfaceTexture onto the current EGL surface.
*/
public void drawFrame(SurfaceTexture st, bool invert)
{
checkGlError("onDrawFrame start");
st.GetTransformMatrix(mSTMatrix);
if (invert)
{
mSTMatrix[5] = -mSTMatrix[5];
mSTMatrix[13] = 1.0f - mSTMatrix[13];
}
// (optional) clear to green so we can see if we're failing to set pixels
GLES20.GlClearColor(0.0f, 1.0f, 0.0f, 1.0f);
GLES20.GlClear(GLES20.GlColorBufferBit);
GLES20.GlUseProgram(mProgram);
checkGlError("glUseProgram");
GLES20.GlActiveTexture(GLES20.GlTexture0);
GLES20.GlBindTexture(GLES11Ext.GlTextureExternalOes, mTextureID);
mTriangleVertices.Position(TRIANGLE_VERTICES_DATA_POS_OFFSET);
GLES20.GlVertexAttribPointer(maPositionHandle, 3, GLES20.GlFloat, false,
TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mTriangleVertices);
checkGlError("glVertexAttribPointer maPosition");
GLES20.GlEnableVertexAttribArray(maPositionHandle);
checkGlError("glEnableVertexAttribArray maPositionHandle");
mTriangleVertices.Position(TRIANGLE_VERTICES_DATA_UV_OFFSET);
GLES20.GlVertexAttribPointer(maTextureHandle, 2, GLES20.GlFloat, false,
TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mTriangleVertices);
checkGlError("glVertexAttribPointer maTextureHandle");
GLES20.GlEnableVertexAttribArray(maTextureHandle);
checkGlError("glEnableVertexAttribArray maTextureHandle");
Android.Opengl.Matrix.SetIdentityM(mMVPMatrix, 0);
GLES20.GlUniformMatrix4fv(muMVPMatrixHandle, 1, false, mMVPMatrix, 0);
GLES20.GlUniformMatrix4fv(muSTMatrixHandle, 1, false, mSTMatrix, 0);
GLES20.GlDrawArrays(GLES20.GlTriangleStrip, 0, 4);
checkGlError("glDrawArrays");
GLES20.GlBindTexture(GLES11Ext.GlTextureExternalOes, 0);
}
private void DrawTriangle(FloatBuffer aTriangleBuffer)
{
// Pass in the position information.
aTriangleBuffer.Position(mPositionOffset);
GLES20.GlVertexAttribPointer(mPositionHandle, mPositionDataSize, GLES20.GlFloat, false, mStrideBytes, aTriangleBuffer);
GLES20.GlEnableVertexAttribArray(mPositionHandle);
//Pass in the color information
aTriangleBuffer.Position(mColorOffset);
GLES20.GlVertexAttribPointer(mColorHandle, mColorDataSize, GLES20.GlFloat, false, mStrideBytes, aTriangleBuffer);
GLES20.GlEnableVertexAttribArray(mColorHandle);
Matrix.MultiplyMM(mMVPMatrix, 0, mViewMatrix, 0, mModelMatrix, 0);
Matrix.MultiplyMM(mMVPMatrix, 0, mProjectionMatrix, 0, mMVPMatrix, 0);
GLES20.GlUniformMatrix4fv(mMVPMatrixHandle, 1, false, mMVPMatrix, 0);
GLES20.GlDrawArrays(GLES20.GlTriangles, 0, 3);
}
public MainRenderer(MainView view)
{
mView = view;
float[] vtmp = { 1.0f, -1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f };
float[] ttmp = { 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f };
pVertex = ByteBuffer.AllocateDirect(8 * 4).Order(ByteOrder.NativeOrder()).AsFloatBuffer();
pVertex.Put(vtmp);
pVertex.Position(0);
pTexCoord = ByteBuffer.AllocateDirect(8 * 4).Order(ByteOrder.NativeOrder()).AsFloatBuffer();
pTexCoord.Put(ttmp);
pTexCoord.Position(0);
}
public MainRenderer(MainView view)
{
mView = view;
float[] vtmp = { 1.0f, -1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f };
float[] ttmp = { 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f };
pVertex = ByteBuffer.AllocateDirect(8 * 4).Order(ByteOrder.NativeOrder()).AsFloatBuffer();
pVertex.Put(vtmp);
pVertex.Position(0);
pTexCoord = ByteBuffer.AllocateDirect(8 * 4).Order(ByteOrder.NativeOrder()).AsFloatBuffer();
pTexCoord.Put(ttmp);
pTexCoord.Position(0);
}
protected internal virtual void UpdateVertices()
{
var y1 = _cellH * updated.Top;
var y2 = y1 + _cellH;
for (var i = updated.Top; i < updated.Bottom; i++)
{
var x1 = _cellW * updated.Left;
var x2 = x1 + _cellW;
var pos = i * mapWidth + updated.Left;
quads.Position(16 * pos);
for (var j = updated.Left; j < updated.Right; j++)
{
var uv = tileset.Get(data[pos++]);
vertices[0] = x1;
vertices[1] = y1;
vertices[2] = uv.Left;
vertices[3] = uv.Top;
vertices[4] = x2;
vertices[5] = y1;
vertices[6] = uv.Right;
vertices[7] = uv.Top;
vertices[8] = x2;
vertices[9] = y2;
vertices[10] = uv.Right;
vertices[11] = uv.Bottom;
vertices[12] = x1;
vertices[13] = y2;
vertices[14] = uv.Left;
vertices[15] = uv.Bottom;
quads.Put(vertices);
x1 = x2;
x2 += _cellW;
}
y1 = y2;
y2 += _cellH;
}
updated.SetEmpty();
}
public override void Present(float deltaTime)
{
IGL10 gl = _glGraphics.GL10;
gl.GlViewport(0, 0, _glGraphics.Width, _glGraphics.Height);
gl.GlClear(GL10.GlColorBufferBit);
gl.GlMatrixMode(GL10.GlProjection);
gl.GlLoadIdentity();
gl.GlOrthof(0, 540, 0, 960, 1, -1);
gl.GlEnable(GL10.GlTexture2d);
_texture.BindTexture();
gl.GlEnableClientState(GL10.GlVertexArray);
gl.GlEnableClientState(GL10.GlTextureCoordArray);
_vertices.Position(0);
gl.GlVertexPointer(2, GL10.GlFloat, _vertexSize, _vertices);
_vertices.Position(2);
gl.GlTexCoordPointer(2, GL10.GlFloat, _vertexSize, _vertices);
gl.GlDrawElements(GL10.GlTriangles, 6, GL10.GlUnsignedShort, _indices);
}
public void Bind()
{
IGL10 gl = _glGraphics.GL10;
gl.GlEnableClientState(GL10.GlVertexArray);
_vertices.Position(0);
gl.GlVertexPointer(2, GL10.GlFloat, _vertexSize, _vertices);
if (_hasColor)
{
gl.GlEnableClientState(GL10.GlColorArray);
_vertices.Position(2);
gl.GlColorPointer(4, GL10.GlFloat, _vertexSize, _vertices);
}
if (_hasTexCoords)
{
gl.GlEnableClientState(GL10.GlTextureCoordArray);
_vertices.Position(_hasColor?6:2);
gl.GlTexCoordPointer(2, GL10.GlFloat, _vertexSize, _vertices);
}
}
public void OnDrawFrame(Javax.Microedition.Khronos.Opengles.IGL10 glUnused)
{
if (_updateSurface)
{
_surfaceTexture.UpdateTexImage();
_surfaceTexture.GetTransformMatrix(_STMatrix);
_updateSurface = false;
}
GLES20.GlUseProgram(0);
GLES20.GlUseProgram(_glProgram);
GLES20.GlActiveTexture(GLES20.GlTexture2);
var tWidth = _width;
var tHeight = _height;
funnyGhostEffectBuffer = ByteBuffer.AllocateDirect(tWidth * tHeight * 4);
funnyGhostEffectBuffer.Order(ByteOrder.NativeOrder());
funnyGhostEffectBuffer.Position(0);
// Note that it is read in GlReadPixels in a different pixel order than top-left to lower-right, so it adds a reversed+mirror effect
// when passed to TexImage2D to convert to texture.
GLES20.GlReadPixels(0, 0, tWidth - 1, tHeight - 1, GLES20.GlRgba, GLES20.GlUnsignedByte, funnyGhostEffectBuffer);
updateTargetTexture(tWidth, tHeight);
GLES20.GlBindTexture(GLES20.GlTexture2d, _otherTextureId);
GLES20.GlUniform1i(_otherTextureUniform, 2);
GLES20.GlUseProgram(0);
GLES20.GlUseProgram(_glProgram);
GLES20.GlActiveTexture(GLES20.GlTexture1);
GLES20.GlBindTexture(GLES11Ext.GlTextureExternalOes, _OESTextureId);
GLES20.GlUniform1i(_OESTextureUniform, 1);
_triangleVertices.Position(TRIANGLE_VERTICES_DATA_POS_OFFSET);
GLES20.GlVertexAttribPointer(_aPositionHandle, 3, GLES20.GlFloat, false, TRIANGLE_VERTICES_DATA_STRIDE_BYTES, _triangleVertices);
GLES20.GlEnableVertexAttribArray(_aPositionHandle);
_textureVertices.Position(TRIANGLE_VERTICES_DATA_UV_OFFSET);
GLES20.GlVertexAttribPointer(_aTextureCoord, 2, GLES20.GlFloat, false, TEXTURE_VERTICES_DATA_STRIDE_BYTES, _textureVertices);
GLES20.GlEnableVertexAttribArray(_aTextureCoord);
Android.Opengl.Matrix.SetIdentityM(_MVPMatrix, 0);
GLES20.GlUniformMatrix4fv(_uMVPMatrixHandle, 1, false, _MVPMatrix, 0);
GLES20.GlUniformMatrix4fv(_uSTMatrixHandle, 1, false, _STMatrix, 0);
GLES20.GlDrawArrays(GLES20.GlTriangleStrip, 0, 4);
GLES20.GlFinish();
}
public void OnDrawFrame(IGL10 gl)
{
// Our vertices.
float[] vertices =
{
-1.5f, 1.5f, 0.0f, // 0, Top Left
-1.5f, -1.5f, 0.0f, // 1, Bottom Left
1.5f, 1.5f, 0.0f, // 3, Top Right
1.5f, -1.5f, 0.0f, // 2, Bottom Right
};
// a float is 4 bytes, therefore we multiply the number if
// vertices with 4.
ByteBuffer vbb = ByteBuffer.AllocateDirect(vertices.Length * 4);
vbb.Order(ByteOrder.NativeOrder());
FloatBuffer vertexBuffer = vbb.AsFloatBuffer();
vertexBuffer.Put(vertices);
vertexBuffer.Position(0);
// The order we like to connect them.
byte[] colors =
{
(byte)0.0, (byte)255, (byte)0.0, (byte)255,
(byte)0.0, (byte)255, (byte)0.0, (byte)255,
(byte)0.0, (byte)255, (byte)0.0, (byte)255,
(byte)0.0, (byte)255, (byte)0.0, (byte)255
};
// a float is 4 bytes, therefore we multiply the number if
// vertices with 4.
ByteBuffer cbb = ByteBuffer.AllocateDirect(colors.Length * 4);
cbb.Order(ByteOrder.NativeOrder());
cbb.Put(colors);
cbb.Position(0);
gl.GlVertexPointer(3, GL10.GlFloat, 0, vertexBuffer);
gl.GlEnableClientState(GL10.GlVertexArray);
gl.GlColorPointer(4, GL10.GlUnsignedByte, 0, cbb);
gl.GlEnableClientState(GL10.GlColorArray);
gl.GlDrawArrays(GL10.GlTriangleStrip, 0, 4);
}
private void SetupTriangle()
{
rect = new RectF(10, 200, 100, 10);
/*rect.Left = 10;
* rect.Right = 100;
* rect.Bottom = 100;
* rect.Top = 200;*/
// We have to create the vertices.
/*vertices = new float[]
* {
* 10.0f, 200f, 0.0f,
* 10.0f, 100f, 0.0f,
* 100f, 100f, 0.0f,
* 100f, 200f, 0.0f,
* };*/
vertices = new float[]
{
rect.Left, rect.Top, 0.0f,
rect.Left, rect.Bottom, 0.0f,
rect.Right, rect.Bottom, 0.0f,
rect.Right, rect.Top, 0.0f,
};
indices = new short[] { 0, 1, 2, 0, 2, 3 }; // The order of vertexrendering.
// The vertex buffer.
ByteBuffer byteBuffer = ByteBuffer.AllocateDirect(vertices.Length * 4);
byteBuffer.Order(ByteOrder.NativeOrder());
vertexBuffer = byteBuffer.AsFloatBuffer();
vertexBuffer.Put(vertices);
vertexBuffer.Position(0);
// initialize byte buffer for the draw list
ByteBuffer byteBuffer2 = ByteBuffer.AllocateDirect(indices.Length * 2);
byteBuffer2.Order(ByteOrder.NativeOrder());
drawListBuffer = byteBuffer2.AsShortBuffer();
drawListBuffer.Put(indices);
drawListBuffer.Position(0);
}
public Cube()
{
ByteBuffer byteBuf = ByteBuffer.AllocateDirect(vertices.Length * 4);
byteBuf.Order(ByteOrder.NativeOrder());
mVertexBuffer = byteBuf.AsFloatBuffer();
mVertexBuffer.Put(vertices);
mVertexBuffer.Position(0);
byteBuf = ByteBuffer.AllocateDirect(colors.Length * 4);
byteBuf.Order(ByteOrder.NativeOrder());
mColorBuffer = byteBuf.AsFloatBuffer();
mColorBuffer.Put(colors);
mColorBuffer.Position(0);
mIndexBuffer = ByteBuffer.AllocateDirect(indices.Length);
mIndexBuffer.Put(indices);
mIndexBuffer.Position(0);
}
private void SetupImage()
{
// Create our UV coordinates.
uvs = new float[] {
0.0f, 0.0f,
0.0f, 1.0f,
1.0f, 1.0f,
1.0f, 0.0f
};
// The texture buffer
ByteBuffer byteBuffer = ByteBuffer.AllocateDirect(uvs.Length * 4);
byteBuffer.Order(ByteOrder.NativeOrder());
uvBuffer = byteBuffer.AsFloatBuffer();
uvBuffer.Put(uvs);
uvBuffer.Position(0);
// Generate Textures, if more needed, alter these numbers.
int[] textureIds = new int[1];
GLES20.GlGenTextures(1, textureIds, 0);
// Retrieve our image from resources.
Bitmap bitmap = BitmapFactory.DecodeResource(context.Resources, Resource.Drawable.plant07);
// Bind texture to texturename
GLES20.GlActiveTexture(GLES20.GlTexture0);
GLES20.GlBindTexture(GLES20.GlTexture2d, textureIds[0]);
// Set filtering
GLES20.GlTexParameteri(GLES20.GlTexture2d, GLES20.GlTextureMinFilter, GLES20.GlLinear);
GLES20.GlTexParameteri(GLES20.GlTexture2d, GLES20.GlTextureMagFilter, GLES20.GlLinear);
// Set wrapping mode
GLES20.GlTexParameteri(GLES20.GlTexture2d, GLES20.GlTextureWrapS, GLES20.GlClampToEdge);
GLES20.GlTexParameteri(GLES20.GlTexture2d, GLES20.GlTextureWrapT, GLES20.GlClampToEdge);
// Load the bitmap into the bound texture.
GLUtils.TexImage2D(GLES20.GlTexture2d, 0, bitmap, 0);
// We are done using the bitmap so we should recycle it.
bitmap.Recycle();
bitmap.Dispose();
}
/// <summary>
/// Adds a basic series of triangles to render.
/// </summary>
/// <param name="corners">Triangle data.</param>
/// <param name="argb">The ARGB colors.</param>
public void AddTriangles(float[] corners, int argb)
{
// a float is 4 bytes, therefore we multiply the number if
// vertices with 4.
ByteBuffer vbb = ByteBuffer.AllocateDirect(corners.Length * 4);
vbb.Order(ByteOrder.NativeOrder());
FloatBuffer vertexBuffer = vbb.AsFloatBuffer();
vertexBuffer.Put(corners);
vertexBuffer.Position(0);
// The order we like to connect them.
SimpleColor color = new SimpleColor()
{
Value = argb
};
int count = corners.Length / 3;
byte[] colors = new byte[count * 4];
for (int idx = 0; idx < count; idx++)
{
colors [idx * 4] = (byte)color.R;
colors [idx * 4 + 1] = (byte)color.G;
colors [idx * 4 + 2] = (byte)color.B;
colors [idx * 4 + 3] = (byte)color.A;
}
// a float is 4 bytes, therefore we multiply the number if
// vertices with 4.
ByteBuffer cbb = ByteBuffer.AllocateDirect(colors.Length);
cbb.Order(ByteOrder.NativeOrder());
cbb.Put(colors);
cbb.Position(0);
_triangles.Add(new TriangleProcessed()
{
Vertices = vertexBuffer,
Colors = cbb,
Count = corners.Length / 3
});
}
public Cube()
{
ByteBuffer byteBuf = ByteBuffer.AllocateDirect(vertices.Length * 4);
byteBuf.Order(ByteOrder.NativeOrder());
mVertexBuffer = byteBuf.AsFloatBuffer();
mVertexBuffer.Put(vertices);
mVertexBuffer.Position(0);
byteBuf = ByteBuffer.AllocateDirect(colors.Length * 4);
byteBuf.Order(ByteOrder.NativeOrder());
mColorBuffer = byteBuf.AsFloatBuffer();
mColorBuffer.Put(colors);
mColorBuffer.Position(0);
mIndexBuffer = ByteBuffer.AllocateDirect(indices.Length);
mIndexBuffer.Put(indices);
mIndexBuffer.Position(0);
}
public override void draw(float[] viewMatrix, float[] projectionMatrix)
{
GLES20.GlUseProgram(mProgram);
mVertexBuffer.Position(0);
// Compose the model, view, and projection matrices into a single m-v-p
// matrix
updateMvpMatrix(viewMatrix, projectionMatrix);
// Load vertex attribute data
mPosHandle = GLES20.GlGetAttribLocation(mProgram, "vPosition");
GLES20.GlVertexAttribPointer(mPosHandle, COORDS_PER_VERTEX, GLES20.GlFloat, false, 0, mVertexBuffer);
GLES20.GlEnableVertexAttribArray(mPosHandle);
// Draw the Grid
mMVPMatrixHandle = GLES20.GlGetUniformLocation(mProgram, "uMVPMatrix");
GLES20.GlUniformMatrix4fv(mMVPMatrixHandle, 1, false, MvpMatrix, 0);
GLES20.GlLineWidth(1);
GLES20.GlDrawArrays(GLES20.GlLines, 0, (GRID_RANGE_M * 2 + 1) * 4);
}
/**
* Creates the buffers we use to store information about the 3D world.
*
* OpenGL doesn't use Java arrays, but rather needs data in a format it can understand.
* Hence we use ByteBuffers.
*/
public void OnSurfaceCreated (Javax.Microedition.Khronos.Egl.EGLConfig config)
{
Android.Util.Log.Info (TAG, "onSurfaceCreated");
GLES20.GlClearColor (0.1f, 0.1f, 0.1f, 0.5f); // Dark background so text shows up well.
var bbVertices = ByteBuffer.AllocateDirect (WorldLayoutData.CUBE_COORDS.Length * 4);
bbVertices.Order (ByteOrder.NativeOrder ());
cubeVertices = bbVertices.AsFloatBuffer ();
cubeVertices.Put (WorldLayoutData.CUBE_COORDS);
cubeVertices.Position (0);
var bbColors = ByteBuffer.AllocateDirect (WorldLayoutData.CUBE_COLORS.Length * 4);
bbColors.Order (ByteOrder.NativeOrder ());
cubeColors = bbColors.AsFloatBuffer ();
cubeColors.Put (WorldLayoutData.CUBE_COLORS);
cubeColors.Position (0);
var bbFoundColors = ByteBuffer.AllocateDirect (WorldLayoutData.CUBE_FOUND_COLORS.Length * 4);
bbFoundColors.Order (ByteOrder.NativeOrder ());
cubeFoundColors = bbFoundColors.AsFloatBuffer ();
cubeFoundColors.Put (WorldLayoutData.CUBE_FOUND_COLORS);
cubeFoundColors.Position (0);
var bbNormals = ByteBuffer.AllocateDirect (WorldLayoutData.CUBE_NORMALS.Length * 4);
bbNormals.Order (ByteOrder.NativeOrder ());
cubeNormals = bbNormals.AsFloatBuffer ();
cubeNormals.Put (WorldLayoutData.CUBE_NORMALS);
cubeNormals.Position (0);
// make a floor
var bbFloorVertices = ByteBuffer.AllocateDirect (WorldLayoutData.FLOOR_COORDS.Length * 4);
bbFloorVertices.Order (ByteOrder.NativeOrder ());
floorVertices = bbFloorVertices.AsFloatBuffer ();
floorVertices.Put (WorldLayoutData.FLOOR_COORDS);
floorVertices.Position (0);
var bbFloorNormals = ByteBuffer.AllocateDirect (WorldLayoutData.FLOOR_NORMALS.Length * 4);
bbFloorNormals.Order (ByteOrder.NativeOrder ());
floorNormals = bbFloorNormals.AsFloatBuffer ();
floorNormals.Put (WorldLayoutData.FLOOR_NORMALS);
floorNormals.Position (0);
var bbFloorColors = ByteBuffer.AllocateDirect (WorldLayoutData.FLOOR_COLORS.Length * 4);
bbFloorColors.Order (ByteOrder.NativeOrder ());
floorColors = bbFloorColors.AsFloatBuffer ();
floorColors.Put (WorldLayoutData.FLOOR_COLORS);
floorColors.Position (0);
int vertexShader = loadGLShader (GLES20.GlVertexShader, Resource.Raw.light_vertex);
int gridShader = loadGLShader (GLES20.GlFragmentShader, Resource.Raw.grid_fragment);
int passthroughShader = loadGLShader (GLES20.GlFragmentShader, Resource.Raw.passthrough_fragment);
cubeProgram = GLES20.GlCreateProgram ();
GLES20.GlAttachShader (cubeProgram, vertexShader);
GLES20.GlAttachShader (cubeProgram, passthroughShader);
GLES20.GlLinkProgram (cubeProgram);
GLES20.GlUseProgram (cubeProgram);
CheckGLError ("Cube program");
cubePositionParam = GLES20.GlGetAttribLocation (cubeProgram, "a_Position");
cubeNormalParam = GLES20.GlGetAttribLocation (cubeProgram, "a_Normal");
cubeColorParam = GLES20.GlGetAttribLocation (cubeProgram, "a_Color");
cubeModelParam = GLES20.GlGetUniformLocation (cubeProgram, "u_Model");
cubeModelViewParam = GLES20.GlGetUniformLocation (cubeProgram, "u_MVMatrix");
cubeModelViewProjectionParam = GLES20.GlGetUniformLocation (cubeProgram, "u_MVP");
cubeLightPosParam = GLES20.GlGetUniformLocation (cubeProgram, "u_LightPos");
CheckGLError ("Cube program params");
floorProgram = GLES20.GlCreateProgram ();
GLES20.GlAttachShader (floorProgram, vertexShader);
GLES20.GlAttachShader (floorProgram, gridShader);
GLES20.GlLinkProgram (floorProgram);
GLES20.GlUseProgram (floorProgram);
CheckGLError ("Floor program");
floorModelParam = GLES20.GlGetUniformLocation (floorProgram, "u_Model");
floorModelViewParam = GLES20.GlGetUniformLocation (floorProgram, "u_MVMatrix");
floorModelViewProjectionParam = GLES20.GlGetUniformLocation (floorProgram, "u_MVP");
floorLightPosParam = GLES20.GlGetUniformLocation (floorProgram, "u_LightPos");
floorPositionParam = GLES20.GlGetAttribLocation (floorProgram, "a_Position");
floorNormalParam = GLES20.GlGetAttribLocation (floorProgram, "a_Normal");
floorColorParam = GLES20.GlGetAttribLocation (floorProgram, "a_Color");
CheckGLError ("Floor program params");
Matrix.SetIdentityM (modelFloor, 0);
Matrix.TranslateM (modelFloor, 0, 0, -floorDepth, 0); // Floor appears below user.
// Avoid any delays during start-up due to decoding of sound files.
System.Threading.Tasks.Task.Run (() => {
// Start spatial audio playback of SOUND_FILE at the model postion. The returned
//soundId handle is stored and allows for repositioning the sound object whenever
// the cube position changes.
gvrAudioEngine.PreloadSoundFile (SOUND_FILE);
soundId = gvrAudioEngine.CreateSoundObject (SOUND_FILE);
gvrAudioEngine.SetSoundObjectPosition (
soundId, modelPosition [0], modelPosition [1], modelPosition [2]);
gvrAudioEngine.PlaySound (soundId, true /* looped playback */);
});
UpdateModelPosition ();
CheckGLError ("onSurfaceCreated");
}