Progress

xx/xx/2000 - A new demos section is available, with a recent working version of the jTrace applet and a number of model files for you to try out.

I have found there are some problems in internet explorer when the applet is scrolled off the top of the page, this can be fixed by downloading the latest version of the java 2 plugin.

xx/xx/2000 - Object group manipulation has been implemented, and a couple of minor syntax changes to the language have been implemented, (csgnode replaced with node and csgstart replaced with startnode) to make it more intuitive. The Language Definition has been updated to reflect these changes.

xx/xx/2000 - The renderer is now a very almost complete a short todo list remains. A new Images page is up with pictures created by the renderer.

New features :

• Greatly speeded up cylinder and cone rendering
• Implemented hyperboloid
• Improved Lighting efficiency
• implemented basic transparency (no refraction)
• implemented reflection

Known Issues :

• Camera class doesn't work when moved from Z axis
• Refraction not implemented
• Plane primitive not implemented
• User Interaction not implemented at all

Planned extensions :

• Object Grouping for easier shape manipulation
• Texture Mapping
• Client Side Texture generation
• More powerful and free-form language

xx/xx/2000 - The renderer is in a working state and with it I have included a parser. This language is likely to change but is good enough for current use.

The definition of this language can be found here or by following the new 'Lang definition' link in the menu.

xx/xx/2000 - The renderer is almost complete with just a few lighting bugs to work out and transparency to be implemented. here are a few pictures from the renderer.

Union

Intersection

Subtraction

Example

xx/xx/2000 - Basic untested implementations of the classes have been completed and I am currently goign through the process of testing and improving them. I am also researching how to store the information needed to implement the interactivity of the project both in the input file and internally.

Another decision that is currently being considered is how complex the interaction can be. There are 2 basic methods available.

a) The user defines complete models and can have a user 'click' either follow a link or change the displayed model

b) The user defines alterations to the model and a click to carry out an alteration or follow a link

The second method is generally harder to do for both the user and the program - but the alterations could be more advanced, even including logic and control statements greatly increasing the power of the program such that entire systems such as chess could be implemented in it

xx/xx/2000 - The basic class structure has been finished though it is likely to change as I discover problems with the implementation. A basic description of the class structure can be found here

xx/xx/2000 - On trying to modify the basic renderer to render a cube I discovered the algorithm I had for this needed the ray to be pre-rotated which couldn't be done easily with what I had. The current single class implementation also couldn't implement a CSG tree either. As a result I abandoned the basic renderer and started to plan out using class diagrams, and write out the method definitions for those classes, needed for a more flexible renderer.

xx/xx/2000 - To get an idea of the speed of a raytrace renderer and to investigate implementation problems, I started to create a simple 1 class renderer which just had 1 sphere and 1 light. This found some problems. Such as even pre-calculating the picture and then drawing the memory image to the window in java still produced a noticeable flicker, which is ok for static pictures but would have to be solved if the project was to be extended to do animation. The rendering time for 1 sphere and 1 light with ambient, diffuse and specular lighting was found to be insignificant on a high spec machine. i.e. less than 0.1 seconds, below which it was hard to measure.

examples of milestone versions of this basic renderer can be found in Examples

xx/xx/2000 - After choosing Raytracing as a rendering method I looked into algorithms and equations to implement it.

I searched on the internet for equations for various shapes and found that that to reduce the maths needed, I would need to limit the basic shapes to those with a maximum of 2 intersections. i.e cuboid, sphere, cylinder, cone, and the plain.

xx/xx/2000 - There are two main parts to the project, the renderer and the parser. The language to be parsed is needed before the parser can even be considered. Before the language can be designed the capabilities of the renderer that the language has to describe must be determined. So I first must investigate various rendering options

There are two basic candidates:

  - polygonal mesh

  - raytracing

The mesh will be faster but will produce a poorer quality picture. Discribing the model for a polygonal mesh model is significantly harder than for a CSG based model. However on researching the ease of implementation of the methods I have discovered Java3D. This is a 3D API which would make writing the renderer for a polygonal mesh model significantly easier and would probably increase the performance. Even though I feel the benifits of the raytracing method outweigh the speed and ease of implementation of the mesh method and have chosen to use Raytracing.

xx/xx/2000 - The language the project is to be written in will affect the performance and ease of implementation of the whole project. The program needs to run client side otherwise it entirely defeats the point of the project. Due to personal preference and language suitability Java was chosen.