D, Derelict2, and OpenGL

[Stephen Jones]

In the same vein, I have getting nothing on the screen when there 
should be rendered a red triangle. The vertex positions are those 
used by McKeeson http://www.arcsynthesis.org/gltut/, being in ndc 
fall within the frustum. The code for setting up vao and shaders 
is:

module ShaderHub;

import std.stdio;
import std.string;
import derelict.opengl3.gl3;

class ShaderHub{
	private bool ok=true;
	private GLuint shad=0, vshad=0, fshad=0;
	private int voff=0;
	private GLuint vbo=0, vao=0;
	const float[] v = [	0.75f, 0.75f, 0.0f, 1.0f,
						0.75f, -0.75f, 0.0f, 1.0f,
						-0.75f, -0.75f, 0.0f, 1.0f];
	
	public this(){
		immutable string vshader = `
#version 330
layout(location = 1) in vec4 pos;
void main(void)
{
     gl_Position = pos;
}
`;

		immutable string fshader = `
#version 330
void main(void)
{
     gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}
`;

		shad=glCreateProgram();
		if(shad==0){
			writeln("Error: GL did not assigh main shader program id");
			ok=false;
		}
		
		vshad=glCreateShader(GL_VERTEX_SHADER);
		const char *vptr=toStringz(vshader);
		glShaderSource(vshad, 1, &vptr, null);
		glCompileShader(vshad);	
		int status, len;
		glGetShaderiv(vshad, GL_COMPILE_STATUS, &status);
		if(status==GL_FALSE){
			glGetShaderiv(vshad, GL_INFO_LOG_LENGTH, &len);
			char[] error=new char[len];
			glGetShaderInfoLog(vshad, len, null, cast(char*)error);
			writeln(error);
			ok=false;
		}
		
		fshad=glCreateShader(GL_FRAGMENT_SHADER);
		const char *fptr=toStringz(fshader);
		glShaderSource(fshad, 1, &fptr, null);
		glCompileShader(fshad);	
		glGetShaderiv(vshad, GL_COMPILE_STATUS, &status);
		if(status==GL_FALSE){
			glGetShaderiv(fshad, GL_INFO_LOG_LENGTH, &len);
			char[] error=new char[len];
			glGetShaderInfoLog(fshad, len, null, cast(char*)error);
			writeln(error);
			ok=false;
		}
		
		glAttachShader(shad, vshad);
		glAttachShader(shad, fshad);
		glLinkProgram(shad);
		glGetShaderiv(shad, GL_LINK_STATUS, &status);
		if(status==GL_FALSE){
			glGetShaderiv(shad, GL_INFO_LOG_LENGTH, &len);
			char[] error=new char[len];
			glGetShaderInfoLog(shad, len, null, cast(char*)error);
			writeln(error);
			ok=false;
		}
		
		
		glGenVertexArrays(1, &vao);
		if(vao<1){
			writeln("Error: GL failed to assign vao id");
			ok=false;
		}
		glBindVertexArray(vao);
		
		glGenBuffers(1, &vbo);
		if(vbo<1){
			writeln("Error: GL failed to assign vbo id");
			ok=false;
		}
		glBindBuffer(GL_ARRAY_BUFFER, vbo);
		glBufferData(GL_ARRAY_BUFFER, v.length * GL_FLOAT.sizeof, 
&v[0], GL_STATIC_DRAW);
		glEnableVertexAttribArray(1);
		glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, 
cast(void*)voff);	
			
		glBindBuffer(GL_ARRAY_BUFFER, 0);
		glBindVertexArray(0);	
	}
	
	public void draw(){
		glUseProgram(shad);
		
		writeln(glGetAttribLocation(shad, "pos"));//prints 1
		
		glBindVertexArray(vao);	
		glDrawArrays(GL_TRIANGLES, 0, 6);		
		glBindVertexArray(0);
		

		glUseProgram(0);
	}
}

//__________________________________________________________________

the code for setting up openGL3 is:


import std.stdio;
import derelict.sdl2.sdl;
import derelict.opengl3.gl3;

import EventHub;
import ExposeApp;

pragma(lib, "DerelictUtil.lib");
pragma(lib, "DerelictSDL2.lib");
pragma(lib, "DerelictGL3.lib");


class App{
     private ExposeApp funcPtrs;
     private EventHub ehub;
     private SDL_Window *win;
     private SDL_GLContext context;
     private int w=600, h=480, fov=55;
     private bool running=true;

     public this(){
         if(!initSDL()){
             writeln("Error initializing SDL");
             SDL_Quit();
         }
         initGL();

         funcPtrs=new ExposeApp();
         funcPtrs.stop=&stopLoop;
         funcPtrs.grabMouse=&grabMouse;
         funcPtrs.releaseMouse=&releaseMouse;
         ehub=new EventHub(funcPtrs);


         while(running){
             glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

             ehub.tick();

             SDL_GL_SwapWindow(win);
         }


         SDL_GL_DeleteContext(context);
         SDL_DestroyWindow(win);
         SDL_Quit();
     }

     private void stopLoop(){
         running=false;
     }
     private void grabMouse(){
         SDL_ShowCursor(SDL_DISABLE);
         SDL_SetWindowGrab(win, SDL_TRUE);
     }
     private void releaseMouse(){
         SDL_ShowCursor(SDL_ENABLE);
         SDL_SetWindowGrab(win, SDL_FALSE);
     }
     private bool initSDL(){
         if(SDL_Init(SDL_INIT_VIDEO)< 0){
			writefln("Error initializing SDL");
			SDL_Quit();
			return false;
		}
				
		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
		SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
		SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
		SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
		
		win=SDL_CreateWindow("3Doodle", SDL_WINDOWPOS_CENTERED, 
SDL_WINDOWPOS_CENTERED, w, h, SDL_WINDOW_OPENGL | 
SDL_WINDOW_SHOWN);
         if(!win){
             writefln("Error creating SDL window");
			SDL_Quit();
			return false;
         }

         context=SDL_GL_CreateContext(win);
         SDL_GL_SetSwapInterval(1);

         DerelictGL3.reload();

         return true;
     }
     private void initGL(){
         resize(w, h);

         glEnable(GL_DEPTH_TEST);
         glEnable(GL_CULL_FACE);

         glDepthFunc(GL_LEQUAL);

         glClearColor(0.0, 0.0, 0.0, 1.0);
         glClearDepth(1.0);

         glCullFace(GL_BACK);
         glFrontFace(GL_CCW);

     }
     private void resize(int w, int h){
         //this will contain the makings of the projection matrix, 
which we go into next tut
         glViewport(0, 0, w, h);
     }
}


void main(){
     try{
         DerelictSDL2.load();
     }catch(Exception e){
         writeln("Error loading SDL2 lib");
     }
     try{
         DerelictGL3.load();
     }catch(Exception e){
         writeln("Error loading GL3 lib");
     }

     App a=new App();
}


Any help would be great.