opengl και glut

dinak · 4 Ιανουαρίου 2012

προσπαθώ να φτιάξω ένα 3d tetris, και για κάποιο λόγο ενώ θέλω με τα βελάκια να κινήσω την κάμερα, δεν τα καταφέρνω...μπορεί κάποιος να βοηθήσει;

>// 3dtetris.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdio.h>
#include <math.h>
#include <GL/glut.h>
#include <GL/gl.h>	     
#include <GL/glu.h>	  

#define WIDTH  800
#define HEIGHT 600

#define RED   0
#define GREEN 0
#define BLUE  0
#define ALPHA 1

#define N 5

GLuint face;
GLuint cube;

float angle=0;
float lx=0, lz=-1;
float x=0, z=9;


GLvoid initGL()	
{
 glClearColor(RED, GREEN, BLUE, ALPHA);	
 glClearDepth(1.0);				
 glDepthFunc(GL_LESS);                       
 glEnable(GL_DEPTH_TEST);                    
}

void init_scene()
{

 float x=0, y=0, z=0;
 face = glGenLists(2);
 cube = face+1;

 glNewList(face, GL_COMPILE);
   glBegin(GL_POLYGON);
     glVertex3f(0, 0, 0);
     glVertex3f(0.5, 0, 0);
     glVertex3f(0.5, 0.5, 0);
     glVertex3f(0, 0.5, 0);  
   glEnd();  
 glEndList();

 glNewList(cube, GL_COMPILE);
  
 glColor3f(1, 1, 0);
 glPushMatrix();
 glTranslatef(0, 0, -0.5);
 glCallList(face);
 glPopMatrix();
  
 for(int i=0;i<N;i++){

  y=y+0.5;

  glColor3f(1, 1, 0);
  glPushMatrix();
  glTranslatef(0, y, -0.5);
  glCallList(face);
  glPopMatrix();

  glColor3f(1, 1, 0);
  glPushMatrix();
  glTranslatef(-y, 0, -0.5);
  glCallList(face);
  glPopMatrix();
  
 
   glColor3f(0, 1, 1);
   glPushMatrix();
   glTranslatef(0.5, 0, 0);
   glRotatef(90, 0, 1, 0);
   glCallList(face);
   glPopMatrix();

glColor3f(0, 1, 1);
   glPushMatrix();
   glTranslatef(0.5, 0, y);
   glRotatef(90, 0, 1, 0);
   glCallList(face);
   glPopMatrix();

glColor3f(0, 1, 1);
   glPushMatrix();
   glTranslatef(0.5, y, 0);
   glRotatef(90, 0, 1, 0);
   glCallList(face);
   glPopMatrix();

   glColor3f(0, 0, 1);
   glPushMatrix();
   glRotatef(-90, 1, 0, 0);
   glCallList(face);
   glPopMatrix();

glColor3f(0, 0, 1);
   glPushMatrix();
glTranslatef(0, 0, y);
glRotatef(-90, 1, 0, 0);
   glCallList(face);
glPopMatrix();



for(int j=0;j<N;j++){

	  x=x-0.5;
	  z=z+0.5;
	 

	  glColor3f(1, 1, 0);
	  glPushMatrix();
	  glTranslatef(x, y, -0.5);
	  glCallList(face);
	  glPopMatrix();

	  glColor3f(0, 1, 1);
	  glPushMatrix();
	  glTranslatef(0.5, z, y);
	  glRotatef(90, 0, 1, 0);
	  glCallList(face);
	  glPopMatrix();	

	  glColor3f(0, 0, 1);
	  glPushMatrix();
	  glTranslatef(x, 0, y);
	  glRotatef(-90, 1, 0, 0);
	  glCallList(face);
	  glPopMatrix();

	  glColor3f(0, 0, 1);
	  glPushMatrix();
	  glTranslatef(x, 0, 0);
	  glRotatef(-90, 1, 0, 0);
	  glCallList(face);
	  glPopMatrix();


  }

  x=0;
  z=0;

 }  

 glEndList();
}



GLvoid window_reshape(GLsizei width, GLsizei height)
{
 if (height == 0) 
   height = 1; 
 
 glViewport(0, 0, width, height);

 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();
 gluPerspective(45, (GLdouble)width/(GLdouble)height, 1, 10); 
 glMatrixMode(GL_MODELVIEW);
}


void render_scene()
{
 glRotatef(40, 0, 1, 0);
 glRotatef(30, 0, 0, 1);
 glRotatef(30, 1, 0, 0);
 glCallList(cube);
}

GLvoid window_display()
{
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	    
 glLoadIdentity();
 gluLookAt(x, 0, z, x+lx, 0, z+lz, 0, 1, 0); // COP, VRP, VUP (defines view)
 render_scene();
 glFlush();
}

void special_keys(int key, int xx, int yy){

float fraction = 0.1;

switch(key){

case GLUT_KEY_LEFT :
	angle -= 0.01;
	lx = sin(angle);
	lz = -cos(angle);
	break;

case GLUT_KEY_RIGHT :
	angle += 0.01;
	lx = sin(angle);
	lz = -cos(angle);
	break;

case GLUT_KEY_UP :
	x += lx * fraction;
	z += lz * fraction;
	break;

case GLUT_KEY_DOWN :
	x -= lx * fraction;
	z -= lz * fraction;
	break;

}
}

int main(int argc, char **argv) 
{  
 glutInit(&argc, argv);
 glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH);

 glutInitWindowSize(WIDTH, HEIGHT);
 glutInitWindowPosition(0, 0);
 glutCreateWindow("3D tetris");

 initGL();  
 init_scene();

 glutDisplayFunc(window_display);
 glutReshapeFunc(window_reshape);
 glutSpecialFunc(special_keys);

 glEnable(GL_DEPTH_TEST);


 glutMainLoop();  

 return 1;
}

παπι · 4 Ιανουαρίου 2012

Πως ακριβος θελεις να συμπεριφερεται η καμερα ?

dinak · 10 Ιανουαρίου 2012

Πως ακριβος θελεις να συμπεριφερεται η καμερα ?

θέλω να περιστρέφεται γύρω από τον y άξονα...τα zoom in zoom out τα έχω καταφέρει

o καινούργιος μου κώδικας περιέχει τις εξής ρουτίνες

>void computePos(float deltaMove) {

x += deltaMove * lx * 0.01;
y += deltaMove * ly * 0.01;
z += deltaMove * lz * 0.01;
}

//void computeDir(float deltaAngle) {
//
//	angle += deltaAngle;
//	lx = sin(angle);
//	lz = -cos(angle);
//}


GLvoid window_display()
{

 if (deltaMove)
	computePos(deltaMove);

/* if (deltaAngle)
	computeDir(deltaAngle);*/
 


 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	    
 glLoadIdentity();
 gluLookAt(x, y, z, x+lx, y+ly, z+lz, 0, 1, 0); // COP, VRP, VUP (defines view)
 render_scene();
 glFlush();
}


void pressKey(int key, int x, int y) {

      switch (key) {
            case GLUT_KEY_F5: deltaMove = 0.02; break;
            case GLUT_KEY_F6 : deltaMove = -0.02; break;
      }
} 

void releaseKey(int key, int x, int y) { 	

       switch (key) {
            case GLUT_KEY_F5 :
            case GLUT_KEY_F6 : deltaMove = 0;break;
       }
} 

void mouseButton(int button, int state, int x, int y) {

// only start motion if the left button is pressed
if (button == GLUT_LEFT_BUTTON) {

	// when the button is released
	if (state == GLUT_UP) {
		angle += deltaAngle;
		xOrigin = -1;
	}
	else  {// state = GLUT_DOWN
		xOrigin = x;
	}
}
}

void mouseMove(int x, int y) {

// this will only be true when the left button is down
if (xOrigin >= 0) {

	// update deltaAngle
	deltaAngle = (x - xOrigin) * 0.001;

	// update camera's direction
	lx = sin(angle + deltaAngle);
	lz = -cos(angle + deltaAngle);
}
}

αλλά δεν μπορώ να καταλάβω πως θα το κάνω να περιστρέφεται γύρω την σκηνή...αυτό που κάνει τώρα είναι να περιστρέφεται γύρω από την δικιά μου οπτική γωνία

παπι · 10 Ιανουαρίου 2012

Πω πω. Γιατι εχουν βαλει το world view μαζι στο glut;

Κοιτα, μια προσεκγιση με matrices world view transformation projection

Θα ηταν ετσι

>

GLvoid window_display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//gluLookAt(x, 0, z, x+lx, 0, z+lz, 0, 1, 0); // COP, VRP, VUP (defines view)
gluLookAt(
	0.0f,3.0f,-20.0f,//eye
	0.0f,0.0f,0.0f, //look at
	0.0f,1.0f,0.0f); //up
//render_scene();

glPushMatrix();//World Olos o kosmos 8a mikrinei
glScalef(0.5,0.5f,0.5);

	glPushMatrix();//View auto paizei to rolo ths kameras
	static float yRotate = 0.0f;
	yRotate+= 0.5f;
	if(yRotate > 360) yRotate = 0.0f;
	glRotatef(yRotate,0.0f,1.0f,0.0f); // peristorfh ths kameras apo ton aksona y
	

		//edw kanoyme ta transformation gia ka8e object
		glPushMatrix();//transformation 1
		glTranslatef(2.0f,-2.0f,0.0f);
		glCallList(cube);
		glPopMatrix();

		glPushMatrix();//transformation 2
		glTranslatef(-2.0f,2.0f,0.0f);
		glCallList(cube);
		glPopMatrix();

		glPushMatrix();//transformation 3
		glTranslatef(2.0f,2.0f,0.0f);
		glCallList(cube);
		glPopMatrix();

		glPushMatrix();//transformation N... kai paei legontas
		glTranslatef(-2.0f,-2.0f,0.0f);
		glCallList(cube);
		glPopMatrix();

	glPopMatrix();
glPopMatrix();
glFlush();
}

Αλλα επειδη βλεπω οτι τα matrices υπολογιζονται εσωτερικα, τοτε με τον παραπανω τροπο θα σου βγει η παναγια για να βγαλεις pitch roll yaw

dinak · 18 Ιανουαρίου 2012

βασικά τώρα έχω το εξής πρόβλημα....θέλω να βάλω στο τέτρις να πέφτουν τα τουβλάκια. Οπότε έχω την place_cubes για να φτιάχνει τα κουτιά ανάλογα με τα αποτελέσματα της cubejoin που φτιάχνει τυχαίες συναθροίσεις τέτοιων κουτιών.

>void place_cubes(int pos_used[27]){

int i, j, k, l;
int temp;
float x1num, y1num, z1num, x2num, y2num, z2num;


//initGL();

for(i=0;i<27;i++){

	if(pos_used[i]==-1)
		break;

	temp=pos_used[i];

	for(j=0;j<3;j++){

		for(k=0;k<3;k++){

			for(l=0;l<3;l++){

				if(temp==c[k][j][l].number){

					x1num=c[k][j][l].x1;
					x2num=c[k][j][l].x2;
					y1num=c[k][j][l].y1;
					y2num=c[k][j][l].y2;
					z1num=c[k][j][l].z1;
					z2num=c[k][j][l].z2;


					glBegin(GL_POLYGON);
						glColor3f(1,0,1);
						glVertex3f(x1num, y1num, z1num);
						glVertex3f(x2num, y1num, z1num);
						glVertex3f(x2num, y2num, z1num);
						glVertex3f(x1num, y2num, z1num);
						glVertex3f(x1num, y2num, z2num);
						glVertex3f(x1num, y1num, z2num);
						
						glVertex3f(x1num, y1num, z1num);

						glVertex3f(x2num, y1num, z1num);
						glVertex3f(x2num, y1num, z2num);
						glVertex3f(x1num, y1num, z2num);

						//glVertex3f(x2num, y1num, z2num);
						//glVertex3f(x2num, y2num, z1num);
						
					glEnd();

					
						
				}
			}
		}
	}
}
}

>
void cubejoin(){

int cubes;
int i;
int pos, newpos;
int neighbors[27][27];
int pos_used[27];


for(i=0;i<27;i++)
	pos_used[i]=-1;

for(i=0;i<27;i++){

	for(int j=0;j<27;j++){

		neighbors[i][j]=0;
	}
}

neighbors[0][1]=1;
neighbors[0][3]=1;
neighbors[0][9]=1;

neighbors[1][0]=1;
neighbors[1][2]=1;
neighbors[1][4]=1;
neighbors[1][10]=1;

neighbors[2][1]=1;
neighbors[2][5]=1;
neighbors[2][11]=1;

neighbors[3][0]=1;
neighbors[3][6]=1;
neighbors[3][4]=1;
neighbors[3][12]=1;

neighbors[4][1]=1;
neighbors[4][3]=1;
neighbors[4][5]=1;
neighbors[4][7]=1;
neighbors[4][13]=1;

neighbors[5][2]=1;
neighbors[5][4]=1;
neighbors[5][8]=1;
neighbors[5][14]=1;

neighbors[6][3]=1;
neighbors[6][7]=1;
neighbors[6][15]=1;

neighbors[7][6]=1;
neighbors[7][4]=1;
neighbors[7][8]=1;
neighbors[7][16]=1;

neighbors[8][7]=1;
neighbors[8][5]=1;
neighbors[8][17]=1;

neighbors[9][10]=1;
neighbors[9][12]=1;
neighbors[9][0]=1;
neighbors[9][18]=1;

neighbors[10][9]=1;
neighbors[10][11]=1;
neighbors[10][13]=1;
neighbors[10][1]=1;
neighbors[10][19]=1;

neighbors[11][10]=1;
neighbors[11][14]=1;
neighbors[11][2]=1;
neighbors[11][20]=1;

neighbors[12][9]=1;
neighbors[12][13]=1;
neighbors[12][15]=1;
neighbors[12][3]=1;
neighbors[12][21]=1;

neighbors[13][12]=1;
neighbors[13][10]=1;
neighbors[13][14]=1;
neighbors[13][16]=1;
neighbors[13][4]=1;
neighbors[13][22]=1;

neighbors[14][11]=1;
neighbors[14][13]=1;
neighbors[14][17]=1;
neighbors[14][5]=1;
neighbors[14][23]=1;

neighbors[15][12]=1;
neighbors[15][16]=1;
neighbors[15][6]=1;
neighbors[15][24]=1;

neighbors[16][15]=1;
neighbors[16][17]=1;
neighbors[16][13]=1;
neighbors[16][7]=1;
neighbors[16][25]=1;

neighbors[17][16]=1;
neighbors[17][14]=1;
neighbors[17][8]=1;
neighbors[17][26]=1;

neighbors[18][19]=1;
neighbors[18][21]=1;
neighbors[18][9]=1;

neighbors[19][18]=1;
neighbors[19][20]=1;
neighbors[19][22]=1;
neighbors[19][10]=1;

neighbors[20][19]=1;
neighbors[20][23]=1;
neighbors[20][11]=1;

neighbors[21][18]=1;
neighbors[21][22]=1;
neighbors[21][24]=1;
neighbors[21][12]=1;

neighbors[22][21]=1;
neighbors[22][19]=1;
neighbors[22][23]=1;
neighbors[22][25]=1;
neighbors[22][13]=1;

neighbors[23][22]=1;
neighbors[23][20]=1;
neighbors[23][26]=1;
neighbors[23][14]=1;

neighbors[24][21]=1;
neighbors[24][25]=1;
neighbors[24][15]=1;

neighbors[25][24]=1;
neighbors[25][22]=1;
neighbors[25][26]=1;
neighbors[25][16]=1;

neighbors[26][25]=1;
neighbors[26][23]=1;
neighbors[26][17]=1;




//choose number of cubes you want to use
srand(time(NULL));
cubes = rand()% 27 + 1;

//pick the first cube

pos_used[0] = rand()% 27;


for(i=1;i<cubes;i++){

	//choose one position inside the cube

	pos=rand() % 27;
	

	//check if pos is neighbor with any of pos_used

	while(newpos=check_neighbor(pos, pos_used, neighbors)==-1){
		
		pos=rand() % 27;
	}


	pos_used[i]=pos;



}


place_cubes(pos_used);


}
}

