Jump to content

  • Log In with Google      Sign In   
  • Create Account


Help with a Solar System


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
4 replies to this topic

#1 alexandrafotin   Members   -  Reputation: 105

Like
0Likes
Like

Posted 18 April 2013 - 07:25 AM

Hello everybody, 
I want to ask help for a project I make. 
I have made a complete solar system with key action for zoom in zoom out, moving along x,y,z axes on plus or minus and going up/down/right/left. 
I am now in a bit of a dilemma. 
I want to add a text window ( i have made my project in visual studio 2010 in win32 console application) where to put a text like a description of each planet to apear when i hit the left mouse button. 
E.g. When i click with the left mouse button the venus planet I want a description to apear in my text window.
However I don't know how to put make a text window and how to add mouse action (for the mouse action I have tried but it doesn't work)
Please help me!( write on private)
Thanks in advance.


Sponsor:

#2 BitMaster   Crossbones+   -  Reputation: 3650

Like
0Likes
Like

Posted 19 April 2013 - 01:39 AM

Please help me!( write on private)

The very point of a forum is being a free resource for everyone. Answering questions in private defeats the whole purpose and is very selfish.

That aside, you just have to properly process the mouse messages to react on button presses. Since you do not offer any information on what you use to create and manage the window (pure Windows API? SDL? GLUT? GLFW? SFML? ...) it is impossible to be less general here.

There are plenty of ways to get text in there. A common approach would be using freetype to render text into a bitmap, use that bitmap as a texture and render that texture with OpenGL.

#3 alexandrafotin   Members   -  Reputation: 105

Like
0Likes
Like

Posted 19 April 2013 - 11:42 PM

I have tried to use freetype but i didn't succeded.

Here is my code so far 

 
 
#include "SolarSystem.h"
 
#include "windows.h"
#include <stdio.h>
#include <stdlib.h>
#include<iostream>
using namespace std;
#include <gl/glut.h>
#include <GL/glu.h>
#include <gl/GL.h>
#include <math.h>
 
// Valori lumina
GLfloat  whiteLight[] = { 0.2f, 0.2f, 0.2f, 1.0f };
GLfloat  sourceLight[] = { 0.8f, 0.8f, 0.8f, 1.0f };
GLfloat  lightPos[] = { 0.0f, 0.0f, 0.0f, 1.0f };
 
//verificare pt incarcare texturi doar o data
bool texturesCreated = false;
 
//texturi
GLuint sunTexture;
GLuint mercuryTexture;
GLuint venusTexture;
GLuint earthTexture;
GLuint moonTexture;
GLuint marsTexture;
GLuint jupiterTexture;
GLuint saturnTexture;
GLuint uranusTexture;
GLuint neptuneTexture;
GLuint plutoTexture;
GLuint starsTexture;
 
//pozitia si rotatia soarelui
GLfloat fSunX = 0.0f;
GLfloat fSunY = 0.0f;
GLfloat fSunZ = -300.0f;
GLfloat fCamX = 0.0f;
GLfloat fCamY = 0.0f;
GLfloat fCamZ = 0.0f;
GLfloat fSunRotX = 0.0f;
GLfloat fSunRotY = 0.0f;
GLfloat fSunRotZ = 0.0f;
 
//definitii functii
void keyDown(unsigned char, int, int);
unsigned char *LoadBmp(char *fn, int *wi, int *hi);
void GenerateTextures(char *, int);
void InitialiseTextures(void);
 
 
void gl_init(int w, int h);
void gl_select(int x, int y);
void mouseClick();
void mousedw(int x, int y, int but);
void list_hits(GLint hits, GLuint *names);
 
 
//definitii pt click
#define Sun 1
#define Mercur 2
#define Venus 3
#define Terra 4
#define Moon 5
#define Marte 6
#define Jupiter 7
#define Saturn 8
#define Uranus 9
#define Pluto 10
#define Neptun 11
#define MAXSELECT 100
#define BUFSIZE 512
 
 
#define SW 450
#define SH 450
 
 
GLuint selectBuf[BUFSIZE];
GLuint buf_selectie[MAXSELECT];
GLint windH;
GLint viewport [4];
 
