private void ArrayToVBO(Array source, int size)
{
float[] floatArray = new float[size / 4];
System.Buffer.BlockCopy(source, 0, floatArray, 0, (int)size);
//temp Cut vertex
int cutSize = 0;
for (int i = 0; i < size / 4; i += 3)
{
if (floatArray[i + 1] < 20.0f)
{
cutSize++;
}
}
float[] cutArray = new float[cutSize * 3];
int cutArrayIndex = 0;
for (int i = 0; i < size / 4; i += 3)
{
if (floatArray[i + 1] < 20.0f)
{
cutArray[cutArrayIndex] = floatArray[i];
cutArray[cutArrayIndex + 1] = floatArray[i + 1];
cutArray[cutArrayIndex + 2] = floatArray[i + 2];
cutArrayIndex += 3;
}
}
size = cutSize * 3 * 4;
objectSize = (int)(size / 4 / 3);
FloatBuffer vertexBuffer;
vertexBuffer = FloatBuffer.Allocate((int)size / 4); // float array to
vertexBuffer.Put(cutArray, 0, (int)size / 4);
vertexBuffer.Flip();
GLES20.GlGenBuffers(1, VBOBuffers, 0);
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, VBOBuffers[0]);
//VBOManager.setSize(fileName, vertexBuffer.Capacity() / 4); //is size of vertex count = 1 vertex 4 float x,y,z, 1
GLES20.GlBufferData(GLES20.GlArrayBuffer, vertexBuffer.Capacity() * mBytesPerFloat, vertexBuffer, GLES20.GlStaticDraw);
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, 0);
handle = VBOBuffers[0];
floatArray = null;
vertexBuffer = null;
}
public void OnSurfaceCreated(IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
const float coord = 1.0f;
//FloatBuffer mTriangleVertices = ByteBuffer.AllocateDirect(triangleVerticesData.Length * mBytesPerFloat).Order(ByteOrder.NativeOrder()).AsFloatBuffer();
//mTriangleVertices.Put(triangleVerticesData).Flip();
// Cube colors
// R, G, B, A
float[] triangleColorsData =
{
1.0f, 0.0f, 0.0f, 0.5f,
0.0f, 0.5f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 0.0f, 0.5f,
0.0f, 0.5f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 0.0f, 0.5f,
0.0f, 0.5f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 0.0f, 0.5f,
0.0f, 0.5f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 0.0f, 0.5f,
0.0f, 0.5f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 0.0f, 0.5f,
0.0f, 0.5f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 0.0f, 0.5f,
0.0f, 0.5f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 0.0f, 0.5f,
0.0f, 0.5f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 0.0f, 0.5f,
0.0f, 0.5f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 0.0f, 0.5f,
0.0f, 0.5f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 0.0f, 0.5f,
0.0f, 0.5f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f,
1.0f, 0.0f, 0.0f, 0.5f,
0.0f, 0.5f, 1.0f, 1.0f,
0.0f, 1.0f, 0.0f, 1.0f
};
FloatBuffer mTriangleColors = ByteBuffer.AllocateDirect(triangleColorsData.Length * mBytesPerFloat).Order(ByteOrder.NativeOrder()).AsFloatBuffer();
mTriangleColors.Put(triangleColorsData).Flip();
//Cube texture UV Map
float[] triangleTextureUVMapData =
{
0.0f, 0.0f,
0.0f, 1.0f,
1.0f, 0.0f,
0.0f, 0.0f,
0.0f, 1.0f,
1.0f, 0.0f,
0.0f, 0.0f,
0.0f, 1.0f,
1.0f, 0.0f,
0.0f, 0.0f,
0.0f, 1.0f,
1.0f, 0.0f,
0.0f, 0.0f,
0.0f, 1.0f,
1.0f, 0.0f,
0.0f, 0.0f,
0.0f, 1.0f,
1.0f, 0.0f,
0.0f, 0.0f,
0.0f, 1.0f,
1.0f, 0.0f,
0.0f, 0.0f,
0.0f, 1.0f,
1.0f, 0.0f,
0.0f, 0.0f,
0.0f, 1.0f,
1.0f, 0.0f,
0.0f, 0.0f,
0.0f, 1.0f,
1.0f, 0.0f,
0.0f, 0.0f,
0.0f, 1.0f,
1.0f, 0.0f,
0.0f, 0.0f,
0.0f, 1.0f,
1.0f, 0.0f
};
FloatBuffer mTriangleTextureUVMap = ByteBuffer.AllocateDirect(triangleTextureUVMapData.Length * mBytesPerFloat).Order(ByteOrder.NativeOrder()).AsFloatBuffer();
mTriangleTextureUVMap.Put(triangleTextureUVMapData).Flip();
//triagles normals
//This normal array is not right, it is spacialy DO FOR demonstrate how normals work with faces when light is calculated at shader program
float[] triangleNormalData =
{
// Front face
0.0f, 0.0f, 1.0f,
0.0f, 0.0f, 1.0f,
0.0f, 0.0f, 1.0f,
1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f,
// Right face
1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f,
// Back face
0.0f, 0.0f, -1.0f,
0.0f, 0.0f, -1.0f,
0.0f, 0.0f, -1.0f,
0.0f, 0.0f, -1.0f,
0.0f, 0.0f, -1.0f,
0.0f, 0.0f, -1.0f,
// Left face
-1.0f, 0.0f, 0.0f,
-1.0f, 0.0f, 0.0f,
-1.0f, 0.0f, 0.0f,
-1.0f, 0.0f, 0.0f,
-1.0f, 0.0f, 0.0f,
-1.0f, 0.0f, 0.0f,
// Top face
0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f,
// Bottom face
0.0f, -1.0f, 0.0f,
0.0f, -1.0f, 0.0f,
0.0f, -1.0f, 0.0f,
0.0f, -1.0f, 0.0f,
0.0f, -1.0f, 0.0f,
0.0f, -1.0f, 0.0f
};
FloatBuffer mTriangleNormal = ByteBuffer.AllocateDirect(triangleNormalData.Length * mBytesPerFloat).Order(ByteOrder.NativeOrder()).AsFloatBuffer();
mTriangleNormal.Put(triangleNormalData).Flip();
//Data buffers to VBO
GLES20.GlGenBuffers(4, VBOBuffers, 0); //2 buffers for vertices, texture and colors
//--------------------------------------------
//int resourceId = //context.Resources.GetIdentifier("object1_objvertex", "raw", context.PackageName);
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, VBOBuffers[0]);
float[] floatArray;
long size;
// Vertex
FloatBuffer vertexBuffer;
Stream fileIn = context.Resources.OpenRawResource(Resource.Raw.OldHouse_objvertex) as Stream;
MemoryStream m = new MemoryStream();
fileIn.CopyTo(m);
size = m.Length;
floatArray = new float[size / 4];
objectSize = (int)(size / 4 / 3);
System.Buffer.BlockCopy(m.ToArray(), 0, floatArray, 0, (int)size);
vertexBuffer = FloatBuffer.Allocate((int)size / 4); // float array to
vertexBuffer.Put(floatArray, 0, (int)size / 4);
vertexBuffer.Flip();
//VBOManager.setSize(fileName, vertexBuffer.Capacity() / 4); //is size of vertex count = 1 vertex 4 float x,y,z, 1
GLES20.GlBufferData(GLES20.GlArrayBuffer, vertexBuffer.Capacity() * mBytesPerFloat, vertexBuffer, GLES20.GlStaticDraw);
floatArray = null;
vertexBuffer = null;
fileIn.Close();
m.Close();
//--------------------------------------------
//GLES20.GlBufferData(GLES20.GlArrayBuffer, mTriangleVertices.Capacity() * mBytesPerFloat, mTriangleVertices, GLES20.GlStaticDraw);
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, VBOBuffers[1]);
GLES20.GlBufferData(GLES20.GlArrayBuffer, mTriangleColors.Capacity() * mBytesPerFloat, mTriangleColors, GLES20.GlStaticDraw);
//Textures -----------------------------------------
//GLES20.GlBindBuffer(GLES20.GlArrayBuffer, VBOBuffers[2]);
//GLES20.GlBufferData(GLES20.GlArrayBuffer, mTriangleTextureUVMap.Capacity() * mBytesPerFloat, mTriangleTextureUVMap, GLES20.GlStaticDraw);
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, VBOBuffers[2]);
// Vertex
fileIn = context.Resources.OpenRawResource(Resource.Raw.OldHouse_objtexture) as Stream;
m = new MemoryStream();
fileIn.CopyTo(m);
size = m.Length;
floatArray = new float[size / 4];
//objectSize = (int)(size / 4 / 3);
System.Buffer.BlockCopy(m.ToArray(), 0, floatArray, 0, (int)size);
vertexBuffer = FloatBuffer.Allocate((int)size / 4); // float array to
vertexBuffer.Put(floatArray, 0, (int)size / 4);
vertexBuffer.Flip();
//VBOManager.setSize(fileName, vertexBuffer.Capacity() / 4); //is size of vertex count = 1 vertex 4 float x,y,z, 1
GLES20.GlBufferData(GLES20.GlArrayBuffer, vertexBuffer.Capacity() * mBytesPerFloat, vertexBuffer, GLES20.GlStaticDraw);
floatArray = null;
vertexBuffer = null;
fileIn.Close();
m.Close();
//ENDOF Textures -----------------------------------------
// GLES20.GlBindBuffer(GLES20.GlArrayBuffer, VBOBuffers[3]);
/// GLES20.GlBufferData(GLES20.GlArrayBuffer, mTriangleNormal.Capacity() * mBytesPerFloat, mTriangleNormal, GLES20.GlStaticDraw);
/// Normales
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, VBOBuffers[3]);
// Vertex
fileIn = context.Resources.OpenRawResource(Resource.Raw.OldHouse_objnormal) as Stream;
m = new MemoryStream();
fileIn.CopyTo(m);
size = m.Length;
floatArray = new float[size / 4];
//objectSize = (int)(size / 4 / 3);
System.Buffer.BlockCopy(m.ToArray(), 0, floatArray, 0, (int)size);
vertexBuffer = FloatBuffer.Allocate((int)size / 4); // float array to
vertexBuffer.Put(floatArray, 0, (int)size / 4);
vertexBuffer.Flip();
//VBOManager.setSize(fileName, vertexBuffer.Capacity() / 4); //is size of vertex count = 1 vertex 4 float x,y,z, 1
GLES20.GlBufferData(GLES20.GlArrayBuffer, vertexBuffer.Capacity() * mBytesPerFloat, vertexBuffer, GLES20.GlStaticDraw);
floatArray = null;
vertexBuffer = null;
fileIn.Close();
m.Close();
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, 0);
//Load and setup texture
GLES20.GlGenTextures(1, textureHandle, 0); //init 1 texture storage handle
if (textureHandle[0] != 0)
{
//Android.Graphics cose class Matrix exists at both Android.Graphics and Android.OpenGL and this is only sample of using
Android.Graphics.BitmapFactory.Options options = new Android.Graphics.BitmapFactory.Options();
options.InScaled = false; // No pre-scaling
Android.Graphics.Bitmap bitmap = Android.Graphics.BitmapFactory.DecodeResource(context.Resources, Resource.Drawable.body, options);
GLES20.GlBindTexture(GLES20.GlTexture2d, textureHandle[0]);
GLES20.GlTexParameteri(GLES20.GlTexture2d, GLES20.GlTextureMinFilter, GLES20.GlNearest);
GLES20.GlTexParameteri(GLES20.GlTexture2d, GLES20.GlTextureMagFilter, GLES20.GlNearest);
GLES20.GlTexParameteri(GLES20.GlTexture2d, GLES20.GlTextureWrapS, GLES20.GlClampToEdge);
GLES20.GlTexParameteri(GLES20.GlTexture2d, GLES20.GlTextureWrapT, GLES20.GlClampToEdge);
GLUtils.TexImage2D(GLES20.GlTexture2d, 0, bitmap, 0);
bitmap.Recycle();
}
//Ask android to run RAM garbage cleaner
System.GC.Collect();
//Setup OpenGL ES
GLES20.GlClearColor(0.0f, 0.0f, 0.0f, 0.0f);
GLES20.GlEnable(GLES20.GlDepthTest); //uncoment if needs enabled dpeth test
// GLES20.GlEnable(2884); // GlCullFace == 2884 see OpenGL documentation to this constant value
// GLES20.GlCullFace(GLES20.GlFront);
// Position the eye behind the origin.
float eyeX = 0.0f;
float eyeY = 0.0f;
float eyeZ = 7.5f;
// We are looking toward the distance
float lookX = 0.0f;
float lookY = 0.0f;
float lookZ = -7.0f;
// Set our up vector. This is where our head would be pointing were we holding the camera.
float upX = 0.0f;
float upY = coord;
float upZ = 0.0f;
// Set the view matrix. This matrix can be said to represent the camera position.
// NOTE: In OpenGL 1, a ModelView matrix is used, which is a combination of a model and
// view matrix. In OpenGL 2, we can keep track of these matrices separately if we choose.
Matrix.SetLookAtM(mViewMatrix, 0, eyeX, eyeY, eyeZ, lookX, lookY, lookZ, upX, upY, upZ);
//all "attribute" variables is "triagles" VBO (arrays) items representation
//a_Possition[0] <=> a_Color[0] <=> a_TextureCoord[0] <=> a_Normal[0]
//a_Possition[1] <=> a_Color[1] <=> a_TextureCoord[1] <=> a_Normal[1]
//...
//a_Possition[n] <=> a_Color[n] <=> a_TextureCoord[n] <=> a_Normal[n] -- where "n" is object buffers length
//-> HOW MANY faces in your object (model) in VBO -> how many times the vertex shader will be called by OpenGL
string vertexShader =
"uniform mat4 u_MVPMatrix; \n" // A constant representing the combined model/view/projection matrix.
+ "uniform vec4 u_LightPos; \n" // A constant representing the light source position
+ "attribute vec4 a_Position; \n" // Per-vertex position information we will pass in. (it means vec4[x,y,z,w] but we put only x,y,z at this sample
+ "attribute vec4 a_Color; \n" // Per-vertex color information we will pass in.
+ "varying vec4 v_Color; \n" // This will be passed into the fragment shader.
+ "attribute vec2 a_TextureCoord; \n" // Per-vertex texture UVMap information we will pass in.
+ "varying vec2 v_TextureCoord; \n" // This will be passed into the fragment shader.
+ "attribute vec3 a_Normal; \n" // Per-vertex normals information we will pass in.
+ "void main() \n" // The entry point for our vertex shader.
+ "{ \n"
//light calculation section for fragment shader
+ " vec3 modelViewVertex = vec3(u_MVPMatrix * a_Position);\n"
+ " vec3 modelViewNormal = vec3(u_MVPMatrix * vec4(a_Normal, 0.0));\n"
+ " float distance = length(u_LightPos.xyz - modelViewVertex);\n"
+ " vec3 lightVector = normalize(u_LightPos.xyz - modelViewVertex);\n"
+ " float diffuse = max(dot(modelViewNormal, lightVector), 0.1);\n"
+ " diffuse = diffuse * (1.0 / (1.0 + (u_LightPos.w * distance * distance)));\n"
+ " v_Color = vec4(diffuse, diffuse, diffuse, diffuse);\n" //Pass the color with light aspect to fragment shader R G B A
//+ " v_Color = vec4(a_Normal, 1.0);\n" //Test normals array loading
+ " v_TextureCoord = a_TextureCoord; \n" // Pass the texture coordinate through to the fragment shader. It will be interpolated across the triangle.
+ " gl_Position = u_MVPMatrix \n" // gl_Position is a special variable used to store the final position.
+ " * a_Position; \n" // Multiply the vertex by the matrix to get the final point in normalized screen coordinates.
+ "} \n";
string fragmentShader =
"precision mediump float; \n" // Set the default precision to medium. We don't need as high of a
// precision in the fragment shader.
+ "varying vec4 v_Color; \n" // This is the color from the vertex shader interpolated across the triangle per fragment.
+ "varying vec2 v_TextureCoord; \n" // This is the texture coordinate from the vertex shader interpolated across the triangle per fragment.
+ "uniform sampler2D u_Texture; \n" // This is the texture image handler
+ "void main() \n" // The entry point for our fragment shader.
+ "{ \n"
+ " gl_FragColor = texture2D(u_Texture, v_TextureCoord) * v_Color; \n" // Pass the color directly through the pipeline.
//+ " gl_FragColor = v_Color; \n" // Pass the color directly through the pipeline.
+ "} \n";
int vertexShaderHandle = GLES20.GlCreateShader(GLES20.GlVertexShader);
if (vertexShaderHandle != 0)
{
// Pass in the shader source.
GLES20.GlShaderSource(vertexShaderHandle, vertexShader);
// Compile the shader.
GLES20.GlCompileShader(vertexShaderHandle);
// Get the compilation status.
int[] compileStatus = new int[1];
GLES20.GlGetShaderiv(vertexShaderHandle, GLES20.GlCompileStatus, compileStatus, 0);
// If the compilation failed, delete the shader.
if (compileStatus[0] == 0)
{
GLES20.GlDeleteShader(vertexShaderHandle);
vertexShaderHandle = 0;
}
}
if (vertexShaderHandle == 0)
{
throw new Exception("Error creating vertex shader.");
}
// Load in the fragment shader shader.
int fragmentShaderHandle = GLES20.GlCreateShader(GLES20.GlFragmentShader);
if (fragmentShaderHandle != 0)
{
// Pass in the shader source.
GLES20.GlShaderSource(fragmentShaderHandle, fragmentShader);
// Compile the shader.
GLES20.GlCompileShader(fragmentShaderHandle);
// Get the compilation status.
int[] compileStatus = new int[1];
GLES20.GlGetShaderiv(fragmentShaderHandle, GLES20.GlCompileStatus, compileStatus, 0);
// If the compilation failed, delete the shader.
if (compileStatus[0] == 0)
{
GLES20.GlDeleteShader(fragmentShaderHandle);
fragmentShaderHandle = 0;
}
}
if (fragmentShaderHandle == 0)
{
throw new Exception("Error creating fragment shader.");
}
// Create a program object and store the handle to it.
int programHandle = GLES20.GlCreateProgram();
if (programHandle != 0)
{
// Bind the vertex shader to the program.
GLES20.GlAttachShader(programHandle, vertexShaderHandle);
// Bind the fragment shader to the program.
GLES20.GlAttachShader(programHandle, fragmentShaderHandle);
// Bind attributes
GLES20.GlBindAttribLocation(programHandle, 0, "a_Position");
GLES20.GlBindAttribLocation(programHandle, 1, "a_Color");
GLES20.GlBindAttribLocation(programHandle, 2, "a_TextureCoord");
GLES20.GlBindAttribLocation(programHandle, 3, "a_Normal");
// Link the two shaders together into a program.
GLES20.GlLinkProgram(programHandle);
// Get the link status.
int[] linkStatus = new int[1];
GLES20.GlGetProgramiv(programHandle, GLES20.GlLinkStatus, linkStatus, 0);
// If the link failed, delete the program.
if (linkStatus[0] == 0)
{
GLES20.GlDeleteProgram(programHandle);
programHandle = 0;
}
}
if (programHandle == 0)
{
throw new Exception("Error creating program.");
}
// Set program handles. These will later be used to pass in values to the program.
mMVPMatrixHandle = GLES20.GlGetUniformLocation(programHandle, "u_MVPMatrix");
mLightPos = GLES20.GlGetUniformLocation(programHandle, "u_LightPos");
mPositionHandle = GLES20.GlGetAttribLocation(programHandle, "a_Position");
mColorHandle = GLES20.GlGetAttribLocation(programHandle, "a_Color");
mTextureCoordHandle = GLES20.GlGetAttribLocation(programHandle, "a_TextureCoord");
mNormalHandle = GLES20.GlGetAttribLocation(programHandle, "a_Normal");
mTextureHandle = GLES20.GlGetUniformLocation(programHandle, "u_Texture");
// Tell OpenGL to use this program when rendering.
GLES20.GlUseProgram(programHandle);
}
public override void loadFileToVBO(String fileName)
{
if (fileName == "")
{
return;
}
files.Add(fileName);
int indexResult = VBOManager.getVBOIndex(fileName);
if (indexResult == -1)
{
List <float[]> vertexes = new List <float[]>();
List <float[]> normales = new List <float[]>();
List <float[]> textures = new List <float[]>();
float alphaStep = (float)(2 * Math.PI) / steps;
float alpha = 0;
//front and back faces
for (int i = 0; i < steps; i++)
{
//triagle face
float[] v1 = new float[4]; //vertex 1
float[] v2 = new float[4]; //vertex 2
float[] v3 = new float[4]; //vertex 3
//top face
v1[0] = 0; //x
v1[1] = 0; //y
v1[2] = height; //z
v1[3] = 1;
v2[0] = radius * (float)Math.Sin(alpha);
v2[1] = radius * (float)Math.Cos(alpha);
v2[2] = height; //z
v2[3] = 1;
alpha += alphaStep;
v3[0] = radius * (float)Math.Sin(alpha);
v3[1] = radius * (float)Math.Cos(alpha);
v3[2] = height; //z
v3[3] = 1;
vertexes.Add(v1);
vertexes.Add(v2);
vertexes.Add(v3);
//normales
float[] normale = new float[4]; //vertex 1
normale[0] = -1; //x
normale[1] = 0; //y
normale[2] = 0; //z
normale[3] = 1;
normales.Add(normale);
normales.Add(normale);
normales.Add(normale);
float[] t1 = new float[2];
float[] t2 = new float[2];
float[] t3 = new float[2];
t1[0] = 0.0f;
t1[1] = 0.0f;
t2[0] = 0.0f;
t2[1] = 0.0f;
t3[0] = 0.0f;
t3[1] = 0.0f;
textures.Add(t1);
textures.Add(t2);
textures.Add(t3);
//spin face (from top) -----------
float[] vS1 = new float[4]; //vertex 1
float[] vS2 = new float[4]; //vertex 2
float[] vS3 = new float[4]; //vertex 3
vS1[0] = radius * (float)Math.Sin(alpha);
vS1[1] = radius * (float)Math.Cos(alpha);
vS1[2] = 0; //z
vS1[3] = 1;
vS2 = v2;
vS3 = v3;
vertexes.Add(vS1);
vertexes.Add(vS2);
vertexes.Add(vS3);
normale = new float[4]; //vertex 1
normales.Add(normale);
normales.Add(normale);
normales.Add(normale);
//SPIN TEXTURE FACE
//Spin face texture -----------------------------------
t1 = new float[2];
t2 = new float[2];
t3 = new float[2];
t1[0] = coordToTexture(textureStep);
t1[1] = coordToTexture(textureStep * i);
t2[0] = coordToTexture(textureStep * 2);
t2[1] = coordToTexture(textureStep * i);
t3[0] = coordToTexture(textureStep); //texture x
t3[1] = coordToTexture(textureStep * i + textureStep); //texture y
textures.Add(t3);
textures.Add(t2);
textures.Add(t1);
//--------------------------------------------------------
//back face -------------------------------------
alpha -= alphaStep;
v1 = new float[4]; //vertex 1
v2 = new float[4]; //vertex 2
v3 = new float[4]; //vertex 3
//top face
v1[0] = 0; //x
v1[1] = 0; //y
v1[2] = 0; //z
v1[3] = 1;
v2[0] = radius * (float)Math.Sin(alpha);
v2[1] = radius * (float)Math.Cos(alpha);
v2[2] = 0; //z
v2[3] = 1;
alpha += alphaStep;
v3[0] = radius * (float)Math.Sin(alpha);
v3[1] = radius * (float)Math.Cos(alpha);
v3[2] = 0; //z
v3[3] = 1;
vertexes.Add(v1);
vertexes.Add(v2);
vertexes.Add(v3);
//normales
normale = new float[4]; //vertex 1
normale[0] = -1; //x
normale[1] = 0; //y
normale[2] = 0; //z
normale[3] = 1;
normales.Add(normale);
normales.Add(normale);
normales.Add(normale);
t1 = new float[2];
t2 = new float[2];
t3 = new float[2];
t1[0] = 0;
t1[1] = 0;
t2[0] = 0;
t2[1] = 0;
t3[0] = 0;
t3[1] = 0;
textures.Add(t1);
textures.Add(t2);
textures.Add(t3);
//spin face (from top) -----------
alpha -= alphaStep;
vS1 = new float[4]; //vertex 1
vS2 = new float[4]; //vertex 2
vS3 = new float[4]; //vertex 3
vS1[0] = radius * (float)Math.Sin(alpha);
vS1[1] = radius * (float)Math.Cos(alpha);
vS1[2] = height; //z
vS1[3] = 1;
vS2 = v2;
vS3 = v3;
vertexes.Add(vS1);
vertexes.Add(vS2);
vertexes.Add(vS3);
normale = new float[4]; //vertex 1
normales.Add(normale);
normales.Add(normale);
normales.Add(normale);
t1 = new float[2];
t2 = new float[2];
t3 = new float[2];
t1[0] = coordToTexture(textureStep * 2); //texture x
t1[1] = coordToTexture(textureStep * i); //texture y
t2[0] = coordToTexture(textureStep * 2);
t2[1] = coordToTexture(textureStep * i + textureStep);
t3[0] = coordToTexture(textureStep);
t3[1] = coordToTexture(textureStep * i + textureStep);
textures.Add(t1);
textures.Add(t2);
textures.Add(t3);
alpha += alphaStep;
}
long size = vertexes.Count; //all faces (faces*4 = all vertex)
float[] floatArray = new float[size * 4]; //4 float to one vertex, 3 vertex to one face slow way
for (int i = 0; i < vertexes.Count; i++)
{
floatArray[i * 4 + 0] = vertexes[i][0];
floatArray[i * 4 + 1] = vertexes[i][1];
floatArray[i * 4 + 2] = vertexes[i][2];
floatArray[i * 4 + 3] = vertexes[i][3];
}
vertexBuffer = FloatBuffer.Allocate((int)size * 4); // float array to
vertexBuffer.Put(floatArray, 0, (int)size * 4);
vertexBuffer.Flip();
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, VBOManager.getVBO(fileName)[0]);
GLES20.GlBufferData(GLES20.GlArrayBuffer, vertexBuffer.Capacity() * FLOAT_SIZE, vertexBuffer, GLES20.GlStaticDraw); // vbb.capacity()
vertexBuffer = null;
floatArray = null;
//-----------------------------------------------------------------------
floatArray = new float[size * 4]; //4 float to one vertex, 3 vertex to one face slow way
for (int i = 0; i < vertexes.Count; i++)
{
floatArray[i * 4 + 0] = normales[i][0];
floatArray[i * 4 + 1] = normales[i][1];
floatArray[i * 4 + 2] = normales[i][2];
floatArray[i * 4 + 3] = normales[i][3];
}
normalBuffer = FloatBuffer.Allocate((int)size * 4);
normalBuffer.Put(floatArray, 0, (int)size * 4);
normalBuffer.Flip();
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, VBOManager.getVBO(fileName)[2]);
GLES20.GlBufferData(GLES20.GlArrayBuffer, normalBuffer.Capacity() * FLOAT_SIZE, normalBuffer, GLES20.GlStaticDraw); // vbb.capacity()
normalBuffer = null;
//-----------------------------------------------------------------------
floatArray = new float[size * 2]; //2 float
for (int i = 0; i < textures.Count; i++)
{
floatArray[i * 2 + 0] = textures[i][0];
floatArray[i * 2 + 1] = textures[i][1];
}
textureBuffer = FloatBuffer.Allocate((int)size * 2);
textureBuffer.Put(floatArray, 0, (int)size * 2);
textureBuffer.Flip();
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, VBOManager.getVBO(fileName)[1]);
GLES20.GlBufferData(GLES20.GlArrayBuffer, textureBuffer.Capacity() * FLOAT_SIZE, textureBuffer, GLES20.GlStaticDraw); // vbb.capacity()
textureBuffer = null;
VBOManager.setSize(fileName, (int)size);
}
}
public bool loadingBinModel(String fileName)
{
float[] floatArray;
long size;
try
{
// Vertex
vertexBuffer = null;
System.GC.Collect();
int resourceId = context.Resources.GetIdentifier(fileName + "_vert", "raw", context.PackageName);
Stream fileIn = context.Resources.OpenRawResource(resourceId) as Stream;
MemoryStream m = new MemoryStream();
fileIn.CopyTo(m);
size = m.Length;
floatArray = new float[size / 4];
System.Buffer.BlockCopy(m.ToArray(), 0, floatArray, 0, (int)size);
vertexBuffer = FloatBuffer.Allocate((int)size / 4); // float array to
vertexBuffer.Put(floatArray, 0, (int)size / 4);
vertexBuffer.Flip();
VBOManager.setSize(fileName, vertexBuffer.Capacity() / 4); //is size of vertex count = 1 vertex 4 float x,y,z, 1
floatArray = null;
fileIn.Close();
m.Close();
//----------------------------------------------------------------------------------------------------
normalBuffer = null;
System.GC.Collect();
resourceId = context.Resources.GetIdentifier(fileName + "_norm", "raw", context.PackageName);
fileIn = context.Resources.OpenRawResource(resourceId) as Stream;
m = new MemoryStream();
fileIn.CopyTo(m);
size = m.Length;
floatArray = new float[size / 4];
System.Buffer.BlockCopy(m.ToArray(), 0, floatArray, 0, (int)size);
normalBuffer = FloatBuffer.Allocate((int)size / 4); // float array to
normalBuffer.Put(floatArray, 0, (int)size / 4);
normalBuffer.Flip();
floatArray = null;
fileIn.Close();
m.Close();
//----------------------------------------------------------------------------------------------------
textureBuffer = null;
System.GC.Collect();
resourceId = context.Resources.GetIdentifier(fileName + "_texture", "raw", context.PackageName);
fileIn = context.Resources.OpenRawResource(resourceId) as Stream;
m = new MemoryStream();
fileIn.CopyTo(m);
size = m.Length;
floatArray = new float[size / 4];
System.Buffer.BlockCopy(m.ToArray(), 0, floatArray, 0, (int)size);
textureBuffer = FloatBuffer.Allocate((int)size / 4); // float array to
textureBuffer.Put(floatArray, 0, (int)size / 4);
textureBuffer.Flip();
floatArray = null;
fileIn.Close();
m.Close();
return(true);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(false);
}
}
