NeHe Lesson 22: Bump-Mapping, Multi-Texturing & Extensions

Oh, it's been a while from my last post. Been busy with the life outside of computers.

The next lesson has been done for a quite a while now, except for a small bug. When displaying the cube with mip-mapped textures the texture is not drawn for some reason. Today I got the drawing working, but it introduced a another problem. The fix was to remove the texture flipping and rotating code from the initGL function. This has the effect of displaying the logos upside down and as mirror images, but now the mip-mapped cube is displayed correctly.

If any of you has any idea how to fix this small problem, let me know so I can fix it. Otherwise I'll move on to the next lesson.

The NeHe's lesson can be found here.

Btw, I've kept the broken mip-map version in the repository as I think it's a smaller problem than upside down logos.

NeHe Lesson 12: Display Lists

Ok, didn't get to test this on Windows, but it should work as the lesson doesn't contain platform specific code.

First off there's an example on how to initialize a static multi-dimensional array:
(In case you didn't know already how to do it.)

/// Array For Box Colors
GLfloat boxcol[5][3] =
[
   // Bright:  Red, Orange, Yellow, Green, Blue
   [1.0f, 0.0f, 0.0f], [1.0f, 0.5f, 0.0f], [1.0f, 1.0f, 0.0f], [0.0f, 1.0f, 0.0f], [0.0f, 1.0f, 1.0f]
];

In the module constructor we have something new.

// Enable key repeating
if ((SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL)))
{
   throw new Exception("Failed to set key repeat: " ~ getSDLError());
}

Here we enable SDL to repeat key presses if you keep a key down. I've used SDL's default values for the arguments.

There isn't really anything special about the rest of the code, so grab a cola and go read what NeHe has written on the subject, here.

Here's the link to the source.

NeHe Lesson 06: Texture Mapping

So, it's been a while. I've been very busy with other stuff lately, but I haven't forgotten this blog.

The next lesson is about texture mapping. Go read it here. There's couple things I'd like to mention about SDL and OpenGL concerning this tutorial.

First of SDL has its own image loading functions, mainly SDL_LoadBMP, which loads BMP images. In a bigger project you might want to look at SDL_image for other image types.

The other thing is that you will need to flip and rotate your textures when using SDL. The following lines of code will setup OpenGL to do that for you.

glMatrixMode(GL_TEXTURE);
glRotatef(180.0f, 0.0f, 0.0f, 1.0f);
glScalef(-1.0f, 1.0f, 1.0f);
glMatrixMode(GL_MODELVIEW);

The full code listing can be found here.

A few words

I wanted to say a few words about the requirements for building the lessons from my blog. First of all I'm working on a Windows box and wont be doing very much testing on the other platforms. The code is mostly cross-platform so it should compile and run just fine on Linux or Mac OS X. I'll try to point out places where I've used platform specific code.

Next you will need the D compiler. There are two choices at the moment, the DMD from DigitalMars and GDC a GCC based compiler from here.

You also need the shared library for your platform from the SDL website.

I use Derelict for OpenGL and SDL bindings. You can grab them from there or do as I do and use DSSS, the D Shared Software System.

After that you should be ready to go.

Please note, that I'm not going to go over how you can compile a D program or the basic usage of the SDL library. For those problems there are already very good documentation on the net. Google is your friend.

NeHe Lesson 01: Setting up an OpenGL window

Hi, and welcome to the NeHe lesson 01 done in the D programming language.

This code snippet shows you how to set up SDL to display an OpenGL window, How to use Derelict to load shared libraries and a basic loop for reading input and then drawing the screen.

I'm trying to use documenting comments in the code as specified by Ddoc.

/**
* The first lesson in the NeHe tutorial series.
* Originally written by Jeff Molofee.
*
* Authors: Jeff Molofee
*          Olli Aalto
*/
module lesson01;

import derelict.opengl.gl;
import derelict.opengl.glu;
import derelict.sdl.sdl;

import tango.stdc.stringz;