// Scena
void RenderScene(void)
{
//picking initializare stiva
glInitNames();
 
 
 
 
 
GLUquadricObj* pObj;
// Unghiul de revolutie al planetelor
static float fMoonRot = 0.0f;
static float fEarthRot = 0.0f;
static float fMercuryRot = 0.0f;
static float fVenusRot = 0.0f;
static float fMarsRot = 0.0f;
static float fJupiterRot = 0.0f;
static float fSaturnRot = 0.0f;
static float fUranusRot = 0.0f;
static float fNeptuneRot = 0.0f;
static float fPlutoRot = 0.0f;
 
// 
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
//Salvarea matricii cu stari 
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
 
 
// translatarea scenei in functie de soare
glTranslatef(fSunX, fSunY, fSunZ); 
 
// Soare
glDisable(GL_LIGHTING);
 
pObj = gluNewQuadric(); //creare obiecte cuadrice pt pObj
gluQuadricTexture(pObj,GL_TRUE);
 
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, sunTexture); //setare textura soare
 
//Rotatia soarelui in jurul axei sale
glRotatef(fSunRotX, 1.0f, 0.0f, 0.0f); //rotatie soare in jurul axei x
glRotatef(fSunRotY, 0.0f, 1.0f, 0.0f); //rotatie soare in jurul axei y
glRotatef(fSunRotZ, 0.0f, 0.0f, 1.0f); //rotatie soare in jurul axei z
glLoadName(Sun);
gluSphere(pObj, 33.0f, 30, 17); //draw sphere for the sun
glDisable(GL_TEXTURE_2D);
 
gluDeleteQuadric(pObj); //eliberare obiect pObj
 
glEnable(GL_LIGHTING);
 
// mutarea luminii la pozitia soareui
glLightfv(GL_LIGHT0,GL_POSITION,lightPos);
 
#pragma region skybox
 
// memorare matrice currenta
glPushMatrix();
 
 
 
glPushAttrib(GL_ENABLE_BIT);
glEnable(GL_TEXTURE_2D);
 
 
glColor4f(1,1,1,1);
GLfloat val = 450.0f;
 
// Render the front quad
glBindTexture(GL_TEXTURE_2D, starsTexture);
glBegin(GL_QUADS); 
glTexCoord2f(0, 0); glVertex3f(val, -val, val);
glTexCoord2f(1, 0); glVertex3f(-val, -val, val);
glTexCoord2f(1, 1); glVertex3f(-val, val, val);
glTexCoord2f(0, 1); glVertex3f(val, val, val);
glEnd();
 
// Render the left quad
glBindTexture(GL_TEXTURE_2D, starsTexture);
glBegin(GL_QUADS);
glTexCoord2f(0, 0); glVertex3f(val, -val, -val);
glTexCoord2f(1, 0); glVertex3f(val, -val, val);
glTexCoord2f(1, 1); glVertex3f(val, val, val);
glTexCoord2f(0, 1); glVertex3f(val, val, -val);
glEnd();
 
// Render the back quad
glBindTexture(GL_TEXTURE_2D, starsTexture);
glBegin(GL_QUADS);
glTexCoord2f(0, 0); glVertex3f(-val, -val, -val);
glTexCoord2f(1, 0); glVertex3f(val, -val, -val);
glTexCoord2f(1, 1); glVertex3f(val, val, -val);
glTexCoord2f(0, 1); glVertex3f(-val, val, -val);
 
glEnd();
 
// Render the right quad
glBindTexture(GL_TEXTURE_2D, starsTexture);
glBegin(GL_QUADS);
glTexCoord2f(0, 0); glVertex3f(-val, val, -val);
glTexCoord2f(1, 0); glVertex3f(-val, val, val);
glTexCoord2f(1, 1); glVertex3f(-val, -val, val);
glTexCoord2f(0, 1); glVertex3f(-val, -val, -val);
glEnd();
 
// Render the top quad
glBindTexture(GL_TEXTURE_2D, starsTexture);
glBegin(GL_QUADS);
glTexCoord2f(0, 0); glVertex3f(val, val, -val);
glTexCoord2f(1, 0); glVertex3f(val, val, val);
glTexCoord2f(1, 1); glVertex3f(-val, val, val);
glTexCoord2f(0, 1); glVertex3f(-val, val, -val);
glEnd();
 
// Render the bottom quad
glBindTexture(GL_TEXTURE_2D, starsTexture);
glBegin(GL_QUADS);
glTexCoord2f(0, 0); glVertex3f(-val, -val, -val);
glTexCoord2f(1, 0); glVertex3f(-val, -val, val);
glTexCoord2f(1, 1); glVertex3f(val, -val, val);
glTexCoord2f(0, 1); glVertex3f(val, -val, -val);
glEnd();
 
