public void Draw() { // Add program to OpenGL environment GLES20.GlUseProgram(mProgram); // get handle to vertex shader's vPosition member mPositionHandle = GLES20.GlGetAttribLocation(mProgram, "vPosition"); // Enable a handle to the triangle vertices GLES20.GlEnableVertexAttribArray(mPositionHandle); // Prepare the triangle coordinate data GLES20.GlVertexAttribPointer(mPositionHandle, COORDS_PER_VERTEX, GLES20.GL_FLOAT, false, vertexStride, vertexBuffer); // get handle to fragment shader's vColor member mColorHandle = GLES20.GlGetUniformLocation(mProgram, "vColor"); // Set color for drawing the triangle GLES20.GlUniform4fv(mColorHandle, 1, color, 0); // Draw the triangle GLES20.GlDrawArrays(GLES20.GL_TRIANGLES, 0, vertexCount); // Disable vertex array GLES20.GlDisableVertexAttribArray(mPositionHandle); }
/** * Renders the point cloud. * * @param pose the current point cloud pose, from {@link Frame#getPointCloudPose()}. * @param cameraView the camera view matrix for this frame, typically from * {@link Frame#getViewMatrix(float[], int)}. * @param cameraPerspective the camera projection matrix for this frame, typically from * {@link Session#getProjectionMatrix(float[], int, float, float)}. */ public void Draw(Pose pose, float[] cameraView, float[] cameraPerspective) { float[] modelMatrix = new float[16]; pose.ToMatrix(modelMatrix, 0); float[] modelView = new float[16]; float[] modelViewProjection = new float[16]; Matrix.MultiplyMM(modelView, 0, cameraView, 0, modelMatrix, 0); Matrix.MultiplyMM(modelViewProjection, 0, cameraPerspective, 0, modelView, 0); ShaderUtil.CheckGLError(TAG, "Before draw"); GLES20.GlUseProgram(mProgramName); GLES20.GlEnableVertexAttribArray(mPositionAttribute); GLES20.GlBindBuffer(GLES20.GlArrayBuffer, mVbo); GLES20.GlVertexAttribPointer( mPositionAttribute, 4, GLES20.GlFloat, false, BYTES_PER_POINT, 0); GLES20.GlUniform4f(mColorUniform, 31.0f / 255.0f, 188.0f / 255.0f, 210.0f / 255.0f, 1.0f); GLES20.GlUniformMatrix4fv(mModelViewProjectionUniform, 1, false, modelViewProjection, 0); GLES20.GlUniform1f(mPointSizeUniform, 5.0f); GLES20.GlDrawArrays(GLES20.GlPoints, 0, mNumPoints); GLES20.GlDisableVertexAttribArray(mPositionAttribute); GLES20.GlBindBuffer(GLES20.GlArrayBuffer, 0); ShaderUtil.CheckGLError(TAG, "Draw"); }
/** * \brief Draw the video keyframe (in OpenGL). * @param mvpMatrix the model-view-projection matrix. */ private void DrawKeyFrame(float[] mvpMatrix) { 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); GLES20.GlBindTexture(GLES20.GlTexture2d, mKeyframeTexture_GL_ID); 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); }
/** * \brief Draw the video (in OpenGL). * @param mvpMatrix the model-view-projection matrix. */ private void DrawVideo(float[] mvpMatrix) { GLES20.GlUseProgram(mVideo_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, "texSamplerOES"); GLES20.GlVertexAttribPointer(vertexHandle, 3, GLES20.GlFloat, false, 0, mVertices_Buffer); GLES20.GlVertexAttribPointer(textureCoordHandle, 2, GLES20.GlFloat, false, 0, mVideoTexCoords_Buffer); GLES20.GlEnableVertexAttribArray(vertexHandle); GLES20.GlEnableVertexAttribArray(textureCoordHandle); GLES20.GlActiveTexture(GLES20.GlTexture0); GLES20.GlBindTexture(GLES11Ext.GlTextureExternalOes, mVideoTexture_GL_ID); GLES20.GlUniform1i(texSampler2DHandle, 0); GLES20.GlUniformMatrix4fv(mvpMatrixHandle, 1, false, mvpMatrix, 0); // Render GLES20.GlDrawElements(GLES20.GlTriangles, mIndices_Number, GLES20.GlUnsignedShort, mIndex_Buffer); GLES20.GlDisableVertexAttribArray(vertexHandle); GLES20.GlDisableVertexAttribArray(textureCoordHandle); GLES20.GlUseProgram(0); }
/// <summary> /// Render the hand bounding box. /// </summary> private void DrawHandBox() { ShaderUtil.CheckGlError(TAG, "Draw hand box start."); GLES20.GlUseProgram(mProgram); GLES20.GlEnableVertexAttribArray(mPosition); GLES20.GlEnableVertexAttribArray(mColor); GLES20.GlBindBuffer(GLES20.GlArrayBuffer, mVbo); GLES20.GlVertexAttribPointer( mPosition, COORDINATE_DIMENSION, GLES20.GlFloat, false, BYTES_PER_POINT, 0); GLES20.GlUniform4f(mColor, 1.0f, 0.0f, 0.0f, 1.0f); GLES20.GlUniformMatrix4fv(mModelViewProjectionMatrix, 1, false, mMVPMatrix, 0); // Set the size of the rendering vertex. GLES20.GlUniform1f(mPointSize, 50.0f); // Set the width of a rendering stroke. GLES20.GlLineWidth(18.0f); GLES20.GlDrawArrays(GLES20.GlLineLoop, 0, mNumPoints); GLES20.GlDisableVertexAttribArray(mPosition); GLES20.GlDisableVertexAttribArray(mColor); GLES20.GlBindBuffer(GLES20.GlArrayBuffer, 0); ShaderUtil.CheckGlError(TAG, "Draw hand box end."); }
/// <summary> /// Draw hand skeleton connection line. /// </summary> /// <param name="projectionMatrix">Projection matrix(4 * 4).</param> private void DrawHandSkeletonLine(float[] projectionMatrix) { ShaderUtil.CheckGlError(TAG, "Draw hand skeleton line start."); GLES20.GlUseProgram(mProgram); GLES20.GlEnableVertexAttribArray(mPosition); GLES20.GlEnableVertexAttribArray(mColor); GLES20.GlBindBuffer(GLES20.GlArrayBuffer, mVbo); // Set the width of the drawn line GLES20.GlLineWidth(18.0f); // Represented each point by 4D coordinates in the shader. GLES20.GlVertexAttribPointer( mPosition, 4, GLES20.GlFloat, false, BYTES_PER_POINT, 0); GLES20.GlUniform4f(mColor, 0.0f, 0.0f, 0.0f, 1.0f); GLES20.GlUniformMatrix4fv(mModelViewProjectionMatrix, 1, false, projectionMatrix, 0); GLES20.GlUniform1f(mPointSize, JOINT_POINT_SIZE); GLES20.GlDrawArrays(GLES20.GlLines, 0, mPointsNum); GLES20.GlDisableVertexAttribArray(mPosition); GLES20.GlDisableVertexAttribArray(mColor); GLES20.GlBindBuffer(GLES20.GlArrayBuffer, 0); ShaderUtil.CheckGlError(TAG, "Draw hand skeleton line end."); }
public void Draw(Frame frame) { if (frame.HasDisplayGeometryChanged)//.IsDisplayRotationChanged) { frame.TransformDisplayUvCoords(mQuadTexCoord, mQuadTexCoordTransformed); } GLES20.GlDisable(GLES20.GlDepthTest); GLES20.GlDepthMask(false); GLES20.GlBindTexture(GLES11Ext.GlTextureExternalOes, TextureId); GLES20.GlUseProgram(mQuadProgram); GLES20.GlVertexAttribPointer( mQuadPositionParam, COORDS_PER_VERTEX, GLES20.GlFloat, false, 0, mQuadVertices); GLES20.GlVertexAttribPointer(mQuadTexCoordParam, TEXCOORDS_PER_VERTEX, GLES20.GlFloat, false, 0, mQuadTexCoordTransformed); GLES20.GlEnableVertexAttribArray(mQuadPositionParam); GLES20.GlEnableVertexAttribArray(mQuadTexCoordParam); GLES20.GlDrawArrays(GLES20.GlTriangleStrip, 0, 4); // Disable vertex arrays GLES20.GlDisableVertexAttribArray(mQuadPositionParam); GLES20.GlDisableVertexAttribArray(mQuadTexCoordParam); // Restore the depth state for further drawing. GLES20.GlDepthMask(true); GLES20.GlEnable(GLES20.GlDepthTest); ShaderUtil.CheckGLError(TAG, "Draw"); }
private void DrawSkeletonLine(float coordinate, float[] projectionMatrix) { ShaderUtil.CheckGlError(TAG, "Draw skeleton line start."); GLES20.GlUseProgram(mProgram); GLES20.GlEnableVertexAttribArray(mPosition); GLES20.GlEnableVertexAttribArray(mColor); GLES20.GlBindBuffer(GLES20.GlArrayBuffer, mVbo); // Set the width of the rendered skeleton line. GLES20.GlLineWidth(18.0f); // The size of the vertex attribute is 4, and each vertex has four coordinate components. GLES20.GlVertexAttribPointer( mPosition, 4, GLES20.GlFloat, false, BYTES_PER_POINT, 0); GLES20.GlUniform4f(mColor, 1.0f, 0.0f, 0.0f, 1.0f); GLES20.GlUniformMatrix4fv(mProjectionMatrix, 1, false, projectionMatrix, 0); // Set the size of the points. GLES20.GlUniform1f(mPointSize, 100.0f); GLES20.GlUniform1f(mCoordinateSystem, coordinate); GLES20.GlDrawArrays(GLES20.GlLines, 0, mNumPoints); GLES20.GlDisableVertexAttribArray(mPosition); GLES20.GlDisableVertexAttribArray(mColor); GLES20.GlBindBuffer(GLES20.GlArrayBuffer, 0); ShaderUtil.CheckGlError(TAG, "Draw skeleton line end."); }
/** * \brief Draw this mesh (in OpenGL). * @param modelViewProjection this mesh model-view-projection matrix. */ public void DrawMesh(float[] modelViewProjection) { //set up gl state GLES20.GlEnable(GLES20.GlDepthTest); //GLES20.GlDisable(GLES20.GlCullFaceMode); GLES20.GlCullFace(GLES20.GlBack); GLES20.GlFrontFace(GLES20.GlCw); //set shader program to use GLES20.GlUseProgram(mProgram_GL_ID); RenderUtils.CheckGLError("DrawMesh:glUseProgram"); //find attrib and unifroms in shader program int vertexHandle = GLES20.GlGetAttribLocation(mProgram_GL_ID, "vertexPosition"); //int normalHandle = GLES20.GlGetAttribLocation(Program_GL_ID, "vertexNormal"); int textureCoordHandle = GLES20.GlGetAttribLocation(mProgram_GL_ID, "vertexTexCoord"); int mvpMatrixHandle = GLES20.GlGetUniformLocation(mProgram_GL_ID, "modelViewProjectionMatrix"); int texSampler2DHandle = GLES20.GlGetUniformLocation(mProgram_GL_ID, "texSampler2D"); RenderUtils.CheckGLError("DrawMesh:get attribs and uniforms"); //upload mesh data to OpenGL attribs GLES20.GlVertexAttribPointer(vertexHandle, 3, GLES20.GlFloat, false, 0, mVertices_Buffer); //GLES20.GlVertexAttribPointer(normalHandle, 3, GLES20.GlFloat, false, 0, Normals_Buffer); GLES20.GlVertexAttribPointer(textureCoordHandle, 2, GLES20.GlFloat, false, 0, mTexCoords_Buffer); RenderUtils.CheckGLError("DrawMesh:put attrib pointers"); //enable gl attribs to use GLES20.GlEnableVertexAttribArray(vertexHandle); //GLES20.GlEnableVertexAttribArray(normalHandle); GLES20.GlEnableVertexAttribArray(textureCoordHandle); RenderUtils.CheckGLError("DrawMesh:enable attrib arrays"); // activate texture 0, bind it, and pass to shader GLES20.GlActiveTexture(GLES20.GlTexture0); GLES20.GlBindTexture(GLES20.GlTexture2d, mTexture_GL_ID); GLES20.GlUniform1i(texSampler2DHandle, 0); RenderUtils.CheckGLError("DrawMesh:activate texturing"); // pass the model view matrix to the shader GLES20.GlUniformMatrix4fv(mvpMatrixHandle, 1, false, modelViewProjection, 0); RenderUtils.CheckGLError("DrawMesh:upload matrix"); // finally draw the teapot GLES20.GlDrawElements(GLES20.GlTriangles, mIndices_Number, GLES20.GlUnsignedShort, mIndex_Buffer); RenderUtils.CheckGLError("DrawMesh:draw elements"); // disable the enabled arrays GLES20.GlDisableVertexAttribArray(vertexHandle); //GLES20.GlDisableVertexAttribArray(normalHandle); GLES20.GlDisableVertexAttribArray(textureCoordHandle); RenderUtils.CheckGLError("DrawMesh:disable attrib arrays"); }
/// <summary> /// Draw face geometrical features. This method is called on each frame. /// </summary> private void DrawFaceGeometry() { ShaderUtil.CheckGlError(TAG, "Before draw."); Log.Debug(TAG, "Draw face geometry: mPointsNum: " + mPointsNum + " mTrianglesNum: " + mTrianglesNum); GLES20.GlActiveTexture(GLES20.GlTexture0); GLES20.GlBindTexture(GLES20.GlTexture2d, mTextureName); GLES20.GlUniform1i(mTextureUniform, 0); ShaderUtil.CheckGlError(TAG, "Init texture."); GLES20.GlEnable(GLES20.GlDepthTest); GLES20.GlEnable(GL_CULL_FACE_CONSTANT); // Draw point. GLES20.GlUseProgram(mProgram); ShaderUtil.CheckGlError(TAG, "Draw point."); GLES20.GlEnableVertexAttribArray(mPositionAttribute); GLES20.GlEnableVertexAttribArray(mTextureCoordAttribute); GLES20.GlEnableVertexAttribArray(mColorUniform); GLES20.GlBindBuffer(GLES20.GlArrayBuffer, mVerticeId); GLES20.GlVertexAttribPointer(mPositionAttribute, POSITION_COMPONENTS_NUMBER, GLES20.GlFloat, false, BYTES_PER_POINT, 0); GLES20.GlVertexAttribPointer(mTextureCoordAttribute, TEXCOORD_COMPONENTS_NUMBER, GLES20.GlFloat, false, BYTES_PER_COORD, 0); GLES20.GlUniform4f(mColorUniform, 1.0f, 0.0f, 0.0f, 1.0f); GLES20.GlUniformMatrix4fv(mModelViewProjectionUniform, 1, false, mModelViewProjections, 0); GLES20.GlUniform1f(mPointSizeUniform, 5.0f); // Set the size of Point to 5. GLES20.GlDrawArrays(GLES20.GlPoints, 0, mPointsNum); GLES20.GlDisableVertexAttribArray(mColorUniform); GLES20.GlBindBuffer(GLES20.GlArrayBuffer, 0); ShaderUtil.CheckGlError(TAG, "Draw point."); // Draw triangles. GLES20.GlEnableVertexAttribArray(mColorUniform); // Clear the color and use the texture color to draw triangles. GLES20.GlUniform4f(mColorUniform, 0.0f, 0.0f, 0.0f, 0.0f); GLES20.GlBindBuffer(GLES20.GlElementArrayBuffer, mTriangleId); // The number of input triangle points GLES20.GlDrawElements(GLES20.GlTriangles, mTrianglesNum * 3, GLES20.GlUnsignedInt, 0); GLES20.GlBindBuffer(GLES20.GlElementArrayBuffer, 0); GLES20.GlDisableVertexAttribArray(mColorUniform); ShaderUtil.CheckGlError(TAG, "Draw triangles."); GLES20.GlDisableVertexAttribArray(mTextureCoordAttribute); GLES20.GlDisableVertexAttribArray(mPositionAttribute); GLES20.GlBindTexture(GLES20.GlTexture2d, 0); GLES20.GlDisable(GLES20.GlDepthTest); GLES20.GlDisable(GL_CULL_FACE_CONSTANT); ShaderUtil.CheckGlError(TAG, "Draw after."); }
/// <summary> /// Draw a virtual object at a specific location on a specified plane. /// This method is called when WorldRenderManager's OnDrawFrame. /// </summary> /// <param name="cameraView">The viewMatrix is a 4 * 4 matrix.</param> /// <param name="cameraProjection">The ProjectionMatrix is a 4 * 4 matrix.</param> /// <param name="lightIntensity">The lighting intensity.</param> /// <param name="obj">The virtual object.</param> public void OnDrawFrame(float[] cameraView, float[] cameraProjection, float lightIntensity, VirtualObject obj) { ShaderUtil.CheckGlError(TAG, "onDrawFrame start."); mModelMatrixs = obj.GetModelAnchorMatrix(); Matrix.MultiplyMM(mModelViewMatrixs, 0, cameraView, 0, mModelMatrixs, 0); Matrix.MultiplyMM(mModelViewProjectionMatrixs, 0, cameraProjection, 0, mModelViewMatrixs, 0); GLES20.GlUseProgram(mGlProgram); Matrix.MultiplyMV(mViewLightDirections, 0, mModelViewMatrixs, 0, LIGHT_DIRECTIONS, 0); MatrixUtil.NormalizeVec3(mViewLightDirections); // Light direction. GLES20.GlUniform4f(mLightingParametersUniform, mViewLightDirections[0], mViewLightDirections[1], mViewLightDirections[2], lightIntensity); float[] objColors = obj.GetColor(); GLES20.GlUniform4fv(mColorUniform, 1, objColors, 0); GLES20.GlActiveTexture(GLES20.GlTexture0); GLES20.GlBindTexture(GLES20.GlTexture2d, mTextures[0]); GLES20.GlUniform1i(mTextureUniform, 0); GLES20.GlBindBuffer(GLES20.GlArrayBuffer, mVertexBufferId); // The coordinate dimension of the read virtual object is 3. GLES20.GlVertexAttribPointer( mPositionAttribute, 3, GLES20.GlFloat, false, 0, 0); // The dimension of the normal vector is 3. GLES20.GlVertexAttribPointer( mNormalAttribute, 3, GLES20.GlFloat, false, 0, mNormalsBaseAddress); // The dimension of the texture coordinate is 2. GLES20.GlVertexAttribPointer( mTexCoordAttribute, 2, GLES20.GlFloat, false, 0, mTexCoordsBaseAddress); GLES20.GlBindBuffer(GLES20.GlArrayBuffer, 0); GLES20.GlUniformMatrix4fv( mModelViewUniform, 1, false, mModelViewMatrixs, 0); GLES20.GlUniformMatrix4fv( mModelViewProjectionUniform, 1, false, mModelViewProjectionMatrixs, 0); GLES20.GlEnableVertexAttribArray(mPositionAttribute); GLES20.GlEnableVertexAttribArray(mNormalAttribute); GLES20.GlEnableVertexAttribArray(mTexCoordAttribute); GLES20.GlBindBuffer(GLES20.GlElementArrayBuffer, mIndexBufferId); GLES20.GlDrawElements(GLES20.GlTriangles, mIndexCount, GLES20.GlUnsignedShort, 0); GLES20.GlBindBuffer(GLES20.GlElementArrayBuffer, 0); GLES20.GlDisableVertexAttribArray(mPositionAttribute); GLES20.GlDisableVertexAttribArray(mNormalAttribute); GLES20.GlDisableVertexAttribArray(mTexCoordAttribute); GLES20.GlBindTexture(GLES20.GlTexture2d, 0); ShaderUtil.CheckGlError(TAG, "onDrawFrame end."); }
/** * Draws the AR background image. The image will be drawn such that virtual content rendered * with the matrices provided by {@link Frame#getViewMatrix(float[], int)} and * {@link Session#getProjectionMatrix(float[], int, float, float)} will accurately follow * static physical objects. This must be called <b>before</b> drawing virtual content. * * @param frame The last {@code Frame} returned by {@link Session#update()}. */ public void Draw(Frame frame) { // If display rotation changed (also includes view size change), we need to re-query the uv // coordinates for the screen rect, as they may have changed as well. if (frame.HasDisplayGeometryChanged) { frame.TransformDisplayUvCoords(mQuadTexCoord, mQuadTexCoordTransformed); } // No need to test or write depth, the screen quad has arbitrary depth, and is expected // to be drawn first. GLES20.GlDisable(GLES20.GlDepthTest); GLES20.GlDepthMask(false); 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); GLES20.GlUseProgram(mQuadProgram); // Set the vertex positions. GLES20.GlVertexAttribPointer( mQuadPositionParam, COORDS_PER_VERTEX, GLES20.GlFloat, false, 0, mQuadVertices); // Set the texture coordinates. GLES20.GlVertexAttribPointer(mQuadTexCoordParam, TEXCOORDS_PER_VERTEX, GLES20.GlFloat, false, 0, mQuadTexCoordTransformed); // Enable vertex arrays GLES20.GlEnableVertexAttribArray(mQuadPositionParam); GLES20.GlEnableVertexAttribArray(mQuadTexCoordParam); GLES20.GlDrawArrays(GLES20.GlTriangleStrip, 0, 4); // Disable vertex arrays GLES20.GlDisableVertexAttribArray(mQuadPositionParam); GLES20.GlDisableVertexAttribArray(mQuadTexCoordParam); // Restore the depth state for further drawing. GLES20.GlDepthMask(true); GLES20.GlEnable(GLES20.GlDepthTest); ShaderUtil.CheckGLError(TAG, "Draw"); }
private void Render(float[] matrix) { // clear Screen and Depth Buffer, we have set the clear color as black. GLES20.GlClear(GLES20.GlColorBufferBit | GLES20.GlDepthBufferBit); // get handle to vertex shader's vPosition member int positionHandle = GLES20.GlGetAttribLocation(ShaderHelper.SpImage, "vPosition"); // Enable generic vertex attribute array GLES20.GlEnableVertexAttribArray(positionHandle); // Prepare the triangle coordinate data GLES20.GlVertexAttribPointer(positionHandle, 3, GLES20.GlFloat, false, 0, vertexBuffer); // Get handle to texture coordinates location int textureCoordinatesLocation = GLES20.GlGetAttribLocation(ShaderHelper.SpImage, "a_texCoord"); // Enable generic vertex attribute array GLES20.GlEnableVertexAttribArray(textureCoordinatesLocation); // Prepare the texturecoordinates GLES20.GlVertexAttribPointer(textureCoordinatesLocation, 2, GLES20.GlFloat, false, 0, uvBuffer); // Get handle to shape's transformation matrix int matrixhandle = GLES20.GlGetUniformLocation(ShaderHelper.SpImage, "uMVPMatrix"); // Apply the projection and view transformation GLES20.GlUniformMatrix4fv(matrixhandle, 1, false, matrix, 0); // Get handle to textures locations int samplerLocation = GLES20.GlGetUniformLocation(ShaderHelper.SpImage, "s_texture"); // Set the sampler texture unit to 0, where we have saved the texture. GLES20.GlUniform1i(samplerLocation, 0); // Draw the triangle GLES20.GlDrawElements(GLES20.GlTriangles, indices.Length, GLES20.GlUnsignedShort, drawListBuffer); // Disable vertex array GLES20.GlDisableVertexAttribArray(positionHandle); GLES20.GlDisableVertexAttribArray(textureCoordinatesLocation); }
/// <summary> /// Render each frame. /// This method is called when Android.Opengl.GLSurfaceView.IRenderer's OnDrawFrame. /// </summary> /// <param name="frame">ARFrame</param> public void OnDrawFrame(ARFrame frame) { ShaderUtil.CheckGlError(TAG, "On draw frame start."); if (frame == null) { return; } if (frame.HasDisplayGeometryChanged) { frame.TransformDisplayUvCoords(mTexBuffer, mTexTransformedBuffer); } Clear(); GLES20.GlDisable(GLES20.GlDepthTest); GLES20.GlDepthMask(false); GLES20.GlUseProgram(mProgram); // Set the texture ID. GLES20.GlBindTexture(GLES11Ext.GlTextureExternalOes, mExternalTextureId); // Set the projection matrix. GLES20.GlUniformMatrix4fv(mMatrix, 1, false, mProjectionMatrix, 0); GLES20.GlUniformMatrix4fv(mCoordMatrix, 1, false, coordMatrixs, 0); // Set the vertex. GLES20.GlEnableVertexAttribArray(mPosition); GLES20.GlVertexAttribPointer(mPosition, 2, GLES20.GlFloat, false, 0, mVerBuffer); // Set the texture coordinates. GLES20.GlEnableVertexAttribArray(mCoord); GLES20.GlVertexAttribPointer(mCoord, 2, GLES20.GlFloat, false, 0, mTexTransformedBuffer); // Number of vertices. GLES20.GlDrawArrays(GLES20.GlTriangleStrip, 0, 4); GLES20.GlDisableVertexAttribArray(mPosition); GLES20.GlDisableVertexAttribArray(mCoord); GLES20.GlDepthMask(true); GLES20.GlEnable(GLES20.GlDepthTest); ShaderUtil.CheckGlError(TAG, "On draw frame end."); }
private void DrawSortedPlans(List <ARPlane> sortedPlanes, float[] cameraViews, float[] cameraProjection) { ShaderUtil.CheckGlError(TAG, "Draw sorted plans start."); GLES20.GlDepthMask(false); GLES20.GlEnable(GLES20.GlBlend); GLES20.GlBlendFuncSeparate( GLES20.GlDstAlpha, GLES20.GlOne, GLES20.GlZero, GLES20.GlOneMinusSrcAlpha); GLES20.GlUseProgram(mProgram); GLES20.GlEnableVertexAttribArray(glPositionParameter); foreach (ARPlane plane in sortedPlanes) { float[] planeMatrix = new float[MATRIX_SIZE]; plane.CenterPose.ToMatrix(planeMatrix, 0); Array.Copy(planeMatrix, modelMatrix, MATRIX_SIZE); float scaleU = 1.0f / LABEL_WIDTH; // Set the value of the plane angle uv matrix. planeAngleUvMatrix[0] = scaleU; planeAngleUvMatrix[1] = 0.0f; planeAngleUvMatrix[2] = 0.0f; float scaleV = 1.0f / LABEL_HEIGHT; planeAngleUvMatrix[3] = scaleV; int idx = plane.Label.Ordinal(); Log.Debug(TAG, "Plane getLabel:" + idx); idx = Java.Lang.Math.Abs(idx); GLES20.GlActiveTexture(GLES20.GlTexture0 + idx); GLES20.GlBindTexture(GLES20.GlTexture2d, textures[idx]); GLES20.GlUniform1i(glTexture, idx); GLES20.GlUniformMatrix2fv(glPlaneUvMatrix, 1, false, planeAngleUvMatrix, 0); DrawLabel(cameraViews, cameraProjection); } GLES20.GlDisableVertexAttribArray(glPositionParameter); GLES20.GlBindTexture(GLES20.GlTexture2d, 0); GLES20.GlDisable(GLES20.GlBlend); GLES20.GlDepthMask(true); ShaderUtil.CheckGlError(TAG, "Draw sorted plans end."); }
void DrawCube() { // This is not the floor! GLES20.GlUniform1f(isFloorParam, 0f); // Set the Model in the shader, used to calculate lighting GLES20.GlUniformMatrix4fv(modelParam, 1, false, modelCube, 0); // Set the ModelView in the shader, used to calculate lighting GLES20.GlUniformMatrix4fv(modelViewParam, 1, false, modelView, 0); // Set the position of the cube GLES20.GlVertexAttribPointer(positionParam, CoordsPerVertex, GLES20.GlFloat, false, 0, cubeVertices); // Set the ModelViewProjection matrix in the shader. GLES20.GlUniformMatrix4fv(modelViewProjectionParam, 1, false, modelViewProjection, 0); // Set the normal positions of the cube, again for shading GLES20.GlVertexAttribPointer(normalParam, 3, GLES20.GlFloat, false, 0, cubeNormals); // Disable color for cube GLES20.GlDisableVertexAttribArray(colorParam); // Set the texture coordinates GLES20.GlVertexAttribPointer(texCoordParam, 2, GLES20.GlFloat, false, 0, cubeTextureCoords); GLES20.GlActiveTexture(GLES20.GlTexture0); if (IsLookingAtObject) { GLES20.GlBindTexture(GLES20.GlTexture2d, monkeyFound); } else { GLES20.GlBindTexture(GLES20.GlTexture2d, monkeyNotFound); } GLES20.GlUniform1i(texture, 0); GLES20.GlDrawArrays(GLES20.GlTriangles, 0, 36); CheckGlError("Drawing cube"); }
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)); }
/** * Encapsulates the OpenGL ES instructions for drawing this shape. * * @param mvpMatrix - The Model View Project matrix in which to draw * this shape. */ public void draw(float[] mvpMatrix) { // Add program to OpenGL environment GLES20.GlUseProgram(mProgram); // get handle to vertex shader's vPosition member mPositionHandle = GLES20.GlGetAttribLocation(mProgram, "vPosition"); // Enable a handle to the triangle vertices GLES20.GlEnableVertexAttribArray(mPositionHandle); // Prepare the triangle coordinate data GLES20.GlVertexAttribPointer( mPositionHandle, COORDS_PER_VERTEX, GLES20.GlFloat, false, vertexStride, vertexBuffer); // get handle to fragment shader's vColor member mColorHandle = GLES20.GlGetUniformLocation(mProgram, "vColor"); // Set color for drawing the triangle GLES20.GlUniform4fv(mColorHandle, 1, color, 0); // get handle to shape's transformation matrix mMVPMatrixHandle = GLES20.GlGetUniformLocation(mProgram, "uMVPMatrix"); MainRenderer.checkGlError("glGetUniformLocation"); // Apply the projection and view transformation GLES20.GlUniformMatrix4fv(mMVPMatrixHandle, 1, false, mvpMatrix, 0); MainRenderer.checkGlError("glUniformMatrix4fv"); // Draw the triangle GLES20.GlDrawArrays(GLES20.GlTriangles, 0, vertexCount); // Disable vertex array GLES20.GlDisableVertexAttribArray(mPositionHandle); }
/// <summary> /// Draw hand skeleton points. /// </summary> /// <param name="projectionMatrix">Projection matrix.</param> private void DrawHandSkeletons(float[] projectionMatrix) { ShaderUtil.CheckGlError(TAG, "Draw hand skeletons start."); GLES20.GlUseProgram(mProgram); GLES20.GlEnableVertexAttribArray(mPosition); GLES20.GlBindBuffer(GLES20.GlArrayBuffer, mVbo); // The size of the vertex attribute is 4, and each vertex has four coordinate components GLES20.GlVertexAttribPointer( mPosition, 4, GLES20.GlFloat, false, BYTES_PER_POINT, 0); // Set the color of the skeleton points to blue. GLES20.GlUniform4f(mColor, 0.0f, 0.0f, 1.0f, 1.0f); GLES20.GlUniformMatrix4fv(mModelViewProjectionMatrix, 1, false, projectionMatrix, 0); // Set the size of the skeleton points. GLES20.GlUniform1f(mPointSize, 30.0f); GLES20.GlDrawArrays(GLES20.GlPoints, 0, mNumPoints); GLES20.GlDisableVertexAttribArray(mPosition); GLES20.GlBindBuffer(GLES20.GlArrayBuffer, 0); ShaderUtil.CheckGlError(TAG, "Draw hand skeletons end."); }
/** * \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); }
/** * 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"); }
/** * 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"); }
public virtual void disable() { GLES20.GlDisableVertexAttribArray(_Location); }