JADENGINE Wiki & Documentation Rss Feed

UPDATED WIKI: Home

Vicente — Wed, 04 Jun 2008 19:20:23 GMT

We are searching for new team members! Read here http://kartones.net/blogs/jadengine/archive/2008/06/04/jad-engine-looking-for-new-members.aspx

Please visit http://www.jadengine.com

for complete details, documentation, and more information relating to the Jad Engine.

UPDATED WIKI: Home

Vicente — Wed, 04 Jun 2008 19:18:49 GMT

We are searching for new team members! Read here http://kartones.net/blogs/jadengine/

Please visit http://www.jadengine.com

for complete details, documentation, and more information relating to the Jad Engine.

UPDATED WIKI: Home

Vicente — Wed, 04 Jun 2008 19:17:43 GMT

We are searching for new team members! Read here http://kartones.net/blogs/jadengine/

Please visit http://www.jadengine.com

for complete details, documentation, and more information relating to the Jad Engine.

UPDATED WIKI: Home

ReedCopsey — Fri, 08 Jun 2007 15:53:27 GMT

Please visit http://www.jadengine.com

for complete details, documentation, and more information relating to the Jad Engine.

UPDATED WIKI: Home

ReedCopsey — Fri, 08 Jun 2007 15:52:24 GMT

Please visit http://www.jadengine.com

for complete details, documentation, and more information relating to the Jad Engine.

UPDATED WIKI: Home

ReedCopsey — Tue, 05 Jun 2007 23:04:57 GMT

Please visit http://www.jadengine.com

for complete details, documentation, and more information relating to the Jad Engine.

June 5th, 2007 - Jad Engine Web Site Moving

http://www.jadengine.com is being moved to a new home. It will point to its new location in 24-36 hours at most. We'll keep using Codeplex for our source control and the releases, but all the documentation will be in the new site.

UPDATED WIKI: Home

ReedCopsey — Tue, 05 Jun 2007 23:04:46 GMT

Please visit http://www.jadengine.com

for complete details, documentation, and more information relating to the Jad Engine.

June 5th, 2007 - Jad Engine Web Site Moving

UPDATED WIKI: Home

ReedCopsey — Tue, 05 Jun 2007 23:02:24 GMT

Please visit http://www.jadengine.com, the main Jad Engine website.

It contains complete details, documentation, and more information relating to the Jad Engine.*

June 5th, 2007 - Jad Engine Web Site Moving

UPDATED WIKI: News Feeds

ReedCopsey — Tue, 05 Jun 2007 22:57:52 GMT

NEWS FEED

IRC Chat Log and comments

Thursday, May 31, 2007 | From Jad Engine Blog

Well, a little later than expected but here it comes the post about our last IRC meeting. First, I would like to thank all the people who attended, Jade users and devs, but I would like to especially thank Borrillis for coming. If you didn't know him, he is the current developer of Axiom and SharpInputSystem.

Why was another engine developer in Jade meeting? Well, the main subject of our meeting was to see what would we do for our next release. We have been working in the engine internals and we have found that several parts are really too hard to improve without a complete rewrite. So we wanted to see how much people could help, and depending on that we would do either minor core changes or a complete rewrite. Even if we missed some people in the meeting because of exams (these dates are really hard for students), we decided in the end to go for the rewrite. That's where Axiom makes sense: a complete rewrite is a very hard affair, so we plan to take things here and there from other open source projects to speed things.

So far our idea is to build our new scenegraph using OpenSceneGraph as a base and study the Axiom renderer and materials system to see how well it would work with Jade's current renderer and EffectBuilder. We also plan on using SharpInputSystem for the new input. We aren't going to reinvent anything if we can avoid it :)

Another of our objectives is to make the engine more ".NETish": currently most engines out there are built in a "C++ way", and while C++ is nice for some things, the .NET way of thinking is pretty different for others. So expect things to be more like .NET in the engine (events, delegates, reflection, and things like that). There's a great deal of code using these features in Pluto, so you can check there and see for yourself.

And well, you can read the chat log in this URL:

http://jadengine.dreamhosters.com/index.php?title=24/05/2007_-_Jade_1.2_Meeting

If you are asking yourself "what's that site?", the answer is that it will be the new Jade site/wiki :) So far it has all the old material (thanks to Reed for setting everything up), but several sections (features, what's coming and FAQs) badly need an update, so we won't be promoting much yet (but it should go live soon).

Jade 1.2 talk (IRC)

Monday, May 21, 2007 | From Jad Engine Blog

We’ve been pretty quiet these last weeks: not many forums posts, no blog posts,… But we have been doing some work related to 1.2 objectives (rework the engine internals). Reed has launched a new project called Pluto (Plugin Toolkit) who is aimed to give plugin support to any .NET app (it’s not tied to Jade although Jade uses it). This will allow us to have a robust support for plugins within the engine and tie the functionality more to interfaces and less to the implementation (so we can swap plugins in the future, for example for music or for physics).

Also, there are 2 new tools around: one is a FTP sync who allows you to sync your data folders with our FTP, so you don’t have to download everything again every time we change a effect file or a texture for the tutorials. Getting the data in the correct place and with the correct configuration.xml file continues to be a problem most new people usually have, so let’s hope this tool makes it easier. The other tool is an attribute/documentation viewer: Pluto has added a new attribute called CompletionStatus that tells you the completion status of a class, method,… (clever naming ;)). This attribute it’s very useful for us as we can have a general overview of the engine classes and namespaces and see where more work is needed or what parts are completed. Now the thing is adding this attribute to all the engine classes, but we will come to it.

But the biggest changes on the engine are yet to come and we have been talking about them a lot in the last week. We are going to hold a meeting on IRC on Thursday 24^th at 10 PM GMT +1, so feel free to come there and tell us what do you think of the changes we are planning. We would like to have your feedback on what we talk on Thursday because it will mean a lot for the engine future. For the people who don’t know our IRC info, there it is:

Server: arcor.de.eu.dal.net (the server has the bad habit of kicking out people from time to time…)

Channel: #JadEngine

I’ll add another blog entry after the meeting to tell what we talked about and what we decided. Btw, my english hasn't improved these last days, it's that Steve has kindly offered to review my posts before I post them, thanks man ;)

Jade 1.2 Plans

Sunday, April 29, 2007 | From Jad Engine Blog

Kartones.net had a problem several days ago and this post was lost in the backups, so I'm reposting it again (thanks to Overlord who had the feed :)). I'll post in the following days about what we are doing in the project, there are some interesting things happening. Here goes the old post:

"Well, Jade 1.1 got released some days ago and it generated some buzz around: Gamedev, Devmaster and Stratos. We have seen a lot of new people visiting the site, this blog and the forums in the latest days also And now it is time to think in the future of Jade and what will come in Jad 1.2.

To be truth, the engine devs hold a meeting some weeks before the 1.1 launch to talk about the release and what we would be doing. In this meeting one thing was clear: the engine needed serious cleaning on the internal parts, it was taking us too long to develop new features, to long to integrate the and to long to test them. The engine base wasn't designed thinking in helping the engine developer to maintain and extend it and we have paid that price in 1.1. We wanted to write some new features and we ended rewriting several parts while doing our main objectives. This is the main problem of the engine from our point of view, as engine developers. But the engine has other problems from other point of view: the problems of the engine users. For you the main problems are the lack of several important features: animation and collada are still half-done, a GUI system, terrain rendering,...

We have talked quite a lot about this subject between ourselves, and we feel that the most important subject to solve right now is the engine internals. There are some points that made us take this decision:

The more code we write, the harder it becomes to continue coding, so the slower we are able to finish things. This means that 1.2 would need even more time than 1.1 and well, 1.1 took too long to born.

We break the existing code every time we release something. Not breaking things is hard, but it's very desirable for people that use the engine so they don't have to change their code every time a new version appears.

The team is growing and it's getting harder to coordinate. If the code is meshed you have to check out too many files to write something and then we have to do strange merges in the server.

MDX will die in the future, we don' t know when but it will happen. Microsoft has released XNA and DX10, so MDX future will end someday and we have to be prepared for it. We can't just stop the engine 6 months (or more) while we rewrite everything around to move from MDX to another graphics API.

Then, what does this mean? If you have looked at JadEd project (Jad Engine Editor), you probably have seen that there's a very powerful plugins architecture there. It's easy to use, easy to integrate and it cleans a lot code, and more important: it helps extending code. So, in the end we have decided that Jade 1.2 is going to be a design release. We are going to move all Jade parts to a plugin based approach, so we can exchange components in the future easily (sound, physics, rendering,...). We are going also to clean the internal problems we have found in 1.1 (and some problems you have pointed to us in the forums).

I'm sure by now some people using the engine will be probably sad or angry right now. I promised in the forums that GUI would make it for 1.2, and the following lines are pretty clear in that GUI won't be for 1.2. I have learnt that in the future I won't promise anything unless I have a very very very clear idea of how things are going. But to be truth, things aren't really so dark. We think that the re-design and cleaning will make the engine a lot easier to understand and use for you, but we also know that new features are needed. And we have got quite lucky in this subject the latest months

If you follow the forums, you probably have read about two people, Krisso and Stephan who are working on a terrain renderer and a new and more complex scenegraph (Krisso released today some nice screens of his work ). They are students from Munich University who are going to do part of their university work helping in Jade. On another front, Jader is going to work on finishing meeshoo work on the Collada importing, something that will help easing to import graphic assets in the engine. Kartones and RGB are doing their work on the console (and a secret small new app to help you guys to try the new dev versions more easily ), and yesterday a new person showed his interest in helping us with the input and the GUI So while not in our main plan, there are several important aditions in the works (terrain, scenegraph, Collada, console and GUI).

As usual, if you want to see the advances, check the development branch to get the new goodies we have there: the plugin system is already there (with a new sound system over OpenAL to show it), Collada importing (with some mistakes), new scenegraph,... But remember that so far in the iteration of a new version, the code is quite unstable and probably breaks easily, but nevertheless is pretty interesting if you want to have a glimpse in how things will look in the future for Jad."

Jad Engine 1.1 Released

Tuesday, April 03, 2007 | From Jad Engine Blog

It's been a long time, but at last it's here. After a RC in the Jad Engine forums and some last hour bug-fixing, today we release Jad Engine 1.1. For the Jade Team is a great moment as this release has sucked a lot of our free time in the last months. It's more stable, faster and better organized that Jade 1.0. I must say it's my mistake not having a proper changelog, so I'll copy the "new features" text from the 1.1 Readme.txt:

"Apart from a very big list of changes and fixes, the most important new features in Jade 1.1 are:

- Jade Binary Format: Jade now has its own binary format to load and save scenes. This format is meant to be used when deploying a game, as it will offer very fast load times.
- Input: Jade's input system was rewritten, and it's now scriptable.
- Scripting: Jade supports now scripting in Boo, C# and VB.NET.
- Virtual File System: Jade now has a virtual file system (VFS) used to query for files and load resources into the engine from different sources via one simplyfied interface. It supports package files and comes with a visual tool to create and manage them.
- Collada Importer: the main format for Jade will be Collada, so there's now a tool that allows you to load Collada files into Jade. This feature is in beta state.
- Animation Support: there's now support for morphing animation in Jade. Also, the basics for skeletal animation are there, but they need a little more work. This feature is also in beta state."

Believe me the list of fixes and new minor features is very big (like multiple viewports, math improvements,...) ;) The main features are also pretty important for the engine future, and it's here where we have failed a little with this release: due to real life matters (one dev had to leave the project), we haven't been able to finish the Collada and Animation parts. They are mostly done, but they aren't in a usable state yet. I know a lot of people would like to see these features in the engine, and I can tell that we would love to see them in the engine also, but at the moment we lack the knowledge on those subjects to finish them properly, but we are searching solutions for the subject (if you feel interested in helping, drop an email to jadengine AT gmail DOT com).

Apart from that "dark point", we have tried to make an effort on the documentation area on this release, so we have added several new tutorials and several new docs for starters. I would invite you specially to check the "Jad Engine Quickstart Guide" from Jesse A. Jimenez, as it makes a great job teaching the basics of Jade.

You can grab the 1.1 release here:

http://www.codeplex.com/JADENGINE/Release/ProjectReleases.aspx?ReleaseId=2841

Feel free to post your oppinions about Jade 1.1 here, or better in our forums ;) We hope you enjoy this new release as much as we enjoyed coding it. Now time to work on 1.2!

We have moved!

Wednesday, March 14, 2007 | From Jad Engine Blog

The Jad Engine blog has moved here to Kartones.net :) Thanks a lot to Kartones for his kind offer of space here. Keep your eyes open the next days, we have something important to say ;)

Jade Virtual File System (VFS)

Tuesday, March 13, 2007 | From Jad Engine Blog

The 13 September 2006 I posted in this blog:

"Nothing more I think, probably the next post will be about the new virtual file system of Jade."

And then the nexts posts were not about the VFS :p They were more reports about how the project is going. I'll do a quickly one and move on: 1.1 is really close, most features are there (collada is there, animation is there, new input is there, scripting is there, VFS is there,...). But polishing takes a lot of time :( But you can download the latest check-ins and play with all the new things ;)

And now about the VFS. Back to when I started thinking about this subject (severals months ago), I asked in Stratos if someone had already done it (just to avoid common mistakes and to get some guidelines). I got several very useful answers, and a link to a very good article in old Flipcode (here). I also got several good answers from Jade forums.

Most of my objectives for the VFS were pretty similar to those of the article:

- it should be able to handle archives (a big file with lots of files inside, like a .zip file)
- it should allow plugins to read or write in archives (encryption, compression,...)
- accessing normal files and archives should be transparent to the user
- it should allow several file paths

The idea was to write the new VFS and replace the old class of the engine that managed that (JPath). I had a more or less idea of what JPath was doing and I though switching from one thing to the other wouldn't be very hard (BIG mistake, more on this later) .

So, with that in mind, I started to code. I took the decision to leave the plugins for the end (not a great idea, but not too bad either) because I wanted to have first a bare minimum functionality. The main code was written pretty fast (it was quite easy), and were I spent most time was writing the tool to create the "archives" (a small winforms application). I was lucky that Fernando (delahermosa) was not too busy during that time and he helped me a lot in several parts of the tool.

The structure for the VFS at the start was like this:

- there was a JVFS class that represented the file system. The engine or the user would ask for files to this class. This class would hold internally a dictionary of FileSources (places where you can find files) and pass the request to them. One of the features from JPath that the engine used a lot was that you could ask for a file without knowing where it is exactly and then JPath would search for it.

- I wrote to FileSources implementations: HardDiskSources and StorageSources. HardDiskSources is normal IO, and StorageSources are the so called archives. A StorageSource holds virtual directories and files inside it.

- The engine used to read files the .NET methods called FromFile(string path,...), but now it would have to use the FromStream(Stream stream,...), because there´s not a real file when reading from an archive file. To allow this a new type of stream class is created: a VirtualStream. A virtual stream works over a file stream (the stream for the archive file) and controls that the reading is done the right way (you read the file you want to, and not more or less than you should). This way, the archive is only open once really and close at the end (so you avoid lot of costly IO operations).

And that was it more or less. It sounded great, but when I started merging the VFS with the engine, things weren't so great ;)

First, I decided to do the plugins support. And well, it was hell to write that. Plugins are small classes that modify how a file is written or read, and you can apply several of them to a file. This is their final interface:

Stream ApplyForRead(Stream input);
Stream ApplyForWrite(Stream input);

In theory it is pretty easy: most times filters will be streams wrapping streams. In practice it was quite complicated. Why? Things go more or less like this: we are writing our new archive (remember, lots of files together like a .zip), so we have one stream open and a binary writer writing on it. But now, when writing files with filters applied, we have to modify the stream the writer uses to write (filters modify the stream). So:

- we cache the position where we are in the stream
- we close our stream
- we reopen it and apply the filters to write
- we write the file
- we get the new position in the stream. Now, we can calculate the number of bytes we wrote :) We can't use the Length property of a file stream to know the number of bytes we wrote because we can be reading a compressed file or writing a compressed file, and compressed streams don't support the Length property (System.IO.Compression).
- we close the stream
- we reopen it again to continue doing work with it (file header, and other things)

Sure you loved it :p But then things get better. After finishing that part (I can tell you it took me a while to write those 40 lines of code), now I needed to give support for the filters in the visual tool. It involved writting a custom attribute so filters can tell the type that edits them in a visual environment (like VS visual designers) and a lot of strange errors with reflection and assembly loading.

And the last headache I got was when testing the encryption filters, because for some strange reason, when using AES, DES or TDES symmetric cyphers with PaddingMode.ISO10126 the output ended truncated. It took me a while to realize it was the algorithm padding, so well, I set it to PaddingMode.Zeros and at last, filters were working :)

And things got worse :p

Now I started replacing JPath for JVFS. I deprecated all the JPath code and started searching the warnings around to replace it. I had to change also some configuration stuff, but nothing too serious.

After looking how JPath was working I found the harsh reality: my JVFS interface wasn't prepared to manage it. JPath allowed the user to get all files from a directory, write a file (I didn't allow to write files! You can't save your game, you have to finish it at once :p), set special directories (like for example, Shaders directories where all shaders would be), ignore extensions,... Well, a lot of stuff I haven't thought. So I had to stop the merge and rework the VFS.

This rework involved mostly the FileSources interface. Before this change, the VFS had methods to ask for a file to a specific FileSource (all of them have an unique name) or to all of them at the same time. But now, the VFS class was reworked to be also a FileSource. So, I took out the methods to ask for a specific file or to a generic file. Now the method was something like this:

public abstract Stream GetFile(string path, string fileName, bool recurse, System.IO.FileAccess access);

So, if you do VFS.GetFile, the VFS implementation would search in all its FileSources, but if you do VFS["FileSourceName"].GetFile, it will be use whatever that specific FileSource implementation is. Everything is much clearer like that. FileSources also got some new methods (all files from one directory and minor things needed).

Next step was to allow for defined directories. The old way of putting directories for Jade was something like this:

X:\Whatever\InHouse
X:\Whatever\Base

InHouse is for internal engine files. Base is for your game files. But the engine assumes some directories always exist. For example, it loads all shaders in the Shaders defined directory, that is that the engine searches for InHouse\Shaders and Base\Shaders. So I had to allow a way to get all files from a specific path from all the FileSources. And the defined directories where born.

A defined directory is a pair of key (name, for example Shaders) and value (path, for example MyWork\Shaders). What the engine does when it finds a request to a defined directory is to ask every FileSource if the defined directory key exists, and if it does exist, it performs a normal search using the path associated to that key. So every user can put the Shaders wherever he likes the most as long as the key is Shaders.

All of this is defined in the configuration file, like this:

[VFS]
[FilesSource Type="HardDisk" Name="Base" Path="../../../../Base"]
[DefinedPath Name="Materials" Path="Materials"/]
[DefinedPath Name="Models" Path="Models"/]
[DefinedPath Name="Particles" Path="Particles "/]
[DefinedPath Name="Scenes" Path="Scenes"/]
[DefinedPath Name="Textures" Path="Textures"/]
[/FilesSource]
[FilesSource Type="HardDisk" Name="InHouse" Path="../../../../InHouse"]
[DefinedPath Name="Effects" Path="Effects"/]
[DefinedPath Name="PostProcess" Path="Effects/PostProcess"/]
[DefinedPath Name="Shaders" Path="Shaders"/]
[DefinedPath Name="Geometry" Path="Shaders/Geometry"/]
[DefinedPath Name="Internal" Path="Shaders/Internal"/]
[DefinedPath Name="Lighting" Path="Shaders/Lighting"/]
[DefinedPath Name="Materials" Path="Materials"/]
[DefinedPath Name="Textures" Path="Textures"/]
[DefinedPath Name="Gizmos" Path="Textures/Gizmos"/]
[/FilesSource]
[/VFS]

(Note: it's a normal XML File, I just replaced it with brackets [] to avoid some formatting problems here in the blog)

Quite easy: you define a FilesSource, with its type (HardDisk is normal files, Storage is an archive), its name and its path (relative to the configuration.xml file or absolute, as you wish). And then inside it you can add defined paths with their name and their real path.

With everything done, I went back to replace JPath for the VFS again: now things were fitting much better as there weren't strange things around that I hadn't thought. But, when I finished, the engine didn't work at all :( It would load and start, but it would not render correctly, probably related to a shaders loading problem, but I was unable to find it, so in the end I had to go back and undo all the changes in the engine (I backed up everything first). See changesets 14554, 14572 and 14574 comments to see what I mean (I broke the build compilation on the first check-in).

And so, there I'm at the moment, trying (for the 3rd time) to replace JPath for JVFS, but this time, instead of changing all at the same time, I'm going to have both systems living together and then I'll remove JPath little by little.

Let's hope this time it works ;)

Edit: I forgot to say (and I shouldn't have) that all of this work was possible thanks to the support, advice and comments from Jader, Reed, Quimbo and delahermosa. They helped me a lot to catch bugs, write some parts of the code, test, ideas,... Thks team! ;)

Advance Forward - Jade and JadEd

Tuesday, March 13, 2007 | From Jad Engine Blog

Long time since last post, and lots of things happened along the way :)

Jade 1.1 it´s coming out nicely, and it´s going to package more features than expected. At the moment the Jade binary format is completed and Jader has moved to tweak with the engine internals: his changes now allow to support multiple render views and scenes. Also, he did some changes in the engine shaders.

The collade import is advancing at a very good rate, with most of the import now finished (meeshoo is now giving it finishing touches and testing). Animation should closely come after he finishes with this.

The new filesystem is finished, except for the filters and total integration, but it´s working and the packager tool performs it work too.

The only point we haven´t being able to touch yet is the buffered input, that part will come probably after all the other features are finished. But on the other hand we are getting a very nice new mathematic library from Reed, who has finished several classes for interpolation and geometry operations. He also cleaned most warnings from the development code, so it´s much more neat now :)

But one of the most exciting things that have being happening to Jade in these last days are related to the Jad Engine Editor, codenamed JadEd (we are so clever with word jokes :p). After several people expressed their interest in JadEd, we have decided to create a new project in codeplex:

http://www.codeplex.com/Wiki/View.aspx?ProjectName=jaded

This project will be exclusively for JadEd, and it´s mainly managed by gonzo, Quimbo, Reed and matias. There´s some code now available to download, and I must admit that the level of architectural design they are giving to it will make it a very good piece of software. If you don´t believe me, you can join them at the new JadEd forum:

http://forums.jadengine.de/forumdisplay.php?fid=16

Also, if you have read the latest news in the boards, you will probably know that we have now some IRC channels where you´ll be able to chat with us and see how the development goes. You can grab the info at the JadEngine webpage (www.jadengine.com).

Hope to see you on IRC!

Getting closer to 1.1

Tuesday, March 13, 2007 | From Jad Engine Blog

We are getting closer and closer to 1.1. Jader is hunting bugs in the engine to help Gonzo with a new planet tutorial. It will be quite a complete tutorial that will show you step by step how to use Jade to render a full planet. This is an early screenshot:

I´m aware it looks more like a hedgedog right now ;) But it will get prettier with some effects and shaders that are coming.

Meeshoo continues with his Collada work, and he has being able to import information to the engine from Collada, and now is working in the animation part (importing the Collada data and then playing the animations correctly).

The JadEd team has finished most of the core services of JadEd (plugin services, messaging services, undo/redo services,...). They are now going to start wrapping the engine so JadEd can talk to Jade and preparing the UI to work with Jade. They have being a little out during this last days, but they are back to work.

And myself I have finished the VFS once for all and uploaded to the main code. The VFS and the Storage Packager tool are now functional and working. The next step is to replace the JPath class for the VFS class to handle file requests. This change will be a little more heavy than expected in the end because I plan to change another thing also. Usually, when people get to try Jade for the first time, the "strange" directory structure we use gives them some problems to setup the engine and start using it.

So, as I have to change the JPath class (the one that was in charge of this feature also), I'm going to change how the engine starts up: you'll be able to define paths for files in the configuration.xml file, so it will be way easier to start playing with the engine and change resource locations (no need to compile anymore).

After this is ended, I´ll write two different tutorials, once about how the VFS internals (more oriented to understand how it works, how to extend it,...) and another about using the VFS.

And not much more, there are some interesting threads in the boards that maybe you should read if you haven´t done it: Jade GUI, DX10 vx XNA,... Check them, because they are the ones that will decide where Jade will be headed in the future.

Have a nice x-mas!

Moving towards Jade 1.1

Tuesday, March 13, 2007 | From Jad Engine Blog

Today the Jade Team announced the new features that will come with Jade 1.1. The new features are:

- Jade binary format: it will be able to load and save a full scene (scenegraph, meshobjects, meshes, materials, physics & animation).
- Collada converter: it will be able to convert collada exported scenes into Jade binary format with all the information needed to build a Jade scene. It will be a tool for the engine.
- Animation system: it will support morphing and skeletal animation.
- Virtual file system: it will be able to load files from real paths and virtual paths (storage files). It will come with a tool to create storage files.
- Input: buffered input and action based input (through scripting or another solution, not clear yet).

