OpenGL draws nothing to screen

Tony

#22556

April 12, 2020

Hi.

I'm trying to get shaders working with opengl. I'm currently drawing with fixed function pipeline and I can draw bitmaps and rectangles just fine. As soon as I call glUseProgram everything disappears from the screen and I'm out of ideas to why this happens.

I have confirmed the shaders compile and link fine, I made sure the transform uniform is active.

This is my OpenGL code

OpenGL.BasicZBiasProg = OpenGLCreateProgram(HeaderCode, VertexCode, FragmentCode);
OpenGL.TransformID = glGetUniformLocation(OpenGL.BasicZBiasProg, "Transform");

f32 Proj[] = 
{
	A, 0, 0, 0,
	0, B, 0, 0,
	0, 0, 1, 0,
	0, 0, 0, 1
};


glUseProgram(OpenGL.BasicZBiasProg);
glUniformMatrix4fv(OpenGL.TransformID, 1, GL_FALSE, Proj);
				
OpenGLDrawRect(Entry->P, Entry->Dim, Entry->Color);
				
glUseProgram(0);

And this is my shader

char *HeaderCode = R"FOO(
// Header code
#version 330

)FOO";
	
char *VertexCode = R"FOO(
// Vertex code
uniform mat4x4 Transform;
void main()
{
gl_Position = Transform*gl_Position;

}
)FOO";
	
char *FragmentCode = R"FOO(
// Fragment code
out vec4 Color;

void main()
{
Color = vec4(1.0, 0.0, 0.0, 1.0);
}
)FOO";

What I cant confirm Is that the transform uniform is set to anything. I have tried to use glUniforms on multiple different variables and after that I have tried to get the value back from the shader with glGetUniform and all I get back is the value 0.

I'm not even sure if the glUniformMatrix4fv even sets the transform... I also tried to put the actual proj into the shader but that didn't work either. Is the problem In my shader code since the fixed function pipeline works?

I'm not using double buffers or anything like that yet.

Please help...

Edited by Tony on April 12, 2020, 7:12am Reason: Initial post

Mārtiņš Možeiko

#22557

April 12, 2020

There could be million reasons why something is not drawing in OpenGL. It has so many states that it is impossible to debug without seeing full code. Maybe you called glEnable(GL_RASTERIZER_DISCARD). Nobody knows...

Have you checked for OpenGL errors? Use ARB_debug_output extension.
How are you passing vertex data to OpenGL pipeline?

Edited by Mārtiņš Možeiko on April 12, 2020, 8:37am

Tony

#22560

April 12, 2020

My current OpenGL code is a copy of caseys. I'm at day 246 and I jumped to day 368-369 for shaders.

Heres the rect call

internal void
OpenGLDrawRect(v2 Min, v2 Dim, v4 Color)
{
	
	glBegin(GL_TRIANGLES);
	
	glColor4f(Color.r, Color.g, Color.b, Color.a);
	
	v2 Max = Min + Dim;
	
	glTexCoord2f(0.0f, 0.0f);
	glVertex2f(Min.x, Min.y);
	
	glTexCoord2f(1.0f, 0.0f);
	glVertex2f(Max.x, Min.y);
	
	glTexCoord2f(1.0f, 1.0f);
	glVertex2f(Max.x, Max.y);
	
	glTexCoord2f(1.0f, 1.0f);
	glVertex2f(Max.x, Max.y);
	
	glTexCoord2f(0.0f, 1.0f);
	glVertex2f(Min.x, Max.y);
	
	glTexCoord2f(0.0f, 0.0f);
	glVertex2f(Min.x, Min.y);
	
	
	glEnd();
}

I also have tried to check for errors with glError while loop and it returns nothing

These are the only settings I give for OpenGL outside init. I don't use framebuffers tho, which casey does use. I tried using them but I'm not sure if they helped at all.

glMatrixMode(GL_TEXTURE);
glLoadIdentity();
   
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

glMatrixMode(GL_PROJECTION);
f32 A = SafeRatio1(2.0f, (f32)WindowWidth);
f32 B = SafeRatio1(2.0f, (f32)WindowHeight);
	
f32 Proj[] = 
{
	A, 0, 0, 0,
	0, B, 0, 0,
	0, 0, 1, 0,
	0, 0, 0, 1
};

