ComG Lab 2! (Finally OpenGL!!!!!!!!!!!!!!! xD)

Yes! Finally OpenGL! I’d like to say that I’m starting to like this module =) however, the whole blog thing is quite tedious. I had to say it so I’m hoping the teachers wouldn’t mind my opinion, or at least mind in a good way. xD Anyway, OPENGL!!!!!!
Question 1 : Define a Callback function?

I learnt that when doing OpenGL, you always have to include a Callback function in your code. I don’t know why exactly but there are 2 reasons that I can come up with.
1. This Callback function is what we wrote as myDisplay() and all our codes for display are put into this function, so it should mean that if you want to display something, you got to have the CALLBACK FUNCTION.
2. We had to put this
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE GLUT_RGB GLUT_DEPTH);
glutInitWindowSize(800, 800); //creates a display window of 800 by 600 px
glutCreateWindow("The Window"); //set the title of the window to "The Window"
glutDisplayFunc(myDisplay); //displays what is in myDisplay()
glutMainLoop();

in our main function. Notice the glutDisplayFunc() takes in myDisplay as a parameter so that’s another reason why we possibly need the a Callback function.

Question 2 : When exactly is myDisplay()called? How do you get to your findings?

myDisplay() is called whenever the code reaches a point where it wants to display something. I was told that glutMainLoop() loops the display code in the main function therefore if we look at the code above, a pseudocode would look like this.

Initialize Display Mode
Initialize Window Size
Create the Window and name it “The Window”
Display what is in the Function myDisplay()
Loops Main

Hence from this we can see that myDisplay() is called in Main every time it reaches the point where it wants to display what needs to be displayed.
Question 3 : List the process to access the VRAM.

Create a struct to store data of all the pixels to be drawn.
Send data to the buffer.
OpenGL accesses the VRAM to draw the pixels.

Question 4 : What color format are we using here i.e. 8 bits, 16 bits, 24 bits or 32 bits?

As we are using only R , G and B and each color is 8bits, it means we are using 8*3 = 24 bits color.
I heard that 32 bits is R , G , B and the alpha channel.

Question 5 : How much memory have we allocated?

When we create the pixels for the window we did
buffer=new Pixel[800*800];
Actually we did 800*600 but I changed it after I’m done with my stuff. Anyway the math is still the same.800*800*24/3 = 5120000 bytes = 4.8828125 Mbytes

Question 7 : Describe what has glDrawPixel() done.

Firstly, here’s glDrawPixel()!

glDrawPixels(800,800,GL_RGB,GL_UNSIGNED_BYTE, buffer);

Basically, it draws pixels.800,800 because that’s the resolution I set. 800 by 800 pixels.GL_RGB because we are only using R , G , and B.GL_UNSIGNED_BYTE is the type of memory that the pixels are which in this case is unsigned byte.buffer is the pointer which was used to create the pixels for the window.

From msdn.microsoft.com,

The glDrawPixels function writes a block of pixels to the framebuffer.

void glDrawPixels(
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
const GLvoid *pixels
);

Parameters
width, height
The dimensions of the pixel rectangle that will be written into the framebuffer.

format
The format of the pixel data. Acceptable symbolic constants are:

GL_COLOR_INDEX

Each pixel is a single value, a color index.

The glDrawPixels function converts each pixel to fixed-point format, with an unspecified number of bits to the right of the binary point, regardless of the memory data type. Floating-point values convert to true fixed-point values. The glDrawPixels function converts signed and unsigned integer data with all fraction bits set to zero. The function converts bitmap data to either 0.0 or 1.0.

The glDrawPixels function shifts each fixed-point index left by GL_INDEX_SHIFT bits and adds it to GL_INDEX_OFFSET. If GL_INDEX_SHIFT is negative, the shift is to the right. In either case, zero bits fill otherwise unspecified bit locations in the result.

