Development Journal of a Raytracer - Game

Track Texture - 8

nospam@example.com (Josef Meixner) — Thu, 18 Mar 2010 21:37:20 +0100

This week I managed to implement the checks for the track slices. And I started on the algorithm to find the points, where the slice changes. I haven't come far with that, but the check-function at least gave me some ideas of how to continue. The biggest problem is the flexibility I have built into the format. I think I should be able to write the function next week, at least I hope so. I slowly would like to get on with this thing.

Track Texture - 7

nospam@example.com (Josef Meixner) — Thu, 11 Mar 2010 22:05:49 +0100

Last week I didn't do anything, but at least this week I have started on the code to create the geometry to handle the track textures. The first function I need is to define where I have to put the slices. When I started to add it, I noticed there was something missing, I had not added some form of sanity checks, so even completely useless definitions could make it into the algorithm.

To make it at least a bit easier I decided to first check the slices. There are a number of conditions which have to be met. E.g. there has to be at least one slice, at least one slice has to be flexible in width and if there are fixed alignment positions they have to be in a rising sequence. Also the first slice has to either be anchored to the position 0 or at least be able to fill the track all the way to the left edge. The same is true for the last slice, it has to be able to fill the track to the right edge.

I hope, I can implement all the checks next week and perhaps even start on the distribution algorithm.

Track Texture - 6

nospam@example.com (Josef Meixner) — Thu, 25 Feb 2010 21:51:04 +0100

Today I only refactored the code I already had. I had tried to come up with a better way to store the track textures, but I didn't find any. So I simply moved the once internal enumerations and classes from the SAX-parser and made them top-level classes. So now I should really have all the information ready and should be able to implement the code to turn the track information into properly textured geometry.

Track Texture - 5

nospam@example.com (Josef Meixner) — Thu, 18 Feb 2010 22:05:32 +0100

I had no time today, so only a small change. I started to add the class which will handle the application of the track textures to the track segments. It currently is completely empty, but I have already added it to the SAX-parser. So next is adding some functions to set the data, some functions to format it and then the first part is done. The second part will consist of the code to create geometry for and apply texturing information to the track segments. That will again remove some functionality from the track class making that one simpler.

Track Texture - 4

nospam@example.com (Josef Meixner) — Thu, 11 Feb 2010 21:53:38 +0100

I think I have implemented the SAX-parser for the track textures (not tested yet). So next is creating a class which will store them. This class will get the slices (small parts of the width of the track), calculate some values to aid in creating the textures and then get a function which creates a track segment. As I expect the track segments to often use the same track texture for quite some time, the evaluation will have to try to create as few objects as possible. It would be possible to create one quadrangle per track segment and slice, but I doubt it would be efficient. So I will track, if the last segment used the same track texture and then the class is expected to add to the objects created before instead of creating new ones.

Track Texture - 3

nospam@example.com (Josef Meixner) — Thu, 04 Feb 2010 21:50:19 +0100

Nothing much to write about today, I have managed to pass the DTD to the parser and it found some bugs (e.g. I had misspelled "EMPTY" as "Empty"). Then I added some code to handle the first tag and extended the documentation of the parser class. I also had to extend the DTD slightly, I had forgotten a small detail. The track textures are built from a number of slices, some have a fixed width, others just fill some space between other slices. I need to be able to define alignment of fixed width slices to be able to for example put one exactly into the middle. So I added two attributes, one defining what part of the slice to align to which percentage of the track width.

I hope I now have all the attributes and can finally just implement the parser and then the object to receive the specifications. After I have also modified the program so it can actually apply the specifications I will have to define (and draw) a more complex example of a track texture.

Track Texture - 2

nospam@example.com (Josef Meixner) — Thu, 28 Jan 2010 21:48:14 +0100

Finally a day where I did get some stuff done. I have finished defining the DTD for the track texture files. I have also created a very simple file containing only a single very simple track texture (basically it will result in the same texture I have been using all along). And I have started to write the SAX-parser to read the file and turn it into Java-objects.

Next week I will try to get as far as possible in implementing the parser. I don't know if I can finished it, but it is possible, the file format isn't very difficult. Then I will have to write the functions which create the track segment so they match the specification and apply the textures.

Track Texture - 1

nospam@example.com (Josef Meixner) — Thu, 21 Jan 2010 22:09:03 +0100

Today I started on the next issue. I want the track geometry and the track textures to be separate. That way I can define a track and don't have to watch that the vertices match the textures. The same is true of the textures. What has to be done is to map the textures to the track, eventually creating additional geometry.

I have started this by starting to define a DTD for the file containing the definitions. A track texture will be made out of multiple slices. E.g. there could be five slices, which define the left edge, the left side, the center, the right side and the right edge. The edge and center slices would be of a fixed width to make it possible to define graphical elements, the left side and right side slices would basically repeat to fill the space to handle different track widths. The program would need to create five vertices at the start and end of a segment and create five quads. Each quad would then get a texture mapped to it and the texture coordinates and wrapping modes would be set so that the texture fills the track.

