OdeFu

Composite Oriented Programming Part 2

2008-12-15T14:49:00.002+02:00

I made a slightly more complicated version of the hello world example. This time I made two composite implementations of a Speaker interface.


public interface Speaker
{
 public void setSpeech(char[] speech);
 
 public char[] speak();
}

Then I changed how the data is handled as I didn't want two different templates, HelloData and ByeData. So I made a PropertiesMixin template which contains a simple way to set and get properties as char[]s.


public template PropertiesMixin()
{
 private char[][char[]] properties;
 
 public void set(char[] name, char[] value)
 {
  properties[name] = value;
 }
 
 public char[] get(char[] name, char[] defaultValue = null)
 {
  if (name in properties)
  {
   return properties[name];
  }
  return defaultValue;
 }
}

This can be used to add properties support to a class. There is room for improvement, for example some how use the tango.text.Properties class to save and load the properties.

Then the real meat are the new HelloMixin and ByeMixin, which handles the heavy lifting.


public template HelloMixin()
{
 private static const char[] HELLO = "hello";
 
 mixin PropertiesMixin;
 
 public void setSpeech(char[] speech)
 {
  set(HELLO, speech);
 }
 
 public char[] speak()
 {
  return get(HELLO);
 }
}

public template ByeMixin()
{
 private static const char[] BYE = "bye";
 
 mixin PropertiesMixin;
 
 public void setSpeech(char[] speech)
 {
  set(BYE, speech);
 }
 
 public char[] speak()
 {
  return get(BYE);
 }
}

I've mixed in the PropertiesMixin for both of them, and then implemented the Speaker interface functions using properties. We could even have a default speech very easily, if needed.

The composite classes are very simple as they do not contain any functionality whatsoever.


public class HelloSpeaker : Speaker
{
 mixin HelloMixin;
}

public class ByeSpeaker : Speaker
{
 mixin ByeMixin;
}

I've put the setting of the speeches in the main function of the program, where the composites are created, to better demonstrate the usage of the Speaker interface.


public void main()
{
 Speaker hello = new HelloSpeaker();
 hello.setSpeech("Hello, World!");
 Stdout(hello.speak()).newline;
 
 Speaker bye = new ByeSpeaker();
 bye.setSpeech("Bye, World!");
 Stdout(bye.speak()).newline;
}

I'm pretty impressed about how easy it is to implement complex objects using mixins. Next I need to look into a more complicated version. Something like Fredrik Kalseth has done here.

Until then you can find the new code here.

Composite Oriented Programming

2008-12-15T11:12:00.002+02:00

Ok, so I found a new buzzword; Composite Oriented Programming. I first heard it from Thomas Biskup. He wrote about it on his JADE-blog, here. From there I started reading about COP on qi4j.org. I haven't completely understood it, but so far it seems to be quite nice buzzword.

So I wrote a small hello world sample in D using templates. Got it working after a while with the help of downs and Bill Baxter, on #D and D.learn respectively.

You can find the code here.

I'll go over it here now.

First we have a template to hold out data, namely helloStr:


public template HelloData
{
    private char[] helloStr;
}

Next we define the action or function for the whole composite. I don't remember what this is in COP-speak.


public interface HelloSpeech
{
    public char[] sayHello();
}

Then we implement the above function in HelloSpeaker.


public template HelloSpeaker
{
    mixin HelloData;

    public char[] sayHello()
    {
        return helloStr;
    }
}

So we mixin the data template, so we can return the helloStr from sayHello. Notice that we don't need to import the actual interface for sayHello.

Then we will create the actual composite.


public class HelloWorld : HelloSpeech
{
    mixin HelloSpeaker;

    public this()
    {
        helloStr = "Hello, World!";
    }
}

Now we have a concrete class that implements HelloSpeech. If you look at the code here, you notice that we've had to import the HelloData module. This is as far as I can see the only downside so far.

We have now nicely removed the implementation for sayHello to their own modules. This is a very small example, but I can see it to be quite useful with bigger systems and with more interfaces.

Now just add an interface for setting the value for helloStr and creating an implementation for it, then this would be complete. The helloStr could be hidden completely behind a getter/setter-pair.

Small Update

2008-09-08T13:58:00.002+02:00