// Resetare matrice
glPopAttrib();
glPopMatrix();
 
#pragma endregion
 
#pragma region mercury 
 
//Mercur
glPushMatrix(); //salvare matrice
 
pObj = gluNewQuadric();
gluQuadricTexture(pObj,GL_TRUE);
 
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, mercuryTexture); //setare textura mercur
 
//coord de rotatie pt mercur
glRotatef(fMercuryRot, 0.0f, 2.0f, 0.3f);
 
//desenare Mercur
glTranslatef(45.0f,-15.0f,0.0f); //mutare mercur la distanta de soare
glRotatef(270.0f, 1.0f, 0.0f, 0.0f); //rotire
glRotatef(fMercuryRot * 3, 0.0f, 0.0f, 1.0f); //rotatie in jurul axei sale
glLoadName(Mercur);
gluSphere(pObj, 8.0f, 30, 17); //desenare sfera
glDisable(GL_TEXTURE_2D);
 
gluDeleteQuadric(pObj);
 
//viteza de rotatie
fMercuryRot += 20.0f;
//resetare rotatie
if(fMercuryRot >= 360.0f)
fMercuryRot = 0.0f;
 
glPopMatrix(); //resetare matrice
 
#pragma endregion
 
#pragma region venus
//Venus
glPushMatrix(); //salvare matrice
 
pObj = gluNewQuadric();
gluQuadricTexture(pObj,GL_TRUE);
 
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, venusTexture); //setare textura venus
 
//coord de rotire pt venus
glRotatef(fVenusRot, 0.0f, 1.0f, 0.0f);
 
//Desenare Venus
glTranslatef(65.0f,0.0f,0.0f); //mutare venus la distanta de soare
glRotatef(270.0f, 1.0f, 0.0f, 0.0f); //rotire
glRotatef(fVenusRot * 3, 0.0f, 0.0f, 1.0f); //rotatie in jurul axei sale
glLoadName(Venus);
gluSphere(pObj, 14.0f, 30, 17); //desenare sfera pt venus
glDisable(GL_TEXTURE_2D);
 
gluDeleteQuadric(pObj); 
 
//viteza rotire
fVenusRot += 10.0f;
//resetare rotire
if(fVenusRot >= 360.0f)
fVenusRot = 0.0f;
 
 
glPopMatrix();
 
#pragma endregion
 
#pragma region marte
//Marte
glPushMatrix();
 
pObj = gluNewQuadric();
gluQuadricTexture(pObj,GL_TRUE);
 
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, marsTexture); //setare textura marte
 
//coord de rotire pt marte
glRotatef(fMarsRot, 0.0f, 1.0f, 0.3f);
 
//desenare marte
glTranslatef(130.0f,0.0f,0.0f); //pozitionare marte la distanta de soare
glRotatef(270.0f, 1.0f, 0.0f, 0.0f); //rotatie 
glRotatef(fMarsRot * 3, 0.0f, 0.0f, 1.0f); //rotatie in jurul axei sale
glLoadName(Marte);
gluSphere(pObj, 7.0f, 30, 17); //desenare sfera
glDisable(GL_TEXTURE_2D);
 
gluDeleteQuadric(pObj);
 
//viteza rotatie
fMarsRot += 4.0f;
//resetare rotatie
if(fMarsRot >= 360.0f)
fMarsRot = 0.0f;
 
 
glPopMatrix();
 
#pragma endregion
 
#pragma region jupiter
//Jupiter
glPushMatrix(); 
 
pObj = gluNewQuadric();
gluQuadricTexture(pObj,GL_TRUE);
 
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, jupiterTexture); //setare textura jupiter
 
//coord de rotire pt jupiter
glRotatef(fJupiterRot, 0.0f, 1.0f, -0.3f);
 
//Desenare Jupiter
glTranslatef(200.0f,0.0f,0.0f); //pozitionare jupiter la distanta de soare
glRotatef(270.0f, 1.0f, 0.0f, 0.0f); //rotatie 
glRotatef(fJupiterRot * 3, 0.0f, 0.0f, 1.0f); //rotatie in jurul axei sale
glLoadName(Jupiter);
gluSphere(pObj, 22.0f, 30, 17); //desenare sfera
glDisable(GL_TEXTURE_2D);
 
gluDeleteQuadric(pObj); 
 
//setare viteza de rotatie 
fJupiterRot += 2.0f;
//resetare rotatie
if(fJupiterRot >= 360.0f)
fJupiterRot = 0.0f;
 
 
glPopMatrix();
 
