To go to the previous page, click on the following link: Virtual reality cardboard messenger - Part 1

Step 13: The following models have been defined in the class file which has come into effect are as follows:

Shader Model : Create shaders to render the scene: Firstly create a raw folder in res folder.Create a .shader files-

gauss_fragment.shader-

 precision mediump float;
 uniform sampler2D uTexture0;
 uniform vec4 uTexCoef0;
 uniform vec4 uTexCoef1;
 uniform vec4 uTexCoef2;
 uniform vec4 uTexCoef3;
 varying vec4 TexCoord0;
 varying vec4 TexCoord1;
 varying vec4 TexCoord2;
 varying vec4 TexCoord3;
 void main() {
 vec4 c0 = texture2D(uTexture0, TexCoord0.xy); 
 vec4 c1 = texture2D(uTexture0, TexCoord1.xy);
 vec4 c2 = texture2D(uTexture0, TexCoord2.xy);
 vec4 c3 = texture2D(uTexture0, TexCoord3.xy);
 gl_FragColor = uTexCoef0 * c0 + uTexCoef1 * c1 + uTexCoef2 * c2 + uTexCoef3 * c3; }

gauss_vertex.shader-

 precision mediump float;
 attribute vec4 vPosition;
 attribute vec4 vTexCoord0;
 uniform vec4 uTexOffset0;
 uniform vec4 uTexOffset1;
 uniform vec4 uTexOffset2;
 uniform vec4 uTexOffset3;
 varying vec4 TexCoord0;
 varying vec4 TexCoord1;
 varying vec4 TexCoord2;
 varying vec4 TexCoord3;
 void main() {
 gl_Position = vPosition; TexCoord0 = vTexCoord0 + uTexOffset0;
 TexCoord1 = vTexCoord0 + uTexOffset1;
 TexCoord2 = vTexCoord0 + uTexOffset2;
 TexCoord3 = vTexCoord0 + uTexOffset3;
 }

lighting_fragment.shader-
 precision mediump float;
 varying vec4 FrontColor;
 void main() {
 gl_FragColor = FrontColor;
}

lighting_vertex.shader-
 precision mediump float;
 uniform mat4 uMVPMatrix;
 uniform vec4 uAmbient;
 uniform vec4 uDiffuse;
 const int MaxLights = 8;
 struct LightSourceParameters {
 vec4 color;
 vec3 position;
 };
 uniform LightSourceParameters uLight[MaxLights];
 attribute vec4 vPosition;
 attribute vec3 vNormal;
 varying vec4 FrontColor;
 void main() {
 gl_Position = uMVPMatrix * vPosition;
 vec4 vcolor = uAmbient;
 int i; for (i = 0; i < MaxLights; i++) {
 vec3 vert2light = uLight[i].position - vPosition.xyz;
 vec3 ldir = normalize(vert2light);
 float NdotL = dot(vNormal, ldir);
 if (NdotL > 0.0) { vcolor += uLight[i].color * uDiffuse * NdotL;
 } }
 FrontColor = clamp(vcolor, 0.0, 1.0);
 }
particle_fragment.shader-
precision mediump float;
uniform sampler2D uTexture0;
 varying vec4 Color;
 void main() {
 gl_FragColor = texture2D(uTexture0, gl_PointCoord) * Color;
 }
 particle_vertex.shader-
 precision mediump float;
 attribute vec4 vPosition;
 attribute float vSizeShift;
 uniform float uPointSize;
 uniform float uTime;
 uniform vec4 uColor;
 varying vec4 Color;
 void main() {
 float Phase = abs(fract(uTime + vSizeShift) * 2.0 - 1.0);
 vec4 pColor = uColor; if (Phase > 0.75) {
 pColor.z = (Phase - 0.75) * 4.0;
 };
 Color = pColor; gl_PointSize = uPointSize * Phase;
 gl_Position = vPosition;
}
quad_fragment.shader-
precision mediump float;
 uniform sampler2D uTexture0;
 varying vec4 TexCoord0;
 void main() {
 gl_FragColor = texture2D(uTexture0, TexCoord0.xy);
}
quad_vertex.shader-
precision mediump float;
 attribute vec4 vPosition;
attribute vec4 vTexCoord0;
 varying vec4 TexCoord0;
 void main() {
 gl_Position = vPosition; TexCoord0 = vTexCoord0;
}

The shader has been created and compiled to determine the location of the attributes: Compile them, determines the location of attributes:

Details on the work of these shaders will not dwell: and so trivial fragment and vertex implements regular work with omni-directional light sources.
Drawing model : It is assumed that we are ready to transform matrix Model, View and Projection (I, for one, rosette smoothly rotated). Of the product of Model-View allocate only a turn, it is necessary to work with normals. Drawing is simple and pleasant, take the previously created buffers, assign attributes, draw. It is worth noting that the coordinates of the light sources are transferred to the eye-space, for they are multiplied by View-matrix. Using Scene3D class.

The result was a scene rendering function without the texture, but the materials and the eight light sources. Actually, this particular scene, and even on such a small screen, textures no longer happening, and so looks good. But I still want to glow! Now - the most interesting thing: to render the scene to a texture.

Quad Quad we need, first, to apply a Gaussian blur to otrenderёnnoy advance stage, and secondly, to impose a final "glow" to the stage.
Creating Quad Cooking tops and texture coordinates, create a buffer, shader compile - all the same as the model, except that the shaders become even simpler:
              muQTexture = GLES20.glGetUniformLocation(mQProgram, "uTexture0");  

Preparation of texture buffers Create just two buffer size 256x256, this should be done as a function of onSurfaceChanged.
}

Every texture buffer connected two variables: the actual texture and frame buffer (sorry for tautology).
Quad rendering of textures / texture in Just a couple of functions: one sets the current source and target drawing (0 - this is our shield, and the rest - previously created frame buffers), the second draws quad.

Since the effect will be imposed in several passes, the texture performance reasons we have low resolution, so that the result of its draw on the Quad will be similar to something like the image below.Phew! You're quite a bit: a couple of shaders and several blocks of code!

Gaussian Blur: Dimensional blur here implemented as follows: for each point taken our frame 44 adjacent pixels, and their colors are added with different weights according to a Gaussian distribution. To do so we will be in 11 passes, each of which in the resulting image will be added to 4 pixels of the original scene. Respectively, shaders arranged to apply to four textures per pass, with different displacements. Of course, you can make and fewer passes, here we must look to your taste and how many will be able to pull it acceptable performance hardware on which you plan to run the program. The effect is applied in two phases: horizontal and vertical. We need to find something in advance. Auxiliary data Gauss-

Counted at the end of the constant need to adjust the aspect ratio: screen, unlike the texture buffer, not square, so no such adjustment will be somewhat flattened glow.
Shaders Gauss -

Drawing Gauss - This function will perform blurring on the same axis either horizontally or vertically, and in several passes. That is why it was necessary two textures!
Putting it all together. The last step procedure rendering the entire frame, with all the effects. We must once again render the model, and then lay on her radiance.

Note- Once you get the CardboardView you associate it with a renderer, and then you associate the CardboardView with the activity. Cardboard supports two kinds of renderers, but the quickest way to get started is to use CardboardView.StereoRenderer, which is what the demo app uses. CardboardView.StereoRenderer includes these key methods:
onNewFrame(), called every time that app renders. onDrawEye(), called for each eye with different eye parameters. Implement onDrawEye() to perform per-eye configuration. This is the meat of the rendering code, and very similar to building a regular OpenGL ES2 application. The following snippet shows how to get the view transformation matrix, and also the perspective transformation matrix. You need to make sure that you render with low latency. The Eye object contains the transformation and projection matrices for the eye. This is the sequence of events: The treasure comes into eye space. We apply the projection matrix. This provides the scene rendered for the specified eye. The Cardboard SDK applies distortion automatically, to render the final scene.

Step 15: Draw Text using following code-

Step 16: Now, how to use magnet – To provide custom behavior when the user pulls the magnet, override CardboardActivity.onCardboardTrigger() in your app's activity. Call the text message on trigger event.

Total:
 1. Draw the scene in the first texture;
 2. For the first texture makes horizontal blur, store the result in the second;
 3. Second texture blur vertically stored in the first;
 4. Draw the scene as usual;
 5. Impose the first texture over a scene using the quad;
 6. Text has been showcased on the click of a magnet.
 7. Done! Actually, the stage can be drawn once and only on the texture directly copying it into the     screen buffer at the beginning of using the quad. However, to ensure a decent quality image texture that would require the same resolution as the screen itself, and this is considerably slow down its blur. By the way, the resulting program is a good benchmark, although it rests mainly in fillrate.
Now, please go through the code as mentioned below: