GaanZa » developer http://www.gaanza.com Sat, 04 Sep 2010 07:55:44 +0000 en hourly 1 Installing Vlc Player 1.1.4 on Ubuntu 10.04 http://www.gaanza.com/blog/vlc-1-1-4/ http://www.gaanza.com/blog/vlc-1-1-4/#comments Fri, 03 Sep 2010 12:10:35 +0000 padam http://www.gaanza.com/?p=540

Here is how i installed latest vlc media player 1.1.4 on ubuntu 10.04 from new personal package archieve.

I ran these commands on terminal:

sudo add-apt-repository ppa:ferramroberto/vlc && sudo apt-get update

sudo apt-get install vlc mozilla-plugin-vlc

This is it. :)

Gracias.


]]> http://www.gaanza.com/blog/vlc-1-1-4/feed/ 0 My new Mac Ubuntu :D http://www.gaanza.com/blog/mac-ubuntu/ http://www.gaanza.com/blog/mac-ubuntu/#comments Fri, 03 Sep 2010 10:27:12 +0000 padam http://www.gaanza.com/?p=532

I have been using Ubuntu 10.o4 for last two weeks. I am loving it. I haven’t touched windows yet after installing Ubuntu 10.04 on dual boot system. Ubuntu has got everything for my requirements. Yesterday My Brother uploaded the picture of his new Ubuntu 10.04 look on facebook. He gave exact replica of mac os x look and feel to his ubuntu desktop. Everything from icons to buttons to folders to menus to login screen, everything had a mac os X feel and even desktop functions/features were that of mac os X. I loved it and i asked  him the steps/instructions to do it. Here is the image of My new Ubuntu Desktop Look:

Here are the steps to install Macbuntu:

You should be connected to an internet.

1) Open Terminal.
sudo wget https://downloads.sourceforge.net/project/macbuntu/macbuntu-10.04/v2.1/Macbuntu-10.04.tar.gz -O /tmp/Macbuntu-10.04.tar.gz

2) Then Type tar xzvf /tmp/Macbuntu-10.04.tar.gz -C /tmp

3) cd /tmp/Macbuntu-10.04/

4) ./install.sh

This is it. Now just follow the instructions and macbuntu will be installed. Then Reboot your machine. After restart your desktop will look like above picture.

To uninstall macbuntu:

Open Terminal:
1) Type cd ~/.macbuntu/10.04-2.1/
2) Type ./uninstall.sh

So enjoy.

Gracias.


]]> http://www.gaanza.com/blog/mac-ubuntu/feed/ 0 2D Rain Effect http://www.gaanza.com/blog/2d-rain-effect/ http://www.gaanza.com/blog/2d-rain-effect/#comments Fri, 05 Mar 2010 05:40:10 +0000 padam http://www.gaanza.com/?p=382

Hola Everyone.
I am working on a level for 2d game where i needed to add a rain effects. I am using Slick 2D library for making my 2d game. Before i started working on making 2D rain effect , i discussed this topic on slick 2d forum for how to get started ? Here is the forum thread. You can check it out.
So i wrote a simple code to create a rain effect:
1) Make a Rain Drop, i wrote a class for Rain Drop that extends Polygon class. Yes i m creating rain drops with polygons.
2) Create number of drops at random coordinates and simulate it across the screen i.e make them fall. You can use wind factor also for providing bit more interesting.


So this is the way i started.

Here is the Rain Drop class:

import org.newdawn.slick.geom.Polygon;

public class RainDrop extends Polygon{
public RainDrop(int size){
super();

/** coordinates of vertices of polygon(rain drop) */
this.addPoint(0, 0);
this.addPoint(0, size);
}
}

This is the main class where we are using rain drops and simulating it to create a simple rain effect, nothing fancy.

import java.util.logging.Level;
import java.util.logging.Logger;
import org.newdawn.slick.AppGameContainer;
import org.newdawn.slick.BasicGame;
import org.newdawn.slick.Color;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.Image;
import org.newdawn.slick.SlickException;

