OpenGL glBufferSubData

This entry is part 3 of 4 in the series Learning OpenGL

I finally wrote the next beginner program which uses the OpenGL glBufferSubData function. The advantage with this function is that you don’t need to define a huge buffer upfront, but instead provide the graphics card small buffers piece by piece.

I added a little thread to my program and call the draw function every 200 milliseconds. The program is as the ones before fairly unspectacular. All you see is a moving rectangle.

For my next program, I’ll use the glMapBuffer function which is generally the better function to use. Why and how to use it will be described in my next post.

Simple Beginner OpenGL programs

This entry is part 2 of 4 in the series Learning OpenGL

I’m currently at the 21st YouTube episode from Jamie King’s Playlist ‘3D Computer Graphics using OpenGL’. So far, I have created 3 little programs which are based on each other. All of them are available on Github.

The best way to learn a new language is by actually using it and that’s why I write little programs based on what I’m learning from the YouTube episodes.

My 2nd beginner program

The 2nd OpenGL program consists of a fixed pipeline (no use of shaders). It sets the background blue and then draws two white triangles.

Setting the background color is done via the glClearColor function.

For the drawing of the triangles, there are a few more steps required. First, you need an array with your vertices. Then you need to create a buffer OpenGL can use, which is done via the glGenBuffer function. This buffer then needs to be bound to GL_ARRAY_ELEMENT (since we have an array of vertices which form two triangles if you connect each of them) via glBindBuffer.

This OpenGL buffer object now still needs the actual vertice coordinates which we provide via the glBufferData function. Now all that’s left is to tell OpenGL that it can use that buffer via glEnableVertexAttribArray and we also still need to tell it how the buffer looks like (how many floats for a vertice, etc.) which is done via glVertexAttribPointer.

The buffer object is now ready to be used by OpenGL. We only have to tell OpenGL anymore about the size of the window to render which we do with glViewport and call the actual drawing function glDrawArrays.

My 3rd beginner program

The 3rd program improves memory usage of the previous program (though admittingly for that tiny array, it doesn’t really matter at all) and uses a simple vertex and fragment shader to actually color those two triangles created.

When creating an array of vertices, it is likely that you have a lot of duplication. E.g. one vertice of the first triangle could be the starting point of the second triangle. To avoid unnecessary duplication, you can use additionally to the GL_ARRAY_BUFFER also the GL_ELEMENT_ARRAY_BUFFER. That means I remove all duplicated vertices in the one array and create a second array with the indices. For that array, I generate again an OpenGL buffer and this time bind it to GL_ELEMENT_ARRAY_BUFFER. Last but not least, I have to give the new buffer object the indices array.

The drawing function glDrawElements is now a different one, since the indices array tells OpenGL which vertice comes next.

For the coloring of the triangles, we need to add the RGB floats to each vertice in the first buffer array. Then we tell OpenGL that the buffer array contains those color vertices as well via glEnableVertexAttribArray and glVertexAttribPointer.

Last but not least, we need to write simple vertex and fragment shader code (minimal.vert and minimal.frag in my example program) and then tell OpenGL to compile, link and use the shaders.

Pretty unspectacular what I’ve produced so far, but I’m looking forward to learning more and more.

Do. Or do not! There is no try. – Yoda

Database/table information

This entry is part 2 of 2 in the series SQL tips and tricks

In the last few weeks, I improved/corrected lots of my existing stored procedures for my current project. It feels good knowing that my understanding of inline views has definitely improved. I’ve additionally learned a few SQL queries that provide me with database/table information.

I also faced a few issues while trying to use views in SQL Server. I have a few views in SQL Server that I can’t actually use because as soon as I save them, the content gets automatically formatted and changed. I’d be fine with it if the change didn’t influence the outcome, but it does. When I have several joins and then a WHERE clause, SQL Server always changes it to joins with an AND instead of the WHERE. That’s really annoying since the outcome with the AND is wrong. I hope I can figure out what’s going on soon but till then, I’ll end up saving those queries in a stored procedure directly (where it doesn’t get auto-formatted and changed).

A few things I’ve learned lately:

SQL Servers sys.sql_modules