η main μου είναι η εξής:

>
int main(int argc, char **argv) 
{  
 glutInit(&argc, argv);
 glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH);

 glutInitWindowSize(WIDTH, HEIGHT);
 glutInitWindowPosition(0, 0);
 glutCreateWindow("3D tetris");

 initGL();  
 init_scene();

 

 fall=true;
 glutDisplayFunc(window_display);
 glutReshapeFunc(window_reshape);
 glutIdleFunc(window_display);	
 
   glutKeyboardFunc(presskeyboard);
glutIgnoreKeyRepeat(1);
glutKeyboardUpFunc(releasekeyboard);


 glutSpecialFunc(pressKey);


 glutIgnoreKeyRepeat(1);
 glutSpecialUpFunc(releaseKey);


 glutMouseFunc(mouseButton);
 glutMotionFunc(mouseMove);

 glEnable(GL_DEPTH_TEST);


 glutMainLoop();  

 return 1;
}

και η window_display η

>GLvoid window_display()
{

if (deltaMove)
	computePos(deltaMove);

if (deltax || deltay || deltaz)
	Newpos(deltax, deltay, deltaz);



	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	    
	glLoadIdentity();
	gluLookAt(x+lx, y+ly, z+lz, 0, 0, 0, 0, 1, 0); // COP, VRP, VUP (defines view)

	glRotatef(yrot, 0, 1, 0);
    glRotatef(zrot, 0, 0, 1);
    glRotatef(xrot, 1, 0, 0);
	glTranslatef(tx, ty, tz);


  
	glCallList(scene);

	glPushMatrix();
	glTranslatef(0, 8, 0);
	glPopMatrix();
	
	cubejoin();


	glFlush();
 
}

το πρόβλημα μου είναι ότι η cubejoin εκτελείται συνεχώς...δηλαδή φτιάχνει συνεχώς καινούργιες συναθροίσεις και δε παραμένει μία σταθερή για να πέσει μέχρι κάτω στην σκηνή....πως μπορώ να βάλω την cubejoin να μου κρατάει μόνο μια συγκεκριμένη συνάθροιση, μέχρι να πέσει κάτω;

επίσης ο φωτισμός μου για κάποιο λόγο δε λειτουργεί στις συναθροίσεις της cubejoin...εάν κάνω λίστα τότε λειτουργεί μια χαρά...

>
GLvoid initGL()	
{

 GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
 GLfloat mat_emission[] = { 0, 0, 0, 1.0 };
 GLfloat mat_shininess[] = { 50.0 };
 GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
 GLfloat ambient_color[] = { 0, 0, 0, 1.0 };
 GLfloat diffuse_color[] = { 1.0, 1.0, 1.0, 1.0 };
 GLfloat specular_color[] = { 1.0, 1.0, 1.0, 1.0 };
   
 glClearColor(RED, GREEN, BLUE, ALPHA);	
 glClearDepth(1.0);				
 glDepthFunc(GL_LESS); 

 glEnable(GL_LIGHTING);
 glEnable(GL_COLOR_MATERIAL);
 glShadeModel (GL_SMOOTH);
 glEnable(GL_LIGHT0);     
 glLightfv(GL_LIGHT0, GL_AMBIENT, ambient_color );
 glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse_color );
 glLightfv(GL_LIGHT0, GL_SPECULAR, specular_color );
 glLightfv(GL_LIGHT0, GL_POSITION, light_position);

 
 glColorMaterial ( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
 glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
 glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);
 glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
 
 

     

               
}

V.I.Smirnov · 18 Ιανουαρίου 2012

Ένα πράγμα έχω να σου και μην απογοητευτείς.

Όλη αυτή η τεχνοτροπία που χρησιμοποιείς, δηλ. η fixed function pipeline, είναι τελείως ξεπερασμένη.

Όλα τα αντίστοιχα χαρακτηριστικά έχουν χαρακτηριστεί deprecated και σταδιακά θα αφαιρεθούν από τις

μελλοντικές εκδόσεις του openGL.

Δεν τα βγάζουν αμέσως για λόγους συμβατότητας (αυτό είναι ένα μεγάλο πλεονέκτημα σε σχέση με το DX).

Το openGl από την έκδοση 3.0 και εντεύθεν χρησιμοποιεί programming pipeline, δηλ. openGL shading language

και GLSL shaders. Όλα πρέπει να γίνονται πλέον μόνον με αυτά κι όχι με την fixed pipeline.

Eιδικότερα, τα πεπαλαιωμένα χαρακτηριστικά είναι :

- Color Index mode

- OpenGL shading language versions 1.10 and 1.20

- Immediate mode

- Fixed-function vertex processing

- Matrix stacks

- Client vertex arrays

- Rectangles

- Raster position

- Non-sprite points

- Wide lines and line stipple

- Quadrilateral and polygon primitives

- Separate polygon drawing mode

- Polygon stipple

- Pixel drawing

- Bitmaps

- Texture wrap mode—GL_CLAMP

- Display lists

- The selection buffer

- The accumulation buffer

- Αpha test

- Attribute stacks

- Evaluators

- Unified extension string

Τα περισσότερα από τα παραπάνω υλοποιούνται πλέον με shaders.

Κάποια δεν έχουν αντίστοιχο στις νέες εκδόσεις επειδή η διαδικασία γίνεται

πιο αποτελεσματικά και δεν χρειάζονται. Π.χ. οι display lists είναι πλέον άχρηστες.