I must admit I´m very happy with the new features that are coming to the engine, as most people seems to want animation and importing/exporting facilities (and with a good reason, the engine is much less usable without them). Also, a lot of minor improvements are coming for all parts of the engine: refactoring, comenting, editing,... To be truth, with 1.1 I really hope more people will start considering Jade for their own game development needs using .NET.

The importance of profiling

Tuesday, March 13, 2007 | From Jad Engine Blog

We love to optmize code, all programmers do. We find joy and pleasure in writing more optimal and faster algorithms and routines. The problem is that most times, we just do it and think that the new code will be better, without taking measures or doing some tests to confirm that the new code is in fact faster than the old one.

Since the last update, I´ve spent most of my time profiling Jade. While I´m not able to make architectural changes to improve performance, I can find some functions that are not well written and improve them. I´ve had a lot of fun fighting with the Hashtable and Dictionary classes.

When I did my first profiles, I found two dark points:

- JEffectBuilder
- Building shadow volumes in the light pass

Both parts were using a lot of time calling several methods of the Hashtable class (Contains, [], Add,...). I started looking first at the JEffectBuilder class. There the Hashtable was declared as:

Hashtable effects = new Hashtable;

I browsed the code to search what it was using as keys and values: it was using JUniqueEffectID (struct) for the keys and JEffect (a class) for the values.

My first move was to change it to the Dictionary class. I like a lot generics and generic collections (they save casts), so a Dictionary should work better than a Hashtable. I also changed the keys from JUniqueEffectID to int because that struct has a field called Global that is like a hash value. It wasn´t going to save me from the call to GetHashCode, but well, I felt it was more natural to put it that way.

I profiled again the code and well, I was amazed: the time used by the JEffectBuilder diminished a lot. I was very happy with this, but I couldn´t believe that changing from Hashtable to Dictionary would yield such a great speed improvement. I rushed to do the same change in the shadow volumes, because they were well... slow as hell to say the least.

I re-ran the profiler again, and I was shocked by the results: the shadow volumes were as slow as usual. I started to think what had happened, because I was really surprised that I had changed the Hashtable of the shadow volumes to a Dictionary and the speed was the same... And then I realized: the problem was in the GetHashCode method. I don´t know the implementation, but I´m pretty sure that calculating the hash code of a struct is a lot slower than calculating the code of an int. That´s why changing to int keys from structs gave me such a big improvement in speed in the JEffectBuilder while in the shadow volumes, as the keys were already int values, I didn´t notice the boost.

I then had another strange result: Dictionaries have a method called TryGetValue. In the .NET 2.0 framework there are a lot of methods like that (like TryParse in float, int, double,...) that help to make code faster and easier to read. In Jade, the TryGetValue would save me from calling first Contains to see if a key existed in the dictionary, and then using the indexer to get the value. I was reducing the number of calls in half :)

I did some test projects, and they confirmed my idea: using TryGetValue was nearly 2 times faster than using Contains and the Indexer. But then the strange thing happened: when implemented in Jade, it was slower :(

I will continue studying this result, because it doesn´t make any sense at all (or I haven´t found it yet). I must admit it can be also that I haven´t run enough tests: my laptop heats quite fast when running Jade and then the performance of my ATI card drops a lot. I´ll investigate this one further.

Appart from my rambling in profiling and optimization, this last check in has several other aditions:

- documentation and translation fixes (seems they aren´t going to end any time soon).
- a third person camera class written by gonzo. Very nice addition for the default camera classes of Jade (and much more useful later in his editor JadEd).
- fixed some error messages in the code: the engine wasn´t reporting some errors as it should. Sweenie and timbann wrote some code that fixes that.
- fixed the dammed resize bug: Haddd found it at the end, after fighting with it since nearly the start of the engine coding. This will help a lot in the work of the editor.
- the old Haddd editor ported to Jade. Haddd and I ported it to the new code so people can use it as a testbench for their own experiments.

Nothing more I think, probably the next post will be about the new virtual file system of Jade. Or maybe about a surprise, but I don´t know where it´ll be ready (I´m not writting it ;)

Jad Community Contributions

Tuesday, March 13, 2007 | From Jad Engine Blog

One of the best ideas when thinking about Haddd future was converting it into an Open Source project. In very little time some people have submitted code in the form of new features or bug fixes that are very valuable for the engine future.

The first updates that have being merged in the engine code are:

- XBox360 controller and XInput wrapper by plonkman
- Jostick support by ThunderMusic
- JApplication with integrated states by meeshoo
- Reporting delegate on .haddd files loading by Ronnie Barnard
- Bug in input classes from MindGames

They are small features, but nice ones to be truth. And much more important things are on the works:

- Networking by ThunderMusic
- Collada support by meeshoo
- Viewer/Editor by gonzo

This projects when finished will allow Jade to be a much more rounded engine for game development and more useful for the community in general. So, that´s why I feel very happy having opened the code of Haddd, because if not, that code would have never appeared in Jade and no matter how small or big it is, it´s useful :)

Well, I said I was going to return to steering behaviors after this, but I´m going to move to profile the engine, I´ve seen very strange things in the performance, and I´m confident that some small changes can be done to improve it. The ideas is to rework some inner workings of the engine that will allow it to gain 10% speed more or less without breaking any interface or anything (so no method name or signature will change).

Let´s see what happens in the end, I´ll post some points that will be changed when I´m more sure that I´m right ;)

Steering Behaviors

Tuesday, March 13, 2007 | From Jad Engine Blog

When starting with AI programming, a lot of people fight with a problem called "pathfinding": the search of the path to move from one point to another. Pathfinding has a lot of resources around the web, mostly related to Dijkstra algorithm or A*. While efective pathfinding (dynamic environments, multiple agents,...) is much more than A*, A* is a great point to start solving this problem.

But other problems people find when they have implemented A* are: how do I move from A to B? How do I avoid another unit that is moving while moving myself? One way of moving the entities is using "steering behaviors": they are easy to understand, easy to implement and fast to calculate.

The original paper about steering behaviors comes from Craig Reynolds and can be found here:

http://www.red3d.com/cwr/steer/

I like specially the Java Applets, as seing things visually helps a lot to understand them. His paper is also not to hard on the technical side, so it´s quite easy to follow. Some other links in his web are also useful, as the OpenSteer project: their sourcecode can help to understand some problems and concepts in the implementation.

To implement steering behaviors in Jade, I first used the material presented in "Programming Game AI by Example", from Mat Buckland (excellent book, don´t miss it if you like AI programming). After some tests, while most behaviors were working pretty nicely, I had several problems, so I moved to look at Reynolds paper and other sources to find the mistakes I was doing.

After some hard work last week, while not all the behaviors are yet implemented, I think I have ended with a very easy to use architecture to move entities using steering behaviors. Also, I started to try another feature I wanted to develop, but I never found time to: visual AI debuggers.

Debugging AI is pretty hard, you just can´t follow code or print things on a file most times, but watching visually what´s happening makes things very easy to understand and fix. I added a new namespace (JadEngine.AI.Utilities) that allows to draw easily some "2D" figures (circles, crosses,...) to give visual clues of what is happening: it´s like Jade copy of those nice Java Applets from Reynolds. I´m pretty happy with the results so far, although I have to find a good way to put 3D text yet (I asked Haddd about this subject and it seems I have missed some methods and classes used for this, I´ll look better next time).

All the new source code is up and checked in Codeplex. Now I´ll move on to 2 different things: adding the tutorials to the TSS (including a new tutorial for steering behaviors) and adding the community contributions to Jade source code.

And after that, who knows, probably more steering behaviors, but not sure yet ;)

Jade Documentation

Tuesday, March 13, 2007 | From Jad Engine Blog

One of the things the engine lacked since the start of the project was a good documentation: inside the code and an outside reference.

The first problem was because the code was a heavy mix of english and spanish, and a lot of things were unexplained. While the engine has being fully translated to english, some things remain undocumented (with a nice TODO tag to remember myself that I have to fix that someday). That problem will be fixed as the engine moves on.

The second problem was an outside reference for the engine. Usually, .NET projects use NDoc to build their help, but due to several reasons (mostly lack of support from the .NET community), the NDoc project died. The engine uses generics and it has some references to unmanaged assemblies, 2 things NDoc dislikes a lot, so it wasn´t possible to build our documentation with it.

Other tools on the web are professional documenters that cost at least 400-500 dollars, and well, I´m not going to pay that.

But this kind of documentation is quite needed for the community (it is one of the things people asked about first). gonzo helped building a documentation file with an alpha version of NDoc 2.0 and taking out the references to Vorbisdotnet.dll. I continued searching for something (a lot of people have this same problem, so there must be a solution). So after browsing a lot, I discovered project "Sandcastle":

Microsoft Sandcastle Blog

This project are the tools Microsoft uses to build its own documentation. I was quite happy when I found this: "now I can build the doc for Jade!" I though. But another problem arised: using Sandcastle CTP was far from "intuitive" or "easy". But by chance (reading the CodeProject Newsletter), I found this jewel from Ashley van Gerven:

Sandcastle CHM-compile BAT script & configuration utility

This project builds a .bat script that calls Sandcastle and HTML Workshop to build a nice .chm file with the documentation of your assembly. After some tries, I managed to create 2 .chm, one for Jade and one for Jade.AI, and the results are impressive in my opinion. The files are now uploaded in the 1.0.0.0 Release (Jad 1.0 Documentation), so have a look at them, you won´t be disappointed.

After a long fight, it seems Jade has got a nice documentation (at last!).

EvolutionaryComputing Update

Tuesday, March 13, 2007 | From Jad Engine Blog

At last! I´ve finished the update of the EvolutionaryComputing namespace. I´ve being thinking about this update for a long time, but because all the work involved in moving from Haddd to Jade I didn´t have time to commit to it until this last week.

This objective with this namespace was to get an easy to use yet powerful solution for genetic algorithms and evolutionary strategies. The evolutionary strategies thing was halted because I lacked a gaussian random number generator, but now I´ve got it, so I´ll do some work on it in the upcoming weeks.

The genetic algorithms on the other side, was more or less finished, and even though not many people have use it, the comments from all of them have being pretty good. I myself like the library a lot (well, it´s mine after all ;)).

But even with that, some "dark" points where lurking there: some things I didn´t end to like, some comments from the people that used it, some bugs and some mistakes I realized later after using it.

Some points:

The IChromosome and IPopulation interfaces are pretty useless. After thinking and arguing about this one, I think I was wrong and it´s true that this interfaces are useless, as their implementation is trivial (you can´t hardly implement a List property without using a List as the field, and so on). I think this problem came from the "over-designing and pattern overloading" I´ve experienced in my work for some time (and my lack of real experience). In the end, I´ve decided to eliminate them, if someone wants more capabilities for those classes, just inherit from them.

The Clone method of Chromosome and Population. This one was harder to realize. I´m used to write the Clone method like this:

public object Clone()
{
MemoryStream memory;
BinaryFormatter formater;
object clone;

using (memory = new MemoryStream())
{
//Serialize ourself
formater = new BinaryFormatter();
formater.Serialize(memory, this);

//Move the memory buffer to the start
memory.Seek(0, SeekOrigin.Begin);

//Undo the serialization in the new clone object
clone = formater.Deserialize(memory);

return clone;
}
}

This aproach has several good properties: it´s very easy and it works very well if everything is Serializable. But it has a big drawback: it´s slow as hell. The Serialize call is very slow (browse a little and you´ll see lots of arguments about this subject).

Most times, the Chromosomes are using value types as their type paremeter T. Value types can just be copied, there´s no need to clone them and waste so much time.

//Best scenario, T is a ValueType
if (typeof(T).IsValueType)
{
newChrom = (Chromosome) MemberwiseClone();
newChrom.Genotype.Clear();

for (int i = 0; i < genotype.Count; i++)
newChrom.Genotype.Add(genotype); return newChrom;
}

Other times the type parameter will be a Cloneable class, so we can call it´s clone method. And in the worst case, we just can use the old method (well, the worst case is that the item is not ValueType, Cloneable or Serializable so the method crashes, but I won´t count that one :p).

Calling Activator.CreateInstance(type). I needed to call this method in some places of the code to create new instances of items and make the code generic. This method is very slow and it does too much for my needs, so I decided to use a MemberwiseClone type of method (I have to test this one more, but it seems things go better).

Selection, Scaling, Crossover. This one has several parts. First, in the selection methods that used the scaling operator (RouletteWheelSelection and SUSSelection), the operator was being called in every selection to create the ScalingMapping. Well, that was overkill, you could just call it the first time and use the result for all the selections. That "bug" has being fixed.

