java/Samples/src/com/android/samples/rsrenderstates.rs - fp2-dev/platform/frameworks/rs - Gitiles

 // Copyright (C) 2009 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #pragma version(1)

 #pragma rs java_package_name(com.android.samples)

 #include "rs_graphics.rsh"
 #include "shader_def.rsh"

 rs_program_vertex gProgVertex;
 rs_program_fragment gProgFragmentColor;
 rs_program_fragment gProgFragmentTexture;

 rs_program_store gProgStoreBlendNoneDepth;
 rs_program_store gProgStoreBlendNone;
 rs_program_store gProgStoreBlendAlpha;
 rs_program_store gProgStoreBlendAdd;

 rs_allocation gTexOpaque;
 rs_allocation gTexTorus;
 rs_allocation gTexTransparent;

 rs_mesh gMbyNMesh;
 rs_mesh gTorusMesh;

 rs_font gFontSans;
 rs_font gFontSerif;
 rs_font gFontSerifBold;
 rs_font gFontSerifItalic;
 rs_font gFontSerifBoldItalic;
 rs_font gFontMono;

 int gDisplayMode;

 rs_sampler gLinearClamp;
 rs_sampler gLinearWrap;
 rs_sampler gMipLinearWrap;
 rs_sampler gNearestClamp;

 rs_program_raster gCullBack;
 rs_program_raster gCullFront;

 // Custom vertex shader compunents
 VertexShaderConstants *gVSConstants;
 FragentShaderConstants *gFSConstants;
 // Export these out to easily set the inputs to shader
 VertexShaderInputs *gVSInputs;
 // Custom shaders we use for lighting
 rs_program_vertex gProgVertexCustom;
 rs_program_fragment gProgFragmentCustom;

 #pragma rs export_var(gProgVertex, gProgFragmentColor, gProgFragmentTexture)
 #pragma rs export_var(gProgStoreBlendNoneDepth, gProgStoreBlendNone, gProgStoreBlendAlpha, gProgStoreBlendAdd)
 #pragma rs export_var(gTexOpaque, gTexTorus, gTexTransparent)
 #pragma rs export_var(gMbyNMesh, gTorusMesh)
 #pragma rs export_var(gFontSans, gFontSerif, gFontSerifBold, gFontSerifItalic, gFontSerifBoldItalic, gFontMono)
 #pragma rs export_var(gLinearClamp, gLinearWrap, gMipLinearWrap, gNearestClamp)
 #pragma rs export_var(gCullBack, gCullFront)
 #pragma rs export_var(gVSConstants, gFSConstants, gVSInputs, gProgVertexCustom, gProgFragmentCustom)

 //What we are showing
 #pragma rs export_var(gDisplayMode)

 float gDt = 0;

 void init() {
 }

 void displayFontSamples() {
     rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);
     int yPos = 30;
     rsgBindFont(gFontSans);
     rsgDrawText("Sans font sample", 30, yPos);
     yPos += 30;
     rsgFontColor(0.5f, 0.9f, 0.5f, 1.0f);
     rsgBindFont(gFontSerif);
     rsgDrawText("Serif font sample", 30, yPos);
     yPos += 30;
     rsgFontColor(0.7f, 0.7f, 0.7f, 1.0f);
     rsgBindFont(gFontSerifBold);
     rsgDrawText("Serif Bold font sample", 30, yPos);
     yPos += 30;
     rsgFontColor(0.5f, 0.5f, 0.9f, 1.0f);
     rsgBindFont(gFontSerifItalic);
     rsgDrawText("Serif Italic font sample", 30, yPos);
     yPos += 30;
     rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);
     rsgBindFont(gFontSerifBoldItalic);
     rsgDrawText("Serif Bold Italic font sample", 30, yPos);
     yPos += 30;
     rsgBindFont(gFontMono);
     rsgDrawText("Monospace font sample", 30, yPos);
 }

 void bindProgramVertexOrtho() {
     // Default vertex sahder
     rsgBindProgramVertex(gProgVertex);
     // Setup the projectioni matrix
     rs_matrix4x4 proj;
     rsMatrixLoadOrtho(&proj, 0, rsgGetWidth(), rsgGetHeight(), 0, -1,1);
     rsgProgramVertexLoadProjectionMatrix(&proj);
 }

 void displayShaderSamples() {
     bindProgramVertexOrtho();
     rs_matrix4x4 matrix;
     rsMatrixLoadIdentity(&matrix);
     rsgProgramVertexLoadModelMatrix(&matrix);

     // Fragment shader with texture
     rsgBindProgramStore(gProgStoreBlendNone);
     rsgBindProgramFragment(gProgFragmentTexture);
     rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp);
     rsgBindTexture(gProgFragmentTexture, 0, gTexOpaque);

     float startX = 0, startY = 0;
     float width = 256, height = 256;
     rsgDrawQuadTexCoords(startX, startY, 0, 0, 0,
                          startX, startY + height, 0, 0, 1,
                          startX + width, startY + height, 0, 1, 1,
                          startX + width, startY, 0, 1, 0);

     startX = 200; startY = 0;
     width = 128; height = 128;
     rsgDrawQuadTexCoords(startX, startY, 0, 0, 0,
                          startX, startY + height, 0, 0, 1,
                          startX + width, startY + height, 0, 1, 1,
                          startX + width, startY, 0, 1, 0);

     rsgBindProgramStore(gProgStoreBlendAlpha);
     rsgBindTexture(gProgFragmentTexture, 0, gTexTransparent);
     startX = 0; startY = 200;
     width = 128; height = 128;
     rsgDrawQuadTexCoords(startX, startY, 0, 0, 0,
                          startX, startY + height, 0, 0, 1,
                          startX + width, startY + height, 0, 1, 1,
                          startX + width, startY, 0, 1, 0);

     // Fragment program with simple color
     rsgBindProgramFragment(gProgFragmentColor);
     rsgProgramFragmentConstantColor(gProgFragmentColor, 0.9, 0.3, 0.3, 1);
     rsgDrawRect(200, 300, 350, 450, 0);
     rsgProgramFragmentConstantColor(gProgFragmentColor, 0.3, 0.9, 0.3, 1);
     rsgDrawRect(50, 400, 400, 600, 0);

     rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);
     rsgBindFont(gFontMono);
     rsgDrawText("Texture shader", 10, 50);
     rsgDrawText("Alpha-blended texture shader", 10, 280);
     rsgDrawText("Flat color shader", 100, 450);
 }

 void displayBlendingSamples() {
     int i;

     bindProgramVertexOrtho();
     rs_matrix4x4 matrix;
     rsMatrixLoadIdentity(&matrix);
     rsgProgramVertexLoadModelMatrix(&matrix);

     rsgBindProgramFragment(gProgFragmentColor);

     rsgBindProgramStore(gProgStoreBlendNone);
     for(i = 0; i < 3; i ++) {
         float iPlusOne = (float)(i + 1);
         rsgProgramFragmentConstantColor(gProgFragmentColor,
                                         0.1f*iPlusOne, 0.2f*iPlusOne, 0.3f*iPlusOne, 1);
         float yPos = 150 * (float)i;
         rsgDrawRect(0, yPos, 200, yPos + 200, 0);
     }

     rsgBindProgramStore(gProgStoreBlendAlpha);
     for(i = 0; i < 3; i ++) {
         float iPlusOne = (float)(i + 1);
         rsgProgramFragmentConstantColor(gProgFragmentColor,
                                         0.2f*iPlusOne, 0.3f*iPlusOne, 0.1f*iPlusOne, 0.5);
         float yPos = 150 * (float)i;
         rsgDrawRect(150, yPos, 350, yPos + 200, 0);
     }

     rsgBindProgramStore(gProgStoreBlendAdd);
     for(i = 0; i < 3; i ++) {
         float iPlusOne = (float)(i + 1);
         rsgProgramFragmentConstantColor(gProgFragmentColor,
                                         0.3f*iPlusOne, 0.1f*iPlusOne, 0.2f*iPlusOne, 0.5);
         float yPos = 150 * (float)i;
         rsgDrawRect(300, yPos, 500, yPos + 200, 0);
     }


     rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);
     rsgBindFont(gFontMono);
     rsgDrawText("No Blending", 10, 50);
     rsgDrawText("Alpha Blending", 160, 150);
     rsgDrawText("Additive Blending", 320, 250);

 }

 void displayMeshSamples() {

     bindProgramVertexOrtho();
     rs_matrix4x4 matrix;
     rsMatrixLoadTranslate(&matrix, 128, 128, 0);
     rsgProgramVertexLoadModelMatrix(&matrix);

     // Fragment shader with texture
     rsgBindProgramStore(gProgStoreBlendNone);
     rsgBindProgramFragment(gProgFragmentTexture);
     rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp);
     rsgBindTexture(gProgFragmentTexture, 0, gTexOpaque);

     rsgDrawMesh(gMbyNMesh);

     rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);
     rsgBindFont(gFontMono);
     rsgDrawText("User gen 10 by 10 grid mesh", 10, 250);
 }

 void displayTextureSamplers() {

     bindProgramVertexOrtho();
     rs_matrix4x4 matrix;
     rsMatrixLoadIdentity(&matrix);
     rsgProgramVertexLoadModelMatrix(&matrix);

     // Fragment shader with texture
     rsgBindProgramStore(gProgStoreBlendNone);
     rsgBindProgramFragment(gProgFragmentTexture);
     rsgBindTexture(gProgFragmentTexture, 0, gTexOpaque);

     // Linear clamp
     rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp);
     float startX = 0, startY = 0;
     float width = 300, height = 300;
     rsgDrawQuadTexCoords(startX, startY, 0, 0, 0,
                          startX, startY + height, 0, 0, 1.1,
                          startX + width, startY + height, 0, 1.1, 1.1,
                          startX + width, startY, 0, 1.1, 0);

     // Linear Wrap
     rsgBindSampler(gProgFragmentTexture, 0, gLinearWrap);
     startX = 0; startY = 300;
     width = 300; height = 300;
     rsgDrawQuadTexCoords(startX, startY, 0, 0, 0,
                          startX, startY + height, 0, 0, 1.1,
                          startX + width, startY + height, 0, 1.1, 1.1,
                          startX + width, startY, 0, 1.1, 0);

     // Nearest
     rsgBindSampler(gProgFragmentTexture, 0, gNearestClamp);
     startX = 300; startY = 0;
     width = 300; height = 300;
     rsgDrawQuadTexCoords(startX, startY, 0, 0, 0,
                          startX, startY + height, 0, 0, 1.1,
                          startX + width, startY + height, 0, 1.1, 1.1,
                          startX + width, startY, 0, 1.1, 0);

     rsgBindSampler(gProgFragmentTexture, 0, gMipLinearWrap);
     startX = 300; startY = 300;
     width = 300; height = 300;
     rsgDrawQuadTexCoords(startX, startY, 0, 0, 0,
                          startX, startY + height, 0, 0, 1.5,
                          startX + width, startY + height, 0, 1.5, 1.5,
                          startX + width, startY, 0, 1.5, 0);


     rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);
     rsgBindFont(gFontMono);
     rsgDrawText("Filtering: linear clamp", 10, 290);
     rsgDrawText("Filtering: linear wrap", 10, 590);
     rsgDrawText("Filtering: nearest clamp", 310, 290);
     rsgDrawText("Filtering: miplinear wrap", 310, 590);

 }

 float gTorusRotation = 0;

 void displayCullingSamples() {
     rsgBindProgramVertex(gProgVertex);
     // Setup the projectioni matrix with 60 degree field of view
     rs_matrix4x4 proj;
     float aspect = (float)rsgGetWidth() / (float)rsgGetHeight();
     rsMatrixLoadPerspective(&proj, 30.0f, aspect, 0.1f, 100.0f);
     rsgProgramVertexLoadProjectionMatrix(&proj);

     // Fragment shader with texture
     rsgBindProgramStore(gProgStoreBlendNoneDepth);
     rsgBindProgramFragment(gProgFragmentTexture);
     rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp);
     rsgBindTexture(gProgFragmentTexture, 0, gTexTorus);

     // Aplly a rotation to our mesh
     gTorusRotation += 50.0f * gDt;
     if(gTorusRotation > 360.0f) {
         gTorusRotation -= 360.0f;
     }

     rs_matrix4x4 matrix;
     // Position our model on the screen
     rsMatrixLoadTranslate(&matrix, -2.0f, 0.0f, -10.0f);
     rsMatrixRotate(&matrix, gTorusRotation, 1.0f, 0.0f, 0.0f);
     rsgProgramVertexLoadModelMatrix(&matrix);
     // Use front face culling
     rsgBindProgramRaster(gCullFront);
     rsgDrawMesh(gTorusMesh);

     rsMatrixLoadTranslate(&matrix, 2.0f, 0.0f, -10.0f);
     rsMatrixRotate(&matrix, gTorusRotation, 1.0f, 0.0f, 0.0f);
     rsgProgramVertexLoadModelMatrix(&matrix);
     // Use back face culling
     rsgBindProgramRaster(gCullBack);
     rsgDrawMesh(gTorusMesh);

     rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);
     rsgBindFont(gFontMono);
     rsgDrawText("Displaying mesh front/back face culling", 10, rsgGetHeight() - 10);
 }

 float gLight0Rotation = 0;
 float gLight1Rotation = 0;

 void setupCustomShaderLights() {
     float4 light0Pos = {-5.0f, 5.0f, -10.0f, 1.0f};
     float4 light1Pos = {2.0f, 5.0f, 15.0f, 1.0f};
     float3 light0DiffCol = {0.9f, 0.7f, 0.7f};
     float3 light0SpecCol = {0.9f, 0.6f, 0.6f};
     float3 light1DiffCol = {0.5f, 0.5f, 0.9f};
     float3 light1SpecCol = {0.5f, 0.5f, 0.9f};

     gLight0Rotation += 50.0f * gDt;
     if(gLight0Rotation > 360.0f) {
         gLight0Rotation -= 360.0f;
     }
     gLight1Rotation -= 50.0f * gDt;
     if(gLight1Rotation > 360.0f) {
         gLight1Rotation -= 360.0f;
     }

     rs_matrix4x4 l0Mat;
     rsMatrixLoadRotate(&l0Mat, gLight0Rotation, 1.0f, 0.0f, 0.0f);
     light0Pos = rsMatrixMultiply(&l0Mat, light0Pos);
     rs_matrix4x4 l1Mat;
     rsMatrixLoadRotate(&l1Mat, gLight1Rotation, 0.0f, 0.0f, 1.0f);
     light1Pos = rsMatrixMultiply(&l1Mat, light1Pos);

     // Set light 0 properties
     gVSConstants->light0_Posision.x = light0Pos.x;
     gVSConstants->light0_Posision.y = light0Pos.y;
     gVSConstants->light0_Posision.z = light0Pos.z;
     gVSConstants->light0_Diffuse = 1.0f;
     gVSConstants->light0_Specular = 0.5f;
     gVSConstants->light0_CosinePower = 40.0f;
     // Set light 1 properties
     gVSConstants->light1_Posision.x = light1Pos.x;
     gVSConstants->light1_Posision.y = light1Pos.y;
     gVSConstants->light1_Posision.z = light1Pos.z;
     gVSConstants->light1_Diffuse = 1.0f;
     gVSConstants->light1_Specular = 0.7f;
     gVSConstants->light1_CosinePower = 50.0f;
     rsAllocationMarkDirty(rsGetAllocation(gVSConstants));

     // Update fragmetn shader constants
     // Set light 0 colors
     gFSConstants->light0_DiffuseColor = light0DiffCol;
     gFSConstants->light0_SpecularColor = light0SpecCol;
     // Set light 1 colors
     gFSConstants->light1_DiffuseColor = light1DiffCol;
     gFSConstants->light1_SpecularColor = light1SpecCol;
     rsAllocationMarkDirty(rsGetAllocation(gFSConstants));
 }

 void displayCustomShaderSamples() {

     // Update vertex shader constants
     // Load model matrix
     // Aplly a rotation to our mesh
     gTorusRotation += 50.0f * gDt;
     if(gTorusRotation > 360.0f) {
         gTorusRotation -= 360.0f;
     }

     // Position our model on the screen
     rsMatrixLoadTranslate(&gVSConstants->model, 0.0f, 0.0f, -10.0f);
     rsMatrixRotate(&gVSConstants->model, gTorusRotation, 1.0f, 0.0f, 0.0f);
     rsMatrixRotate(&gVSConstants->model, gTorusRotation, 0.0f, 0.0f, 1.0f);
     setupCustomShaderLights();

     rsgBindProgramVertex(gProgVertexCustom);
     // Setup the projectioni matrix with 60 degree field of view
     rs_matrix4x4 proj;
     float aspect = (float)rsgGetWidth() / (float)rsgGetHeight();
     rsMatrixLoadPerspective(&proj, 30.0f, aspect, 0.1f, 100.0f);
     rsgProgramVertexLoadProjectionMatrix(&proj);

     // Fragment shader with texture
     rsgBindProgramStore(gProgStoreBlendNoneDepth);
     rsgBindProgramFragment(gProgFragmentCustom);
     rsgBindSampler(gProgFragmentCustom, 0, gLinearClamp);
     rsgBindTexture(gProgFragmentCustom, 0, gTexTorus);

     // Use back face culling
     rsgBindProgramRaster(gCullBack);
     rsgDrawMesh(gTorusMesh);

     rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);
     rsgBindFont(gFontMono);
     rsgDrawText("Custom shader sample", 10, rsgGetHeight() - 10);
 }

 int root(int launchID) {

     gDt = rsGetDt();

     rsgClearColor(0.2f, 0.2f, 0.2f, 0.0f);
     rsgClearDepth(1.0f);

     switch(gDisplayMode) {
     case 0:
         displayFontSamples();
         break;
     case 1:
         displayShaderSamples();
         break;
     case 2:
         displayBlendingSamples();
         break;
     case 3:
         displayMeshSamples();
         break;
     case 4:
         displayTextureSamplers();
         break;
     case 5:
         displayCullingSamples();
         break;
     case 6:
         displayCustomShaderSamples();
         break;
     }

     return 10;
 }
	// Copyright (C) 2009 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#pragma version(1)

	#pragma rs java_package_name(com.android.samples)

	#include "rs_graphics.rsh"
	#include "shader_def.rsh"

	rs_program_vertex gProgVertex;
	rs_program_fragment gProgFragmentColor;
	rs_program_fragment gProgFragmentTexture;

	rs_program_store gProgStoreBlendNoneDepth;
	rs_program_store gProgStoreBlendNone;
	rs_program_store gProgStoreBlendAlpha;
	rs_program_store gProgStoreBlendAdd;

	rs_allocation gTexOpaque;
	rs_allocation gTexTorus;
	rs_allocation gTexTransparent;

	rs_mesh gMbyNMesh;
	rs_mesh gTorusMesh;

	rs_font gFontSans;
	rs_font gFontSerif;
	rs_font gFontSerifBold;
	rs_font gFontSerifItalic;
	rs_font gFontSerifBoldItalic;
	rs_font gFontMono;

	int gDisplayMode;

	rs_sampler gLinearClamp;
	rs_sampler gLinearWrap;
	rs_sampler gMipLinearWrap;
	rs_sampler gNearestClamp;

	rs_program_raster gCullBack;
	rs_program_raster gCullFront;

	// Custom vertex shader compunents
	VertexShaderConstants *gVSConstants;
	FragentShaderConstants *gFSConstants;
	// Export these out to easily set the inputs to shader
	VertexShaderInputs *gVSInputs;
	// Custom shaders we use for lighting
	rs_program_vertex gProgVertexCustom;
	rs_program_fragment gProgFragmentCustom;

	#pragma rs export_var(gProgVertex, gProgFragmentColor, gProgFragmentTexture)
	#pragma rs export_var(gProgStoreBlendNoneDepth, gProgStoreBlendNone, gProgStoreBlendAlpha, gProgStoreBlendAdd)
	#pragma rs export_var(gTexOpaque, gTexTorus, gTexTransparent)
	#pragma rs export_var(gMbyNMesh, gTorusMesh)
	#pragma rs export_var(gFontSans, gFontSerif, gFontSerifBold, gFontSerifItalic, gFontSerifBoldItalic, gFontMono)
	#pragma rs export_var(gLinearClamp, gLinearWrap, gMipLinearWrap, gNearestClamp)
	#pragma rs export_var(gCullBack, gCullFront)
	#pragma rs export_var(gVSConstants, gFSConstants, gVSInputs, gProgVertexCustom, gProgFragmentCustom)

	//What we are showing
	#pragma rs export_var(gDisplayMode)

	float gDt = 0;

	void init() {
	}

	void displayFontSamples() {
	rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);
	int yPos = 30;
	rsgBindFont(gFontSans);
	rsgDrawText("Sans font sample", 30, yPos);
	yPos += 30;
	rsgFontColor(0.5f, 0.9f, 0.5f, 1.0f);
	rsgBindFont(gFontSerif);
	rsgDrawText("Serif font sample", 30, yPos);
	yPos += 30;
	rsgFontColor(0.7f, 0.7f, 0.7f, 1.0f);
	rsgBindFont(gFontSerifBold);
	rsgDrawText("Serif Bold font sample", 30, yPos);
	yPos += 30;
	rsgFontColor(0.5f, 0.5f, 0.9f, 1.0f);
	rsgBindFont(gFontSerifItalic);
	rsgDrawText("Serif Italic font sample", 30, yPos);
	yPos += 30;
	rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);
	rsgBindFont(gFontSerifBoldItalic);
	rsgDrawText("Serif Bold Italic font sample", 30, yPos);
	yPos += 30;
	rsgBindFont(gFontMono);
	rsgDrawText("Monospace font sample", 30, yPos);
	}

	void bindProgramVertexOrtho() {
	// Default vertex sahder
	rsgBindProgramVertex(gProgVertex);
	// Setup the projectioni matrix
	rs_matrix4x4 proj;
	rsMatrixLoadOrtho(&proj, 0, rsgGetWidth(), rsgGetHeight(), 0, -1,1);
	rsgProgramVertexLoadProjectionMatrix(&proj);
	}

	void displayShaderSamples() {
	bindProgramVertexOrtho();
	rs_matrix4x4 matrix;
	rsMatrixLoadIdentity(&matrix);
	rsgProgramVertexLoadModelMatrix(&matrix);

	// Fragment shader with texture
	rsgBindProgramStore(gProgStoreBlendNone);
	rsgBindProgramFragment(gProgFragmentTexture);
	rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp);
	rsgBindTexture(gProgFragmentTexture, 0, gTexOpaque);

	float startX = 0, startY = 0;
	float width = 256, height = 256;
	rsgDrawQuadTexCoords(startX, startY, 0, 0, 0,
	startX, startY + height, 0, 0, 1,
	startX + width, startY + height, 0, 1, 1,
	startX + width, startY, 0, 1, 0);

	startX = 200; startY = 0;
	width = 128; height = 128;
	rsgDrawQuadTexCoords(startX, startY, 0, 0, 0,
	startX, startY + height, 0, 0, 1,
	startX + width, startY + height, 0, 1, 1,
	startX + width, startY, 0, 1, 0);

	rsgBindProgramStore(gProgStoreBlendAlpha);
	rsgBindTexture(gProgFragmentTexture, 0, gTexTransparent);
	startX = 0; startY = 200;
	width = 128; height = 128;
	rsgDrawQuadTexCoords(startX, startY, 0, 0, 0,
	startX, startY + height, 0, 0, 1,
	startX + width, startY + height, 0, 1, 1,
	startX + width, startY, 0, 1, 0);

	// Fragment program with simple color
	rsgBindProgramFragment(gProgFragmentColor);
	rsgProgramFragmentConstantColor(gProgFragmentColor, 0.9, 0.3, 0.3, 1);
	rsgDrawRect(200, 300, 350, 450, 0);
	rsgProgramFragmentConstantColor(gProgFragmentColor, 0.3, 0.9, 0.3, 1);
	rsgDrawRect(50, 400, 400, 600, 0);

	rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);
	rsgBindFont(gFontMono);
	rsgDrawText("Texture shader", 10, 50);
	rsgDrawText("Alpha-blended texture shader", 10, 280);
	rsgDrawText("Flat color shader", 100, 450);
	}

	void displayBlendingSamples() {
	int i;

	bindProgramVertexOrtho();
	rs_matrix4x4 matrix;
	rsMatrixLoadIdentity(&matrix);
	rsgProgramVertexLoadModelMatrix(&matrix);

	rsgBindProgramFragment(gProgFragmentColor);

	rsgBindProgramStore(gProgStoreBlendNone);
	for(i = 0; i < 3; i ++) {
	float iPlusOne = (float)(i + 1);
	rsgProgramFragmentConstantColor(gProgFragmentColor,
	0.1fiPlusOne, 0.2fiPlusOne, 0.3f*iPlusOne, 1);
	float yPos = 150 * (float)i;
	rsgDrawRect(0, yPos, 200, yPos + 200, 0);
	}

	rsgBindProgramStore(gProgStoreBlendAlpha);
	for(i = 0; i < 3; i ++) {
	float iPlusOne = (float)(i + 1);
	rsgProgramFragmentConstantColor(gProgFragmentColor,
	0.2fiPlusOne, 0.3fiPlusOne, 0.1f*iPlusOne, 0.5);
	float yPos = 150 * (float)i;
	rsgDrawRect(150, yPos, 350, yPos + 200, 0);
	}

	rsgBindProgramStore(gProgStoreBlendAdd);
	for(i = 0; i < 3; i ++) {
	float iPlusOne = (float)(i + 1);
	rsgProgramFragmentConstantColor(gProgFragmentColor,
	0.3fiPlusOne, 0.1fiPlusOne, 0.2f*iPlusOne, 0.5);
	float yPos = 150 * (float)i;
	rsgDrawRect(300, yPos, 500, yPos + 200, 0);
	}


	rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);
	rsgBindFont(gFontMono);
	rsgDrawText("No Blending", 10, 50);
	rsgDrawText("Alpha Blending", 160, 150);
	rsgDrawText("Additive Blending", 320, 250);

	}

	void displayMeshSamples() {

	bindProgramVertexOrtho();
	rs_matrix4x4 matrix;
	rsMatrixLoadTranslate(&matrix, 128, 128, 0);
	rsgProgramVertexLoadModelMatrix(&matrix);

	// Fragment shader with texture
	rsgBindProgramStore(gProgStoreBlendNone);
	rsgBindProgramFragment(gProgFragmentTexture);
	rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp);
	rsgBindTexture(gProgFragmentTexture, 0, gTexOpaque);

	rsgDrawMesh(gMbyNMesh);

	rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);
	rsgBindFont(gFontMono);
	rsgDrawText("User gen 10 by 10 grid mesh", 10, 250);
	}

	void displayTextureSamplers() {

	bindProgramVertexOrtho();
	rs_matrix4x4 matrix;
	rsMatrixLoadIdentity(&matrix);
	rsgProgramVertexLoadModelMatrix(&matrix);

	// Fragment shader with texture
	rsgBindProgramStore(gProgStoreBlendNone);
	rsgBindProgramFragment(gProgFragmentTexture);
	rsgBindTexture(gProgFragmentTexture, 0, gTexOpaque);

	// Linear clamp
	rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp);
	float startX = 0, startY = 0;
	float width = 300, height = 300;
	rsgDrawQuadTexCoords(startX, startY, 0, 0, 0,
	startX, startY + height, 0, 0, 1.1,
	startX + width, startY + height, 0, 1.1, 1.1,
	startX + width, startY, 0, 1.1, 0);

	// Linear Wrap
	rsgBindSampler(gProgFragmentTexture, 0, gLinearWrap);
	startX = 0; startY = 300;
	width = 300; height = 300;
	rsgDrawQuadTexCoords(startX, startY, 0, 0, 0,
	startX, startY + height, 0, 0, 1.1,
	startX + width, startY + height, 0, 1.1, 1.1,
	startX + width, startY, 0, 1.1, 0);

	// Nearest
	rsgBindSampler(gProgFragmentTexture, 0, gNearestClamp);
	startX = 300; startY = 0;
	width = 300; height = 300;
	rsgDrawQuadTexCoords(startX, startY, 0, 0, 0,
	startX, startY + height, 0, 0, 1.1,
	startX + width, startY + height, 0, 1.1, 1.1,
	startX + width, startY, 0, 1.1, 0);

	rsgBindSampler(gProgFragmentTexture, 0, gMipLinearWrap);
	startX = 300; startY = 300;
	width = 300; height = 300;
	rsgDrawQuadTexCoords(startX, startY, 0, 0, 0,
	startX, startY + height, 0, 0, 1.5,
	startX + width, startY + height, 0, 1.5, 1.5,
	startX + width, startY, 0, 1.5, 0);


	rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);
	rsgBindFont(gFontMono);
	rsgDrawText("Filtering: linear clamp", 10, 290);
	rsgDrawText("Filtering: linear wrap", 10, 590);
	rsgDrawText("Filtering: nearest clamp", 310, 290);
	rsgDrawText("Filtering: miplinear wrap", 310, 590);

	}

	float gTorusRotation = 0;

	void displayCullingSamples() {
	rsgBindProgramVertex(gProgVertex);
	// Setup the projectioni matrix with 60 degree field of view
	rs_matrix4x4 proj;
	float aspect = (float)rsgGetWidth() / (float)rsgGetHeight();
	rsMatrixLoadPerspective(&proj, 30.0f, aspect, 0.1f, 100.0f);
	rsgProgramVertexLoadProjectionMatrix(&proj);

	// Fragment shader with texture
	rsgBindProgramStore(gProgStoreBlendNoneDepth);
	rsgBindProgramFragment(gProgFragmentTexture);
	rsgBindSampler(gProgFragmentTexture, 0, gLinearClamp);
	rsgBindTexture(gProgFragmentTexture, 0, gTexTorus);

	// Aplly a rotation to our mesh
	gTorusRotation += 50.0f * gDt;
	if(gTorusRotation > 360.0f) {
	gTorusRotation -= 360.0f;
	}

	rs_matrix4x4 matrix;
	// Position our model on the screen
	rsMatrixLoadTranslate(&matrix, -2.0f, 0.0f, -10.0f);
	rsMatrixRotate(&matrix, gTorusRotation, 1.0f, 0.0f, 0.0f);
	rsgProgramVertexLoadModelMatrix(&matrix);
	// Use front face culling
	rsgBindProgramRaster(gCullFront);
	rsgDrawMesh(gTorusMesh);

	rsMatrixLoadTranslate(&matrix, 2.0f, 0.0f, -10.0f);
	rsMatrixRotate(&matrix, gTorusRotation, 1.0f, 0.0f, 0.0f);
	rsgProgramVertexLoadModelMatrix(&matrix);
	// Use back face culling
	rsgBindProgramRaster(gCullBack);
	rsgDrawMesh(gTorusMesh);

	rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);
	rsgBindFont(gFontMono);
	rsgDrawText("Displaying mesh front/back face culling", 10, rsgGetHeight() - 10);
	}

	float gLight0Rotation = 0;
	float gLight1Rotation = 0;

	void setupCustomShaderLights() {
	float4 light0Pos = {-5.0f, 5.0f, -10.0f, 1.0f};
	float4 light1Pos = {2.0f, 5.0f, 15.0f, 1.0f};
	float3 light0DiffCol = {0.9f, 0.7f, 0.7f};
	float3 light0SpecCol = {0.9f, 0.6f, 0.6f};
	float3 light1DiffCol = {0.5f, 0.5f, 0.9f};
	float3 light1SpecCol = {0.5f, 0.5f, 0.9f};

	gLight0Rotation += 50.0f * gDt;
	if(gLight0Rotation > 360.0f) {
	gLight0Rotation -= 360.0f;
	}
	gLight1Rotation -= 50.0f * gDt;
	if(gLight1Rotation > 360.0f) {
	gLight1Rotation -= 360.0f;
	}

	rs_matrix4x4 l0Mat;
	rsMatrixLoadRotate(&l0Mat, gLight0Rotation, 1.0f, 0.0f, 0.0f);
	light0Pos = rsMatrixMultiply(&l0Mat, light0Pos);
	rs_matrix4x4 l1Mat;
	rsMatrixLoadRotate(&l1Mat, gLight1Rotation, 0.0f, 0.0f, 1.0f);
	light1Pos = rsMatrixMultiply(&l1Mat, light1Pos);

	// Set light 0 properties
	gVSConstants->light0_Posision.x = light0Pos.x;
	gVSConstants->light0_Posision.y = light0Pos.y;
	gVSConstants->light0_Posision.z = light0Pos.z;
	gVSConstants->light0_Diffuse = 1.0f;
	gVSConstants->light0_Specular = 0.5f;
	gVSConstants->light0_CosinePower = 40.0f;
	// Set light 1 properties
	gVSConstants->light1_Posision.x = light1Pos.x;
	gVSConstants->light1_Posision.y = light1Pos.y;
	gVSConstants->light1_Posision.z = light1Pos.z;
	gVSConstants->light1_Diffuse = 1.0f;
	gVSConstants->light1_Specular = 0.7f;
	gVSConstants->light1_CosinePower = 50.0f;
	rsAllocationMarkDirty(rsGetAllocation(gVSConstants));

	// Update fragmetn shader constants
	// Set light 0 colors
	gFSConstants->light0_DiffuseColor = light0DiffCol;
	gFSConstants->light0_SpecularColor = light0SpecCol;
	// Set light 1 colors
	gFSConstants->light1_DiffuseColor = light1DiffCol;
	gFSConstants->light1_SpecularColor = light1SpecCol;
	rsAllocationMarkDirty(rsGetAllocation(gFSConstants));
	}

	void displayCustomShaderSamples() {

	// Update vertex shader constants
	// Load model matrix
	// Aplly a rotation to our mesh
	gTorusRotation += 50.0f * gDt;
	if(gTorusRotation > 360.0f) {
	gTorusRotation -= 360.0f;
	}

	// Position our model on the screen
	rsMatrixLoadTranslate(&gVSConstants->model, 0.0f, 0.0f, -10.0f);
	rsMatrixRotate(&gVSConstants->model, gTorusRotation, 1.0f, 0.0f, 0.0f);
	rsMatrixRotate(&gVSConstants->model, gTorusRotation, 0.0f, 0.0f, 1.0f);
	setupCustomShaderLights();

	rsgBindProgramVertex(gProgVertexCustom);
	// Setup the projectioni matrix with 60 degree field of view
	rs_matrix4x4 proj;
	float aspect = (float)rsgGetWidth() / (float)rsgGetHeight();
	rsMatrixLoadPerspective(&proj, 30.0f, aspect, 0.1f, 100.0f);
	rsgProgramVertexLoadProjectionMatrix(&proj);

	// Fragment shader with texture
	rsgBindProgramStore(gProgStoreBlendNoneDepth);
	rsgBindProgramFragment(gProgFragmentCustom);
	rsgBindSampler(gProgFragmentCustom, 0, gLinearClamp);
	rsgBindTexture(gProgFragmentCustom, 0, gTexTorus);

	// Use back face culling
	rsgBindProgramRaster(gCullBack);
	rsgDrawMesh(gTorusMesh);

	rsgFontColor(1.0f, 1.0f, 1.0f, 1.0f);
	rsgBindFont(gFontMono);
	rsgDrawText("Custom shader sample", 10, rsgGetHeight() - 10);
	}

	int root(int launchID) {

	gDt = rsGetDt();

	rsgClearColor(0.2f, 0.2f, 0.2f, 0.0f);
	rsgClearDepth(1.0f);

	switch(gDisplayMode) {
	case 0:
	displayFontSamples();
	break;
	case 1:
	displayShaderSamples();
	break;
	case 2:
	displayBlendingSamples();
	break;
	case 3:
	displayMeshSamples();
	break;
	case 4:
	displayTextureSamplers();
	break;
	case 5:
	displayCullingSamples();
	break;
	case 6:
	displayCustomShaderSamples();
	break;
	}

	return 10;
	}