Kalábovi

Kalábovic wikina

Uživatelské nástroje

Nástroje pro tento web

Historie:
pitel:izg:lab07

Rozdíly

Zde můžete vidět rozdíly mezi vybranou verzí a aktuální verzí dané stránky.

Odkaz na výstup diff

Obě strany předchozí revizePředchozí verze
pitel:izg:lab07 [05. 04. 2013, 06.37:14] – file pitelpitel:izg:lab07 [30. 12. 2022, 13.43:01] (aktuální) – upraveno mimo DokuWiki 127.0.0.1
Řádek 1: Řádek 1:
 +====== Základy OpenGL ======
 +[[http://www.flickr.com/photos/pitel/2457114342/|{{ http://farm4.static.flickr.com/3248/2457114342_cc50b0dff8.jpg |Základy OpenGL}}]]
  
 +<file cpp main.cpp>
 +///////////////////////////////////////////////////////////////////////////////
 +// Zaklady pocitacove grafiky
 +// Cviceni #7
 +//
 +// Autor: Adam Herout, modified by Michal Spanel
 +//
 +// Obsah cviceni: "Informativni nejzakladnejsi zaklady OpenGL"
 +//
 +// Demonstrovane jevy:
 +//      - OpenGL + GLUT
 +//      - vykreslovani
 +//      - display-listy
 +//      - barvy
 +//      - osvetleni
 +//      - pruhlednost
 +//      - stencil buffer
 +//
 +// *) Ovladani programu:
 +//      mys + leve tl.  - rotace cele sceny
 +//      mys + prave tl. - priblizeni sceny
 +//      1,2,3           - polygony vyplnit, carami, body
 +//
 +// Opravy:
 +//
 +///////////////////////////////////////////////////////////////////////////////
 +
 +
 +///////////////////////////////////////////////////////////////////////////////
 +// include
 +
 +#ifdef _WIN32
 +#  include <windows.h>
 +#endif
 +
 +#include <GL/gl.h>
 +#include <GL/glut.h>
 +//#include <GL/glext.h>
 +#include <math.h>
 +#include <stdio.h>
 +#include <stdlib.h>
 +
 +
 +///////////////////////////////////////////////////////////////////////////////
 +// globalni konstanty
 +
 +// titulek hlavniho okna
 +const char      * PROGRAM_TITLE = "IZG Labs #07, Informativni nejzakladnejsi zaklady OpenGL";
 +
 +const float     fov = 45.0;                 // zorny uhel - field of view
 +const float     near_plane = 10.0;          // blizsi orezavaci rovina
 +const float     far_plane = 250.0;          // zdalenejsi orezavaci rovina
 +
 +const int       default_w = 600;            // defaultni velikost okna
 +const int       default_h = 600;
 +
 +
 +///////////////////////////////////////////////////////////////////////////////
 +// globalni promenne
 +
 +int             scene_rot_x = 0;             // rotace sceny dana mysovanim
 +int             scene_rot_y = 0;
 +int             scene_move_z = -50;          // posuv sceny
 +int             time = 0;                    // virtualni cas [s]
 +
 +
 +///////////////////////////////////////////////////////////////////////////////
 +// zakladni nastaveni OpenGL
 +// - funkce se vola jednou, pri zacatku programu
 +//
 +
 +void Init(void)
 +{
 +  // nastaveni clear color
 +  glClearColor(0.0, 0.0, 0.0, 0.0);
 +
 +  // parametry svetla
 +  GLfloat light_ambient[]  = {0.5, 0.5, 0.5, 1.0};  // ambientni slozka svetla
 +  GLfloat light_specular[] = {0.8, 0.8, 0.8, 1.0};  // barva odlesku
 +  GLfloat light_diffuse[]  = {0.9, 0.9, 0.9, 1.0};  // difuzni slozka svetla
 +  GLfloat light_position[] = {15.0, 0.0, 0.0, 1.0}; // definice pozice svetla
 +
 +  // nastaveni svetla
 +  glEnable(GL_LIGHTING);
 +  glEnable(GL_LIGHT0);
 +  glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
 +  glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
 +  glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
 +  glLightfv(GL_LIGHT0, GL_POSITION, light_position);
 +
 +  // nastaveni osvetlovaciho modelu
 +//  glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL_EXT, GL_SEPARATE_SPECULAR_COLOR_EXT);
 +
 +  // povoleni z-bufferu 
 +  glClearDepth(1000.0);
 +  glEnable(GL_DEPTH_TEST);
 +  glDepthFunc(GL_LESS);
 +
 +  // velikost bodu, pokud se nejaky kresli...
 +  glPointSize(5.0);
 +}
 +
 +
 +///////////////////////////////////////////////////////////////////////////////
 +// vygenerovani display-listu ozubeneho kolecka
 +// - funkce se vola pri zacatku programu
 +// - vraci id vytvoreneho display-listu
 +
 +// zakladni parametry kolecka
 +#define COG_COUNT       14                      // pocet zubu kola
 +#define RADIUS          4.0                     // radius kola (vnitrni radius zubu)
 +
 +// dalsi parametry kolecka
 +#define COG_HEIGHT      1.0                     // vyska zubu
 +#define RADIUS_AXLE     1.0                     // radius diry pro osu v kole
 +#define WHEEL_THICKNESS 3.0                     // tloustka kola
 +#define CONST_PI        3.141592653589793
 +
 +// identifikator display-listu kolecka
 +int wheel;
 +int wheel2;
 +
 +int InitWheelDisplayList(double radius, int cog_count)
 +{
 +  double phi = 0;
 +
 +  // vygeneruje identifikator display-listu
 +  int id = glGenLists(1);
 +  
 +  // naplneni display-listu s koleckem 
 +  glNewList(id, GL_COMPILE);
 +  {
 +    glBegin(GL_QUADS);                          // vykreslujem same ctyruhelniky
 +    for (int i = 0; i < cog_count; i++) {       // pro kazdy zub...
 +      glNormal3f(0, 0, -1);
 +      glVertex3f(RADIUS_AXLE*cos(phi), RADIUS_AXLE*sin(phi), -WHEEL_THICKNESS/2.0);
 +      glVertex3f((radius+COG_HEIGHT)*cos(phi), (radius+COG_HEIGHT)*sin(phi), -WHEEL_THICKNESS/2.0);
 +      glVertex3f((radius+COG_HEIGHT)*cos(phi + 2/7.0*2*CONST_PI/cog_count),
 +                 (radius+COG_HEIGHT)*sin(phi + 2/7.0*2*CONST_PI/cog_count),
 +                 -WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi + 2/7.0*2*CONST_PI/cog_count),
 +                 RADIUS_AXLE*sin(phi + 2/7.0*2*CONST_PI/cog_count),
 +                 -WHEEL_THICKNESS/2.0);
 +  
 +      glNormal3f(cos(phi + 2/7.0*2*CONST_PI/cog_count/2), sin(phi + 2/7.0*2*CONST_PI/cog_count/2), 0.0);
 +      glVertex3f((radius+COG_HEIGHT)*cos(phi), (radius+COG_HEIGHT)*sin(phi), -WHEEL_THICKNESS/2.0);
 +      glVertex3f((radius+COG_HEIGHT)*cos(phi + 2/7.0*2*CONST_PI/cog_count),
 +                 (radius+COG_HEIGHT)*sin(phi + 2/7.0*2*CONST_PI/cog_count),
 +                 -WHEEL_THICKNESS/2.0
 +                 );
 +      glVertex3f((radius+COG_HEIGHT)*cos(phi + 2/7.0*2*CONST_PI/cog_count),
 +                 (radius+COG_HEIGHT)*sin(phi + 2/7.0*2*CONST_PI/cog_count),
 +                 WHEEL_THICKNESS/2.0);
 +      glVertex3f((radius+COG_HEIGHT)*cos(phi), (radius+COG_HEIGHT)*sin(phi), WHEEL_THICKNESS/2.0);
 +  
 +      glNormal3f(0, 0, 1);
 +      glVertex3f(RADIUS_AXLE*cos(phi), RADIUS_AXLE*sin(phi), WHEEL_THICKNESS/2.0);
 +      glVertex3f((radius+COG_HEIGHT)*cos(phi), (radius+COG_HEIGHT)*sin(phi), WHEEL_THICKNESS/2.0);
 +      glVertex3f((radius+COG_HEIGHT)*cos(phi + 2/7.0*2*CONST_PI/cog_count),
 +                 (radius+COG_HEIGHT)*sin(phi + 2/7.0*2*CONST_PI/cog_count),
 +                 WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi + 2/7.0*2*CONST_PI/cog_count),
 +                 RADIUS_AXLE*sin(phi + 2/7.0*2*CONST_PI/cog_count),
 +                 WHEEL_THICKNESS/2.0);
 +  
 +      glNormal3f(-cos(phi + 2/7.0*2*CONST_PI/cog_count/2), -sin(phi + 2/7.0*2*CONST_PI/cog_count/2), 0.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi), RADIUS_AXLE*sin(phi), -WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi + 2/7.0*2*CONST_PI/cog_count),
 +                 RADIUS_AXLE*sin(phi + 2/7.0*2*CONST_PI/cog_count),
 +                 -WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi + 2/7.0*2*CONST_PI/cog_count),
 +                 RADIUS_AXLE*sin(phi + 2/7.0*2*CONST_PI/cog_count),
 +                 WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi), RADIUS_AXLE*sin(phi), WHEEL_THICKNESS/2.0);
 +      phi += 2/7.0*2*CONST_PI/cog_count;
 +  
 +      
 +      glNormal3f(0, 0, -1);
 +      glVertex3f(RADIUS_AXLE*cos(phi), RADIUS_AXLE*sin(phi), -WHEEL_THICKNESS/2.0);
 +      glVertex3f((radius+COG_HEIGHT)*cos(phi), (radius+COG_HEIGHT)*sin(phi), -WHEEL_THICKNESS/2.0);
 +      glVertex3f(radius*cos(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 radius*sin(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 -WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 RADIUS_AXLE*sin(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 -WHEEL_THICKNESS/2.0);
 +  
 +      glNormal3f(cos(phi + 1/7.0*2*CONST_PI/cog_count/2), sin(phi + 1/7.0*2*CONST_PI/cog_count/2), 0.0);
 +      glVertex3f((radius+COG_HEIGHT)*cos(phi), (radius+COG_HEIGHT)*sin(phi), -WHEEL_THICKNESS/2.0);
 +      glVertex3f(radius*cos(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 radius*sin(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 -WHEEL_THICKNESS/2.0);
 +      glVertex3f(radius*cos(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 radius*sin(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 WHEEL_THICKNESS/2.0);
 +      glVertex3f((radius+COG_HEIGHT)*cos(phi), (radius+COG_HEIGHT)*sin(phi), WHEEL_THICKNESS/2.0);
 +  
 +      glNormal3f(0, 0, 1);
 +      glVertex3f(RADIUS_AXLE*cos(phi), RADIUS_AXLE*sin(phi), WHEEL_THICKNESS/2.0);
 +      glVertex3f((radius+COG_HEIGHT)*cos(phi), (radius+COG_HEIGHT)*sin(phi), WHEEL_THICKNESS/2.0);
 +      glVertex3f(radius*cos(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 radius*sin(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 RADIUS_AXLE*sin(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 WHEEL_THICKNESS/2.0);
 +  
 +      glNormal3f(-cos(phi + 1/7.0*2*CONST_PI/cog_count/2), -sin(phi + 1/7.0*2*CONST_PI/cog_count/2), 0.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi), RADIUS_AXLE*sin(phi), -WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 RADIUS_AXLE*sin(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 -WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 RADIUS_AXLE*sin(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi), RADIUS_AXLE*sin(phi), WHEEL_THICKNESS/2.0);
 +      phi += 1/7.0*2*CONST_PI/cog_count;
 +  
 +      
 +      glNormal3f(0, 0, -1);
 +      glVertex3f(RADIUS_AXLE*cos(phi), RADIUS_AXLE*sin(phi), -WHEEL_THICKNESS/2.0);
 +      glVertex3f(radius*cos(phi), radius*sin(phi), -WHEEL_THICKNESS/2.0);
 +      glVertex3f(radius*cos(phi + 3/7.0*2*CONST_PI/cog_count),
 +                 radius*sin(phi + 3/7.0*2*CONST_PI/cog_count),
 +                 -WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi + 3/7.0*2*CONST_PI/cog_count),
 +                 RADIUS_AXLE*sin(phi + 3/7.0*2*CONST_PI/cog_count),
 +                 -WHEEL_THICKNESS/2.0);
 +  
 +      glNormal3f(cos(phi + 3/7.0*2*CONST_PI/cog_count/2), sin(phi + 3/7.0*2*CONST_PI/cog_count/2), 0.0);
 +      glVertex3f(radius*cos(phi), radius*sin(phi), -WHEEL_THICKNESS/2.0);
 +      glVertex3f(radius*cos(phi + 3/7.0*2*CONST_PI/cog_count),
 +                 radius*sin(phi + 3/7.0*2*CONST_PI/cog_count),
 +                 -WHEEL_THICKNESS/2.0);
 +      glVertex3f(radius*cos(phi + 3/7.0*2*CONST_PI/cog_count),
 +                 radius*sin(phi + 3/7.0*2*CONST_PI/cog_count),
 +                 WHEEL_THICKNESS/2.0);
 +      glVertex3f(radius*cos(phi), radius*sin(phi), WHEEL_THICKNESS/2.0);
 +  
 +      glNormal3f(0, 0, 1);
 +      glVertex3f(RADIUS_AXLE*cos(phi), RADIUS_AXLE*sin(phi), WHEEL_THICKNESS/2.0);
 +      glVertex3f(radius*cos(phi), radius*sin(phi), WHEEL_THICKNESS/2.0);
 +      glVertex3f(radius*cos(phi + 3/7.0*2*CONST_PI/cog_count),
 +                 radius*sin(phi + 3/7.0*2*CONST_PI/cog_count),
 +                 WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi + 3/7.0*2*CONST_PI/cog_count),
 +                 RADIUS_AXLE*sin(phi + 3/7.0*2*CONST_PI/cog_count),
 +                 WHEEL_THICKNESS/2.0);
 +  
 +      glNormal3f(-cos(phi + 3/7.0*2*CONST_PI/cog_count/2), -sin(phi + 3/7.0*2*CONST_PI/cog_count/2), 0.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi), RADIUS_AXLE*sin(phi), -WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi + 3/7.0*2*CONST_PI/cog_count),
 +                 RADIUS_AXLE*sin(phi + 3/7.0*2*CONST_PI/cog_count),
 +                 -WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi + 3/7.0*2*CONST_PI/cog_count),
 +                 RADIUS_AXLE*sin(phi + 3/7.0*2*CONST_PI/cog_count),
 +                 WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi), RADIUS_AXLE*sin(phi), WHEEL_THICKNESS/2.0);
 +      phi += 3/7.0*2*CONST_PI/cog_count;
 +  
 +      
 +      glNormal3f(0, 0, -1);
 +      glVertex3f(RADIUS_AXLE*cos(phi), RADIUS_AXLE*sin(phi), -WHEEL_THICKNESS/2.0);
 +      glVertex3f(radius*cos(phi), radius*sin(phi), -WHEEL_THICKNESS/2.0);
 +      glVertex3f((radius+COG_HEIGHT)*cos(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 (radius+COG_HEIGHT)*sin(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 -WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 RADIUS_AXLE*sin(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 -WHEEL_THICKNESS/2.0);
 +  
 +      glNormal3f(cos(phi + 1/7.0*2*CONST_PI/cog_count/2), sin(phi + 1/7.0*2*CONST_PI/cog_count/2), 0.0);
 +      glVertex3f(radius*cos(phi), radius*sin(phi), -WHEEL_THICKNESS/2.0);
 +      glVertex3f((radius+COG_HEIGHT)*cos(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 (radius+COG_HEIGHT)*sin(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 -WHEEL_THICKNESS/2.0);
 +      glVertex3f((radius+COG_HEIGHT)*cos(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 (radius+COG_HEIGHT)*sin(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 WHEEL_THICKNESS/2.0);
 +      glVertex3f(radius*cos(phi), radius*sin(phi), WHEEL_THICKNESS/2.0);
 +  
 +      glNormal3f(0, 0, 1);
 +      glVertex3f(RADIUS_AXLE*cos(phi), RADIUS_AXLE*sin(phi), WHEEL_THICKNESS/2.0);
 +      glVertex3f(radius*cos(phi), radius*sin(phi), WHEEL_THICKNESS/2.0);
 +      glVertex3f((radius+COG_HEIGHT)*cos(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 (radius+COG_HEIGHT)*sin(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 RADIUS_AXLE*sin(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 WHEEL_THICKNESS/2.0);
 +  
 +      glNormal3f(-cos(phi + 1/7.0*2*CONST_PI/cog_count/2), -sin(phi + 1/7.0*2*CONST_PI/cog_count/2), 0.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi), RADIUS_AXLE*sin(phi), -WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 RADIUS_AXLE*sin(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 -WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 RADIUS_AXLE*sin(phi + 1/7.0*2*CONST_PI/cog_count),
 +                 WHEEL_THICKNESS/2.0);
 +      glVertex3f(RADIUS_AXLE*cos(phi), RADIUS_AXLE*sin(phi), WHEEL_THICKNESS/2.0);
 +      phi += 1/7.0*2*CONST_PI/cog_count;
 +    }                                           // konec cyklu pro kazdy zub
 +    glEnd();                                    // GL_QUADS
 +  }
 +  glEndList();                                  // to je ke kolecku vsechno...
 +
 +  // vratime identifikator display-listu
 +  return id;
 +}
 +
 +
 +///////////////////////////////////////////////////////////////////////////////
 +// vygenerovani display-listu pro dva materialy
 +// - funkce se vola jednou, pri zacatku programu
 +
 +// identifikatory display-listu pro materialy
 +int red_mat, blue_mat;
 +
 +void InitMaterialDisplayLists()
 +{
 +  // vygenerujeme display listy pro dva dulezite materialy
 +  red_mat = glGenLists(1);                      // cerveny material - display-list
 +  glNewList(red_mat, GL_COMPILE);               // budeme plnit prislusny display-list
 +  {
 +    GLfloat mat_diffuse[] = {0.9, 0.0, 0.0, 1.0};  // difuzni (matna) slozka materialu
 +    GLfloat mat_ambient[] = {0.2, 0.2, 0.2, 1.0};  // ambient (rozptylena) slozka materialu
 +    GLfloat mat_specular[] = {0.5, 0.5, 0.5, 1.0}; // spekularni (odleskova) slozka materialu
 +
 +    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient);
 +    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse);
 +    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
 +    glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 80); // lesklost materialu - 1-128
 +  }
 +  glEndList();                                  // konec cerveneho materialu
 +
 +  // vygenerujeme display-list pro modry material
 +  blue_mat = glGenLists(1);
 +  glNewList(blue_mat, GL_COMPILE);
 +  {
 +    GLfloat mat_diffuse[] = {0.0, 0.0, 0.9, 1.0};  // difuzni slozka materialu
 +    GLfloat mat_ambient[] = {0.2, 0.2, 0.2, 1.0};  // ambient (rozptylena) slozka materialu
 +    GLfloat mat_specular[] = {0.5, 0.5, 0.5, 1.0}; // spekularni slozka materialu
 +
 +    glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient);
 +    glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse);
 +    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular); 
 +    glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 120);
 +  }
 +  glEndList();                                  // konec popisu modreho materialu
 +}
 +
 +
 +///////////////////////////////////////////////////////////////////////////////
 +// vygenerovani textury - bitmapy RGBA o vhodnych rozmerech
 +// - funkce se vola jednou, pri zacatku programu
 +
 +// parametry textury
 +#define TEXTURE_WIDTH   256                     // sirka textury - musi byt mocnina 2
 +#define TEXTURE_HEIGHT  256                     // vyska textury - musi byt mocnina 2
 +
 +// pole kde budou data textury
 +unsigned char texture[TEXTURE_WIDTH * TEXTURE_HEIGHT * 4];
 +
 +// identifikator ("jmeno") textury
 +unsigned texid;
 +
 +void InitTexture()
 +{
 +  unsigned char *p = texture;                   // ukazatel, ktery "leze" pres texturu
 +  for (int i = 0; i < TEXTURE_HEIGHT; ++i) {
 +    for (int j = 0; j < TEXTURE_WIDTH; ++j) {
 +      *p++ = (((int)(i+10*(sin(j/20.0)+1))&0x10)^(j&0x10)) ? 0xff:160; // red
 +      *p++ = (((int)(i+10*(sin(j/20.0)+1))&0x10)^(j&0x10)) ? 0xff:180; // green
 +      *p++ = (((int)(i+10*(sin(j/20.0)+1))&0x10)^(j&0x10)) ? 0xff:180; // blue
 +      *p++ = (((int)(i+10*(sin(j/20.0)+1))&0x10)^(j&0x10)) ? 0xff:160; // alpha
 +    }
 +  }
 +
 +  // vygeneruje (prideli) identifikator textury - ulozi do promenne texid
 +  glGenTextures(0, &texid);
 +  
 +  // texid bude aktivni textura
 +  glBindTexture(GL_TEXTURE_2D, texid);
 +  
 +  // nastaveni parametru textury
 +  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 +  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 +  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 +  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 +  glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 +  
 +  // vytvoreni textury - podle naseho vygenerovaneho pole v promenne texture
 +  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEXTURE_WIDTH, TEXTURE_HEIGHT, 
 +               0, GL_RGBA, GL_UNSIGNED_BYTE, texture);
 +}
 +
 +
 +///////////////////////////////////////////////////////////////////////////////
 +// nastaveni souradneho systemu podle velikosti okna
 +// - funkci zavola GLUT vzdy, kdyz se zmeni rozmery okna
 +
 +void onReshape(int w, int h)
 +{
 +  glViewport(0, 0, w, h);                       // viditelna oblast
 +  glMatrixMode(GL_PROJECTION);                  // nastavujeme projekcni matici
 +  glLoadIdentity();                             // nahrat jednotkovou matici
 +  gluPerspective(fov, (double)w / (double)h, near_plane, far_plane); // perspektivni projekce
 +  glMatrixMode(GL_MODELVIEW);                   // modelova matice
 +  glLoadIdentity();
 +}
 +
 +
 +///////////////////////////////////////////////////////////////////////////////
 +// tato funkce je volana pro prekresleni okna
 +// - vola ji GLUT, kdyz okno vystoupi do popredi, nebo kdyz si to
 +//   objedname funkci glutPostRedisplay()
 +
 +void onDisplay(void)
 +{
 +  // vymazani bufferu
 +  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 +
 +  glMatrixMode(GL_MODELVIEW);                   // bude se menit modelova matice
 +  glLoadIdentity();                             // nahrat jednotkovou matici
 +
 +  ////////////////////////////////////////////////////////////////
 +  // nastaveni kamery
 +
 +  glTranslatef(0.0f, 0.0f, scene_move_z);       // posun sceny podle pohybu mysi
 +  glRotatef(scene_rot_x, 1.0, 0.0, 0.0);        // rotace sceny podle pohybu kurzoru mysi
 +  glRotatef(scene_rot_y, 0.0, 1.0, 0.0);
 +  
 +  ////////////////////////////////////////////////////////////////
 +  // vykresleni sceny
 +
 +  // kolecka vpredu
 +#if 1
 +  glPushMatrix();                               // zapamatovat souradny system
 +    glTranslatef(0.0, 0.0, 6.0);
 +
 +    glCallList(red_mat);                        // cerveny material - display-list
 +    glPushMatrix();                             // zapamatujem souradny system
 +      glCallList(wheel);                        // vykreslime kolecko
 +    glPopMatrix();                              // vratime souradny system
 +
 +    glCallList(blue_mat);
 +    glPushMatrix();
 +      glRotatef(time, 0, 0, 1);
 +      glTranslatef(((2 * RADIUS + COG_HEIGHT) / 2) + 2.5, 0, 0);
 +      glRotatef(2 * time - 14, 0, 0, 1);
 +      glCallList(wheel2);
 +    glPopMatrix();
 +  glPopMatrix();                                // vratit zapamatovany souradny system
 +#endif
 +  
 +  // vykresleni POLOHY zrcadla do stencil-bufferu
 +  glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); // zakaze zapis do color-bufferu
 +  glDepthMask(GL_FALSE);                        // zakaze zapis do depth-bufferu
 +  glEnable(GL_CULL_FACE);                       // vykreslovani jen licu polygonu
 +  glEnable(GL_STENCIL_TEST);                    // zapne praci se stencil-bufferem
 +  glStencilFunc(GL_ALWAYS, 1, 1);               // zapis VZDY
 +  glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);       // inkrementujeme hodnotu ve stencil-bufferu
 +  glBegin(GL_QUADS);                            // obdelnik
 +    glVertex3f(-16.0, -11.0, 0.0);
 +    glVertex3f( 16.0, -11.0, 0.0);
 +    glVertex3f( 16.0,  11.0, 0.0);
 +    glVertex3f(-16.0,  11.0, 0.0);
 +  glEnd();
 +  glDisable(GL_CULL_FACE);                      // vratit nastaveni - licove i rubove strany polygonu
 +  glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); // vratit nastaveni - bude se kreslit
 +  glDepthMask(GL_TRUE);                         // vratit nastaveni - bude se psat do depth-bufferu
 +
 +#if 1
 +  // kolecka jeste jednou - tentokrate za zrcadlem
 +  glEnable(GL_STENCIL_TEST);                    // zapne praci se stencil-bufferem
 +  glStencilFunc(GL_EQUAL, 1, 1);                // podminka stencil bufferu - musi tam byt 1
 +  glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);       // operace stencil bufferu - necha tam, co bylo
 +  glPushMatrix();
 +    glScalef(1.0, 1.0, -1.0);
 +    glTranslatef(0, 0, 6);
 +    
 +    glCallList(red_mat);
 +    glPushMatrix();
 +      glCallList(wheel);
 +    glPopMatrix();
 +
 +    glCallList(blue_mat);
 +    glPushMatrix();
 +      glRotatef(time, 0, 0, 1);
 +      glTranslatef(((2 * RADIUS + COG_HEIGHT) / 2) + 2.5, 0, 0);
 +      glRotatef(2 * time - 14, 0, 0, 1);
 +      glCallList(wheel2);
 +    glPopMatrix();
 +  glPopMatrix();
 +  glDisable(GL_STENCIL_TEST);                   // vratit nastaveni - vypneme praci se stencil bufferem
 +#endif
 +
 +  // mrizka z car dole
 +  glDisable(GL_LIGHTING);                       // nepracujeme se svetlem - porad stejne sede
 +  glColor3f(0.5, 0.5, 0.5);                     // seda barva
 +  glLineWidth(1.0);                             // tloustka cary - 1 pixel
 +  glBegin(GL_LINES);                            // budem kreslit cary
 +  for (int i = -10; i <= 10; i++) {
 +    glColor3f(1, 0, 0);  glVertex3f(1.5*i, -11.0, -20.0);
 +    glColor3f(0, 1, 0);  glVertex3f(1.5*i, -11.0,  20.0);
 +    glColor3f(1, 1, 1);  glVertex3f(-20.0, -11.0, 1.5*i);
 +    glColor3f(0, 0, 0);  glVertex3f( 20.0, -11.0, 1.5*i);
 +  }
 +  glEnd();
 +  glEnable(GL_LIGHTING);                        // vratit nastaveni - zapnout osvetleni
 +
 +#if 1
 +  // material zrcadla
 +  GLfloat mat_diffuse[] = {0.8, 0.8, 0.0, 1.0}; // difuzni (matna) slozka materialu
 +  GLfloat mat_ambient[] = {0.4, 0.4, 0.0, 1.0}; // ambient (rozptylena) slozka materialu
 +  GLfloat mat_specular[]= {0.6, 0.9, 0.7, 1.0}; // specular (odleskova) slozka materialu
 +
 +  glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient);
 +  glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse);
 +  glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
 +  glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 125);
 +
 +  // vykresleni zrcadla s texturou, ktera udava barvy a pruhlednost
 +  glEnable(GL_TEXTURE_2D);                      // zapnout texturovani
 +  glEnable(GL_BLEND);                           // zapnout pruhlednost
 +  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // pruhlednostni funkce - alpha slozka materialu
 +  glBegin(GL_QUADS);
 +    glNormal3f(0.0, 0.0, 1.0);                  // nastaveni normaloveho vektoru
 +    glTexCoord2f(0.0, 0.0);  glVertex3f(-16.0, -11.0, 0.0);
 +    glTexCoord2f(1.0, 0.0);  glVertex3f( 16.0, -11.0, 0.0);
 +    glTexCoord2f(1.0, 1.0);  glVertex3f( 16.0,  11.0, 0.0);
 +    glTexCoord2f(0.0, 1.0);  glVertex3f(-16.0,  11.0, 0.0);
 +  glEnd();
 +  glDisable(GL_BLEND);                          // vratit nastaveni - vypnout michani/pruhlednost
 +  glDisable(GL_TEXTURE_2D);                     // vratit nastaveni - vypnout texturovani
 +#endif
 +
 +  // takrka povinne ukonceni
 +  glFlush();                                    // provedeni vsech prikazu
 +  glutSwapBuffers();                            // a prohozeni bufferu
 +}
 +
 +
 +///////////////////////////////////////////////////////////////////////////////
 +// funkce volana pri stisku klavesy
 +// - vola ji GLUT, kdyz uzivatel stiskne klavesu
 +
 +void onKeyboard(unsigned char key, int x, int y)
 +{
 +  // uprava velkych pismen na mala
 +  if (key >= 'A' && key <= 'Z')
 +    key += 'a' - 'A'; 
 +
 +  // rozeskok podle stlacene klavesy
 +  switch (key)
 +  {
 +    // prepnuti na zobrazeni pouze vrcholu
 +    case '1':
 +      glPolygonMode(GL_FRONT, GL_FILL);
 +      glPolygonMode(GL_BACK, GL_FILL);
 +      break;
 +
 +    // prepnuti na zobrazeni dratoveho modelu
 +    case '2':
 +      glPolygonMode(GL_FRONT, GL_LINE);
 +      glPolygonMode(GL_BACK, GL_LINE);
 +      break;
 +
 +    // prepnuti na zobrazeni vyplnenych sten
 +    case '3':
 +      glPolygonMode(GL_FRONT, GL_POINT);
 +      glPolygonMode(GL_BACK, GL_POINT);
 +      break;
 +    
 +    // ukonceni programu
 +    case 27:                                    // klavesa Escape
 +    case 'q':
 +    case 'x':
 +      exit(0);
 +      break;
 +
 +    // prepnuti na celou obrazovku
 +    case 'f':
 +      glutFullScreen();
 +      break;
 +
 +    // prepnuti zpet do okna
 +    case 'w':
 +      glutReshapeWindow(default_w, default_h);
 +      break;
 +
 +    default:
 +      break;
 +  }
 +
 +  // vyvolani prekresleni OpenGL okna
 +  glutPostRedisplay();
 +}
 +
 +
 +///////////////////////////////////////////////////////////////////////////////
 +// funkce volana pri stisku tlacitek mysi                          
 +// - vola GLUT, kdyz uzivatel stiskne tlacitko mysi
 +             
 +int old_mouse_x = 0, old_mouse_y = 0;           // minula pozice mysi, ze ktere se pocitaji rotace
 +int stav = 0;                                   // stav tlacitek mysi
 +
 +void onMouseClick(int button, int state, int x, int y)
 +{
 +  // zapamatovat pozici kurzoru mysi
 +  old_mouse_x = x;
 +  old_mouse_y = y;
 +
 +  if (button == GLUT_LEFT_BUTTON) {             // leve tlacitko aktivuje rotaci
 +    stav = (state == GLUT_DOWN) ? 1 : 0;        // otestuj stlaceni
 +  }
 +  else if (button == GLUT_RIGHT_BUTTON) {       // prave tlacitko aktivuje posun
 +    stav = (state == GLUT_DOWN) ? 2 : 0;        // otestuj stlaceni
 +  }
 +  else {
 +    stav = 0;
 +  }
 +  
 +  // prekresleni sceny
 +  glutPostRedisplay();
 +}
 +
 +
 +///////////////////////////////////////////////////////////////////////////////
 +// funkce volana jestlize se mys pohybuje a je stlaceno nektere tlacitko
 +// - vola GLUT, kdyz uzivatel pohne mysi
 +
 +void onMouseMotion(int x, int y)
 +{
 +  if (stav == 1) {                          // rotace sceny
 +    scene_rot_y += x - old_mouse_x;         // vypocitat novou pozici
 +    scene_rot_x += y - old_mouse_y;
 +    glutPostRedisplay();                    // a prekreslit scenu
 +  }
 +  else if (stav == 2) {                     // posuv sceny
 +    scene_move_z += old_mouse_y - y;
 +    glutPostRedisplay();
 +  }
 +
 +  // zapamatovat novou pozici kurzoru
 +  old_mouse_x = x;
 +  old_mouse_y = y;
 +}
 +
 +
 +///////////////////////////////////////////////////////////////////////////////
 +// funkce volana 40x za sekundu                                         
 +// - vola GLUT                                                       
 +
 +void onTimer(int x)
 +{
 +  time++;                               // zaznacime, ze doslo ke zmene stavu
 +  glutPostRedisplay();                  // a rekneme, ze ma dojit k prekresleni
 +  glutTimerFunc(25, onTimer, 0);        // naplanujeme, ze za dalsich 25ms se ma funkce zavolat
 +}
 +
 +
 +///////////////////////////////////////////////////////////////////////////////
 +// hlavni funkce koznolove aplikace                                
 +// argc - pocet vstupnich parametru
 +// argv - pole vstupnich parametru
 +
 +int main(int argc, char **argv)
 +{
 +  // inicializace knihovny GLUT
 +  glutInit(&argc, argv);
 +
 +  // nastaveni grafickeho modu okna
 +  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH | GLUT_STENCIL);
 +  // pocatecni velikost okna
 +  glutInitWindowSize(default_w, default_h);
 +  // pocatecni pozice okna
 +//  glutInitWindowPosition(200, 100);
 +  // vytvoreni okna pro kresleni
 +  glutCreateWindow(PROGRAM_TITLE);
 +
 +  // registrace funkce volane pri prekreslovani
 +  glutDisplayFunc(onDisplay);
 +  // registrace funkce volane pri zmene velikosti
 +  glutReshapeFunc(onReshape);
 +  // registrace funkce volane pri stisku klavesy
 +  glutKeyboardFunc(onKeyboard);
 +  // registrace funkce volane pri stisku tlacitek mysi
 +  glutMouseFunc(onMouseClick);
 +  // registrace funkce volane pri pohybu mysi
 +  glutMotionFunc(onMouseMotion);
 +  // registrace funkce volane za 25 milisekund
 +  glutTimerFunc(25, onTimer, 0);
 +
 +  // provest nasi uzivatelskou inicializaci
 +  Init();
 +  InitMaterialDisplayLists();
 +  wheel = InitWheelDisplayList(RADIUS, COG_COUNT);
 +  wheel2 = InitWheelDisplayList(RADIUS/2, COG_COUNT/2);
 +  InitTexture();
 +
 +  // nekonecna smycka volajici registrovane funkce
 +  glutMainLoop();
 +
 +  // ANSI C potrebuje ukoncit fci main prikazem return
 +  return 0;
 +}
 +
 +///////////////////////////////////////////////////////////////////////////////
 +///////////////////////////////////////////////////////////////////////////////
 +</file>
/var/www/wiki/data/attic/pitel/izg/lab07.1365143834.txt.bz2 · Poslední úprava: 30. 12. 2022, 13.43:01 (upraveno mimo DokuWiki)

Nástroje pro stránku

Kromě míst, kde je explicitně uvedeno jinak, je obsah této wiki licencován pod následující licencí: CC Attribution-Share Alike 4.0 International
CC Attribution-Share Alike 4.0 International Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki