ComG Lecture 3

[Lecture 3 –3D Graphics Rendering] leh.
This certainly is Lecture THREE because it's the start of THREE DIMENSIONAL GRAPHICS RENDERING! Ok back to business.
As usual.
Recap :
[
Color
-Perception of Color.
-3 basic color –Red, Green & Blue.
-RGB color model.
Displays
-Frame buffer.
-2D rendering.
-Double Buffering.

And the answer to the Crazy Question in Lecture 2. ~507 textures.(If you round UP)

OpenGL.
-Graphics rendering API.
-GL/ GLU (OpenGL Utility Library).
-GLUT (OpenGL Utility Toolkit) -> FreeGLUT.

#include "gl/freeglut.h"

Include freeglut will automatically include gl.h and glu.h.
]
That's the end of Recap 3.

In this lecture, we'll be learning, or rather we've learned about...

-3D Rendering Pipeline.
-Cartesian Coordinates System.
-3D Geometrics Primitives.
-3D Object Representation.

[3D Rendering Pipeline]
A pipelined sequence of operations to draw a 3D primitive into a 2D image.

( 3D Geometric Primitives -> Modeling Transformation -> Illumination -> Viewing Transformation -> Projection Transformation -> Clipping -> Rasterization -> Image )

The Modeling Transformation phase TRANSFORMS into 3D world coordinate System.
The Illumination phase ILLUMINATES according to lighting & reflectance.
The Viewing Transformation phase TRANSFORMS into 3D camera coordinate System.
The Projection Transformation phase TRANSFORMS into 2D camera coordinate System.
The Clipping phase CLIPS primitives outside camera's view.
The Rasterization phase DRAWS pixels.

So what happens first? Before the Modeling Transformation phase is our glBegin(); and glEnd();.

Basically, you enter your code, which would be 3D object coordinates like glVertex3f(0.5,0.25,0.125);, which would be TRANSFORMED into 3D world coordinates, which would then be illuminated, which would be TRANSFORMED into 3D camera coordinates, which would then be TRANSFORMED into 2D camera coordinates, which would then do a Window-to-Viewport transformation through Rasterization, and out comes 2D image coordinates!

Next we see the Cartesian Coordinate System. The y-axis points upwards, while the x-axis points towards the right. Now we see the difference between Direct3D and OpenGL - the z-axis. For Direct3D, the z-axis is pointing inwards, which means in a 2D view it points away from the user, however, for OpenGL, the z-axis points outwards, or towards the user in a 2D view.

Next we see the difference between a hand modeled with less or more vertices. Apparently, more vertices = more good looking. We also learned that ALL models can be described with triangles, like "The cube you modeled is made up of 12 triangles!" or something like that.

What is a vertex? A vertex is what makes a polygon. For example, a square has 4 vertices, while a cube has 8 vertices. NOTE: 3D no.of vertices != 2D no.of vertices *2. A triangle has 3 vertices, while a pyramid has 5 vertices.

Finally, we learned about 2D Rendering of the PRESENT. We learned about what is V-Sync, which is the synchronization of frame changes with the vertical blanking interval.

Here's how to do it!

-Obtain memory pointer to VRAM.
-Obtain double buffer memory.
-Modify double buffer memory.
-Wait for V-Sync.
-Copy double buffer to VRAM.
-Modify double buffer memory again.

and we're done.

ComG Lab 3D!

So yeah, first we had NO OpenGL, then we had Pixel Plotting(hellish), and now we have...3D drawing!(less hellish!).
Exercise 1: Drawing points

#include "freeglut.h"

void myDisplay(void)
{
glClear(GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT);

glBegin(GL_POINTS);

glVertex3f(0.0f, 0.0f, 0.0f);

glEnd();

glutSwapBuffers();

}

void main(int argc, char **argv)

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_DOUBLE GLUT_RGB GLUT_DEPTH);

glutInitWindowSize(800,600);

glutInitWindowPosition(100, 100);

glutCreateWindow("My 1st OpenGL");

glutDisplayFunc(myDisplay);

glutMainLoop();

}

Even though you probably can't see it, there's a small white dot in the middle. THAT is a pixel in white.

Exercise 2: Drawing Lines

This you can roughly see, is a diagonal line of pixels in white. THIS is GL_LINES for the glBegin() function.