But there´s a strange relation in those three operators: all of them are used in the creation of the offsprings population (you scale the parents if needed, select some parents, cross them to create a children, select, cross, select, cross,...). I changed some code from EvolutionaryAlgorithm class and moved it to the SelectionAlgorithm, so now creating the offsprings it´s only a call like:

//Create the offsprings population
offsprings = selection(parents, numberOffsprings);

A cosmetic change that will make that part a little easier (and more in line with the others operators of the namespace).

Well, that´s all. I have to finish the evolutionary strategies crossover and mutation operators, but I think I´ll rest from evolutionary computing a little and move to other things like a tutorial on how to setup Jade for your own projects (it´s not a very intuitive thing), fixing some error messages and adding some contributions from the community to the source code.

NEWS FEED

UPDATED WIKI: News Feeds

ReedCopsey — Tue, 05 Jun 2007 22:56:53 GMT

NEWS FEED

IRC Chat Log and comments

Thursday, May 31, 2007 | From Jad Engine Blog

And well, you can read the chat log in this URL:

http://jadengine.dreamhosters.com/index.php?title=24/05/2007_-_Jade_1.2_Meeting

Jade 1.2 talk (IRC)

Monday, May 21, 2007 | From Jad Engine Blog

Server: arcor.de.eu.dal.net (the server has the bad habit of kicking out people from time to time…)

Channel: #JadEngine

Jade 1.2 Plans

Sunday, April 29, 2007 | From Jad Engine Blog

Jad Engine 1.1 Released

Tuesday, April 03, 2007 | From Jad Engine Blog

You can grab the 1.1 release here:

We have moved!

Wednesday, March 14, 2007 | From Jad Engine Blog

The Jad Engine blog has moved here to Kartones.net :) Thanks a lot to Kartones for his kind offer of space here. Keep your eyes open the next days, we have something important to say ;)

Jade Virtual File System (VFS)

Tuesday, March 13, 2007 | From Jad Engine Blog

Advance Forward - Jade and JadEd

Tuesday, March 13, 2007 | From Jad Engine Blog

Getting closer to 1.1

Tuesday, March 13, 2007 | From Jad Engine Blog

Moving towards Jade 1.1

Tuesday, March 13, 2007 | From Jad Engine Blog

The importance of profiling

Tuesday, March 13, 2007 | From Jad Engine Blog

Jad Community Contributions

Tuesday, March 13, 2007 | From Jad Engine Blog

Steering Behaviors

Tuesday, March 13, 2007 | From Jad Engine Blog

Jade Documentation

Tuesday, March 13, 2007 | From Jad Engine Blog

EvolutionaryComputing Update

Tuesday, March 13, 2007 | From Jad Engine Blog

//Create the offsprings population
offsprings = selection(parents, numberOffsprings);

NEWS FEED

UPDATED WIKI: Home

Vicente — Tue, 05 Jun 2007 19:11:00 GMT

News Feeds

05/06/2007 Jad Engine Web Site Moving

www.jadengine.com is going to point to a new home in 24-36 hours at most. We'll keep using Codeplex for our source control and the releases, but all the documentation will be in the new site.

UPDATED WIKI: Home

Vicente — Tue, 03 Apr 2007 15:31:34 GMT

News Feeds

03/04/2007 Jad Engine 1.1 Released

At last! Jad Engine 1.1 has been released and it's waiting for you to download it in the released tab of the site. Enjoy!

UPDATED WIKI: Home

Vicente — Wed, 14 Mar 2007 17:43:01 GMT

News Feeds

14/03/2007 Jad Engine Blog has moved

We have moved Jad Engine Blog from blogger to Kartones.net community. So be sure to update your bookmars and RSS readers, because in the following days we'll do a big announcement.

UPDATED WIKI: Tutorial 32: Trackball Camera

Vicente — Thu, 08 Mar 2007 23:24:47 GMT

TrackballCameraTutorial.cs

#region Using directives
 
using System.Windows.Forms;
 
using Microsoft.DirectX;
 
using JadEngine;
using JadEngine.Video;
using JadEngine.Core;
using JadEngine.Scene;
using JadEngine.Input;
 
#endregion
 
namespace Tutorial
{
	/// <summary>
	/// This tutorial will show you how to use the trackball camera
	/// </summary>
	public class TrackballCameraTutorial : JApplication
	{
		#region Fields
 
		// Saves the reference to the trackball camera
		JCameraTrackball _camera;
		bool _lastTargetSphere;
 
		#endregion
 
		#region Methods
 
		/// <summary>
		/// The engine calls this method after creating the device
		/// </summary>
		/// <param name="form">Form used as window</param>
		/// <returns>True if everything went right</returns>
		public override bool InitGame(Form form)
		{
			// Create the fonts and texture objects
			Jad.AfterCreateDevice();
 
			// Load default textures, scenes, shaders,...
			Jad.LoadCreateInHouse();
 
			// Show the object names
			//Jad.Scene.ShowNames = true;
 
			// Show the gizmos
			Jad.Scene.ShowGizmos = true;
 
			#region Objects
 
			// Create the objects
			JMesh cubeMesh = JMesh.CreateCube(3, 3, 3);
			JMesh sphereMesh = JMesh.CreateSphere(1.5f, 24, 24);
 
			JMeshObject cube = Jad.Scene.MeshObjects.Create("cube", false);
			JMeshObject sphere = Jad.Scene.MeshObjects.Create("sphere", false);
 
			// Now, we associate the mesh with the mesh object
			cube.Mesh = cubeMesh;
			sphere.Mesh = sphereMesh;
 
			// Position the objects
			sphere.Transform.Position = new Vector3(0, 0, 0);
			cube.Transform.Position = new Vector3(0, 5, 0);
 
			#endregion
 
			#region Material
 
			// Create a material's array of 1 element.
			// An array is needed because meshes can have subsets:
			// information for more than 1 material.
 
			JMaterial[] material = new JMaterial[1];
 
			material[0] = Jad.Scene.Materials.Create();
 
			// A material is composed by layers, so we can do multilayer effects.
			// In this example we´ll use only one layer.
 
			// Create the layer
			JMaterialLayer layer = new JMaterialLayer();
 
			// Add it to the material
			material[0].AddLayer(layer);
 
			// Set the diffuse texture. The engine detects if the texture doesn´t exists
			// and load it. If it exists, it only references it.
			// You must not indicate the file extension (.tga, .jpg, .bmp,...). The engine
			// we´ll search the different extensions until it finds the texture.
 
			// To search for textures, the engine will enter in the base/textures
			// directory, and we´ll move through it recursively until it finds the
			// texture. Thanks to this, you can create subfolders to order the textures
			// without needing to change the engine.
 
			layer.DiffuseMap.Texture = Jad.Video.Textures.Create2D("brick_d", true);
 
			// Set the material we have just created to our JMeshObject
			cube.Material = material;
			sphere.Material = material;
 
			#endregion
 
			#region Light
 
			// Create an omni light
			JOmniLight light = (JOmniLight) Jad.Scene.Lights.Create("light", JLightType.Omni);
 
			// Set its position
			light.Transform.Position = new Vector3(0, 2.5f, 0f);
 
			// Intensity
			light.Multiplier = 1f;
 
			// Attenuation
			light.Attenuation.Type = JLightAttenuationType.DualRadius;
 
			// Distance to start attenuating the light
			light.Attenuation.Start = 5f;
 
			// Distance where the light is completely attenuated
			light.Attenuation.End = 10f;
 
			// Color
			light.Color = JColor.Yellow;
 
			// The light affects the diffuse component of the material
			light.AffectDiffuse = true;
 
			// The light affects the specular component of the material
			light.AffectSpecular = true;
 
			// Don´t generate shadows
			light.CastShadows = false;
 
			// Put ambient light
			Jad.Scene.Lights.Ambient = new JColor(0.6f, 0.6f, 0.6f);
 
			#endregion
 
			#region Camera
 
			// Create the trackball camera
			this._camera = (JCameraTrackball) Jad.Scene.Cameras.CreateTrackball("trackballCamera");
 
			// Set the trackball camera as active camera
			Jad.Scene.Camera = this._camera;
			// Center our center of focus and rotation onto the cube object
			_camera.Target = cube;
 
			// Back us off a bit to start
			_camera.Radius = 25f;
 
			// Remove the default camera completely 
			// (Otherwise, you see it's frustrum when ShowGizmo's is true
			JCamera jad_camera = (JCamera) Jad.Scene.Root.SceneGraph.GetNodeByName("jad_camera");
			jad_camera.Remove();
 
			#endregion
 
			// Everything is set, start the engine
			Jad.Begin();
 
			// Create input class to manage the keyboard and the mouse
			Jad.CreateInput();
 
			return true;
		}
 
		/// <summary>
		/// This method is called every frame and it´s where the input
		/// events and the game action must be placed
		/// </summary>
		/// <returns>True to continue, false to exit the application</returns>
		public override bool Update()
		{
			// Exit the app?
			if (Jad.Input.Keyboard[Key.Escape].Down) return false;
 
			// If the spcae key is pressed, switch the camera target
			if (Jad.Input.Keyboard[Key.Space].Pressed)
			{
				if (_lastTargetSphere)
					_camera.Target = Jad.Scene.MeshObjects["cube"];
				else
					_camera.Target = Jad.Scene.MeshObjects["sphere"];
				_lastTargetSphere = !_lastTargetSphere;
			}
 
			return true;
		}
 
		/// <summary>
		/// Render method
		/// </summary>
		public override void Render()
		{
			JView backbuffer = Jad.Video.Views[0];
 
			// Render the Jad.Scene using the scene camera
			backbuffer.Render();
 
			// Get access to the 1st font. The engine creates a font by default
			JFont font = Jad.Video.Fonts[0];
 
			// Start fonts rendering
			Jad.Video.Fonts.Begin();
 
			/// Write text in the first line, position x=0, yellow color
			font.RenderLine(Jad.Version + ": FPS " + Jad.Video.Views.CurrentView.Stats.Fps + " - Press ESC to Exit", 0, JColor.White);
 
			// Write instructions
			font.RenderLine("Use left mouse button, arrow keys, or NumPad to rotate", 0, JColor.Yellow);
			font.RenderLine("Use mouse wheel to zoom: Radius = " + _camera.Radius.ToString(), 0, JColor.Yellow);
			font.RenderLine("Use right mouse button to translate", 0, JColor.Yellow);
			font.RenderLine("Use middle mouse button to shift center of rotation", 0, JColor.Yellow);
			font.RenderLine("Press Space to switch the camera target", 0, JColor.Yellow);
 
			// End fonts rendering
			Jad.Video.Fonts.End();
 
			// Show the backbuffer
			backbuffer.Present();
		}
 
		#endregion
	}
}

UPDATED WIKI: Tutorial 31: Standard Attenuation

Vicente — Thu, 08 Mar 2007 23:23:44 GMT

StandardAttenuation.cs

#region Using directives
 
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
 
using Microsoft.DirectX;
using Microsoft.DirectX.DirectSound;
using Microsoft.DirectX.Direct3D;
 
using JadEngine;
using JadEngine.Video;
using JadEngine.Core;
using JadEngine.Mathematics;
using JadEngine.Scene;
using JadEngine.Scene.MD5;
using JadEngine.Physics;
using JadEngine.Particles;
using JadEngine.Sound;
using JadEngine.Tools;
using JadEngine.Input;
 
#endregion
 
namespace Tutorial
{
	/// <summary>
	/// This example will teach you to use standard attenuation.
	/// </summary>
	public class StandardAttenuation : JApplication
	{
		#region Fields
 
		/// <summary>
		/// Indicates if the help must be shown in the screen or not
		/// </summary>
		bool showHelp = true;
 
		/// <summary>
		/// TODO
		/// </summary>
		JMeshObject sphere;
 
		JOmniLight light;
 
		#endregion
 
		#region Methods
 
		/// <summary>
		/// The engine calls this method after creating the device
		/// </summary>
		/// <param name="form">Form used as window</param>
		/// <returns>True if everything went right</returns>
		public override bool InitGame(Form form)
		{
			// Create the fonts and texture objects
			Jad.AfterCreateDevice();
 
			// Load default textures, scenes, shaders,...
			Jad.LoadCreateInHouse();
 
			// Create the scene
			CreateScene();
 
			// Set the ambient light
			Jad.Scene.Lights.Ambient = new JColor(0.2f, 0.2f, 0.2f);
 
			// Set the camera
			Jad.Scene.Camera.Transform.Position = new Vector3(0, 0f, -2f);
 
			// Everything is set, start the engine
			Jad.Begin();
 
			// Create input class to manage the keyboard and the mouse
			Jad.CreateInput();
 
			return true;
		}
 