Kάποια έχουν καταργηθεί εντελώς επειδή δεν ανήκουν στο rendering API, π.χ. το selection buffer.

Η πολιτική για την αφαίρεσή τους είναι όπως είπα να χαρακτηρίζονται deprecated.

Ένα deprecated χαρακτηριστικό δεν πρέπει να χρησιμοποιείται σε νέα προγράμματα.

Σε κάποια από τις μελλοντικές εκδόσεις το deprecated χαρακτηριστικό θα αφαιρείται

και πιθανόν να υποστηριχτεί ως ειδική επέκταση για λόγους συμβατότητας μόνον.

Και τελικά θα κοπεί εντελώς.

Όσο πιο γρήγορα στραφείς στον σωστό δρόμο τόσο το καλύτερο, δεν θα χάσεις τον χρόνο σου με αρχαιολογίες.

Προς γνώσιν και συμμόρφωσιν...

-

dinak · 18 Ιανουαρίου 2012

συμφωνώ...αλλά όλο το παραπάνω είναι εργασία για τη σχολή μου...και χρησιμοποιώ τις μεθόδους που μας διδάσκουνε....

V.I.Smirnov · 18 Ιανουαρίου 2012

Χάνετε τον χρόνο σας, άσκοπα, δυστυχώς.

Το κακό είναι ότι δεν ψάχνετε την βιβλιογραφία να δείτε τι λένε οι ειδικοί επί του θέματος και

μένετε προσκολλημένοι τυφλά μόνον σε ότι σας πουν στην σχολή, είτε σωστό είτε λάθος.

Αν διάβαζες από κάποιο σύγχρονο βιβλίο, θα τα έβλεπες όλα με την σωστή σειρά και τον σωστό τρόπο,

και θα ήταν σίγουρο ότι ο χρόνος και ο κόπος σου θα πιάσουν τόπο.

Τώρα μαθαίνεις πράγματα που είναι μια δεκαετία πίσω.

Το DX έβαλε τους προγραμματιστές του στην programming pipeline σχεδόν με το ζόρι διότι

κατάργησε την fixed και έσπασε την συμβατότητα (και όχι μόνον μια φορά).

Το opengl εφαρμόζει την πολιτική deprecated για να να μην σπάσει αμέσως την συμβατότητα.

Κάποιοι αντί να το χρησιμοποιήσουν αυτό για να προσαρμοστούν ομαλότερα,

έκλεισαν τα μάτια τους και έμειναν εκεί.

Κοντολογίς, οι μέθοδοι που σας διδάσκουν είναι για ιστορικό μάθημα.

Δεν ξέρω τι θα κάνεις τελικά, εγώ είπα απλώς ποιό είναι το σωστό....καλή συνέχεια...

-

παπι · 18 Ιανουαρίου 2012

Λοιπον, το λογικοτερο θα ηταν να παρεις ενα προγραμμα μοντελοποιησης τυπου 3dmax blender etc μπλα μπλα μπλα.

Τεσπα, το να φτιαξεις ενα σχημα προγραμματιστικα ειναι δυσκολο, αλλα γινεται. Ας πουμε οτι θελουμε να φτιαξουμε ενα Γ, αυτο αποτελειται απο κυβους αρα θελουμε εναν κυβο (vertices για εναν κυβο). Ο γουγλη μου λεει οτι υπαρχει μια συναρτηση που φτιαχνει (vertices??? ) κυβους (glutSolidCube)

Για να φτιαξεις το Γ θες 4 κυβους (ψεμα εναν)

Η λογικη για την κατασκευη του ειναι απλη.

1) Φτιαχνεις εναν vertex buffer (δεν ξερω πως γινεται σε gl) για εναν κυβο το ονομαζεις... πες cube

2) Φτιαχνεις ενα matrix

3) ζωγραφιζεις τον πρωτο κυβο ( με κεντρο βαρος να ειναι το πραγματικο κεντρο βαρους , δλδ το xyz 0 να ειναι στο κεντρο του κυβου)

4) κανεις translate το matrix (0,1,0) ενα κυβο πιο πανω, ζωγραφιζεις το cube με βαση το εν λογο matrix

5) translate το matrix (1,0,0) ενα κυβο δεξια, ξαναζωγραφιζεις το cube

6) translate translate μεχρι να φτιαχτει το σχημα

Τωρα το 3-6 ειναι μια διαδικασια που φτιανει ενα Γ, εφοσον εισαι σε c++ θα ηταν αμαρτια να μην παιξεις με classes, για αυτο φτιαχνεις μια κλαση για να σου κραταει το Γ.

πχ

>

class ObjectΓ
{
private:
float rotateZ;
float translateY;
bool isSelected;

void DrawMesh()
{
	//φτιαξε ενα Γ
	/* indices (0 = center)
	| 1 | 2 |
	| 0 |
	| 3 |
	*/
	glPushMatrix(); // to transformation toy objectΓ
	if(this->isSelected)
		glColor3f(1.0f,1.0f,1.0f); //αν ειναι το επιλεγμενο σχημα βαλτου ασπρο χρωμα 
	else
		glColor3f(.5f,.5f,.5f);
	//idx 0
	
	glutSolidCube(1.0f);

	//idx 1
	glTranslatef(0.0f,1.0f,0.0f);
	glutSolidCube(1.0f);

	//idx 2
	glTranslatef(-1.0f,0.0f,0.0f);
	glutSolidCube(1.0f);

	//idx 3
	glTranslatef(1.0f,-2.0f,0.0f);
	glutSolidCube(1.0f);


	glPopMatrix();
}
public:
ObjectΓ()
	: rotateZ(0.0f),translateY(0.0f),
	isSelected(false)
{
}
void Render()
{
	glPushMatrix();

	glTranslatef(0.0f,translateY,0.0f);
	glRotatef(this->rotateZ,0.0f,0.0f,1.0f);
	
	this->DrawMesh();

	glPopMatrix();
}
void MoveDown()
{
	this->translateY -= 1.0f;
}
void SpinRight()
{
	this->rotateZ += 90.0f;
}
void SpinLeft()
{
	this->rotateZ -= 90.0f;
}
bool& Selected()
{
	return this->isSelected;
}
};