#pragma endregion
 
#pragma region saturn
//Saturn
glPushMatrix(); 
 
pObj = gluNewQuadric();
gluQuadricTexture(pObj,GL_TRUE);
 
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, saturnTexture); //setare textura Saturn
 
//Coord de rotire pt Saturn
glRotatef(fSaturnRot, 0.0f, 0.8f, -0.2f);
 
//Desenare Saturn
glTranslatef(245.0f,0.0f,0.0f); //setare pozitie Saturn la distanta de soare
glRotatef(270.0f, 1.0f, 0.0f, 0.0f); //Rotatie
glRotatef(fSaturnRot * 3, 0.0f, 0.0f, 1.0f); //rotatie in jurul axei sale
glLoadName(Saturn);
gluSphere(pObj, 20.0f, 30, 17); //desenare sfera
glDisable(GL_TEXTURE_2D);
 
gluDeleteQuadric(pObj); 
 
//viteza rotatie
fSaturnRot += 1.5f;
//resetare rotatie
if(fSaturnRot >= 360.0f)
fSaturnRot = 0.0f;
 
glPopMatrix();
 
#pragma endregion
 
#pragma region uranus
//Uranus
glPushMatrix();
 
pObj = gluNewQuadric();
gluQuadricTexture(pObj,GL_TRUE);
 
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, uranusTexture); //setare textura pt Uranus
 
//coord de rotire pt Uranus
glRotatef(fUranusRot, 0.0f, 0.8f, 0.2f);
 
//Desenare Uranus
glTranslatef(285.0f,0.0f,0.0f); //pozitionare Uranus la distanta de soare
glRotatef(270.0f, 1.0f, 0.0f, 0.0f); //rotatie 
glRotatef(fUranusRot * 3, 0.0f, 0.0f, 1.0f); //rotatie in jurul axei sale
glLoadName(Uranus);
gluSphere(pObj, 10.0f, 30, 17); //desenare sfera
glDisable(GL_TEXTURE_2D);
 
gluDeleteQuadric(pObj); 
 
//viteza de rotatie
fUranusRot += 1.0f;
//resetare rotatie
if(fUranusRot >= 360.0f)
fUranusRot = 0.0f;
 
 
glPopMatrix();
 
#pragma endregion
 
#pragma region neptun
//Neptun
glPushMatrix();
 
pObj = gluNewQuadric();
gluQuadricTexture(pObj,GL_TRUE);
 
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, neptuneTexture); //setare textura pt neptun
 
//coord de rotatie pt neptun
glRotatef(fNeptuneRot, 0.0f, 0.8f, 0.2f);
 
//Desenare Neptune
glTranslatef(315.0f,0.0f,0.0f); //setare pozitie la distanta de soare
glRotatef(270.0f, 1.0f, 0.0f, 0.0f); //rotire 
glRotatef(fNeptuneRot * 3, 0.0f, 0.0f, 1.0f); //rotatie in jurul axei sale
glLoadName(Neptun);
gluSphere(pObj, 12.0f, 30, 17); //desenare sfera pt neptun
glDisable(GL_TEXTURE_2D);
 
gluDeleteQuadric(pObj); 
 
//viteza de rotatie
fNeptuneRot += 0.6f;
//resetare rotatie
if(fNeptuneRot >= 360.0f)
fNeptuneRot = 0.0f;
 
 
glPopMatrix();
 
#pragma endregion
 
#pragma region pluto
//Pluto
glPushMatrix(); 
 
pObj = gluNewQuadric();
gluQuadricTexture(pObj,GL_TRUE);
 
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, plutoTexture); //setare textura pt pluto
 
//coord de rotatie pt Pluto
glRotatef(fPlutoRot, 0.0f, 0.8f, 0.2f);
 
//Desenare Pluto
glTranslatef(350.0f,0.0f,0.0f); //setare la distanta de soare
glRotatef(270.0f, 1.0f, 0.0f, 0.0f); //rotatie 
glRotatef(fPlutoRot * 3, 0.0f, 0.0f, 1.0f); //rotatie in jurul axei sale
glLoadName(Pluto);
gluSphere(pObj, 12.0f, 30, 17); //desenare sfera
glDisable(GL_TEXTURE_2D);
 
gluDeleteQuadric(pObj); 
 
//viteza de rotatie
fPlutoRot += 0.2f;
//
if(fPlutoRot >= 360.0f)
fPlutoRot = 0.0f;
 
 
glPopMatrix();
 
#pragma endregion
 
#pragma region Terra
//Pamant
glPushMatrix();
 
pObj = gluNewQuadric();
gluQuadricTexture(pObj,GL_TRUE);
 
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, earthTexture);//setare textura
 
// coord de rotire pt pamant
glRotatef(fEarthRot, 0.0f, 1.0f, 0.0f); //rotatie in jurul soarelui
 
// Desenare Terra
glTranslatef(100.0f,0.0f,0.0f); //setare distanta de soare
glRotatef(270.0f, 1.0f, 0.0f, 0.0f); //rotire
glRotatef(fEarthRot * 3, 0.0f, 0.0f, 1.0f); //rotire in jurul axei sale
glLoadName(Terra);
gluSphere(pObj, 16.0f, 30, 17); //desenare sfera
glDisable(GL_TEXTURE_2D);
 
gluDeleteQuadric(pObj); 
 
#pragma region earthMoon
// Desenare Luna
pObj = gluNewQuadric();
gluQuadricTexture(pObj,GL_TRUE);
 
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, moonTexture); //setare textura Luna
glRotatef(fMoonRot,0.0f, 0.0f, 1.0f); //rotire luna in jurul pamantului
glTranslatef(25.0f, 0.0f, 0.0f); //distanta fata de pamant
glRotatef(270.0f, 1.0f, 0.0f, 0.0f); //rotire
glRotatef(fMoonRot * 3, 0.0f, 0.0f, 1.0f); //rotire in jurul axei sale
 
//viteza de rotatie
fMoonRot+= 15.0f;
//
if(fMoonRot >= 360.0f)
fMoonRot = 0.0f;
glLoadName(Moon);
gluSphere(pObj, 4.0f, 30, 17); //desenare sfera pt luna
glDisable(GL_TEXTURE_2D);
 
gluDeleteQuadric(pObj);
 
glPopMatrix(); 
#pragma endregion
 
 
//viteza de rotire a pamantului
fEarthRot += 5.0f;
//
if(fEarthRot >= 360.0f)
fEarthRot = 0.0f;
 
glPopMatrix(); // 
 
#pragma endregion
 
// Show  image
glutSwapBuffers();
 
}
 
 
 
void SetupRC()
{
//valoare si coord lumina
glEnable(GL_DEPTH_TEST); // 
glFrontFace(GL_CCW); // invers acelor de ceasornic (pt sfere)
glEnable(GL_CULL_FACE); //
 
// on lumina
glEnable(GL_LIGHTING);
 
// setare lumina
glLightModelfv(GL_LIGHT_MODEL_AMBIENT,whiteLight);
 
glLightfv(GL_LIGHT0,GL_AMBIENT_AND_DIFFUSE,sourceLight);
glLightfv(GL_LIGHT0,GL_POSITION,lightPos);
glEnable(GL_LIGHT0);
 
//
glEnable(GL_COLOR_MATERIAL);
 
// 
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
 
// setare background negru
glClearColor(0.0f, 0.0f, 0.0f, 1.0f );
}
 
void TimerFunc(int value)
{
glutPostRedisplay();
glutTimerFunc(100, TimerFunc, 1);
}
 
