Line data    Source code

       1             : #include "../libprimis-headers/cube.h"
       2             : #include "../../shared/geomexts.h"
       3             : #include "../../shared/glemu.h"
       4             : #include "../../shared/glexts.h"
       5             : 
       6             : #include "rendergl.h"
       7             : #include "world/octaworld.h"
       8             : 
       9             : namespace lightsphere
      10             : {
      11             :     namespace
      12             :     {
      13             :         size_t numverts   = 0,
      14             :                numindices = 0;
      15             :         GLuint vbuf = 0, //the GLuint pointing to the lightsphere vertex buffer obj; bound to a buffer with init(), its texture deleted with cleanup(), bound by enable()
      16             :                ebuf = 0; //the GLuint pointing to the lightsphere element buffer obj; bound to a buffer with init(), its texture deleted with cleanup(), bound by enable()
      17             : 
      18           0 :         void init(size_t slices, size_t stacks)
      19             :         {
      20           0 :             numverts = (stacks+1)*(slices+1);
      21           0 :             vec * verts = new vec[numverts];
      22           0 :             float ds = 1.0f/slices,
      23           0 :                   dt = 1.0f/stacks,
      24           0 :                   t  = 1.0f;
      25           0 :             for(size_t i = 0; i < stacks+1; ++i)
      26             :             {
      27           0 :                 float rho    = M_PI*(1-t),
      28           0 :                       s      = 0.0f,
      29           0 :                       sinrho = i && i < stacks ? std::sin(rho) : 0,
      30           0 :                       cosrho = !i ? 1 : (i < stacks ? std::cos(rho) : -1);
      31           0 :                 for(size_t j = 0; j < slices+1; ++j)
      32             :                 {
      33           0 :                     float theta = j==slices ? 0 : 2*M_PI*s;
      34           0 :                     verts[i*(slices+1) + j] = vec(-std::sin(theta)*sinrho, -std::cos(theta)*sinrho, cosrho);
      35           0 :                     s += ds;
      36             :                 }
      37           0 :                 t -= dt;
      38             :             }
      39             : 
      40           0 :             numindices = (stacks-1)*slices*3*2;
      41           0 :             GLushort *indices = new ushort[numindices];
      42           0 :             GLushort *curindex = indices;
      43           0 :             for(size_t i = 0; i < stacks; ++i)
      44             :             {
      45           0 :                 for(size_t k = 0; k < slices; ++k)
      46             :                 {
      47           0 :                     size_t j = i%2 ? slices-k-1 : k;
      48           0 :                     if(i)
      49             :                     {
      50           0 :                         *curindex++ = i*(slices+1)+j;
      51           0 :                         *curindex++ = i*(slices+1)+j+1;
      52           0 :                         *curindex++ = (i+1)*(slices+1)+j;
      53             :                     }
      54           0 :                     if(i+1 < stacks)
      55             :                     {
      56           0 :                         *curindex++ = i*(slices+1)+j+1;
      57           0 :                         *curindex++ = (i+1)*(slices+1)+j+1;
      58           0 :                         *curindex++ = (i+1)*(slices+1)+j;
      59             :                     }
      60             :                 }
      61             :             }
      62           0 :             if(!vbuf)
      63             :             {
      64           0 :                 glGenBuffers(1, &vbuf);
      65             :             }
      66           0 :             gle::bindvbo(vbuf);
      67           0 :             glBufferData(GL_ARRAY_BUFFER, numverts*sizeof(vec), verts, GL_STATIC_DRAW);
      68           0 :             delete[] verts;
      69           0 :             verts = nullptr;
      70           0 :             if(!ebuf)
      71             :             {
      72           0 :                 glGenBuffers(1, &ebuf);
      73             :             }
      74           0 :             gle::bindebo(ebuf);
      75           0 :             glBufferData(GL_ELEMENT_ARRAY_BUFFER, numindices*sizeof(GLushort), indices, GL_STATIC_DRAW);
      76           0 :             delete[] indices;
      77           0 :             indices = nullptr;
      78           0 :         }
      79             :     }
      80           0 :     void cleanup()
      81             :     {
      82           0 :         if(vbuf)
      83             :         {
      84           0 :             glDeleteBuffers(1, &vbuf);
      85           0 :             vbuf = 0;
      86             :         }
      87           0 :         if(ebuf)
      88             :         {
      89           0 :             glDeleteBuffers(1, &ebuf);
      90           0 :             ebuf = 0;
      91             :         }
      92           0 :     }
      93             : 
      94           0 :     void enable()
      95             :     {
      96           0 :         if(!vbuf)
      97             :         {
      98           0 :             init(8, 4);
      99             :         }
     100           0 :         gle::bindvbo(vbuf);
     101           0 :         gle::bindebo(ebuf);
     102           0 :         gle::vertexpointer(sizeof(vec), nullptr);
     103           0 :         gle::enablevertex();
     104           0 :     }
     105             : 
     106           0 :     void draw()
     107             :     {
     108           0 :         glDrawRangeElements(GL_TRIANGLES, 0, numverts-1, numindices, GL_UNSIGNED_SHORT, nullptr);
     109           0 :         xtraverts += numindices;
     110           0 :         glde++;
     111           0 :     }
     112             : 
     113           0 :     void disable()
     114             :     {
     115           0 :         gle::disablevertex();
     116           0 :         gle::clearvbo();
     117           0 :         gle::clearebo();
     118           0 :     }
     119             : }