Λοιπον η DrawMesh ειναι το 3-6 που εγραψα πιο πανω. Το βαζουμε σε ξεχωριστη συναρτηση επειδη η δουλεια της ειναι μονο να κατασκευασει το κυβο. Φτιαχνεις μια Render συναρτηση η οποια θα οριζει την θεση του ολου σχηματος (Γ), αυτη θα εχει αλλο matrix το οποιο στο παραπανω το περιστρερφω/μετακινω (μπορεις να βαλεις και αλλα).

Με δυο πραματα παραπανω εχεις αυτο το αποτελεσμα

http://www.youtube.com/watch?v=Xf3-3FFJptw

Οι αλλαγες που εκανα ( τα περισσοτερα ειναι απομειναρια απο το δικο σου source)

>#include "stdafx.h"
#include <Windows.h>


#include <math.h>
#include "E:/emb/glut-3.7.6-bin/glut.h"
#pragma comment(lib,"E:/emb/glut-3.7.6-bin/glut32.lib")
#include <GL/gl.h>       	
#include <GL/glu.h>      



#define WIDTH  800
#define HEIGHT 600

#define RED   0
#define GREEN 0
#define BLUE  0
#define ALPHA 1

#define N 5

GLuint face;
GLuint cube;

float angle=0;
float lx=0, lz=-1;
float x=0, z= 9;


class ObjectΓ
{
private:
float rotateZ;
float translateY;
bool isSelected;

void DrawMesh()
{
	//φτιαξε ενα Γ
	/* indices (0 = center)
	| 1 | 2 |
	| 0 |
	| 3 |
	*/
	glPushMatrix(); // to transformation toy objectΓ
	if(this->isSelected)
		glColor3f(1.0f,1.0f,1.0f); //to xrwma 
	else
		glColor3f(.5f,.5f,.5f);
	//idx 0
	
	glutSolidCube(1.0f);

	//idx 1
	glTranslatef(0.0f,1.0f,0.0f);
	glutSolidCube(1.0f);

	//idx 2
	glTranslatef(-1.0f,0.0f,0.0f);
	glutSolidCube(1.0f);

	//idx 3
	glTranslatef(1.0f,-2.0f,0.0f);
	glutSolidCube(1.0f);


	glPopMatrix();
}
public:
ObjectΓ()
	: rotateZ(0.0f),translateY(0.0f),
	isSelected(false)
{
}
void Render()
{
	glPushMatrix();

	glTranslatef(0.0f,translateY,0.0f);
	glRotatef(this->rotateZ,0.0f,0.0f,1.0f);
	
	this->DrawMesh();

	glPopMatrix();
}
void MoveDown()
{
	this->translateY -= 1.0f;
}
void SpinRight()
{
	this->rotateZ += 90.0f;
}
void SpinLeft()
{
	this->rotateZ -= 90.0f;
}
bool& Selected()
{
	return this->isSelected;
}
};
ObjectΓ obj;

#include <vector>
std::vector<ObjectΓ> objs;



GLvoid initGL() 
{
 glClearColor(RED, GREEN, BLUE, ALPHA);        
 glClearDepth(1.0);                            
 glDepthFunc(GL_LESS);                   	
 glEnable(GL_DEPTH_TEST);

 objs.push_back(ObjectΓ());
 objs.push_back(ObjectΓ());
 objs.push_back(ObjectΓ());
 objs[1].Selected() = true;
}
GLvoid window_reshape(GLsizei width, GLsizei height)
{
 if (height == 0) 
   height = 1; 
 
 glViewport(0, 0, width, height);

 glMatrixMode(GL_PROJECTION);
 glLoadIdentity();
 gluPerspective(45.0, (GLdouble)width/(GLdouble)height, 1, 100);
 glMatrixMode(GL_MODELVIEW);
}



GLvoid window_display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(
	5.0,0.0,-15.0,//eye
	0.0,0.0,0.0, //look at
	0.0f,1.0f,0.0f); //up

glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
//Object 
glPushMatrix();
glScalef(.5f,.5f,.5f);
for(int i = 0; i < objs.size(); i++)
	objs[i].Render();
	
glPopMatrix();
glFlush();
}

void special_keys(int key, int xx, int yy){

       float fraction = 0.1;

       switch(key){

       case GLUT_KEY_LEFT :
		for(int i = 0; i < objs.size(); i++)
		{
			if(objs[i].Selected())
				objs[i].SpinLeft();
		}
               break;

       case GLUT_KEY_RIGHT :
		for(int i = 0; i < objs.size(); i++)
		{
			if(objs[i].Selected())
				objs[i].SpinRight();
		}
               break;

	case GLUT_KEY_F1:
		for(int i = 0; i < objs.size(); i++)
		{
			if(objs[i].Selected())
			{
				objs[i].Selected() = false;

				if(i == (objs.size() -1))
					objs[0].Selected() = true;
				else
					objs[i+1].Selected() = true;
				break;
			}
		}
           break;

       case GLUT_KEY_DOWN :
		for(int i = 0; i < objs.size(); i++)
		{
			if(objs[i].Selected())
				objs[i].MoveDown();
		}
               break;

       }
}