public class Rainy extends BasicGame{

private RainDrop[] drops;
private Image background;

public Rainy(){
   super(“”);
}

public static void main(String[] args){
try {
AppGameContainer app = new AppGameContainer(new Rainy());
app.setDisplayMode(1024, 768, true);
app.setTargetFrameRate(100);
app.setShowFPS(false);
app.start();
} catch (SlickException ex) {
Logger.getLogger(Rainy.class.getName()).log(Level.SEVERE, null, ex);
}
}

@Override
public void init(GameContainer gc) throws SlickException {
background=new Image(“data/jungle.jpg”);

/** creating 700 rain drops and placing it on random location across the screen */
initializeRain(900);
}

@Override
public void update(GameContainer gc, int delta) throws SlickException {

for(int i=0;i<drops.length-1;i++){

        drops[i].setY(drops[i].getY()+4.0f);

        drops[i].setX(drops[i].getX()-1.0f);

      if(drops[i].getY()>768){

         drops[i].setX((float) ((Math.random() * 2000)+30));

         drops[i].setY((float) ((Math.random() * 5)));

}

}

}

public void render(GameContainer gc, Graphics g) throws SlickException {
g.drawImage(background, 0, 0);
g.setColor(new Color(188.0f,227.0f,229.0f,0.3f));
for(int i=0;i<drops.length-1;i++){
     g.draw(drops[i]);
}
}

/** creating rain drops */
void initializeRain(int num_of_drops){
drops=new RainDrop[num_of_drops];
for(int i=0;i<drops.length-1;i++){
    drops[i]=new RainDrop((int) (Math.random() * 10 + 4));
    drops[i].setX((float) ((Math.random() * 2000)+30));
    drops[i].setY((float) ((Math.random() * 750)));
}
}

}

So what i am doing :
1) initializeRain(int num_of_drops) takes an int parameter which denotes the number of rain drops. This function creates a number of rain drops(instance of raindrop class) and assigns the random x and y position to each rain drops.
2) Then we simply iterate the array of rain drops and translate them across the screen. When drops reaches the bottom of screen then we simply restore back to random initial starting postion. This keeps going on and gives the impression of rainy effect.

This is very simple 2d effect that i started with. You can write your own optimized version and can add more feature to give fancy impression like adding alpha values for each rain drop etc.

Gracias.


]]> http://www.gaanza.com/blog/2d-rain-effect/feed/ 0 Finding Nearest Sprite For 2D Collision http://www.gaanza.com/blog/finding-nearest-sprite-for-2d-collision/ http://www.gaanza.com/blog/finding-nearest-sprite-for-2d-collision/#comments Thu, 25 Feb 2010 15:04:08 +0000 padam http://www.gaanza.com/?p=368

Hola EveryOne.

There are various methods/ways to detect a collision between two objects. Each having its own advantage and disadvantage and based on our requirement we implement one of the collsion detection algorithm.

Here i am not going to talk about collision algorithm. I am going to talk about determining the nearest object with which collision will take place. Suppose there are many objects across the screen and u have to detect the collision between your game character and those objects. And you run the algorithm to detect collision with each of every object in every frame. So it decreases the efficiency of your program. Its better to detremine the nearest object to your game character and detect collision with that determined nearest object.

Here i m using bounding rectangle concept for collision detection.

Code Example:

public static Sprite getNearestGroundSprite(ArrayList<Sprite> sprites,Sprite hero){
    Sprite sprite=null;
    float minDistance=9999;
    if(hero!=null)
    for(int i=0;i<sprites.size();i++){
/* ignore all those objects which are not visible across the screen */
        if(sprites.get(i).getSX()>screenWidth || (sprites.get(i).getSX()+sprites.get(i).getWidth()<0)){
            continue;
        }
        else
/* ignore all those objects which are located above the game character */
        if(hero.getSY()>sprites.get(i).getSY()){
            continue;
        }
        else
/* ignore all those objects that are located at the left side of game character */
        if(hero.getSX()>(sprites.get(i).getSX()+sprites.get(i).getWidth())){
            continue;
        }
        else
/* ignore all those objects that are located at right side of game character */
        if((hero.getSX()+hero.getWidth())<sprites.get(i).getSX()){
            continue;
        } 
/* calculate the distance between remaining objects and game character */
        float dist=sprites.get(i).getSY()-hero.getSY();
/* determine the nearest sprite from remaining sprites */
        if(dist<minDistance){
            minDistance=dist;
            sprite=sprites.get(i);
        }
    }
/* nearest object found or return null if not found */
    return sprite;
}

