SHARE
TWEET

cpp

a guest May 11th, 2016 262 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include "MyApp.h"
  2. #include "GLUtils.hpp"
  3.  
  4. #include <GL/GLU.h>
  5. #include <math.h>
  6.  
  7. CMyApp::CMyApp(void)
  8. {
  9.     m_vaoID = 0;
  10.     m_vboID = 0;
  11.     m_programID = 0;
  12.     m_waterTextureID = 0;
  13.  
  14.     meshLabak = 0;
  15. }
  16.  
  17. glm::vec3   CMyApp::GetUV(float u, float v) {
  18.     u *= 2 * 3.1415f;
  19.     v *= 3.1415f;
  20.     float cu = cosf(u), su = sinf(u), cv = cosf(v), sv = sinf(v);
  21.     float r = 5;
  22.  
  23.     return glm::vec3(r*cu*sv, r*cv, r*su*sv);
  24. }
  25.  
  26. GLuint CMyApp::GenTexture() {
  27.     unsigned char tex[512][512][3];
  28.     for (int i = 0; i<512; ++i)
  29.         for (int j = 0; j<512; ++j) {
  30.             tex[i][j][0] = 44;
  31.             tex[i][j][1] = 44;
  32.             tex[i][j][2] = 44;
  33.         }
  34.  
  35.     const int N = 5000;
  36.     for (int i = 0; i < N; ++i) {
  37.         glm::vec4 pont = glm::vec4(cos(1 / (float)N*i * 2 * M_PI) * 20 * 512 / 40.0,
  38.             0,
  39.             -sin(1 / (float)N*i * 2 * M_PI) * 5 * 512 / 40.0, 1);
  40.         pont = glm::translate<float>(256, 0, 256)*glm::rotate<float>(45, 0, 1, 0)*pont;
  41.         tex[(int)pont.x][(int)pont.z][0] = 57;
  42.         tex[(int)pont.x][(int)pont.z][1] = 195;
  43.         tex[(int)pont.x][(int)pont.z][2] = 79;
  44.  
  45.     }
  46.  
  47.     GLuint tmpID;
  48.  
  49.     glGenTextures(1, &tmpID);
  50.     glBindTexture(GL_TEXTURE_2D, tmpID);
  51.     gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB8, 512, 512, GL_RGB, GL_UNSIGNED_BYTE, tex);
  52.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  53.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  54.     glBindTexture(GL_TEXTURE_2D, 0);
  55.  
  56.     return tmpID;
  57. }
  58.  
  59. glm::vec3 CMyApp::toDesc(float fi, float theta) {
  60.     return glm::vec3(sin(fi)*cos(theta), cos(fi), -sin(fi)*sin(theta));
  61. }
  62.  
  63.  
  64. CMyApp::~CMyApp(void)
  65. {
  66. }
  67.  
  68. bool CMyApp::Init()
  69. {
  70.     // törlési szín legyen kékes
  71.     glClearColor(0.125f, 0.25f, 0.5f, 1.0f);
  72.  
  73.     glEnable(GL_CULL_FACE); // kapcsoljuk be a hatrafele nezo lapok eldobasat
  74.     glEnable(GL_DEPTH_TEST); // mélységi teszt bekapcsolása (takarás)
  75.     glCullFace(GL_BACK); // GL_BACK: a kamerától "elfelé" néző lapok, GL_FRONT: a kamera felé néző lapok
  76.  
  77.     //
  78.     // geometria letrehozasa
  79.     //
  80.  
  81.     Vertex vert[] ={
  82.         //          x,  y, z               nx,ny,nz          s, t
  83.         {glm::vec3(-20, 0, -20), glm::vec3( 0, 1, 0), glm::vec2(0, 0)},
  84.         {glm::vec3(-20, 0,  20), glm::vec3( 0, 1, 0), glm::vec2(0, 1)},
  85.         {glm::vec3( 20, 0, -20), glm::vec3( 0, 1, 0), glm::vec2(1, 0)},
  86.         {glm::vec3( 20, 0,  20), glm::vec3( 0, 1, 0), glm::vec2(1, 1)},
  87.     };
  88.     GLushort indices[]= {
  89.         0,1,2,
  90.         2,1,3,
  91.     };
  92.  
  93.     const int N = 10;
  94.     const int M = 10;
  95.     Vertex vertGomb[(N + 1)*(M + 1)];
  96.     for (int i = 0; i <= N; ++i)
  97.         for (int j = 0; j <= M; ++j)
  98.         {
  99.             float u = i / (float)N;
  100.             float v = j / (float)M;
  101.  
  102.             vertGomb[i + j*(N + 1)].p = GetUV(u, v);
  103.             vertGomb[i + j*(N + 1)].t = glm::vec2(u,v);
  104.             //vertGomb[i + j*(N + 1)].n = GetUVn(u, v);;
  105.         }
  106.  
  107.     GLushort indicesGomb[3 * 2 * (N)*(M)];
  108.     for (int i = 0; i<N; ++i)
  109.         for (int j = 0; j<M; ++j)
  110.         {
  111.             indicesGomb[6 * i + j * 3 * 2 * (N)+0] = (i)+(j)*   (N + 1);
  112.             indicesGomb[6 * i + j * 3 * 2 * (N)+1] = (i + 1) + (j)* (N + 1);
  113.             indicesGomb[6 * i + j * 3 * 2 * (N)+2] = (i)+(j + 1)*(N + 1);
  114.             indicesGomb[6 * i + j * 3 * 2 * (N)+3] = (i + 1) + (j)* (N + 1);
  115.             indicesGomb[6 * i + j * 3 * 2 * (N)+4] = (i + 1) + (j + 1)*(N + 1);
  116.             indicesGomb[6 * i + j * 3 * 2 * (N)+5] = (i)+(j + 1)*(N + 1);
  117.         }
  118.  
  119.  
  120.     glGenVertexArrays(1, &m_vaoID);
  121.     glBindVertexArray(m_vaoID);
  122.  
  123.     glGenBuffers(1, &m_vboID);
  124.     glBindBuffer(GL_ARRAY_BUFFER, m_vboID); // tegyük "aktívvá" a létrehozott VBO-t
  125.     glBufferData( GL_ARRAY_BUFFER,  // az aktív VBO-ba töltsünk adatokat
  126.                   sizeof(vert),     // ennyi bájt nagyságban
  127.                   vert, // erről a rendszermemóriabeli címről olvasva
  128.                   GL_STATIC_DRAW)// úgy, hogy a VBO-nkba nem tervezünk ezután írni és minden kirajzoláskor felhasnzáljuk a benne lévő adatokat
  129.    
  130.  
  131.     // VAO-ban jegyezzük fel, hogy a VBO-ban az első 3 float sizeof(Vertex)-enként lesz az első attribútum (pozíció)
  132.     glEnableVertexAttribArray(0); // ez lesz majd a pozíció
  133.     glVertexAttribPointer(
  134.         0,              // a VB-ben található adatok közül a 0. "indexű" attribútumait állítjuk be
  135.         3,              // komponens szam
  136.         GL_FLOAT,       // adatok tipusa
  137.         GL_FALSE,       // normalizalt legyen-e
  138.         sizeof(Vertex), // stride (0=egymas utan)
  139.         0               // a 0. indexű attribútum hol kezdődik a sizeof(Vertex)-nyi területen belül
  140.     );
  141.  
  142.     // a második attribútumhoz pedig a VBO-ban sizeof(Vertex) ugrás után sizeof(glm::vec3)-nyit menve újabb 3 float adatot találunk (szín)
  143.     glEnableVertexAttribArray(1); // ez lesz majd a szín
  144.     glVertexAttribPointer(
  145.         1,
  146.         3,
  147.         GL_FLOAT,
  148.         GL_FALSE,
  149.         sizeof(Vertex),
  150.         (void*)(sizeof(glm::vec3)) );
  151.  
  152.     // textúrakoordináták bekapcsolása a 2-es azonosítójú attribútom csatornán
  153.     glEnableVertexAttribArray(2);
  154.     glVertexAttribPointer(
  155.         2,
  156.         2,
  157.         GL_FLOAT,
  158.         GL_FALSE,
  159.         sizeof(Vertex),
  160.         (void*)(2*sizeof(glm::vec3)) );
  161.  
  162.     // index puffer létrehozása
  163.     glGenBuffers(1, &m_ibID);
  164.     // a VAO észreveszi, hogy bind-olunk egy index puffert és feljegyzi, hogy melyik volt ez!
  165.     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibID);
  166.     glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
  167.  
  168.     glBindVertexArray(0); // feltöltüttük a VAO-t, kapcsoljuk le
  169.     glBindBuffer(GL_ARRAY_BUFFER, 0); // feltöltöttük a VBO-t is, ezt is vegyük le
  170.     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); // feltöltöttük a VBO-t is, ezt is vegyük le
  171.  
  172.     //------------------------GOMB VAO, VBO, IBO ---------------------
  173.  
  174.     glGenVertexArrays(1, &gomb_vaoID);
  175.     glBindVertexArray(gomb_vaoID);
  176.  
  177.     glGenBuffers(1, &gomb_vboID);
  178.     glBindBuffer(GL_ARRAY_BUFFER, gomb_vboID); // tegyük "aktívvá" a létrehozott VBO-t
  179.     glBufferData(GL_ARRAY_BUFFER,   // az aktív VBO-ba töltsünk adatokat
  180.         sizeof(vertGomb),       // ennyi bájt nagyságban
  181.         vertGomb,   // erről a rendszermemóriabeli címről olvasva
  182.         GL_STATIC_DRAW);    // úgy, hogy a VBO-nkba nem tervezünk ezután írni és minden kirajzoláskor felhasnzáljuk a benne lévő adatokat
  183.  
  184.  
  185.                             // VAO-ban jegyezzük fel, hogy a VBO-ban az első 3 float sizeof(Vertex)-enként lesz az első attribútum (pozíció)
  186.     glEnableVertexAttribArray(0); // ez lesz majd a pozíció
  187.     glVertexAttribPointer(
  188.         0,              // a VB-ben található adatok közül a 0. "indexű" attribútumait állítjuk be
  189.         3,              // komponens szam
  190.         GL_FLOAT,       // adatok tipusa
  191.         GL_FALSE,       // normalizalt legyen-e
  192.         sizeof(Vertex), // stride (0=egymas utan)
  193.         0               // a 0. indexű attribútum hol kezdődik a sizeof(Vertex)-nyi területen belül
  194.         );
  195.  
  196.     // a második attribútumhoz pedig a VBO-ban sizeof(Vertex) ugrás után sizeof(glm::vec3)-nyit menve újabb 3 float adatot találunk (szín)
  197.     glEnableVertexAttribArray(1); // ez lesz majd a szín
  198.     glVertexAttribPointer(
  199.         1,
  200.         3,
  201.         GL_FLOAT,
  202.         GL_FALSE,
  203.         sizeof(Vertex),
  204.         (void*)(sizeof(glm::vec3)));
  205.  
  206.     // textúrakoordináták bekapcsolása a 2-es azonosítójú attribútom csatornán
  207.     glEnableVertexAttribArray(2);
  208.     glVertexAttribPointer(
  209.         2,
  210.         2,
  211.         GL_FLOAT,
  212.         GL_FALSE,
  213.         sizeof(Vertex),
  214.         (void*)(2 * sizeof(glm::vec3)));
  215.  
  216.     // index puffer létrehozása
  217.     glGenBuffers(1, &gomb_ibID);
  218.     // a VAO észreveszi, hogy bind-olunk egy index puffert és feljegyzi, hogy melyik volt ez!
  219.     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, gomb_ibID);
  220.     glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indicesGomb), indicesGomb, GL_STATIC_DRAW);
  221.  
  222.     glBindVertexArray(0); // feltöltüttük a VAO-t, kapcsoljuk le
  223.     glBindBuffer(GL_ARRAY_BUFFER, 0); // feltöltöttük a VBO-t is, ezt is vegyük le
  224.     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); // feltöltöttük a VBO-t is, ezt is vegyük le
  225.  
  226.     //
  227.     // shaderek betöltése
  228.     //
  229.     GLuint vs_ID = loadShader(GL_VERTEX_SHADER,     "myVert.vert");
  230.     GLuint fs_ID = loadShader(GL_FRAGMENT_SHADER,   "myFrag.frag");
  231.  
  232.     // a shadereket tároló program létrehozása
  233.     m_programID = glCreateProgram();
  234.  
  235.     // adjuk hozzá a programhoz a shadereket
  236.     glAttachShader(m_programID, vs_ID);
  237.     glAttachShader(m_programID, fs_ID);
  238.  
  239.     // VAO-beli attribútumok hozzárendelése a shader változókhoz
  240.     // FONTOS: linkelés előtt kell ezt megtenni!
  241.     glBindAttribLocation(   m_programID,    // shader azonosítója, amiből egy változóhoz szeretnénk hozzárendelést csinálni
  242.                             0,              // a VAO-beli azonosító index
  243.                             "vs_in_pos");   // a shader-beli változónév
  244.     glBindAttribLocation( m_programID, 1, "vs_in_col");
  245.     glBindAttribLocation( m_programID, 2, "vs_in_tex0");
  246.  
  247.     // illesszük össze a shadereket (kimenő-bemenő változók összerendelése stb.)
  248.     glLinkProgram(m_programID);
  249.  
  250.     // linkeles ellenorzese
  251.     GLint infoLogLength = 0, result = 0;
  252.  
  253.     glGetProgramiv(m_programID, GL_LINK_STATUS, &result);
  254.     glGetProgramiv(m_programID, GL_INFO_LOG_LENGTH, &infoLogLength);
  255.     if ( GL_FALSE == result )
  256.     {
  257.         std::vector<char> ProgramErrorMessage( infoLogLength );
  258.         glGetProgramInfoLog(m_programID, infoLogLength, NULL, &ProgramErrorMessage[0]);
  259.         fprintf(stdout, "%s\n", &ProgramErrorMessage[0]);
  260.        
  261.         char* aSzoveg = new char[ProgramErrorMessage.size()];
  262.         memcpy( aSzoveg, &ProgramErrorMessage[0], ProgramErrorMessage.size());
  263.  
  264.         std::cout << "[app.Init()] Sáder Huba panasza: " << aSzoveg << std::endl;
  265.  
  266.         delete aSzoveg;
  267.     }
  268.  
  269.     // mar nincs ezekre szukseg
  270.     glDeleteShader( vs_ID );
  271.     glDeleteShader( fs_ID );
  272.  
  273.     //
  274.     // egyéb inicializálás
  275.     //
  276.  
  277.     // vetítési mátrix létrehozása
  278.     m_matProj = glm::perspective( 45.0f, 640/480.0f, 1.0f, 1000.0f );
  279.  
  280.     // shader-beli transzformációs mátrixok címének lekérdezése
  281.     m_loc_mvp = glGetUniformLocation( m_programID, "MVP");
  282.  
  283.     m_loc_texture = glGetUniformLocation( m_programID, "texture" );
  284.  
  285.     //
  286.     // egyéb erőforrások betöltése
  287.     //
  288.  
  289.     // textúra betöltése
  290.     m_waterTextureID = TextureFromFile("texture.bmp");
  291.     fejTexturaID = TextureFromFile("fej.jpg");
  292.     labakTexturaID = TextureFromFile("labak.jpg");
  293.     gombTexturaID = TextureFromFile("texture.bmp");
  294.     talajTexturaID = GenTexture();
  295.  
  296.     // mesh betoltese
  297.     meshLabak = ObjParser::parse("labak.obj");
  298.     meshLabak->initBuffers();
  299.  
  300.     meshFej = ObjParser::parse("fej.obj");
  301.     meshFej->initBuffers();
  302.  
  303.     return true;
  304. }
  305.  
  306. void CMyApp::Clean()
  307. {
  308.     delete meshLabak;
  309.     glDeleteTextures(1, &m_waterTextureID);
  310.  
  311.     glDeleteBuffers(1, &m_vboID);
  312.     glDeleteVertexArrays(1, &m_vaoID);
  313.  
  314.     glDeleteProgram( m_programID );
  315. }
  316.  
  317. void CMyApp::Update()
  318. {
  319.     m_matView = glm::lookAt(eye, at, glm::vec3(0, 1, 0));
  320. }
  321.  
  322.  
  323. void CMyApp::DrawGround()
  324. {
  325.     // a talaj kirajzolasahoz szukseges shader beallitasa
  326.     glUseProgram( m_programID );
  327.     m_matWorld = glm::mat4(1.0f);
  328.     glm::mat4 mvp = m_matProj * m_matView * m_matWorld;
  329.     glUniformMatrix4fv( m_loc_mvp,// erre a helyre töltsünk át adatot
  330.                         1,          // egy darab mátrixot
  331.                         GL_FALSE,   // NEM transzponálva
  332.                         &(mvp[0][0]) ); // innen olvasva a 16 x sizeof(float)-nyi adatot
  333.     glActiveTexture(GL_TEXTURE0);
  334.     glBindTexture(GL_TEXTURE_2D, talajTexturaID);
  335.     glUniform1i(    m_loc_texture,0);
  336.  
  337.     // kapcsoljuk be a VAO-t (a VBO jön vele együtt)
  338.     glBindVertexArray(m_vaoID);
  339.  
  340.     // kirajzolás
  341.     glDrawElements( GL_TRIANGLES,       // primitív típus
  342.                     6,                  // hany csucspontot hasznalunk a kirajzolashoz
  343.                     GL_UNSIGNED_SHORT,  // indexek tipusa
  344.                     0);                 // indexek cime
  345.  
  346.     // VAO kikapcsolasa
  347.     glBindVertexArray(0);
  348.  
  349.     // textúra kikapcsolása
  350.     glBindTexture(GL_TEXTURE_2D, 0);
  351.  
  352.     glUseProgram( 0 );
  353. }
  354.  
  355. void CMyApp::DrawMesh() {
  356.     glUseProgram( m_programID );
  357.     /*fej*/
  358.     m_matWorld = glm::rotate<float>(45,0,1,0)*glm::translate<float>(20*cos(SDL_GetTicks()/3000.0*2*M_PI), 0, -5*sin(SDL_GetTicks()/3000.0*2*M_PI));
  359.     glm::mat4 mvp = m_matProj * m_matView * m_matWorld;
  360.     glUniformMatrix4fv( m_loc_mvp,1,GL_FALSE,&(mvp[0][0]) ); // innen olvasva a 16 x sizeof(float)-nyi adatot
  361.  
  362.     glActiveTexture(GL_TEXTURE0);
  363.     glBindTexture(GL_TEXTURE_2D, labakTexturaID);
  364.     glUniform1i(m_loc_texture,0);
  365.     meshFej->draw();
  366.  
  367.     /*labak*/
  368.     m_matWorld = m_matWorld*glm::rotate<float>(SDL_GetTicks() / 500.0 * 360, 0, 1, 0);
  369.     mvp = m_matProj * m_matView * m_matWorld;
  370.     glUniformMatrix4fv(m_loc_mvp, 1, GL_FALSE, &(mvp[0][0]));
  371.  
  372.     glBindTexture(GL_TEXTURE_2D, fejTexturaID);
  373.     meshLabak->draw();
  374.  
  375.     /*gomb*/
  376.     m_matWorld = glm::translate<float>(0,15,0);
  377.     mvp = m_matProj * m_matView * m_matWorld;
  378.     glBindTexture(GL_TEXTURE_2D, gombTexturaID);
  379.     glUniformMatrix4fv(m_loc_mvp, 1, GL_FALSE, &(mvp[0][0]));
  380.     glBindVertexArray(gomb_vaoID);
  381.     glDrawElements(GL_TRIANGLES, 3*2*10*10, GL_UNSIGNED_SHORT, 0);
  382.     glBindVertexArray(0);
  383.  
  384.     glUseProgram( 0 );
  385. }
  386.  
  387. void CMyApp::Render()
  388. {
  389.     // töröljük a frampuffert (GL_COLOR_BUFFER_BIT) és a mélységi Z puffert (GL_DEPTH_BUFFER_BIT)
  390.     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  391.  
  392.     DrawGround();
  393.     DrawMesh();
  394. }
  395.  
  396. void CMyApp::KeyboardDown(SDL_KeyboardEvent& key)
  397. {
  398.     switch (key.keysym.sym) {
  399.     case SDLK_w:
  400.         eye += forward*glm::vec3(0.1);
  401.         at = toDesc(fi, theta) + eye;
  402.         break;
  403.     case SDLK_s:
  404.         eye -= forward*glm::vec3(0.1);
  405.         at = toDesc(fi, theta) + eye;
  406.         break;
  407.     case SDLK_a:
  408.         eye += glm::normalize(glm::cross(glm::vec3(0, 1, 0), forward))*glm::vec3(0.1);
  409.         at = toDesc(fi, theta) + eye;
  410.         break;
  411.     case SDLK_d:
  412.         eye -= glm::normalize(glm::cross(glm::vec3(0, 1, 0), forward))*glm::vec3(0.1);
  413.         at = toDesc(fi, theta) + eye;
  414.         break;
  415.     }
  416.  
  417. }
  418.  
  419. void CMyApp::KeyboardUp(SDL_KeyboardEvent& key)
  420. {
  421. }
  422.  
  423. void CMyApp::MouseMove(SDL_MouseMotionEvent& mouse) {
  424.     if (mouse.state & SDL_BUTTON_LMASK) {
  425.         theta -= mouse.xrel*0.005;
  426.         fi += mouse.yrel*0.005;
  427.         fi = glm::clamp(fi, 0.001f, 3.13f);
  428.         at = toDesc(fi, theta) + eye;
  429.         forward = glm::normalize(at - eye);
  430.     }
  431. }
  432.  
  433. void CMyApp::MouseDown(SDL_MouseButtonEvent& mouse)
  434. {
  435. }
  436.  
  437. void CMyApp::MouseUp(SDL_MouseButtonEvent& mouse)
  438. {
  439. }
  440.  
  441. void CMyApp::MouseWheel(SDL_MouseWheelEvent& wheel)
  442. {
  443. }
  444.  
  445. // a két paraméterbe az új ablakméret szélessége (_w) és magassága (_h) található
  446. void CMyApp::Resize(int _w, int _h)
  447. {
  448.     glViewport(0, 0, _w, _h);
  449.  
  450.     m_matProj = glm::perspective(  45.0f,       // 90 fokos nyilasszog
  451.                                     _w/(float)_h,   // ablakmereteknek megfelelo nezeti arany
  452.                                     0.01f,          // kozeli vagosik
  453.                                     100.0f);        // tavoli vagosik
  454. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top