OpenGL ES & Quake 1 Tutorials (RFC)

Tutorials concerning the OpenGL® ES cross-platform API for full-function 2D and 3D graphics on the Google-Android platform.

OpenGL ES & Quake 1 Tutorials (RFC)

Postby MichaelTACTEL » Tue May 05, 2009 5:58 am

Greets,

Well I have some exciting news as my next project at Tactel US (I'm a software architect working on Android projects) is to start a technology blog/tutorial site for Android. I proposed basing the first tutorial sections on OpenGL ES and with a section on a Java port of Quake 1 as there is very little information specifically targeting Android, OpenGL ES, and 3D engines (let alone for desktop Java on this topic). With a bit of good fortune this topic was approved and I'll be providing educational tutorials on core OpenGL ES techniques and dissect a bit of a Java port of a Q1 class engine and initially provide a port for the level renderer and model loader. This will provide a kick start for a native Java Q1 port effort and a foundation to complete the rest of the port to Android for those inclined to do so.

Here is an overview of the sections. Note Section 3 will draw from the NeHe tutorials that are pertinent to Q1 tech and may include new material for Android that is not a part of the NeHe tutorials. Section 4 is on the Q1 engine and will likely contain more sections.

I'd like you guys to review this outline and let me know if there are additional topics you'd like to see covered that fit into the general goals of the site.

My plan is to work pretty furiously on this project and launch it by Google I/O at the end of May with at least the Q1 level renderer and model loader completed if possible and all goes well.

Also this effort is a partial coordination with the Android & Me Mobile Quake challenge:
http://www.androidandme.com/2009/03/con ... ile-quake/

There is a Google group for the Q1 port effort here:
http://groups.google.com/group/android- ... bile-quake

Regards,
--Mike

Section 1: General Information
-----------------------------------------------

1. Android Development Setup – This tutorial describes how to set up the Android developer environment for Eclipse and command line Ant compilation. Links to relevant information will be provided.

2. AndroidManifest.xml – There are a lot of parameters in AndroidManifest.xml and some that are quite useful for the life cycle of an Android activity.

3. Timing and Control – One of the most important aspects of near real time software development is accurate timing control. This tutorial will cover the EGR Software / Typhon timing mechanism that will be reused in all OpenGL examples and the Q1 engine.

4. Setting up Android / OpenGL ES – Describes the base code used to setup the rendering context that will be used in all OpenGL ES examples including the Q1 engine.

5. Testing capabilities of the device and OpenGL ES specific support.

6. Input control – Describes framework code that will be used to gather input control from various sources such as the keyboard, trackball, and accelerometer. This tutorial also covers how to setup the standard menu system.

7. An overview of the T-Mobile G1 – Pertinent information on the G1 and HTC Magic (“G2”) will be covered in this tutorial from processor information to OpenGL performance metrics.

8. Android 1.0 API vs Android 1.5 API – Discuss the differences between both API versions and any ramifications on supported OpenGL ES functionality.

9. NIO NIO NIO – Discusses Java NIO and why it is important for OpenGL rendering and networking. Also discusses performance issues when using NIO on Android.


Section 2: Math and Algorithms
-----------------------------------------------
1. Vectors / Matrices / Normals – Provides an overview with links to other online material covering the basics of linear algebra including vectors and normals and some applied information. Discussion on the framework code that provides this functionality is discussed.

2. Coordinate systems and units – Discusses the left hand and right hand coordinate systems and the concept of unit measurement in OpenGL.

3. Faster math shortcuts - Including lookup tables and approximations for common functions

4. Radix Sort – A fast sorting technique useful for alpha blending

5. BSP Trees – A general introduction to binary space partitioning trees.


Section 3: OpenGL ES fundamentals & NeHe Tutorial Ports – One demo APK with all tutorials in finished form available for download
-----------------------------------------------

1. Tutorial 1 – Vertex Arrays & Your First Polygon – http://nehe.gamedev.net/data/lessons/le ... ?lesson=02
In addition to the basic NeHe lesson OpenGL ES specific information will be covered including vertex arrays. A discussion on the various primitive drawing modes.
Deliverables – source code for tutorial 1

2. Tutorial 2 – Adding Color – http://nehe.gamedev.net/data/lessons/le ... ?lesson=03
Deliverables – source code for tutorial 2

3. Tutorial 3 – Projection, Model View Matrices including orthographic projection and basic camera functionality
Deliverables – source code for tutorial 3

4. Tutorial 4 – Rotation – http://nehe.gamedev.net/data/lessons/le ... ?lesson=04
Deliverables – source code for tutorial 4

5. Tutorial 5 – 3D Shapes – http://nehe.gamedev.net/data/lessons/le ... ?lesson=05
Deliverables – source code for tutorial 5

6. Tutorial 6 – Texture Mapping – http://nehe.gamedev.net/data/lessons/le ... ?lesson=06
Deliverables – source code for tutorial 6

7. Tutorial 7 – Texture Filters, Lighting – http://nehe.gamedev.net/data/lessons/le ... ?lesson=07
Deliverables – source code for tutorial 7

8. Tutorial 8 – Blending – http://nehe.gamedev.net/data/lessons/le ... ?lesson=08
Deliverables – source code for tutorial 8

9. Tutorial 9 – Fonts – Provides a discussion on font rendering with OpenGL ES and creating font textures dynamically from installed Android fonts.
Deliverables – source code for tutorial 9

10. Tutorial 10 – Masking – http://nehe.gamedev.net/data/lessons/le ... ?lesson=20
Deliverables – source code for tutorial 10

11. Tutorial 11 – Bump-Mapping, Multi-Texturing & Lightmapping – http://nehe.gamedev.net/data/lessons/le ... ?lesson=22

In addition to covering the standard NeHe lesson lightmapping will be discussed as part of multi-texturing.
Deliverables – source code for tutorial 11

12. Tutorial 12 – Alpha Blending / Alpha Testing / Sorting – http://nehe.gamedev.net/data/lessons/le ... ?lesson=32
Deliverables – source code for tutorial 12

13. Tutorial 13 – Billboarding – Billboarding is one of the most crucial techniques to use to fake 3D shapes and allow for better rendering performance. Discusses the different types of billboarding and the math behind it.
Deliverables – source code for tutorial 13

14. Tutorial 14 – Point Sprites – Covers point sprite functionality and limitations with the G1.
Deliverables – source code for tutorial 14

15. Tutorial 15 – Particle Engine Using Triangle Strips – http://nehe.gamedev.net/data/lessons/le ... ?lesson=19
Deliverables – source code for tutorial 15

16. Tutorial 16 – Bounding Geometry / Basic Collision Detection / Picking –
Deliverables – source code for tutorial 16

This tutorial will cover basic bounding geometry including AABB, OBB, Sphere, Cylinder, Plane geometry primitives and collision detection between the various types and finally a picking example.

17. Tutorial 17 – Advanced Picking w/ Touch Screen Interaction – The orientation of 3D objects on screen are not coordinated with touch screen interactions. This tutorial discusses how to find the orientation of a 3D object and adjust picking accordingly.

Deliverables – source code for tutorial 17

18. Tutorial 18 – Frustum Culling – Discusses how to create a frustum which defines the viewing area. Tricks are necessary to complete this with Android / G1. Once a frustum is defined the first level of culling optimization is to remove objects that are not within the frustum.

19. Tutorial 19 – Vertex Buffer Objects – http://nehe.gamedev.net/data/lessons/le ... ?lesson=45

Defines the fastest way to render vertex data.
Deliverables – source code for tutorial 19

20. Tutorial 20 – Time based state management / animation – This tutorial discusses animation and the importance to base all animation on time.

Deliverables – source code for tutorial 20


Section 4: Quake 1 Java Source Port – A demo APK will be available on the market.
-----------------------------------------------

1. Historical background on Quake 1 – Discusses the state of computer graphics / OpenGL in 1999 when the Q1 source was released.

2. Q1 level loader – Discusses the data structures and loading process to read in Q1 data

3. Q1 level rendering – Discusses rendering a Q1 level including applications of frustum culling, state sorting, and other pertinent optimization techniques including how BSP trees play a major role in culling out unseen surfaces.

4. Q1 model loading / rendering / animation – Discusses rendering a Q1 model and animation capabilities possible

5. Q1 collision detection – BSP trees are used in both rendering optimization and collision detection. This tutorial will cover how to do collision detection with BSP trees and the bounding geometry primitives

6. Basic player movements – Running, jumping, stair climbing, strafing in 3D and the necessity to do smoothing of trackball input to accomplish circle staffing.

Further topics TBD
Michael Leahy
Software Architect, Tactel San Francisco

Tactel US, Inc
600 Townsend St, Suite 340e
San Francisco, CA 94103
USA
Tactel is a leading developer of mobile applications, providing solutions and consulting services to many of the worlds major network operators and mobile handset vendors. We help these customers stay ahead of the game by designing genuinely original applications, and making sure they work on all networks and with all handsets.
MichaelTACTEL
Freshman
Freshman
 
Posts: 4
Joined: Tue May 05, 2009 5:20 am

Top

Android OpenGL ES & Quake 1 Tutorials (RFC)

Postby reisma » Fri Jul 31, 2009 11:43 am

I am looking forward to this, from what I see, there is currently nothing I would change on your outline.
Kind regards!
reisma
Once Poster
Once Poster
 
Posts: 1
Joined: Fri Jul 31, 2009 11:27 am

Postby desuvinodkumar » Tue Oct 20, 2009 8:49 am

HI MichaelTACTEL

Very good opengl tutorial for starter of opengl in android step by step....

Heartful thanks for this tutorial...
Vinod...
User avatar
desuvinodkumar
Senior Developer
Senior Developer
 
Posts: 102
Joined: Mon Mar 23, 2009 6:51 am
Location: India

Top

Return to Android 2D/3D Graphics - OpenGL Tutorials

Who is online

Users browsing this forum: No registered users and 3 guests