VAO OpenGL + шейдеры - пара-тройка вопросов (2 стр)

// расчёт нормалей
void Mesh::CalculateNormals()
{
  for (int i=0; i<i_count; i+=3) // количество индексов вершин с шагом 3(каждые 3 - triangle)
  {
    Vector3f a(vertex[index[i]]-vertex[index[i+1]]);  // одна сторона треугольника
    Vector3f b(vertex[index[i]]-vertex[index[i+2]]);  // вторая сторона
    Vector3f norm=cross(a,b);
    norm.normalise();
    normal[i] = normal[i+1] = normal[i+2] = norm;  // у всех трёх вершин в этом треугольнике одинаковая нормаль
  }
}

// расчёт сглаженных нормалей(правда если к примеру 1000 вершин, то цикл в расчёте будет 1000*1000, но вроде быстро, либо хранить нормали в файле модели и не считать их вообще)
void Mesh::CalculateSmoothNormals()
{
  int p;

  CalculateNormals(); // расчитаем простые нормали

  Vector3f *nrm=new Vector3f[v_count]; //сохраним расчитанные нормали в временном массиве
  for (p=0; p<v_count; p++)
  nrm[p]=normal[p];

  // посчитаем сглаженные
  for (int i=0; i<v_count; i++)  // пройдёмся по каждой вершине
  {
    Vector3f vnorm;                 // будущая сглаженная нормаль
    Vector3f pos = vertex[i];   // возьмём позицию вершины
    for (p=0; p<v_count; p++) // будем сравнивать со всеми вершинами(в том числе и с собой)
    {
      if (vertex[p]==pos) // если позиция совпадает
      vnorm+=nrm[p]; // прибавим нормаль этой вершины к общей сумме
    }
    vnorm.normalise(); // нормализуем полученный результат

    normal[i] = vnorm; // запишем уже сглаженную нормаль
  }

  delete []nrm;
}