Interpolating Up Direction

nospam@example.com (Josef Meixner) — Thu, 14 Jan 2010 21:49:04 +0100

The original reason to start the new track segment class was, that the code had gotten so complex, that it was hard to add a little feature. I had the problem, that the slope up the hill used straight track segments which were so long, that you could see the car adjusting when you moved from one of the segments to the next. I now simply added an interpolation to the up direction and that problem has completely vanished. Instead I have gotten another one, it seems I haven't calculated the up direction at start and end correctly, the inclination now seems to jump. But already it is easier to find and fix those issues, as the code has been refactored into a number of function and that made it quite a bit simpler. So next week I will try to fix the inclination and then will start with some texturing issues.

New Track Class - 5

nospam@example.com (Josef Meixner) — Thu, 07 Jan 2010 22:34:57 +0100

Today I finally finished the new track class. It is now able to do everything the old one did. The code should be a bit more maintainable as well. So next I can finally start to add the new things, e.g. interpolation of the up direction.

New Track Class - 4

nospam@example.com (Josef Meixner) — Thu, 17 Dec 2009 21:43:50 +0100

I am so terribly slow. The new track class should now have all the information so I can substitute it for what I use currently. It won't be better at first, it just has to work. So next I can truly start to add it to the function to find the intersection points.

New Track Class - 3

nospam@example.com (Josef Meixner) — Thu, 10 Dec 2009 21:56:28 +0100

I again didn't have a lot of time, so only a tiny incremental change. The new class is now used by the track-class, it stores its values into it. So next I have to see, what information is missing and extend the class so I can start to use it to calculate where the car is and how to align it.

Currently a lot of information is calculated again and again and again, I hope storing it will help to speed up the program and also make complexer algorithms workable. The current solution is not really good, but already too complex.

New Track Class - 2

nospam@example.com (Josef Meixner) — Thu, 03 Dec 2009 22:01:07 +0100

I continued work on the new class to handle the tracks. I haven't gotten very far again, but next week I can start to actually fill the objects of that class with data. Then I have to add some functions to evaluate the data and then I can start to throw away old code and make the thing simpler. It will be some time until I will be able to actually implement new features.

New Track Segment Class - 1

nospam@example.com (Josef Meixner) — Thu, 26 Nov 2009 21:45:03 +0100

Today I started to add a class which is supposed to handle one single segment of the track. But I have just started and already doubt, if it is right what I am doing. Currently a segment is a very short, straight piece of track. Every curve and even longer straight parts are segmented into multiple parts. For the curves I need it for geometrical reasons, for the straights for texturing. I also need many parts to form slopes.

Perhaps it would make sense, to define a structure even higher up in the hierarchy which breaks down the segments when needed. It would make defining tracks much easier. But there is also a good argument against it, the current way to define the tracks is only for testing, in the long run I want to draw them in the editor and then I don't care, if the export writes a data set for a curve or 20 for the segments to form the curve. So it might be a nice structure, but it is not clear if it is a good idea to even implement it. And I think, at least currently I should continue the low level structure.

Planning next Steps

nospam@example.com (Josef Meixner) — Thu, 19 Nov 2009 21:36:54 +0100

I had the intention to finally interpolate the up vector of the sloped parts of the track. But when I looked at the data structure I quickly decided it wouldn't be right. The data structure I use to describe and handle the track is not good. I have never sat down and actually created a comprehensive structure, so I have three structures. The first is the list of track points I use to specify the track. It contains a point, a left and a right width and the inclination, at least currently. The second "structure" is the object I pass to the scene graph to render the element. I don't use it in any calculation afterwards. And finally I have a list of planes to do the intersection tests.

I think I should create a structure which contains track segments. That would make some calculations easier and I could store information I continuously recalculate. Also it would make calculations independent from the data structure I use to specify the track. I will have to extend that structure to contain additional information like what texture to use or if I want something like a crash barrier created at the sides. I could also separate the visual width from the width usable by the car so that it could leave the track a bit.

Also I still need to make the calculations to find where the car is located more efficient. It is very wasteful to search for it on the whole track. With vehicles you generally expect it near the spot you last saw it, they don't vanish and reappear on different parts of the track. And I think it is generally a good idea to put some of the calculations into its own class.

So I will next refactor the code. And then gradually add new features, first the interpolation of normals and then fitting the texture better. Currently each segment gets the full texture, irrespective of length. This is quite expensive (as I have to use many short segments instead of one long segment) and looks strange when segments of differing lengths are used. I also want to add a guard rail, but I would like to do that by specifying some values and let the program create the geometry.