//posibilitate de minimizare si maximizare de catre user
void ChangeSize(int w, int h)
{
GLfloat fAspect;
 
// 
if(h == 0)
h = 1;
 
// setare vedere in functie de marimea ferestrei
glViewport(0, 0, w, h);
 
// aspect in functie de marimea ferestrei
fAspect = (GLfloat)w/(GLfloat)h;
 
//  setare coord pt ferestra
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
 
// modul de vizionare
gluPerspective(45.0f, fAspect, 1.0, 1600.0);
 
// 
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
 
 
void gl_init(int w, int h)
{
glClearColor(0.0f, 0.0f, 0.0f, 1.0f );
glViewport(0, 0, w, h);
 
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
 
gluPerspective(60.0, 1.0, 0.0001, 1000.0);
 
glMatrixMode(GL_MODELVIEW);
}
 
void list_hits(GLint hits, GLuint *names)
{
 
 
printf("%d hits:\n", hits);
 
switch(hits)
{
 
case Mercur:
cout<<"Ati selectat Planeta Mercur"<<endl;
break;
case Sun:
cout<<"Ati selectat Soarele"<<endl;
break;
case Saturn:
cout<<"Ati selectat Planeta Saturn"<<endl;
break;
case Neptun:
cout<<"Ati selectat Planeta Neptun"<<endl;
break;
case Uranus:
cout<<"Ati selectat Planeta Uranus"<<endl;
break;
case Jupiter:
cout<<"Ati selectat Planeta Jupiter"<<endl;
break;
case Marte:
cout<<"Ati selectat Planeta Marte"<<endl;
break;
case Venus:
cout<<"Ati selectat Planeta Venus"<<endl;
break;
case Pluto:
cout<<"Ati selectat Planeta Pluto"<<endl;
break;
case Terra:
cout<<"Ati selectat Planeta Pamant"<<endl;
break;
case Moon:
cout<<"Ati selectat Luna"<<endl;
break;
default:
cout<<"Nu ati selectat nimic"<<endl;
break;
 
}
 
}
 
void gl_select(int x, int y)
{
GLuint buff[64] = {0};
GLint hits, view[4];
 
/*
This choose the buffer where store the values for the selection data
*/
glSelectBuffer(64, buff);
 
/*
This retrieve info about the viewport
*/
glGetIntegerv(GL_VIEWPORT, view);
 
/*
Switching in selecton mode
*/
glRenderMode(GL_SELECT);
 
/*
Clearing the name's stack
This stack contains all the info about the objects
*/
glInitNames();
 
/*
Now fill the stack with one element (or glLoadName will generate an error)
*/
glLoadName(0);
 
/*
Now modify the vieving volume, restricting selection area around the cursor
*/
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
 
/*
restrict the draw to an area around the cursor
*/
gluPickMatrix(x, y, 0.2, 0.2, view);
gluPerspective(60, 0.5, 0.0001, 1000.0);
 
/*
Draw the objects onto the screen
*/
glMatrixMode(GL_MODELVIEW);
 
/*
draw only the names in the stack, and fill the array
*/
glutSwapBuffers();
RenderScene();
 
/*
Do you remeber? We do pushMatrix in PROJECTION mode
*/
glMatrixMode(GL_PROJECTION);
glPopMatrix();
 
/*
get number of objects drawed in that area
and return to render mode
*/
hits = glRenderMode(GL_RENDER);
 
/*
Print a list of the objects
*/
list_hits(hits, buff);
 
/*
uncomment this to show the whole buffer
* /
gl_selall(hits, buff);
*/
 
glMatrixMode(GL_MODELVIEW);
}
 
void mousedw(int x, int y, int but)
{
printf("Mouse button %d pressed at %d %d\n", but, x, y);
gl_select(x,SH-y); //Important: gl (0,0) ist bottom left but window coords (0,0) are top left so we have to change this!
}
 
 
void mouseClick(int button, int state, int x, int y)
{
if  ((button == GLUT_LEFT_BUTTON) && (state == GLUT_DOWN))
{
mousedw(x, y, button);
}
}
 
 
 
int main(int argc, char* argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
///glutInitWindowSize(1000, 600);
glutInitWindowSize(SW, SH);
glutInitWindowPosition(0, 0);
glutCreateWindow("Solar System"); //numele ferestrei
glutReshapeFunc(ChangeSize);
glutDisplayFunc(RenderScene);
glutKeyboardFunc(keyDown); //pt taste
//INREGISTRARIILE FUNCTIILOR PT MOUSE
glutMouseFunc(mouseClick);
// glutMouseFunc(mouse);
gl_init(SW, SH);
 
 
glutTimerFunc(250, TimerFunc, 1);
SetupRC();
//verificare textura
if (texturesCreated == false)
{
InitialiseTextures();
texturesCreated = true; //
}
glutMainLoop();
 
return 0;
}
 
//controale
void keyDown(unsigned char key, int x, int y) 
{
//Moves the camera to the right
if (key == 'A' || key == 'a')
{
fSunX += 3.0f;
fCamX += -3.0f;
}
//Moves the camera to the left
if (key == 'D' || key == 'd')
{
fSunX += -3.0f;
fCamX += 3.0f;
}
//Moves the camera up
if (key == 'W' || key == 'w')
{
fSunY += -3.0f;
fCamY += 3.0f;
}
//Moves the camera down
if (key == 'S' || key == 's')
{
fSunY += 3.0f;
fCamY += -3.0f;
}
//Zooms the camera out
if (key == 'X' || key == 'x')
{
fSunZ += -3.0f;
fCamZ += 3.0f;
}
//Zooms the camera in
if (key == 'Z' || key == 'z')
{
fSunZ += 3.0f;
fCamZ += -3.0f;
}
//Rotates the camera along the positive X axis
if (key == 'J' || key == 'j')
{
fSunRotY += 3.0f;
}
//Rotates the camera along the negative X axis
if (key == 'L' || key == 'l')
{
fSunRotY += -3.0f;
}
//Rotates the camera along the negative Y axis
if (key == 'I' || key == 'i')
{
fSunRotX += 3.0f;
}
//Rotates the camera along the positive Y axis
if (key == 'K' || key == 'k')
{
fSunRotX += -3.0f;
}
//Rotates the camera along the positive Z axis
if (key == 'M' || key == 'm')
{
fSunRotZ += -3.0f;
}
//Rotates the camera along the positive Z axis
if (key == 'N' || key == 'n')
{
fSunRotZ += 3.0f;
}
 
}
 
unsigned char *LoadBmp(char *fn, int *wi, int *hi)
{
BITMAPFILEHEADER bmfh;
BITMAPINFOHEADER bmih;
WORD bits;
FILE *t24;
unsigned char *lpBitmapBits;
long imagesize,nc;
 
// citire bitmap
t24=fopen((char *)fn,"rb");
if(t24 == NULL){printf("Could not open input file\n"); exit(0);}
fread((char *)&bmfh,sizeof(BITMAPFILEHEADER),1,t24);
fread((char *)&bmih,sizeof(BITMAPINFOHEADER),1,t24);
if(bmih.biClrUsed != 0)nc=bmih.biClrUsed;
else{
bits = bmih.biBitCount;
switch (bits){
case 1:    nc=2;   break;
case 4:    nc=16;  break;
case 8:    nc=256; break;
default:   nc=0;   break;
}
}
if(nc > 0){printf("Cannot handle paletted image\n"); exit(0);}
imagesize=bmfh.bfSize-bmfh.bfOffBits;
if((lpBitmapBits=(unsigned char *)malloc(imagesize)) == NULL){ fclose(t24); exit (0); }
fread((char *)lpBitmapBits,imagesize,1,t24);
fclose(t24);
*wi=bmih.biWidth; *hi=bmih.biHeight;
return lpBitmapBits;
}
 
 
 
void InitialiseTextures()
{
//load texturi
GenerateTextures("earth.bmp", 1);
GenerateTextures("sun.bmp", 2);
GenerateTextures("mercur.bmp", 3);
GenerateTextures("venus.bmp", 4);
GenerateTextures("moon.bmp", 5);
GenerateTextures("marte.bmp", 6);
GenerateTextures("jupiter.bmp", 7);
GenerateTextures("saturn.bmp", 8);
GenerateTextures("uranus.bmp", 9);
GenerateTextures("neptun.bmp", 10);
GenerateTextures("pluto.bmp", 11);
GenerateTextures("stars.bmp", 12);
}
 
//
void GenerateTextures(char *name, int i)
{
unsigned char *pix;
int w,h;
glEnable(GL_TEXTURE_2D);
//asigane pt texturi
pix=LoadBmp(name,&w,&h); 
if (i == 1) //gets & sets textura pt pamant
{
glGenTextures(1, &earthTexture);
glBindTexture(GL_TEXTURE_2D, earthTexture);
}
if (i == 2) //gets & sets textura pt soare
{
glGenTextures(1, &sunTexture);
glBindTexture(GL_TEXTURE_2D, sunTexture);
}
if (i == 3) //gets & sets textura pt mercur
{
glGenTextures(1, &mercuryTexture);
glBindTexture(GL_TEXTURE_2D, mercuryTexture);
}
if (i == 4) //gets & sets textura pt venus
{
glGenTextures(1, &venusTexture);
glBindTexture(GL_TEXTURE_2D, venusTexture);
}
if (i == 5) //gets & sets textura pt luna
{
glGenTextures(1, &moonTexture);
glBindTexture(GL_TEXTURE_2D, moonTexture);
}
if (i == 6) //gets & sets textura pt marte
{
glGenTextures(1, &marsTexture);
glBindTexture(GL_TEXTURE_2D, marsTexture);
}
if (i == 7) //gets & sets textura pt jupiter
{
glGenTextures(1, &jupiterTexture);
glBindTexture(GL_TEXTURE_2D, jupiterTexture);
}
if (i == 8) //gets & sets textura pt saturn
{
glGenTextures(1, &saturnTexture);
glBindTexture(GL_TEXTURE_2D, saturnTexture);
}
if (i == 9) //gets & setstextura pt uranus
{
glGenTextures(1, &uranusTexture);
glBindTexture(GL_TEXTURE_2D, uranusTexture);
}
if (i == 10) //gets & sets textura pt neptun
{
glGenTextures(1, &neptuneTexture);
glBindTexture(GL_TEXTURE_2D, neptuneTexture);
}
if (i == 11) //gets & sets textura pt pluto
{
glGenTextures(1, &plutoTexture);
glBindTexture(GL_TEXTURE_2D, plutoTexture);
}
if (i == 12) //gets & sets textura pt stele
{
glGenTextures(1, &starsTexture);
glBindTexture(GL_TEXTURE_2D, starsTexture);
}
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, w, h,
0, GL_BGR_EXT, GL_UNSIGNED_BYTE, pix);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
free(pix); //eliberare pix
glDisable(GL_TEXTURE_2D);
}
 