In my current project, I ended up having quite a lot of stored procedures. I started getting a bit overwhelmed. For example, I knew I had used certain keywords (like TRANSACTION) in some procedures, but how could I quickly find them. Going through each stored procedure is an option, but a very slow, annoying, and frustrating one. Then I found out about the sys.sql_modules table. It has a ‘description’ column which contains SQL scripts for creating each existing view and stored procedure.

I started using following search

SELECT definition FROM sys.sql_modules 

That helped me tremendously in finding certain stored procedures very quickly.

SQL Servers sys.objects

The SQL query above helps in finding the wanted stored procedure/view since each ‘description’ column contains the name of the stored procedure/view within a few words. But I figured it would be nicer if I could just get the stored procedure/view name instead. And that’s where the sys.objects table comes handy.

SELECT DISTINCT FROM sys.sql_modules sm 
INNER JOIN sys.objects o ON sm.object_id = o.object_id
WHERE sm.definition LIKE '%account%';

Other useful SQL queries to learn more about the database

The more tables/columns/views/stored procedures/functions/etc., the harder it gets to maintain the database and to keep an overview.

I found querying the Information Schema views very useful. For example, if you want to quickly know the columns of a table or view, use following query:

WHERE TABLE_NAME = 'my_table'

I’ve already mentioned how to search for certain keywords in views/stored procedures via sys.sql_modules. Another way of doing exactly this is via the Information Schema views. The following code snippet shows all CREATE VIEW/PROCEDURE functions for your database:


Example usage

During development, I often have more than one database of the same thing. I have the main database which will eventually be deployed and which I use for all kind of tests. Then I have for each person that plays around with my software (for testing purposes or other) an additional copied database.

During development, I often need to correct some views or/and stored procedures which I update on my database and then retest. As soon as I’m happy with the changes, I need to also make my ‘testers’ happy and provide them with the latest version. I wrote a little script extra for that purpose to make updating the other database views/stored procedures so much easier and quicker.

use tester_x_db;
DECLARE @row int = 1;
DECLARE @sp varchar(8000);
DECLARE @maxViews int = 
WHILE @row <= @maxViews
	) AS tmp
    WHERE rownumber = @row;
    EXEC (@sp);
    SET @row = @row + 1;

DECLARE @maxRoutines int = 
SET @row = 1;
WHILE @row <= @maxRoutines
	 ) AS foo
    WHERE rownumber = @row;
    EXEC (@sp);
    SET @row = @row + 1;

OpenGL with MFC ‘Hello world’ tutorial

This entry is part 1 of 4 in the series Learning OpenGL

For my first ‘Hello World’ program, I decided to use OpenGL with MFC since I’ve created OpenGL apps with just glew and freeglut before and there are lots of tutorials on the net for just that. I just wanted to know how to integrate OpenGL in an SDI MFC app and it turned out to be quite easy.

I’ve written a few starter OpenGL programs in the past but never really continued studying it for very long. This time, my goal is to actually finish the 3D Computer Graphics Using OpenGL YouTube series by Jamie King.

Jamie’s videos are awesome since he is really good in explaining things. The nice thing about YouTube tutorials comparing to real-life lessons is that you can fast forward when a subject is already known or repeat a section when you didn’t pay attention or just didn’t quite get it.

I’m also using other sources for studying OpenGL. I’m going to use the book ‘OpenGL Programming Guide’ by Dave Shreiner and Graham Sellers as a reference book. Furthermore, I’m going to read through Introduction to Computer Graphics material. Last but not least, I just recently found the ‘OpenGL & Vulkan’ podcast by Kai Niklas. That podcast is perfect to listen to while I play with my son.

Why am I interested in OpenGL? During university and years after, I haven’t really paid much attention to computer graphic design. I mean there was a reason I specialized in embedded systems. After years of microcontroller programming, I started getting a bit bored with it. I still enjoy it, but I just started missing the beauty of object oriented programming languages.

Then I started programming in GDI+ which I actually began to enjoy a lot. Now, I feel like I really want to get deeper into the guts of 2D and 3D graphics, which means OpenGL.

In this series, I’d like to document my OpenGL programming progress and also link to my created programs in github.