glLoadMatrixf(Proj);
glViewport(0, 0, 2560, 1440);

Heres the full source. Most of it is probably just a copy from source, tried to get rid of any typos. Some functions might be commented out but I'm pretty sure I have tried with and without them.

int Win32OpenGLAttribs[] = 
{
	WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
	WGL_CONTEXT_MINOR_VERSION_ARB, 0,
	WGL_CONTEXT_FLAGS_ARB, 0 //  WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB
#if BLACKBOX_INTERNAL
		|WGL_CONTEXT_DEBUG_BIT_ARB
#endif
		,
	WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
	0,
};

internal win32_thread_startup
Win32GetThreadStartupForGL(HDC OpenGLDC, HGLRC OpenGLRC)
{
	win32_thread_startup Result = {};
	
	Result.OpenGLDC = OpenGLDC;
	if(wglCreateContextAttribsARB)
	{
		Result.OpenGLRC = wglCreateContextAttribsARB(OpenGLDC, OpenGLRC, Win32OpenGLAttribs);
	}
	
	return Result;
}

internal void
Win32SetPixelFormat(HDC WindowDC)
{
	int SuggestedPixelFormatIndex = 0;
    GLuint ExtendedPick = 0;
    if(wglChoosePixelFormatARB)
    {
        int IntAttribList[] =
        {
            WGL_DRAW_TO_WINDOW_ARB, GL_TRUE, // 0
            WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB, // 1
            WGL_SUPPORT_OPENGL_ARB, GL_TRUE, // 2
#if HANDMADE_STREAMING
            WGL_DOUBLE_BUFFER_ARB, GL_FALSE, // 3
#else
            WGL_DOUBLE_BUFFER_ARB, GL_TRUE, // 3
#endif
            WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB, // 4
            WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB, GL_TRUE, // 5
            0,
        };
		
        if(!OpenGL.SupportsSRGBFramebuffer)
        {
            IntAttribList[10] = 0;
        }
		
        wglChoosePixelFormatARB(WindowDC, IntAttribList, 0, 1,
								&SuggestedPixelFormatIndex, &ExtendedPick);
    }
	
    if(!ExtendedPick)
    {
        // TODO(casey): Hey Raymond Chen - what's the deal here?
        // Is cColorBits ACTUALLY supposed to exclude the alpha bits, like MSDN says, or not?
        PIXELFORMATDESCRIPTOR DesiredPixelFormat = {};
        DesiredPixelFormat.nSize = sizeof(DesiredPixelFormat);
        DesiredPixelFormat.nVersion = 1;
        DesiredPixelFormat.iPixelType = PFD_TYPE_RGBA;
#if HANDMADE_STREAMING
        // NOTE(casey): PFD_DOUBLEBUFFER appears to prevent OBS from reliably streaming the window
        DesiredPixelFormat.dwFlags = PFD_SUPPORT_OPENGL|PFD_DRAW_TO_WINDOW;
#else
        DesiredPixelFormat.dwFlags = PFD_SUPPORT_OPENGL|PFD_DRAW_TO_WINDOW|PFD_DOUBLEBUFFER;
#endif
        DesiredPixelFormat.cColorBits = 32;
        DesiredPixelFormat.cAlphaBits = 8;
        DesiredPixelFormat.cDepthBits = 24;
        DesiredPixelFormat.iLayerType = PFD_MAIN_PLANE;
		
        SuggestedPixelFormatIndex = ChoosePixelFormat(WindowDC, &DesiredPixelFormat);
    }
	
    PIXELFORMATDESCRIPTOR SuggestedPixelFormat;
    // NOTE(casey): Technically you do not need to call DescribePixelFormat here,
    // as SetPixelFormat doesn't actually need it to be filled out properly.
    DescribePixelFormat(WindowDC, SuggestedPixelFormatIndex,
						sizeof(SuggestedPixelFormat), &SuggestedPixelFormat);
    SetPixelFormat(WindowDC, SuggestedPixelFormatIndex, &SuggestedPixelFormat);
}

