Line data    Source code

       1             : // texture.cpp: texture slot management
       2             : 
       3             : #include "../libprimis-headers/cube.h"
       4             : #include "../../shared/geomexts.h"
       5             : #include "../../shared/glexts.h"
       6             : #include "../../shared/stream.h"
       7             : 
       8             : #include "imagedata.h"
       9             : #include "octarender.h"
      10             : #include "renderwindow.h"
      11             : #include "shaderparam.h"
      12             : #include "shader.h"
      13             : #include "texture.h"
      14             : 
      15             : #include "world/light.h"
      16             : #include "world/material.h"
      17             : #include "world/octaedit.h"
      18             : #include "world/octaworld.h"
      19             : #include "world/world.h"
      20             : 
      21             : #include "interface/console.h"
      22             : #include "interface/control.h"
      23             : 
      24             : //globalshaderparam
      25             : 
      26           0 : GlobalShaderParam::GlobalShaderParam(const char *name) : name(name), param(nullptr) {}
      27             : 
      28           0 : GlobalShaderParamState &GlobalShaderParam::getglobalparam(const std::string &name) const
      29             : {
      30           0 :     auto itr = globalparams.find(name);
      31           0 :     if(itr != globalparams.end())
      32             :     {
      33           0 :         return (*itr).second;
      34             :     }
      35             :     else
      36             :     {
      37           0 :         GlobalShaderParamState &param = globalparams[name];
      38           0 :         param.buf.fill(-1);
      39           0 :         param.version = -1;
      40           0 :         return param;
      41             :     }
      42             : }
      43             : 
      44           0 : GlobalShaderParamState &GlobalShaderParam::resolve()
      45             : {
      46           0 :     if(!param)
      47             :     {
      48           0 :         param = &getglobalparam(name);
      49             :     }
      50           0 :     param->changed();
      51           0 :     return *param;
      52             : }
      53             : 
      54           0 : void GlobalShaderParam::setf(float x, float y, float z, float w)
      55             : {
      56           0 :     GlobalShaderParamState &g = resolve();
      57           0 :     g.fval[0] = x;
      58           0 :     g.fval[1] = y;
      59           0 :     g.fval[2] = z;
      60           0 :     g.fval[3] = w;
      61           0 : }
      62             : 
      63           0 : void GlobalShaderParam::set(const vec &v, float w)
      64             : {
      65           0 :     setf(v.x, v.y, v.z, w);
      66           0 : }
      67             : 
      68           0 : void GlobalShaderParam::set(const vec2 &v, float z, float w)
      69             : {
      70           0 :     setf(v.x, v.y, z, w);
      71           0 : }
      72             : 
      73           0 : void GlobalShaderParam::set(const matrix3 &m)
      74             : {
      75           0 :     std::memcpy(resolve().fval, m.a.v, sizeof(m));
      76           0 : }
      77             : 
      78           0 : void GlobalShaderParam::set(const matrix4 &m)
      79             : {
      80           0 :     std::memcpy(resolve().fval, m.a.v, sizeof(m));
      81           0 : }
      82             : 
      83             : std::map<std::string, GlobalShaderParamState> globalparams;
      84             : 
      85             : //localshaderparam
      86             : 
      87           0 : LocalShaderParam::LocalShaderParam(const char *name) : name(name), loc(-1)
      88             : {
      89           0 : }
      90             : 
      91           0 : const LocalShaderParamState *LocalShaderParam::resolve() const
      92             : {
      93           0 :     const Shader *s = Shader::lastshader;
      94           0 :     if(!s)
      95             :     {
      96           0 :         return nullptr;
      97             :     }
      98           0 :     if(!(s->localparamremap.size() > static_cast<uint>(loc)))
      99             :     {
     100           0 :         if(loc == -1)
     101             :         {
     102           0 :             loc = getlocalparam(name);
     103             :         }
     104           0 :         if(!(s->localparamremap.size() > static_cast<uint>(loc)))
     105             :         {
     106           0 :             return nullptr;
     107             :         }
     108             :     }
     109           0 :     uchar remap = s->localparamremap[loc];
     110           0 :     return (s->localparams.size() > remap) ? &s->localparams[remap] : nullptr;
     111             : }
     112             : 
     113           0 : void LocalShaderParam::setf(float x, float y, float z, float w) const
     114             : {
     115           0 :     const ShaderParamBinding *b = resolve();
     116           0 :     if(b)
     117             :     {
     118           0 :         switch(b->format)
     119             :         {
     120           0 :             case GL_BOOL:
     121             :             case GL_FLOAT:
     122             :             {
     123           0 :                 glUniform1f(b->loc, x);
     124           0 :                 break;
     125             :             }
     126           0 :             case GL_BOOL_VEC2:
     127             :             case GL_FLOAT_VEC2:
     128             :             {
     129           0 :                 glUniform2f(b->loc, x, y);
     130           0 :                 break;
     131             :             }
     132           0 :             case GL_BOOL_VEC3:
     133             :             case GL_FLOAT_VEC3:
     134             :             {
     135           0 :                 glUniform3f(b->loc, x, y, z);
     136           0 :                 break;
     137             :             }
     138           0 :             case GL_BOOL_VEC4:
     139             :             case GL_FLOAT_VEC4:
     140             :             {
     141           0 :                 glUniform4f(b->loc, x, y, z, w);
     142           0 :                 break;
     143             :             }
     144           0 :             case GL_INT:
     145             :             {
     146           0 :                 glUniform1i(b->loc, static_cast<int>(x));
     147           0 :                 break;
     148             :             }
     149           0 :             case GL_INT_VEC2:
     150             :             {
     151           0 :                 glUniform2i(b->loc, static_cast<int>(x), static_cast<int>(y));
     152           0 :                 break;
     153             :             }
     154           0 :             case GL_INT_VEC3:
     155             :             {
     156           0 :                 glUniform3i(b->loc, static_cast<int>(x), static_cast<int>(y), static_cast<int>(z));
     157           0 :                 break;
     158             :             }
     159           0 :             case GL_INT_VEC4:
     160             :             {
     161           0 :                 glUniform4i(b->loc, static_cast<int>(x), static_cast<int>(y), static_cast<int>(z), static_cast<int>(w));
     162           0 :                 break;
     163             :             }
     164           0 :             case GL_UNSIGNED_INT:
     165             :             {
     166           0 :                 glUniform1ui(b->loc, static_cast<uint>(x));
     167           0 :                 break;
     168             :             }
     169           0 :             case GL_UNSIGNED_INT_VEC2:
     170             :             {
     171           0 :                 glUniform2ui(b->loc, static_cast<uint>(x), static_cast<uint>(y));
     172           0 :                 break;
     173             :             }
     174           0 :             case GL_UNSIGNED_INT_VEC3:
     175             :             {
     176           0 :                 glUniform3ui(b->loc, static_cast<uint>(x), static_cast<uint>(y), static_cast<uint>(z));
     177           0 :                 break;
     178             :             }
     179           0 :             case GL_UNSIGNED_INT_VEC4:
     180             :             {
     181           0 :                 glUniform4ui(b->loc, static_cast<uint>(x), static_cast<uint>(y), static_cast<uint>(z), static_cast<uint>(w));
     182           0 :                 break;
     183             :             }
     184             :         }
     185             :     }
     186           0 : }
     187             : 
     188           0 : void LocalShaderParam::set(const vec &v, float w) const
     189             : {
     190           0 :     setf(v.x, v.y, v.z, w);
     191           0 : }
     192             : 
     193           0 : void LocalShaderParam::set(const vec4<float> &v) const
     194             : {
     195           0 :     setf(v.x, v.y, v.z, v.w);
     196           0 : }
     197             : 
     198           0 : void LocalShaderParam::setv(const float *f, int n) const
     199             : {
     200           0 :     const ShaderParamBinding *b = resolve();
     201           0 :     if(b)
     202             :     {
     203           0 :         glUniform1fv(b->loc, n, f);
     204             :     }
     205           0 : }
     206             : 
     207           0 : void LocalShaderParam::setv(const vec *v, int n) const
     208             : {
     209           0 :     const ShaderParamBinding *b = resolve();
     210           0 :     if(b)
     211             :     {
     212           0 :         glUniform3fv(b->loc, n, v->v);
     213             :     }
     214           0 : }
     215             : 
     216           0 : void LocalShaderParam::setv(const vec2 *v, int n) const
     217             : {
     218           0 :     const ShaderParamBinding *b = resolve();
     219           0 :     if(b)
     220             :     {
     221           0 :         glUniform2fv(b->loc, n, v->v);
     222             :     }
     223           0 : }
     224             : 
     225           0 : void LocalShaderParam::setv(const vec4<float> *v, int n) const
     226             : {
     227           0 :     const ShaderParamBinding *b = resolve();
     228           0 :     if(b)
     229             :     {
     230           0 :         glUniform4fv(b->loc, n, v->v);
     231             :     }
     232           0 : }
     233             : 
     234           0 : void LocalShaderParam::setv(const matrix3 *m, int n) const
     235             : {
     236           0 :     const ShaderParamBinding *b = resolve();
     237           0 :     if(b)
     238             :     {
     239           0 :         glUniformMatrix3fv(b->loc, n, GL_FALSE, m->a.v);
     240             :     }
     241           0 : }
     242             : 
     243           0 : void LocalShaderParam::setv(const matrix4 *m, int n) const
     244             : {
     245           0 :     const ShaderParamBinding *b = resolve();
     246           0 :     if(b)
     247             :     {
     248           0 :         glUniformMatrix4fv(b->loc, n, GL_FALSE, m->a.v);
     249             :     }
     250           0 : }
     251             : 
     252           0 : void LocalShaderParam::set(const matrix3 &m) const
     253             : {
     254           0 :     setv(&m);
     255           0 : }
     256             : 
     257           0 : void LocalShaderParam::set(const matrix4 &m) const
     258             : {
     259           0 :     setv(&m);
     260           0 : }