Cardboard VR Projects for Android

Table of contents

1. Cardboard VR Projects for Android
   1. Table of Contents
   2. Cardboard VR Projects for Android
   3. Credits
   4. About the Authors
   5. About the Reviewers
   6. www.PacktPub.com
      1. eBooks, discount offers, and more
         1. Why subscribe?
   7. Preface
      1. What this book covers
      2. What you need for this book
      3. Who this book is for
      4. Conventions
      5. Reader feedback
      6. Customer support
         1. Downloading the example code
         2. Downloading the color images of this book
         3. Errata
         4. Piracy
         5. Questions
   8. 1. Virtual Reality for Everyone
      1. Why is it called Cardboard?
      2. The spectrum of VR devices
         1. Old fashioned stereoscopes
         2. Cardboard is mobile VR
         3. Desktop VR and beyond
      3. A gateway to VR
      4. The value of low-end VR
      5. Cardware!
      6. Configuring your Cardboard viewer
      7. Developing apps for Cardboard
         1. Using Unity
         2. Going native
      8. An overview to VR best practices
      9. Summary
   9. 2. The Skeleton Cardboard Project
      1. What's in an Android app?
         1. APK files
         2. A Gradle build process
         3. A Java compiler
      2. The Android project structure
      3. Getting started with Android Studio
         1. Installing Android Studio
         2. The Android Studio user interface
      4. Creating a new Cardboard project
      5. Adding the Cardboard Java SDK
      6. The AndroidManifest.xml file
      7. The activity_main.xml file
      8. The MainActivity class
         1. Default onCreate
         2. Building and running
      9. Summary
   10. 3. Cardboard Box
       1. Creating a new project
       2. Hello, triangle!
          1. Introducing geometry
          2. Triangle variables
          3. onSurfaceCreated
          4. Introducing OpenGL ES 2.0
          5. Simple shaders
          6. The compileShaders method
          7. The prepareRenderingTriangle method
          8. onDrawEye
          9. Building and running
       3. 3D camera, perspective, and head rotation
          1. Welcome to the matrix
          2. The MVP vertex shader
          3. Setting up the perspective viewing matrices
          4. Render in perspective
          5. Building and running
       4. Repositioning the triangle
       5. Hello, cube!
          1. The cube model data
          2. Cube code
       6. Lighting and shading
          1. Adding shaders
          2. Cube normals and colors
          3. Preparing the vertex buffers
          4. Preparing the shaders
          5. Adding a light source
          6. Building and running the app
       7. Spinning the cube
       8. Hello, floor!
          1. Shaders
          2. Floor model data
          3. Variables
          4. onCreate
          5. onSurfaceCreated
          6. initializeScene
          7. prepareRenderingFloor
          8. onDrawEye
          9. drawFloor
       9. Hey, look at this!
          1. The isLookingAtObject method
       10. Summary
   11. 4. Launcher Lobby
       1. Creating a new project
       2. Adding Hello Virtual World text overlay
          1. A simple text overlay
          2. Center the text using a child view
          3. Create stereoscopic views for each eye
          4. Controlling the overlay view from MainActivity
       3. Using a virtual screen
       4. Responding to head look
       5. Adding an icon to the view
       6. Listing installed Cardboard apps
          1. Queries for Cardboard apps
          2. Create the Shortcut class for apps
          3. Add shortcuts to OverlayView
          4. Using view lists in OverlayEye
       7. Highlighting the current shortcut
       8. Using the trigger to pick and launch the app
       9. Further enhancements
       10. Summary
   12. 5. RenderBox Engine
       1. Introducing RenderBox – a graphics engine
       2. Creating a new project
          1. Creating the RenderBox package folder
          2. Creating an empty RenderBox class
          3. Adding the IRenderBox interface
       3. Materials, textures, and shaders
          1. Abstract material
       4. The Math package
          1. MathUtils
          2. Matrix4
          3. Quaternion
          4. Vector2
          5. Vector3
       5. The Transform class
          1. Parent methods
          2. Position methods
          3. Rotation methods
          4. Scale methods
          5. Transform to matrix and draw
       6. The Component class
       7. The RenderObject component
       8. The Cube RenderObject component
       9. Vertex color material and shaders
          1. Vertex color shaders
          2. VertexColorMaterial
       10. The Camera component
       11. RenderBox methods
       12. A simple box scene
       13. Cube with face normals
       14. The Light component
       15. Vertex color lighting material and shaders
       16. Time for animation
       17. Detect looking at objects
       18. Exporting the RenderBox package
           1. Building the RenderBoxLib module
           2. The RenderBox test app
           3. Using RenderBox in future projects
       19. Summary
   13. 6. Solar System
       1. Setting up a new project
       2. Creating a Sphere component
       3. A solid color lighted sphere
          1. Solid color lighting shaders
          2. Solid color lighting material
          3. Adding a Material to a Sphere
          4. Viewing the Sphere
       4. Adding the Earth texture material
          1. Loading a texture file
          2. Diffuse lighting shaders
          3. Diffuse lighting material
          4. Adding diffuse lighting texture to a Sphere component
          5. Viewing the Earth
          6. Changing the camera position
       5. Day and night material
          1. Day/night shader
          2. The DayNightMaterial class
          3. Rendering with day/night
       6. Creating the Sun
          1. Unlit texture shaders
          2. Unlit texture material
          3. Rendering with an unlit texture
          4. Adding the Sun
       7. Creating a Planet class
       8. Formation of the Solar System
          1. Setting up planets in MainActivity
          2. Camera's planet view
          3. Animating the heavenly bodies
       9. A starry sky dome
       10. Fine tuning the Earth
           1. The night texture
           2. Axis tilt and wobble
       11. Changing the camera location
       12. Possible enhancements
       13. Updating the RenderBox library
       14. Summary
   14. 7. 360-Degree Gallery
       1. Setting up the new project
       2. Viewing a 360-degree photo
          1. Viewing a sample photosphere
          2. Using the background image
       3. Viewing a regular photo
          1. Defining the Plane component and allocating buffers
          2. Adding materials to the Plane component
          3. Adding an image screen to the scene
       4. Putting a border frame on the image
          1. Border shaders
          2. The border material
          3. Using the border material
       5. Loading and displaying a photo image
          1. Defining the image class
          2. Reading images into the app
          3. Image load texture
          4. Showing an image on the screen
          5. Rotating to the correct orientation
          6. Dimensions to correct the width and height
          7. Sample image down to size
       6. Loading and displaying a photosphere image
       7. The image gallery user interface
          1. Positioning the photo screen on the left
       8. Displaying thumbnails in a grid
          1. The thumbnail image
          2. The Thumbnail class
          3. The thumbnail grid
       9. Gaze to load
          1. Gaze-based highlights
          2. Selecting and showing photos
          3. Queue events
          4. Using a vibrator
       10. Enable scrolling
           1. Creating the Triangle component
           2. Adding triangles to the UI
           3. Interacting with the scroll buttons
           4. Implementing the scrolling method
       11. Stay responsive and use threads
       12. An explanation of threading and virtual reality
       13. Launch with an intent
       14. Showing/hiding the grid with tilt-up gestures
       15. Spherical thumbnails
           1. Add a sphere to the Thumbnail class
       16. Updating the RenderBox library
       17. Further possible enhancements
       18. Summary
   15. 8. 3D Model Viewer
       1. Setting up a new project
       2. Understanding the OBJ file format
       3. Creating the ModelObject class
       4. Parse OBJ models
          1. buildBuffers
       5. Model extents, scaling, and center
       6. I'm a little teapot
       7. I'm a little rotating teapot
       8. Thread safe
       9. Launch with intent
       10. Practical and production ready
       11. Summary
   16. 9. Music Visualizer
       1. Setting up a new project
       2. Capturing audio data
       3. A VisualizerBox architecture
       4. Waveform data capture
       5. A basic geometric visualization
       6. 2D texture-based visualization
          1. Texture generator and loader
          2. Waveform shaders
          3. Basic waveform material
          4. Waveform visualization
       7. FFT visualization
          1. Capture the FFT audio data
          2. FFT shaders
          3. Basic FFT material
          4. FFT visualization
       8. Trippy trails mode
       9. Multiple simultaneous visualizations
       10. Random visualizations
       11. Further enhancements
           1. A community invite
       12. Summary
       13. Onward to the future
   17. Index