void idle()
{
glutPostRedisplay();
Sleep(10);
}
int main(int argc, char **argv) 
{  




 glutInit(&argc, argv);
 glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH);

 glutInitWindowSize(WIDTH, HEIGHT);
 glutInitWindowPosition(0, 0);
 glutCreateWindow("3D tetris");

 initGL();  


 glutDisplayFunc(window_display);
 glutReshapeFunc(window_reshape);
 glutSpecialFunc(special_keys);
 glutIdleFunc(idle);
 glEnable(GL_DEPTH_TEST);



 glutMainLoop();  

 return 1;
}

nplatis · 24 Ιανουαρίου 2012

Χάνετε τον χρόνο σας, άσκοπα, δυστυχώς.

Το κακό είναι ότι δεν ψάχνετε την βιβλιογραφία να δείτε τι λένε οι ειδικοί επί του θέματος και

μένετε προσκολλημένοι τυφλά μόνον σε ότι σας πουν στην σχολή, είτε σωστό είτε λάθος.

Αν διάβαζες από κάποιο σύγχρονο βιβλίο, θα τα έβλεπες όλα με την σωστή σειρά και τον σωστό τρόπο,

και θα ήταν σίγουρο ότι ο χρόνος και ο κόπος σου θα πιάσουν τόπο.

Τώρα μαθαίνεις πράγματα που είναι μια δεκαετία πίσω.

Δυστυχώς εκτός θέματος, αλλά με τρώει να ρωτήσω:

Πιστεύεις ότι μπορεί στα πλαίσια ενός εξαμηνιαίου εισαγωγικού προπτυχιακού μαθήματος Γραφικών να διδαχθεί ο προγραμματισμός με shaders;

Προσωπικά βλέπω τουλάχιστον δύο δυσκολίες:

α) Είναι αρκετά δύσκολη η εύρεση σφαλμάτων στους shaders, τουλάχιστον σε σχέση με τις γλώσσες που τρέχουν στην CPU

β) Νομίζω λίγα πανεπιστημιακά εργαστήρια έχουν κατάλληλους υπολογιστές για να υποστηρίξουν τέτοιο μάθημα.

Αντίθετα, το glut με την παραδοσιακή OpenGL μπορεί να χρησιμεύσει ως ένα γρήγορο και εύκολο εργαλείο για τον πειραματισμό με τις θεωρητικές έννοιες.

Θα προσέθετα και μία τρίτη δυσκολία στα παραπάνω, ότι ακόμα όλα αυτά είναι σε κάποιο βαθμό (ευτυχώς μειούμενο) κινούμενος στόχος, δηλαδή αλλάζουν σχετικά γρήγορα. Επιπλέον νομίζω ότι συνεχώς οι δυνατότητες των καρτών γραφικών εμπλουτίζονται, ώστε, αν όχι ακόμα, σε λίγο καιρό να είναι αρκετά πιο ευχάριστος ο προγραμματισμός τους...

V.I.Smirnov · 24 Ιανουαρίου 2012

@nplatis

Δεν είμαι απόφοιτος πληροφορικής και άρα δεν ξέρω τι και πώς διδάσκεται.

Εν μέρη έχεις δίκιο. Αλλά μόνον εν μέρει.

Διότι είναι λάθος να διδάσκεται αποκλειστικά μόνον η ύλη που βαίνει προς κατάργηση από το πρότυπο.

Οι διδασκόμενοι θα έπρεπε να ενημερωθούν ως προς το τι είναι απαξιωμένο, από τι αντικαθιστάται

και ποιά είναι σημασία του και οι νέες δυνατότητες. Δηλ. να ξέρουν σημαντικά θέματα που υπέδειξα

στο post #6. Ούτε είναι όλες οι αλλαγές δύσκολο να υιοθετηθούν.

Σε οτι αφορά τους shaders, προφανώς δεν γίνεται να καλυφθούν σε ένα ένα μάθημα αλλά γίνεται άνετα

να δοθεί μιαν εισαγωγή. Π.χ. υπάρχει εισαγωγικό βιβλίο που σε λιγότερο από 300 σελίδες παρουσιάζει