I’ve used following sites to guide me create my first MFC OpenGL program:

  • For GLEW and freeglut installation, I followed the ‘Installing freeglut’ and ‘Install GLEW’ guides in ‘Introduction to Computer Graphics’ installation guide.
  • Instead of using the OpenGL helper classes/functions freely accessible from the course site above, I decided to use the GLRenderer class from
  • Now, all I needed to do was call several GLRenderer functions from my SDI view class. I created message handlers for
    • WM_SIZE

    and also overloaded OnInitialUpdate().

The code for this first program can be found in github.

For this first program, I wasn’t really concerned about the drawing functionality. My goal was to just have a basic OpenGL with MFC skeleton for future programs.

SQL features

This entry is part 1 of 2 in the series SQL tips and tricks

I’m currently going through ‘SQL Cookbook’ by Anthony Molinaro to fresh up my SQL knowledge. I’ve read about 1/6th of the book so far and love it. It’s not meant for newbies, but I’d say for everybody else. It contains tonnes of examples and in detail explanations. I really like that it explains solutions for the most common databases (SQL Server, MySQL, Oracle, PostgreSQL, DB2).

Before I start going into details of what all I’ve learned so far, I quickly explain how I even got to buy the book. I’m using MySQL and MSSQL databases for about 2 years now and all the databases I’ve worked so far were fairly straight forward, small, and the queries simple. I’ve had database courses at university and thought I remembered still most of what I’ve learned (about 10 years ago – what was I thinking?).

One of my current projects is atypical with respect to my previous databases: It still doesn’t consist of too many tables, but the required SQL queries are a whole lot more complicated. I hit a road block. I tried to solve way too many issues on the application side (which resulted in performance costs) and finally decided to step back and do it right in the first place (hmm, that line sounds familiar. Guess I’ve watched too many Mike Holmes episodes years ago).

Pattern matching in search conditions

Let’s assume you want to show all rows that start with the characters ‘Star’ in a certain column.
Furthermore, we have the following table named movie:

Star Wars
Star Trek
Despicable Me

The sql statement would be:

SELECT title FROM movie WHERE title LIKE 'Star%';

Real easy, isn’t it? Yeah, as long as you remember what wildcard stands for ‘any sequence of characters’.

List of wildcards that can be used:

%      any sequence of characters
_      any single character
[]     any single character within range/set (e.g. [s-z]/[stuvwxyz]
[^]    any single character not within range/set (e.g. [^s-z]/[^stuvwxyz]


To combine the result of several SELECT queries you use UNION. Nothing knew here, but there is a slight difference between UNION and UNION ALL. UNION ALL will result in duplicates if they exist. UNION, on the other hand side, will filter duplicates.

NOT IN statement in the WHERE clause

Ok, that one was completely new to me, but important to know. Let’s look at the following query:

SELECT title FROM move WHERE title NOT IN ('Despicable Me','Startdust');

As you guessed, the result will contain all columns but ‘Despicable Me’ and ‘Startdust’. Let’s quickly create a second table named ‘wishlist’ with following entries:

id    | title
1     | Despicable Me
2     | Startdust

Now change the SELECT query a bit and you get the same result:

SELECT title FROM movie WHERE title NOT IN (SELECT title FROM wishlist);

But what if the wishlist contained one entry with id 3 and title NULL? Ok, in this example, a title with NULL doesn’t quite make sense, but let’s just go with it. You still expect the same 4 movie titles as result with the above statement or? If you do, you’re mistaken. The result will be empty. What I didn’t know is that IN and NOT IN are essentially OR operations. So above select statement would be equivalent to following:

SELECT title FROM movie WHERE title NOT IN ('Despicable Me','Startdust',NULL);

So let’s look at the comparison for ‘Star Wars’:

'Star Wars'='Despicable Me' || 'Star Wars'='Startdust' || 'Star Wars'=NULL
==> (FALSE || FALSE || NULL)
==> NULL

The part to remember is that (FALSE or NULL) results in NULL and (TRUE or NULL) results in TRUE. That means if there is a chance that the column will contain a NULL value, use the following statement instead:

SELECT title FROM movie m WHERE NOT EXISTS (SELECT 1 FROM wishlist w WHERE m.title=w.title);