#4 BitMaster   Crossbones+   -  Reputation: 3650

Like
0Likes
Like

Posted 22 April 2013 - 12:40 AM

I have tried to use freetype but i didn't succeded.

What have you tried? What exactly did you do? What did not work? What were the exact error messages?

Edited by BitMaster, 22 April 2013 - 01:06 AM.


#5 Vortez   Crossbones+   -  Reputation: 2688

Like
0Likes
Like

Posted 22 April 2013 - 07:29 AM

NeHe have some nice fonts tutorial.

 

http://nehe.gamedev.net/tutorial/bitmap_fonts/17002/

http://nehe.gamedev.net/tutorial/freetype_fonts_in_opengl/24001/

 

Freetype fonts look better since they're antialiased but is more difficult to implement than simple bitmap fonts, but i find bitmap font more suitable for small font anyway, so, feel free to experiment with them.

 

You could try my bitmap font class build from the first tutorial, it work great and is easy to use, although i admit the build function could be a bit better... feel free to modify it if you wish. Bitmaster have a nice approach too, that would probably look even better that way.

 

Not that it matter much, but why did you defined pluto before neptune? Pluto is the fartest planet(or rather, was), not neptune, well, most of the time, due to is elliptical orbit.

 

Also, looking at your code, they're a lot of it that could be put inside functions intead, especially the planet drawing part, it's basically the same code but with different parameters. You could also store those numbers in arrays from 0 being the sun and 9, pluto. Same thing for the GenerateTexture function, all those ifs could be replaced with a loop using arrays.

 

