path: root/hacks/glx/glsl-utils.c

/* glsl-utils.c --- support functions for GLSL in OpenGL hacks.
 * Copyright (c) 2020-2021 Carsten Steger <carsten@mirsanmir.org>
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation.  No representations are made about the suitability of this
 * software for any purpose.  It is provided "as is" without express or 
 * implied warranty.
 */

#include "screenhackI.h"
#include "glsl-utils.h"

#include <math.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


#ifdef HAVE_GLSL

extern const char *progname;

/* Copy a 4x4 column-major matrix: c = m. */
void glsl_CopyMatrix(GLfloat c[16], GLfloat m[16])
{
  int i, j;

  for (j=0; j<4; j++)
    for (i=0; i<4; i++)
      c[GLSL__LINCOOR(i,j,4)] = m[GLSL__LINCOOR(i,j,4)];
}


/* Create a 4x4 column-major identity matrix. */
void glsl_Identity(GLfloat c[16])
{
  int i, j;

  for (j=0; j<4; j++)
    for (i=0; i<4; i++)
      c[GLSL__LINCOOR(i,j,4)] = (i==j);
}


/* Multiply two 4x4 column-major matrices: c = c*m. */
void glsl_MultMatrix(GLfloat c[16], GLfloat m[16])
{
  int i, j;
  GLfloat t[16];

  /* Copy c to t. */
  glsl_CopyMatrix(t,c);
  /* Compute c = t*m. */
  for (j=0; j<4; j++)
    for (i=0; i<4; i++)
      c[GLSL__LINCOOR(i,j,4)] =
        (t[GLSL__LINCOOR(i,0,4)]*m[GLSL__LINCOOR(0,j,4)]+
         t[GLSL__LINCOOR(i,1,4)]*m[GLSL__LINCOOR(1,j,4)]+
         t[GLSL__LINCOOR(i,2,4)]*m[GLSL__LINCOOR(2,j,4)]+
         t[GLSL__LINCOOR(i,3,4)]*m[GLSL__LINCOOR(3,j,4)]);
}


/* Multiply a 4x4 column-major matrix by a rotation matrix that rotates
   around the axis (x,y,z) by the angle angle: c = c*r(angle,x,y,z). */
