Newsgroup: it.comp.lang.c++
Titolo: Glut + caricare sfondo

Salve a tutti, grazie ai vostri consigli sono riuscito + o - a creare
quello che volevo.
Ora mi mancano alcune cose.
In glut ho creato un'immagine di fondo sfruttando glBegin(GL_POLYGON);
Separatamente ho creato un pallino che si muove a seconda di alcune
coordinate che cambiano nel tempo ogni 15millisecondi.
1) Come faccio a mettere queste 2 cose insieme? Per creare il pallino
che si refresha ad ogni coordinata mandata devo utilizzare queste
funzioni:
glutIdleFunc(renderScene);
glutSwapBuffers();
glClear(GL_COLOR_BUFFER_BIT);
ma se le utilizzo mi pulisce e ricrea tutta l'immagne con conseguente
rallentamento di tutto il sistema.
C'è un modo che non conosco per tenere le immagini precedentemente
create con glBegin e fare solo il refresh dell'immagine che mi
interessa?
2)La cosa che mi chiedo a questo punto è questa, dato che sarà
un'immagine statica di fondo (solo il pallino si dovrà muovere), è
necessario crearla in questo modo o sempliceente mi creo immagine di
fondo con paint di quello che vorrei e la carico come sfondo?
Nel caso come faccio a caricare un'immagine di fondo da mettere nella
finestra aperta invece di utilizzare un unico colore con glClearColor
(1, 1, 1, 1); all'inizio di tutto? Devo utilizzare le librerie
freeimage? Ma come si fa? ho provato a cercare ma non ho capito come
carico e metto l'immagine come sfondo.
Grazie ancora di tutto

 carico e metto l'immagine come sfondo.
No, come dicevo devi disegnare un singolo "quad" grande come tutta la 
finestra con sopra appiccicata la texture. Utilizzando la coordinata z 
puoi dirgli che quel quad sta dietro a tutto il resto.
E.

 E.
