From 9659f35509ed98cf6888510ea0c3fcf0e3017f56 Mon Sep 17 00:00:00 2001
From: Matt Larsen <mlarsen@cs.uoregon.edu>
Date: Tue, 2 Aug 2016 09:56:26 -0700
Subject: [PATCH] my changes

---
 vtkm/rendering/MapperGL.h                     | 364 +++++++++++++++++-
 vtkm/rendering/internal/OpenGLHeaders.h       |   3 +
 vtkm/rendering/testing/CMakeLists.txt         |   3 +-
 vtkm/rendering/testing/UnitTestMapperGLFW.cxx |   4 +
 4 files changed, 360 insertions(+), 14 deletions(-)

diff --git a/vtkm/rendering/MapperGL.h b/vtkm/rendering/MapperGL.h
index bea0c2bf9..e9d6589d0 100644
--- a/vtkm/rendering/MapperGL.h
+++ b/vtkm/rendering/MapperGL.h
@@ -33,6 +33,8 @@
 #include <iostream>
 #include <fstream>
 
+using namespace std;
+
 
 namespace vtkm {
 namespace rendering {
@@ -92,7 +94,108 @@ public:
     glFinish();
     glFlush();
   }
-
+const char* GL_type_to_string (GLenum type) 
+{
+  switch (type) {
+    case GL_BOOL: return "bool";
+    case GL_INT: return "int";
+    case GL_FLOAT: return "float";
+    case GL_FLOAT_VEC2: return "vec2";
+    case GL_FLOAT_VEC3: return "vec3";
+    case GL_FLOAT_VEC4: return "vec4";
+    case GL_FLOAT_MAT2: return "mat2";
+    case GL_FLOAT_MAT3: return "mat3";
+    case GL_FLOAT_MAT4: return "mat4";
+    case GL_SAMPLER_2D: return "sampler2D";
+    case GL_SAMPLER_3D: return "sampler3D";
+    case GL_SAMPLER_CUBE: return "samplerCube";
+    case GL_SAMPLER_2D_SHADOW: return "sampler2DShadow";
+    default: break;
+  }
+  return "other";
+}
+void _print_programme_info_log (GLuint programme) {
+  int max_length = 2048;
+  int actual_length = 0;
+  char log[2048];
+  glGetProgramInfoLog (programme, max_length, &actual_length, log);
+  printf ("program info log for GL index %u:\n%s", programme, log);
+}
+void print_all (GLuint programme) {
+  printf ("--------------------\nshader programme %i info:\n", programme);
+  int params = -1;
+  glGetProgramiv (programme, GL_LINK_STATUS, &params);
+  printf ("GL_LINK_STATUS = %i\n", params);
+  
+  glGetProgramiv (programme, GL_ATTACHED_SHADERS, &params);
+  printf ("GL_ATTACHED_SHADERS = %i\n", params);
+  
+  glGetProgramiv (programme, GL_ACTIVE_ATTRIBUTES, &params);
+  printf ("GL_ACTIVE_ATTRIBUTES = %i\n", params);
+  for (int i = 0; i < params; i++) {
+    char name[64];
+    int max_length = 64;
+    int actual_length = 0;
+    int size = 0;
+    GLenum type;
+    glGetActiveAttrib (
+      programme,
+      i,
+      max_length,
+      &actual_length,
+      &size,
+      &type,
+      name
+    );
+    if (size > 1) {
+      for (int j = 0; j < size; j++) {
+        char long_name[64];
+        sprintf (long_name, "%s[%i]", name, j);
+        int location = glGetAttribLocation (programme, long_name);
+        printf ("  %i) type:%s name:%s location:%i\n",
+          i, GL_type_to_string (type), long_name, location);
+      }
+    } else {
+      int location = glGetAttribLocation (programme, name);
+      printf ("  %i) type:%s name:%s location:%i\n",
+        i, GL_type_to_string (type), name, location);
+    }
+  }
+  
+  glGetProgramiv (programme, GL_ACTIVE_UNIFORMS, &params);
+  printf ("GL_ACTIVE_UNIFORMS = %i\n", params);
+  for (int i = 0; i < params; i++) {
+    char name[64];
+    int max_length = 64;
+    int actual_length = 0;
+    int size = 0;
+    GLenum type;
+    glGetActiveUniform (
+      programme,
+      i,
+      max_length,
+      &actual_length,
+      &size,
+      &type,
+      name
+    );
+    if (size > 1) {
+      for (int j = 0; j < size; j++) {
+        char long_name[64];
+        sprintf (long_name, "%s[%i]", name, j);
+        int location = glGetUniformLocation (programme, long_name);
+        printf ("  %i) type:%s name:%s location:%i\n",
+          i, GL_type_to_string (type), long_name, location);
+      }
+    } else {
+      int location = glGetUniformLocation (programme, name);
+      printf ("  %i) type:%s name:%s location:%i\n",
+        i, GL_type_to_string (type), name, location);
+    }
+  }
+  
+  _print_programme_info_log (programme);
+}
   template <typename PtType>
   VTKM_CONT_EXPORT
   void RenderTriangles(vtkm::Id numTri, const PtType &verts,
@@ -101,11 +204,14 @@ public:
                        const vtkm::rendering::ColorTable &ct,
                        const vtkm::Range &scalarRange)
   {
+    glewExperimental = GL_TRUE; 
+    glewInit();
     vtkm::Float32 sMin = vtkm::Float32(scalarRange.Min);
     vtkm::Float32 sMax = vtkm::Float32(scalarRange.Max);
     vtkm::Float32 sDiff = sMax-sMin;
 
-    glBegin(GL_TRIANGLES);
+    vector<float> data, colors;
+    int method = 2;
     for (int i = 0; i < numTri; i++)
     {
       vtkm::Vec<vtkm::Id, 4> idx = indices.GetPortalConstControl().Get(i);
@@ -117,29 +223,261 @@ public:
       vtkm::Vec<vtkm::Float32, 3> p2 = verts.GetPortalConstControl().Get(idx[2]);
       vtkm::Vec<vtkm::Float32, 3> p3 = verts.GetPortalConstControl().Get(idx[3]);
 
-      vtkm::Float32 s = scalar.GetPortalConstControl().Get(i1);
+      vtkm::Float32 s;
+      Color color;
+      
+      s = scalar.GetPortalConstControl().Get(i1);
       s = (s-sMin)/sDiff;
-
-      Color color = ct.MapRGB(s);
-      glColor3f(color.Components[0], color.Components[1], color.Components[2]);
-      glVertex3f(p1[0],p1[1],p1[2]);
+      color = ct.MapRGB(s);
+      data.push_back(p1[0]);
+      data.push_back(p1[1]);
+      data.push_back(p1[2]);
+      if (method==0)
+      {
+          data.push_back(color.Components[0]);
+          data.push_back(color.Components[1]);
+          data.push_back(color.Components[2]);
+      }
+      else if (method == 2)
+      {
+          colors.push_back(color.Components[0]);
+          colors.push_back(color.Components[1]);
+          colors.push_back(color.Components[2]);
+      }
 
       s = scalar.GetPortalConstControl().Get(i2);
       s = (s-sMin)/sDiff;
       color = ct.MapRGB(s);
-      glColor3f(color.Components[0], color.Components[1], color.Components[2]);
-      glVertex3f(p2[0],p2[1],p2[2]);
+      data.push_back(p2[0]);
+      data.push_back(p2[1]);
+      data.push_back(p2[2]);
+      if (method==0)      
+      {
+          data.push_back(color.Components[0]);
+          data.push_back(color.Components[1]);
+          data.push_back(color.Components[2]);
+      }
+      else if (method == 2)
+      {
+          colors.push_back(color.Components[0]);
+          colors.push_back(color.Components[1]);
+          colors.push_back(color.Components[2]);
+      }          
 
       s = scalar.GetPortalConstControl().Get(i3);
       s = (s-sMin)/sDiff;
       color = ct.MapRGB(s);
-      glColor3f(color.Components[0], color.Components[1], color.Components[2]);
-      glVertex3f(p3[0],p3[1],p3[2]);
+      data.push_back(p3[0]);
+      data.push_back(p3[1]);
+      data.push_back(p3[2]);
+      if (method==0)
+      {
+          data.push_back(color.Components[0]);
+          data.push_back(color.Components[1]);
+          data.push_back(color.Components[2]);
+      }
+      else if (method == 2)
+      {
+          colors.push_back(color.Components[0]);
+          colors.push_back(color.Components[1]);
+          colors.push_back(color.Components[2]);
+      }          
     }
-    glEnd();
+    cout<<"data.size()= "<<data.size()<<endl;
+
+    if (method == 0)
+    {
+        glBegin(GL_TRIANGLES);
+        for (int i = 0; i < data.size(); i+=6)
+        {
+            glColor3f(data[i+3], data[i+4], data[i+5]);
+            glVertex3f(data[i+0], data[i+1], data[i+2]);
+        }
+        glEnd();
+    }
+    else if (method == 1)
+    {   
+
+        cout<<"Enter method 1\n";
+        GLuint vbo = 0;
+        glGenBuffers(1, &vbo);
+        glBindBuffer(GL_ARRAY_BUFFER, vbo);
+        glBufferData(GL_ARRAY_BUFFER, data.size()*sizeof (float), &data[0], GL_STATIC_DRAW);
+        cout<<"Bind buffer\n";
+        GLuint vao = 0;
+        glGenVertexArrays(1, &vao);
+        cout<<"Bind buffer1\n";
+        glBindVertexArray(vao);
+        cout<<"Bind buffer 1.5\n";
+        glEnableVertexAttribArray(0);
+        cout<<"Bind buffer 2\n";
+        glBindBuffer(GL_ARRAY_BUFFER, vbo);
+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
+        cout<<"Vertex pointer \n";
+        GLfloat mvMat[16], pMat[16];
+        glGetFloatv(GL_MODELVIEW_MATRIX, (float*)mvMat);
+        glGetFloatv(GL_PROJECTION_MATRIX, (float*)pMat);
+        
+        const char* vertex_shader =
+            "#version 400\n"
+            "uniform mat4 mv_matrix;"
+            "uniform mat4 p_matrix;"
+            "in vec4 a_vertex;"
+            "uniform mat4 mvp;"
+            "void main() {"
+//            "  gl_Position = p_matrix * mv_matrix * gl_Vertex;"
+//           "  gl_Position = p_matrix * mv_matrix * vec4(a_vertex, 1);" //vec4(position, 1);"            
+            "  gl_Position = gl_Vertex;" //gl_ProjectionMatrix * gl_ModelViewMatrix * gl_Vertex;"
+            "}\0";
+
+        const char* fragment_shader =
+            "#version 400\n"
+            "out vec4 frag_colour;"
+            "void main () {"
+            "  frag_colour = vec4 (0.5, 0.0, 0.5, 1.0);"
+            "}\0";
+        cout<<"Compiling \n";
+        GLuint vs = glCreateShader(GL_VERTEX_SHADER);
+        glShaderSource(vs, 1, &vertex_shader, NULL);
+        glCompileShader(vs);
+        GLint isCompiled = 0;
+        glGetShaderiv(vs, GL_COMPILE_STATUS, &isCompiled);
+        if(isCompiled == GL_FALSE)
+        {
+          GLint maxLength = 0;
+          glGetShaderiv(vs, GL_INFO_LOG_LENGTH, &maxLength);
+
+          // The maxLength includes the NULL character
+          GLchar* strInfoLog = new GLchar[maxLength + 1];
+          glGetShaderInfoLog(vs, maxLength, &maxLength, strInfoLog);
+          fprintf(stderr, "Compilation error in shader : %s\n", strInfoLog);
+          delete[] strInfoLog;
+        }
+
+        GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
+        glShaderSource(fs, 1, &fragment_shader, NULL);
+        glCompileShader(fs);
+        GLuint shader_programme = glCreateProgram();
+        GLint mvID = glGetUniformLocation(shader_programme, "mv_matrix");
+        glUniformMatrix4fv(mvID, 1, GL_FALSE, mvMat);
+        GLint pID = glGetUniformLocation(shader_programme, "p_matrix");
+        glUniformMatrix4fv(pID, 1, GL_FALSE, pMat);        
+        cout<<"Shaders Compiled\n";
+        glAttachShader(shader_programme, fs);
+        glAttachShader(shader_programme, vs);
+        glLinkProgram(shader_programme);
+        GLint success;
+        glGetProgramiv(shader_programme, GL_LINK_STATUS, &success);
+        if (!success)
+        {
+          cout<<"**********************************************LINK FAILED"<<endl;
+        } 
+
+        char log[2048];
+        GLsizei len;
+        glGetProgramInfoLog(shader_programme, 2048, &len, log);
+        cout<<"program info: "<<log<<endl;        
+        
+        glUseProgram(shader_programme);
+        print_all(shader_programme);
+        glBindVertexArray(vao);
+        glDrawArrays (GL_TRIANGLES, 0, numTri*3);
+        glUseProgram(0);
+    }
+    else if (method == 2)
+    {
+        for (int i = 0; i < data.size(); i+= 3)
+            cout<<i%3<<": ("<<data[i]<<","<<data[i+1]<<","<<data[i+2]<<") ["<<colors[i]<<","<<colors[i+1]<<","<<colors[i+2]<<"]"<<endl;
+        GLuint points_vbo = 0;
+        glGenBuffers(1, &points_vbo);
+        glBindBuffer(GL_ARRAY_BUFFER, points_vbo);
+        glBufferData(GL_ARRAY_BUFFER, data.size()*sizeof (float), &data[0], GL_STATIC_DRAW);        
+
+        GLuint colours_vbo = 0;
+        glGenBuffers(1, &colours_vbo);
+        glBindBuffer(GL_ARRAY_BUFFER, colours_vbo);
+        glBufferData(GL_ARRAY_BUFFER, colors.size()*sizeof(float), &colors[0], GL_STATIC_DRAW);
+
+        GLuint vao = 0;
+        glGenVertexArrays(1, &vao);
+        glBindVertexArray(vao);
+        glBindBuffer(GL_ARRAY_BUFFER, points_vbo);
+        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
+        glBindBuffer(GL_ARRAY_BUFFER, colours_vbo);
+        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL);
+
+        glEnableVertexAttribArray(0);
+        glEnableVertexAttribArray(1);
+
+        GLfloat mvMat[16], pMat[16];
+        glGetFloatv(GL_MODELVIEW_MATRIX, (float*)mvMat);
+        glGetFloatv(GL_PROJECTION_MATRIX, (float*)pMat);
+        for(int i = 0; i < 16;++i) 
+          {
+            if(i % 4 == 0 && i != 0) cout<<"\n";
+            cout<<mvMat[i]<<" ";
+          }
+          cout<<"\n";
+        const char *vertex_shader =
+            "#version 400 core\n"
+            "layout(location = 1) in vec3 vertex_position;"
+            "layout(location = 0) in vec3 vertex_color;"
+            "out vec3 ourColor;"
+            "uniform mat4 mv_matrix;"
+            "uniform mat4 p_matrix;"        
+        
+            "void main() {"
+           "  gl_Position = p_matrix*mv_matrix * vec4(vertex_position, 1.0);"
+ //           "  gl_Position = vec4(vertex_color, 1.0);"
+ //           "  gl_Position = vec4(vertex_position, 1.0);"
+            "  ourColor = vertex_color;"
+            "}";
+        const char *fragment_shader =
+            "#version 400 core\n"
+            "in vec3 ourColor;"
+            "out vec4 color;"
+            "void main() {"
+//           "  color = vec4 (0.5, 0.0, 0.5, 1.0);"
+             "  color = vec4 (ourColor, 1.0);"
+            "}";
+
+        GLuint vs = glCreateShader(GL_VERTEX_SHADER);
+        glShaderSource(vs, 1, &vertex_shader, NULL);
+        glCompileShader(vs);
+        GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
+        glShaderSource(fs, 1, &fragment_shader, NULL);
+        glCompileShader(fs);        
+        GLuint shader_programme = glCreateProgram();
+                      
+        
+        glAttachShader(shader_programme, fs);
+        glAttachShader(shader_programme, vs);
+        
+        // insert location binding code here
+        glBindAttribLocation (shader_programme, 0, "vertex_position");
+        glBindAttribLocation (shader_programme, 1, "vertex_color");
+        glLinkProgram (shader_programme);
+        GLint success;
+        glGetProgramiv(shader_programme, GL_LINK_STATUS, &success);
+        if (!success) cout<<"**********************************************LINK FAILED"<<endl;
+        char log[2048];
+        GLsizei len;
+        glGetProgramInfoLog(shader_programme, 2048, &len, log);
+        cout<<"program info: "<<log<<endl;
+        
+        glUseProgram(shader_programme);
+        GLint mvID = glGetUniformLocation(shader_programme, "mv_matrix");
+        glUniformMatrix4fv(mvID, 1, GL_FALSE, mvMat);
+        GLint pID = glGetUniformLocation(shader_programme, "p_matrix");
+        glUniformMatrix4fv(pID, 1, GL_FALSE, pMat);  
+        print_all(shader_programme);
+        glBindVertexArray(vao);
+        glDrawArrays (GL_TRIANGLES, 0, numTri*3);
+        glUseProgram(0);
+    }    
   }
 };
 
 }} //namespace vtkm::rendering
 