		/// <summary>
		/// Creates a spot light
		/// </summary>
		/// <param name="position">Position of the light</param>
		/// <param name="lightColor">Color of the light</param>
		void CreateLight(string name, Vector3 position, JColor lightColor)
		{
			light = (JOmniLight) Jad.Scene.Lights.Create(name, JLightType.Omni);
 
			light.Transform.Position = position;
 
			light.Multiplier = 1f;
 
			light.Attenuation.Type = JLightAttenuationType.Standard;
 
			light.Attenuation.Constant = 0;
			light.Attenuation.Linear = 0.2f;
			light.Attenuation.Quadratic = 0.4f;
 
			light.Attenuation.End = 3f;
 
			light.Color = lightColor;
 
			light.AffectDiffuse = true;
 
			light.AffectSpecular = true;
 
		}
 
		/// <summary>
		/// Creates the room of the scene
		/// </summary>
		void CreateRoom()
		{
			JMesh cubeMesh = JMesh.CreateCube(2f, 2f, 2f);
 
			// Invert the cube faces, as we want to be inside the room
			cubeMesh.IndexBuffer.InvertFaces();
 
			JMeshObject cube = Jad.Scene.MeshObjects.Create("room", false);
 
			cube.Mesh = cubeMesh;
 
			JMaterial[] material = new JMaterial[1];
 
			material[0] = Jad.Scene.Materials.Create();
 
			JMaterialLayer layer = new JMaterialLayer();
 
			material[0].AddLayer(layer);
 
			layer.DiffuseMap.Texture = Jad.Video.Textures.Create2D("brick_d", true);
 
			layer.DiffuseMap.UTile = layer.DiffuseMap.VTile = 4f;
 
			cube.Material = material;
		}
 
		/// <summary>
		/// Creates a sphere
		/// </summary>
		void CreateSphere()
		{
			float radius = 0.25f;
 
			JMesh sphereMesh = JMesh.CreateSphere(radius, 20, 20);
 
			sphere = Jad.Scene.MeshObjects.Create("sphere", false);
 
			sphere.Mesh = sphereMesh;
 
			JMaterial[] material = new JMaterial[1];
 
			material[0] = Jad.Scene.Materials.Create();
 
			JMaterialLayer layer = new JMaterialLayer();
 
			material[0].AddLayer(layer);
 
			layer.DiffuseMap.Texture = Jad.Video.Textures.Create2D("mancha", true);
 
			sphere.Material = material;
 
			sphere.Transform.Position = new Vector3(0, -1f + 0.25f, 0);
 
		}
 
		/// <summary>
		/// Creates the scene
		/// </summary>
		void CreateScene()
		{
			// Create the room
			CreateRoom();
 
			// Create the spehre
			CreateSphere();
 
			CreateLight("White", new Vector3(0f, 0.4f, 0.4f), JColor.White);
 
		}
 
		/// <summary>
		/// This method is called every frame and it´s where the input
		/// events and the game action must be placed
		/// </summary>
		/// <returns>True to continue, false to exit the application</returns>
		public override bool Update()
		{
			// Exit the app?
			if (Jad.Input.Keyboard[Key.Escape].Down) return false;
 
			if (Jad.Input.Keyboard[Key.F1].Pressed) showHelp = !showHelp;
 
			if (Jad.Input.Keyboard[Key.NumPad1].Pressed) light.Attenuation.Constant += 0.1f; ;
			if (Jad.Input.Keyboard[Key.NumPad3].Pressed) light.Attenuation.Constant -= 0.1f; ;
 
			if (Jad.Input.Keyboard[Key.NumPad4].Pressed) light.Attenuation.Linear += 0.1f; ;
			if (Jad.Input.Keyboard[Key.NumPad6].Pressed) light.Attenuation.Linear -= 0.1f; ;
 
			if (Jad.Input.Keyboard[Key.NumPad7].Pressed) light.Attenuation.Quadratic += 0.1f; ;
			if (Jad.Input.Keyboard[Key.NumPad9].Pressed) light.Attenuation.Quadratic -= 0.1f; ;
 
			if (Jad.Input.Keyboard[Key.G].Pressed)
				Jad.Scene.ShowGizmos = !Jad.Scene.ShowGizmos;
 
			// Everything was right, continue
			return true;
		}
 
		/// <summary>
		/// Render method
		/// </summary>
		public override void Render()
		{
			JView backbuffer = Jad.Video.Views[0];
 
			backbuffer.Render();
 
			if (showHelp)
			{
				// Get access to the 1st font. The engine creates a font by default
				JFont font = Jad.Video.Fonts[0];
 
				// Start fonts rendering
				Jad.Video.Fonts.Begin();
 
				// Write text in the first line, position x=0, yellow color
				font.RenderLine(Jad.Version + ". Press ESC to exit. Press G to Show/Hide Gizmos. F1 show/hide text", 0, JColor.Yellow);
 
				// Write text in the second line, position x=0, white color
				font.RenderLine(Jad.Video.Views.CurrentView.Stats.Fps + " FPS", 0, JColor.White);
 
				font.RenderLine("Constant (1,3):" + light.Attenuation.Constant.ToString("N1"), 0, JColor.White);
				font.RenderLine("Linear (4,6):" + light.Attenuation.Linear.ToString("N1"), 0, JColor.White);
				font.RenderLine("Quadratic (7,9):" + light.Attenuation.Quadratic.ToString("N1"), 0, JColor.White);
 
				// End fonts rendering
				Jad.Video.Fonts.End();
			}
 
			backbuffer.Present();
		}
 
		#endregion
	}
}

UPDATED WIKI: Tutorial 16: Postproduction and building your own camera class

Vicente — Thu, 08 Mar 2007 23:20:23 GMT

PostproductionAndCamera.cs

#region Using directives
 
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
 
using Microsoft.DirectX;
using Microsoft.DirectX.DirectSound;
using Microsoft.DirectX.Direct3D;
 
using JadEngine;
using JadEngine.Video;
using JadEngine.Core;
using JadEngine.Mathematics;
using JadEngine.Scene;
using JadEngine.Scene.MD5;
using JadEngine.Physics;
using JadEngine.Particles;
using JadEngine.Sound;
using JadEngine.Tools;
using JadEngine.Import;
using JadEngine.Input;
 
#endregion
 
namespace Tutorial
{
	/// <summary>
	/// This example will teach you to create postproduction effects, and add them to the scene.
	/// The bloom effect for example adds more intesity to the bright zones.
	/// It also shows how to create a camera, instead of using the ones that come with the engine.
	/// </summary>
	public class PostproductionAndCamera : JApplication
	{
		#region Internal Classes
 
		/// <summary>
		/// Class to define a simple camera that moves with the cursors
		/// and with the L, targets a node
		/// </summary>
		public class JMyOwnCamera : JCamera
		{
			#region Fields
 
			/// <summary>
			/// Used for translations
			/// </summary>
			float time;
 
			/// <summary>
			/// Flag for enable / disable look at
			/// </summary>
			bool lookAt;
 
			/// <summary>
			/// Target look at node
			/// </summary>
			JNode targetNode;
 
			/// <summary>
			/// Traslation speed
			/// </summary>
			float speed;
 
			#endregion
 
			#region Constructors
 
			/// <summary>
			/// default Constructor
			/// </summary>
			public JMyOwnCamera(string name, float speed, JNode target)
				: base(name, Jad.Scene.Cameras)
			{
				this.speed = speed;
				targetNode = target;
			}
 
			#endregion
 
			#region Properties
 
			/// <summary>
			/// Gets the look at flag
			/// </summary>
			public bool LookAtFlag
			{
				get { return lookAt; }
			}
 
			#endregion
 
			#region Methods
 
			/// <summary>
			/// Updates the camera
			/// </summary>
			public override void UpdateAction()
			{
				time = Jad.Timer.DeltaTime;
 
				// Position
 
				if (Jad.Input.Keyboard[Key.Left].Down)
					MoveX(-speed);
 
				if (Jad.Input.Keyboard[Key.Right].Down)
					MoveX(speed);
 
				if (Jad.Input.Keyboard[Key.Up].Down)
					MoveY(speed);
 
				if (Jad.Input.Keyboard[Key.Down].Down)
					MoveY(-speed);
 
				if (Jad.Input.Keyboard[Key.L].Pressed)
				{
					lookAt = !lookAt;
 
					if (lookAt) Transform.LookAt(targetNode);
					else
					{
						// when we are setting a target, the rotation values are lost
						// So we must get it
						float angX, angY, angZ; Vector3 pos;
						JMath.AnglesRadiansPositionFromMatrix(Transform.WorldTM, out angX, out angY, out angZ, out pos);
						Transform.Angles = new Vector3(angX, angY, angZ);
						Transform.Target = null;
					}
				}
			}
 
			/// <summary>
			/// Updates the camera
			/// </summary>
			protected override void Update()
			{
				base.Update();
			}
 
			/// <summary>
			/// Moves the camera on the x axis
			/// </summary>
			private void MoveX(float speed)
			{
				Transform.Position += speed * time * Right;
			}
 
			/// <summary>
			/// Moves the camera on the x axis
			/// </summary>
			private void MoveY(float speed)
			{
				Transform.Position += speed * time * Up;
			}
 
			#endregion
		}
 
		#endregion
 
		#region Fields
 
		/// <summary>
		/// Indicates if the help must be shown in the screen or not
		/// </summary>
		bool showHelp = true;
 
		/// <summary>
		/// Size of the blur
		/// </summary>
		string blurSize = "low";
 
		/// <summary>
		/// The high pass filter
		/// </summary>
		JPostFilterHighPass highPass;
 
		/// <summary>
		/// The post effect
		/// </summary>
		JPostProductionEffect post;
 
		/// <summary>
		/// The blur filters
		/// </summary>
		JPostFilterGaussianBlur horizontalBlur, verticalBlur;
 
		/// <summary>
		/// The model that will be drawn in the screen
		/// </summary>
		JMeshObject model;
 
		/// <summary>
		/// Special camera created
		/// </summary>
		JMyOwnCamera myOwnCamera;
 
		/// <summary>
		/// Indicates if the own camera should be used or not
		/// </summary>
		bool useOwnCamera;
 
		#endregion
 
		#region Methods
 
		/// <summary>
		/// The engine calls this method after creating the device
		/// </summary>
		/// <param name="form">Form used as window</param>
		/// <returns>True if everything went right</returns>
		public override bool InitGame(Form form)
		{
			// Create the fonts and texture objects
			Jad.AfterCreateDevice();
 
			// Load default textures, scenes, shaders,...
			Jad.LoadCreateInHouse();
 
			#region Material creation
 
			// Create the materials we'll use for our model
			// This materials are loaded from the material scripts you can find in the "base/materials/tutorials" folder
			JMaterial material = Jad.Scene.Materials.Load("green_metal.material");
 
			#endregion
 
			#region MeshObject creation
 
			// Load our mesh object
			Jad.Import.Load("TorusKnot.haddd");
			// Get a reference of our mesh object
			model = Jad.Import.MeshObjects[0];
			// Assign a material to the mesh object
			model.Material[0] = material;
 
			//model.Hide = true;
 
			#endregion
 
			#region Light
 
			// Create an omni light
			JDirectLight light = (JDirectLight) Jad.Scene.Lights.Create("light", JLightType.Directional);
 
			// Set its angles
			light.Transform.Angles = new Vector3(Geometry.DegreeToRadian(45.0f), 0.0f, 0.0f);
 
			// Position
			light.Transform.Position = new Vector3(0, 5.0f, -5.0f);
 
			// Intensity
			light.Multiplier = 1.0f;
 
			// Attenuation
			light.Attenuation.Type = JLightAttenuationType.None;
 
			// Color
			light.Color = JColor.White;
 
			// The light affects the diffuse component of the material
			light.AffectDiffuse = true;
 
			// The light affects the specular component of the material
			light.AffectSpecular = true;
 
			// Don´t generate shadows
			light.CastShadows = false;
 
			// Falloff & HotSpot, don't affect directional (nor omni) lights but we use them
			// because are needed for building the light frustum (for the gizmo)
			light.FallOff = 15.0f;
			light.HotSpot = 20.0f;
 
			// Put ambient light
			Jad.Scene.Lights.Ambient = new JColor(0.0f, 0.0f, 0.0f);
 
			#endregion
 
			// Set some camera parameters
			Jad.Scene.Camera.Transform.Position = new Vector3(0.0f, 0.0f, -10.0f);
			((JCameraFirstPerson) Jad.Scene.Camera).Speed = 5.0f;
 
			CreateBloomEffect();
 
			CreateRoom();
 
			// Create the new camera
 
			myOwnCamera = new JMyOwnCamera("my own camera", 2.0f, model);
 
			// Add it to the scene
			Jad.Scene.Cameras.Add(myOwnCamera);
 
			// Everything is set, start the engine
			Jad.Begin();
 
			// Create input class to manage the keyboard and the mouse
			Jad.CreateInput();
 
			return true;
		}
 