Exercise 3: Drawing triangles

This is obviously not a right angled triangle, but still a triangle. THIS is GL_TRIANGLES for the glBegin() function.

Exercise 4: Drawing more than just triangles -> Quads

This is a SQUARE. This is the GL_QUADS for the glBegin() function. Anything above 3 points uses the GL_QUADS.


Exercise 6: To add colour
glColor3f(red,green,blue); changes the colors of the stuff below where you declare it.
For example, putting glColor3f(1,0,0); above glBegin(GL_QUADS); turns this QUADS into a red color. You can even put different colors for each point in the QUADS and the colors will blend together from each point forming a gradient effect!

Beautiful isn't it?

Exercise 7: A pointy try

Those are just 3 points. glPointSize(); changes the size of points!


Exercise 8: To be completed and shown to the tutor before end of class

[ Create a window of size 640 X 480 entitled "Squares and Triangles". In the window, draw 4 squares of different sizes and 4 triangles of different sizes. Make sure each polygon (squares and triangles are known as polygons) is a unique colour. They can overlap each other. ]

Not the nicest. But it was hellish. Nonetheless, beats Pixel Plotting so I'm happy =)

ComG Lecture 2

[Lecture 2 - Basic Computer Graphics]
Ok so we have reached the SECOND lecture. Since it is the SECOND lecture, it should follow a FIRST, therefore a recap for those who weren't listening in the FIRST lecture.
Recap
was in the lecture. xD

We start off the lecture looking at what seems to be a black and white chess board. Above the board was a terrifying statement - "The square marked 'A' and 'B' are the same shade of Grey". What in the world could this mean?! A is obviously black and B is obviously white with a shadow over it making it darker!
Now calm down, we are educated people, let's not get too worked up over something that SEEMS ridiculous. In the next slide, the truth was revealed, that both of them ARE the same, it was just the lighting that made them look different. This is Perception of Color. Next we see the electromagnetic spectrum...O levels...

Anyway, now for something cool.
[Trichromatic Theory of Color Vision]
Each of our eyes contain Rods and Cones, cool eh? We are able to see color because of these rods and cones in our eyes. Rods govern brightness while Cones govern color. There are 3 different types of Cones, which are Red, Green & Blue. Since Cones govern color, people who are color blind to red colors are probably missing the Red Cone, likewise for the others. Also since Rods govern brightness, I suppose having missing Rods have something to do with going blind.

Next we have a CIE Chromaticity Diagram.
- It covers the WHOLE color spectrum. WOW.
- Used as basis to define supported color range.

And then, something to jeer at that Diagram. The RGB Color Model!
- It was introduced because CIE primaries are difficult to work with.
- It is also called the Additive Color Model.

Now something important about describing colors!
Terms that describe Color :
HSB( Hue , Saturation , Brightness)
Hue is basically......the color!
Saturation is how VIBRANT the color is!E.g.LightBlue is more saturated than DarkBlue
Brightness is how BRIGHT the color is!(obviously)E.g. White is brightest!

[To test out how Saturation works by yourself, Open Paint, Go to Colors > Edit Colors > Define Custom Colors and then pick a color and play around with the Sat value.
Example : I picked Yellow with a Sat of 240. When I changed it to 200, it turned into a darker Yellow, like as if it had a transparent grey sheet over it. When I changed it to 100, it became grey.]

Now...Raster Devices!
-Equipments that have a display surface on which an image is presented.
E.g Monitors, Printers, Film Recorders.
[Display Surface on a Monitor]
Display Surface = no.of rows * no.of columns (basically your 1280*1024 resolution)
A 1280*1024 resolution can present 1280*1024*1 pixels simultaneously.
More on Raster Display, like the Frame Buffer, is seen in the lecture in pictures.

Ok next is something VERY IMPORTANT!!!!! Unless you don't care about SIZE.
[Precision of Color Representation]
The number of unique colors a pixel can represent depends on the number of bits per pixel, which in other words, the color depth.
Suppose I have a color depth of 8.
Each pixel of mine can represent up to 2^8 = 256 colors.

Color Look Up Table a.k.a CLUT

 CLUT = Color Look Up Table or palette.
 8bits.
 Colors are looked up from a palette.
 Tells which color to choose16 over million colors to be displayed.
 Each pixel takes up 1 byte.

