Derelict2 openGL3 issues

[Stephen Jones]

David suggested I start a new thread rather than asking on an old 
existing one (probably wants to get rid of me). So what I have 
done is created the most parred back, hello world type program 
that could run under the GL3 enforcement policies dictated by 
Derelict2. Fixed function pipeline is out. The vertex positions 
fit within clip space so there is no need to be sending 
projection, view or model matricies to the vertex shader, nor any 
need therein to be altering the vertex positions; they simply get 
set to gl_Position. The fragment shader assigns red to 
gl_FragColor. I have read somewhere that vaos are required for 
GL3 and that vbos hang pointlessly without the chaperone of a 
vao, regardless, the code can draw either vao or vbo depending on 
which draw function is not commented out in the loop. The problem 
is, however, that neither function draws anything. Yet all the 
initializations are returning true; the SDL window pops up and 
gets cleared to black. Is there a problem with Derelict2?


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

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

SDL_Window *win;
SDL_GLContext context;
int w=800, h=600;
bool running=true;
int shader = 0;
uint vao=0, vbo=0;

bool loadLibs(){
     try{
         DerelictSDL2.load();
     }catch(Exception e){
         writeln("Error loading SDL2 lib");
	return false;
     }
     try{
         DerelictGL3.load();
     }catch(Exception e){
         writeln("Error loading GL3 lib");
	return false;
     }

     return true;
}
bool initSDL(){
	if(SDL_Init(SDL_INIT_VIDEO) < 0){
		writefln("Error initializing SDL");
		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;
}
bool initGL(){
	glClearColor(0.0, 0.0, 0.0, 1.0);
	glViewport(0, 0, w, h);

	return true;
}
bool initShaders(){
	const string vshader="
	#version 330
	layout(location = 0) in vec4 pos;
	void main(void)
	{
     gl_Position = pos;
	}
	";
	const string fshader="
	#version 330
	void main(void)
	{
     gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
	}
	";

	shader=glCreateProgram();
	if(shader == 0){
		writeln("Error: GL did not assigh main shader program id");
		return false;
	}
	int 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);
		return false;
	}
	int 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);
		return false;
	}
	glAttachShader(shader, vshad);
	glAttachShader(shader, fshad);
	glLinkProgram(shader);
	glGetShaderiv(shader, GL_LINK_STATUS, &status);
	if(status==GL_FALSE){
		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &len);
		char[] error=new char[len];
		glGetShaderInfoLog(shader, len, null, cast(char*)error);
		writeln(error);
		return false;
	}

	return true;
}
bool initVAO(){
	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];
	glGenVertexArrays(1, &vao);
	if(vao<1){
		writeln("Error: GL failed to assign vao id");
		return false;
	}

	glBindVertexArray(vao);

	glGenBuffers(1, &vbo);
	if(vbo<1){
		writeln("Error: GL failed to assign vbo id");
		return false;
	}
	
	glBindBuffer(GL_ARRAY_BUFFER, vbo);
	glBufferData(GL_ARRAY_BUFFER, v.length * GL_FLOAT.sizeof, &v, 
GL_STATIC_DRAW);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, null);//is 
this right casting a void pointer for 0 offset?	
			
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindVertexArray(0);	

	return true;
}

void drawVao(){
	glUseProgram(shader);

	glBindVertexArray(vao);
	glDrawArrays(GL_TRIANGLES, 0, 6);

	glBindVertexArray(0);
	glUseProgram(0);
}
void drawVbo(){
	glUseProgram(shader);
	glBindBuffer(GL_ARRAY_BUFFER, vbo);

	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, null);
	glDrawArrays(GL_TRIANGLES, 0, 6);
	
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glUseProgram(0);
}


int main()
{
	writeln("Load libs: ", loadLibs());//true
	writeln("Init sdl: ", initSDL());//true
	writeln("Init gl: ", initGL());//true
	writeln("Init shaders: ", initShaders());//true
	writeln("Init vao: ", initVAO());//true

	while(running){
		SDL_Event e;
		while(SDL_PollEvent(&e)){
			switch(e.type){
				case SDL_KEYDOWN:
				running=false;
				break;
				default:
				break;
			}
		}
		glClear(GL_COLOR_BUFFER_BIT);

		//drawVao();
		drawVbo();

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

	return 0;
}