void glsl_Rotate(GLfloat c[16], GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{
  GLfloat l, t, ct, st, omct, n[3], r[16];

  l = sqrtf(x*x+y*y+z*z);
  n[0] = x/l;
  n[1] = y/l;
  n[2] = z/l;
  t = angle*180.0f/M_PI;
  ct = cosf(t);
  st = sinf(t);
  omct = 1.0f-ct;

  r[GLSL__LINCOOR(0,0,4)] = n[0]*n[0]*omct+ct;
  r[GLSL__LINCOOR(1,0,4)] = n[0]*n[1]*omct+n[2]*st;
  r[GLSL__LINCOOR(2,0,4)] = n[0]*n[2]*omct-n[1]*st;
  r[GLSL__LINCOOR(3,0,4)] = 0.0f;

  r[GLSL__LINCOOR(0,1,4)] = n[0]*n[1]*omct-n[2]*st;
  r[GLSL__LINCOOR(1,1,4)] = n[1]*n[1]*omct+ct;
  r[GLSL__LINCOOR(2,1,4)] = n[1]*n[2]*omct+n[0]*st;
  r[GLSL__LINCOOR(3,1,4)] = 0.0f;

  r[GLSL__LINCOOR(0,2,4)] = n[0]*n[2]*omct+n[1]*st;
  r[GLSL__LINCOOR(1,2,4)] = n[1]*n[2]*omct-n[0]*st;
  r[GLSL__LINCOOR(2,2,4)] = n[2]*n[2]*omct+ct;
  r[GLSL__LINCOOR(3,2,4)] = 0.0f;

  r[GLSL__LINCOOR(0,3,4)] = 0.0f;
  r[GLSL__LINCOOR(1,3,4)] = 0.0f;
  r[GLSL__LINCOOR(2,3,4)] = 0.0f;
  r[GLSL__LINCOOR(3,3,4)] = 1.0f;

  glsl_MultMatrix(c,r);
}


/* Multiply a 4x4 column-major matrix by a matrix that stretches, shrinks,
   or reflects an object along the axes: c = c*m(sx,sy,sz). */
void glsl_Scale(GLfloat c[16], GLfloat sx, GLfloat sy, GLfloat sz)
{
  int i;

  for (i=0; i<4; i++)
  {
    c[GLSL__LINCOOR(i,0,4)] *= sx;
    c[GLSL__LINCOOR(i,1,4)] *= sy;
    c[GLSL__LINCOOR(i,2,4)] *= sz;
  }
}


/* Multiply a 4x4 column-major matrix by a matrix that translates an object
   by a translation vector: c = c*t(tx,ty,tz). */
void glsl_Translate(GLfloat c[16], GLfloat tx, GLfloat ty, GLfloat tz)
{
  int i;

  for (i=0; i<4; i++)
  {
    c[GLSL__LINCOOR(i,3,4)] = (tx*c[GLSL__LINCOOR(i,0,4)]+
                               ty*c[GLSL__LINCOOR(i,1,4)]+
                               tz*c[GLSL__LINCOOR(i,2,4)]+
                               c[GLSL__LINCOOR(i,3,4)]);
  }
}


/* Add a perspective projection to a 4x4 column-major matrix. */
void glsl_Perspective(GLfloat c[16], GLfloat fovy, GLfloat aspect,
                      GLfloat z_near, GLfloat z_far)
{
  GLfloat m[16];
  double s, cot, dz;
  double rad;

  rad = fovy*(0.5f*(float)M_PI/180.0f);
  dz = z_far-z_near;
  s = sinf(rad);
  if (dz == 0.0f || s == 0.0f || aspect == 0.0f)
    return;
  cot = cosf(rad)/s;

  glsl_Identity(m);
  m[GLSL__LINCOOR(0,0,4)] = cot/aspect;
  m[GLSL__LINCOOR(1,1,4)] = cot;
  m[GLSL__LINCOOR(2,2,4)] = -(z_far+z_near)/dz;
  m[GLSL__LINCOOR(3,2,4)] = -1.0f;
  m[GLSL__LINCOOR(2,3,4)] = -2.0f*z_near*z_far/dz;
  m[GLSL__LINCOOR(3,3,4)] = 0.0f;
  glsl_MultMatrix(c,m);
}


/* Add an orthographic projection to a 4x4 column-major matrix. */
void glsl_Orthographic(GLfloat c[16], GLfloat left, GLfloat right,
                       GLfloat bottom, GLfloat top,
                       GLfloat nearval, GLfloat farval)
{
  GLfloat m[16];

  if (left == right || bottom == top || nearval == farval)
    return;

  glsl_Identity(m);
  m[GLSL__LINCOOR(0,0,4)] = 2.0f/(right-left);
  m[GLSL__LINCOOR(0,3,4)] = -(right+left)/(right-left);
  m[GLSL__LINCOOR(1,1,4)] = 2.0f/(top-bottom);
  m[GLSL__LINCOOR(1,3,4)] = -(top+bottom)/(top-bottom);
  m[GLSL__LINCOOR(2,2,4)] = -2.0f/(farval-nearval);
  m[GLSL__LINCOOR(2,3,4)] = -(farval+nearval)/(farval-nearval);
  glsl_MultMatrix(c,m);
}


/* Get the OpenGL and GLSL versions. */
GLboolean glsl_GetGlAndGlslVersions(GLint *gl_major, GLint *gl_minor,
                                    GLint *glsl_major, GLint *glsl_minor,
                                    GLboolean *gl_gles3)
{
  const char *gl_version, *glsl_version;
  int n;
  const char *err = 0;

  *gl_major = -1;
  *gl_minor = -1;
  *glsl_major = 1;
  *glsl_minor = -1;
  *gl_gles3 = GL_FALSE;
  gl_version = (const char *)glGetString(GL_VERSION);
  glsl_version = (const char *)glGetString(GL_SHADING_LANGUAGE_VERSION);
  if (gl_version == NULL || glsl_version == NULL)
    {
      err = "GL version unknown";
      goto DONE;
    }
  if (!strncmp(gl_version,"OpenGL ES",9))
  {
    if (!strncmp(glsl_version,"OpenGL ES GLSL ES",17))
      *gl_gles3 = GL_TRUE;
    else
      {
        err = "GLSL not supported";
        goto DONE;
      }
  }
  if (*gl_gles3)
    n = sscanf(&gl_version[9],"%d.%d",gl_major,gl_minor);
  else
    n = sscanf(gl_version,"%d.%d",gl_major,gl_minor);
  if (n != 2)
    {
      err = "GL version number unparsable";
      goto DONE;
    }
  if (*gl_gles3)
    n = sscanf(&glsl_version[17],"%d.%d",glsl_major,glsl_minor);
  else
    n = sscanf(glsl_version,"%d.%d",glsl_major,glsl_minor);
  if (n != 2)
    {
      err = "GLSL version number unparsable";
      goto DONE;
    }

 DONE:

#if 0/*# ifndef __OPTIMIZE__*/
  if (err)
    fprintf (stderr, "%s: GLSL: %s\n", progname, err);
  else
    fprintf (stderr, "%s: GLSL available: GL=%d.%d, GLSL=%d.%d GLES3=%d\n",
             progname,
             *gl_major, *gl_minor, 
             *glsl_major, *glsl_minor,
             *gl_gles3 ? 1 : 0);
# endif

  return (err ? GL_FALSE : GL_TRUE);
}


#define PRINT_ERRORS
/* #undef PRINT_ERRORS */

#ifdef PRINT_ERRORS

#define PRINT_COMPILE_ERROR(shader) print_compile_error(shader)
#define PRINT_LINK_ERROR(program) print_link_error(program)

static void print_compile_error(GLuint shader)
{
  GLint length_log;
  GLsizei length;
  GLchar *log;

  glGetShaderiv(shader,GL_INFO_LOG_LENGTH,&length_log);
  if (length_log > 0)
  {
    log = malloc(length_log*sizeof(*log));
    if (log != NULL)
    {
      glGetShaderInfoLog(shader,length_log,&length,log);
      fprintf(stderr,"%s: %s",progname,log);
    }
    free(log);
  }
}


static void print_link_error(GLuint program)
{
  GLint length_log;
  GLsizei length;
  GLchar *log;

  glGetProgramiv(program,GL_INFO_LOG_LENGTH,&length_log);
  if (length_log > 0)
  {
    log = malloc(length_log*sizeof(*log));
    if (log != NULL)
    {
      glGetProgramInfoLog(program,length_log,&length,log);
      fprintf(stderr,"%s: %s",progname,log);
    }
    free(log);
  }
}

#else

#define PRINT_COMPILE_ERROR(shader)
#define PRINT_LINK_ERROR(program)

#endif


/* Compile and link a vertex and a Fragment shader into a GLSL program. */
GLboolean glsl_CompileAndLinkShaders(GLsizei vertex_shader_count,
                                     const GLchar **vertex_shader_source,
                                     GLsizei fragment_shader_count,
                                     const GLchar **fragment_shader_source,
                                     GLuint *shader_program)
{
  GLuint vertex_shader, fragment_shader;
  GLint status;
  const char *err = 0;

  /* Create and compile the vertex shader. */
  vertex_shader = glCreateShader(GL_VERTEX_SHADER);
  if (vertex_shader == 0)
    return GL_FALSE;
  fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
  if (fragment_shader == 0)
  {
    glDeleteShader(vertex_shader);
    err = "unable to create fragment shader";
    goto DONE;
  }
  glShaderSource(vertex_shader,vertex_shader_count,vertex_shader_source,
                 NULL);
  glShaderSource(fragment_shader,fragment_shader_count,fragment_shader_source,
                 NULL);
  glCompileShader(vertex_shader);
  glGetShaderiv(vertex_shader,GL_COMPILE_STATUS,&status);
  if (status == GL_FALSE)
  {
    PRINT_COMPILE_ERROR(vertex_shader);
    glDeleteShader(vertex_shader);
    glDeleteShader(fragment_shader);
    err = "vertex shader compilation failed";
    goto DONE;
  }
  glCompileShader(fragment_shader);
  glGetShaderiv(fragment_shader,GL_COMPILE_STATUS,&status);
  if (status == GL_FALSE)
  {
    PRINT_COMPILE_ERROR(fragment_shader);
    glDeleteShader(vertex_shader);
    glDeleteShader(fragment_shader);
    err = "fragment shader compilation failed";
    goto DONE;
  }
  *shader_program = glCreateProgram();
  if (*shader_program == 0)
  {
    glDeleteShader(vertex_shader);
    glDeleteShader(fragment_shader);
    err = "shader creation failed";
    goto DONE;
  }
  glAttachShader(*shader_program,vertex_shader);
  glAttachShader(*shader_program,fragment_shader);
  glLinkProgram(*shader_program);
  glGetProgramiv(*shader_program,GL_LINK_STATUS,&status);
  if (status == GL_FALSE)
  {
    PRINT_LINK_ERROR(*shader_program);
    glDeleteProgram(*shader_program);
    glDeleteShader(vertex_shader);
    glDeleteShader(fragment_shader);
    err = "shader attachment failed";
    goto DONE;
  }
  /* Once the shader program has compiled successfully, we can delete the
     vertex and fragment shaders. */
  glDeleteShader(vertex_shader);
  glDeleteShader(fragment_shader);

 DONE:
  if (err)
    fprintf (stderr, "%s: GLSL: %s\n", progname, err);
#if 0/*# ifndef __OPTIMIZE__*/
  else
    fprintf (stderr, "%s: GLSL: shaders initialized\n", progname);
# endif

  return (err ? GL_FALSE : GL_TRUE);
}


#endif /* HAVE_GLSL */