internal void
Win32LoadWGLExtensions(void)
{
    WNDCLASSA WindowClass = {};
	
    WindowClass.lpfnWndProc = DefWindowProcA;
    WindowClass.hInstance = GetModuleHandle(0);
    WindowClass.lpszClassName = "HandmadeWGLLoader";
	
    if(RegisterClassA(&WindowClass))
    {
        HWND Window = CreateWindowExA(
            0,
            WindowClass.lpszClassName,
            "Handmade Hero",
            0,
            CW_USEDEFAULT,
            CW_USEDEFAULT,
            CW_USEDEFAULT,
            CW_USEDEFAULT,
            0,
            0,
            WindowClass.hInstance,
            0);
        
        HDC WindowDC = GetDC(Window);
        Win32SetPixelFormat(WindowDC);
        HGLRC OpenGLRC = wglCreateContext(WindowDC);
        if(wglMakeCurrent(WindowDC, OpenGLRC))        
        {
            wglChoosePixelFormatARB = 
                (wgl_choose_pixel_format_arb *)wglGetProcAddress("wglChoosePixelFormatARB");
            wglCreateContextAttribsARB =
				(wgl_create_context_attribs_arb *)wglGetProcAddress("wglCreateContextAttribsARB");
            wglSwapIntervalEXT = (wgl_swap_interval_ext *)wglGetProcAddress("wglSwapIntervalEXT");
            wglGetExtensionsStringEXT = (wgl_get_extensions_string_ext *)wglGetProcAddress("wglGetExtensionsStringEXT");
			
            if(wglGetExtensionsStringEXT)
            {
                char *Extensions = (char *)wglGetExtensionsStringEXT();
                char *At = Extensions;
                while(*At)
                {
					while(IsWhitespace(*At)) {++At;}
                    char *End = At;
                    while(*End && !IsWhitespace(*End)) {++End;}
					
                    umm Count = End - At;
					
                    if(0) {}
                    else if(StringsAreEqual(Count, At, "WGL_EXT_framebuffer_sRGB")) {OpenGL.SupportsSRGBFramebuffer = true;}
                    else if(StringsAreEqual(Count, At, "WGL_ARB_framebuffer_sRGB")) {OpenGL.SupportsSRGBFramebuffer = true;}
                    
                    At = End;
                }
            }
			
            wglMakeCurrent(0, 0);
        }
		
        wglDeleteContext(OpenGLRC);
        ReleaseDC(Window, WindowDC);
        DestroyWindow(Window);
    }
}