It seems that I won't have much free time in the future either, Ive decided to completely stop even thinking on doing any of the old NeHe tutorials anymore. Besides anyone can get a pretty good idea of how to do them from those that I've already done and do the ones they want. It's good practice that way too. =)

I'll probably do any new tutorials for the new basecode, if ever there will be any.

My next D project or journey will be to familiarize myself with Hybrid and Dog. I've got a few ideas on what to do with them. But time will tell. I'll write anything worthwhile here.

NeHe Update

2008-06-30T14:22:00.003+03:00

There's been some activity on the NeHe site recently. They have launched a wiki, and are planning on moving the old stuff from the website to the wiki. There is also new versions of the new lessons on the wiki. For some reason they rewrote the basecode and the first three lessons. The beta version wasn't that bad. On the plus side the code is much simpler, so they can extend the it later.

I've ported the new lessons to D. Why else write this post. =) I didn't do it 1:1, as in my opinion there are too much c++(bad design) in them. I kept them mostly as they were, but fixed most of the more glaring problems in it, at least in my opinion. I'm still thinking on making them more D'ish/generally better. I'll decide probably after more lessons are available, and we'll see where they are taking the basecode.

You can find the relevant information about the source code on the google code project page.

GLFW Derelictified

2008-04-04T09:06:00.002+02:00

I started looking again at the GLFW library yesterday. I do really like the API. Somehow it's nicer than SDL's. The only thing missing is a better support for image loading.

I remembered using a D binding for GLFW once and tried to find it. In the end I found it in the Schooner project in dsource, but it hasn't been updated in a long time. Plus it uses Phobos. I thought about trying to update and convert it to Tango for about a second or two, and then decided to do Derelict bindings for it instead. They are easier to maintain, but the downside is that you need to lug around the shared library for it.

I used the latest release of GLFW (2.6), and only tested things with a simple test application on Windows XP.

So if you like the framework go grab the D bindings from here.

Windows users please read the readme file.

NeHe Lesson 25: Morphing & Loading Objects From A File

2008-03-20T21:44:00.002+02:00

Somehow I found time to do the next one too. This was pretty fun one as well. I love the morphing effect. And I like the simpleness of the code compared to the c/c++ version. :)

I left out the Object struct as the D version didn't need the field for the number of vertices, and then there wasn't anything else left than the array itself. So now there are just arrays of Vertices.
I also put a static opCall in the Vertex struct, although it isn't strictly necessary.

And as with the lesson 10, the datais imported into the binary at compile time, so no file i/o is needed.

You can check it out here.

NeHe Lesson 24: Tokens, Extensions, Scissor Testing And TGA Loading

2008-03-20T09:45:00.002+02:00

A new lesson done. Yay! I should have called this one the Extensions and Scissor Testing lesson, because I left the TGA stuff out and the token thingy was replaced with a call to split. But I wanted to keep to the pattern with the lesson titles.

I changed the code to initialize the texts only once and not every draw-call. Better that way. Otherwise there isn't that much new stuff. Then glScissor call is pretty simple.

See the code here.

NeHe Lessons Updated

2008-01-22T22:41:00.000+02:00

It's been a while. Life has been busy. Haven't had the time and energy for coding at home. Although I still follow the happenings in the D world. And because of that I've updated all the NeHe lessons to work with the latest version of Tango. I'll try to get more done during the coming spring, but can't promise anything as there are lots of things happening at the moment.

Happy new year and all that. =)

NeHe Lesson 23: Sphere Mapping Quadrics In OpenGL

2007-10-08T09:17:00.000+02:00

The 23rd lesson is finished. Nothing special on the D-front in this one. Go read the the text here.
Then grab the code from here.

NeHe Lesson 22: Bump-Mapping, Multi-Texturing & Extensions

2007-10-03T13:06:00.000+02:00

Oh, it's been a while from my last post. Been busy with the life outside of computers.

The next lesson has been done for a quite a while now, except for a small bug. When displaying the cube with mip-mapped textures the texture is not drawn for some reason. Today I got the drawing working, but it introduced a another problem. The fix was to remove the texture flipping and rotating code from the initGL function. This has the effect of displaying the logos upside down and as mirror images, but now the mip-mapped cube is displayed correctly.

If any of you has any idea how to fix this small problem, let me know so I can fix it. Otherwise I'll move on to the next lesson.

The NeHe's lesson can be found here.