Then we did some calculations to help us understand this more.

Question 1 -I want my game to run at 800 x 600 on 32 bits. How much VRAM do I need?

Each pixel takes up 1 byte hence the resolution alone takes up 800*600 bytes.
As for the 32 bits. 32 bits means 4 colors. Each color is 8bits = 1byte. Hence a screen of 800*600 pixels where each pixel has 4 colors = 800*600*4 bytes.

Crazy Question

Question 2 -My artist are told they have a maximum of 32MB to use for textures. How many textures can they use if they are limit to 256 x 256, with a 24bits palette of 8bits color depth?

Firstly, let's calculate how much memory is available for use.
32 MB = 32*1024 KB = 32*1024*1024 bytes = 33554432 bytes

Secondly, let's calculate how many pixels and how much memory they would take up.
256*256 pixels = 256*256*1 bytes = 65536 bytes

Thirdly, let's calculate how much memory each texture's palette will take up.
bits per pixel = color depth
color depth = 8
Total no.of colors in 1 pixel = 2^color depth = 2^8 = 256 bytes
A 24 bits palette has R G and B hence, 256*3 = 768 bytes

Fourth, let's calculate how much memory each TEXTURE takes up in total.
65536 + 768 = 66304 bytes

Finally, let's calculate the total amount of TEXTURES that can be used.
33554432/66304 = 506.069 textures
Round up = 507 textures
Round down = 506 textures
Round off to nearest whole number = 506 textures
Hence approximately 506 textures can be used.

[Graphical File Format]
Some comparisons –
JPG --Does not store alphas.
TGA --Supports alpha.
GIF --Supports transparency, animation & 8 bits color depth.

Finally, the lecture ends with 2D Rendering and what it is.

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.

ComG Lecture 1

I learned that praying to a book called the OpenGL Super Bible helps you pass this module.
Well, maybe not learn, but I did hear that.
The RULES:

Be punctual. (10 minutes grace)

Pay attention. (No Games, No MSN, Only COMPG work is allowed in Labs)

If you fail this module, you have to repeat it and you are not allowed to take any
advanced module or any related modules.

Practice and Do is the key to passing this module.

Ask questions when in doubt.

About rule #2, I have something very important to point out, I might be wrong but... I think it is now Windows Live Messenger and not MSN Messenger.

About this MODULE:

60 Hrs, 1hr lecture & 3hrs practical per week(What you are paying for)

Lecture –Theory & Concept of Computer Graphics

Lab –Application of Computer Graphics (OpenGL why?)

Assessment Modes(SUPER IMPORTANT)
•Assignment 1 –30%
•Assignment 2 –35%
•Quiz/ In-class Assessment –10%
•Test –20%
•Participation –5%