/// The window title
const char[] WINDOW_TITLE = "NeHe's OpenGL Lesson 01 (D version)";

/// The main loop flag
bool running;

/**
* Module constructor. Here we load the GL, GLU and SDL shared libraries,
* and the initialize SDL.
*/
static this()
{
   DerelictGL.load();
   DerelictGLU.load();
   DerelictSDL.load();

   if (SDL_Init(SDL_INIT_VIDEO) < args =" the" fullscreen =" false;"> 1)
   {
       fullScreen = args[1] == "-fullscreen";
   }

   createGLWindow(WINDOW_TITLE, 640, 480, 16, fullScreen);
   initGL();

   running = true;
   while (running)
   {
       processEvents();

       drawGLScene();

       SDL_GL_SwapBuffers();
       SDL_Delay(10);
  }
}

/**
* Process all the pending events.
*/
void processEvents()
{
   SDL_Event event;
   while (SDL_PollEvent(&event))
   {
       switch (event.type)
       {
           case SDL_KEYUP:
               keyReleased(event.key.keysym.sym);
               break;
           case SDL_QUIT:
               running = false;
               break;
           default:
               break;
       }
   }
}

/**
* Process a key released event.
*/
void keyReleased(int key)
{
   switch (key)
   {
       case SDLK_ESCAPE:
           running = false;
           break;
       default:
           break;
   }
}

/**
* Resize and initialize the OpenGL window.
*/
void resizeGLScene(GLsizei width, GLsizei height)
{
   if (height == 0)
   {
       height = 1;
   }

   // Reset The Current Viewport
   glViewport(0, 0, width, height);

   // Select The Projection Matrix
   glMatrixMode(GL_PROJECTION);

   // Reset The Projection Matrix
   glLoadIdentity();

   // Calculate The Aspect Ratio Of The Window
   gluPerspective(45.0f, cast(GLfloat)width / cast(GLfloat)height,
       0.1f, 100.0f);

   // Select The Modelview Matrix
   glMatrixMode(GL_MODELVIEW);

   // Reset The Modelview Matrix
   glLoadIdentity();
}

/**
* Initialize OpenGL.
*/
void initGL()
{
   // Enables Smooth Shading
   glShadeModel(GL_SMOOTH);

   // Black Background
   glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

   // Depth Buffer Setup
   glClearDepth(1.0f);

   // Enables Depth Testing
   glEnable(GL_DEPTH_TEST);

   // The Type Of Depth Test To Do
   glDepthFunc(GL_LEQUAL);

   // Really Nice Perspective Calculations
   glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
}

/**
* The drawing function. Now we only clear the color and depht buffers, so that
* the window stays black.
*/
void drawGLScene()
{
   // Clear The Screen And The Depth Buffer
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

   // Reset The Current Modelview Matrix
   glLoadIdentity();
}

/**
* Initializes and opens the SDL window.
*/
void createGLWindow(char[] title, int width, int height, int bits,
   bool fullScreen)
{
   // Set the OpenGL attributes
   SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
   SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6);
   SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
   SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
   SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);

   // Set the window title
   SDL_WM_SetCaption(toUtf8z(title), null);

   // Note the SDL_DOUBLEBUF flag is not required to enable double
   // buffering when setting an OpenGL video mode.
   // Double buffering is enabled or disabled using the
   // SDL_GL_DOUBLEBUFFER attribute. (See above.)
   int mode = SDL_OPENGL;
   if (fullScreen)
   {
       mode |= SDL_FULLSCREEN;
   }

   // Now open a SDL OpenGL window with the given parameters
   if (SDL_SetVideoMode(width, height, bits, mode) is null)
   {
       throw new Exception("Failed to open OpenGL window: " ~ getSDLError());
   }

   resizeGLScene(width, height);
}

/**
* Get the SDL error as a D string.
*
* Returns: A D string containing the current SDL error.
*/
char[] getSDLError()
{
   return fromUtf8z(SDL_GetError());
}

You can download the code from here.