Btw, I've kept the broken mip-map version in the repository as I think it's a smaller problem than upside down logos.

NeHe tutorials ported to D news post

2007-08-20T15:42:00.000+03:00

There is a news post of D in general and my NeHe lesson ports on http://nehe.gamedev.net. =)

Direct link: here.

NeHe Lesson 21: Lines, Antialiasing, Timing, Ortho View And Simple Sounds

2007-07-24T11:07:00.000+03:00

It's time for a new lesson. This time NeHe has made a simple game for us to enjoy.

First before doing anything else make sure that you have SDL_Mixer installed on your system, as we're going to use it to play back the music and sound effects.

Next is a small improvement I made over the C version, is the use of the enemies-array. The original lesson uses it as a static array, but I made it dynamic. This way we can use the D's great foreach-loop to go over every enemy in the level.

/// Enemy Information
GameObject[] enemies;

....

/**
* Resets the player character and all the enemies.
*/
void resetObjects()
{
 player.x  = 0; // Reset Player X Position To Far Left Of The Screen
 player.y  = 0; // Reset Player Y Position To The Top Of The Screen
 player.fx = 0; // Set Fine X Position To Match
 player.fy = 0; // Set Fine Y Position To Match

 // Create the enemies for the next level/stage
 enemies = new GameObject[stage * level];
 // Loop Through All The Enemies
 foreach (inout enemy ; enemies)
 {
  // A Random X Position
  enemy.x  = 5 + rand.next() % 6;
  // A Random Y Position
  enemy.y  = rand.next() % 11;
  // Set Fine X To Match
  enemy.fx = enemy.x * 60;
  // Set Fine Y To Match
  enemy.fy = enemy.y * 40;
 }
}

As you can see there, we use the new operator to create just the number of enemies for the level/stage. Then we can loop over the array with foreach and be certain that we always have the correct number of enemies.

In the module constructor the parameter to SDL_Init has changed to SDL_INIT_EVERYTHING.

if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
{
 throw new Exception("Failed to initialize SDL: " ~ getSDLError());
}

This is needed for audio. There are other options, which you can read about here.

The module destructor is responsible for freeing the textures and SDL_Mixer's buffers.

static ~this()
{
 // Clean up our font list
 glDeleteLists(base, 256);

 // Clean up our textures
 glDeleteTextures(NUM_TEXTURES, &textures[0]);

 // Stop playing the music
 Mix_HaltMusic();

 // Free up the memory for the music
 Mix_FreeMusic(music);

 // Free up any memory for the sfx
 Mix_FreeChunk(chunk);

 // Close our audio device
 Mix_CloseAudio();

 SDL_Quit();
}

That's about it. Everything else is hopefully easy enough to understand, so just dig in.

NeHe Lesson 20: Masking

2007-07-04T14:37:00.000+03:00

Puuh! Full 20 lessons now. =) Almost half of them. With luck I'll get them all by the end of the year. ;)

This lesson doesn't bring anything special on the D-table, but the lesson itself is interesting, so go read it.

I separated the texture loading into two functions, because there is 5 different textures which need to be loaded.

The source can be found here.

NeHE Lesson 19: Particle Engine Using Triangle Strips

2007-06-26T16:45:00.000+03:00

I've been sitting on this one far too long. It's a nice tutorial on particles and NeHe has written a long explanation for it here. There shouldn't be anything new on the D front that warrants an explanation. If you disagree then leave me a note and I'll go over it.

The source can be found here.

The OpenGL Pipeline Newsletter Volume 004

2007-06-21T09:49:00.000+03:00

The newest edition of the Pipeline has been released. I've been reading it and there was a small paragraph which contains information about the recent debug stuff that has been going on in the D-OpenGL-land.

Here's the part:

More context creation options are available. In the previous edition of OpenGL Pipeline I described how we are planning on handling interoperability of OpenGL 2.1 and Longs Peak code. As a result, the application needs to explicitly create an OpenGL Longs Peak or OpenGL 2.x context. To aid debugging, it is also possible to request the GL to create a debug context. A debug context is only intended for use during application development. It provides additional validation, logging and error checking, but possibly at the cost of performance.

At last OpenGL itself will assist the poor programmer in debuggin.

DebugGL

2007-06-15T16:48:00.000+03:00

