Cos'è OpenGL?
OpenGL (Open Graphics Library) è una potente libreria grafica che si pone il compito di interfacciarsi con l'hardware e fornire al programma client una serie di primitive, più o meno essenziali, per lo sviluppo di applicazioni nel campo del rendering tridimensionale. Queste primitive comprendono funzioni per la manipolazione dei pixel, per la proiezione di poligoni in 3D e per la gestione del movimento degli stessi, per la rappresentazione di luci e colori, per il texture mapping etc.
Il prefisso Open sta ad indicare che OpenGL è una architettura aperta, ciò significa che il suo sviluppo è curato non da una singola azienda ma da una associazione di industrie leader del settore (ATI, Compaq, IBM, nVidia, Hewlett-Packard, Silicon Graphics) che hanno dato vita all'ARB (OpenGL Architecture Review Board).
Questa organizzazione, nata nel 1992, ha il compito di sviluppare e standardizzare gli aggiornamenti di OpenGL, che oggi è giunta alla versione 1.5 (anche se in realtà la versione più diffusa è la 1.1).
Una delle peculiarità di OpenGL che la distingue immediatamente dalle sue rivali (ad esempio DirectX di Microsoft) è la portabilità. Infatti OGL è disponibile su tutte le piattaforme più diffuse, Unix, Linux, Windows, Mac, Solaris etc.
Questa estrema portabilità ha fatto si che anche i costruttori di hardware (nVidia per prima) si adeguassero ad essa e ora un gran numero di schede video moderne hanno la possibilità di eseguire la maggior parte delle funzioni OpenGL direttamente in hardware con un netto vantaggio in termini di prestazioni.
OGL è oggi una delle più valide e potenti librerie grafiche disponibili e lo dimostra il fatto che grandi Software House specializzate nel campo dei videogames l'hanno scelta per sviluppare i propri prodotti. Tra i titoli targati OpenGL troviamo Quake2, Quake3 e (di prossima uscita) Doom III della ID Software, Unreal Tournament 1 e 2 della Epic Games, oppure il mitico Half Life e tanti altri.
Ciò che è importante capire è che OGL e sostanzialmente una libreria grafica di basso livello e le sue funzioni sono relative all'utilizzo delle primitive fondamentali quali vertici e poligoni piuttosto che a modelli complessi la cui gestione viene di norma lasciata nelle mani del programmatore, garantendo così la massima flessibilità.
Naturalmente non mancano le possibilità di creare luci, trasparenze, riflessi e altri "effetti speciali" per trasformare una sterile rappresentazione di poligoni in una affascinante riproduzione della realtà.
OpenGL, nelle sue distribuzioni, è sempre accompagnata dalla libreria GLU (GL Utility Library).
GLU è una libreria ausiliaria che contiene alcuni funzioni di più alto livello, utili ad esempio per la creazione di sfere o altri oggetti complessi ma anche per impostare particolari matrici di proiezione e per facilitare alcune operazioni al programma client. Normalmente, infatti, le funzioni della GLU contengono al loro interno routine basate sulle funzioni base di OGL.
Un'ulteriore libreria che è possibile scaricare (non è fornita di default) è la GLUT (GL Utility Toolkit), si tratta di un toolkit per la creazione delle finestre indipendente dal sistema operativo che permette, utilizzando solamente le funzioni di tale libreria, di scrivere programmi completi nascondendo le differenze di implementazione tra i gestori finestre dei vari sistemi operativi.
In realtà la libreria GLUT, per motivi di prestazioni e di qualità, viene poco utilizzata nelle applicazioni professionali che generalmente si occupano autonomamente di gestire la creazione delle finestre e l'acquisizione dell'input in base al sistema operativo sulle quali devono girare.
Per quanto riguarda la possibilità di utilizzare OGL nel proprio linguaggio preferito, nonostante essa sia stata sviluppata inizialmente per essere utilizzata attraverso il linguaggio C (a differenza di architetture più complesse come quella adottata dalle DirectX che si basa sul Component Object Model COM), è disponibile in un'ampia varietà di linguaggi tra i quali C++, Java, Delphi e il neonato C#.
Mentre le case sviluppatrici di videogiochi su sistemi Windows si dividono, così come tanti programmatori, sulla questione DirectX Vs OpenGL, in ambiente Linux, ancora piuttosto estraneo all'utilizzo come Desktop, OGL ha una netta predominanza. Molto probabilmente grazie alla sua larga diffusione e grazie al fatto che è sempre più supportata da diverse distribuzioni sarà alla base dello sviluppo del mercato dei videogames sui sistemi *nix.
scanner maus
vorrei istallarlo ma mi dice che ci vuole almeno1.5 di open...eppure ho un compiuter recente...che posso fare.
GRAZIE ALBY
Re: opengl per mirco
ciao mirco,
si scarica dalla rete , è semplice vai a download microsoft visual c++ express edition e ti scarichi il programma.
una volta scaricato trovi le librerie in :http://www.opengl.org/ e basta che le carichi in visual c++
spostamento luce
salve, ho una scenna illuminata da una luce chemi permette di illuminare e succesivamente proiettare ombre sulle pareti, però quando mi sposto la luce le ombre non si aggiornano, come faccio?
Rispondiopengl
qualcuno mi può spiegare se opengl è un programma da installare e se sì come posso procurarmelo?
RispondiRe: allied assault
ho un problema..quando vado ad aprire il tutto, si chiude da solo mandando un'errore: could not load open GL subsystem.....aiutatemi per favore
Rispondiogl
qualcuno cel'à?
Rispondiallied assault
ho un problema..quando vado ad aprire il tutto, si chiude da solo mandando un'errore: could not load open GL subsystem.
wolfenstein enemy territory
ho un problema..quando vado ad aprire il tutto, si chiude da solo mandando un'errore: could not load open GL subsystem.
per favore chi può aiutarmi??
opengl
come inserirla in un pc ..? ho xp
Rispondiproblema con opengl
Ciao, ho bisogno di aiuto !! Quando lancio un programma di calcolo strutturale appena acquistato mi si presenta il seguente errore: "Impossibile trovare il punto di ingresso della DLL Choosepixelformat in Opengl"....cosa significa e come i risolve??
RispondiMatrici in c++
Salve a tutti, so che probabilmente la domanda a voi sembrerà stupida....chiedo aiuto per quanto riguarda un copito di programmazione procedurale, non riesco a capire come giocare con le matrici(ad esempio come si faccia a selezionare una casellla, una riga, acambiare il valore in una casella, a cambiare una riga con una colonna o il contrario e come si faccia a sostiutuire le diagonali di una matrice e quelle tra due matrici,qualcuno sa indicarmi un teso reperibile su internet molto chiaro su questo argomento?o se vi è possibile potreste inviarmi i pezzi di codice con queste funzionalità?il mio indirizzo mail è [email protected] ringrazio infinitamente
Re: Rallentamento ridisegno
Ciao,
non è una questione di dimensione del buffer, ma è un problema di prestazioni dovuto alla necessità di eseguire un enorme numero di operazioni di disegno. Se il tuo array è composto da valori statici potresti pensare di usare una DisplayList, altrimenti se è dinamico dovresti utilizzare algoritmi per ridimensionare il numero di punti da visualizzare (Frustum Culling) o tecniche similari.
Ciao
Rallentamento ridisegno
Ho scritto un semplice programma (in VC++ con XP) che disegna un grande numero di
linee con questo codice
glVertexPointer(2, GL_DOUBLE, 0, m_dataCh3);
glColor3ub(GetRValue(m_foreColorY3), GetGValue(m_foreColorY3), GetBValue(m_foreColorY3));
glDrawArrays(GL_LINE_STRIP, m_currArrayStart, m_currArraySize);
Funzione tutto regolarmente fino a quando l'array non diventa molto grande e gli elementi
da disegnare sono tanti e tutto rallenta in modo molto evidente ...
Non so se debba essere impostato qualcosa (a livello di grandezza di buffer di ridisegno) per
la scheda o chiamare delle funzioni OpenGL per scaricare il buffer corrente ...
So che non ho dato molti dettagli e potrei non essere stato chiaro ... vi prego di farmi delle
domande se avete dei dubbi da colmare prima di rispondermi ...
Grazie
Re: Problemi con OpenGL
Cosiglio a te, ed a tutti quelli che scrivono per problemi con OpenGL di frequentare il newsgroup it.comp.giochi a questo link: http://groups-beta.google.com/group/it.comp.giochi/topics
Sarà molto più facile trovare una risposta ai propri problemi proprio perché creato appositamente per discussioni tra videogiocatori. Good luck! :-)
Problemi con OpenGL
Ciao volevo sapere se qualcuno di voi sa dirmi come posso risolvere un problema con un gioco call of duty 3. Praticamente mi dice could load open GL cosa dovrei fare? se qualcuno mi può aiutare mi contatti su [email protected]
Rispondiaiutatemi........
#include <GL\glut.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <string.h>
#include <stdio.h>
#include "pong.h"
//#include <windows.h>
#include "tga.h"
//#include <stdlib.h>
//#include <time.h>
#include <math.h>
void *font = GLUT_BITMAP_TIMES_ROMAN_24;
// definizioni di costanti
#define schermox 700
#define schermoy 500
// margini
float Vx_min=-1.0, Vx_max=1.0, Vy_min=-1.0, Vy_max=1.0;
float x=0;
float y=0;
float incrx=0.01;
float incry=0.01;
float yR1=0,yR2=0;
void output(float x, float y , char *string)
{
int len, i;
glRasterPos2f(x,y);
len = (int) strlen(string);
for (i = 0; i < len; i++)
{
glutBitmapCharacter(font, string[i]);
}
glutPostRedisplay();
}
void myReshape(GLsizei w, GLsizei h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glOrtho(Vx_min, Vx_max, Vy_min, Vy_max, -1.0, 1.0);
glMatrixMode (GL_MODELVIEW);
}
void Gool(void)
{
glClear(GL_COLOR_BUFFER_BIT);
}
int Gol()
{
if(x>0.9 && (y<=0.2 && y>=-0.2)) //Gol giocaore 1
{
return 1;
}
else if(x<-0.9 && (y<=0.2 && y>=-0.2))//Gol giocatore 2
{
return 2;
}
}
void mov(void)
{
//char c[80];
if (!pausa)
{
if(x>=0.95 )
{
incrx=-0.01;
// PlaySound("ah ma ne vale la pena ah.vaw",NULL,SND_FILENAME|SND_ASYNC);
}
else if(x<=-0.95)
{
incrx=0.01;
// PlaySound("ah ma ne vale la pena ah.vaw",NULL,SND_FILENAME|SND_ASYNC);
}
if(y>=0.95 )
{
incry=-0.012;
//PlaySound("ah ma ne vale la pena ah.vaw",NULL,SND_FILENAME|SND_ASYNC);
}
else if(y<=-0.95)
{
incry=0.01;
//PlaySound("ah ma ne vale la pena ah.vaw",NULL,SND_FILENAME|SND_ASYNC);
}
if((x>=0.78) && ((y>(yR1-0.2)) && (y<(yR1+0.2))))
{
incrx-=0.01;
//PlaySound("ah ma ne vale la pena ah.vaw",NULL,SND_FILENAME|SND_ASYNC);
}
if((x<=-0.78) && ((y>(yR2-0.2)) && (y<(yR2+0.2))))
{
incrx+=0.01;
}//PlaySound("ah ma ne vale la pena ah.vaw",NULL,SND_FILENAME|SND_ASYNC);
x+=incrx;
y+=incry;
//PlaySound("ah ma ne vale la pena ah.vaw",NULL,SND_FILENAME|SND_ASYNC);
if(incry>0)
{
if(yR1<0.75)
yR1+=0.01;//PlaySound("ah ma ne vale la pena ah.vaw",NULL,SND_FILENAME|SND_ASYNC);
}
else
{
if(yR1>-0.75)
yR1-=0.01;
}//PlaySound("ah ma ne vale la pena ah.vaw",NULL,SND_FILENAME|SND_ASYNC);
if(Gol()==1)
{
puntigioc1++;
// sprintf(c,"%d",punti);
//output(-0.4 ,0.6 ,"0");
// PlaySound("ah ma ne vale la pena ah.vaw",NULL,SND_FILENAME|SND_ASYNC);
/* glutInitWindowSize (gol,gol1);
glutCreateWindow("Ping Pong");
glutDisplayFunc(Gool);
glutPostRedisplay();
glutReshapeFunc(myReshape);
glutMainLoop(); */
x=0;
y=0;
//g1++;
// sprintf(c,"%d",g1);
//
//output(-0.4,0.6,0);
//glutPostRedisplay();
// exit(1);
}
else if(Gol()==2)
{
puntigioc2++;
// sprintf(c,"%d",g1);
// output(1.2,0.45,c);
//PlaySound("ah ma ne vale la pena ah.vaw",NULL,SND_FILENAME|SND_ASYNC);
x=0;
y=0;
}
glutPostRedisplay();
}
}
void Oggetto(int id)
{
float i=0, j=0;
switch(id)
{
case 1: //Campo di gioco
glLineWidth(8.0);
//Campo alto
glBegin(GL_LINE_STRIP);
glColor3f(0.0,0.0,0.0);
glVertex2f(-0.98,0.2);
glColor3f(0.0,0.0,0.0);
glVertex2f(-0.98,0.98);
glColor3f(0.0,0.0,0.0);
glVertex2f(0.98,0.98);
glColor3f(0.0,0.0,0.0);
glVertex2f(0.98,0.2);
glEnd();
//Campo basso
glBegin(GL_LINE_STRIP);
glColor3f(0.0,0.0,0.0);
glVertex2f(-0.98,-0.2);
glColor3f(0.0,0.0,0.0);
glVertex2f(-0.98,-0.98);
glColor3f(0.0,0.0,0.0);
glVertex2f(0.98,-0.98);
glColor3f(0.0,0.0,0.0);
glVertex2f(0.98,-0.2);
glEnd();
glLineWidth(1.0);
break;
case 2:
//pallina
glEnable (GL_TEXTURE_2D); /* enable texture mapping */
glBindTexture (GL_TEXTURE_2D, 1);
glBegin(GL_POLYGON);
glColor3f(1,1,1);
glVertex2f(-0.02,-0.02);
glVertex2f(0.02,-0.02);
glColor3f(1,1,1);
glVertex2f(0.02,0.02);
glColor3f(1,1,1);
glVertex2f(-0.02,0.02);
glEnd();
glDisable (GL_TEXTURE_2D); /* disable texture mapping */
break;
case 3:
//porta
glBegin(GL_POLYGON);
glColor3f(0.2,0.1,0.1);
glVertex2f(0.0,-0.2);
glVertex2f(0.1,-0.2);
glVertex2f(0.1,0.2);
glColor3f(0.1,0.1,0.1);
glVertex2f(0.0,0.2);
glEnd();
break;
case 4:
//centrocampo
glLineWidth(8.0);
glBegin(GL_LINE_STRIP);
glColor3f(0.0,0.0,0.0);
glVertex2f(0,0.98);
glColor3f(0.0,0.0,0.0);
glVertex2f(-0,-0.98);
glEnd();
/*glLineWidth(8.0);
for(i=0.01,j=-0.01;i<=0.98,j>=-0.98 ;i++ , j--)
{
glBegin(GL_LINE_STRIP);
glColor3f(0.0,0.0,0.0);
glVertex2f(0,i);
glColor3f(1,1,1);
glVertex2f(i,i+=0.01);
glColor3f(0.0,0.0,0.0);
glVertex2f(0,j);
glColor3f(1,1,1);
glVertex2f(j,j-=0.01);
glEnd();
} */
break;
default :
break;
}
}
void display (void)
{ char punteggiochar;
glClear(GL_COLOR_BUFFER_BIT);
Oggetto(1);
glPushMatrix();
glLoadIdentity();
glTranslatef(x,y,0.0);
Oggetto(2);
glLoadIdentity();
glTranslatef(0.88,yR1,0.0);
glRotatef(180,0.0,0.0,1.0);
Oggetto(3);
glLoadIdentity();
glTranslatef(-0.88,yR2,0.0);
Oggetto(3);
glPopMatrix();
Oggetto(4);
glPushMatrix();
glLoadIdentity();
if(pausa)
output(-0.2,0.0,"PAUSA");
output(-0.4,0.8,"Giocatore1");
punteggiochar=(char*)puntigioc1;
punteggiochar+=48;
output(-0.4 ,0.6 ,&punteggiochar);
output(0.1,0.8,"Giocatore2");
punteggiochar=(char*)puntigioc2;
punteggiochar+=48;
output(0.4 ,0.6 ,&punteggiochar);
glutSwapBuffers();
}
void keyboard (unsigned char key , int a , int b )
{
switch (key) {
case 27:
exit(0);
break;
//up
case 'd':
if(yR2<=0.75)
yR2+=0.05;
glutPostRedisplay();
break;
//down
case 's':
if(yR2>=-0.75)
yR2-=0.05;
glutPostRedisplay();
break;
case 'p':
case 'P':
pausa=!pausa;
break;
default:
break;
}
}
void mouse(int button, int state, int a, int b)
{
switch (button)
{
case GLUT_LEFT_BUTTON:
//if (state == GLUT_DOWN)
// {
if(yR2<=0.75)
yR2+=0.05;
glutPostRedisplay();
break;
// {
case GLUT_RIGHT_BUTTON:
if(yR2>=-0.75)
yR2-=0.05;
glutPostRedisplay();
break;
default:
break;
}
}
void init(void)
{
glEnable (GL_DEPTH_TEST);
glClearColor(0.4, 0.5, 0.8, 0.0); //sfondo
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0, 1.0, 1.0);
if (!loadTGA ("texture.tga", 1))
printf ("texture.tga not found!\n");
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize (schermox,schermoy);
glutCreateWindow("Ping Pong");
init();
//glutMouseFunc(mouse);
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutIdleFunc(mov);
glutReshapeFunc(myReshape);
glutMainLoop();
return 0;
}
pong.h
int g1=0, g2=0 ; // punteggio
GLboolean pausa;
int puntigioc1=0;
int puntigioc2=0;
void output ( float x, float y, char *string);
//int LoadGLTextures(char *name,int id);
come faccio a farlo funzionare in modo decente??? grazie DAVIDE
jedy knight 2 academy
could not load opengl subsystem
RispondiMedal of Honor Allied Assault
salle ogni volta che cerco di aprire il gioco Medal of Honor Allied Assault mi compare questo errore GLW_StartOpenGL() - could not load OpenGL subsystem
comeposso risolvere il problema, ho una scheda video nvidia fx 5200
Ancora Open gl
Intanto salve a tutti. Anche io sto dannando con l'Opengl (per ora niente call of duty e soldier of fortune, per fare solo 2 esempi) Io come scheda ho una nvidia geforce fx 5700le, ma non sono ancora riuscito a capire se è compatibile (ho scaicato un driver dal sito della nvidia ma ho paura che installandolo possa far danni). Se c'è qualcuno che misericordiosamente può inserire qualche link utile alla risoluzione del problema, glie ne sarei infinitamente grato. Grazie comunque e buone feste!
RispondiAggiornamento versione
ho bisogno di aiuto. ho una Hercules 3DProphet 4000XT TV Out, con versione OpenGl 1.1.0, GLU version 1.2.2.0. Come facci a passare ad una versione che sia almeno 1.4, come richiesto da un programma? Grazie a quanti vorranno aiutarmi.