mirror of
https://gitlab.kitware.com/vtk/vtk-m
synced 2024-09-19 18:45:43 +00:00
520 lines
19 KiB
C++
520 lines
19 KiB
C++
//============================================================================
|
|
// Copyright (c) Kitware, Inc.
|
|
// All rights reserved.
|
|
// See LICENSE.txt for details.
|
|
// This software is distributed WITHOUT ANY WARRANTY; without even
|
|
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
// PURPOSE. See the above copyright notice for more information.
|
|
//
|
|
// Copyright 2015 Sandia Corporation.
|
|
// Copyright 2015 UT-Battelle, LLC.
|
|
// Copyright 2015 Los Alamos National Security.
|
|
//
|
|
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
|
|
// the U.S. Government retains certain rights in this software.
|
|
//
|
|
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
|
|
// Laboratory (LANL), the U.S. Government retains certain rights in
|
|
// this software.
|
|
//============================================================================
|
|
#ifndef vtk_m_rendering_MapperGL_h
|
|
#define vtk_m_rendering_MapperGL_h
|
|
|
|
#include <vtkm/cont/DataSet.h>
|
|
#include <vtkm/cont/CoordinateSystem.h>
|
|
#include <vtkm/cont/DynamicArrayHandle.h>
|
|
#include <vtkm/rendering/Camera.h>
|
|
#include <vtkm/rendering/ColorTable.h>
|
|
#include <vtkm/rendering/Mapper.h>
|
|
#include <vtkm/rendering/Triangulator.h>
|
|
#include <vtkm/rendering/internal/OpenGLHeaders.h>
|
|
|
|
#include <stdio.h>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
|
|
using namespace std;
|
|
|
|
|
|
namespace vtkm {
|
|
namespace rendering {
|
|
|
|
template<typename DeviceAdapter = VTKM_DEFAULT_DEVICE_ADAPTER_TAG>
|
|
class MapperGL : public Mapper
|
|
{
|
|
public:
|
|
VTKM_CONT_EXPORT
|
|
MapperGL() {}
|
|
|
|
VTKM_CONT_EXPORT
|
|
virtual void RenderCells(const vtkm::cont::DynamicCellSet &cellset,
|
|
const vtkm::cont::CoordinateSystem &coords,
|
|
const vtkm::cont::Field &scalarField,
|
|
const vtkm::rendering::ColorTable &colorTable,
|
|
const vtkm::rendering::Camera &camera,
|
|
const vtkm::Range &scalarRange)
|
|
{
|
|
vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Id, 4> > indices;
|
|
vtkm::Id numTri;
|
|
Triangulator<DeviceAdapter> triangulator;
|
|
triangulator.run(cellset, indices, numTri);
|
|
|
|
vtkm::cont::ArrayHandle<vtkm::Float32> sf;
|
|
sf = scalarField.GetData().Cast<vtkm::cont::ArrayHandle<vtkm::Float32> >();
|
|
|
|
vtkm::cont::DynamicArrayHandleCoordinateSystem dcoords = coords.GetData();
|
|
vtkm::cont::ArrayHandleUniformPointCoordinates uVerts;
|
|
vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32,3> > eVerts;
|
|
|
|
if(dcoords.IsSameType(vtkm::cont::ArrayHandleUniformPointCoordinates()))
|
|
{
|
|
uVerts = dcoords.Cast<vtkm::cont::ArrayHandleUniformPointCoordinates>();
|
|
RenderTriangles(numTri, uVerts, indices, sf, colorTable, scalarRange, camera);
|
|
}
|
|
else if(dcoords.IsSameType(vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32,3> >()))
|
|
{
|
|
eVerts = dcoords.Cast<vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Float32,3> > > ();
|
|
RenderTriangles(numTri, eVerts, indices, sf, colorTable, scalarRange, camera);
|
|
}
|
|
else if(dcoords.IsSameType(vtkm::cont::ArrayHandleCartesianProduct<
|
|
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
|
|
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
|
|
vtkm::cont::ArrayHandle<vtkm::FloatDefault> >()))
|
|
{
|
|
vtkm::cont::ArrayHandleCartesianProduct<
|
|
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
|
|
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
|
|
vtkm::cont::ArrayHandle<vtkm::FloatDefault> > rVerts;
|
|
rVerts = dcoords.Cast<vtkm::cont::ArrayHandleCartesianProduct<
|
|
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
|
|
vtkm::cont::ArrayHandle<vtkm::FloatDefault>,
|
|
vtkm::cont::ArrayHandle<vtkm::FloatDefault> > > ();
|
|
RenderTriangles(numTri, rVerts, indices, sf, colorTable, scalarRange, camera);
|
|
}
|
|
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, ¶ms);
|
|
printf ("GL_LINK_STATUS = %i\n", params);
|
|
|
|
glGetProgramiv (programme, GL_ATTACHED_SHADERS, ¶ms);
|
|
printf ("GL_ATTACHED_SHADERS = %i\n", params);
|
|
|
|
glGetProgramiv (programme, GL_ACTIVE_ATTRIBUTES, ¶ms);
|
|
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, ¶ms);
|
|
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,
|
|
const vtkm::cont::ArrayHandle< vtkm::Vec<vtkm::Id, 4> > &indices,
|
|
const vtkm::cont::ArrayHandle<vtkm::Float32> &scalar,
|
|
const vtkm::rendering::ColorTable &ct,
|
|
const vtkm::Range &scalarRange,
|
|
const vtkm::rendering::Camera &camera)
|
|
{
|
|
glewExperimental = GL_TRUE;
|
|
glewInit();
|
|
vtkm::Float32 sMin = vtkm::Float32(scalarRange.Min);
|
|
vtkm::Float32 sMax = vtkm::Float32(scalarRange.Max);
|
|
vtkm::Float32 sDiff = sMax-sMin;
|
|
|
|
vector<float> data, colors;
|
|
int method = 2;
|
|
for (int i = 0; i < numTri; i++)
|
|
{
|
|
vtkm::Vec<vtkm::Id, 4> idx = indices.GetPortalConstControl().Get(i);
|
|
vtkm::Id i1 = idx[1];
|
|
vtkm::Id i2 = idx[2];
|
|
vtkm::Id i3 = idx[3];
|
|
|
|
vtkm::Vec<vtkm::Float32, 3> p1 = verts.GetPortalConstControl().Get(idx[1]);
|
|
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;
|
|
Color color;
|
|
|
|
s = scalar.GetPortalConstControl().Get(i1);
|
|
s = (s-sMin)/sDiff;
|
|
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);
|
|
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);
|
|
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]);
|
|
}
|
|
}
|
|
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];
|
|
bool validV=1, validP=1;
|
|
vtkm::Matrix<vtkm::Float32,4,4> viewM = camera.CreateViewMatrix();
|
|
//vtkm::Matrix<vtkm::Float32,4,4> viewM = vtkm::MatrixInverse(camera.CreateViewMatrix(), validV);
|
|
vtkm::Matrix<vtkm::Float32,4,4> projM = camera.CreateProjectionMatrix(512,512);
|
|
//vtkm::Matrix<vtkm::Float32,4,4> projM = vtkm::MatrixInverse(camera.CreateProjectionMatrix(512,512), validP);
|
|
cout<<"Valid Inverse: "<<validV<<" "<<validP<<endl;
|
|
|
|
MatrixHelpers::CreateOGLMatrix(viewM, mvMat);
|
|
MatrixHelpers::CreateOGLMatrix(projM, pMat);
|
|
//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);
|
|
GLint isCompiled = 0;
|
|
cout<<"hi there"<<endl;
|
|
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, "VS: Compilation error in shader : %s\n", strInfoLog);
|
|
delete[] strInfoLog;
|
|
}
|
|
|
|
GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
|
|
glShaderSource(fs, 1, &fragment_shader, NULL);
|
|
glCompileShader(fs);
|
|
if(isCompiled == GL_FALSE)
|
|
{
|
|
GLint maxLength = 0;
|
|
glGetShaderiv(fs, GL_INFO_LOG_LENGTH, &maxLength);
|
|
|
|
// The maxLength includes the NULL character
|
|
GLchar* strInfoLog = new GLchar[maxLength + 1];
|
|
glGetShaderInfoLog(vs, maxLength, &maxLength, strInfoLog);
|
|
fprintf(stderr, "FS: Compilation error in shader : %s\n", strInfoLog);
|
|
delete[] strInfoLog;
|
|
}
|
|
|
|
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
|