void Mesh::CreateTangentSpace()
{

  for (int p=0; p<i_count; p+=3)
  {
        // расчёт тангент оси
        Vector3f A(vertex[index[p]]),          //первая вершина
          B(vertex[index[p+1]]),      //вторая
          C(vertex[index[p+2]]);     //третья

  
        Texcoord TA(texcoord[index[p]]),  // текстурные координаты этих вершин
           TB(texcoord[index[p+1]]), 
           TC(texcoord[index[p+2]]);
  
        Vector3f v1,v2,t1,t2,tmp;

  v1 = B-A; 
        v2 = C-A;
        t1 = Vector3f((TB-TA).x, (TB-TA).y, 0);
        t2 = Vector3f((TC-TA).x, (TC-TA).y, 0);

  Vector3f N=cross(v1,v2);
        N.normalise();
  
        Vector3f TANGENT;
        if (t1.y == 0) TANGENT = ((t1.x > 0) ? v1 : -v1); // если координата t текстурного вектора t1 равна нулю, то тангент совпадает с v1
        else
  {
          if (t2.y == 0) TANGENT = ((t2.x > 0) ? v2 : -v2); // если координата t текстурного вектора t2 равна нулю, то тангент совпадает с v2
    else
   {
           // тут пояснять без рисунка сложновато, расчитывается то, каким по длине должен быть вектор одной из сторон, чтоб разница текстурной координаты t по обоим сторонам была одинакова
            float lenv = (t2.y * v1.len()) / t1.y;
      tmp = v1;
      tmp.normalise();
            TANGENT = v2 - (tmp * lenv) ;
            // если текстура перевёрнута, то и тангент нужно будет повернуть
      float tlenv = (t2.y * t1.len()) / t1.y;
      tmp = t1;
      tmp.normalise();
      Vector3f tT = t2 - (tmp * tlenv);
      if (tT.x < 0) TANGENT = -TANGENT;  // если полученный вектор тангента спроецированный в систему текстурных координат направлен в сторону -s, то тангент в системе координат модели нужно повернуть(иначе нормалмап будет в другую сторону)
         }
        }
        TANGENT.normalise();
        
        // аналогичный расчёт бинормали (тангент и бинормаль могут быть не перпендикулярны)
        Vector3f BINORM;
        if (t1.x == 0) BINORM = ((t1.y > 0) ? v1 : -v1);
        else
       {
          if (t2.x == 0) BINORM = ((t2.y > 0) ? v2 : -v2);
    else
         {
            float lenv = (t2.x * v1.len()) / t1.x;
            tmp = v1;
      tmp.normalise();
            BINORM = v2 - (tmp * lenv);
      float tlenv = (t2.x * t1.len()) / t1.x;
      tmp = t1;
      tmp.normalise();
      Vector3f tB = t2 - (tmp * tlenv);
      if (tB.y < 0) BINORM = -BINORM;
         }
      }
      BINORM.normalise();

     // запишем для каждой вершины треугольника одинаковый тангент и бинормаль
      for (int t=0; t<3; t++)
     {
        tangent[index[p+t]] = TANGENT;  
        binormal[index[p+t]] = BINORM; 
      }

      // если нормали сглаженные, то мы и тангент и бинормаль должны повернуть на столько же, на сколько повернута сглаженная нормаль по отношению к обычной
      /*if (smooth)  при повороте работает не совсем корректно, изменил на новый способ
     {
       for (int c=0; c<3; c++)
      {
        Vector3f norm = normal[index[p+c]]; // сглаженная нормаль
  Vector3f tan = tangent[index[p+c]];  // уже посчитанный тангент
  Vector3f binorm = binormal[index[p+c]]; //уже посчитанная бинормаль

        Vector3f axis = cross(N, norm); // найдём ось поворота обычной нормали до сглаженной
        float angle = rad(N, norm);  // получим угол между ними в радианах
        Rotate(tan, axis, angle); // повернём тангент по этой же оси, и на такой же угол
        Rotate(binorm, axis, angle); // повернём бинормаль так же

       // запишем новые повёрнутые значение
       tangent[index[p+c]] = tan;
       binormal[index[p+c]] = binorm;
     }
    }*/

  // корректный способ
  // в предыдущем способе TBN поворачивался, но направления T и B для точек с одними координатами всё равно могли быть с разным направлением, 
  //потому проявлялась "гранёность" при рендере.
  //новый способ аналогичен расчёту сглаженных нормалей за исключением того, что теперь мы суммируем все T и B всех точек, у которых одинаковые текстурные координаты
  // Если даже точки в одном месте, но текстурные координаты отличаются(текстура на меше "разрезана"), то в этих точках тангентспейс не сглаживается, 
  //чтоб видна была грань. (сюда следует добавить ещё проверку на координаты точки, для того, чтоб при разрыве самого меша а не текстуры, у точек с разными коордами будет одинаковые текстурные координаты, и тангентспейс между ними сгладится, хотя не нужно)
   if (smooth)
  {

    int p;

    Vector3f *tan=new Vector3f[i_count]; // временный массив
    Vector3f *bin=new Vector3f[i_count]; // временный массив
    for (p=0; p<i_count; p++)
  {
      tan[p]=tangent[index[p]];
      bin[p]=binormal[index[p]];
  }

    for (int i=0; i<i_count; i++)
  {
      Vector3f vtan;
      Vector3f vbin;

     Vector2f tex = texcoord[index[i]];
      for (p=0; p<i_count; p++)
     {
        if (texcoord[index[p]]==tex)
       {
          vtan+=tan[index[p]]; // прибавляем
          vbin+=bin[index[p]];
       }
      }
      vtan.normalise(); // нормализуем
      vbin.normalise();

      tangent[index[i]]=vtan;
      binormal[index[i]]=vbin;
  }

    delete []tan;
  delete []bin;
  }

  }
}

    ext->glGenBuffers(1, &VBOvertex);                                                                                           //создадим буфер и получим его идентификатор в VBOvertex
    ext->glBindBuffer(GL_ARRAY_BUFFER, VBOvertex );                                                                  //задействуем этот буфер 
    ext->glBufferData(GL_ARRAY_BUFFER, sizeof(Vector3f)*i_count, vertex, GL_STATIC_DRAW);  //наполним его данными из массива
    ext->glBindBuffer(GL_ARRAY_BUFFER,0);                                                                                  // отключим его

    ext->glGenBuffers(1, &VBOtexcoord);
    ext->glBindBuffer(GL_ARRAY_BUFFER, VBOtexcoord );
    ext->glBufferData(GL_ARRAY_BUFFER, sizeof(Vector2f)*i_count, texcoord, GL_STATIC_DRAW);
    ext->glBindBuffer(GL_ARRAY_BUFFER,0); 
  
    ext->glGenBuffers(1, &VBOtangent);
    ext->glBindBuffer(GL_ARRAY_BUFFER, VBOtangent );
    ext->glBufferData(GL_ARRAY_BUFFER, sizeof(Vector3f)*i_count, tangent, GL_STATIC_DRAW);
    ext->glBindBuffer(GL_ARRAY_BUFFER,0);

    ext->glGenBuffers(1, &VBOnormal);
    ext->glBindBuffer(GL_ARRAY_BUFFER, VBOnormal );
    ext->glBufferData(GL_ARRAY_BUFFER, sizeof(Vector3f)*i_count, normal, GL_STATIC_DRAW);
    ext->glBindBuffer(GL_ARRAY_BUFFER,0);

    ext->glGenBuffers(1, &VBObinormal);
    ext->glBindBuffer(GL_ARRAY_BUFFER, VBObinormal );
    ext->glBufferData(GL_ARRAY_BUFFER, sizeof(Vector3f)*i_count, binormal, GL_STATIC_DRAW);
    ext->glBindBuffer(GL_ARRAY_BUFFER,0);

    ext->glGenBuffers(1, &VBOindex);
    ext->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, VBOindex );
    ext->glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(int)*i_count, index, GL_STATIC_DRAW);
    ext->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);