internal HGLRC
Win32InitOpenGL(HDC WindowDC)
{
    Win32LoadWGLExtensions();
	
    b32 ModernContext = true;
    HGLRC OpenGLRC = 0;
    if(wglCreateContextAttribsARB)
    {
        Win32SetPixelFormat(WindowDC);
        OpenGLRC = wglCreateContextAttribsARB(WindowDC, 0, Win32OpenGLAttribs);
    }
    
    if(!OpenGLRC)
    {
        ModernContext = false;
        OpenGLRC = wglCreateContext(WindowDC);
    }
	
    if(wglMakeCurrent(WindowDC, OpenGLRC))
    {
		opengl_info Info = OpenGLGetInfo(ModernContext);
        if(Info.GL_ARB_framebuffer_object)
        {
            
        }
		glBindFramebuffer = (gl_bind_framebuffer *)wglGetProcAddress("glBindFramebuffer");
		glGenFramebuffers = (gl_gen_framebuffers *)wglGetProcAddress("glGenFramebuffers");
		glFramebufferTexture2D = (gl_framebuffer_texture_2D *)wglGetProcAddress("glFramebufferTexture2D");
		glCheckFramebufferStatus = (gl_check_framebuffer_status *)wglGetProcAddress("glCheckFramebufferStatus");
		
		glUniform1f = (gl_uniform1f *)wglGetProcAddress("glUniform1f");
		glUniform2f = (gl_uniform2f *)wglGetProcAddress("glUniform2f");
		glUniform3f = (gl_uniform3f *)wglGetProcAddress("glUniform3f");
		glUniform4f = (gl_uniform4f *)wglGetProcAddress("glUniform4f"); 
		
		glValidateProgram = (gl_validate_program *)wglGetProcAddress("glValidateProgram");
		glGetProgramInfoLog = (gl_get_program_info_log *)wglGetProcAddress("glGetProgramInfoLog");
		glGetProgramiv = (gl_get_programiv *)wglGetProcAddress("glGetProgramiv");
		glGetShaderInfoLog = (gl_get_shader_info_log *)wglGetProcAddress("glGetShaderInfoLog");
		
		glAttachShader = (gl_attach_shader *)wglGetProcAddress("glAttachShader");
		glCompileShader = (gl_compile_shader *)wglGetProcAddress("glCompileShader");
		glCreateProgram = (gl_create_program *)wglGetProcAddress("glCreateProgram");
		glCreateShader = (gl_create_shader *)wglGetProcAddress("glCreateShader");
		glLinkProgram = (gl_link_program *)wglGetProcAddress("glLinkProgram");
		glShaderSource = (gl_shader_source *)wglGetProcAddress("glShaderSource");
		glUseProgram = (gl_use_program *)wglGetProcAddress("glUseProgram");
		
		glGetUniformLocation = (gl_get_uniform_location *)wglGetProcAddress("glGetUniformLocation");
		glUniform4iv = (gl_uniform4iv *)wglGetProcAddress("glUniform4iv");
		glUniformMatrix4fv = (gl_uniform_matrix4fv *)wglGetProcAddress("glUniformMatrix4fv");
		
		glBindBuffer = (gl_bind_buffer *)wglGetProcAddress("glBindBuffer");
		glGenBuffers = (gl_gen_buffers *)wglGetProcAddress("glGenBuffers");
		glBufferData = (gl_buffer_data *)wglGetProcAddress("glBufferData");
		glVertexAttribPointer = (gl_vertex_attrib_pointer *)wglGetProcAddress("glVertexAttribPointer");
		glEnableVertexAttribArray = (gl_enable_vertex_attrib_array *)wglGetProcAddress("glEnableVertexAttribArray");
		glGenVertexArrays = (gl_gen_vertex_arrays *)wglGetProcAddress("glGenVertexArrays");
		glBindVertexArray = (gl_bind_vertex_array *)wglGetProcAddress("glBindVertexArray");
		glGetAttribLocation = (gl_get_attrib_location *)wglGetProcAddress("glGetAttribLocation");
		
		glGetUniformfv = (gl_get_uniformfv *)wglGetProcAddress("glGetUniformfv");
		glGetUniformiv = (gl_get_uniformiv *)wglGetProcAddress("glGetUniformiv");
		glGenFramebuffers = (gl_gen_framebuffers *)wglGetProcAddress("glGenFramebuffers");
		
		if(wglSwapIntervalEXT)
        {
            wglSwapIntervalEXT(1);
        }
		
		OpenGLInit(Info, OpenGL.SupportsSRGBFramebuffer);
    }
    
    return(OpenGLRC);
}



internal GLuint
OpenGLCreateProgram(char *HeaderCode, char *VertexCode, char *FragmentCode)
{
	GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
	GLchar *VertexShaderCode[] = 
	{
		HeaderCode,
		VertexCode,
	};
	
	glShaderSource(VertexShaderID, ArrayCount(VertexShaderCode), VertexShaderCode, 0);
	glCompileShader(VertexShaderID);
	
	GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
	GLchar *FragmentShaderCode[] = 
	{
		HeaderCode,
		FragmentCode,
	};
	
	glShaderSource(VertexShaderID, ArrayCount(FragmentShaderCode), FragmentShaderCode, 0);
	glCompileShader(FragmentShaderID);
	
	GLuint ProgramID = glCreateProgram();
	glAttachShader(ProgramID, VertexShaderID);
	glAttachShader(ProgramID, FragmentShaderID);
	glLinkProgram(ProgramID);
	
	glValidateProgram(ProgramID);
	GLint Link = false;
	glGetProgramiv(ProgramID, GL_LINK_STATUS, &Link);
	if(!Link)
	{
		GLsizei Ignored;
		char VertexErrors[4096];
		char FragmentErrors[4096];
		char ProgramErrors[4096];
		glGetShaderInfoLog(VertexShaderID, sizeof(VertexErrors), &Ignored, VertexErrors);
		glGetShaderInfoLog(FragmentShaderID, sizeof(FragmentErrors), &Ignored, FragmentErrors);
		glGetShaderInfoLog(ProgramID, sizeof(ProgramErrors), &Ignored, ProgramErrors);
		
		Assert(!"Shader Validation Failed!!!!!");
	}
	
	return ProgramID;
}