When in RGBA mode, glDrawPixels converts the resulting index to an RGBA pixel using the GL_PIXEL_MAP_I_TO_R, GL_PIXEL_MAP_I_TO_G, GL_PIXEL_MAP_I_TO_B, and GL_PIXEL_MAP_I_TO_A tables. When in the color-index mode and GL_MAP_COLOR is true, the index is replaced with the value that glDrawPixels references in lookup table GL_PIXEL_MAP_I_TO_I.

Whether the lookup replacement of the index is done or not, the integer part of the index is ANDed with 2b 1, where b is the number of bits in a color-index buffer.

The resulting indexes or RGBA colors are then converted to fragments by attaching the current raster position z-coordinate and texture coordinates to each pixel, and then assigning x and y window coordinates to the nth fragment such that
xn = xr + n mod width
yn = yr + n/width
where (xr, yr) is the current raster position.

The glDrawPixels function treats these pixel fragments just like the fragments generated by rasterizing points, lines, or polygons. It applies texture mapping, fog, and all the fragment operations before writing the fragments to the framebuffer.
GL_STENCIL_INDEX

Each pixel is a single value, a stencil index.

The glDrawPixels function converts it to fixed-point format, with an unspecified number of bits to the right of the binary point, regardless of the memory data type. Floating-point values convert to true fixed-point values. The glDrawPixels function converts signed and unsigned integer data with all fraction bits set to zero. Bitmap data converts to either 0.0 or 1.0.

The glDrawPixels function shifts each fixed-point index left by GL_INDEX_SHIFT bits, and adds it to GL_INDEX_OFFSET. If GL_INDEX_SHIFT is negative, the shift is to the right. In either case, zero bits fill otherwise unspecified bit locations in the result.

If GL_MAP_STENCIL is true, the index is replaced with the value that glDrawPixels references in lookup table GL_PIXEL_MAP_S_TO_S.

Whether the lookup replacement of the index is done or not, the integer part of the index is then ANDed with 2b 1, where b is the number of bits in the stencil buffer. The resulting stencil indexes are then written to the stencil buffer such that the nth index is written to location
xn = xr + n mod width
yn = yr + n /width
where (xr, yr) is the current raster position. Only the pixel ownership test, the scissor test, and the stencil writemask affect these writes.

GL_DEPTH_COMPONENT

Each pixel is a single-depth component.

The glDrawPixels function converts floating-point data directly to an internal floating-point format with unspecified precision. Signed integer data is mapped linearly to the internal floating-point format such that the most positive representable integer value maps to 1.0, and the most negative representable value maps to 1.0. Unsigned integer data is mapped similarly: the largest integer value maps to 1.0, and zero maps to 0.0.

The glDrawPixels function multiplies the resulting floating-point depth value by GL_DEPTH_SCALE and adds it to GL_DEPTH_BIAS. The result is clamped to the range [0,1].

The glDrawPixels function converts the resulting depth components to fragments by attaching the current raster position color or color index and texture coordinates to each pixel, and then assigning x and y window coordinates to the nth fragment such that
xn = xr + n mod width
yn = yr + n /width
where (xr, yr) is the current raster position.

These pixel fragments are then treated just like the fragments generated by rasterizing points, lines, or polygons. The glDrawPixels function applies texture mapping, fog, and all the fragment operations before writing the fragments to the framebuffer.

GL_RGBA

Each pixel is a four-component group in this order: red, green, blue, alpha.

The glDrawPixels function converts floating-point values directly to an internal floating-point format with unspecified precision. Signed integer values are mapped linearly to the internal floating-point format such that the most positive representable integer value maps to 1.0, and the most negative representable value maps to 1.0. Unsigned integer data is mapped similarly: the largest integer value maps to 1.0, and zero maps to 0.0.

The glDrawPixels function multiplies the resulting floating-point color values by GL_c_SCALE and adds them to GL_c_BIAS, where c is RED, GREEN, BLUE, and ALPHA for the respective color components. The results are clamped to the range [0,1].

If GL_MAP_COLOR is true, glDrawPixels scales each color component by the size of lookup table GL_PIXEL_MAP_c_TO_c, and then replaces the component by the value that it references in that table; c is R, G, B, or A, respectively.