// scene.cam - это структуры сцены и камеры
//CamMatrix - это видовая матрица
  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);          //очистим цветовой буфер
  scene.cam.CalcMatrix();  // тут высчитывается видовая матрица по текущему положению камеры
  
  //получим матрицу видового и проекционного преобразования, чтоб не высчитывать в вершинном шейдере, 
  //а посчитать один раз за проход рендеринга
  Matrix4f ViewProj = scene.cam.CamMatrix * view.ProjectionMatrix;  


  //тут у меняется позиция источника света(задана в мировых координатах)
  scene.lugh+=0.01f;
  scene.lugw+=0.0027f;
  scene.model1.pos.x=float(100*sin(scene.lugh));  //позиция источника света привязана к положению одной из моделек
  scene.model1.pos.z=float(-100*cos(scene.lugh));
  scene.model1.pos.y=float(30+20*sin(scene.lugw));

  //отправим в шейдер нужные данные
  scene.model.CalcTransform();  // тут просчитывается матрица преобразований спмой модели и матрица ОБРАТНЫХ преобразований
 
  //суём в шейдер позицию нашего источника света(так как расчёт освещения происходит в координатах модели, 
  //то все нужные вектора мы переведём в эту систему, перемножив с матрицей обратного преобразования модели, 
  //чтоб он относительно модели был повёрнут также, как если бы мы применили к модели её прямое преобразование, а свет оставили нетронутым 
  shdr.setUniformf("LightPos", scene.model.DeTransformMatrix * scene.model1.pos); 

  //с позицией "глаза" так же, хотя тут можно просто расчитать разницу координат центра модели и источника света, без перемножения на матрицу 
  shdr.setUniformf("EyePos", scene.model.DeTransformMatrix * scene.cam.pos);
  shdr.setUniformMatrix4fv("VievProjTransf", (scene.model.TransformMatrix * ViewProj).M);



  //И собственно сама прорисовка из созданных буферов(без VAO)
  //scene.model.Render();

  //подключим нужные текстуры 
    shader->SetTexture(0,texID,"TextureSampler");
    shader->SetTexture(1,normmapID,"NormalSampler");

    ext->glEnableVertexAttribArray(attr_pos);                    // разрешим использовать в шейдере наш атрибут
    ext->glBindBuffer( GL_ARRAY_BUFFER, VBOvertex );     // скажем в каком буфере лежат эти атрибуты
    //тут по порядку, какой именно атрибут, сколько значений на одну вершину, тип этих значений, не нормализовать, размер атрибута в буфере, 
    //смещение между началами данных каждого атрибута в буфере(с каким шагом в шейдере будут браться атрибуты из буфера) в этом случае ноль
    ext->glVertexAttribPointer(attr_pos, 3, GL_FLOAT, false, sizeof(Vector3f), 0);

    ext->glEnableVertexAttribArray(attr_tcoord);
    ext->glBindBuffer( GL_ARRAY_BUFFER, VBOtexcoord );
    ext->glVertexAttribPointer(attr_tcoord, 2, GL_FLOAT, false, sizeof(Vector2f), 0);

    ext->glEnableVertexAttribArray(attr_tan);
    ext->glBindBuffer( GL_ARRAY_BUFFER, VBOtangent );
    ext->glVertexAttribPointer(attr_tan, 3, GL_FLOAT, false, sizeof(Vector3f), 0);

    ext->glEnableVertexAttribArray(attr_norm);
    ext->glBindBuffer( GL_ARRAY_BUFFER, VBOnormal );
    ext->glVertexAttribPointer(attr_norm, 3, GL_FLOAT, false, sizeof(Vector3f), 0);

    ext->glEnableVertexAttribArray(attr_binorm);
    ext->glBindBuffer( GL_ARRAY_BUFFER, VBObinormal );
    ext->glVertexAttribPointer(attr_binorm, 3, GL_FLOAT, false, sizeof(Vector3f), 0);

    ext->glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, VBOindex);  // забиндим буфер индексов
    glDrawElements(GL_TRIANGLES, i_count, GL_UNSIGNED_INT, NULL); // прорисуем наши буферы по индексному буферу