Sprite is just a class representing characters of game. getSX() and getSY() returns the x and y coordinate location of that sprite. getWidth() simply returns the width of the sprite image.

In above code i am ignoring all those sprites that are located at left, right and top of my game character because i need bottom sprite to check collision with i.e when character falls down. This way the number of sprites decreases for checking collisions. You can write function for finding nearest left and right sprites also. You need to call this function at right place and when needed.

This is very simple and basic way i started and it gets the job done. You can write your own optimized code. This is how i started. I have written my optimized code for finding nearest sprite but right now i won’t be posting it but i’l share it soon in near future.

Gracias.

]]> http://www.gaanza.com/blog/finding-nearest-sprite-for-2d-collision/feed/ 2 Loading image/Texture Mapping in LWJGL http://www.gaanza.com/blog/loading-imagetexture-mapping-in-lwjgl/ http://www.gaanza.com/blog/loading-imagetexture-mapping-in-lwjgl/#comments Sun, 04 Oct 2009 15:35:40 +0000 padam http://www.gaanza.com/blog/?p=318

box

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.

1

2

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.

Crate

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.

]]> http://www.gaanza.com/blog/loading-imagetexture-mapping-in-lwjgl/feed/ 0 Diving into Mobile Gaming !! http://www.gaanza.com/blog/diving-into-mobile-gaming/ http://www.gaanza.com/blog/diving-into-mobile-gaming/#comments Sat, 03 Oct 2009 08:12:34 +0000 padam http://www.gaanza.com/blog/?p=313

Recently my friends suggested me to make games for mobile phones. I haven’t done any formal course for mobile programming so i did a some search on mobile game development on google and gone through some articles like The Clash of Mobile Platforms: J2ME, ExEn, Mophun and WGE

I have a Nokia N70ME handset and most of my friends have same kinda(specifications) handset. All of them are java enabled. I did a search on their specifications and found that almost all were midp 2.0 enabled. After doing some research on mobile gaming i chose J2ME for developing mobile games because majority of the phones of my target audience are java-enabled so i can reach to masses. Secondly, SUN provides you all the development tools for free. And thirdly i am more comfortable in java programming language so it would be easier for me to pick up things more fast and easily. So i am using netbeans IDE 6.7 with the mobility pack to write my app and its pretty productive and reliable. My next step was to find some good online tutorial to just get started, all basic things. I searched the google and found many useful stuff there:

http://developers.sun.com/mobility/midp/articles/gameapi/

http://developers.sun.com/mobility/midp/articles/game/

http://today.java.net/pub/a/today/2005/07/07/j2me3.html

http://www.devx.com/wireless/Article/27167/1954

So i got many stuffs to get started making midp 2.0 games. It didn’t take too much time to pick up things. I got the concepts easily and started implementing them. I just started with testing codes like drawing images, moving them, rotation etc. After testing all those codes i decided to make very simple 2d side scrolling game. Then i searched for some free sprites on google and got some stuffs on world war 2 theme. Then i asked my friend to make some background images for me and he made some pretty good backgrounds. So then i was off to fly and started making the game.

This is my current progress on game and i am pretty sure that soon i’ll complete the game and upload here for the download.

jungleMobile

This is my mobile game project that i am working. Soon i’l finish it. And important thing is that i am enjoying very much making game for mobile phones. I tested it on my Nokia N70 handset and it worked flawlessly. I am very excited regarding this project.

Gracias.

]]> http://www.gaanza.com/blog/diving-into-mobile-gaming/feed/ 0 Setting Up LWJGL with Netbeans http://www.gaanza.com/blog/setting-up-lwjgl-with-netbeans/ http://www.gaanza.com/blog/setting-up-lwjgl-with-netbeans/#comments Wed, 16 Sep 2009 04:41:05 +0000 padam http://www.gaanza.com/blog/?p=285

On Forums, people keeps asking about setting up lwjgl library with netbeans. So here i am going to show the steps to do that.

STEP 1: Go to Tools-> Libariries.Now create new library. Give it a name say “lwjgl21″.