Come si fa? E' proprio quello che vorrei fare. Ti scrivo il codice mi
potresti dare una mano? Grazie.
#include <windows.h>
#include <math.h>
#include "glut.h"
#define PI 3.1415
void renderScene(void) {
	float x,y,rx,ry;
	float radius = 0.07;
	float Gradius = 0.5;
	glClear(GL_COLOR_BUFFER_BIT);
	glMatrixMode(GL_MODELVIEW);
	/*****Parte mobile***************
	Ora ho creato io un cerchio che si muove nello spazio di lavoro.
	In teoria rx e ry sono le coordinate del punto che dovrebero essere
passate esternamente dal sistema di controllo*/
	rx = (float)Gradius * cos(359 * PI/180.0f);
	ry = (float)Gradius * sin(359 * PI/180.0f);
	for (int i=0;i<360;i++)
	{
		Sleep(15);
		glBegin(GL_POLYGON);
		glColor3f(0,0,1);
		x = rx+(float)radius * cos(359 * PI/180.0f);
		y = ry+(float)radius * sin(359 * PI/180.0f);
		rx = (float)Gradius * cos(i * PI/180.0f);
		ry = (float)Gradius * sin(i * PI/180.0f);
		for(int j = 0; j < 360; j++)
		{
			glVertex2f(x,y);
			x = rx+(float)radius * cos(j * PI/180.0f);
			y = ry+(float)radius * sin(j * PI/180.0f);
			glVertex2f(x,y);
		}
		glEnd();
		/*******************************************/
		/********Parte fissa************
		Questa parte deve rimanere come sfondo*/
		glLineWidth((GLfloat)2);
		glColor3f(0,0,0);
		glBegin(GL_LINES);
		glVertex2f(0,0.8);
		glVertex2f(0,-0.8);
		glVertex2f(0.8,0);
		glVertex2f(-0.8,0);
		glVertex2f(0.5657,0.5657);
		glVertex2f(-0.5657,-0.5657);
		glVertex2f(-0.5657,0.5657);
		glVertex2f(0.5657,-0.5657);
		glEnd();
		/*Draw Circle*/
		float radius = 0.08;
		glBegin(GL_POLYGON);
		glColor3f(1,0.0f,0.0f);
		x = (float)radius * cos(359 * PI/180.0f);
		y = (float)radius * sin(359 * PI/180.0f);
		for(int j = 0; j < 360; j++)
		{
			glVertex2f(x,y);
			x = (float)radius * cos(j * PI/180.0f);
			y = (float)radius * sin(j * PI/180.0f);
			glVertex2f(x,y);
		}
		glEnd();
		glBegin(GL_POLYGON);
		glColor3f(1,0.0f,0.0f);
		x = (float)radius * cos(359 * PI/180.0f);
		y = 0.8+(float)radius * sin(359 * PI/180.0f);
		for(int j = 0; j < 360; j++)
		{
			glVertex2f(x,y);
			x = (float)radius * cos(j * PI/180.0f);
			y = 0.8+(float)radius * sin(j * PI/180.0f);
			glVertex2f(x,y);
		}
		glEnd();
		glBegin(GL_POLYGON);
		glColor3f(1,0.0f,0.0f);
		x = 0.5657+(float)radius * cos(359 * PI/180.0f);
		y = 0.5657+(float)radius * sin(359 * PI/180.0f);
		for(int j = 0; j < 360; j++)
		{
			glVertex2f(x,y);
			x = 0.5657+(float)radius * cos(j * PI/180.0f);
			y = 0.5657+(float)radius * sin(j * PI/180.0f);
			glVertex2f(x,y);
		}
		glEnd();
		glBegin(GL_POLYGON);
		glColor3f(1,0.0f,0.0f);
		x = 0.8+(float)radius * cos(359 * PI/180.0f);
		y = (float)radius * sin(359 * PI/180.0f);
		for(int j = 0; j < 360; j++)
		{
			glVertex2f(x,y);
			x = 0.8+(float)radius * cos(j * PI/180.0f);
			y = (float)radius * sin(j * PI/180.0f);
			glVertex2f(x,y);
		}
		glEnd();
		glBegin(GL_POLYGON);
		glColor3f(1,0.0f,0.0f);
		x = 0.5657+(float)radius * cos(359 * PI/180.0f);
		y = -0.5657+(float)radius * sin(359 * PI/180.0f);
		for(int j = 0; j < 360; j++)
		{
			glVertex2f(x,y);
			x = 0.5657+(float)radius * cos(j * PI/180.0f);
			y = -0.5657+(float)radius * sin(j * PI/180.0f);
			glVertex2f(x,y);
		}
		glEnd();
		glBegin(GL_POLYGON);
		glColor3f(1,0.0f,0.0f);
		x = 0+(float)radius * cos(359 * PI/180.0f);
		y = -0.8+(float)radius * sin(359 * PI/180.0f);
		for(int j = 0; j < 360; j++)
		{
			glVertex2f(x,y);
			x = 0+(float)radius * cos(j * PI/180.0f);
			y = -0.8+(float)radius * sin(j * PI/180.0f);
			glVertex2f(x,y);
		}
		glEnd();
		glBegin(GL_POLYGON);
		glColor3f(1,0.0f,0.0f);
		x = -0.5657+(float)radius * cos(359 * PI/180.0f);
		y = -0.5657+(float)radius * sin(359 * PI/180.0f);
		for(int j = 0; j < 360; j++)
		{
			glVertex2f(x,y);
			x = -0.5657+(float)radius * cos(j * PI/180.0f);
			y = -0.5657+(float)radius * sin(j * PI/180.0f);
			glVertex2f(x,y);
		}
		glEnd();
		glBegin(GL_POLYGON);
		glColor3f(1,0.0f,0.0f);
		x = -0.8+(float)radius * cos(359 * PI/180.0f);
		y = 0+(float)radius * sin(359 * PI/180.0f);
		for(int j = 0; j < 360; j++)
		{
			glVertex2f(x,y);
			x = -0.8+(float)radius * cos(j * PI/180.0f);
			y = 0+(float)radius * sin(j * PI/180.0f);
			glVertex2f(x,y);
		}
		glEnd();
		glBegin(GL_POLYGON);
		glColor3f(1,0.0f,0.0f);
		x = -0.5657+(float)radius * cos(359 * PI/180.0f);
		y = 0.5657+(float)radius * sin(359 * PI/180.0f);
		for(int j = 0; j < 360; j++)
		{
			glVertex2f(x,y);
			x = -0.5657+(float)radius * cos(j * PI/180.0f);
			y = 0.5657+(float)radius * sin(j * PI/180.0f);
			glVertex2f(x,y);
		}
		glEnd();
		/**********************/
		glFlush();
		glutSwapBuffers();
		glClear(GL_COLOR_BUFFER_BIT);
	}
}
void main(int argc, char **argv) {
	glutInit(&argc, argv);
	glutInitWindowSize(800, 800);
	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
	glutCreateWindow("CLOCK");
	glClearColor (1, 1, 1, 1);
	glutDisplayFunc(renderScene);
	glutIdleFunc(renderScene);
	glutMainLoop();
}

 potresti dare una mano? Grazie.
No, mi spiace, non ho tempo per provare a sistemare il tuo codice. Però 
penso che su internet si trovino molti esempi di come si carica una 
texture da file (di solito da un file BMP che ha un formato semplice) e 
come si applica la texture ad un quadrilatero.
Comunque se riesci a fare lo sfondo in maniera "procedurale", e sei 
soddisfatto del risultato, puoi benissimo lasciare stare le cose come 
stanno.
E.