όλα τα βασικά του openGL όπως πρέπει (θεωρία, glut κ' εισαγωγή στους shaders) και από το 0 σε

εισάγει στο game programming. Συνεπώς υπάρχει χρονικό περιθώριο αρκεί να γίνει σωστή επιλογή

της ύλης.

Η fixed pipeline έχει εγκαταλειφθεί εδώ και 10 χρόνια και χρησιμοποιείται πλέον μόνον για να

γραφεί κάτι απλό στα γρήγορα, το λες κι εσύ. Αν κάποιος ενδιαφερθεί για πιο προχωρημένα θέματα

γραφικών (π.χ. χρήση του stencil buffer για σκιές και ανακλάσεις ή κάποιο ειδικό εφέ), επειδή

αυτά γίνονται πλέον μόνον με shaders, θα είναι σαν να μην έχει μάθει προγραμματιστικά τίποτε.

Η fixed pipeline προσέγγιση, πέραν του βασικού μαθηματικού υπόβαθρου (μετασχηματισμοί κλπ),

ελάχιστα θα του έχει προσφέρει για να συνεχίσει, δυστυχώς. Xώρια που στο μέλλον θα καταργηθεί τελείως...

Για τον εξοπλισμό δεν ξέρω, είναι άλλο θέμα.

Oι περισσότερες κάρτες γραφικών υποστηρίζουν πλέον τουλάχιστον opengl 3.0 .

Το δικό μου μηχάνημα όχι (είναι παλιό, του 2005) αλλά ένα εργαστήριο που διδάσκει τέτοια πράγματα

πρέπει να έχει και το αντίστοιχο στοιχειώδες hardaware. Δεν πρόκειται για τίποτε υψηλές απαιτήσεις,

μια modest κάρτα γραφικών ίσα-ίσα για να τρέχει το πρόγραμμα αρκεί...

-

nplatis · 24 Ιανουαρίου 2012

@nplatis

Δεν είμαι απόφοιτος πληροφορικής και άρα δεν ξέρω τι και πώς διδάσκεται.

Εν μέρη έχεις δίκιο. Αλλά μόνον εν μέρει.

Διότι είναι λάθος να διδάσκεται αποκλειστικά μόνον η ύλη που βαίνει προς κατάργηση από το πρότυπο.

Οι διδασκόμενοι θα έπρεπε να ενημερωθούν ως προς το τι είναι απαξιωμένο, από τι αντικαθιστάται

και ποιά είναι σημασία του και οι νέες δυνατότητες. Δηλ. να ξέρουν σημαντικά θέματα που υπέδειξα

στο post #6. Ούτε είναι όλες οι αλλαγές δύσκολο να υιοθετηθούν.

Σε ένα εισαγωγικό μάθημα συνήθως διδάσκονται οι αρχές και οι βασικοί αλγόριθμοι, ανεξαρτήτως γλώσσας υλοποίησης, επομένως η αναφορά σε fixed ή programmed pipeline δεν είναι κεντρική. Πάντως ίσως θα πρέπει πλέον ένα εισαγωγικό μάθημα να προσαρμοστεί στον τρόπο που λειτουργούν πλέον οι κάρτες γραφικών, όσο γίνεται για να μην χαθούν οι βάσεις...

Σε οτι αφορά τους shaders, προφανώς δεν γίνεται να καλυφθούν σε ένα ένα μάθημα αλλά γίνεται άνετα

να δοθεί μιαν εισαγωγή. Π.χ. υπάρχει εισαγωγικό βιβλίο που σε λιγότερο από 300 σελίδες παρουσιάζει

όλα τα βασικά του openGL όπως πρέπει (θεωρία, glut κ' εισαγωγή στους shaders) και από το 0 σε

εισάγει στο game programming. Συνεπώς υπάρχει χρονικό περιθώριο αρκεί να γίνει σωστή επιλογή

της ύλης.

Για πες και το βιβλίο, για να μην ψάχνουμε πολύ

Για τον εξοπλισμό δεν ξέρω, είναι άλλο θέμα.

Oι περισσότερες κάρτες γραφικών υποστηρίζουν πλέον τουλάχιστον opengl 3.0 .

Το δικό μου μηχάνημα όχι (είναι παλιό, του 2005) αλλά ένα εργαστήριο που διδάσκει τέτοια πράγματα

πρέπει να έχει και το αντίστοιχο στοιχειώδες hardaware. Δεν πρόκειται για τίποτε υψηλές απαιτήσεις,

μια modest κάρτα γραφικών ίσα-ίσα για να τρέχει το πρόγραμμα αρκεί...

Προφανώς οι ίδιες οι κάρτες γραφικών δεν είναι οικονομικό ζήτημα. Το πρόβλημα (στα δημόσια πανεπιστήμια) είναι συχνά οι διαδικασίες που απαιτούνται για να γίνει κάτι τέτοιο και η μόνιμη οικονομική στενότητα...

ChRis6 · 24 Ιανουαρίου 2012

Μια χαρα μπορουν οι shaders να διδαχθουν μεσα σε ενα εξαμηνο.Ενταξει δεν ειπαμε να μαθουν οι φοιτητες και post-processing κτλ , αλλα τα βασικα μπορουν να τα μαθουν , οπως φωτισμος σε διαφορα μοντελα ( π.χ ADS ) ή απλες υλοποιησεις motion blur.Το θεμα ειναι οτι ΟΛΟΙ βαριουνται να ασχοληθουν με κατι καινουριο....Εχουν μαθει 10 πραγματα και αφηνουν τους φοιτητες να ψαχτουν μονοι τους

@nplatis

Κοιταξε το OpenGL superbible 5η εκδοση.Πολυ κατανοητο και μπαινεις γρηγορα στο νοημα.

Το μονο αρνητικο που βρισκω ειναι οτι δεν ασχολειται και πολυ με τη μαθηματικη πλευρα των γραφικων.....

παπι · 24 Ιανουαρίου 2012

Μια χαρα μπορουν οι shaders να διδαχθουν μεσα σε ενα εξαμηνο.

Σε ελληνικο ΑΕΙ/ΤΕΙ. Δεν νομιζω.

Σύνδεση

opengl και glut

Προτεινόμενες αναρτήσεις

dinak

παπι

dinak

παπι

dinak

V.I.Smirnov

dinak

V.I.Smirnov

παπι

nplatis

V.I.Smirnov

nplatis

ChRis6

παπι

Δημιουργήστε ένα λογαριασμό ή συνδεθείτε για να σχολιάσετε

Δημιουργία λογαριασμού

Σύνδεση

Σύνδεση