These are the list of some popular books on OpenGl and (ES) preffered by many.
OpenGl SuperBible Fourth Edition
It begins by illuminating the core techniques of “classic” opengl programming, from drawing in space to geometric transformations, from lighting to texture mapping. The authors covers newer OpenGL capabilities, including OpenGL 2.1’s powerful programmable pipeline, vertex and fragment shaders, and advanced buffers. They also present thorough, up-to-date inroduction to opengl implementation on openl platforms, including windows,mac,linux and embedded systems.
Coverage includes
· An entirely new chapter on OpenGL ES programming for handhelds
· Completely rewritten chapters on OpenGL for Mac OS X and GNU/Linux
· Up-to-the-minute coverage of OpenGL on Windows Vista
· New material on floating-point color buffers and off-screen rendering
· In-depth introductions to 3D modeling and object composition
· Expert techniques for utilizing OpenGL’s programmable shading language
· Thorough coverage of curves, surfaces, interactive graphics, textures, shadows, and much more
· A fully updated API reference, and an all-new section of full-color images
The OpenGl Programming Guide: The Official Guide to Learning OpenGl Version 2.1
The OpenGL® Programming Guide, Sixth Edition, provides definitive and comprehensive information on OpenGL and the OpenGL Utility Library. The previous edition covered OpenGL through Version 2.0. This sixth edition of the best-selling “red book” describes the latest features of OpenGL Version 2.1. You will find clear explanations of OpenGL functionality and many basic computer graphics techniques, such as building and rendering 3D models; interactively viewing objects from different perspective points; and using shading, lighting, and texturing effects for greater realism. In addition, this book provides in-depth coverage of advanced techniques, including texture mapping, antialiasing, fog and atmospheric effects, NURBS, image processing, and more. The text also explores other key topics such as enhancing performance, OpenGL extensions, and cross-platform techniques.
This sixth edition has been updated to include the newest features of OpenGL Version 2.1, including:
- Using server-side pixel buffer objects for fast pixel rectangle download and retrieval
- Discussion of the sRGB texture format
- Expanded discussion of the OpenGL Shading Language
This edition continues the discussion of the OpenGL Shading Language (GLSL) and explains the mechanics of using this language to create complex graphics effects and boost the computational power of OpenGL.
The OpenGL Technical Library provides tutorial and reference books for OpenGL. The Library enables programmers to gain a practical understanding of OpenGL and shows them how to unlock its full potential. Originally developed by SGI, the Library continues to evolve under the auspices of the OpenGL Architecture Review Board (ARB) Steering Group (now part of the Khronos Group), an industry consortium responsible for guiding the evolution of OpenGL and related technologies.
OpenGL Shading Language 2nd Edition
OpenGL® Shading Language, Second Edition, includes updated descriptions for the language and all the GLSL entry points added to OpenGL 2.0; new chapters that discuss lighting, shadows, and surface characteristics; and an under-the-hood look at the implementation of RealWorldz, the most ambitious GLSL application to date. The second edition also features 18 extensive new examples of shaders and their underlying algorithms, including
The color plate section illustrates the power and sophistication of the OpenGL Shading Language. The API Function Reference at the end of the book is an excellent guide to the API entry points that support the OpenGLShading Language. Also included is a convenient Quick Reference Card to GLSL.
OpenGL ES 2.0 Programming Guide
In the OpenGL® ES 2.0 Programming Guide, three leading authorities on the Open GL ES 2.0 interface—including the specification’s editor—provide start-to-finish guidance for maximizing the interface’s value in a wide range of high-performance applications. The authors cover the entire API, including Khronos-ratified extensions. Using detailed C-based code examples, they demonstrate how to set up and program every aspect of the graphics pipeline. You’ll move from introductory techniques all the way to advanced per-pixel lighting, particle systems, and performance optimization.
Coverage includes:
-
Shaders in depth: creating shader objects, compiling shaders, checking for compile errors, attaching shader objects to program objects, and linking final program objects
-
The OpenGL ES Shading Language: variables, types, constructors, structures, arrays, attributes, uniforms, varyings, precision qualifiers, and invariance
-
Inputting geometry into the graphics pipeline, and assembling geometry into primitives
-
Vertex shaders, their special variables, and their use in per-vertex lighting, skinning, and other applications
-
Using fragment shaders—including examples of multitexturing, fog, alpha test, and user clip planes
-
Fragment operations: scissor test, stencil test, depth test, multisampling, blending, and dithering
-
Advanced rendering: per-pixel lighting with normal maps, environment mapping, particle systems, image post-processing, and projective texturing
-
Real-world programming challenges: platform diversity, C++ portability, OpenKODE, and platform-specific shader binaries
OpenGL Distilled
OpenGL® Distilled provides the fundamental information you need to start programming 3D graphics, from setting up an OpenGL development environment to creating realistic textures and shadows. Written in an engaging, easy-to-follow style, this book makes it easy to find the information you’re looking for. You’ll quickly learn the essential and most-often-used features of OpenGL 2.0, along with the best coding practices and troubleshooting tips.
Topics include
-
Drawing and rendering geometric data such as points, lines, and polygons
-
Controlling color and lighting to create elegant graphics
-
Creating and orienting views
-
Increasing image realism with texture mapping and shadows
-
Improving rendering performance
-
Preserving graphics integrity across platforms
Gracias
…seamless transition between cinematic and gameplay.
Loading image/Texture Mapping in LWJGL
Hola everyone.
I am currently working on my own two game projects: one project is of mobile phone game and other is 2.5 or side-scrolling 3d game, not much sure. So for second project i am making an small engine that will be used to make 2.5D game or side scrolling 3d game, Just simple and fun game. I have chosen LWJGL, which is a java binding for Opengl to make my game. So first thing i need to work on loading images.texture mapping in lwjgl. I found some pretty much useful tutorials and great help from lwjgl forums. But atlast i got something that i was looking for from the forum.
I came to know about slick-util which is free and open source lib to load images and play sounds. Its very easy to pick up and implement it. Its just worked flawlessly and smoothly for me. You can download the slick-util from here. PNG, GIF, JPG, TGA are supported and WAV, OGG, XM sounds are supported by slick-util.
So here i’l show u how easily i loaded images and mapped to a 3D BOX. First u have to setup lwjgl and slick-util with netbeans. Yeah i am using netbeans to write my program. You can see my post to setup lwjgl with netbeans. Now we will set up slick-util, its a continuation to the steps that we did to setup lwjgl.
Continued…
Step 1: We just have to configure the project properties so that project can find the lib to compile and run.
Ok that was it. Now slick-util lib has been set up.Now first i’l show u how to load image and bind it , full source will be at the end.
Texture texture;
Texture is an interface having description of texture which will be loaded.
texture = TextureLoader.getTexture(“PNG”, new FileInputStream(“Data/Crate.png”));
now we are loading the texture using TextureLoader utility class. Just smooth and simple.
texture.bind();
Now we are binding the texture.
So thats what u need to load the image and map them to objects. Download this image to use it in this program.
Full Code:
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package com.gaanza.engine.test2;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.lwjgl.LWJGLException;
import org.lwjgl.Sys;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.glu.GLU;
import org.newdawn.slick.opengl.Texture;
import org.newdawn.slick.opengl.TextureLoader;
/**
*
* @author Java Guy
*/
public class EngineTest {
private static boolean gameRunning=true;
private static int targetWidth = 800;
private static int targetHeight = 600;
private float xrot=0.1f;
private float yrot=0.1f;
private float zrot=0.1f;
/** The texture that’s been loaded */
private Texture texture;
public static void main(String[] args){
EngineTest app=new EngineTest();
initDisplay(false);
initGL();
app.init();
app.run();
}
private static void initDisplay(boolean fullscreen){
DisplayMode chosenMode = null;
try {
DisplayMode[] modes = Display.getAvailableDisplayModes();
for (int i=0;i<modes.length;i++) {
if ((modes[i].getWidth() == targetWidth) && (modes[i].getHeight() == targetHeight)) {
chosenMode = modes[i];
break;
}
}
} catch (LWJGLException e) {
Sys.alert(“Error”, “Unable to determine display modes.”);
System.exit(0);
}
// at this point if we have no mode there was no appropriate, let the user know
// and give up
if (chosenMode == null) {
Sys.alert(“Error”, “Unable to find appropriate display mode.”);
System.exit(0);
}
try {
Display.setDisplayMode(chosenMode);
Display.setFullscreen(fullscreen);
Display.setTitle(“LWJGL window”);
Display.create();
}
catch (LWJGLException e) {
Sys.alert(“Error”,“Unable to create display.”);
System.exit(0);
}
}
private static boolean initGL(){
GL11.glMatrixMode(GL11.GL_PROJECTION);
GL11.glLoadIdentity();
// Calculate the aspect ratio of the window
GLU.gluPerspective(45.0f,((float)targetWidth)/((float)targetHeight),0.1f,100.0f);
GL11.glMatrixMode(GL11.GL_MODELVIEW);
GL11.glLoadIdentity();
GL11.glEnable(GL11.GL_TEXTURE_2D); // Enable Texture Mapping ( NEW )
GL11.glShadeModel(GL11.GL_SMOOTH);
GL11.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
GL11.glClearDepth(1.0f);
GL11.glEnable(GL11.GL_DEPTH_TEST);
GL11.glDepthFunc(GL11.GL_LEQUAL);
GL11.glHint(GL11.GL_PERSPECTIVE_CORRECTION_HINT, GL11.GL_NICEST);
return true;
}
private void init(){
try {
texture = TextureLoader.getTexture(“PNG”, new FileInputStream(“Data/grass.png”));
} catch (IOException ex) {
Logger.getLogger(EngineTest.class.getName()).log(Level.SEVERE, null, ex);
}
}
private void run(){
while(gameRunning){
update();
render();
Display.update();
// finally check if the user has requested that the display be
// shutdown
if (Display.isCloseRequested()) {
gameRunning = false;
Display.destroy();
System.exit(0);
}
}
}
private void update(){
xrot+=0.1f;
yrot+=0.1f;
zrot+=0.1f;
}
private void render(){
GL11.glClear(GL11.GL_COLOR_BUFFER_BIT|GL11.GL_DEPTH_BUFFER_BIT);
GL11.glLoadIdentity();
GL11.glTranslatef(0.0f,0.0f,-5.0f); // Move Into The Screen 5 Units
GL11.glRotatef(xrot,1.0f,0.0f,0.0f); // Rotate On The X Axis
GL11.glRotatef(yrot,0.0f,1.0f,0.0f); // Rotate On The Y Axis
GL11.glRotatef(zrot,0.0f,0.0f,1.0f); // Rotate On The Z Axis
texture.bind(); // or GL11.glBind(texture.getTextureID());
GL11.glBegin(GL11.GL_QUADS);
// Front Face
GL11.glTexCoord2f(0.0f, 0.0f);
GL11.glVertex3f(-1.0f, -1.0f, 1.0f); // Bottom Left Of The Texture and Quad
GL11.glTexCoord2f(1.0f, 0.0f);
GL11.glVertex3f( 1.0f, -1.0f, 1.0f); // Bottom Right Of The Texture and Quad
GL11.glTexCoord2f(1.0f, 1.0f);
GL11.glVertex3f( 1.0f, 1.0f, 1.0f); // Top Right Of The Texture and Quad
GL11.glTexCoord2f(0.0f, 1.0f);
GL11.glVertex3f(-1.0f, 1.0f, 1.0f); // Top Left Of The Texture and Quad
// Back Face
GL11.glTexCoord2f(1.0f, 0.0f);
GL11.glVertex3f(-1.0f, -1.0f, -1.0f); // Bottom Right Of The Texture and Quad
GL11.glTexCoord2f(1.0f, 1.0f);
GL11.glVertex3f(-1.0f, 1.0f, -1.0f); // Top Right Of The Texture and Quad
GL11.glTexCoord2f(0.0f, 1.0f);
GL11.glVertex3f( 1.0f, 1.0f, -1.0f); // Top Left Of The Texture and Quad
GL11.glTexCoord2f(0.0f, 0.0f);
GL11.glVertex3f( 1.0f, -1.0f, -1.0f); // Bottom Left Of The Texture and Quad
// Top Face
GL11.glTexCoord2f(0.0f, 1.0f);
GL11.glVertex3f(-1.0f, 1.0f, -1.0f); // Top Left Of The Texture and Quad
GL11.glTexCoord2f(0.0f, 0.0f);
GL11.glVertex3f(-1.0f, 1.0f, 1.0f); // Bottom Left Of The Texture and Quad
GL11.glTexCoord2f(1.0f, 0.0f);
GL11.glVertex3f( 1.0f, 1.0f, 1.0f); // Bottom Right Of The Texture and Quad
GL11.glTexCoord2f(1.0f, 1.0f);
GL11.glVertex3f( 1.0f, 1.0f, -1.0f); // Top Right Of The Texture and Quad
// Bottom Face
GL11.glTexCoord2f(1.0f, 1.0f);
GL11.glVertex3f(-1.0f, -1.0f, -1.0f); // Top Right Of The Texture and Quad
GL11.glTexCoord2f(0.0f, 1.0f);
GL11.glVertex3f( 1.0f, -1.0f, -1.0f); // Top Left Of The Texture and Quad
GL11.glTexCoord2f(0.0f, 0.0f);
GL11.glVertex3f( 1.0f, -1.0f, 1.0f); // Bottom Left Of The Texture and Quad
GL11.glTexCoord2f(1.0f, 0.0f);
GL11.glVertex3f(-1.0f, -1.0f, 1.0f); // Bottom Right Of The Texture and Quad
// Right face
GL11.glTexCoord2f(1.0f, 0.0f);
GL11.glVertex3f( 1.0f, -1.0f, -1.0f); // Bottom Right Of The Texture and Quad
GL11.glTexCoord2f(1.0f, 1.0f);
GL11.glVertex3f( 1.0f, 1.0f, -1.0f); // Top Right Of The Texture and Quad
GL11.glTexCoord2f(0.0f, 1.0f);
GL11.glVertex3f( 1.0f, 1.0f, 1.0f); // Top Left Of The Texture and Quad
GL11.glTexCoord2f(0.0f, 0.0f);
GL11.glVertex3f( 1.0f, -1.0f, 1.0f); // Bottom Left Of The Texture and Quad
// Left Face
GL11.glTexCoord2f(0.0f, 0.0f);
GL11.glVertex3f(-1.0f, -1.0f, -1.0f); // Bottom Left Of The Texture and Quad
GL11.glTexCoord2f(1.0f, 0.0f);
GL11.glVertex3f(-1.0f, -1.0f, 1.0f); // Bottom Right Of The Texture and Quad
GL11.glTexCoord2f(1.0f, 1.0f);
GL11.glVertex3f(-1.0f, 1.0f, 1.0f); // Top Right Of The Texture and Quad
GL11.glTexCoord2f(0.0f, 1.0f);
GL11.glVertex3f(-1.0f, 1.0f, -1.0f); // Top Left Of The Texture and Quad
GL11.glEnd();
}
}
Gracias.