		/// <summary>
		/// Creates the room of the scene
		/// </summary>
		void CreateRoom()
		{
			float size = 10f;
 
			JMesh cubeMesh = JMesh.CreateCube(size, size, size);
 
			// Invertimos las caras del cubo, porque queremos ponernos dentro de la habitación
			cubeMesh.IndexBuffer.InvertFaces();
 
			JMeshObject cube = Jad.Scene.MeshObjects.Create("room", false);
 
			cube.Mesh = cubeMesh;
 
			JMaterial[] material = new JMaterial[1];
 
			material[0] = Jad.Scene.Materials.Create();
 
			JMaterialLayer layer = new JMaterialLayer();
 
			material[0].AddLayer(layer);
 
			layer.DiffuseMap.Texture = Jad.Video.Textures.Create2D("brick_d", true);
 
			layer.DiffuseMap.UTile = layer.DiffuseMap.VTile = 4f;
 
			cube.Material = material;
		}
 
		/// <summary>
		/// Create the Bloom effect. Please note that this effect is built in
		/// the scene (Jad.BloomEffect) but created here for learning purposes
		/// </summary>
		public void CreateBloomEffect()
		{
			JPostProductionRT postRT;
 
			// Create a new effect, called Bloom
			post = new JPostProductionEffect("Bloom");
 
			// -----------------------------------------------------------------
			// We want to "protect" the active render target, because will be
			// used at the end of the effect
			// -----------------------------------------------------------------
 
			post.Add(new JPostFilterProtectPrimary(null, false));
 
			// The JPostProductionRT tells the engine what kind of RenderTarget
			// you need. The engine has full sized temporary rendertargets, and 50%
			// rendertargets. You can tell the engine that you only need a 10% of the
			// rendertarget, or that you will need a fixed rendertarget..
 
			// Here we are creating a postRT , with id=0 and percentage=1, that is,
			// get a full RenderTarget
			postRT = new JPostProductionRT(0, 1f);
 
			// I want the result on this RenderTarget
			postRT.FixedRenderTarget = Jad.Video.Views[0].RenderTargets.Glow;
 
			// Create the high pass filter, telling that the high value is greater or equal than 0.56 and the multiplier is equal to 0.5
			highPass = new JPostFilterHighPass(postRT, 0.56f, 0.7f);
 
			// Add it to the effect
			post.Add(highPass);
 
			// -----------------------------------------------------------------
			// Horizontal Gaussian Blur
			// -----------------------------------------------------------------
 
			postRT = new JPostProductionRT(1, 1f);
 
			// Tell the engine to set a target RenderTarget that will be 50% of the backbuffer
			// If you would do:
			// postRT = new JPostProductionRT(1, 0.5f);
			// the engine should return an RT that will be full sized(the same size like backbuffer)
			// but the texture coords would be 0.5, to use only the 50%
			// This is radically different than seting the FindRTPercentage=0.5, because with
			// this option the engine will set a RT that will be 50% of the backbuffer, but 
			// the texture coords will be 1
			postRT.FindRTPercentage = 0.5f;
 
			// Set the source texture
			postRT.Texture = Jad.Video.Views[0].RenderTargets.Glow;
 
			// Create the filter with the default values( 16 samples )
			horizontalBlur = new JPostFilterGaussianBlur(postRT, JBlurType.Horizontal);
 
			// Add id to the effect
			post.Add(horizontalBlur);
 
			// -----------------------------------------------------------------
			// 2º Gaussian Blur
			// -----------------------------------------------------------------
 
			postRT = new JPostProductionRT(2, 1f);
 
			postRT.FindRTPercentage = 0.5f;
 
			verticalBlur = new JPostFilterGaussianBlur(postRT, JBlurType.Vertical);
 
			post.Add(verticalBlur);
 
			// Set the att values
			horizontalBlur.GlowAttenuation = 0.7f;
			verticalBlur.GlowAttenuation = 0.7f;
 
			// -----------------------------------------------------------------
			// Now, we want to blend the original RT, ( locked by the JPostFilterProtectPrimary)
			// with the blurred
			// -----------------------------------------------------------------
 
			postRT = new JPostProductionRT(3, 1f);
 
			post.Add(new JPostFilterBlend(postRT));
 
			// We add the effect to the scene postproduction list
			Jad.Scene.PostProduction.Add(post);
		}
 
		/// <summary>
		/// This method is called every frame and it´s where the input
		/// events and the game action must be placed
		/// </summary>
		/// <returns>True to continue, false to exit the application</returns>
		public override bool Update()
		{
			// Exit the app?
			if (Jad.Input.Keyboard[Key.Escape].Down) return false;
 
			if (Jad.Input.Keyboard[Key.F1].Pressed) showHelp = !showHelp;
 
			if (Jad.Input.Keyboard[Key.G].Pressed)
				Jad.Scene.ShowGizmos = !Jad.Scene.ShowGizmos;
 
			// Change the size of the blurred RenderTarget
			if (Jad.Input.Keyboard[Key.O].Pressed)
			{
				if (horizontalBlur.PostProductionRT.FindRTPercentage == 0)
				{
					horizontalBlur.PostProductionRT.FindRTPercentage = 0.5f;
 
					blurSize = "low";
				}
 
				else
				{
					horizontalBlur.PostProductionRT.FindRTPercentage = 0;
 
					blurSize = "high";
				}
 
				verticalBlur.PostProductionRT.FindRTPercentage = horizontalBlur.PostProductionRT.FindRTPercentage;
			}
 
			// Enable/Disable the effect
			if (Jad.Input.Keyboard[Key.P].Pressed)
				post.Enabled = !post.Enabled;
 
			// If keys + - (from the numeric keyboard) were pressed, modify the high pass value
 
			if (Jad.Input.Keyboard[Key.NumPadPlus].Pressed)
				highPass.HighPassValue += 0.02f;
 
			if (Jad.Input.Keyboard[Key.NumPadMinus].Pressed)
				highPass.HighPassValue -= 0.02f;
 
			// Controls the brightness
			if (Jad.Input.Keyboard[Key.NumPad8].Pressed)
				horizontalBlur.GlowAttenuation += 0.1f;
 
			if (Jad.Input.Keyboard[Key.NumPad2].Pressed)
				horizontalBlur.GlowAttenuation -= 0.1f;
 
			verticalBlur.GlowAttenuation = horizontalBlur.GlowAttenuation;
 
			if (Jad.Input.Keyboard[Key.C].Pressed)
			{
				useOwnCamera = !useOwnCamera;
 
				if (useOwnCamera)
				{
					myOwnCamera.Transform.Position = Jad.Scene.Camera.Transform.Position;
					Jad.Scene.Camera = myOwnCamera;
				}
 
				else
					Jad.Scene.Camera = Jad.Scene.Cameras["jad_camera"];
			}
 
			// Rotate the mesh object
			model.Transform.RotateRadians(Jad.Timer.Time * 0.5f, Jad.Timer.Time * 2.0f, Jad.Timer.Time);
 
			// Everything was right, continue
			return true;
		}
 
		/// <summary>
		/// Render method
		/// </summary>
		public override void Render()
		{
			JView backbuffer = Jad.Video.Views[0];
 
			// Render the Jad.Scene using the scene camera
			backbuffer.Render();
 
			if (showHelp)
			{
				JFont font = Jad.Video.Fonts[0];
 
				Jad.Video.Fonts.Begin();
 
				font.RenderLine(Jad.Version + ". Press ESC to exit. Press G to Show/Hide Gizmos. F1 show/hide text", 0, JColor.Yellow);
				font.RenderLine(Jad.Video.Views.CurrentView.Stats.Fps + " FPS", 0, JColor.White);
				font.RenderLine("Effect ( P ): " + post.Enabled.ToString() + " / High pass value( Numpad + - to change ): " + highPass.HighPassValue.ToString("N2"), 0, JColor.White);
				font.RenderLine("Blur size ( O ): " + blurSize + " / Glow Attenuation (8,2): " + horizontalBlur.GlowAttenuation.ToString("N2"), 0, JColor.White);
 
				if (useOwnCamera)
					font.RenderLine("Custom camera ON (C) Use Arrow keys to move. Look ( L ): " + myOwnCamera.LookAtFlag.ToString(), 0, JColor.White);
 
				else
					font.RenderLine("Custom camera OFF (C)", 0, JColor.White);
 
				// End fonts rendering
				Jad.Video.Fonts.End();
			}
 
			// Show the backbuffer
			backbuffer.Present();
		}
 
		#endregion
	}
}

UPDATED WIKI: Tutorial 32: Trackball Camera

Vicente — Thu, 08 Mar 2007 23:20:20 GMT

TrackballCameraTutorial.cs

#region Using directives
 
using System.Windows.Forms;
 
using Microsoft.DirectX;
 
using JadEngine;
using JadEngine.Video;
using JadEngine.Core;
using JadEngine.Scene;
using JadEngine.Input;
 
#endregion
 
namespace Tutorial
{
	/// <summary>
	/// This tutorial will show you how to use the trackball camera
	/// </summary>
	public class TrackballCameraTutorial : JApplication
	{
		#region Fields
 
		// Saves the reference to the trackball camera
		JCameraTrackball _camera;
		bool _lastTargetSphere;
 
		#endregion
 
		#region Methods
 
		/// <summary>
		/// The engine calls this method after creating the device
		/// </summary>
		/// <param name="form">Form used as window</param>
		/// <returns>True if everything went right</returns>
		public override bool InitGame(Form form)
		{
			// Create the fonts and texture objects
			Jad.AfterCreateDevice();
 
			// Load default textures, scenes, shaders,...
			Jad.LoadCreateInHouse();
 
			// Show the object names
			//Jad.Scene.ShowNames = true;
 
			// Show the gizmos
			Jad.Scene.ShowGizmos = true;
 
			#region Objects
 
			// Create the objects
			JMesh cubeMesh = JMesh.CreateCube(3, 3, 3);
			JMesh sphereMesh = JMesh.CreateSphere(1.5f, 24, 24);
 
			JMeshObject cube = Jad.Scene.MeshObjects.Create("cube", false);
			JMeshObject sphere = Jad.Scene.MeshObjects.Create("sphere", false);
 
			// Now, we associate the mesh with the mesh object
			cube.Mesh = cubeMesh;
			sphere.Mesh = sphereMesh;
 
			// Position the objects
			sphere.Transform.Position = new Vector3(0, 0, 0);
			cube.Transform.Position = new Vector3(0, 5, 0);
 
			#endregion
 
			#region Material
 
			// Create a material's array of 1 element.
			// An array is needed because meshes can have subsets:
			// information for more than 1 material.
 
			JMaterial[] material = new JMaterial[1];
 
			material[0] = Jad.Scene.Materials.Create();
 
			// A material is composed by layers, so we can do multilayer effects.
			// In this example we´ll use only one layer.
 
			// Create the layer
			JMaterialLayer layer = new JMaterialLayer();
 
			// Add it to the material
			material[0].AddLayer(layer);
 
			// Set the diffuse texture. The engine detects if the texture doesn´t exists
			// and load it. If it exists, it only references it.
			// You must not indicate the file extension (.tga, .jpg, .bmp,...). The engine
			// we´ll search the different extensions until it finds the texture.
 
			// To search for textures, the engine will enter in the base/textures
			// directory, and we´ll move through it recursively until it finds the
			// texture. Thanks to this, you can create subfolders to order the textures
			// without needing to change the engine.
 
			layer.DiffuseMap.Texture = Jad.Video.Textures.Create2D("brick_d", true);
 
			// Set the material we have just created to our JMeshObject
			cube.Material = material;
			sphere.Material = material;
 
			#endregion
 
			#region Light
 
			// Create an omni light
			JOmniLight light = (JOmniLight) Jad.Scene.Lights.Create("light", JLightType.Omni);
 
			// Set its position
			light.Transform.Position = new Vector3(0, 2.5f, 0f);
 
			// Intensity
			light.Multiplier = 1f;
 
			// Attenuation
			light.Attenuation.Type = JLightAttenuationType.DualRadius;
 
			// Distance to start attenuating the light
			light.Attenuation.Start = 5f;
 
			// Distance where the light is completely attenuated
			light.Attenuation.End = 10f;
 
			// Color
			light.Color = JColor.Yellow;
 
			// The light affects the diffuse component of the material
			light.AffectDiffuse = true;
 
			// The light affects the specular component of the material
			light.AffectSpecular = true;
 
			// Don´t generate shadows
			light.CastShadows = false;
 
			// Put ambient light
			Jad.Scene.Lights.Ambient = new JColor(0.6f, 0.6f, 0.6f);
 
			#endregion
 
			#region Camera
 
			// Create the trackball camera
			this._camera = (JCameraTrackball) Jad.Scene.Cameras.CreateTrackball("trackballCamera");
 
			// Set the trackball camera as active camera
			Jad.Scene.Camera = this._camera;
			// Center our center of focus and rotation onto the cube object
			_camera.Target = cube;
 
			// Back us off a bit to start
			_camera.Radius = 25f;
 
			// Remove the default camera completely 
			// (Otherwise, you see it's frustrum when ShowGizmo's is true
			JCamera jad_camera = (JCamera) Jad.Scene.Root.SceneGraph.GetNodeByName("jad_camera");
			jad_camera.Remove();
 
			#endregion
 
			// Everything is set, start the engine
			Jad.Begin();
 
			// Create input class to manage the keyboard and the mouse
			Jad.CreateInput();
 
			return true;
		}
 
