DEV Community: Pankaj Doharey

OpenGL Game in Clojure CLR (Mono/.Net) - Part3 (Handling Input)

Pankaj Doharey — Tue, 30 Jul 2019 18:39:48 +0000

Handling Keyboard input and Game loop.

Most 3D applications like games run in a game loop where are series of events modify the game and OpenGL state to draw things on screen. One such important event is user input event. OpenTK GameWindow class has
one such method called OnUpdateFrame which as the name suggest gets triggered every time the frame is rendered.

Right now it is getting it isnt doing anything since it is in the parent class and we are dealing with an instance of GameWindow.

What we really need to do is inherit the GameWindow and override the OnUpdateFrame methods and capture the window events as they happen.

In order to do so there are primarily 3 mechanisms in in Clojure to deal with Inheritance. gen-class, proxy and reify. But since we are dealing with the instance of the inherited class reify cannot be used.

Since i aim to keep the tutorial largely functional my tool of choice is proxy.

So let us modify our core namespace and create a proxy object and override the OnUpdateFrame method like so:

As you can see OpenTK.GameWindow constructor has one more overloading function which can take four parameters, width,height, GraphicsMode and Title of the window. For now we are sticking with default graphics mode thus a nil is passed.

If you compile and run this program it will print the event object to the terminal with every refresh.

Since, much of our game logic will go inside the OnUpdateFrame method it will be better to dispatch the events to a separate on-update-frame function to handle the inputs and keep only the override definition in the proxy object like so:

Lets us compile and run this application:

You see every time we press the escape key it would print Escape Pressed on the terminal multiple times because the refresh rate of the window is so fast that it ends up capturing the escape key press event multiple times.

For now we want the Escape key to exit the current window. But the on-update-frame does not have a handle of the proxy instance.

There is a way though C# has a special keyword this which gives a handle on the current execution context. Thus we would modify our OnUpdateFrame override and on-update-frame function and pass this as a parameter. Then we can simply call (.Exit this) in the input let block.

Let us modify our code like so:

This exits the window when you press escape.

Next we will refactor and properly organise the code, and learn how to draw shapes on the screen ...

To be continued ...

Part 1 - The Setup
Part 2 - The Game Window

OpenGL Game in Clojure CLR (Mono/.Net) - Part2 (The GameWindow)

Pankaj Doharey — Mon, 29 Jul 2019 18:06:31 +0000

Importing OpenTK assembly.

We will begin with importing the OpenTK dll files into our source.

Update the core.clj with the following code:

In the above code we just added the relative path of OpenTK.dll, a .net assembly wrapper for OpenGL.

The we import the necessary drawing and input libs and classes.

Once the necessary classes are imported we will begin with creating an instance of GameWindow class and àssigning a cornflower blue color to the background.

Important thing to note in the above is (.SwapBuffers game) because OpenGl is double buffered so while one buffer is showing on the screen other can be used to be drawn to.

Once a drawing action has been accomplished we need to instruct the Graphics card to swap the visible buffer with the buffer drawn to this makes the new buffer visible and hides the previous one. Double buffering is essential in creating the illusion of animation by drawing to alternate buffers and swapping them.

Also (.Run game 30.0) is essentially telling OpenGL to refresh the screen at 30 FPS (30 Frames per second)

Now let us compile this program using:

$ ./build.sh c
Compiling core to build/ -- 1796 milliseconds.

And then run it using :

$ ./build.sh r

This should result in a sunflower blue coloured window:

So now we have a simple OpenGL Window Running, but it doesnt handle any inputs as of yet. In the next series lets implement ways to handle keyboard input to close the window.

All Posts:

Part 1 - The Setup
Part 3 - Handling Input

OpenGL Game in Clojure CLR (Mono/.Net) - Part1 (The Setup)

Pankaj Doharey — Mon, 29 Jul 2019 15:00:01 +0000

Introduction

I gave been thinking about writing 2D/3D OpenGL games in clojure for sometime. When it comes to developing games you have many choices with clojure. You can develop games for webgl using clojurescript + Webgl/Canvas Api or any 2D/3D javascript library of your choice. You can also use JVM and its many OpenGL libraries like LWJGL.

