I had a very productive Christmas this year.

I spend a lot of it reading various interesting things. For example, I spend about 2 or 3 days reading WPF 2nd edition which I found very good. The nice thing about this particular book is that in the very beginning, i.e, Chapter 1, it pretty much gives you a crash course touching most of the things that get their own dedicated chapter later in the book. I subscribe to this way of learning.

I only got through 3 chapters but in the process, I also created a set of representative artefacts or examples that practise using the concepts, so this made the reading, well somewhat slower but more useful. I wrote a series of training of practise applications that incorporated aspects from basic Xaml theory to creating windows, controls and styling them. Also covered layout and resources. The main reason I wanted to read this text is that I've got some upcoming work that needs some level of proficiency in WPF, so I thought I'd capitalize on the Christmas break. This is pretty much the theme of most of my other Christmas projects.

I also spend some time reason up on 'Game Engine Toolset Development', which is old but in my opinion still relevant as it touches on building utilities for games. I've got a game that could do with expansion, and the expansion would really be improved by better levels and a level editor would be a good utility to build. 

Alongside the above I've also been re-learning OpenGL, however, this time using the most up-to-date version, i.e 4.5 (in my formal training, we covered OpenGL 3.x). I like OpenGL and the combination of graphics programming, c++ and math are very appealing to me. So, in this respect, I've been reading the OpenGL Super Bible. I managed to get through the first 5 chapters and again, like my approach used for my WPF work, I decided to catalogue a list of representative examples to supplement the theory. 

Also, I decided to take some of the work that I did in my 3D project (OpenGL 3.x) and abstract some of the functions I wrote into a stand-alone shared library. First, I tried to make a dynamic library (DLL) to see if that would help, but it only really is useful for exporting specific and standalone C functions, and I have complete classes that I want to package up, so I used a static library which works well.

I basically re-wrote my 3D project by taking out all the custom logic I created and putting them in the library and then got the 3D project to reference the logic instead of from the shared library. This worked well. As a result, the overall game vehicle, which is basically a Windows app with a message pump, handling messages, windows resize events and keyboard input became nice and sparse. This is great because I can use it as a template. This is actually what I did moving forward while reading the Super Bible.

I created a new example for each notable concept documented in the bible and used the template to base them on. As a result, I have a series of examples, all using the template, my shared library and another shared library I created that houses some of the 3rd party game technology stuff, that Id didn't write myself, but that I used in my 3D project (created by staff/community etc), and which can still be re-used in other projects, like these examples.

I covered aspects such as creating a simple OpenGL app, creating basic shaders, using gl_VertexID, drawing simple triangles, using/updating vertex attributes, using interface blocks (uniforms), basic fragment shader etc.

I gave it a break for a day and read the first 5 chapters of 'AI Game Development: Synthetic Creatures with Learning and Reactive Behaviours. This is an old book, and some of the stuff is very specific to a framework that has since disappeared. I'm hoping to gather some interesting points, however, there is a good chance that I'll drop it and move onto a more current AI book.

I came back to OpenGL and covered aspects like using basic buffers, filling vertex attributes from a buffer (very useful) and making some examples of how to interleave or create blocks of vertex attribute data.  It's pretty interesting stuff and it's the kind of thing that if you spend too much time in the theory, results in you forgetting the intricacies a couple of days or months later, so a practical approach is essential in my opinion. 

I also read C++ Today which is an O'Reilly book that outlines the improvements and revolution that C++ is going through at the moment, and one which I've particularly excited about. 

 So quite a productive, useful and enjoying Christmas as I've had in a long time. This is actually a summary of what I did:

Date Tasks
 Dec 23
  • Read WPF 2nd edition
    • Chapter 1: Hello, WPF
    • Chapter 2: Applications and Settings
    • Chapter 3: Layout
  • Created WpfStepByStep:
    • Wpf1 - Basic
    • Wpf2 - App.Run
    • Wpf3 - Imperative Custom Window
    • Wpf4 - Custom Window using Xaml
    • Wpf5 - No Main Entry Point
    • Wpf6 - Content control 1
    • Wpf7 - Content control 2
    • Wpf8 - Content control 3
    • Wpf9 - Content control 4
    • Wpf10 - Grid
    • Wpf11 - Grid + events
    • Wpf13 - Resources
    • Wpf14 - Styles
    • Wpf15 - Control Templates
    • Wpf16 - Graphics
 Dec 24
  • Read Game Engine Toolset Development
    • Chapter 1: What is a tool? What is a Toolset?
    • Chapter 2: Why use C# Why use .Net?
    • Chapter 3: Examples of commercial Toolsets
    • Chapter 4: Everything starts with a plan
    • Chapter 5: Development Phases of a Tool
 Dec 25
  •  Read OpenGL Super Bible chapters 1-5
 Dec 26
  •  Read AI Game Development: Synthetic Creatures with Learning and Reactive Behaviors
    • Chapters 1-5
Dec 27
  • Create a static library to house re-usable cgt functions I created
    • moved from the game into the library
    • The game still works fine 
  • Created a dynamic library
  • Refactored game to use new libraries
  • Re-read OpenGL Super Bible chapters 1-4 
    • Created Understanding-OpenGL apps:
      • OpenGL1 - base OpenGL App
      • OpenGL2 - Basic shaders
      • OpenGL3 - gl_VertexID
      • OpenGL4 - Triangle with gl_VertexID
      • OpenGL5 - Simple vertex attribute update
      • OpenGL6 - passing variables between shaders
      • OpenGL7 - interface block variables
      • OpenGL8 - tessellation
      • OpenGL9 - gl_FragCoord
      • OpenGL10 - Fragment Shader interpolates
      • OpenGL11- Empty compute shader
Dec 28
  • Created Understanding-OpenGL apps:
    • OpenGL12 - Basic Buffers
    • OpenGL13 - glMapBufferRange
    • OpenGL14 - filling vertex attributes from a buffer
    • OpenGL15 - filling multiple vertex attributes
    • OpenGL16 - interleaved vertex buffer 
    • OpenGL17 - Uniforms
    • OpenGL18 - Unform Blocks
Dec 29

Comments powered by CComment