		/// <summary>
		/// This method is called every frame and it´s where the input
		/// events and the game action must be placed
		/// </summary>
		/// <returns>True to continue, false to exit the application</returns>
		public override bool Update()
		{
			// Exit the app?
			if (Jad.Input.Keyboard[Key.Escape].Down) return false;
 
			// If the spcae key is pressed, switch the camera target
			if (Jad.Input.Keyboard[Key.Space].Pressed)
			{
				if (_lastTargetSphere)
					_camera.Target = Jad.Scene.MeshObjects["cube"];
				else
					_camera.Target = Jad.Scene.MeshObjects["sphere"];
				_lastTargetSphere = !_lastTargetSphere;
			}
 
			return true;
		}
 
		/// <summary>
		/// Render method
		/// </summary>
		public override void Render()
		{
			JView backbuffer = Jad.Video.Views[0];
 
			// Render the Jad.Scene using the scene camera
			backbuffer.Render();
 
			// Get access to the 1st font. The engine creates a font by default
			JFont font = Jad.Video.Fonts[0];
 
			// Start fonts rendering
			Jad.Video.Fonts.Begin();
 
			/// Write text in the first line, position x=0, yellow color
			font.RenderLine(Jad.Version + ": FPS " + Jad.Video.Views.CurrentView.Stats.Fps + " - Press ESC to Exit", 0, JColor.White);
 
			// Write instructions
			font.RenderLine("Use left mouse button, arrow keys, or NumPad to rotate", 0, JColor.Yellow);
			font.RenderLine("Use mouse wheel to zoom: Radius = " + _camera.Radius.ToString(), 0, JColor.Yellow);
			font.RenderLine("Use right mouse button to translate", 0, JColor.Yellow);
			font.RenderLine("Use middle mouse button to shift center of rotation", 0, JColor.Yellow);
			font.RenderLine("Press Space to switch the camera target", 0, JColor.Yellow);
 
			// End fonts rendering
			Jad.Video.Fonts.End();
 
			// Show the backbuffer
			backbuffer.Present();
		}
 
		#endregion
	}
}

UPDATED WIKI: Tutorial 31: Standard Attenuation

Vicente — Thu, 08 Mar 2007 23:20:19 GMT

StandardAttenuation.cs

#region Using directives
 
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
 
using Microsoft.DirectX;
using Microsoft.DirectX.DirectSound;
using Microsoft.DirectX.Direct3D;
 
using JadEngine;
using JadEngine.Video;
using JadEngine.Core;
using JadEngine.Mathematics;
using JadEngine.Scene;
using JadEngine.Scene.MD5;
using JadEngine.Physics;
using JadEngine.Particles;
using JadEngine.Sound;
using JadEngine.Tools;
using JadEngine.Input;
 
#endregion
 
namespace Tutorial
{
	/// <summary>
	/// This example will teach you to use standard attenuation.
	/// </summary>
	public class StandardAttenuation : JApplication
	{
		#region Fields
 
		/// <summary>
		/// Indicates if the help must be shown in the screen or not
		/// </summary>
		bool showHelp = true;
 
		/// <summary>
		/// TODO
		/// </summary>
		JMeshObject sphere;
 
		JOmniLight light;
 
		#endregion
 
		#region Methods
 
		/// <summary>
		/// The engine calls this method after creating the device
		/// </summary>
		/// <param name="form">Form used as window</param>
		/// <returns>True if everything went right</returns>
		public override bool InitGame(Form form)
		{
			// Create the fonts and texture objects
			Jad.AfterCreateDevice();
 
			// Load default textures, scenes, shaders,...
			Jad.LoadCreateInHouse();
 
			// Create the scene
			CreateScene();
 
			// Set the ambient light
			Jad.Scene.Lights.Ambient = new JColor(0.2f, 0.2f, 0.2f);
 
			// Set the camera
			Jad.Scene.Camera.Transform.Position = new Vector3(0, 0f, -2f);
 
			// Everything is set, start the engine
			Jad.Begin();
 
			// Create input class to manage the keyboard and the mouse
			Jad.CreateInput();
 
			return true;
		}
 
		/// <summary>
		/// Creates a spot light
		/// </summary>
		/// <param name="position">Position of the light</param>
		/// <param name="lightColor">Color of the light</param>
		void CreateLight(string name, Vector3 position, JColor lightColor)
		{
			light = (JOmniLight) Jad.Scene.Lights.Create(name, JLightType.Omni);
 
			light.Transform.Position = position;
 
			light.Multiplier = 1f;
 
			light.Attenuation.Type = JLightAttenuationType.Standard;
 
			light.Attenuation.Constant = 0;
			light.Attenuation.Linear = 0.2f;
			light.Attenuation.Quadratic = 0.4f;
 
			light.Attenuation.End = 3f;
 
			light.Color = lightColor;
 
			light.AffectDiffuse = true;
 
			light.AffectSpecular = true;
 
		}
 
		/// <summary>
		/// Creates the room of the scene
		/// </summary>
		void CreateRoom()
		{
			JMesh cubeMesh = JMesh.CreateCube(2f, 2f, 2f);
 
			// Invert the cube faces, as we want to be inside the room
			cubeMesh.IndexBuffer.InvertFaces();
 
			JMeshObject cube = Jad.Scene.MeshObjects.Create("room", false);
 
			cube.Mesh = cubeMesh;
 
			JMaterial[] material = new JMaterial[1];
 
			material[0] = Jad.Scene.Materials.Create();
 
			JMaterialLayer layer = new JMaterialLayer();
 
			material[0].AddLayer(layer);
 
			layer.DiffuseMap.Texture = Jad.Video.Textures.Create2D("brick_d", true);
 
			layer.DiffuseMap.UTile = layer.DiffuseMap.VTile = 4f;
 
			cube.Material = material;
		}
 
		/// <summary>
		/// Creates a sphere
		/// </summary>
		void CreateSphere()
		{
			float radius = 0.25f;
 
			JMesh sphereMesh = JMesh.CreateSphere(radius, 20, 20);
 
			sphere = Jad.Scene.MeshObjects.Create("sphere", false);
 
			sphere.Mesh = sphereMesh;
 
			JMaterial[] material = new JMaterial[1];
 
			material[0] = Jad.Scene.Materials.Create();
 
			JMaterialLayer layer = new JMaterialLayer();
 
			material[0].AddLayer(layer);
 
			layer.DiffuseMap.Texture = Jad.Video.Textures.Create2D("mancha", true);
 
			sphere.Material = material;
 
			sphere.Transform.Position = new Vector3(0, -1f + 0.25f, 0);
 
		}
 
		/// <summary>
		/// Creates the scene
		/// </summary>
		void CreateScene()
		{
			// Create the room
			CreateRoom();
 
			// Create the spehre
			CreateSphere();
 
			CreateLight("White", new Vector3(0f, 0.4f, 0.4f), JColor.White);
 
		}
 
		/// <summary>
		/// This method is called every frame and it´s where the input
		/// events and the game action must be placed
		/// </summary>
		/// <returns>True to continue, false to exit the application</returns>
		public override bool Update()
		{
			// Exit the app?
			if (Jad.Input.Keyboard[Key.Escape].Down) return false;
 
			if (Jad.Input.Keyboard[Key.F1].Pressed) showHelp = !showHelp;
 
			if (Jad.Input.Keyboard[Key.NumPad1].Pressed) light.Attenuation.Constant += 0.1f; ;
			if (Jad.Input.Keyboard[Key.NumPad3].Pressed) light.Attenuation.Constant -= 0.1f; ;
 
			if (Jad.Input.Keyboard[Key.NumPad4].Pressed) light.Attenuation.Linear += 0.1f; ;
			if (Jad.Input.Keyboard[Key.NumPad6].Pressed) light.Attenuation.Linear -= 0.1f; ;
 
			if (Jad.Input.Keyboard[Key.NumPad7].Pressed) light.Attenuation.Quadratic += 0.1f; ;
			if (Jad.Input.Keyboard[Key.NumPad9].Pressed) light.Attenuation.Quadratic -= 0.1f; ;
 
			if (Jad.Input.Keyboard[Key.G].Pressed)
				Jad.Scene.ShowGizmos = !Jad.Scene.ShowGizmos;
 
			// Everything was right, continue
			return true;
		}
 
		/// <summary>
		/// Render method
		/// </summary>
		public override void Render()
		{
			JView backbuffer = Jad.Video.Views[0];
 
			backbuffer.Render();
 
			if (showHelp)
			{
				// Get access to the 1st font. The engine creates a font by default
				JFont font = Jad.Video.Fonts[0];
 
				// Start fonts rendering
				Jad.Video.Fonts.Begin();
 
				// Write text in the first line, position x=0, yellow color
				font.RenderLine(Jad.Version + ". Press ESC to exit. Press G to Show/Hide Gizmos. F1 show/hide text", 0, JColor.Yellow);
 
				// Write text in the second line, position x=0, white color
				font.RenderLine(Jad.Video.Views.CurrentView.Stats.Fps + " FPS", 0, JColor.White);
 
				font.RenderLine("Constant (1,3):" + light.Attenuation.Constant.ToString("N1"), 0, JColor.White);
				font.RenderLine("Linear (4,6):" + light.Attenuation.Linear.ToString("N1"), 0, JColor.White);
				font.RenderLine("Quadratic (7,9):" + light.Attenuation.Quadratic.ToString("N1"), 0, JColor.White);
 
				// End fonts rendering
				Jad.Video.Fonts.End();
			}
 
			backbuffer.Present();
		}
 
		#endregion
	}
}

UPDATED WIKI: Tutorial 32: Trackball Camera

Vicente — Thu, 08 Mar 2007 23:19:16 GMT

TrackballCameraTutorial.cs

#region Using directives
 
using System.Windows.Forms;
 
using Microsoft.DirectX;
 
using JadEngine;
using JadEngine.Video;
using JadEngine.Core;
using JadEngine.Scene;
using JadEngine.Input;
 
#endregion
 
namespace Tutorial
{
	/// <summary>
	/// This tutorial will show you how to use the trackball camera
	/// </summary>
	public class TrackballCameraTutorial : JApplication
	{
		#region Fields
 
		// Saves the reference to the trackball camera
		JCameraTrackball _camera;
		bool _lastTargetSphere;
 
		#endregion
 
		#region Methods
 
