Stick Man | OpenGL Project | Computer Graphics Project | With Free Source Code

 

"Creating a Stick Man Animation with OpenGL"

Welcome to the fascinating world of computer graphics! If you are intrigued by the possibilities of creating visual animations and interactive applications, you're in the right place. In this blog post, we’ll journey through the creation of a Stick Man Computer Graphics animation project using OpenGL and FreeGLUT. This project serves as an excellent introduction for beginners keen to grasp the fundamental concepts of graphics programming, including transformations, rotations, and rendering techniques. So, gear up for a fun coding adventure!

---

Overview of the Stick Man Project

The Stick Man OpenGL Project invites you to create a delightful and simple representation of a human figure using basic geometric shapes, like lines and circles. Your mission? To animate this stick figure so it can move in response to user input, adding a fun layer of interaction! As you dive into this creative journey, you'll explore essential concepts such as: 

• Building the Skeleton: Using `GL_LINES` to craft the stick man’s framework, giving it structure and form.  

• User Interaction: Incorporating keyboard controls to animate the limbs and truly bring this character to life. 

• Creating Movement: Applying transformations like `glTranslate` and `glRotate` to make the character dance and maneuver in a realistic manner.  

This project not only offers a fantastic learning experience filled with fundamental graphics programming skills but also serves as a canvas for your artistic expression through coding!

---

Setting Up OpenGL and FreeGLUT

Before diving into the Stick Man project, it’s essential to set up your development environment properly. OpenGL and FreeGLUT libraries must be installed as they are crucial for rendering the Stick Man in a window and providing interactivity. Here’s a friendly guide to help you get started:

1. Install OpenGL and FreeGLUT Libraries: Depending on your operating system, you might need to install the appropriate packages. For Windows, you can download binaries from the respective websites, while Linux users can usually find these libraries in their package manager.

2. Set Up Your Development Environment: Ensure you have a code editor or integrated development environment (IDE) that you are comfortable with. Popular choices include Visual Studio, Code::Blocks, or even simple text editors like VS Code.

3. Include Necessary Headers: In your C++ program, start by including the necessary headers:

   #include <iostream>

   #include <GL/freeglut.h>

This simple step prepares your coding environment for the exciting journey ahead and allows you to access the functionalities provided by OpenGL and FreeGLUT.

---

Defining the Stick Man Structure

Now that we have our setup ready, let’s define our Stick Man’s structure. Each part of the Stick Man will be meticulously crafted using simple geometric shapes. The figure consists of components such as the head, torso, arms, and legs, all created using a combination of lines and circles. Let’s explore how we can construct each of these components!

1. Head and Neck:

The head is an essential part of the Stick Man, represented as a simple sphere. To draw the head, you can use the following function:

void drawHead() {
    glColor3f(1.0f, 1.0f, 1.0f); // Set head color (white)
    glPushMatrix(); // Store the current matrix state for later use.
    glTranslatef(0.0f, 4.0f, 0.0f); // Move up to position the head
    glutSolidSphere(0.5, 50, 50); // Draw the head as a solid sphere
    glPopMatrix(); // Restore the previous matrix state
}

This function draws a white sphere to represent the head, positioning it appropriately above 
the body.

2. Body and Limbs:

Next, we will construct the body and limbs. The torso is easily created with a simple vertical line:

void drawBody() {
    glBegin(GL_LINES); // Start drawing lines for the body
        glVertex2f(0.0f, 3.5f); // Position the upper part of the torso
        glVertex2f(0.0f, 1.0f); // Position the lower part of the torso
    glEnd();
}

This function creates the torso as a vertical line, where the coordinates determine the 
starting and ending points of the body. The simplicity of this design allows the focus to be 
on animation and interactivity.

3. Drawing the Arms:

To animate the arms, we will introduce a function that allows us to rotate them based on user input. Here’s how you can achieve this:

void drawArm(float angle) {
    glPushMatrix(); // Save the matrix state for transformations
    glTranslatef(0.0f, 3.5f, 0.0f); // Move to arm position
    glRotatef(angle, 0.0f, 0.0f, 1.0f); // Rotate the arm
    glBegin(GL_LINES); // Start drawing the arm
        glVertex2f(0.0f, 0.0f); // Origin of the arm
        glVertex2f(1.0f, -1.0f); // End of the arm
    glEnd();
    glPopMatrix(); // Restore the previous matrix state
}

This function allows the arms to rotate around the shoulder joint, adding a dynamic element 
to the Stick Man’s movement.

4. Drawing the Legs:
Similar to the arms, we will create and animate the legs with a dedicated function that allows 
for rotation. This is critical for making your Stick Man appear more realistic. 
Here’s the code:

void drawLeg(float angle) {
    glPushMatrix(); // Keep a copy of the current matrix state to return to it later.
    glTranslatef(0.0f, 1.0f, 0.0f); // Move to leg position
    glRotatef(angle, 0.0f, 0.0f, 1.0f); // Rotate the leg
    glBegin(GL_LINES); // Start drawing the leg
        glVertex2f(0.0f, 0.0f); // Origin of the leg
        glVertex2f(1.0f, -1.5f); // End of the leg
    glEnd();
    glPopMatrix(); // Restore the previous matrix state
}

Here, the legs can rotate around the hip joint, enabling various animations that can be 
triggered by user actions.

5. Putting It All Together:
In the main display function, we combine all the parts to create a cohesive Stick Man:

void display() {
    glClear(GL_COLOR_BUFFER_BIT); // Clear the window
    drawHead(); // Draw the head
    drawBody(); // Draw the body
    drawArm(leftArmAngle); // Draw the left arm
    drawArm(rightArmAngle); // Draw the right arm
    drawLeg(leftLegAngle); // Draw the left leg
    drawLeg(rightLegAngle); // Draw the right leg
    glFlush(); // Render the changes
}

This function clears the window and then sequentially calls each part’s drawing function, 
rendering the full Stick Man.

6. Animating the Stick Man

To create dynamic movement in our Stick Man, we will implement rotation and transformations using the previously defined functions. This is where the magic truly begins!

---

Adding User Interaction

User interaction is the heart of our project, as it enables users to control the movement of the Stick Man effectively. We will use keyboard inputs to adjust the angles of the limbs and invoke exciting animations. Here's how to do so:

Keyboard Function:

The following function defines key inputs that adjust the angles of the left arm, right arm, left leg, and right leg:

void process_Keys(unsigned char key, int x, int y) {
    if (key == 'a') leftArmAngle += 5.0f; // Rotate left arm
    if (key == 'd') leftArmAngle -= 5.0f; // Rotate left arm
    if (key == 'w') rightArmAngle += 5.0f; // Rotate right arm
    if (key == 's') rightArmAngle -= 5.0f; // Rotate right arm
    if (key == 'j') leftLegAngle += 5.0f; // Rotate left leg
    if (key == 'l') leftLegAngle -= 5.0f; // Rotate left leg
    if (key == 'i') rightLegAngle += 5.0f; // Rotate right leg
    if (key == 'k') rightLegAngle -= 5.0f; // Rotate right leg
    glutPostRedisplay(); // Trigger a redraw to reflect changes
}

By using the WASD keys for arm movements and the JKLI keys for leg movements, players 
can easily control the motions of their Stick Man, allowing him to wave, jump, or perform 
simple actions..

Mouse Function:

In addition to keyboard interaction, you can enhance the user experience by implementing mouse controls, further adding to the interactivity of your Stick Man:

void process_Mouse(int button, int state, int x, int y) {
    if (button == GLUT-LEFT-BUTTON && state == GLUT-DOWN) {
        headAngle += 5.0f; // Rotate head on left click
    }
    if (button == GLUT-RIGHT-BUTTON && state == GLUT-DOWN) {
        headAngle -= 5.0f; // This angle makes to Rotate head on right click
    }
    glutPostRedisplay(); // Trigger a redraw to reflect changes
}

By clicking the left or right mouse buttons, users can rotate the Stick Man’s head. This 
addition enhances the interactivity and makes your animation feel alive and responsive.

---

How to Play with the Stick Man

Engaging with your Stick Man animation is a delightful experience! Here’s how to play and interact with your creation:

1. Control the Arms: Use the 'A' key to rotate the left arm upwards and the 'D' key to rotate it downwards. The 'W' key will raise the right arm while pressing 'S' will lower it.
2. Animate the Legs: For leg movements, press the 'J' key to lift the left leg and the 'L' key to lower it. Use the 'I' key to elevate the right leg and 'K' to bring it down.
3. Rotate the Head: Click the left mouse button to rotate the Stick Man’s head to one side, or click the right mouse button to rotate it to the opposite side. This additional interaction adds an engaging layer to your animation and brings personality to your Stick Man.
4. Feel Free to Experiment: Combine different movements together! For instance, animate the arms swinging while the legs kick. Get creative and test how various combinations affect the animation!

Final Thoughts

Creating this Stick Man OpenGL Project offers an exciting way to familiarize yourself with graphics programming and animation fundamentals. The use of transformations, rotations, and real-time interaction highlights the beauty and dynamism of computer graphics.

Once you have a functional Stick Man, consider expanding your project further. Here are some fun ideas to take your animation to the next level:

• Jumping and Running Animations: Implement different actions such as jumping, running, and kicking to truly bring your Stick Man to life!
• Facial Expressions: Add different facial expressions or features to convey emotions, enhancing the storytelling aspect of your Stick Man.
• Background and Environment: Create a vibrant background or environment where your Stick Man can interact, such as a park, city, or landscape.

The magic of animation lies in experimentation and creativity, so I encourage you to step outside the confines of the basic Stick Man framework and put your unique stamp on the project. Play around with colors, shapes, and movements, and don’t hesitate to bring your ideas to life!

We’d love to hear about your versions of the Stick Man project and the unique animations you come up with. Happy coding, and enjoy putting your Stick Man into action! 🎨

Also, check out other intriguing OpenGL projects [here]!

 DOWNLOAD SOURCE CODE  DOWNLOAD SAMPLE REPORT