There is a third choice if you want your games to be highly portable you can choose a game engine with C# bindings. Or better yet use Clojure-CLR to develop on the .Net framework. This is a first tutorial in hopefully a series of tutorials targeting the third option.

Since C# on .Net is the most popular choice of game development for a large number of Indie and Small studios i think it would be an excellent choice to use Clojure CLR to develop cross platform games on the Mono/.Net Framework.

The tutorial is geared towards development on a macOS with mono/.Net but the it should be directly applicable on Ubuntu/Linux or Windows.

Setup.

In order to start developing Clojure CLR application on a mac we need to install Mono which is an open-source implementation on Microsoft .Net Framework on Linux and Mac.

The simplest way to install mono on a mac is using the mac universal package from here https://www.mono-project.com/download/stable/

This will also install nuget, which is a package manager to fetch .Net packages.

Once Mono is installed, which you can check by typing the following on the terminal.

$ mono --version
=> Mono JIT compiler version 6.0.0.313 (tarball Fri Jul 19 16:02:10 BST 2019) Copyright (C) 2002-2014 Novell, Inc, Xamarin Inc and Contributors. www.mono-project.com

Install Clojure-CLR

Now let's install clojure-clr, though you are free to try official Clojure-CLR this tutorial uses a particular fork of Clojure-CLR maintained by Ramsey Nasser and co of Arcadia Technologies, since that is the Clojure-CLR i found most success with instead of the official binaries.

$ git clone git@github.com:arcadia-unity/clojure-clr.git
$ cd clojure-clr/
$ git checkout unity
$ make

If the compilation is successful this should produce a Release directory in bin/4.0/Release/. Now you should add this directory as an entry to CLOJURE_LOAD_PATH environment variable in ~/.bash_profile so that we can write build scripts to find and use clojure-clr binaries.

export CLOJURE_LOAD_PATH=$HOME/Projects/clojure-clr/bin/4.0/Release/

It would also be useful to add the following aliases to ~/.bash_profile
#Clojure clr repl.
alias cljclr="mono $CLOJURE_LOAD_PATH/Clojure.Main.exe"
#Clojure clr compiler.
alias cljcomp="mono $CLOJURE_LOAD_PATH/Clojure.Compile.exe"

Also do remember to source the bash profile: $ source ~/.bash_profile.

The above aliases are clojure-clr repl and compiler respectively.

Invoking $ cljclr on the terminal and you would be greeted with a clojure repl.

Clojure 1.10.0-master-SNAPSHOT user=>

You can run clojure commands on the repl now.

user => (+ 1 2 3) 6 you can press Ctrl+c to exit the repl.

The last thing we need to install is a C# bindings for OpenGL, one such wrapper in OpenTK.

we will begin by creating a directory structure for our app.

$ mkdir -p ~/Projects/cljopentk/extern
$ mkdir -p ~/Projects/cljopentk/build
$ cd ~/Projects/cljopentk/extern
nuget install OpenTK -ExcludeVersion

this should download the latest OpenTK bindings into the extern directory. An ls into the directory should show the following dlls.

$ ls extern/OpenTK/lib/net20/
>> OpenTK.dll OpenTK.pdb OpenTK.xml

now lets create a core.clj file in the parent directory cljopentk.

$ cd ..
$ touch core.clj build.sh

Build Script.

Make the build.sh as executable,

$ chmod +x build.sh

and paste the following code in it.

Create DLL softlinks for program execution.

$ ./build.sh link

Hi World!

Now let us write a small clojure "hi-world" program.
Paste the following code in the newly created core.clj.

Compile the program using the build script.

$ ./build.sh c

Run the program with.

$ ./build.sh r
Hi World

Now that we have a basic setup to compile clojure-clr programs we can continue with developing the OpenTK/OpenGL game.

Since you are still reading perhaps you want to checkout the next post in this series :

All Posts:

Part 2 - The Game Window
Part 3 - Handling Input