public void OnSurfaceCreated(IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
GLES20.GlClearColor(0.1f, 0.1f, 0.1f, 1.0f);
// Create the texture and pass it to ARCore session to be filled during update().
mBackgroundRenderer.CreateOnGlThread(this);
mSession?.SetCameraTextureName(mBackgroundRenderer.TextureId);
// Prepare the other rendering objects.
try
{
mVirtualObject.CreateOnGlThread(this, "andy.obj", "andy.png");
mVirtualObject.setMaterialProperties(0.0f, 3.5f, 1.0f, 6.0f);
mVirtualObjectShadow.CreateOnGlThread(this, "andy_shadow.obj", "andy_shadow.png");
mVirtualObjectShadow.SetBlendMode(ObjectRenderer.BlendMode.Shadow);
mVirtualObjectShadow.setMaterialProperties(1.0f, 0.0f, 0.0f, 1.0f);
}
catch (Java.IO.IOException e)
{
Log.Error(TAG, "Failed to read obj file");
}
try
{
mPlaneRenderer.CreateOnGlThread(this, "trigrid.png");
}
catch (IOException e)
{
Log.Error(TAG, "Failed to read plane texture");
}
mPointCloud.CreateOnGlThread(this);
}
public void OnSurfaceCreated(IGL10 unused, EGLConfig config)
{
// Set the background frame color
GLES20.GlClearColor(0.0f, 0.0f, 0.0f, 1.0f);
mTriangle = new Triangle();
}
public override void OnSurfaceCreated(IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
base.OnSurfaceCreated(gl, config);
//SETUP OpenGL ES
GLES20.GlClearColor(0.9f, 0.9f, 0.9f, 1.0f);
GLES20.GlEnable(GLES20.GlDepthTest); //uncoment if needs enabled dpeth test
//GLES20.GlEnable(2884); // GlCullFace == 2884 see OpenGL documentation to this constant value GLES20.GlDisable(2884);
//GLES20.GlFrontFace(GLES20.GlCcw);
//GLES20.GlCullFace(GLES20.GlFront);
GLES20.GlEnable(GL10.GlBlend);
GLES20.GlBlendFunc(GL10.GlSrcAlpha, GL10.GlOneMinusSrcAlpha);
// GLES20.GlDisable(GL10.GlLighting);
// GLES20.GlEnable(2884);
// GLES20.GlDisable(GL10.GlDepthBufferBit);
// GLES20.GlEnable(GL10.GlDither);
// GLES20.GlEnable(GL10.GlBlend);
// GLES20.GlBlendFunc(GL10.GlSrcAlpha, GL10.GlOne);
//ENDSETUP OpenGL ES
//Loading objects
glObjects.Add(new GLObject(this, "vertex_shader", "fragment_shader", "oldhouse_objvertex", "oldhouse_objnormal", "oldhouse_objtexture", "body"));
//Ask android to run RAM garbage cleaner
System.GC.Collect();
}
public void OnSurfaceCreated(IGL10 unused, EGLConfig config)
{
int program = GLES20.GlCreateProgram();
addShaderTo(GLES20.GlVertexShader, VERTEX_SHADER_STRING, program);
addShaderTo(GLES20.GlFragmentShader, FRAGMENT_SHADER_STRING, program);
GLES20.GlLinkProgram(program);
int[] result = new int[] { GLES20.GlFalse };
result[0] = GLES20.GlFalse;
GLES20.GlGetProgramiv(program, GLES20.GlLinkStatus, result, 0);
abortUnless(result[0] == GLES20.GlTrue, GLES20.GlGetProgramInfoLog(program));
GLES20.GlUseProgram(program);
GLES20.GlUniform1i(GLES20.GlGetUniformLocation(program, "y_tex"), 0);
GLES20.GlUniform1i(GLES20.GlGetUniformLocation(program, "u_tex"), 1);
GLES20.GlUniform1i(GLES20.GlGetUniformLocation(program, "v_tex"), 2);
// Actually set in drawRectangle(), but queried only once here.
posLocation = GLES20.GlGetAttribLocation(program, "in_pos");
int tcLocation = GLES20.GlGetAttribLocation(program, "in_tc");
GLES20.GlEnableVertexAttribArray(tcLocation);
GLES20.GlVertexAttribPointer(tcLocation, 2, GLES20.GlFloat, false, 0, textureCoords);
GLES20.GlClearColor(0.0f, 0.0f, 0.0f, 1.0f);
checkNoGLES2Error();
}
public void OnSurfaceCreated(IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
GLES20.GlClearColor(0.1f, 0.1f, 0.1f, 1.0f);
mBackgroundRenderer.CreateOnGlThread(_context);
mSession.SetCameraTextureName(mBackgroundRenderer.TextureId);
try
{
mVirtualObject.CreateOnGlThread(/*context=*/ Context, "andy.obj", "andy.png");
mVirtualObject.setMaterialProperties(0.0f, 3.5f, 1.0f, 6.0f);
mVirtualObjectShadow.CreateOnGlThread(/*context=*/ Context,
"andy_shadow.obj", "andy_shadow.png");
mVirtualObjectShadow.SetBlendMode(ObjectRenderer.BlendMode.Shadow);
mVirtualObjectShadow.setMaterialProperties(1.0f, 0.0f, 0.0f, 1.0f);
}
catch (Java.IO.IOException ex)
{
Log.Error(TAG, "Failed to read obj file");
}
try
{
mPlaneRenderer.CreateOnGlThread(/*context=*/ _context, "trigrid.png");
}
catch (Java.IO.IOException ex)
{
Log.Error(TAG, "Failed to read plane texture");
}
mPointCloud.CreateOnGlThread(/*context=*/ Context);
}
public void Initialize()
{
GLES20.GlClearColor(0.1f, 0.1f, 0.1f, 0.5f); // Dark background so text shows up well
cubeVertices = PrepareBuffer(WorldLayoutData.CubeCoords);
cubeNormals = PrepareBuffer(WorldLayoutData.CubeNormals);
cubeTextureCoords = PrepareBuffer(WorldLayoutData.CubeTexCoords);
floorVertices = PrepareBuffer(WorldLayoutData.FloorCoords);
floorNormals = PrepareBuffer(WorldLayoutData.FloorNormals);
floorColors = PrepareBuffer(WorldLayoutData.FloorColors);
monkeyFound = DrawingUtils.LoadGlTexture(resources, Resource.Drawable.texture2);
monkeyNotFound = DrawingUtils.LoadGlTexture(resources, Resource.Drawable.texture1);
int vertexShader = DrawingUtils.LoadGlShader(GLES20.GlVertexShader, resources, Resource.Raw.vertex);
int gridShader = DrawingUtils.LoadGlShader(GLES20.GlFragmentShader, resources, Resource.Raw.fragment);
glProgram = GLES20.GlCreateProgram();
GLES20.GlAttachShader(glProgram, vertexShader);
GLES20.GlAttachShader(glProgram, gridShader);
GLES20.GlLinkProgram(glProgram);
GLES20.GlEnable(GLES20.GlDepthTest);
// Object first appears directly in front of user
Matrix.SetIdentityM(modelCube, 0);
Matrix.TranslateM(modelCube, 0, 0, 0, -mObjectDistance);
Matrix.SetIdentityM(modelFloor, 0);
Matrix.TranslateM(modelFloor, 0, 0, -mFloorDepth, 0); // Floor appears below user
CheckGlError("onSurfaceCreated");
}
public void OnSurfaceCreated(Javax.Microedition.Khronos.Opengles.IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
// Set the background frame color
GLES20.GlClearColor(0.0f, 0.0f, 0.0f, 1.0f);
mTriangle = new Triangle();
mSquare = new Square();
}
/// <summary>
/// Called when the OpenGL surface its created
/// </summary>
public void OnSurfaceCreated(IGL10 gl, EGLConfig config)
{
GLES20.GlClearColor(0.1f, 0.1f, 0.1f, 1.0f);
this.backgroundRenderer.CreateOnGlThread(this.context);
this.session.SetCameraTextureName(this.backgroundRenderer.TextureId);
LoadArAssets();
this.session.Resume();
}
public void OnSurfaceCreated(IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
// Clear the original color and set a new color.
GLES20.GlClearColor(0.1f, 0.1f, 0.1f, 1.0f);
foreach (HandRelatedDisplay handRelatedDisplay in mHandRelatedDisplays)
{
handRelatedDisplay.Init();
}
mTextureDisplay.Init();
mTextDisplay.SetListener(new HandOnTextInfoChangeListenerClass(this));
}
public void OnSurfaceCreated(IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
// Clear the color and set the window color.
GLES20.GlClearColor(0.1f, 0.1f, 0.1f, 1.0f);
foreach (BodyRelatedDisplay bodyRelatedDisplay in mBodyRelatedDisplays)
{
bodyRelatedDisplay.Init();
}
mTextureDisplay.Init();
mTextDisplay.SetListener(new BodyOnTextInfoChangeListenerClass(this));
}
public void OnSurfaceCreated(IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
// Set the window color.
GLES20.GlClearColor(0.1f, 0.1f, 0.1f, 1.0f);
mTextureDisplay.Init();
mTextDisplay.SetListener(new WorldOnTextInfoChangeListenerClass(this));
mLabelDisplay.Init(GetPlaneBitmaps());
mObjectDisplay.Init(mContext);
}
void GLSurfaceView.IRenderer.OnSurfaceCreated(Javax.Microedition.Khronos.Opengles.IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
GLES20.GlClearColor(1f, 1f, 1f, 1.0f);
GLES20.GlEnable(GLES20.GlDepthTest);
mPointCloud = new PointCloud(mMaxDepthPoints);
mGrid = new Grid();
mCameraFrustumAndAxis = new CameraFrustumAndAxis();
Matrix.SetIdentityM(mViewMatrix, 0);
Matrix.SetLookAtM(mViewMatrix, 0, 5f, 5f, 5f, 0f, 0f, 0f, 0f, 1f, 0f);
mCameraFrustumAndAxis.ModelMatrix = ModelMatCalculator.ModelMatrix;
}
public override void OnSurfaceCreated(IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
base.OnSurfaceCreated(gl, config);
//SETUP OpenGL ES
GLES20.GlClearColor(0.9f, 0.9f, 0.9f, 0.9f);
GLES20.GlEnable(GLES20.GlDepthTest); //uncoment if needs enabled dpeth test
//ENDSETUP OpenGL ES
//Loading objects
glObjects.Add(new GLObject(this, "vertex_shader", "fragment_shader", "oldhouse_objvertex", "oldhouse_objnormal", "oldhouse_objtexture", "body"));
//Ask android to run RAM garbage cleaner
System.GC.Collect();
}
public void OnSurfaceCreated(IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
// Set background color and enable depth testing
GLES20.GlClearColor(1f, 1f, 1f, 1.0f);
GLES20.GlEnable(GLES20.GlDepthTest);
resetModelMatCalculator();
mCameraFrustum = new CameraFrustum();
mFloorGrid = new Grid();
mCameraFrustumAndAxis = new CameraFrustumAndAxis();
mTrajectory = new Trajectory(3);
// Construct the initial view matrix
Matrix.SetIdentityM(mViewMatrix, 0);
Matrix.SetLookAtM(mViewMatrix, 0, 5f, 5f, 5f, 0f, 0f, 0f, 0f, 1f, 0f);
mCameraFrustumAndAxis.ModelMatrix = ModelMatCalculator.ModelMatrix;
}
public void OnSurfaceCreated(IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
if (RenderManager.externalPaused)
{
RenderManager.initShaders();
}
else
{
RenderManager.createObjects();
}
GLES20.GlClearColor(0.1f, 0.1f, 0.9f, 0.0f);
GLES20.GlEnable(GLES20.GlDepthTest);
GLES20.GlEnable(GLES20.GlCullFaceMode);
GLES20.GlCullFace(GLES20.GlBack);
}
public void OnSurfaceCreated(IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
// Create the triangle
SetupTriangle();
// Create the image information
SetupImage();
// Set the clear color to yellow
GLES20.GlClearColor(1.0f, 1.0f, 0f, 1);
GLES20.GlEnable(GLES20.GlBlend);
GLES20.GlBlendFunc(GLES20.GlOne, GLES20.GlOneMinusSrcAlpha);
#region Solid colors mode
/*
* // Create the shaders, solid color
* int vertexShader = ShaderHelper.LoadShader(GLES20.GlVertexShader, ShaderHelper.VsSolidColor);
* int fragmentShader = ShaderHelper.LoadShader(GLES20.GlFragmentShader, ShaderHelper.FsSolidColor);
*
* ShaderHelper.SpSolidColor = GLES20.GlCreateProgram(); // create empty OpenGL ES Program
* GLES20.GlAttachShader(ShaderHelper.SpSolidColor, vertexShader); // add the vertex shader to program
* GLES20.GlAttachShader(ShaderHelper.SpSolidColor, fragmentShader); // add the fragment shader to program
* GLES20.GlLinkProgram(ShaderHelper.SpSolidColor); // creates OpenGL ES program executables
*
* // Set our shader programm
* GLES20.GlUseProgram(ShaderHelper.SpSolidColor);
*/
#endregion
#region Texture mode
// Create the shaders, images
int vertexShader = ShaderHelper.LoadShader(GLES20.GlVertexShader, ShaderHelper.VsImage);
int fragmentShader = ShaderHelper.LoadShader(GLES20.GlFragmentShader, ShaderHelper.FsImage);
ShaderHelper.SpImage = GLES20.GlCreateProgram();
GLES20.GlAttachShader(ShaderHelper.SpImage, vertexShader);
GLES20.GlAttachShader(ShaderHelper.SpImage, fragmentShader);
GLES20.GlLinkProgram(ShaderHelper.SpImage);
// Set our shader programm
GLES20.GlUseProgram(ShaderHelper.SpImage);
#endregion
}
public void OnSurfaceCreated(IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
GLES20.GlClearColor(0.1f, 0.1f, 0.1f, 1.0f);
if (isOpenCameraOutside)
{
mTextureDisplay.Init(mTextureId);
}
else
{
mTextureDisplay.Init();
}
Log.Debug(TAG, "On surface created textureId= " + mTextureId);
mFaceGeometryDisplay.Init(mContext);
mTextDisplay.SetListener(new FaceOnTextInfoChangeListenerClass(this));
}
public void OnSurfaceCreated(IGL10 gl, EGLConfig config)
{
// GL configurations
int bonenum = 48;
GLES20.GlGetIntegerv(GLES20.GlMaxTextureSize, mTexSize, 0);
ShellViewModel.MaxBone = bonenum;
mNpot = hasExt("GL_OES_texture_npot");
// initialize
GLES20.GlClearColor(0, 0, 0, 1);
GLES20.GlEnable(GLES20.GlDepthTest);
GLES20.GlEnable(GLES20.GlBlend);
checkGlError("GlEnable");
// GLUtils.texImage2D generates premultiplied-alpha texture. so we use GL_ONE instead of GL_ALPHA
GLES20.GlBlendFunc(GL10.GlOne, GL10.GlOneMinusSrcAlpha);
GLES20.GlDepthFunc(GLES20.GlLequal);
GLES20.GlFrontFace(GLES20.GlCw);
checkGlError("GlMiscSettings");
// shader programs
mGLSL = new Dictionary <String, GLSL>();
mGLSL.Add("builtin:default",
new GLSL(String.Format(Util.ReadAssetString("shader/vs.vsh"), ShellViewModel.MaxBone),
Util.ReadAssetString("shader/fs.fsh")));
mGLSL.Add("builtin:default_alpha",
new GLSL(String.Format(Util.ReadAssetString("shader/vs.vsh"), ShellViewModel.MaxBone),
Util.ReadAssetString("shader/fs_alpha.fsh")));
mGLSL.Add("builtin:nomotion",
new GLSL(Util.ReadAssetString("shader/vs_nm.vsh"), Util.ReadAssetString("shader/fs.fsh")));
mGLSL.Add("builtin:nomotion_alpha",
new GLSL(Util.ReadAssetString("shader/vs_nm.vsh"), Util.ReadAssetString("shader/fs_alpha.fsh")));
// render targets
mRT = new Dictionary <String, RenderTarget>();
mRT.Add("screen", new RenderTarget());
GLES20.GlBindFramebuffer(GLES20.GlFramebuffer, 0);
}
/// <summary>
/// This method will clear the surface view from its last rendered pixels.
/// This is used to avoid seeing the previous video rendering when setting
/// a video source to null.
/// </summary>
internal void Clear()
{
#pragma warning disable 618
// The solution is as described here:
// https://stackoverflow.com/questions/25660994/clear-video-frame-from-surfaceview-on-video-complete
if (Holder?.Surface == null)
{
return;
}
var egl = Javax.Microedition.Khronos.Egl.EGLContext.EGL.JavaCast <IEGL10>();
var display = egl.EglGetDisplay(EGL10.EglDefaultDisplay);
egl.EglInitialize(display, null);
int[] attribList =
{
EGL10.EglRedSize, 8,
EGL10.EglGreenSize, 8,
EGL10.EglBlueSize, 8,
EGL10.EglAlphaSize, 8,
EGL10.EglRenderableType, EGL10.EglWindowBit,
EGL10.EglNone, 0, // placeholder for recordable [@-3]
EGL10.EglNone
};
var configs = new Javax.Microedition.Khronos.Egl.EGLConfig[1];
var numConfigs = new int[1];
egl.EglChooseConfig(display, attribList, configs, configs.Length, numConfigs);
var config = configs[0];
var context = egl.EglCreateContext(display, config, EGL10.EglNoContext, new int[] { 12440, 2, EGL10.EglNone });
var eglSurface = egl.EglCreateWindowSurface(display, config, Holder.Surface, new int[] { EGL10.EglNone });
egl.EglMakeCurrent(display, eglSurface, eglSurface, context);
GLES20.GlClearColor(0, 0, 0, 1);
GLES20.GlClear(GLES20.GlColorBufferBit);
egl.EglSwapBuffers(display, eglSurface);
egl.EglDestroySurface(display, eglSurface);
egl.EglMakeCurrent(display, EGL10.EglNoSurface, EGL10.EglNoSurface, EGL10.EglNoContext);
egl.EglDestroyContext(display, context);
egl.EglTerminate(display);
#pragma warning restore 618
}
/**
* 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);
}
public void RenderTexture(int texId)
{
try
{
// Bind default FBO
GLES20.GlBindFramebuffer(GLES20.GlFramebuffer, 0);
// Use our shader program
GLES20.GlUseProgram(MProgram);
GlToolbox.CheckGlError("glUseProgram");
// Set viewport
GLES20.GlViewport(0, 0, MViewWidth, MViewHeight);
GlToolbox.CheckGlError("glViewport");
// Disable blending
GLES20.GlDisable(GLES20.GlBlend);
// Set the vertex attributes
GLES20.GlVertexAttribPointer(MTexCoordHandle, 2, GLES20.GlFloat, false, 0, MTexVertices);
GLES20.GlEnableVertexAttribArray(MTexCoordHandle);
GLES20.GlVertexAttribPointer(MPosCoordHandle, 2, GLES20.GlFloat, false, 0, MPosVertices);
GLES20.GlEnableVertexAttribArray(MPosCoordHandle);
GlToolbox.CheckGlError("vertex attribute setup");
// Set the input texture
GLES20.GlActiveTexture(GLES20.GlTexture0);
GlToolbox.CheckGlError("glActiveTexture");
GLES20.GlBindTexture(GLES20.GlTexture2d, texId);
GlToolbox.CheckGlError("glBindTexture");
GLES20.GlUniform1i(MTexSamplerHandle, 0);
// Draw
GLES20.GlClearColor(0.0f, 0.0f, 0.0f, 1.0f);
GLES20.GlClear(GLES20.GlColorBufferBit);
GLES20.GlDrawArrays(GLES20.GlTriangleStrip, 0, 4);
}
catch (Exception e)
{
Methods.DisplayReportResultTrack(e);
}
}
public void afterDrawFrame()
{
GLES20.GlBindFramebuffer(36160, mOriginalFramebufferId /*.array()[0]*/.Get(0));
GLES20.GlViewport(0, 0, mHmd.getScreen().getWidth(), mHmd.getScreen().getHeight());
GLES20.GlGetIntegerv(2978, mViewport);
GLES20.GlGetIntegerv(2884, mCullFaceEnabled);
GLES20.GlGetIntegerv(3089, mScissorTestEnabled);
GLES20.GlDisable(3089);
GLES20.GlDisable(2884);
GLES20.GlClearColor(0.0F, 0.0F, 0.0F, 1.0F);
GLES20.GlClear(16640);
GLES20.GlUseProgram(mProgramHolder.program);
GLES20.GlEnable(3089);
GLES20.GlScissor(0, 0, mHmd.getScreen().getWidth() / 2, mHmd.getScreen().getHeight());
renderDistortionMesh(mLeftEyeDistortionMesh);
GLES20.GlScissor(mHmd.getScreen().getWidth() / 2, 0, mHmd.getScreen().getWidth() / 2, mHmd.getScreen().getHeight());
renderDistortionMesh(mRightEyeDistortionMesh);
GLES20.GlDisableVertexAttribArray(mProgramHolder.aPosition);
GLES20.GlDisableVertexAttribArray(mProgramHolder.aVignette);
GLES20.GlDisableVertexAttribArray(mProgramHolder.aTextureCoord);
GLES20.GlUseProgram(0);
GLES20.GlBindBuffer(34962, 0);
GLES20.GlBindBuffer(34963, 0);
GLES20.GlDisable(3089);
if (mCullFaceEnabled /*.array()[0]*/.Get(0) == 1)
{
GLES20.GlEnable(2884);
}
if (mScissorTestEnabled /*.array()[0]*/.Get(0) == 1)
{
GLES20.GlEnable(3089);
}
GLES20.GlViewport(mViewport /*.array()[0]*/.Get(0), mViewport /*.array()[1]*/.Get(1), mViewport /*.array()[2]*/.Get(2), mViewport /*.array()[3]*/.Get(3));
}
public override void OnSurfaceCreated(IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
base.OnSurfaceCreated(gl, config);
//SETUP OpenGL ES
GLES20.GlClearColor(0.5f, 0.5f, 0.5f, 1.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);
//ENDSETUP OpenGL ES
//Loading objects
glObjects.Add(new GLObject(this, "den_vertex_shader", "den_fragment_shader", "den_house1_objvertex", "den_house1_objnormal", "den_house1_objtexture", "den_housetextutre2"));
glObjects.Add(new GLObject(this, "den_vertex_shader", "den_fragment_shader", "den_house2_objvertex", "den_house2_objnormal", "den_house2_objtexture", "den_housetextutre2"));
glObjects.Add(new GLObject(this, "den_vertex_shader", "den_fragment_shader", "den_house3_objvertex", "den_house3_objnormal", "den_house3_objtexture", "den_housetextutre2"));
glObjects.Add(new DenGlassObject(this, "den_glass"));
//Ask android to run RAM garbage cleaner
System.GC.Collect();
}
public void OnSurfaceCreated(IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
GLES20.GlClearColor(0.1f, 0.1f, 0.1f, 1.0f);
// Create the texture and pass it to ARCore session to be filled during update().
mBackgroundRenderer.CreateOnGlThread(/*context=*/ this);
if (mSession != null)
{
mSession.SetCameraTextureName(mBackgroundRenderer.TextureId);
}
// Prepare the other rendering objects.
try
{
mVirtualObject.CreateOnGlThread(/*context=*/ this, "andy.obj", "andy2.png");
mVirtualObject.setMaterialProperties(0.0f, 3.5f, 1.0f, 6.0f);
mVirtualObjectShadow.CreateOnGlThread(/*context=*/ this, "andy_shadow.obj", "vsplogo.png");
mVirtualObjectShadow.SetBlendMode(ObjectRenderer.BlendMode.Shadow);
mVirtualObjectShadow.setMaterialProperties(1.0f, 0.0f, 0.0f, 1.0f);
showLoadingObjMessage("1. loaded obj file");
}
catch (Java.IO.IOException e)
{
Log.Error(TAG, "Failed to read obj file");
showLoadingObjMessage("2. Failed to read obj file");
}
try
{
mPlaneRenderer.CreateOnGlThread(/*context=*/ this, "dot4.png");
showLoadingObjMessage("3. load floor image file");
}
catch (Java.IO.IOException e)
{
Log.Error(TAG, "Failed to read plane texture");
}
mPointCloud.CreateOnGlThread(/*context=*/ this);
}
/**
* Generates a frame of data using GL commands.
* <p>
* We have an 8-frame animation sequence that wraps around. It looks like this:
* <pre>
* 0 1 2 3
* 7 6 5 4
* </pre>
* We draw one of the eight rectangles and leave the rest set to the zero-fill color. */
private void generateSurfaceFrame(int frameIndex)
{
frameIndex %= 8;
int startX, startY;
if (frameIndex < 4)
{
// (0,0) is bottom-left in GL
startX = frameIndex * (mWidth / 4);
startY = mHeight / 2;
}
else
{
startX = (7 - frameIndex) * (mWidth / 4);
startY = 0;
}
GLES20.GlDisable(GLES20.GlScissorTest);
GLES20.GlClearColor(TEST_R0 / 255.0f, TEST_G0 / 255.0f, TEST_B0 / 255.0f, 1.0f);
GLES20.GlClear(GLES20.GlColorBufferBit);
GLES20.GlEnable(GLES20.GlScissorTest);
GLES20.GlScissor(startX, startY, mWidth / 4, mHeight / 2);
GLES20.GlClearColor(TEST_R1 / 255.0f, TEST_G1 / 255.0f, TEST_B1 / 255.0f, 1.0f);
GLES20.GlClear(GLES20.GlColorBufferBit);
}
public void OnSurfaceCreated(Javax.Microedition.Khronos.Opengles.IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
// Set the background frame color
GLES20.GlClearColor(0.0f, 0.0f, 0.0f, 1.0f);
initTex();
mSTexture = new SurfaceTexture(hTex[0]);
mSTexture.SetOnFrameAvailableListener(this);
mCamera = Android.Hardware.Camera.Open();
try
{
mCamera.SetPreviewTexture(mSTexture);
}
catch (Exception ioe)
{
}
GLES20.GlClearColor(0.0f, 0.0f, 0.0f, 1.0f);
hProgram = loadShader(vss, fss);
mTriangle = new Triangle();
}
/**
* 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");
}
public void OnDrawFrame(IGL10 unused)
{
// Clear view.
GLES20.GlClearColor(0.5f, 0.5f, 0.5f, 1.0f);
GLES20.GlClear(GLES20.GlColorBufferBit);
// If we have new preview texture.
if (_surfaceTextureUpdate)
{
// Update surface texture.
_surfaceTexture.UpdateTexImage();
// Update texture transform matrix.
_surfaceTexture.GetTransformMatrix(_transformM);
_surfaceTextureUpdate = false;
// Bind offscreen texture into use.
_fboOffscreen.Bind();
_fboOffscreen.BindTexture(0);
// Take copy shader into use.
_shaderCopyOes.UseProgram();
// Uniform variables.
var uOrientationM = _shaderCopyOes.GetHandle("uOrientationM");
var uTransformM = _shaderCopyOes.GetHandle("uTransformM");
// We're about to transform external texture here already.
GLES20.GlUniformMatrix4fv(uOrientationM, 1, false,
_sharedData._orientationM, 0);
GLES20.GlUniformMatrix4fv(uTransformM, 1, false, _transformM, 0);
// We're using external OES texture as source.
GLES20.GlActiveTexture(GLES20.GlTexture0);
//GLES20.GlBindTexture(GLES20.GlTexture2d, mFboExternal.getTexture(0));
// Trigger actual rendering.
renderQuad(_shaderCopyOes.GetHandle("aPosition"));
}
else
{
System.Diagnostics.Debug.WriteLine("OK");
}
// Bind screen buffer into use.
GLES20.GlBindFramebuffer(GLES20.GlFramebuffer, 0);
GLES20.GlViewport(0, 0, _width, _height);
// Take filter shader into use.
_shaderFilterDefault.UseProgram();
// Uniform variables.
var uBrightness = _shaderFilterDefault.GetHandle("uBrightness");
var uContrast = _shaderFilterDefault.GetHandle("uContrast");
var uSaturation = _shaderFilterDefault.GetHandle("uSaturation");
var uCornerRadius = _shaderFilterDefault.GetHandle("uCornerRadius");
var uAspectRatio = _shaderFilterDefault.GetHandle("uAspectRatio");
var uAspectRatioPreview = _shaderFilterDefault.GetHandle("uAspectRatioPreview");
// Store uniform variables into use.
GLES20.GlUniform1f(uBrightness, _sharedData._brightness);
GLES20.GlUniform1f(uContrast, _sharedData._contrast);
GLES20.GlUniform1f(uSaturation, _sharedData._saturation);
GLES20.GlUniform1f(uCornerRadius, _sharedData._cornerRadius);
GLES20.GlUniform2fv(uAspectRatio, 1, _aspectRatio, 0);
GLES20.GlUniform2fv(uAspectRatioPreview, 1,
_sharedData._aspectRatioPreview, 0);
// Use offscreen texture as source.
GLES20.GlActiveTexture(GLES20.GlTexture1);
GLES20.GlBindTexture(GLES20.GlTexture2d, _fboOffscreen.GetTexture(0));
// Trigger actual rendering.
renderQuad(_shaderCopyOes.GetHandle("aPosition"));
}
private int[] VBOBuffers = new int[2]; //2 buffers for vertices and colors
public void OnSurfaceCreated(IGL10 gl, Javax.Microedition.Khronos.Egl.EGLConfig config)
{
const float edge = 1.0f;
// X, Y, Z,
float[] triangleVerticesData =
{
-1.5f, -0.25f, 0.0f,
0.5f, -0.25f, 0.0f,
0.0f, 0.559016994f, 0.0f
};
FloatBuffer mTriangleVertices = ByteBuffer.AllocateDirect(triangleVerticesData.Length * mBytesPerFloat).Order(ByteOrder.NativeOrder()).AsFloatBuffer();
mTriangleVertices.Put(triangleVerticesData).Flip();
// 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
};
FloatBuffer mTriangleColors = ByteBuffer.AllocateDirect(triangleColorsData.Length * mBytesPerFloat).Order(ByteOrder.NativeOrder()).AsFloatBuffer();
mTriangleColors.Put(triangleColorsData).Flip();
//Use VBO
GLES20.GlGenBuffers(2, VBOBuffers, 0); //2 buffers for vertices and colors
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, VBOBuffers[0]);
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);
GLES20.GlBindBuffer(GLES20.GlArrayBuffer, 0);
GLES20.GlClearColor(1.0f, 1.0f, 1.0f, 1.0f);
// Position the eye behind the origin.
float eyeX = 0.0f;
float eyeY = 0.0f;
float eyeZ = 4.5f;
// We are looking toward the distance
float lookX = 0.0f;
float lookY = 0.0f;
float lookZ = -5.0f;
// Set our up vector. This is where our head would be pointing were we holding the camera.
float upX = 0.0f;
float upY = 1.0f;
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);
string vertexShader =
"uniform mat4 u_MVPMatrix; \n" // A constant representing the combined model/view/projection matrix.
+ "attribute vec4 a_Position; \n" // Per-vertex position information we will pass in.
+ "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.
+ "void main() \n" // The entry point for our vertex shader.
+ "{ \n"
+ " v_Color = a_Color; \n" // Pass the color 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.
+ "void main() \n" // The entry point for our fragment shader.
+ "{ \n"
+ " 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");
// 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");
mPositionHandle = GLES20.GlGetAttribLocation(programHandle, "a_Position");
mColorHandle = GLES20.GlGetAttribLocation(programHandle, "a_Color");
// Tell OpenGL to use this program when rendering.
GLES20.GlUseProgram(programHandle);
}
public void OnDrawFrame(IGL10 gl)
{
GLES20.GlClearColor(1, 1, 1, 1);
GLES20.GlClear(GLES20.GlStencilBufferBit | GLES20.GlColorBufferBit);
}