Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
/*
* Project Name: BigDipper
* Solution Name: BigDipper
* Original creation date: 24/03/2008
* Edit date: 19/01/2013
* Programmer name: Jamie Taylor (aka "GaProgMan")
* File name: VBigDipper.cpp
*
* Purpose of the project:
* My favourite constellation is the Big Dipper. So
* it seemed only natrual that my first project,
* post university, was going to be the re-create
* the constellation (as I saw it in the night sky)
* with C++ and OpenGL
*
* GNU Copyright information
* Copyright 2011 Jamie Taylor <jamie@taylorj.org.uk>
*
* This program is free software; you can redistribute
* it and/or modify it under the terms of the GNU General
* Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will
* be useful, but WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A
* PARTICULAR PURPOSE. See the GNU General Public
* License for more details.
*
* You should have received a copy of the GNU General
* Public License along with this program; if not, write
* to the Free Software Foundation, Inc., 51 Franklin
* Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
// remove rarely used commands from attached headers
#define WIN32_LEAN_AND_MEAN
// the above command may only work on 32bit versions
// of windows
#define VC_EXTRALEAN
// multiple use headers, always good to include them. You
// never know when one of the commands might come in useful
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <atlstr.h>
#include <iostream>
#include <math.h>
#include <cstdlib>
#include <ctime>
// header required for windows
#include <windows.h>
//OpenGL and DevIL #includes
#include <math.h>
#include <GL\freeglut.h>
#include <GL\freeglut_ext.h>
#include <GL\freeglut_std.h>
#include <IL\il.h>
#include <IL\ilu.h>
#include <IL\ilut.h>
// required for some commands (cout and cin, etc)
using namespace std;
// Set the size of the OpenGL window, and screen space size
double winSizeX = 500;
double winSizeY = 500;
void DrawScene(void);
void renderBitmapString(float x, float y, void *font,char *string);
// This function is continuously called.
void Idle(void) {
DrawScene();
}
/***********************************************************
* renderBitmapString function
*
* This function takes a string, a set of co-ordinates,
* and a font, then outputs the string to the OpenGL
* window.
***********************************************************/
void renderBitmapString(float x, float y, void *font,char *string) {
// Fonts available are :
// GLUT_BITMAP_8_BY_13
// GLUT_BITMAP_9_BY_15
// GLUT_BITMAP_TIMES_ROMAN_10
// GLUT_BITMAP_TIMES_ROMAN_24
// GLUT_BITMAP_HELVETICA_10
// GLUT_BITMAP_HELVETICA_12
// GLUT_BITMAP_HELVETICA_18
glColor3f(1.0f, 1.0f, 1.0f);
char *c;
glRasterPos2f(x, y);
for (c=string; *c != '\0'; c++) {
glutBitmapCharacter(font, *c);
}
}
/***********************************************************
* Init function
*
* This function sets up the co-ordinate system, the point
* size, the background colour, and the drawing colour.
*
* The background colour is set to black
* (0 [red], 0 [green] , 0 [blue], 0 [alpha])
*
* The drawing colour is set to white
* (1 [red], 1 [green] , 1 [blue])
*
* The dot size is set to 1.0, which means that each drawn
* dot is 1 pixel by 1 pixel.
*
* The matrix, is set to Projection mode.
***********************************************************/
void Init() {
glClearColor(0.0, 0.0, 0.0, 0.0);
glColor3f(1.0f, 1.0f, 1.0f);
glPointSize(2.0);
glMatrixMode(GL_PROJECTION);
glOrtho(0, winSizeX, 0, winSizeY,-1,1);
glMatrixMode(GL_MODELVIEW);
}
/***********************************************************
* Reshape function
*
* This function is required for when the user reshapes the window.
***********************************************************/
void Reshape(int width, int height) {
glViewport(0, 0, width, height);
}
// uses ASCII for character input
void Key(unsigned char key, int x, int y) {
switch (key) {
case 27:
// escape key
exit(0);
break;
case ' ':
glutIdleFunc(Idle);
break;
}
}
// OpenGL GLUT method, (obviously) requires GLUt and OpenGL to work
void SpecialKey(int Specialkey, int x, int y) {
switch (Specialkey) {
case GLUT_KEY_DOWN:
break;
case GLUT_KEY_UP:
break;
case GLUT_KEY_LEFT:
break;
case GLUT_KEY_RIGHT:
break;
}
}
/***********************************************************
* DrawScene callback function
*
* This function is called every time around the unending
* loop that is the glutMainLoop (in the main function)
*
* This function contains all of the drawing commands.
* Anything commands that draw on screen, are contained in
* this function.
*
* glClear; clears the screen and depth buffer
*
* All objects to be drawn fall between a glBegin() and
* glEnd(). A good practise is to seperate each object
* into seperate calls of pairs.
*
* glFlush() flushes the screen buffer, and forces every
* thing within the buffer to be drawn on screen
***********************************************************/
void DrawScene(void) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Drawing code here
// Big dipper constellation
glBegin(GL_POINTS);
glVertex2i(289, 190); // Merak
glVertex2i(320, 128); // Phecda
glVertex2i(194, 101); // Megrez
glVertex2i(129, 83); // Alioth
glVertex2i(75, 73); // Mizar
glVertex2i(74, 74); // Alcor
glVertex2i(20, 10); // Alkaid
glEnd();
// End of drawing code
glutSwapBuffers();
// swap the buffers, end the drawing phase
}
/***********************************************************
* main function
*
* The main function is where all C++ programs begin
*
* glutInit
* This command initializes the OpenGL Utility Toolkit (GLUT)
*
* glutInitDisplayMode
* Specifies how the display should be initialised. The
* arguments (GLUT_SINGLE and GLUT_RGB) are ORed together,
* and indicate a single display buffer with RGB should be used.
*
* glutInitWindowSize
* Specifies the size of the screen window.
*
* glutInitWindowPosition
* Specifies the initial position of the screen window.
*
* glutInitCreateWindow
* Opens and displays the window, with the argument string
* being the text that appears in the title bar (at the top of the window)
*
* glutDisplayFunction
* Registers the (programmer specified) redraw function.
*
* glutMainLoop
* Enters the system into a never ending "wait until some
* thing happens" loop. Required for "event driven programming"
***********************************************************/
int main(int argc, char **argv) {
glutInitWindowSize(winSizeX, winSizeY);
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE);
glutCreateWindow("OpenGL Template");
Init();
glutReshapeFunc(Reshape);
glutSpecialFunc(SpecialKey);
glutKeyboardFunc(Key);
glutDisplayFunc(DrawScene);
glutIdleFunc(Idle);
glutMainLoop();
return 0; /* ANSI C requires main to return int. */
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.