internal void
OpenGLInit(b32 ModernContext)
{
	OpenGLDefaultInternalTextureFormat = GL_RGBA8;
	opengl_info Info = OpenGLGetInfo(ModernContext);
	
	
	if(Info.GL_EXT_texture_sRGB)
	{
                OpenGLDefaultInternalTextureFormat = GL_SRGB8_ALPHA8;
	}
	if(Info.GL_EXT_framebuffer_sRGB)
	{
		//glEnable(GL_FRAMEBUFFER_SRGB);
	}
}

internal void
OpenGLDrawRect(v2 Min, v2 Dim, v4 Color)
{
	
	glBegin(GL_TRIANGLES);
	
	glColor4f(Color.r, Color.g, Color.b, Color.a);
	
	v2 Max = Min + Dim;
	
	glTexCoord2f(0.0f, 0.0f);
	glVertex2f(Min.x, Min.y);
	
	glTexCoord2f(1.0f, 0.0f);
	glVertex2f(Max.x, Min.y);
	
	glTexCoord2f(1.0f, 1.0f);
	glVertex2f(Max.x, Max.y);
	
	glTexCoord2f(1.0f, 1.0f);
	glVertex2f(Max.x, Max.y);
	
	glTexCoord2f(0.0f, 1.0f);
	glVertex2f(Min.x, Max.y);
	
	glTexCoord2f(0.0f, 0.0f);
	glVertex2f(Min.x, Min.y);
	
	
	glEnd();
}

internal void
OpenGLSetScreenspace(s32 Width, s32 Height)
{
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	
	glMatrixMode(GL_PROJECTION);
	f32 A = SafeRatio1(2.0f, (f32)Width);
	f32 B = SafeRatio1(2.0f, (f32)Height);
	
	f32 Proj[] = 
	{
		A, 0, 0, 0,
		0, B, 0, 0,
		0, 0, 1, 0,
		-1, -1, 0, 1
	};
	
	glLoadMatrixf(Proj);
}


internal void
OpenGLRenderCommands(render_commands *Commands, s32 WindowWidth, s32 WindowHeight, rect2i DrawRegion)
{
	glMatrixMode(GL_TEXTURE);
    glLoadIdentity();
    
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
	
	glMatrixMode(GL_PROJECTION);
	f32 A = SafeRatio1(2.0f, (f32)WindowWidth);
	f32 B = SafeRatio1(2.0f, (f32)WindowHeight);
	
	f32 Proj[] = 
	{
		A, 0, 0, 0,
		0, B, 0, 0,
		0, 0, 1, 0,
		0, 0, 0, 1
	};
	
	glLoadMatrixf(Proj);
	glViewport(0, 0, 2560, 1440);
	
	GLint ViewData[4] = {};
	glGetIntegerv(GL_VIEWPORT, ViewData);
	for(u32 BaseAddress = 0;
		BaseAddress < Commands->PushBufferSize;
		)
	{
		render_group_entry_header *Header = (render_group_entry_header *)(Commands->PushBufferBase + BaseAddress);
		BaseAddress += sizeof(*Header);
		
		
		
		void *Data = Header + 1;
		switch(Header->Type)
		{
			
			case RenderGroupEntryType_render_entry_bitmap:
			{
				render_entry_bitmap *Entry = (render_entry_bitmap *)Data;
				
				v2 XAxis = { 1, 0 };
				v2 YAxis = { 0, 1 };
				v2 MinP = Entry->P;
				v2 MaxP = MinP + Entry->Size.x*XAxis + Entry->Size.y*XAxis;
				
				glBindTexture(GL_TEXTURE_2D, (GLuint)Entry->Bitmap->TextureHandle);
				
				glUseProgram(OpenGL.BasicZBiasProg);
				//glUniform4f(OpenGL.TransformID, 1, GL_FALSE, Proj);
				
				OpenGLDrawRect(Entry->P, Entry->Size, Entry->Color);
				
				glUseProgram(0);
			} break;
			case RenderGroupEntryType_render_entry_clear:
			{
				render_entry_clear *Entry = (render_entry_clear *)Data;
				
				glDisable(GL_TEXTURE_2D);
				OpenGLDrawRect(V2(0.0f, 0.0f), Entry->Dim, Entry->Color);
				glEnable(GL_TEXTURE_2D);
				
				BaseAddress += sizeof(*Entry);
			} break;
			
			case RenderGroupEntryType_render_entry_rect:
			{
				render_entry_rect *Entry = (render_entry_rect *)Data;
				
				glDisable(GL_TEXTURE_2D);
				
				//glUseProgram(OpenGL.BasicZBiasProg);
				//glUniformMatrix4fv(OpenGL.TransformID, 1, GL_FALSE, Proj);
				
				OpenGLDrawRect(Entry->P, Entry->Dim, Entry->Color);
				
				glUseProgram(0);
				glEnable(GL_TEXTURE_2D);
				
				BaseAddress += sizeof(*Entry);
			} break;
			
			//InvalidDefaultCase;
		}
	}
#if 0
	glBindFramebuffer(GL_READ_FRAMEBUFFER, GlobalFramebufferHandles);
	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
	glViewport(DrawRegion.Min.x, DrawRegion.Min.y, WindowWidth, WindowHeight);
	glBlitFramebuffer(0, 0, GetWidth(DrawRegion), GetHeight(DrawRegion),
					  DrawRegion.Min.x, DrawRegion.Min.y,
					  DrawRegion.Max.x, DrawRegion.Max.y,
					  GL_COLOR_BUFFER_BIT,
					  GL_LINEAR); 
#endif
}