Lecture Notes(If you still don't know this...)
•Lecture notes can be found in the reference drive T:\DET\DM2122 Computer Graphics(Tan Siew Lan)\Lectures

So hey guess what people? The whole course seems to have become more based on daily work, so no hope of slacking now. =P

and now for the TOPICS!!(drum roll)

General knowledge on Computer Graphics
2D Graphics
•Traditional 2D Graphics
3D Graphics
•3D Object Representation
•Lights, materials
•Textures
•Cameras
•Animation

and here are the TOOLS used and SKILLS needed in this module

OpenGL

GLUT

C++

General programming knowledge
•What is an array?(int arr[10])
•How to call method?(what??)
•What is a class or an object?(well I know that)

Object oriented programming knowledge(OOP)

Now finally, places of REFERENCE(Very important in my opinion)

Computer Graphics with OpenGL, Hearn Baker

OpenGL –A Primer, Edward Angel

Computer Graphics Using OpenGL, Francis S Hill

OpenGL Super Bible 3rd Ed., Wright

http://www.lighthouse3d.com/opengl

http://www.gamedev.net/

http://www.opengl.org/

http://www.morrowland.com/

About the OpenGL Super Bible, I think the 8th edition is already out. Everything else...I'm not really sure. GameDev.net is a good website though.

Now...the summary...begins!

[What are considered Computer Graphics?]
Anything graphical that is generated by a computer is considered Computer Graphics.
Computer Graphics require both software and hardware to generate.

[How are Computer Graphics generated onto the screen?]
CPU > Video Card > Screen

[Where can Computer Graphics be used?]

•Arts, Entertainment, & Publishing

•Developments of Computer Games

•Scientific Analysis & Volume Visualization

•Virtual –Reality Environments

•Computer –Aided Design (CAD)

[How Computer Graphics has become]
Thanks to the many pictures in the lecture, I was able to see the change in Computer Graphics over the years.
1. Quality
How quality has improved can be simply put in this way. Take the blocky graphics in those SNES games and compare it to those smooth graphics of games today, like the game I reviewed on. Those wallpaper-like pictures of the characters are what you actually see moving in the game as you play.

2. Realistic
As Computer Graphics evolved, things that can possibly be created using Computer Graphics become more realistic. In the past, if you took a picture of a game, it will look like a picture of a game, but today we see life-like characters in the game, so life-like that people could probably do a nearly perfect cosplay of the character.

[Why use Computer Graphics?]

Now that Computer Graphics are so advanced, you'd want them in anything that you want to be visually pleasing to the people who would see it. Also, it would be much more convenient than to draw out everything by hand, but doing that might produce even better graphics.

[So what did I learn exactly?]
I admit that I didn't exactly learn much, however this is just the first lecture, so I don't expect to learn anything. However, truth be told, I didn't even know what I would be doing in ComG before this lecture and now I know that what I'll have to expect in this module. Mental preparation.

This post might be updated in time.

Devil May Cry 4 : Teenager and Ex Male Lead VS Old Senile Guy and Friends

Title of the Game: Devil May Cry 4
Game Platforms: PS3, XBOX360, Windows(PC Version).
Genre of Game: Action, Hack and Slash.
Developer: CAPCOM
Rating : M (12 for BBFC)
Product Model Date(s):
[PlayStation 3, Xbox 360]:
JP January 31, 2008
NA February 5, 2008
AUS February 7, 2008
EU February 8, 2008



[Microsoft Windows]:
JP July 24, 2008
NA July 8, 2008
AUS July 10, 2008
EU July 11, 2008

Game Requirements:
-[System Requirements]

• Windows XP/Vista


• Intel Pentium 4 3 GHz, Core 2 Duo or AMD equivalent


• 512 MB RAM / Windows Vista 1 GB RAM


• 5.0 GB free space (PS3) / 7.0 GB free space (PC)


• GeForce 6600 with 256 MB of VRAM (SM3 Required)


• DirectX 9.0c compatible sound card

-[Player Requirements]

• Fast Fingers


• A reasonable amount of tolerance with puzzles
  
• Play Smart


• Good Anger Management


• Good Amount of playtime


• Good Taste for Style

Devil May Cry 4 is the fourth installment of the Devil May Cry series.(obviously) The game allows players to play both protagonists in the plot,
Nero





















and
Dante





















in a way unlike any other past installments in the Devil May Cry series. The switch in characters happens along the storyline which goes on as the player completes the missions. As usual, cutscenes happen frequently in the game to give the players visually pleasing way of continuing the story. Devil May Cry 4 takes a new turn with Nero, adding in a whole new style of play in Devil May Cry 4, which will be explained later.

Gameplay
[Similarities to its predecessors]
The player's main aim in the game is to complete the missions 1-20 in each difficulty.
[Difficulty]
While the difficulties have been renamed, Devil May Cry 4 still has the same levels of difficulty, particularly the Dante Must Die difficulty which was the highest level of difficulty in the past installments. At higher difficulties, enemies can activate their own Devil Trigger, making them faster, more durable, and with higher HP.
[Rank]
Mission completion is still ranked between D and S with D being the lowest and S being the highest. These grades are affected by
Number of Items Used (e.g Gold Orb for revival in missions)
Number of Red Orbs Gathered (Used to buy items in the game)
Time Taken (Continuing the mission after death does not reset the time taken)
Style Points Accumulated
[Style Points]
(Each Style Point grade has its own tag-word. For example, the SSS grade shows up as "Smokin' Sick Style" on the side of the screen when achieved. Stylish combat is the main focus of the game, which is conveyed through unbroken combos of varied attacks while avoiding damage. The player must avoid attack enemies to continue performing combos, often by memorizing attack patterns.)
[Devil Trigger]
As usual, Devil Trigger is a state the player can enter to have special abilities for a limited amount of time. Devil Trigger decreases the delay between attacks, enables the use of special skills, and a slow health regeneration. However, unlike Devil May Cry 3, Dante's Devil Trigger does not change according to what weapon is currently held.

[Difference with its predecessors]
Since it is a sequel, new additions are to be expected.
[Difficulty]
Comparing with Devil May Cry 3, the difficulties are not simply named as Easy, Normal, Hard, Very Hard, Dante Must Die, and Heaven or Hell. Devil May Cry 4 adds a little extra taste to the naming of difficulties, with Human, Devil Hunter, Son of Sparda, Dante Must Die, Legendary Dark Knight, Heaven or Hell, and Hell or Hell. It would seem that the game has taken out the Very Hard mode and added in difficult modes AFTER Dante Must Die mode, while keeping the difficulty of Dante Must Die. A noticable difficulty would be the Hell or Hell mode. Unlike the Heaven or Hell mode where BOTH the player and the enemies die in ONE hit, Hell or Hell mode FEATURES the player dying in ONE hit, while the enemies retain their normal HP.
[Proud Souls]
Proud Souls are a new currency in Devil May Cry 4. Red Orbs are now used for buying items in the shop, while Proud Souls are used to acquire skills for the characters.
During character switch, proud souls are refunded and transferred over to the other character along with the Red Orbs.
[Dante]
Dante still has his weapon acquiring feature, which allows him to gain new weapons after defeating each boss. However, he has lesser weapons compared to the previous installments.
[Nero]
Nero has a unique style of play, contributing alot to the uniqueness of Devil May Cry 4.
[Red Queen]
The Red Queen features an Exceed Gauge that can be charged up, allowing for subsequent attacks that are more powerful than regular slashes, until the gauge empties. The Exceed Gauge can also be filled by pressing the rev button at the peak of each slash, which allows for more powerful combos capable of breaking the opponent's guard.
[Blue Rose]
Nero's own revolver which is very very weak, except maybe in Heaven or Hell mode =P, however along with his Devil Bringer, he can charge up shots, making this weak revolver a far too lethal single-target weapon.
[Devil Bringer]
As you can see, Nero doesn't exactly have what we would call a normal right arm, THAT is the Devil Bringer. Nero can use it to pull himself towards enemies or vice-versa. The Devil Bringer may also be used for context-sensitive throw attacks, leading to high damage and various effects depending on the enemy. Nero's Devil Bringer also gains new abilities during the course of the game, such as being able to detect secret missions or caches of Red Orbs. Nero eventually gains the ability to use Devil Trigger, which increases his Devil Bringer's power, and which also changes his Devil Bringer attacks into more powerful versions with different animations. Using the Devil Bringer on different enemies produces different ways of attacking, noticably on bosses.
[Devil Trigger]
Nero has a Devil Trigger, which would remind players of Vergil back in DMC3, as something that looks like Vergil's Devil Trigger would float behind Nero when he is in Devil Trigger form. When Nero goes into Devil Trigger, he gains a second of invulnerability, slow health regeneration, summoned swords, as well as a second slash to every slash he does. While in Devil Trigger, Nero can still utilise the Ex-Gauge. When in Devil Trigger mode, using the Devil Bringer on enemies deals more damage, and has a different attack animation.

Graphics

Devil May Cry 4 has very nice graphics, however such nice graphics are the cause of extreme lag on the PC version, hence they added a Turbo option specially for the PC version. Thus, playing on a game console would result in better gameplay experience.As you can see from the screenshots, those are what you will actually see when playing the game, which is no less from what you see in the cinematics. That is what I find really impressive about Devil May Cry 4's graphics.
Sound
There isn't much of a background music while the player is just walking around. The real music comes when the player enters a battle, especially one with a boss. To better describe the sound, here are some...
[Videos!]



Conclusion
This is a really fun game. I love it. Try it.





Credits to Wikipedia and other websites that were unintentionally not mentioned.

FIRST POST!!! xDDDDDDDDDDDDDDDDDD

It's been a while since I've seen this anywhere on the Internet so I thought I'd talk about it. "FIRST POST!!", "First!", or anything of the sort, is what some people try to engrave on anywhere on the Internet that allows posting and has not gotten a post before e.g Youtube video comments, tagboards??, new forum topics. To know more about the life of a FIRST POSTER, watch this VERY OLD video!
LOL!!!