-#endif //vtk_m_rendering_MapperGL_h
+#endif //vtk_m_rendering_MapperGL_h
\ No newline at end of file
diff --git a/vtkm/rendering/internal/OpenGLHeaders.h b/vtkm/rendering/internal/OpenGLHeaders.h
index 0b648b96c..05dc0572d 100644
--- a/vtkm/rendering/internal/OpenGLHeaders.h
+++ b/vtkm/rendering/internal/OpenGLHeaders.h
@@ -22,8 +22,11 @@
 #define vtk_m_rendering_internal_OpenGLHeaders_h
 
 #if defined(__APPLE__)
+#include <GL/glew.h>
 # include <OpenGL/gl.h>
+
 #else
+#include <GL/glew.h>
 # include <GL/gl.h>
 #endif
 
diff --git a/vtkm/rendering/testing/CMakeLists.txt b/vtkm/rendering/testing/CMakeLists.txt
index 0cfb7dc06..f84c6e962 100644
--- a/vtkm/rendering/testing/CMakeLists.txt
+++ b/vtkm/rendering/testing/CMakeLists.txt
@@ -36,7 +36,8 @@ if (OPENGL_FOUND)
       )
     list(APPEND libs ${EGL_LIBRARIES})    
   endif()
-  
+  #apple needs thes linker flags
+  #-framework Cocoa -framework OpenGL -framework IOKit -framework CoreVideo
   if (GLFW_FOUND)
     set(unit_tests ${unit_tests}
       UnitTestMapperGLFW.cxx
diff --git a/vtkm/rendering/testing/UnitTestMapperGLFW.cxx b/vtkm/rendering/testing/UnitTestMapperGLFW.cxx
index a82472d8b..acf1066da 100644
--- a/vtkm/rendering/testing/UnitTestMapperGLFW.cxx
+++ b/vtkm/rendering/testing/UnitTestMapperGLFW.cxx
@@ -58,6 +58,10 @@ void RenderTests()
     vtkm::rendering::ColorTable colorTable("thermal");
     
     glfwInit();
+    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
     GLFWwindow *window = glfwCreateWindow(WIDTH, HEIGHT, "GLFW Test", NULL, NULL);
     glfwMakeContextCurrent(window);
     glfwSetKeyCallback(window, keyCallback);