public void OnDrawFrame(IGL10 gl)
{
GLES20.GlClear(GLES20.GlColorBufferBit | GLES20.GlDepthBufferBit);
// Draw the triangle facing straight on.
angleInDegrees += 1.0f;
angleInDegrees2 -= 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);
// Console.WriteLine(System.DateTime.Now.Ticks / System.TimeSpan.TicksPerMillisecond - milliseconds);
if (kofi <= 0)
{
}
else
{
kofi -= 0.001f;
}
Matrix.SetIdentityM(mModelMatrix, 0);
Matrix.ScaleM(mModelMatrix, 0, 0.4f + kofi, 0.4f + kofi, 0.4f + kofi);
Matrix.TranslateM(mModelMatrix, 0, 0.0f + kofi, 0.0f + kofi, 0.0f + kofi);
Matrix.RotateM(mModelMatrix, 0, angleInDegrees2, 0, 0.0001F, 0);
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);
Matrix.SetIdentityM(mModelMatrix, 0);
Matrix.ScaleM(mModelMatrix, 0, 0.4f - kofi, 0.4f - kofi, 0.4f - kofi);
Matrix.TranslateM(mModelMatrix, 0, 0.0f - kofi, 0.0f - kofi, 0.0f - kofi);
Matrix.RotateM(mModelMatrix, 0, angleInDegrees2 + 90, 0, 0.0001F, 0);
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);
Matrix.SetIdentityM(mModelMatrix, 0);
Matrix.ScaleM(mModelMatrix, 0, 0.53f - kofi, 0.53f - kofi, 0.53f - kofi);
Matrix.TranslateM(mModelMatrix, 0, 0.0f - kofi, -0.73f - kofi, 0.0f - kofi);
Matrix.RotateM(mModelMatrix, 0, angleInDegrees, 0, 0.0001F, 0);
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);
Matrix.SetIdentityM(mModelMatrix, 0);
Matrix.ScaleM(mModelMatrix, 0, 0.53f + kofi, 0.53f + kofi, 0.53f + kofi);
Matrix.TranslateM(mModelMatrix, 0, 0.0f + kofi, -0.73f + kofi, 0.0f + kofi);
Matrix.RotateM(mModelMatrix, 0, angleInDegrees + 90, 0, 0.0001F, 0);
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);
Matrix.SetIdentityM(mModelMatrix, 0);
Matrix.ScaleM(mModelMatrix, 0, 0.66f + kofi, 0.66f + kofi, 0.66f + kofi);
Matrix.TranslateM(mModelMatrix, 0, 0.0f + kofi, -1.32f + kofi, 0.0f + kofi);
Matrix.RotateM(mModelMatrix, 0, angleInDegrees2, 0, 0.0001F, 0);
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);
Matrix.SetIdentityM(mModelMatrix, 0);
Matrix.ScaleM(mModelMatrix, 0, 0.66f - kofi, 0.66f - kofi, 0.66f - kofi);
Matrix.TranslateM(mModelMatrix, 0, 0.0f - kofi, -1.32f - kofi, 0.0f - kofi);
Matrix.RotateM(mModelMatrix, 0, angleInDegrees2 + 90, 0, 0.0001F, 0);
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);
}
/**
* Draws the model.
*
* @param cameraView A 4x4 view matrix, in column-major order.
* @param cameraPerspective A 4x4 projection matrix, in column-major order.
* @param lightIntensity Illumination intensity. Combined with diffuse and specular material
* properties.
* @see #setBlendMode(BlendMode)
* @see #updateModelMatrix(float[], float)
* @see #setMaterialProperties(float, float, float, float)
* @see android.opengl.Matrix
*/
public void Draw(float[] cameraView, float[] cameraPerspective, float lightIntensity)
{
ShaderUtil.CheckGLError(TAG, "Before draw");
// Build the ModelView and ModelViewProjection matrices
// for calculating object position and light.
Android.Opengl.Matrix.MultiplyMM(mModelViewMatrix, 0, cameraView, 0, mModelMatrix, 0);
Android.Opengl.Matrix.MultiplyMM(mModelViewProjectionMatrix, 0, cameraPerspective, 0, mModelViewMatrix, 0);
GLES20.GlUseProgram(mProgram);
// Set the lighting environment properties.
Android.Opengl.Matrix.MultiplyMV(mViewLightDirection, 0, mModelViewMatrix, 0, LIGHT_DIRECTION, 0);
normalizeVec3(mViewLightDirection);
GLES20.GlUniform4f(mLightingParametersUniform,
mViewLightDirection[0], mViewLightDirection[1], mViewLightDirection[2], lightIntensity);
// Set the object material properties.
GLES20.GlUniform4f(mMaterialParametersUniform, mAmbient, mDiffuse, mSpecular,
mSpecularPower);
// Attach the object texture.
GLES20.GlActiveTexture(GLES20.GlTexture0);
GLES20.GlBindTexture(GLES20.GlTexture2d, mTextures[0]);
GLES20.GlUniform1i(mTextureUniform, 0);
// Set the vertex attributes.
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, mVertexBufferId);
GLES20.GlVertexAttribPointer(
mPositionAttribute, COORDS_PER_VERTEX, GLES20.GlFloat, false, 0, mVerticesBaseAddress);
GLES20.GlVertexAttribPointer(
mNormalAttribute, 3, GLES20.GlFloat, false, 0, mNormalsBaseAddress);
GLES20.GlVertexAttribPointer(
mTexCoordAttribute, 2, GLES20.GlFloat, false, 0, mTexCoordsBaseAddress);
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, 0);
// Set the ModelViewProjection matrix in the shader.
GLES20.GlUniformMatrix4fv(
mModelViewUniform, 1, false, mModelViewMatrix, 0);
GLES20.GlUniformMatrix4fv(
mModelViewProjectionUniform, 1, false, mModelViewProjectionMatrix, 0);
// Enable vertex arrays
GLES20.GlEnableVertexAttribArray(mPositionAttribute);
GLES20.GlEnableVertexAttribArray(mNormalAttribute);
GLES20.GlEnableVertexAttribArray(mTexCoordAttribute);
if (mBlendMode != BlendMode.Null)
{
GLES20.GlDepthMask(false);
GLES20.GlEnable(GLES20.GlBlend);
switch (mBlendMode)
{
case BlendMode.Shadow:
// Multiplicative blending function for Shadow.
GLES20.GlBlendFunc(GLES20.GlZero, GLES20.GlOneMinusSrcAlpha);
break;
case BlendMode.Grid:
// Grid, additive blending function.
GLES20.GlBlendFunc(GLES20.GlSrcAlpha, GLES20.GlOneMinusSrcAlpha);
break;
}
}
GLES20.GlBindBuffer(GLES20.GlElementArrayBuffer, mIndexBufferId);
GLES20.GlDrawElements(GLES20.GlTriangles, mIndexCount, GLES20.GlUnsignedShort, 0);
GLES20.GlBindBuffer(GLES20.GlElementArrayBuffer, 0);
if (mBlendMode != BlendMode.Null)
{
GLES20.GlDisable(GLES20.GlBlend);
GLES20.GlDepthMask(true);
}
// Disable vertex arrays
GLES20.GlDisableVertexAttribArray(mPositionAttribute);
GLES20.GlDisableVertexAttribArray(mNormalAttribute);
GLES20.GlDisableVertexAttribArray(mTexCoordAttribute);
GLES20.GlBindTexture(GLES20.GlTexture2d, 0);
ShaderUtil.CheckGLError(TAG, "After draw");
}
/**
* Draws the collection of tracked planes, with closer planes hiding more distant ones.
*
* @param allPlanes The collection of planes to draw.
* @param cameraPose The pose of the camera, as returned by {@link Frame#getPose()}
* @param cameraPerspective The projection matrix, as returned by
* {@link Session#getProjectionMatrix(float[], int, float, float)}
*/
public void DrawPlanes(IEnumerable <Plane> allPlanes, Pose cameraPose, float[] cameraPerspective)
{
// Planes must be sorted by distance from camera so that we draw closer planes first, and
// they occlude the farther planes.
List <SortablePlane> sortedPlanes = new List <SortablePlane>();
float[] normal = new float[3];
float cameraX = cameraPose.Tx();
float cameraY = cameraPose.Ty();
float cameraZ = cameraPose.Tz();
foreach (var plane in allPlanes)
{
if (plane.GetType() != Plane.Type.HorizontalUpwardFacing ||
plane.GetTrackingState() != Plane.TrackingState.Tracking)
{
continue;
}
var center = plane.CenterPose;
// Get transformed Y axis of plane's coordinate system.
center.GetTransformedAxis(1, 1.0f, normal, 0);
// Compute dot product of plane's normal with vector from camera to plane center.
float distance = (cameraX - center.Tx()) * normal[0] +
(cameraY - center.Ty()) * normal[1] + (cameraZ - center.Tz()) * normal[2];
if (distance < 0)
{ // Plane is back-facing.
continue;
}
sortedPlanes.Add(new SortablePlane(distance, plane));
}
sortedPlanes.Sort((x, y) => x.Distance.CompareTo(y.Distance));
var cameraView = new float[16];
cameraPose.Inverse().ToMatrix(cameraView, 0);
// Planes are drawn with additive blending, masked by the alpha channel for occlusion.
// Start by clearing the alpha channel of the color buffer to 1.0.
GLES20.GlClearColor(1, 1, 1, 1);
GLES20.GlColorMask(false, false, false, true);
GLES20.GlClear(GLES20.GlColorBufferBit);
GLES20.GlColorMask(true, true, true, true);
// Disable depth write.
GLES20.GlDepthMask(false);
// Additive blending, masked by alpha chanel, clearing alpha channel.
GLES20.GlEnable(GLES20.GlBlend);
GLES20.GlBlendFuncSeparate(
GLES20.GlDstAlpha, GLES20.GlOne, // RGB (src, dest)
GLES20.GlZero, GLES20.GlOneMinusSrcAlpha); // ALPHA (src, dest)
// Set up the shader.
GLES20.GlUseProgram(mPlaneProgram);
// Attach the texture.
GLES20.GlActiveTexture(GLES20.GlTexture0);
GLES20.GlBindTexture(GLES20.GlTexture2d, mTextures[0]);
GLES20.GlUniform1i(mTextureUniform, 0);
// Shared fragment uniforms.
GLES20.GlUniform4fv(mGridControlUniform, 1, GRID_CONTROL, 0);
// Enable vertex arrays
GLES20.GlEnableVertexAttribArray(mPlaneXZPositionAlphaAttribute);
ShaderUtil.CheckGLError(TAG, "Setting up to draw planes");
foreach (var sortedPlane in sortedPlanes)
{
var plane = sortedPlane.Plane;
float[] planeMatrix = new float[16];
plane.CenterPose.ToMatrix(planeMatrix, 0);
updatePlaneParameters(planeMatrix, plane.ExtentX,
plane.ExtentZ, plane.PlanePolygon);
// Get plane index. Keep a map to assign same indices to same planes.
int planeIndex = -1;
if (!mPlaneIndexMap.TryGetValue(plane, out planeIndex))
{
planeIndex = Java.Lang.Integer.ValueOf(mPlaneIndexMap.Count).IntValue();
mPlaneIndexMap.Add(plane, planeIndex);
}
// Set plane color. Computed deterministically from the Plane index.
int colorIndex = planeIndex % PLANE_COLORS_RGBA.Length;
colorRgbaToFloat(mPlaneColor, PLANE_COLORS_RGBA[colorIndex]);
GLES20.GlUniform4fv(mLineColorUniform, 1, mPlaneColor, 0);
GLES20.GlUniform4fv(mDotColorUniform, 1, mPlaneColor, 0);
// Each plane will have its own angle offset from others, to make them easier to
// distinguish. Compute a 2x2 rotation matrix from the angle.
float angleRadians = planeIndex * 0.144f;
float uScale = DOTS_PER_METER;
float vScale = DOTS_PER_METER * EQUILATERAL_TRIANGLE_SCALE;
mPlaneAngleUvMatrix[0] = +(float)Math.Cos(angleRadians) * uScale;
mPlaneAngleUvMatrix[1] = -(float)Math.Sin(angleRadians) * uScale;
mPlaneAngleUvMatrix[2] = +(float)Math.Sin(angleRadians) * vScale;
mPlaneAngleUvMatrix[3] = +(float)Math.Cos(angleRadians) * vScale;
GLES20.GlUniformMatrix2fv(mPlaneUvMatrixUniform, 1, false, mPlaneAngleUvMatrix, 0);
Draw(cameraView, cameraPerspective);
}
// Clean up the state we set
GLES20.GlDisableVertexAttribArray(mPlaneXZPositionAlphaAttribute);
GLES20.GlBindTexture(GLES20.GlTexture2d, 0);
GLES20.GlDisable(GLES20.GlBlend);
GLES20.GlDepthMask(true);
ShaderUtil.CheckGLError(TAG, "Cleaning up after drawing planes");
}
/// <summary>
/// This method is called from Renderer when OpenGL ready to draw scene
/// The code of this method show "standard" OpenGL object drawing routine with using transformation matrix
/// </summary>
/// <param name="gl">IGL10 access object pointer from orign OpenGL.OnDraw(IGL10 gl)</param>
/// <param name="mViewMatrix">Camere View matrix</param>
/// <param name="mProjectionMatrix">Camera Projection matrix</param>
public virtual void DrawFrame()
{
float[] mModelMatrix = new float[16];
Matrix.SetIdentityM(mModelMatrix, 0);
Matrix.ScaleM(mModelMatrix, 0, scale, scale, scale);
Matrix.RotateM(mModelMatrix, 0, angleX, 1, ay, az);
Matrix.RotateM(mModelMatrix, 0, angleY, ax, 1, az);
Matrix.TranslateM(mModelMatrix, 0, x, y, z);
// Tell OpenGL to use this program when rendering.
GLES20.GlUseProgram(shader.programHandle);
//Draw with VBO
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, vertexVBO.handle);
GLES20.GlEnableVertexAttribArray(shader.mPositionHandle);
GLES20.GlVertexAttribPointer(shader.mPositionHandle, mPositionDataSize, GLES20.GlFloat, false, 0, 0);
if (textureVBO.handle != -1)
{
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, textureVBO.handle);
GLES20.GlEnableVertexAttribArray(shader.mTextureCoordHandle);
GLES20.GlVertexAttribPointer(shader.mTextureCoordHandle, 2, GLES20.GlFloat, false, 0, 0);
}
if (normalVBO.handle != -1)
{
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, normalVBO.handle);
GLES20.GlEnableVertexAttribArray(shader.mNormalHandle);
GLES20.GlVertexAttribPointer(shader.mNormalHandle, 3, GLES20.GlFloat, false, 0, 0);
}
if (texture.handle != -1)
{
GLES20.GlActiveTexture(GLES20.GlTexture0);
GLES20.GlBindTexture(GLES20.GlTexture2d, texture.handle);
GLES20.GlUniform1i(shader.mTextureHandle, 0);
}
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, 0);
//END OF Draw with VBO
//light position
GLES20.GlUniform4f(shader.mLightPos, lx, ly, lz, lw);
// 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, renderer.camera.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, renderer.camera.mProjectionMatrix, 0, mMVPMatrix, 0);
GLES20.GlUniformMatrix4fv(shader.mMVPMatrixHandle, 1, false, _mMVPMatrix, 0);
GLES20.GlDrawArrays(GLES20.GlTriangles, 0, vertexVBO.objectSize); //Cube has 12 triagle faces each face has 3 coord
GLES20.GlUseProgram(0);
}
public virtual void enable()
{
GLES20.GlEnableVertexAttribArray(_Location);
}
private void drawOneMaterial(GLSL glsl, ShellSurface surface, RenderList mat)
{
// set motion
if (surface.Animation)
{
if (mat.bone_inv_map == null)
{
for (int j = 0; j < surface.RenderBones.Count; j++)
{
var b = surface.RenderBones[j];
if (b != null)
{
Array.Copy(b.matrix, 0, mBoneMatrix, j * 16, 16);
}
}
}
else
{
for (int j = 0; j < mat.bone_inv_map.Length; j++)
{
int inv = mat.bone_inv_map[j];
if (inv >= 0)
{
var b = surface.RenderBones[inv];
Array.Copy(b.matrix, 0, mBoneMatrix, j * 16, 16);
}
}
}
GLES20.GlUniformMatrix4fv(glsl.muMBone, mat.bone_num, false, mBoneMatrix, 0);
GLES20.GlEnableVertexAttribArray(glsl.maBlendHandle);
GLES20.GlVertexAttribPointer(glsl.maBlendHandle, 3, GLES20.GlUnsignedByte, false, 0, mat.weight);
}
// initialize color
for (int i = 0; i < mDifAmb.Count(); i++)
{
mDifAmb[i] = 1.0f;
}
// diffusion and ambient
float wi = 0.6f; // light color = (0.6, 0.6, 0.6)
for (int i = 0; i < 3; i++)
{
mDifAmb[i] *= mat.material.diffuse_color[i] * wi + mat.material.emmisive_color[i];
}
mDifAmb[3] *= mat.material.diffuse_color[3];
Vector.min(mDifAmb, 1.0f);
GLES20.GlUniform4fv(glsl.muDif, 1, mDifAmb, 0);
// speculation
if (glsl.muPow >= 0)
{
GLES20.GlUniform4f(glsl.muSpec, mat.material.specular_color[0], mat.material.specular_color[1], mat.material.specular_color[2], 0);
GLES20.GlUniform1f(glsl.muPow, mat.material.power);
}
// toon
GLES20.GlUniform1i(glsl.msToonSampler, 0);
GLES20.GlActiveTexture(GLES20.GlTexture0);
GLES20.GlBindTexture(GLES20.GlTexture2d, TextureFile.FetchTexInfo(surface.toon_name[mat.material.toon_index]).tex);
// texture
GLES20.GlUniform1i(glsl.msTextureSampler, 1);
GLES20.GlActiveTexture(GLES20.GlTexture1);
if (mat.material.texture != null)
{
TexInfo tb = TextureFile.FetchTexInfo(mat.material.texture);
if (tb != null)
{
GLES20.GlBindTexture(GLES20.GlTexture2d, tb.tex);
}
else // avoid crash
{
GLES20.GlBindTexture(GLES20.GlTexture2d, TextureFile.FetchTexInfo(surface.toon_name[0]).tex); // white texture using toon0.bmp
for (int i = 0; i < 3; i++) // for emulate premultiplied alpha
{
mDifAmb[i] *= mat.material.diffuse_color[3];
}
}
}
else
{
GLES20.GlBindTexture(GLES20.GlTexture2d, TextureFile.FetchTexInfo(surface.toon_name[0]).tex); // white texture using toon0.bmp
for (int i = 0; i < 3; i++) // for emulate premultiplied alpha
{
mDifAmb[i] *= mat.material.diffuse_color[3];
}
}
// sphere(sph)
GLES20.GlUniform1i(glsl.msSphSampler, 2);
GLES20.GlActiveTexture(GLES20.GlTexture2);
if (mat.material.sph != null)
{
TexInfo tb = TextureFile.FetchTexInfo(mat.material.sph);
if (tb != null)
{
GLES20.GlBindTexture(GLES20.GlTexture2d, tb.tex);
}
else // avoid crash
{
GLES20.GlBindTexture(GLES20.GlTexture2d, TextureFile.FetchTexInfo(surface.toon_name [0]).tex); // white texture using toon0.bmp
}
}
else
{
GLES20.GlBindTexture(GLES20.GlTexture2d, TextureFile.FetchTexInfo(surface.toon_name[0]).tex); // white texture using toon0.bmp
}
// sphere(spa)
GLES20.GlUniform1i(glsl.msSpaSampler, 3);
GLES20.GlActiveTexture(GLES20.GlTexture3);
if (mat.material.spa != null)
{
TexInfo tb = TextureFile.FetchTexInfo(mat.material.spa);
if (tb != null)
{
GLES20.GlBindTexture(GLES20.GlTexture2d, tb.tex);
}
}
// draw
surface.IndexBuffer.Position(mat.face_vert_offset);
GLES20.GlDrawElements(GLES20.GlTriangles, mat.face_vert_count, GLES20.GlUnsignedShort, surface.IndexBuffer);
checkGlError("glDrawElements");
}
/**
* \brief Draw the video icon (in OpenGL).
* @param mvpMatrix the model-view-projection matrix.
* @param status the video state.
*/
private void DrawIcon(float[] mvpMatrix, PikkartVideoPlayer.VideoSate.VIDEO_STATE status)
{
GLES20.GlEnable(GLES20.GlBlend);
GLES20.GlBlendFunc(GLES20.GlSrcAlpha, GLES20.GlOneMinusSrcAlpha);
GLES20.GlUseProgram(mKeyframe_Program_GL_ID);
int vertexHandle = GLES20.GlGetAttribLocation(mKeyframe_Program_GL_ID, "vertexPosition");
int textureCoordHandle = GLES20.GlGetAttribLocation(mKeyframe_Program_GL_ID, "vertexTexCoord");
int mvpMatrixHandle = GLES20.GlGetUniformLocation(mKeyframe_Program_GL_ID, "modelViewProjectionMatrix");
int texSampler2DHandle = GLES20.GlGetUniformLocation(mKeyframe_Program_GL_ID, "texSampler2D");
GLES20.GlVertexAttribPointer(vertexHandle, 3, GLES20.GlFloat, false, 0, mVertices_Buffer);
GLES20.GlVertexAttribPointer(textureCoordHandle, 2, GLES20.GlFloat, false, 0, mTexCoords_Buffer);
GLES20.GlEnableVertexAttribArray(vertexHandle);
GLES20.GlEnableVertexAttribArray(textureCoordHandle);
GLES20.GlActiveTexture(GLES20.GlTexture0);
switch ((int)status)
{
case 0: //end
GLES20.GlBindTexture(GLES20.GlTexture2d, mIconPlayTexture_GL_ID);
break;
case 1: //pasued
GLES20.GlBindTexture(GLES20.GlTexture2d, mIconPlayTexture_GL_ID);
break;
case 2: //stopped
GLES20.GlBindTexture(GLES20.GlTexture2d, mIconPlayTexture_GL_ID);
break;
case 3: //playing
GLES20.GlBindTexture(GLES20.GlTexture2d, mIconPlayTexture_GL_ID);
break;
case 4: //ready
GLES20.GlBindTexture(GLES20.GlTexture2d, mIconPlayTexture_GL_ID);
break;
case 5: //not ready
GLES20.GlBindTexture(GLES20.GlTexture2d, mIconBusyTexture_GL_ID);
break;
case 6: //buffering
GLES20.GlBindTexture(GLES20.GlTexture2d, mIconBusyTexture_GL_ID);
break;
case 7: //error
GLES20.GlBindTexture(GLES20.GlTexture2d, mIconErrorTexture_GL_ID);
break;
default:
GLES20.GlBindTexture(GLES20.GlTexture2d, mIconBusyTexture_GL_ID);
break;
}
GLES20.GlUniform1i(texSampler2DHandle, 0);
GLES20.GlUniformMatrix4fv(mvpMatrixHandle, 1, false, mvpMatrix, 0);
GLES20.GlDrawElements(GLES20.GlTriangles, mIndices_Number, GLES20.GlUnsignedShort, mIndex_Buffer);
GLES20.GlDisableVertexAttribArray(vertexHandle);
GLES20.GlDisableVertexAttribArray(textureCoordHandle);
GLES20.GlUseProgram(0);
GLES20.GlDisable(GLES20.GlBlend);
}