		/// <summary>
		/// The engine calls this method after creating the device
		/// </summary>
		/// <param name="form">Form used as window</param>
		/// <returns>True if everything went right</returns>
		public override bool InitGame(Form form)
		{
			// Create the fonts and texture objects
			Jad.AfterCreateDevice();
 
			// Load default textures, scenes, shaders,...
			Jad.LoadCreateInHouse();
 
			// Show the object names
			//Jad.Scene.ShowNames = true;
 
			// Show the gizmos
			Jad.Scene.ShowGizmos = true;
 
			#region Objects
 
			// Create the objects
			JMesh cubeMesh = JMesh.CreateCube(3, 3, 3);
			JMesh sphereMesh = JMesh.CreateSphere(1.5f, 24, 24);
 
			JMeshObject cube = Jad.Scene.MeshObjects.Create("cube", false);
			JMeshObject sphere = Jad.Scene.MeshObjects.Create("sphere", false);
 
			// Now, we associate the mesh with the mesh object
			cube.Mesh = cubeMesh;
			sphere.Mesh = sphereMesh;
 
			// Position the objects
			sphere.Transform.Position = new Vector3(0, 0, 0);
			cube.Transform.Position = new Vector3(0, 5, 0);
 
			#endregion
 
			#region Material
 
			// Create a material's array of 1 element.
			// An array is needed because meshes can have subsets:
			// information for more than 1 material.
 
			JMaterial[] material = new JMaterial[1];
 
			material[0] = Jad.Scene.Materials.Create();
 
			// A material is composed by layers, so we can do multilayer effects.
			// In this example we´ll use only one layer.
 
			// Create the layer
			JMaterialLayer layer = new JMaterialLayer();
 
			// Add it to the material
			material[0].AddLayer(layer);
 
			// Set the diffuse texture. The engine detects if the texture doesn´t exists
			// and load it. If it exists, it only references it.
			// You must not indicate the file extension (.tga, .jpg, .bmp,...). The engine
			// we´ll search the different extensions until it finds the texture.
 
			// To search for textures, the engine will enter in the base/textures
			// directory, and we´ll move through it recursively until it finds the
			// texture. Thanks to this, you can create subfolders to order the textures
			// without needing to change the engine.
 
			layer.DiffuseMap.Texture = Jad.Video.Textures.Create2D("brick_d", true);
 
			// Set the material we have just created to our JMeshObject
			cube.Material = material;
			sphere.Material = material;
 
			#endregion
 
			#region Light
 
			// Create an omni light
			JOmniLight light = (JOmniLight) Jad.Scene.Lights.Create("light", JLightType.Omni);
 
			// Set its position
			light.Transform.Position = new Vector3(0, 2.5f, 0f);
 
			// Intensity
			light.Multiplier = 1f;
 
			// Attenuation
			light.Attenuation.Type = JLightAttenuationType.DualRadius;
 
			// Distance to start attenuating the light
			light.Attenuation.Start = 5f;
 
			// Distance where the light is completely attenuated
			light.Attenuation.End = 10f;
 
			// Color
			light.Color = JColor.Yellow;
 
			// The light affects the diffuse component of the material
			light.AffectDiffuse = true;
 
			// The light affects the specular component of the material
			light.AffectSpecular = true;
 
			// Don´t generate shadows
			light.CastShadows = false;
 
			// Put ambient light
			Jad.Scene.Lights.Ambient = new JColor(0.6f, 0.6f, 0.6f);
 
			#endregion
 
			#region Camera
 
			// Create the trackball camera
			this._camera = (JCameraTrackball) Jad.Scene.Cameras.CreateTrackball("trackballCamera");
 
			// Set the trackball camera as active camera
			Jad.Scene.Camera = this._camera;
			// Center our center of focus and rotation onto the cube object
			_camera.Target = cube;
 
			// Back us off a bit to start
			_camera.Radius = 25f;
 
			// Remove the default camera completely 
			// (Otherwise, you see it's frustrum when ShowGizmo's is true
			JCamera jad_camera = (JCamera) Jad.Scene.Root.SceneGraph.GetNodeByName("jad_camera");
			jad_camera.Remove();
 
			#endregion
 
			// Everything is set, start the engine
			Jad.Begin();
 
			// Create input class to manage the keyboard and the mouse
			Jad.CreateInput();
 
			return true;
		}
 
		/// <summary>
		/// This method is called every frame and it´s where the input
		/// events and the game action must be placed
		/// </summary>
		/// <returns>True to continue, false to exit the application</returns>
		public override bool Update()
		{
			// Exit the app?
			if (Jad.Input.Keyboard[Key.Escape].Down) return false;
 
			// If the spcae key is pressed, switch the camera target
			if (Jad.Input.Keyboard[Key.Space].Pressed)
			{
				if (_lastTargetSphere)
					_camera.Target = Jad.Scene.MeshObjects["cube"];
				else
					_camera.Target = Jad.Scene.MeshObjects["sphere"];
				_lastTargetSphere = !_lastTargetSphere;
			}
 
			return true;
		}
 
		/// <summary>
		/// Render method
		/// </summary>
		public override void Render()
		{
			JView backbuffer = Jad.Video.Views[0];
 
			// Render the Jad.Scene using the scene camera
			backbuffer.Render();
 
			// Get access to the 1st font. The engine creates a font by default
			JFont font = Jad.Video.Fonts[0];
 
			// Start fonts rendering
			Jad.Video.Fonts.Begin();
 
			/// Write text in the first line, position x=0, yellow color
			font.RenderLine(Jad.Version + ": FPS " + Jad.Video.Views.CurrentView.Stats.Fps + " - Press ESC to Exit", 0, JColor.White);
 
			// Write instructions
			font.RenderLine("Use left mouse button, arrow keys, or NumPad to rotate", 0, JColor.Yellow);
			font.RenderLine("Use mouse wheel to zoom: Radius = " + _camera.Radius.ToString(), 0, JColor.Yellow);
			font.RenderLine("Use right mouse button to translate", 0, JColor.Yellow);
			font.RenderLine("Use middle mouse button to shift center of rotation", 0, JColor.Yellow);
			font.RenderLine("Press Space to switch the camera target", 0, JColor.Yellow);
 
			// End fonts rendering
			Jad.Video.Fonts.End();
 
			// Show the backbuffer
			backbuffer.Present();
		}
 
		#endregion
	}
}

UPDATED WIKI: Tutorial 31: Standard Attenuation

Vicente — Thu, 08 Mar 2007 23:19:14 GMT

StandardAttenuation.cs

#region Using directives
 
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
 
using Microsoft.DirectX;
using Microsoft.DirectX.DirectSound;
using Microsoft.DirectX.Direct3D;
 
using JadEngine;
using JadEngine.Video;
using JadEngine.Core;
using JadEngine.Mathematics;
using JadEngine.Scene;
using JadEngine.Scene.MD5;
using JadEngine.Physics;
using JadEngine.Particles;
using JadEngine.Sound;
using JadEngine.Tools;
using JadEngine.Input;
 
#endregion
 
namespace Tutorial
{
	/// <summary>
	/// This example will teach you to use standard attenuation.
	/// </summary>
	public class StandardAttenuation : JApplication
	{
		#region Fields
 
		/// <summary>
		/// Indicates if the help must be shown in the screen or not
		/// </summary>
		bool showHelp = true;
 
		/// <summary>
		/// TODO
		/// </summary>
		JMeshObject sphere;
 
		JOmniLight light;
 
		#endregion
 
		#region Methods
 
		/// <summary>
		/// The engine calls this method after creating the device
		/// </summary>
		/// <param name="form">Form used as window</param>
		/// <returns>True if everything went right</returns>
		public override bool InitGame(Form form)
		{
			// Create the fonts and texture objects
			Jad.AfterCreateDevice();
 
			// Load default textures, scenes, shaders,...
			Jad.LoadCreateInHouse();
 
			// Create the scene
			CreateScene();
 
			// Set the ambient light
			Jad.Scene.Lights.Ambient = new JColor(0.2f, 0.2f, 0.2f);
 
			// Set the camera
			Jad.Scene.Camera.Transform.Position = new Vector3(0, 0f, -2f);
 
			// Everything is set, start the engine
			Jad.Begin();
 
			// Create input class to manage the keyboard and the mouse
			Jad.CreateInput();
 
			return true;
		}
 
		/// <summary>
		/// Creates a spot light
		/// </summary>
		/// <param name="position">Position of the light</param>
		/// <param name="lightColor">Color of the light</param>
		void CreateLight(string name, Vector3 position, JColor lightColor)
		{
			light = (JOmniLight) Jad.Scene.Lights.Create(name, JLightType.Omni);
 
			light.Transform.Position = position;
 
			light.Multiplier = 1f;
 
			light.Attenuation.Type = JLightAttenuationType.Standard;
 
			light.Attenuation.Constant = 0;
			light.Attenuation.Linear = 0.2f;
			light.Attenuation.Quadratic = 0.4f;
 
			light.Attenuation.End = 3f;
 
			light.Color = lightColor;
 
			light.AffectDiffuse = true;
 
			light.AffectSpecular = true;
 
		}
 
		/// <summary>
		/// Creates the room of the scene
		/// </summary>
		void CreateRoom()
		{
			JMesh cubeMesh = JMesh.CreateCube(2f, 2f, 2f);
 
			// Invert the cube faces, as we want to be inside the room
			cubeMesh.IndexBuffer.InvertFaces();
 
			JMeshObject cube = Jad.Scene.MeshObjects.Create("room", false);
 
			cube.Mesh = cubeMesh;
 
			JMaterial[] material = new JMaterial[1];
 
			material[0] = Jad.Scene.Materials.Create();
 
			JMaterialLayer layer = new JMaterialLayer();
 
			material[0].AddLayer(layer);
 
			layer.DiffuseMap.Texture = Jad.Video.Textures.Create2D("brick_d", true);
 
			layer.DiffuseMap.UTile = layer.DiffuseMap.VTile = 4f;
 
			cube.Material = material;
		}
 
		/// <summary>
		/// Creates a sphere
		/// </summary>
		void CreateSphere()
		{
			float radius = 0.25f;
 
			JMesh sphereMesh = JMesh.CreateSphere(radius, 20, 20);
 
			sphere = Jad.Scene.MeshObjects.Create("sphere", false);
 
			sphere.Mesh = sphereMesh;
 
			JMaterial[] material = new JMaterial[1];
 
			material[0] = Jad.Scene.Materials.Create();
 
			JMaterialLayer layer = new JMaterialLayer();
 
			material[0].AddLayer(layer);
 
			layer.DiffuseMap.Texture = Jad.Video.Textures.Create2D("mancha", true);
 
			sphere.Material = material;
 
			sphere.Transform.Position = new Vector3(0, -1f + 0.25f, 0);
 
		}
 
		/// <summary>
		/// Creates the scene
		/// </summary>
		void CreateScene()
		{
			// Create the room
			CreateRoom();
 
			// Create the spehre
			CreateSphere();
 
			CreateLight("White", new Vector3(0f, 0.4f, 0.4f), JColor.White);
 
		}
 
		/// <summary>
		/// This method is called every frame and it´s where the input
		/// events and the game action must be placed
		/// </summary>
		/// <returns>True to continue, false to exit the application</returns>
		public override bool Update()
		{
			// Exit the app?
			if (Jad.Input.Keyboard[Key.Escape].Down) return false;
 
			if (Jad.Input.Keyboard[Key.F1].Pressed) showHelp = !showHelp;
 
			if (Jad.Input.Keyboard[Key.NumPad1].Pressed) light.Attenuation.Constant += 0.1f; ;
			if (Jad.Input.Keyboard[Key.NumPad3].Pressed) light.Attenuation.Constant -= 0.1f; ;
 
			if (Jad.Input.Keyboard[Key.NumPad4].Pressed) light.Attenuation.Linear += 0.1f; ;
			if (Jad.Input.Keyboard[Key.NumPad6].Pressed) light.Attenuation.Linear -= 0.1f; ;
 
			if (Jad.Input.Keyboard[Key.NumPad7].Pressed) light.Attenuation.Quadratic += 0.1f; ;
			if (Jad.Input.Keyboard[Key.NumPad9].Pressed) light.Attenuation.Quadratic -= 0.1f; ;
 
			if (Jad.Input.Keyboard[Key.G].Pressed)
				Jad.Scene.ShowGizmos = !Jad.Scene.ShowGizmos;
 
			// Everything was right, continue
			return true;
		}
 
		/// <summary>
		/// Render method
		/// </summary>
		public override void Render()
		{
			JView backbuffer = Jad.Video.Views[0];
 
			backbuffer.Render();
 
			if (showHelp)
			{
				// Get access to the 1st font. The engine creates a font by default
				JFont font = Jad.Video.Fonts[0];
 
				// Start fonts rendering
				Jad.Video.Fonts.Begin();
 
				// Write text in the first line, position x=0, yellow color
				font.RenderLine(Jad.Version + ". Press ESC to exit. Press G to Show/Hide Gizmos. F1 show/hide text", 0, JColor.Yellow);
 
				// Write text in the second line, position x=0, white color
				font.RenderLine(Jad.Video.Views.CurrentView.Stats.Fps + " FPS", 0, JColor.White);
 
				font.RenderLine("Constant (1,3):" + light.Attenuation.Constant.ToString("N1"), 0, JColor.White);
				font.RenderLine("Linear (4,6):" + light.Attenuation.Linear.ToString("N1"), 0, JColor.White);
				font.RenderLine("Quadratic (7,9):" + light.Attenuation.Quadratic.ToString("N1"), 0, JColor.White);
 
				// End fonts rendering
				Jad.Video.Fonts.End();
			}
 
			backbuffer.Present();
		}
 
		#endregion
	}
}