Files |  Tutorials |  Articles |  Links |  Home |  Team |  Forum |  Wiki |  Impressum

Aktuelle Zeit: Fr Jul 18, 2025 15:51

Foren-Übersicht » Programmierung » OpenGL
Unbeantwortete Themen | Aktive Themen



Ein neues Thema erstellen Auf das Thema antworten  [ 4 Beiträge ] 
Autor Nachricht
BeitragVerfasst: Sa Apr 29, 2006 11:07 
Offline
DGL Member

Registriert: Fr Apr 28, 2006 12:32
Beiträge: 2
Hallo, gibt es jemanden, der mir helfen kann?

Bei folgendem Problem:

Bis jetzt habe ich das:

#include <windows.h>
#include <glut.h>

#define WHITE 1.0, 1.0, 1.0
#define BLACK 0.0, 0.0, 0.0
#define GREEN 0.0, 1.0, 0.0
#define BLUE 0.0, 0.0, 1.0
#define RED 1.0, 0.0, 0.0
#define YELLOW 1.0, 1.0, 0.15

void init(void);
void display(void);
void keyboard(unsigned char key);
void draw(void);

double window_size_x = 1000.0;
double window_size_y = 1000.0;
double window_size_z = 1000.0;
float zoom = 2.0, radius, schritt_x = 1.0, schritt_y = 1.0, schritt_z = 1.0, geschwindigkeit = 0.5, x = 5.0, y = 10.0, z = 15.0,

durchmesser = 50.0,

breite = 1000.0,

hoehe = 1500.0,

tiefe = 2000.0;

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize (window_size_x,window_size_y);
glutInitWindowPosition (700.0,300.0);
glutCreateWindow ("Geschicklichkeitsspiel von Nebauer Gunter");

init();

glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMainLoop();

return 0;
}

void init(void)
{
GLfloat pos [] = {1.0, 1.0, 1.0, 0.0};
glClearColor(BLUE, 0.0);
glLightfv(GL_LIGHT0, GL_POSITION, pos);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_COLOR_MATERIAL);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_FLAT);

}

void display(void)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glPushMatrix();
draw();
glPopMatrix();
glutSwapBuffers();
}

void keyboard(unsigned char key)
{
switch(key)
{
case 'a':
glRotatef(-5.0, 0.0, 1.0, 0.0);
break;
case 'd':
glRotatef(5.0, 0.0, 1.0, 0.0);
break;
case 's':
glRotatef(-5.0, 1.0, 0.0, 0.0);
break;
case 'w':
glRotatef(5.0, 1.0, 0.0, 0.0);
break;
case '+':
zoom = zoom + 0.1;
break;
case '-':
zoom = zoom - 0.1;
break;
case 'q':
exit(0);
break;
default:
break;
}
glutPostRedisplay();
}

void draw()
{
glScalef(zoom/window_size_x, zoom/window_size_y, zoom/window_size_z);

glColor3f(RED);

glBegin(GL_LINE_LOOP);
glVertex3f(breite , hoehe , tiefe );
glVertex3f(breite , -hoehe , tiefe );
glVertex3f(-breite , -hoehe , tiefe );
glVertex3f(-breite , hoehe , tiefe );
glEnd();

glBegin(GL_LINE_LOOP);
glVertex3f(breite , hoehe , -tiefe );
glVertex3f(breite , -hoehe , -tiefe);
glVertex3f(-breite , -hoehe , -tiefe;
glVertex3f(-breite , hoehe , -tiefe);
glEnd();

glBegin(GL_LINES);
glVertex3f(breite , hoehe, -tiefe);
glVertex3f(breite, hoehe , tiefe );
glVertex3f(-breite, hoehe, -tiefe);
glVertex3f(-breite , hoehe , tiefe);
glEnd();

glBegin(GL_LINES);
glVertex3f(breite, -hoehe, -tiefe);
glVertex3f(breite , -hoehe, tiefe);
glVertex3f(-breite, -hoehe, -tiefe);
glVertex3f(-breite , -hoehe, tiefe);
glEnd();

x += geschwindigkeit * schritt_x;
y += geschwindigkeit * schritt_y;
z += geschwindigkeit * schritt_z;



glTranslatef(x, y, z);

radius = durchmesser / 2.0;

glutSolidSphere(radius, 50.0, 50.0);

if (x == breite- radius)
schritt_x = -2.0;

if (x == -breite+ radius)
schritt_x = 2.0;

if (y == hoehe- radius)
schritt_y = -2.0;

if (y == -hoehe+ radius)
schritt_y = 2.0;

if (z == tiefe- radius)
schritt_z = -2.0;

if (z == -tiefe+ radius)
schritt_z = 2.0;

x += geschwindigkeit * schritt_x;
y += geschwindigkeit * schritt_y;
z += geschwindigkeit * schritt_z;


glTranslatef(x, y, z);

radius = durchmesser / 4.0;

glutSolidSphere(radius, 50.0, 50.0);

if (x == breite- radius)
schritt_x = -1.0;

if (x == -breite + radius)
schritt_x = 1.0;

if (y == hoehe - radius)
schritt_y = -1.0;

if (y == -hoehe + radius)
schritt_y = 1.0;

if (z == tiefe - radius)
schritt_z = -1.0;

if (z == -tiefe + radius)
schritt_z = 1.0;


glutPostRedisplay();
}

Hab aber noch folgende Probleme:

1. Die Kugeln sollten 2 verschiedene Farben haben und sich unabhängig im Quader bewegen.
2. Den Abstand soll es außerhalb in einem Quader anzeigen.
3. Mit der Leertaste sollen die beiden Kugeln stoppen.
4. Wenn sich die beiden Kugeln berühren soll das Programm enden.
5. Am Ende soll ein Geschicklichkeitsspiel entstehen, mit 3 Durchgängen, je Durchgang soll es die vorherigen Würfel anzeigen, Ziel ist es möglichst die Kugeln mit einem kleinen Abstand zueinander zu stoppen.

Vielleicht kannst du mir zu meinen Problemen helfen, wäre nett, denn ich tu mich wirklich schwer bei der Umsetzung...

Danke schonmal für Alles


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Sa Apr 29, 2006 12:11 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Okt 27, 2003 17:46
Beiträge: 788
Also erstmal könntest du bitte den Code formatieren? :-/
mit [ code ] [ /code ] oder [ pascal ] [ /pascal ]

Danke ;)