The glDrawPixels function converts the resulting RGBA colors to fragments by attaching the current raster position z-coordinate and texture coordinates to each pixel, then assigning x and y window coordinates to the nth fragment such that
xn = xr + n mod width
yn = yr + n /width
where (xr, yr) is the current raster position.

These pixel fragments are then treated just like the fragments generated by rasterizing points, lines, or polygons. The glDrawPixels function applies texture mapping, fog, and all the fragment operations before writing the fragments to the framebuffer.

GL_RED

Each pixel is a single red component.

The glDrawPixels function converts this component to the internal floating-point format in the same way that the red component of an RGBA pixel is, and then converts it to an RGBA pixel with green and blue set to 0.0, and alpha set to 1.0. After this conversion, the pixel is treated just as if it had been read as an RGBA pixel.

GL_GREEN

Each pixel is a single green component.

The glDrawPixels function converts this component to the internal floating-point format in the same way that the green component of an RGBA pixel is, and then converts it to an RGBA pixel with red and blue set to 0.0, and alpha set to 1.0. After this conversion, the pixel is treated just as if it had been read as an RGBA pixel.

GL_BLUE

Each pixel is a single blue component.

The glDrawPixels function converts this component to the internal floating-point format in the same way that the blue component of an RGBA pixel is, and then converts it to an RGBA pixel with red and green set to 0.0, and alpha set to 1.0. After this conversion, the pixel is treated just as if it had been read as an RGBA pixel.

GL_ALPHA

Each pixel is a single alpha component.

The glDrawPixels function converts this component to the internal floating-point format in the same way that the alpha component of an RGBA pixel is, and then converts it to an RGBA pixel with red, green, and blue set to 0.0. After this conversion, the pixel is treated just as if it had been read as an RGBA pixel.

GL_RGB

Each pixel is a group of three components in this order: red, green, blue. The glDrawPixels function converts each component to the internal floating-point format in the same way that the red, green, and blue components of an RGBA pixel are. The color triple is converted to an RGBA pixel with alpha set to 1.0. After this conversion, the pixel is treated just as if it had been read as an RGBA pixel.

GL_LUMINANCE

Each pixel is a single luminance component.

The glDrawPixels function converts this component to the internal floating-point format in the same way that the red component of an RGBA pixel is, and then converts it to an RGBA pixel with red, green, and blue set to the converted luminance value, and alpha set to 1.0. After this conversion, the pixel is treated just as if it had been read as an RGBA pixel.

GL_LUMINANCE_ALPHA

Each pixel is a group of two components in this order: luminance, alpha.

The glDrawPixels function converts the two components to the internal floating-point format in the same way that the red component of an RGBA pixel is, and then converts them to an RGBA pixel with red, green, and blue set to the converted luminance value, and alpha set to the converted alpha value. After this conversion, the pixel is treated just as if it had been read as an RGBA pixel.

GL_BGR_EXT

Each pixel is a group of three components in this order: blue, green, red.

GL_BGR_EXT provides a format that matches the memory layout of Windows device-independent bitmaps (DIBs). Thus your applications can use the same data with Win32 function calls and OpenGL pixel function calls.

GL_BGRA_EXT

Each pixel is a group of four components in this order: blue, green, red, alpha.

GL_BGRA_EXT provides a format that matches the memory layout of Windows device-independent bitmaps (DIBs). Thus your applications can use the same data with Win32 function calls and OpenGL pixel function calls.

type

The data type for pixels. The following symbolic constants are accepted: GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, and GL_FLOAT.
The following table summarizes the meaning of the valid constants for the type parameter.

GL_UNSIGNED_BYTE

Unsigned 8-bit integer

GL_BYTE

Signed 8-bit integer

GL_BITMAP

Single bits in unsigned 8-bit integers

GL_UNSIGNED_SHORT

Unsigned 16-bit integer

GL_SHORT

Signed 16-bit integer

GL_UNSIGNED_INT

Unsigned 32-bit integer

GL_INT

32-bit integer

GL_FLOAT

Single-precision floating-point

pixels

A pointer to the pixel data.
So that’s pretty much it.