After reading Daniel's excellent post here, which by the way was something I've been thinking about a little. Although not to the extend that Daniel has. But he got me working on the foundation he made in the post, and the first results can be seen here.

And thanks to h3r3tic and larsivi on #D.Tango. Without you I couldn't have done this. :)

New Page

2007-05-16T16:12:00.000+03:00

I've finally made use of the OdeFu projects main page. There is now a table of the NeHe lessons that have been done, with links to their respective sources. I've also added a link to the page to my bookmarks on the right side.

NeHE Lesson 18: Quadrics

2007-05-16T12:19:00.000+03:00

The 18th lesson gives a tour of some of the GLU functions and how to display different shapes with them. The shortish text can be read here. There shouldn't be anything special.

The D code is here.

NeHe Lesson 17: 2D Texture Font

2007-05-15T10:00:00.000+03:00

This lesson should contain code for those who are interested in drawing text in an OpenGL window. After reading the tutorial text and getting the hang of it, you might want to implement support for AngelCode's Bitmap Font Generator. It's a nifty tool for making bitmap fonts for your games.

Here's the D code for the lesson.

NeHe Lesson 16: Cool Looking Fog

2007-05-14T20:33:00.000+03:00

This lesson doesn't bring that much new to the table. The fog functions should be pretty self-explanatory, but read what Chris Aliotta has to say about it here.

The D version is here.

About Lessons 13, 14 and 15

2007-05-14T18:46:00.000+03:00

I've decided that I'm not going to cover the next 3 lessons(13, 14 and 15). They contain platform specific code, and I'm not into that kind of stuff. The lesson 17 contains a way to show text in a platform independent way for those that want to see text in an OpenGL application.

The New NeHe Tutorials

2007-05-12T14:10:00.000+03:00

Some of you are probably aware that a beta version of the new NeHe tutorials have been released earlier this year. There is a window backend for all the lessons which contains window creation and a simple framework for running the lesson applications. Then they have written 5 lessons already.

I've been writing them in D for some time now. When ever I've had time. They are now done and working nicely. I'm not going to go over them yet, as the real tutorials haven't been released yet, but you can browse the sources here, or if you want to try them out just checkout them. I've written DSSS configuration files for them, so you can just do 'dsss install', for NeHeWindow, and then 'dsss build' for the lessons.

And now back to your regular old NeHe tutorial studying.

The New NeHe Lessons

2007-04-18T14:06:00.000+02:00

I just noticed that a beta release is available for the new NeHe lessons. You can see the release notes here.

I took a look at the code, and apart from the horrible naming convetion and the fact that they still use C++, it looks pretty good. So I've decided to do a port of them to D, but there is a catch:

* I'll only port the SDL backend
* I'll "fix" the naming convertion to something more to my tastes
* I don't know when I have the time to do this

Probably the best place to start is from the window backend so that I can get something useful done as fast as possible.

Stay tuned.

NeHe Lesson 12: Display Lists

2007-04-18T08:24:00.000+02:00

Ok, didn't get to test this on Windows, but it should work as the lesson doesn't contain platform specific code.

First off there's an example on how to initialize a static multi-dimensional array:
(In case you didn't know already how to do it.)

/// Array For Box Colors
GLfloat boxcol[5][3] =
[
   // Bright:  Red, Orange, Yellow, Green, Blue
   [1.0f, 0.0f, 0.0f], [1.0f, 0.5f, 0.0f], [1.0f, 1.0f, 0.0f], [0.0f, 1.0f, 0.0f], [0.0f, 1.0f, 1.0f]
];

In the module constructor we have something new.

// Enable key repeating
if ((SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL)))
{
   throw new Exception("Failed to set key repeat: " ~ getSDLError());
}

Here we enable SDL to repeat key presses if you keep a key down. I've used SDL's default values for the arguments.

There isn't really anything special about the rest of the code, so grab a cola and go read what NeHe has written on the subject, here.

Here's the link to the source.

Linux Update

2007-04-17T12:58:00.000+02:00

I wanted to leave a quite note on the Linux support. I tested all the current lessons on a Linux box with the following setup: Tango RC1 with DMD 1.012 and Rebuild 0.18. All of the worked fine. Found only couple typos in image filenames. Wrong case.

Plus I've pretty much done lesson 12 and I'll put it up as soon as I get home.