GLuint PlanetTextures[10];

...

for(int i = 0; i <= 9; i++){
    glGenTextures(1, &PlanetTextures[i]);
    glBindTexture(GL_TEXTURE_2D, PlanetTextures[i]);
}

void DrawPlanets(GLuint Indx)
{
	glPushMatrix();
 
	pObj = gluNewQuadric();
	gluQuadricTexture(pObj,GL_TRUE);
 
	glEnable(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, PlanetTextures[Indx]);
 
	glRotatef(fNeptuneRot, InitialRotation[Indx].x, InitialRotation[Indx].y, InitialRotation[Indx].z);
 
	glTranslatef(Position[Indx].x,Position[Indx].y,Position[Indx].z);
	glRotatef(Rotation[Indx], 1.0f, 0.0f, 0.0f);
	glRotatef(fTilt[Indx] * 3, 0.0f, 0.0f, 1.0f);
	glLoadName(PlanetsName[Indx]);
	gluSphere(pObj, PlanetsSize[Indx].x, PlanetsSize[Indx].y, PlanetsSize[Indx].z);
	glDisable(GL_TEXTURE_2D);
 
	gluDeleteQuadric(pObj); 
 
	Rotation[Indx] += RotationIncrement[Indx];
	if(Rotation[Indx] >= 360.0f)
		Rotation[Indx] = 0.0f;
 
 
	glPopMatrix();
}

 

Much better now don't you think smile.png

 

As for the "mouse action", well just process the WM_LBUTTONDOWN message in the messages loop.

 

One last thing, im pretty sure you could generate those speres once at initialization time, then delete them when the program close, that would save you a bit of computation time and make the simulation faster.

 

I don't know how your simulation look, but i've tried to make one to real scale once and, well, everything was so tiny and far away it wasen't very good, but i guess yours look good by the way you described it. Good luck.


Edited by Vortez, 22 April 2013 - 09:08 AM.





Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS