Drawing Mountains in OpenGL Using Bitmap Loaders

Using the OpenGL Glut library, we have created numerous straightforward and intricate programs, but none of them have used texturing or image loading. We tried to find how to load image in the Opengl? The stackoverflow question pertaining to "Loading images in openGL" yielded the best response.

Images Loading in OpenGL Graphics Programming

We can claim that working with OpenGL graphics programmiong, the image loading is seems to be difficult task. External libraries such as stb_image.h, DevIL (Developer's Image Library), FreeImage, and SOIL (Simple OpenGL Image Library) are used to read and decode images into raw pixel data; OpenGL does not import image files directly. This data is then sent to the GPU as a texture using OpenGL methods such as glGenTextures, glBindTexture, and glTexImage2D for rendering.

In addition to images/photos/pictures, textures can be used to contain a sizable collection of arbitrary data that can be sent to the shaders for rendering the object.

Drawing Mountains in OpenGL

In this Computer graphics Open project we are going to generate the mountains using the image texture with use of bitmap loaders.

1. Grass Like Texture to Mountains

We are randomly generating the mountains using a normalized pseudo-random number generator and fractal techniques. The windows are displayed differently each time you resize them or start the project program application. This application relies on GLUT and uses a bitmap for the grass texture. Therefore, they were loaded into the program for use using BitmapLoader.h.

2. Random Number for (Gaussian) distribution

Let first define the randomNormal utility function, which uses the central limit theorem approximation (sum of uniform random variables) to produce a random number with a normal (Gaussian) distribution.

double randomNormal (double mu, double sigma)
{
double sum = 0;
for(int i = 0; i < 12; i++)
sum = sum + (double)rand()/RAND_MAX;
sum -= 6;
return sigma*sum + mu;
} 

3. Texture Creation and Circle Drawing Functions

Using raw bitmap data, createTexture1 loads a texture into OpenGL and sets its filtering mode to nearest neighbor (pixelated look) and wrapping mode to clamp.

Draw_circle uses a polygon of 36 vertices (one every 10 degrees) to approximate a 2D filled circle. This might stand in for the sun or another round object in the picture.

See Also - How to draw circle in OpenGL

4. Fractal Mountain Generation Function

By periodically splitting a quadrilateral and applying a random height displacement, this recursive program creates fractal landscape.

Lighting effects are used to draw the quad once it is sufficiently small (perim <= tolerance). Using the Lambertian model, the lighting simulates diffuse light by shading the polygon according to its normal and light positions.

In order to produce four smaller quads recursively and add height perturbations for realistic terrain detail, it computes a displaced midpoint if it is not small enough.

5. Initialization of OpenGL and Textures

Uses the external method LoadBitmapFile to load the grass bitmap texture from the file. The program exits and prints an error if loading is unsuccessful. Specifies the scene's clipping volume and sets up the OpenGL projection matrix with an orthographic projection (no perspective). transforms the clean background into a dark gray.

Running the Program to get Desire Result

Before compiling the program place the grass image in the source folder, let the program load and run pefectly. If the grass image not present then comiplation will be error free but non loading of image lead to failure of outcome.

Downloads

Source code will be provie for both main program and header file including the bitmap image on request by you to our email id openglprojects@gmail.com

Opengl Computer Graphics Projects on Solar Energy Solar Power

  

We are going to get started Opengl Computer Graphics Projects on Solar Power/Solar Energy.

 

Abstract

The Main aim of this Mini OpenGL Project is to illustrate/demonstrate the working principle of Solar power/Solar Energy using the concepts and usage of pre-built functions in OpenGL.

 

In this we are going to demo Solar power using OpenGL. During day electricity is generated through solar panels which are set in fields called as solar farms and is transmitted to near by homes and excess is stored in a power station. During night the power station supplies the stored power to homes. We have used input devices like mouse and key board to interact with in the OpenGL C/C++ program.

Solar Power

Solar power is the power or say energy generated by conversion of sunlight into electricity using solar panels. For Generating energy or power these panels (Solar Panels), uses the photovoltaic cells in them which, convert light into direct current (DC). The DC, afterwards converted to alternating current (AC) for further use in electricity supply or to grid connection, or for storage in batteries. This is  a renewable, green, clean energy source, with many advantages , helps in minimizing greenhouse gas emissions during operation and save plane from Global warming. 

1. The Basics

We are going to code this OpenGL C/C++ program using MS Visual Studio, you are free to use other IDE like Code Block, Dev C++ etc.

First we are going to develop front page where user will input their interaction to start the program. A help screen will also create for getting the information or usage. User will have choice and program will accordingly.

We will implement various primitive functions for creating the square, rectangle and circle shape for create the diagram require for the demo of this Opengl Computer Graphics Projects on Solar Energy.

2. Implementation

2. 1 Various functions used in this program.

 glutInit() : interaction between the windowing system and OPENGL is

initiated

 glutInitDisplayMode() : used when double buffering is required and depth

information is required

 glutCreateWindow() : this opens the OPENGL window and displays the title

at top of the window

 glutInitWindowSize() : specifies the size of the window

 glutInitWindowPosition() : specifies the position of the window in screen

co-ordinates

 glutKeyboardFunc() : handles normal ascii symbols

 glutSpecialFunc() : handles special keyboard keys

 glutReshapeFunc() : sets up the callback function for reshaping the window

 glutIdleFunc() : this handles the processing of the background

 glutDisplayFunc() : this handles redrawing of the window

 glutMainLoop() : this starts the main loop, it never returns

 glViewport() : used to set up the viewport

 glVertex3fv() : used to set up the points or vertices in three dimensions

 glColor3fv() : used to render color to faces

 glFlush() : used to flush the pipeline

glutPostRedisplay() : used to trigger an automatic redrawal of the object

 glMatrixMode() : used to set up the required mode of the matrix

 glLoadIdentity() : used to load or initialize to the identity matrix

 glTranslatef() : used to translate or move the rotation centre from one

point to another in three dimensions

glRotatef() : used to rotate an object through a specified rotation angle

Also See -

Electromagnetic induction demo with opengl graphic program

Mini Solar System Computer Graphics Programs

3D Solar System OpenGL graphics program

Wind Mill C++ Projects Download

3. User Interaction 

This program Opengl Computer Graphics Projects on Solar Energy Solar Power includes following interaction through keyboard.

S->  Toggle Day or night

H-> Get Help Menu

Q-> Quit

4. Source Code

The complete Source code of this Opengl Computer Graphics project can be found in the below. Please Let Us know about your opinion, feedback, question, doubt or any other queries in the comments section below.

void draw(){

if(day){

glClearColor(0.9,0.9,0.9,0.0);

}else{

glClearColor(0.3,0.3,0.3,0.0);

}

glPushMatrix();

glRotatef(angle,1,0,0);

glTranslatef(-10,20,-155);

glScaled(1,1,0.6);

if(day){

glColor3f(1,1,0);

}else{

glColor3f(1,1,1);

}

glutSolidSphere(5,100,100);

glPopMatrix();

glPushMatrix();

glTranslatef(0,-10,5);

glScaled(500,10,1000);

glColor3f(0.8,0.7,0.7);

glutSolidCube(1);

glPopMatrix();

drawHouse(-3,0,-55);

drawHouse(-4,0,-35);

drawHouse(-5,0,-15);

drawHouse(-10,0,-15);

//Solar Panels

for(int i=-1;i<3;i++)

{

for(int j=5;j>-2;j--)

drawSolarPanel(i*2,1,j);

}

//draw power station.

stroke_output(0.8,1.8,"Power Station");

// transformer

glPushMatrix();

glTranslatef(15,5,-100);

//glScaled(0,2,0.2);

glColor3f(1,0.3,0.3);

glutSolidCube(15);

glPopMatrix();

//Transformer Power levels

// y axis from 5 to 18 and show growth in one second delay

if(day){

if(grow<=15000){

grow++;

angle+=0.002;

}

}

else{

if(grow>=0){

grow--;

angle-=0.002;

}

}

if(grow>1000){

glPushMatrix();

glTranslatef(14.8,-2,-99.8);

glScaled(1,0.05,1);

glColor3f(1,1,0);

glutSolidCube(15);

glPopMatrix();

}

if(grow>2000){

glPushMatrix();

glTranslatef(14.8,-1,-99.8);

glScaled(1,0.05,1);

glColor3f(1,1,0);

glutSolidCube(15);

glPopMatrix();

}

if(grow>3000){

glPushMatrix();

glTranslatef(14.8,0,-99.8);

glScaled(1,0.05,1);

glColor3f(1,1,0);

glutSolidCube(15);

glPopMatrix();

}

if(grow>4000){

glPushMatrix();

glTranslatef(14.8,1,-99.8);

glScaled(1,0.05,1);

glColor3f(1,1,0);

glutSolidCube(15);

glPopMatrix();

}

if(grow>5000){

glPushMatrix();

glTranslatef(14.8,2,-99.8);

glScaled(1,0.05,1);

glColor3f(1,1,0);

glutSolidCube(15);

glPopMatrix();

}

if(grow>6000){

glPushMatrix();

glTranslatef(14.8,3,-99.8);

glScaled(1,0.05,1);

glColor3f(1,1,0);

glutSolidCube(15);

glPopMatrix();

}

if(grow>7000){

glPushMatrix();

glTranslatef(14.8,4,-99.8);

glScaled(1,0.05,1);

glColor3f(1,1,0);

glutSolidCube(15);

glPopMatrix();

}

if(grow>8000){

glPushMatrix();

glTranslatef(14.8,5,-99.8);

glScaled(1,0.05,1);

glColor3f(1,1,0);

glutSolidCube(15);

glPopMatrix();

}

if(grow>9000){

glPushMatrix();

glTranslatef(14.8,6,-99.8);

glScaled(1,0.05,1);

glColor3f(1,1,0);

glutSolidCube(15);

glPopMatrix();

}

if(grow>10000){

glPushMatrix();

glTranslatef(14.8,7,-99.8);

glScaled(1,0.05,1);

glColor3f(1,1,0);

glutSolidCube(15);

glPopMatrix();

}

if(grow>11000){

glPushMatrix();

glTranslatef(14.8,8,-99.8);

glScaled(1,0.05,1);

glColor3f(1,1,0);

glutSolidCube(15);

glPopMatrix();

}

if(grow>12000){

glPushMatrix();

glTranslatef(14.8,9,-99.8);

glScaled(1,0.05,1);

glColor3f(1,1,0);

glutSolidCube(15);

glPopMatrix();

}

if(grow>13000){

glPushMatrix();

glTranslatef(14.8,10,-99.8);

glScaled(1,0.05,1);

glColor3f(1,1,0);

glutSolidCube(15);

glPopMatrix();

}

if(grow>14000){

glPushMatrix();

glTranslatef(14.8,11,-99.8);

glScaled(1,0.05,1);

glColor3f(1,1,0);

glutSolidCube(15);

glPopMatrix();

}

if(grow>15000){

}

}

void doDisplay()

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glLoadIdentity();

glTranslatef(0.0f,0.0f,-13.0f);

// Write your Own Code Here

if(help1){

help();

}

else

{

draw();

}

GLfloat mat_ambient[]={0.0f,1.0f,2.0f,1.0f};

GLfloat mat_diffuse[]={0.0f,1.5f,.5f,1.0f};

GLfloat mat_specular[]={5.0f,1.0f,1.0f,1.0f};

GLfloat mat_shininess[]={100.0f};

glMaterialfv(GL_FRONT,GL_AMBIENT,mat_ambient);

glMaterialfv(GL_FRONT,GL_DIFFUSE,mat_diffuse);

glMaterialfv(GL_FRONT,GL_SPECULAR,mat_specular);

glMaterialfv(GL_FRONT,GL_SHININESS,mat_shininess);

/*GLfloat lightIntensity[]={3.7f,0.7f,0.7f,1.0f}; Orange

GLfloat light_position[]={2.0f,5.0f,3.0f,1.0f};*/

/*light source properties*/

//if(day){

GLfloat lightIntensity[]={1.7f,1.7f,1.7f,1.0f};

GLfloat light_position[]={2.0f,0.0f,0.0f,0.0f};

glLightfv(GL_LIGHT0,GL_POSITION,light_position);

GLfloat light_position2[]={0.0f,0.0f,8.0f,0.0f};

glLightfv(GL_LIGHT0,GL_POSITION,light_position2);

GLfloat light_position3[]={0.0f,5.0f,15.0f,0.0f};

glLightfv(GL_LIGHT0,GL_POSITION,light_position3);

glLightfv(GL_LIGHT0,GL_DIFFUSE,lightIntensity);

/*}else{

GLfloat lightIntensity[]={0.7f,0.7f,0.7f,0.5f};

GLfloat light_position[]={2.0f,0.0f,0.0f,0.0f};

glLightfv(GL_LIGHT0,GL_POSITION,light_position);

GLfloat light_position2[]={0.0f,0.0f,8.0f,0.0f};

glLightfv(GL_LIGHT0,GL_POSITION,light_position2);

GLfloat light_position3[]={0.0f,2.0f,2.0f,0.0f};

glLightfv(GL_LIGHT0,GL_POSITION,light_position3);

glLightfv(GL_LIGHT0,GL_DIFFUSE,lightIntensity);

}*/

glFlush();

glutSwapBuffers();

}

void mykey(unsigned char key,int x,int y)

{

if(key=='q'||key=='Q')

{

exit(0);

}

if(key=='h'||key=='H')

{

help1=!help1;

glutPostRedisplay();

}

if(key=='s' || key=='S'){

if(day){

day=false;

}else{

day=true;

}

glutPostRedisplay();

glutIdleFunc(doDisplay);

}

}

int main(int argc, char *argv[])

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);

glutInitWindowSize(640,480);

glutInitWindowPosition(0,0);

glutCreateWindow("Solar power");

glutDisplayFunc(doDisplay);

glEnable(GL_LIGHTING);

glEnable(GL_LIGHT0);

glShadeModel(GL_SMOOTH);

glEnable(GL_DEPTH_TEST);

glEnable(GL_NORMALIZE);

glutKeyboardFunc(mykey);

doInit();

glutMainLoop();

return 0;

}

We have so many good programs in OpenGL.

Create OpenGL CG Projects on Networking Data Communication

We have developed Selective Repeat ARQ a networking based Create OpenGL CG Projects with C/C++. In this post we are going to create new networking based project. As well aware of Internet which help us communicate through various means including mail, chat and social media. We are going to create OpenGL Project on Networking Data Communication. Let's get started with some basics information. 

Abstract - 

Our Aim is to Create, design and the illustrate the concepts and usage of Data Communication over Internet Using OpenGL C/C++. The Communication between two devices begins with a message/information of which one send the message and other receive it. The first device is called source, or sender while the second device i is the destination/receiver, of the message. The destination receives the message and interprets it. Another element involved in the process is called channel, which consists of the media that provides the pathway over which the message can travel from source to destination.

This program is implemented using various OpenGL functions which are shown below