uniform sampler2D TextureSampler;  //диффузная текстура
uniform sampler2D NormalSampler;//нормалмап

varying vec3 T;
varying vec3 N;
varying vec3 B;
varying vec3 to_light;
varying vec3 to_eye;


void main()
{
  const float am = 0.1;  //коэфициент амбиентного освещения
  const float spc = 1.0;  //бликовость, 0 - нету бликов совсем, 1 - полная бликонутость
  const float intens = 1.0 - am; //коэфициент остального от амбиентного освещения
  vec3 spec_color = vec3(1.0, 1.0, 1.0);  //цвет бликов

  vec3 TexColor = texture2D( TextureSampler, gl_TexCoord[0] .xy ).xyz;
  vec3 TexNormal = normalize((texture2D( NormalSampler, gl_TexCoord[0].xy ).xzy * 2.0) - 1.0);
  vec3 Normal = normalize(normalize(T)*TexNormal.x + normalize(N)*TexNormal.y + normalize(B)*TexNormal.z);  //переведём нормаль из текстурных координат в систему координат модели

  vec3 amb_color = TexColor * am;  //амбиентная составляющая
  vec3 dif_color = TexColor * max (dot (Normal, normalize(to_light)), 0.0) * intens; //диффузная составляющая
  vec3 all = amb_color + dif_color; //всё освещение без бликов

  vec3 vh = normalize(normalize(to_light) + normalize(to_eye));
  vec3 dop = vec3(spec_color - all) * pow (max (dot ( Normal, vh ), 0.0) , 30.0) * spc;  //высчитываем бликовую составляющую

  vec3 result = vec3(all + dop); //суммируем все составляющие

  gl_FragColor = vec4(result , 1);

}