OpenGL ES 3.0 Cookbook

OpenGL ES 3.0 Cookbook

By : Parminder Singh

Buy this Book

OpenGL ES 3.0 Cookbook

By: Parminder Singh

Buy this Book

Overview of this book

<p>"Write once, use anywhere" is truly the power behind OpenGL ES and has made it an embedded industry standard. The library provides cutting-edge, easy-to-use features to build a wide range of applications in the gaming, simulation, augmented-reality, image-processing, and geospatial domains.</p> <p>The book starts by providing you with all the necessary OpenGL ES 3.0 setup guidelines on iOS and Android platforms. You'll go on to master the fundamentals of modern 3D graphics, such as drawing APIs, transformations, buffer objects, the model-view-project analogy, and much more. The book goes on to deal with advanced topics and offers a wide range of recipes on the light shading, real-time rendering techniques with static and procedure textures to create stunning visualizations and runtime effects.</p>

OpenGL ES 3.0 Cookbook

Credits

About the Author

Acknowledgments

About the Reviewers

www.PacktPub.com

Preface

Free Chapter

OpenGL ES 3.0 on Android/iOS

Introduction

Programming shaders in OpenGL ES shading language 3.0

Loading and compiling a shader program

Linking a shader program

Checking errors in OpenGL ES 3.0

Using the per-vertex attribute to send data to a shader

Using uniform variables to send data to a shader

Programming OpenGL ES 3.0 Hello World Triangle

Using JNI on Android to communicate with C/C++

Developing an Android OpenGL ES 3.0 application

Developing an iOS OpenGL ES 3.0 application

OpenGL ES 3.0 Essentials

Introduction

Building prototypes using the GLPI framework

Implementing touch events

Rendering primitives with vertex arrays

Drawing APIs in OpenGL ES 3.0

Efficient rendering with Vertex Buffer Object

Transformations with the model, view, and projection analogies

Understanding the projection system in GLPI

Culling in OpenGL ES 3.0

Depth testing in OpenGL ES 3.0

New Features of OpenGL ES 3.0

Introduction

Managing variable attributes with qualifiers

Grouping uniforms and creating buffer objects

Managing VBO with Vertex Array Objects

Reading and writing buffer objects with mapping

Render multiple objects with geometry instancing

Rendering multiple primitives with primitive restart

Working with Meshes

Introduction

Creating polygon meshes with Blender

Rendering the wavefront OBJ mesh model

Rendering the 3Ds mesh model

Light and Materials

Introduction

Implementing the per-vertex ambient light component

Implementing the per-vertex diffuse light component

Implementing the per-vertex specular light component

Optimizing the specular light with the halfway vector

Gouraud shading – the per-vertex shading technique

Phong shading – the per-fragment shading technique

Implementing directional and point light

Implementing multiple lights in a scene

Implementing two-side shading

Working with Shaders

Introduction

Implementing the wobble and ripple effect

Procedural texture shading with object coordinates

Creating the circular pattern and making them revolve

Generating the brick pattern

Generating the polka dot pattern

Discarding fragments

Procedural texture shading with texture coordinates

Textures and Mapping Techniques

Introduction

Applying texture with UV mapping

Efficient rendering with the ETC2 compressed texture

Applying multiple textures

Implementing Skybox with seamless cube mapping

Implementing reflection and refraction with environment mapping

Implementing render to texture with Frame Buffer Objects

Implementing terrain with displacement mapping

Implementing bump mapping

Font Rendering

Introduction

Font rendering with the FreeType project

Rendering different languages with Harfbuzz

Rendering text on Head Up Display

Postscreen Processing and Image Effects

Introduction

Detecting scene edges with the Sobel operator

Making the scene blur with the Gaussian blur equation

Making a scene glow real time with the bloom effect

Painting the scene like a cartoon shading

Generating an embossed scene

Implementing grayscale and CMYK conversions

Implementing fisheye with barrel distortion

Implementing the binocular view with procedural texturing

Twirling the image

Sphere illusion with textured quadrilateral

Scene Management with Scene Graphs

Introduction

Implementing the first scene using a scene graph

Adding local and relative transformations

Adding parent-child support in the scene graph

Creating complex models with a transformation graph

Implementing picking with the ray trace technique

Implementing 2D textured button widgets

Navigating the scene with a camera system

Implementing the scene with multiple views

Anti-aliasing Techniques

Introduction

Understanding the sampling rate technique

Understanding the post processing technique

Implementing fast approximate anti-aliasing

Implementing adaptive anti-aliasing

Implementing an anti-aliased circle geometry

Real-time Shadows and Particle System

Introduction

Creating shadows with shadow mapping

Softening the shadow edges using PCF

Using variance shadow mapping

Simulating the particle system

Transform feedback particle system with sync objects and fences

Supplementary Information on OpenGL ES 3.0

The fixed function and programmable pipeline architecture

Software requirements for OpenGL ES 3.0 – Android ADT

Developing the Hello World Triangle application on Android Studio with OpenGL ES 3.0

Software requirements for OpenGL ES 3.0 – iOS

Opening a sample project on Android ADT and iOS

Application of the Lambert's cosine law

Calculating cosine between two vectors

Swizzling

Index

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Calculating cosine between two vectors

This is an illustration of how to calculate the cosine angle between two vectors formed by the 0, 20, and 0 points on a flat x-z plane surface and the light source situated at 20, 20, and 40, as shown in the following figure:

Calculate ON and OL vectors, as shown in the following code:

   OL = L – O = (20, 20, 40) – (0, 0, 0) => (20-0), (20-0), (40-0) => (20, 20, 40)
ON = N – O = (0, 20, 0) – (0, 0, 0) => (0, 20, 0)

The dot product between OL and ON is as follows:

OL . ON = |OL| * |ON| * cos(θ)

Using Equation 1:

OL .ON = (20*0) + (20*20) + (40*0) = 400

Using Equation 2:

|OL|*|ON| = [√ (20*20) + (20*20) + (40*40)] * [ √ (0*0) +(20*20)+(0*0)] = 979.79

Equating both equations, the result is shown in the following code:

400 = 979.79 * cos(θ);

Here, cos(θ) = 0.40 implies that the θ is 65.90 degrees.

OpenGL ES 3.0 Cookbook

By : Parminder Singh

OpenGL ES 3.0 Cookbook

By: Parminder Singh

Overview of this book

Related Content you might be interested in

Current Title:

OpenGL ES 3.0 Cookbook

Calculating cosine between two vectors