step1

STEP 2: Now we have to configure the library. Click the classpath tab, then click add jars, and add all the jars shown below:

step2

STEP 3: If u want to add java doc than click the javadoc tab, and then add the javadoc folder. Then finally click oK and lwjgl21 library that we have just created is done.

STEP 4: Now create a empty java project.

step3

STEP 5: Now we have to set the properties so that our newly created project can find the lwjgl library and jar files. So Right-Click the project-> Properties. Now check the image carefully and configure accordingly. So first select libraries on the categories section and then click compile tab, and then add jar file for compilation step. This step is very important so check image properly below.

step4

STEP 6: Okie now click run tab, and add the library that we had just created. Check the image very properly.

step5

STEP 7: Now the final step. We have to provide the argument so that project cud find the necessary dll files. So first select the Run at caregories section then go to vm-options. Check the image properly and follow.

step6

Okie thats it. Now click ok. So you have just set up lwjgl with your netbeans ide. So now you can compile and run your lwjgl app. I am using netbeans ide 6.7.

Gracias

]]> http://www.gaanza.com/blog/setting-up-lwjgl-with-netbeans/feed/ 1 Game Engines: A Quick Peek http://www.gaanza.com/blog/game-engines/ http://www.gaanza.com/blog/game-engines/#comments Sat, 12 Sep 2009 13:15:56 +0000 padam http://www.gaanza.com/blog/?p=270

Game Engines are the core libraries which is used as the architecture to develop the game. It cuts down the pressure on development teams as all the complex coding is already written in the engine. The core functions that Game Engine provides are rendering(2d or 3d), physics engine or collision detection, sound, scripting, artificial intelligence. They provide all the core functionalities needed to develop a game while reducing the costs, complexities and time.

There are libraries that are developed to provide only one specific functions, called Middleware. Like Havok is a middleware which offers developers the foundation for creating realistic physics simulation.

Developers  license the engines like id tech, unreal to develop their titles. Some developers use their in-house proprietry engines created by themselves for their own titles. And their are also some free open source engines out there like OGRE, JMonkeyEngine.

Now i’ll discuss about some very well known Game Engines, Middleware And Engines used in making next-gen games.

Unreal Engine:

Unreal is a game engine developed by Epic Games. The games made by this engine are Gears of War franchise, Bioshock, splintercell, MassEffect and many other. This Engine has won the Game Developer’s Front Line awards in engine category for three consecutive awards. This Engine is Game Developer’s Front Line Awards 2008 Hall Of Fame winner. You can read Why Unreal Engine was the Hall Of Fame Winner.

gears2vid01

Gears of War 2 made with Unreal engine

Havok

Havok is a physics engine developed by Havok. Havok offers developers the foundation for creating realistic physics simulation through efficient and optimized calculation. The Titles that used Havok engine are Crackdown, Assassin’s creed, F.E.A.R 2:Project Origin, Fallout 3, Halo 3 and many more. Havok won the Game Developer’s Front Line Awards 2008 in Middleware category. Read why Havok won the award ?.

company-of-heroes

Company of Heroes using Havok engine

cryEngine

Developed by CryTek is the force behind those killer graphics of crysis. They set a new standard for visuals. CryTek released a GDC demonstration movie for their latest all-in-one game development solution using cryEngine 3, premiered at GDC 2009 in san fransisco. cryEngine 3 is the first development platform for Xbox 360, Playstation 3, MMO, DX9/DX10 and includes cryEngine 3 Sandbox level editor and “What you see is what you play” tool designed for professional developers. 3 comes with significant feartures for consoles and next-gen game development.

crysis

crysis made with cryEngine

R.A.G.E (Rockstar Advanced Game Engine)

R.A.G.E is a game engine developed by a team called “Rage Technology Group” at Rockstar san diego. Rockstar has integrated a few third party middleware like euphoria character animation engine and Bullet physics engine. GTA4 was developed with this cool engine. Rockstar are working on a game Red Dead Redemption which uses R.A.G.E engine. The trailer of Read dead Redemption looks really cool with realistic horses, towns, prairies….with ralistic weather. R.A.G.E engine provides functionalities to handle realistic weather effects, complex A.I, large worlds..etc

Check this video of Red Dead Redemption, its jusshows you what R.A.G.E is capable of doing.

gta4

Grand Theft Auto 4 made with R.A.G.E engine

Naughty Dog Game Engine

This Engine is developed by Naughty Dog. This year naughty Dog showcased their upcoming title Uncharted 2 at sony playstation 3 conference, E3 2009 . I was awestruck by watching the trailer and demo. I had never seen such a cinematic game(demo) before, graphics looked so awesome and cool. Naughty Dog with Uncharted 2 really showed the world what Ps3 is capable to do. So i would say Naughty Dog maxed out the Ps3 with Uncharted 2. The demo showcased realistic environments, smooth animation-interaction, cinematic feel with cinematic camera work :D …seamless transition between cinematic and gameplay.

So there are other engines also that i haven’t mentioned like Valve’s Source engine which gave titles like half-life franchise, left 4 dead, Infinity Ward’s IW engine which gave Call Of Duty franchise(not all sequels), Ubisoft’s Anvil engine which was used for Assassin’s creed….and many more engines. I have just  quickly looked at just some good engines that took my interest. This post is not on best engines but tells about good engines.

Gracias.


]]> http://www.gaanza.com/blog/game-engines/feed/ 0 List Of Good OpenGL and (ES) Books http://www.gaanza.com/blog/list-of-good-opengl-and-es-books/ http://www.gaanza.com/blog/list-of-good-opengl-and-es-books/#comments Sun, 06 Sep 2009 07:26:11 +0000 padam http://www.gaanza.com/blog/?p=236

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

superbible

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.

redbook

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

  • Image-based lighting

  • Lighting with spherical harmonics

  • Ambient occlusion

  • Shadow mapping

  • Volume shadows using deferred lighting

  • Ward’s BRDF model

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.

shading

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

    es2.0

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

distilled

Gracias

]]> http://www.gaanza.com/blog/list-of-good-opengl-and-es-books/feed/ 0 Installing or Setting up JOGL on Ubuntu http://www.gaanza.com/blog/setting-up-jogl-in-ubuntu/ http://www.gaanza.com/blog/setting-up-jogl-in-ubuntu/#comments Mon, 08 Jun 2009 03:50:38 +0000 padam http://www.gaanza.com/blog/?p=118

gl_java_ubuntu1

Here are the detailed steps to set up or install JOGL on your ubuntu. First of all you have to download the jogl library(according to your machine) from here . I am using Ubuntu 8.04 on intel board so i downloaded jogl-1.1.1-linux-i586.zip.

So extract the zip file. Now open the folder that you have just now extracted. Go to lib folder.

STEP 1: Now you have to copy four .so files i.e libjogl.so, libjogl_awt.so, libjogl_cg.so, libgluegen-rt.so to [javainstalation directory]/jre/lib/i386

Open the terminal window and type: sudo cp libjogl.so /usr/lib/java/jdk1.6.0_13/jre/lib/i386

similarly you have to copy other three .so files.

*you have to provide you java installation path*

jogl1

Now you can check the destination if files has been copied.

jogl21

STEP 2: Now copy jogl.jar and gluegen-rt.jar to [java installation di]/jre/lib/ext

run this command to copy: sudo cp jogl.jar /usr/lib/java/jdk1.6.0_13/jre/lib/ext

simillarly copy gluegen-rt.jar

*you have to provide your java installation path*

jogl3

You can check:

jogl4

STEP 3: SO thats it. Now lets test the simple jogl code.

import javax.media.opengl.GLCapabilities;

public class Hello{
public static void main (String args[]) {
try {
System.loadLibrary(“jogl”);
System.out.println(
“Hello World! (The native libraries are installed.)”
);
GLCapabilities caps = new GLCapabilities();
System.out.println(
“Hello JOGL! (The jar appears to be available.)”
);
} catch (Exception e) {
System.out.println(e);
}
}
}

Now compile this Hello.java and the run it. Here is the output:

jogl-final

So thats it. Now your are off to fly and write your jogl apps.

Thanks.

]]> http://www.gaanza.com/blog/setting-up-jogl-in-ubuntu/feed/ 2