_________________
www.audi32.de


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Sa Apr 29, 2006 15:22 
Offline
DGL Member

Registriert: Fr Apr 28, 2006 12:32
Beiträge: 2
Alles klar:

Code:
  1. #include <windows.h>
  2. #include <glut.h>
  3.  
  4. #define WHITE 1.0, 1.0, 1.0
  5. #define BLACK 0.0, 0.0, 0.0
  6. #define GREEN 0.0, 1.0, 0.0
  7. #define BLUE 0.0, 0.0, 1.0
  8. #define RED 1.0, 0.0, 0.0
  9. #define YELLOW 1.0, 1.0, 0.15
  10.  
  11. void init(void);
  12. void display(void);
  13. void keyboard(unsigned char key);
  14. void draw(void);
  15.  
  16. double window_size_x = 1000.0;
  17. double window_size_y = 1000.0;
  18. double window_size_z = 1000.0;
  19. float zoom = 2.0, radius, schritt_x = 1.0, schritt_y = 1.0, schritt_z = 1.0, geschwindigkeit = 0.5, x = 5.0, y = 10.0, z = 15.0,
  20.  
  21. durchmesser = 50.0,
  22.  
  23. breite = 1000.0,
  24.  
  25. hoehe = 1500.0,
  26.  
  27. tiefe = 2000.0;
  28.  
  29. int main(int argc, char** argv)
  30. {
  31.     glutInit (&argc, argv);
  32.     glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
  33.     glutInitWindowSize (window_size_x,window_size_y);
  34.     glutInitWindowPosition (700.0,300.0);
  35.     glutCreateWindow ("Geschicklichkeitsspiel von Nebauer Gunter");
  36.  
  37.     init();
  38.  
  39.     glutDisplayFunc(display);
  40.     glutKeyboardFunc(keyboard);
  41.     glutMainLoop();
  42.  
  43.     return 0;
  44. }
  45.  
  46. void init(void)
  47. {
  48.     GLfloat pos [] = {1.0, 1.0, 1.0, 0.0};
  49.     glClearColor(BLUE, 0.0);
  50.     glLightfv(GL_LIGHT0, GL_POSITION, pos);
  51.     glEnable(GL_LIGHTING);
  52.     glEnable(GL_LIGHT0);
  53.     glEnable(GL_COLOR_MATERIAL);
  54.     glEnable(GL_DEPTH_TEST);
  55.     glShadeModel(GL_FLAT);
  56.    
  57. }
  58.  
  59. void display(void)
  60. {
  61.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  62.  
  63.     glPushMatrix();
  64.     draw();
  65.     glPopMatrix();
  66.     glutSwapBuffers();
  67. }
  68.  
  69. void keyboard(unsigned char key)
  70. {
  71.     switch(key)
  72.     {
  73.         case 'a':
  74.             glRotatef(-5.0, 0.0, 1.0, 0.0);
  75.             break;
  76.         case 'd':
  77.             glRotatef(5.0, 0.0, 1.0, 0.0);
  78.             break;
  79.         case 's':
  80.             glRotatef(-5.0, 1.0, 0.0, 0.0);
  81.             break;
  82.         case 'w':
  83.             glRotatef(5.0, 1.0, 0.0, 0.0);
  84.             break;
  85.         case '+':
  86.             zoom = zoom + 0.1;
  87.             break;
  88.         case '-':
  89.             zoom = zoom - 0.1;
  90.             break;
  91.         case 'q':
  92.             exit(0);
  93.             break;
  94.         default:
  95.             break;
  96.     }
  97.     glutPostRedisplay();
  98. }
  99.  
  100. void draw()
  101. {
  102.     glScalef(zoom/window_size_x, zoom/window_size_y, zoom/window_size_z);
  103.  
  104.     glColor3f(RED);
  105.  
  106.     glBegin(GL_LINE_LOOP);
  107.     glVertex3f(breite , hoehe , tiefe );
  108.     glVertex3f(breite , -hoehe , tiefe );
  109.     glVertex3f(-breite , -hoehe , tiefe );
  110.     glVertex3f(-breite , hoehe , tiefe );
  111.     glEnd();
  112.  
  113.     glBegin(GL_LINE_LOOP);
  114.     glVertex3f(breite , hoehe , -tiefe );
  115.     glVertex3f(breite , -hoehe , -tiefe);
  116.     glVertex3f(-breite , -hoehe , -tiefe;
  117.     glVertex3f(-breite , hoehe , -tiefe);
  118.     glEnd();
  119.  
  120.     glBegin(GL_LINES);
  121.     glVertex3f(breite , hoehe, -tiefe);
  122.     glVertex3f(breite, hoehe , tiefe );
  123.     glVertex3f(-breite, hoehe, -tiefe);
  124.     glVertex3f(-breite , hoehe , tiefe);
  125.     glEnd();
  126.  
  127.     glBegin(GL_LINES);
  128.     glVertex3f(breite, -hoehe, -tiefe);
  129.     glVertex3f(breite , -hoehe, tiefe);
  130.     glVertex3f(-breite, -hoehe, -tiefe);
  131.     glVertex3f(-breite , -hoehe, tiefe);
  132.     glEnd();
  133.  
  134.     x += geschwindigkeit * schritt_x;
  135.     y += geschwindigkeit * schritt_y;
  136.     z += geschwindigkeit * schritt_z;
  137.  
  138.  
  139.  
  140. glTranslatef(x, y, z);
  141.  
  142.     radius = durchmesser / 2.0;
  143.  
  144.     glutSolidSphere(radius, 50.0, 50.0);
  145.  
  146.     if (x == breite- radius)
  147.         schritt_x = -2.0;
  148.  
  149.     if (x == -breite+ radius)
  150.         schritt_x = 2.0;
  151.  
  152.     if (y == hoehe- radius)
  153.         schritt_y = -2.0;
  154.  
  155.     if (y == -hoehe+ radius)
  156.         schritt_y = 2.0;
  157.  
  158.     if (z == tiefe- radius)
  159.         schritt_z = -2.0;
  160.  
  161.     if (z == -tiefe+ radius)
  162.         schritt_z = 2.0;
  163.  
  164. x += geschwindigkeit * schritt_x;
  165.     y += geschwindigkeit * schritt_y;
  166.     z += geschwindigkeit * schritt_z;
  167.  
  168.  
  169. glTranslatef(x, y, z);
  170.  
  171.     radius = durchmesser / 4.0;
  172.  
  173.     glutSolidSphere(radius, 50.0, 50.0);
  174.  
  175.     if (x == breite- radius)
  176.         schritt_x = -1.0;
  177.  
  178.     if (x == -breite + radius)
  179.         schritt_x = 1.0;
  180.  
  181.     if (y == hoehe - radius)
  182.         schritt_y = -1.0;
  183.  
  184.     if (y == -hoehe + radius)
  185.         schritt_y = 1.0;
  186.  
  187.     if (z == tiefe  - radius)
  188.         schritt_z = -1.0;
  189.  
  190.     if (z == -tiefe + radius)
  191.         schritt_z = 1.0;
  192.  
  193.  
  194.     glutPostRedisplay();
  195. }
  196.  


So ich hoffe dass es jetzt besser ist


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags:
BeitragVerfasst: Sa Apr 29, 2006 15:46 
Offline
DGL Member
Benutzeravatar

Registriert: Mo Okt 27, 2003 17:46
Beiträge: 788
Also erstmal.. das irritiert jetzt ;)
Mach ma den Code weg, editieren...
dann editierste den ersten post und machst das pascal drum *up*

1. 2 verscheidene farben... mach glcolor3f(1.0f,0.0f,0.0f); vor die eine kugel und glcolor3f(0.0f,1.0f,0.0f);
sorry wenns net klappt, kann net so gut C++ oder C#...
Unabhängig bewegen, ja da kannste dann halt net x, y und z für beide nehmen, sondern x1 und x2 oder so...

2. Kannste den Abstand berechnen?

3. Das mit der Leertaste schaffste allein oder?
Prüf einfach ob sie gedrückt wurde und lass dann das x += .... weg...

4. Das ergibt sich ja dann aus 2., wenn der abstand kleiner durchmesser ist...

5. Die Idee ist schonma gut, gibts sowas schon?!?!

_________________
www.audi32.de


Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 4 Beiträge ] 
Foren-Übersicht » Programmierung » OpenGL


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 6 Gäste


Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
Gehe zu:  
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.007s | 15 Queries | GZIP : On ]