internal opengl_info 
OpenGLInit(opengl_info Info, b32 FramebufferSupportsSRGB)
{
	glGenTextures(1, &OpenGL.ReservedBlitTexture);
	
	// NOTE(casey): If we believe we can do full sRGB on the texture side
	// and the framebuffer side, then we can enable it, otherwise it is
	// safer for us to pass it straight through.
	OpenGL.DefaultInternalTextureFormat = GL_RGBA8;
	if(FramebufferSupportsSRGB && Info.GL_EXT_texture_sRGB && Info.GL_EXT_framebuffer_sRGB)
	{
		OpenGL.DefaultInternalTextureFormat = GL_SRGB8_ALPHA8;
		//glEnable(GL_FRAMEBUFFER_SRGB);
	}
	
	//glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	
	char *HeaderCode = R"FOO(
// Header code
#version 330

)FOO";
	
	char *VertexCode = R"FOO(
// Vertex code
uniform mat4x4 Transform;
void main()
{
gl_Position = Transform*gl_Position;

}
)FOO";
	
	char *FragmentCode = R"FOO(
// Fragment code
out vec4 Color;

void main()
{
Color = vec4(1.0, 0.0, 0.0, 1.0);
}
)FOO";
	
	OpenGL.BasicZBiasProg = OpenGLCreateProgram(HeaderCode, VertexCode, FragmentCode);
	OpenGL.TransformID = glGetUniformLocation(OpenGL.BasicZBiasProg, "Transform");
	
	return(Info);
}

Mārtiņš Možeiko

#22565

April 12, 2020

In this code you are not calling glUniformMatrix to pass projection matrix to shader. Instead you are using GL_MODELVIEW and GL_PROJECTION matrices with glLoadMatrixf that your shader completely ignores. These calls are useless. Also calling glEnable/glDisable with GL_TEXTURE_2D is useless when you do shaders.

Not sure, but I feel like your orthographic matrix is missing translation by -1 for x and y coordinates. See: http://docs.gl/gl2/glOrtho
In your code OpenGLSetScreenspace does the correct matrix (which is not called), but code in OpenGLRenderCommands does incorrect matrix.

Otherwise it looks fine.
Try setting matrix to identity, and just draw triangle with (-1;-1) .. (1,1) coordiantes. If that works, that means your matrix setup is busted.

Edited by Mārtiņš Možeiko on April 12, 2020, 8:54pm

Tony

#22568

April 13, 2020

The matrix used to be this, but it doesnt work either.

f32 Proj[] = 
{
	A, 0, 0, 0,
	0, B, 0, 0,
	0, 0, 1, 0,
	-1, -1, 0, 1
};

I tried setting matrix to identity and draw a triangle but It doesnt show up on the screen either.

Tony

#22578

April 14, 2020

I have no words for my stupidity.

1	glShaderSource(VertexShaderID, ArrayCount(FragmentShaderCode), FragmentShaderCode, 0);

Maybe if I would simply use the FragmentShaderID I could have a working shader and wouldn't have to spend 5 days for nothing...

It works now. Thank you for your help, I appreciate it.