mad god's Tiny Hut

mad god's Tiny Hut, home of the *Cosmic Forge*.

This room seems different somehow... Standing here for a while and trying to decipher your feelings you finally decide that unlike the other rooms that one is filled with a fresh air, fresh air for a closed chamber that is. Not sure what to expect you look around and notice that some of images on the walls are ... moving. No, not quite. The content of the images is moving, changing... You find it quite fascinating for a while and then you shake your head and break free of the charm. You turn around and leave the chamber - you have more important things to attend to...

Wiz3D - OpenGL based C# Rendering System

The project has started in the end of June 2012 is developed in spare time.

The goals:

  • Improve C#, OpenGL, 3D Math, General Programming and System Architect skills.
  • Develop a Rendering System which will potentially include an Editor capable of creating games.
  • Develop a game when everything necessary is ready.
  • Have some fun. 

Using OpenTK at the moment mainly for the wrapping up OpenGL API into C# but planning to get rid of it in the nearest future.

See all screen shots in the corresponding album on the Photos & Screenshots page.

Development Log

17 July, 2013

  • Very Long time since the previous update :)
  • This time the Wiz3D Model Importer has been added. See the screenshot here.
  • The following features are supported at the moment:
    • Import of all 3D model formats supported by the Assimp library.
    • Ability to append the model being imported to the currently loaded model (to either join some separate parts or create a single model with LODs).
    • Different loading options (all Assimp options + opacity map inverting).
    • Displaying of loaded model.
      • Ability to display separate LODs.
      • Ability to highlight a set of meshes or all meshes having a certain material.
      • Free camera and model rotation to be able to view the model from different angles and with different lighting.
    • Mesh management:
      • Merging meshes with the same material.
      • Creating LODs from a set of meshes with the same material.
      • Changing meshes' material.
      • Deleting meshes.
      • Reversing meshes faces with or without normals.
    • Full Material editor with ability to edit most of the material aspects (except the most advanced, which usually require some code).
    • Cloning of materials to create slightly modified versions of the existing materials.
    • Textures preview.
    • Animations preview.
    • Customizing names of all to-be-imported resources: model, geometry, animations, materials, textures.
    • Saving all resources to the Resources folder, ready to be used.
    • Log pane displaying the important events, warnings and errors.

30 May, 2013

  • Long time since the previous update. Decided to post a short update so the project does not appear dead.
  • The project is going forward. New features are ready, re-factoring finished. But for screenshots I need models and to import external models comfortably I need ... a Model Importer.
    • For that I need some GUI. Instead of diving in and writing OpenGL-based GUI or trying to find and adopt an existing one, I decided to use Windows Forms for that. Is it bad or good - I'm not sure at the moment.
    • Guess what - for that I also need to run Render Window in a Windows Forms control. OpenTK has GLControl class which is designed for just that. But there is a catch (always is): it is quite low level and does not have much functionality.
    • Since my Framework has been designed to work with OpenTK's GameWindow (mostly for size, inputs and update/render handlers), something had to be changed.
    • I ended up re-factoring GameWindow and GLControl so they have some common functionality (though implemented differently). It all now works fine (so far).
    • So now time to add some GUI controls so I can load external models there, tweak them and save as Wiz3D models to be available for direct loading. This will take some time, so the screenshots and update are postponed.
  • The positive sides of what I am doing right now are:
    • The ability to stick Render Window anywhere.
    • Having the first reasonably small GUI attempt with the Framework.
    • Producing a useful tool for content pipeline.

26 March, 2013

  • Some considerable time has passed again.
  • The engine now supports Particle Systems.
  • Particle Systems are implemented using transform feedback. All computations are performed on GPU.
  • Support of Geometry Shaders have been added to the system specifically for Particle Systems but not limited to them. Any Shader Program now can have Geometry Shader.
  • Particle Systems support:
    • Particle size (static for a particle system), speed stretch, attenuation with age (fade out), rotation (static for a particle system).
    • Controlled additive blending (this support is engine-wide and can be easily included in any shader).
    • Soft particles (to avoid hard clipping).
    • Multiple particle texture (via texture atlas).
    • Usual stuff like different birth areas, birth direction and speed.
    • Some global accelerations such as gravity, wind and custom acceleration.
    • Point forces (attractors / repellers) with attenuation.
    • Clip planes (deflectors) both for clipping and reflecting particles.
    • Warm-up.
  • The behavior of the particles can easily be changed by supplying modified shaders in place of the standard shaders coming with the engine. Also (in the future) more vertex attributes can be added to transfer additional data. The latter will require the Particle System component class to have some override-able mechanisms which is quite easy to organize. Now it is not that important.
  • Depth-depending effects (such as atmospheric scattering) now work with translucent geometry albeit without having effect on it. The work-around at the moment is to apply such effects before the translucent geometry is rendered. Still thinking about it - maybe in the future will introduce special depth buffer for the translucent geometry, not sure.
  • Screen shot is here. Don't judge too strictly - I didn't have much time to look for good textures and hone the effects.

22 February, 2013

  • Wow, long time no updates. So I decided to post one now, before 2 complete months have passed. 
  • Did some re-factoring and a bit of polishing.
  • Diffuse and Opacity maps are now combined into one Diffuse map with alpha during 3D models import.
  • Texture Source now allows specifying the wrap mode.
  • Reduced amount of shaders by adding defines. So instead of having several shaders doing something slightly different we now have a single one controlled by defines. You will still have different shader programs loaded at run time. Just easier to maintain shaders.
  • Introduced alpha cut-off define to the shaders. This is for materials which don't require blending while containing some transparent parts.
  • Introduced per-material 'shadow bias' parameter to reduce shadow mapping artifacts.
  • Introduced ClutterRender, which implements geometry instancing. See the screen shot here. It features:
    • Based on a square area of a certain size.
    • Can be tiled to perform better culling. Visible tiles of the same LOD are batched together when drawing.
    • Supports multiple models, models can contain multiple meshes.
    • Positioning based on RGB detail map (texture).
    • Able to randomize scaling and rotation (around a specific axis) of each instance.
    • Able to use a height map to determine the elevation of instances. Works good in conjunction with Terrain.
  • Added automated binary serializer (just like xml serializer) using .Net Reflection.
  • Made the engine resistant to absence of resources.
  • Introduced geometry feedback feature. Right now it is used to generate CPU-side Height Field (so it is identical to the rendered Terrain). Later the particle systems (when introduced) will probably be based on geometry feedback too (at least I plan to try it).

28 December, 2012

  • Terrain now supports proper lighting and shadows. Had to re-factor my silly global shader concept into the global render mode concept. Material can have special shaders for different modes, otherwise the default are used. Right now three modes are supported: Normal, Shadow Map, Fast.
  • Terrain now supports geometry LODs. In fact any geometry can have geometry LODs if required. Though with terrain the currently implemented LODs look dodgy - too much popping in, trying to devise something else.
  • Terrain now supports detail textures. The amount is theoretically unlimited. Right now application can be only procedural (in the shaders), but later will add the ability to have detail maps too. That should be fairly easy.
  • Few fixes and small features found their way in.
  • Finally uploaded a new screenshot. This demonstrates at what stage the outdoors features in the engine are: terrain, water, skies. You can see the sky gradient, some aerial perspective is applied to the farthest mountains. The sun is somewhere above the camera. The terrain is tile based, using the height & normal maps and vertex texture fetch. The detail textures are applied in the fragment shader using some simple algorithm based on the height and the slope. The water shader has been modified slightly to avoid too much reflection (or it looks like mirror with some waves). Tossed in Mia, duck, sphere and the spot light to make it more interesting. You can see Mia's shadow on the water from the spot light behind her. In the upper right corner is the 'map' showing the current position and everything around within 250 m radius. The tiny island near the center is where Mia is jumping.
    Yocan see the sky gradient, some aerial perspective is applied to the farthest mountains. The sun is somewhere above the camera.
    The terrain is tile based, using the height & normal maps and vertex texture fetch. The detail textures are applied in the fragment shader using some simple algorithm based on the height and the slope.
    The water shader has been modified slightly to avoid to much reflection (or it looks like mirror with some waves).
    Tossed Mia, duck, sphere and the spot light to make it more interesting. You can see Mia's shadow on the water from the spot light behind her.
    In the upper right corner is the 'map' showing the current position and everything around within 250 m radius. The tiny island near the center is where Mia is jumping.

10 December, 2012

  • Long time since the last update. Haven't had much time to do anything, but still have a small progress.
  • Added some basic terrain
    • Big Terrain slabs consisting of terrain tiles, each tile is rendered and culled separately.
    • Height and Normal maps are for the whole slab.
    • Only a single small geometry (vertex and index buffers) is reused for each tile to save memory and data switching.
    • Basic diffuse map for the whole slab at the moment, but planning to add tiled textures for detailing. The texture distribution will be based on height/slope combination at first.
  • Added bounding boxes support (AABBs and OBBs) to early-cull objects. Now the Node has control over which bounding shape (sphere, AABB, OBB) is to use for determining visibility. Spheres are good for general objects and are the fastest, AABBs are good for static geometry such as Terrain and Water and faster than OBBs, OBBs are good for oblong objects such as poles and also for expensive flat objects such as mirrors where more precise culling is of importance.
  • Added geometry caching to minimize data switching and OpenGL API calls. The last geometry is being stored and vertex and index data are set up only when required. This is especially important for Terrain and later will be important when I start sorting the Materials by Textures and Geometries.
  • Next things to do are (roughly)
    • Geometry LOD support. It will be tested on the terrain tiles first but will be generic for any geometry (including animations).
    • Add lighting and shadows support for Terrain - this one is a matter of simple shader upgrade akin to Diffuse shader.
    • Terrain proper texturing (splatting based on height/slope combination).
    • Tri-planar texture mapping for Terrain to get rid of the stretching on steep slopes.
    • Terrain smoothing (maybe).
    • Post-process water. I don't like the current water and it has 'cracks' along the objects crossing the water volume. I'm not sure if the post-process water can get rid of those, but at least it will get rid of additional refraction path when above the water for the cost of the single full post-process. Will see how it goes (it looks promising now).
  • Still no new screen shots. The progress is poor these days and nothing too exciting to show (except of half-baked terrain with slow atmospheric scattering).
19 November, 2012
  • Added aerial perspective to the scattering compositor. Looks all right, I believe, thought I cannot test it properly now - need some terrain for it. I'm guessing that some sort of terrain is coming next.
  • Revamped the serialization - it now uses the true power of the .NET Reflection. It was provoked by the necessity to save compositors per camera. Serialization now is kinda cool - many classes are not even aware of being serialized, well, almost. :) Only fields are serialized at the moment (including delegates, arrays and lists and child classes referred to as the parent class) - decided not to deal with the properties so far. The only 'presence of serialization' in many classes are a few uses of a custom attribute for those member that aren't supposed to be serialized and (for a few classes) the custom attribute specifying the member function to be called just after reading the class instance's data (sort of 'buildAfterLoad' function to bring the object to a working state). Working great, though it took me about 6 good evenings to do it.
  • Streamlined the rendering statistics collection a bit. Right now for each camera the following info is collected: render calls per frame (could be multiple call for a camera), 'renderables' rendered during the last render and total per frame, compositors fragments processed during the last render and total per frame. More info (such as vertices, triangles, state changes, etc.) could easily be added later using the same mechanism. All functionality work only when a certain define is present, so it can be compiled out in no time.
  • No screenshots again. :(

12 November, 2012

  • Finalized compositors per camera. Now every camera can have its own set of compositors (post-processing effects).
  • Fixed few bugs to make sure the mirrors and water (two reflective effects) work flawlessly with the compositors.
  • Implemented atmosphere scattering compositor, though it lacks aerial perspective at the moment, but this should come in soon. It is also slow, since it is highly iterative, but I don't care at the moment - it can be replaced by a simpler version in no time (in fact I already have a simpler version working but it just does not look that good). And I failed to implement the simplest (no iterations) version so far.
  • Performed more some re-factoring. Cameras are no longer components - they are too complex and can be used everywhere, not necessary on the nodes (though they still require a node to build matrices). Two new components (just holding cameras) have been added instead: Player and SpyCamera. Couldn't come up with a better name for SpyCamera and I really abhor 'CCTV' term.
  • Haven't done much on the weekend - was pretty busy and was reading Dan Simmon's "Summer of Night" at free time.
  • Still no screenshots. Will get something by the next weekend to show off, hopefully.
  • Finished 'Dishonored' - it is a good game but somehow I wish they had a more interesting ending, at least showed a small cinematic or something - the frozen snapshots in the 'ether' did not quite fill the gap after all that hard sneaking work.

4 November, 2012

  • Nothing to boast with at the moment. Spent almost two weeks playing 'Dishonored'. 
  • The rest few evenings of these weeks spent on failed attempt to turn sky effect into the scattering effect. 
  • I believe I am at the last mission of 'Dishonored' now, so will return back to Wiz3D on this Tuesday or Wednesday. 

21 October, 2012

  • Wow, time runs fast. Two weeks since the last update. Let's see what we've done. Well, not much of the eye-candy results, unfortunately. So no screenshots this time, hopefully next time I can boast something. 
  • Dropped support of shaders below 1.3 version - the code gets too messy because of defines. Not sure if I shouldn't just jump into 3.0 or even 4.0, but I don't really use that new functionality now anyway.
  • Considerable re-factoring of the framework to support post processing. Implementation of post processing effect chain. Tested with harmless sepia effect.
  • Window re-sizing now correctly affects all entities depending on the window size.
  • Was working on sky and atmosphere scattering. Wanted to implement it as a post process effect, but the mirrors, water and other reflective entities aren't happy with that. So not even sure now what to do. There could be at least two ways. The first is to render the sky dome, so all reflective entities will render it too and it will look nice, but it will not do the scattering (fog) effect in the mirrors and I will have to post process it for the main render target as well. The second way is to make post process effects attached to the cameras instead of having them global, that means that even a small mirror will be able to produce correct reflection with the scattering and will produce a bonus of adding some other effects to it. I believe I'll stick to the second way now and see how it goes.
  • Got rid of the projection matrix for the 2D layer.

9 October, 2012

  • Implemented recursive mirrors.  Works quite nicely. Here is the screenshot along with the projective light.

6 October, 2012

  • Fixed all fresh bugs.
  • Framework changes finalized to accommodate the new water effect, The changes are promising - another little change can enable recursive mirror rendering. That would be quite cool, though impractical for most real-time applications.
  • Finished water effect. Supports reflection, refraction, water clarity (depends on water depth) and a bunch of adjustable water parameters.  Here is the promised screenshot. Though projective lights did not find their way there - I tried but you can show off nicely only one of them, when both effects are on the screenshot they are both unspectacular. Also showing off water in a big cube is kind of strange but I don't have any terrain yet, so...
  • Next are two impractical things: recursive mirror rendering, light reflection from the mirror. I am not sure about the outcome of both of them, but it is cool to try them out anyway. 

2 October, 2012

  • Implemented Projective Light based on the Spot Light. Can be square or round (spot). Supports hard & soft shadows as other light types. I guess all lights with shadows are in! 
  • Added the Water Effect support with refraction, reflection and waves - all usual niceties. Not fully completed but looks quite good already (my wife says it looks like water and very nice, though she has little experience with this stuff and everything that is behaving alike looks like water to her ).
  • Refactored some areas of the Framework to accommodate the new Water Effect, such as delegates to setup Materials, a second camera for Materials to use for render to texture (decided not to use array because I doubt that there would be more than a few cameras in the end, now there are only two).
  • Fixed the nasty bug with texture binding. Long story short - looks like the best way is to make sure that every Sampler uniform in a shader always uses the same (and only) Texture Unit. If you going to shuffle them around you'll tun into troubles sooner or later. Now all works fine.
  • While working on the Water, found that it is not very happy with my Mirrors.  Or should I say the Mirrors aren't happy with the Water. Some brief investigations (around 11.30 pm) showed that I have two elusive bugs - in generating a Mirror camera matrices and in handling shared frame buffers.  Now I have to track them down and exterminate (I knew I should not fudge that perspective projection matrix for the mirrors).
  • Anyway, all in all it was a decent progress. No screenshots this time since I have few things broken and unfinished. Hopefully by the end of the next weekend it will all settle down. 

23 September, 2012

  • Added FrameBuffer class for shared Frame Buffer Objects.
  • Added Cubemap textures support.
  • Added Point Light Shadows, both hard and soft.
  • Refactored main diffuse shader to depend on code-controlled defines. So actually one source can compile into different shader programs.
  • Fixed few bugs. Spent heaps of time on some weird bug with texture binding which appeared after I introduced Cubemaps. Seems like working now, but it still feels weird why it did not work before I made a rather strange fix.
  • Here is the screenshot of two point lights (white & yellow) with shadows.

17 September, 2012

  • Added texture mip-mapping option for individual Textures.
  • Added anisotropic texture filtering option.
  • Introduced Shader defines accessible from the code as enumeration members. It allowed to merge Shaders with the same code base but separate logic here and there (f.e. diffuse, bump, parallax, relief mapping).
  • Added Parallax Mapping shader.
  • Added Relief Mapping shader with correct shadows from other objects, correct occlusion and slightly-soft-self shadowing.
  • Here is the screenshot of the Relief Mapping with probably the most used texture for that technique in the Internet. :)

10 September, 2012

  • Fixed few bugs in the directional light cascaded shadows. Made cascade shadows stable so they don't shimmer when camera moves around or rotates.
  • Added bump map shader and bump map support to the framework. Need to add support for loading 'bump mapped' 3D models too.
  • Added generation of mipmaps for textures. Will make it optional later. 
  • There is the screenshot with a brick texture I borrowed.

3 September, 2012

  • Animations can now be saved and loaded in a baked format. The whole model class can now be saved in a separate file including references to Geometry, Materials and Animation.
  • Added dedicated Logger class with log level.
  • Added dedicated Settings class controlling the global engine setting.
  • Added soft shadows - looks much better now.
  • Added directional light cascade shadows with up to 4 cascades. Potentially cascades can be used for spot light shadows too, but not now. Still some bits and pieces to fix/add/change, but the main things works fine. Mirrors don't work with directional light shadows now because of the minimizing the shadowed area by the viewing frustum. Maybe some time later I'll add 'non-shimmering' shadow mode which covers the sphere around the camera and the mirrors would be fine.
  • Bits and pieces have been changed (hopefully improved).
  • What's next? Well, a lot of things need to be done just for the renderer (no editor or physics), not in the order of any importance:
    • Scene class.
    • 'Projective light'.
    • Particle systems.
    • Bump mapping.
    • Proper calculation of bounding sphere for animated meshes.
    • Shadows tweaking to balance between shadow detachment and self-shadowing artifacts.
    • Optimize shaders.
    • Optimize rendering framework.
    • Reuse Framebuffer Objects when possible, not only render target textures.
    • Proper 'fast' text rendering using baked font atlas texture.
    • Adjustable Texture parameters such as mipmaps and filtering.
    • Fog.
    • Post-processing effects (including screen space anti-aliasing maybe).
    • Sorted back-to-front translucent geometry rendering.
    • Terrain support: generation from a height map, terrain shader with textures blending.
    • Zillions of small and medium fixes and tweaks.
  • No screenshot this time - nothing too exciting, don't have any terrain to show off the directional shadows

27 August, 2012

  • Added support for bone animations. Loading and playing animations.
  • Added support for bone animations to the shaders.
  • Refactored few bits and pieces.
  • Ah, the girl is now fine! Here is the screenshot (if it is possible to convey animations in a single screenshot, but nevertheless).

20 August, 2012

  • Added Assimp library to the executable to load 3D models. Wiz3D engine itself will not depend on Assimp, instead fast everything-pre-computed custom formats will be used.
  • Added code loading a 3D model using Assimp library with Materials and Geometry creation and Textures copying. This code will be used in the editor.
  • Geometries are more versatile now and Geometry Datas support different vertex formats.
  • Added delayed Node parenting and Component hosting for Nodes and Components added during the game.
  • Added delayed Awake and Start execution for Components added during the game.
  • Here is a new screenshot . It shows a bunch of instances of the same model loaded. The model is not properly loaded (though I suspect it was converted from fbx into dae with some flaws) - the jaw, eyes, eyebrows and hair are few centimeters in front of the rest of the body. I checked the node matrices for the sub-meshes - they are all (except the hair) are second level and are identity. 

12 August, 2012

  • Added frustum class which is now used in cameras.
  • Geometries now have bounding spheres and axis aligned bounding boxes. Spheres are now being checked agains cameras' frustums for early renderables culling.
  • Materials having a single renderable are performing culling check BEFORE proceeding with setting parameters.
  • Added optimization for Mirrors which greatly improves quality when camera is very close to a mirror.
  • Cameras now have global shader support which allows specifying a pair of shaders (for opaque and translucent materials) to render ALL geometry. Shadow maps rendering is currently using this feature. The latest screenshot also demonstrates '2D map' that uses a camera with a global shader.
  • Cameras now can have orthographic projection mode.
  • Have done some minor changes/fixes here and there.

8 August, 2012

  • Render targets are now shared in terms of render target textures. Need to take a look to share the frame buffer objects. It is faster to switch target textures than frame buffer objects. Quick test showed that lights shadow maps are doing all right but the mirrors are not (for whatever reason).
  • Was playing around trying to make mirrors show the same 'crispy' image from close up. Got partial success - at some angles it still becomes grainy. Also works only with main cameras. Stumbled upon the lack of cameras' frustum class.
  • Mirror shader now takes shadows into account and does not produce specular when under a shadow.
  • Lights now have 'produceSpecular' parameter which can be turned off.
  • Implemented Image2D component which can have a generic texture or can hook up to any texture using component in any node and display its texture.  The latter is quite useful for debugging and understanding why some things are the way they are. Image2D and Text2D components are both inherited from Element2DBase class which is renderable, has material, a texture and manages on-screen quad placement and sizing. Works well so far.
  • Have done some minor changes/fixes here and there.
  • Next stage is introducing frustums and using it for improving mirrors' quality further (yes I'm obsessed with the mirrors a little bit, but it is a hobby project after all and I'm the only one determining the features so far). Then using frustums to cull invisible geometry (finally!) to cut down on render calls.
  • Still no new screen shots. Had no time to organize it. 
  • The progress is a bit slow, but hey, better that than none at all! 
  • Oh, by the way, Khronos has announced the release of OpenGL ES 3.0!  With some really useful features such as rendering to up to 4 targets at a time. Will definitely switch to this when the time comes.

2 August, 2012

  • Have improved Tex2D component. Next step is to create Image2D component and inherit Text2D from it. Here goes the 2D GUI layer. 
  • Finalized the current serialization code. Saving/Loading scene works like a charm. Still 'manual'. 
  • Prepared infrastructure for shared Render Targets, need to add half-shared later (when only depth texture is shared).
  • Was having some thoughts on how to improve mirror surfaces when extremely close to them. The problem is in the huge field of view. It is fixable by restricting the field of view to the camera's which is looking at the mirror - we can only see that much. The difficulty is to map the rendered image properly on the mirror surface. Even if I get all the math right I'm afraid there might be some artifacts like image jitters when rotating camera. I'll think more about it. 
  • Finally implemented 'castShadows' and 'receiveShadows' flags in Materials.
  • Almost forgot the big thing! Implemented resource management (Textures, Shaders, Buffers, Render Targets, etc.). Took some time - using C# takes its toll here - don't have proper destructors. Now I end up using IDisposable interface (just for compliance) and AddRef/Release scheme. So the good news is when you load the new scene (and ditch the old one) you don't have any unmanaged resources leaks). Tested by creating a bunch of them and checking returned IDs...  The not so good news is that you better be careful when working with the resources. Hopefully it won't be a problem since they only should be used internally and can be used outside for some advanced stuff only. No free cheese here. 
  • No new screen shots because nothing visual has been added (except for nice FPS counter overlay, but it is minor - will make a screen shot when GUI layer will be ready, will try to fetch some nice free textures in the Internet).

29 July, 2012

  • Felt obliged to add some progress here though I am in the middle of some big changes related to scene serialization.
  • Separated Geometry from Models. Now a Model with Meshes use a Geometry with Geometry Datum. It is easy to have a bunch of Models using the same Geometry but different Materials if required.
  • Supporting Static and Dynamic Geometries. Static Geometries use GL Vertex Buffers and Element Buffers which are stored in the 'fast memory'. Dynamic Geometries use client-side arrays which are slower but allow for quick geometry modification.
  • Supporting Joined Static Geometry when the whole Model (one or more Meshes with different Materials) have their Geometry in a single joined Vertex Buffer and also have a single joined Index Buffer.
  • Scene serialization: Scenes with all Nodes and Components can be saved/loaded in the XML file preserving the complete Scene state. New custom Component can be added without much hassle and will support serialization as long as they implement Read/Write functions. Yes, it is a bit manual at the moment but I am planning to use .Net Reflection to auto-serialize objects. Right now Reflection is used to restore a right class from the XML file and it is quite cool.
  • Geometries can be saved/loaded in the binary resource files.
  • Materials can be saved/loaded in the XML resource files.
  • No new screen shots because nothing visual has been added.

22 July, 2012

  • Ended up in front of the computer only at 20.30 in the evening. The day was crazy (like most of the weekend days now).
  • Anyway added support of hard shadows for objects with translucent textures. Decided to go for a separate shader program for it - most of the objects would be opaque anyway.
  • Material diffuse translucency is not yet supported. Will add it later.
  • Also soft shadows would be nice but not a priority.
  • See shadows screenshot.

21 July, 2012

  • Shader Programs now keep track of themselves and are reusable.
  • Added test part of the framework for shadows supporting Spot Lights only. Transparent objects also cast shadows. :) No screen shots yet because I want to improve it a little bit first. As soon as I get it up and running nicely I'll post a screen shot.
  • Was using a mirror to render the Light's Shadow Map texture, I'm thinking of creating a Component that can hook up to any Render Target in the system and display its texture. Would be handy.

19 July, 2012

  • Fixed some minor bugs in transformations.
  • Adjusted framework a little.
  • Implemented render to texture capability.
  • Implemented mirror support as the test & proof of concept. See screenshot of 3 mirrors in the scene. Mirrors support reflections of other mirrors but no recursion at the moment.

17 July, 2012

  • Creating the first entry on this page. The aim of the page is to track down the changes and get overall picture of the progress.
  • The project has started about 3 weeks ago and is developed in spare time. The aims:
    • Improve C#, OpenGL, 3D Math, General Programming and System Architect skills.
    • Develop a light-weight Rendering System which will potentially include an Editor capable of creating games.
  • Using OpenTK at the moment mainly for the wrapping up OpenGL API into C# but planning to get rid of it in the nearest future.
  • Progress so far:
    • General updating and rendering Framework.
    • Nodes as base elements.
    • Renderables (including Meshes), Materials, Shader Programs and Textures are the base elements of 3D content.
    • Render Target (used by Cameras) describes the ... well ... render target. :)
    • Light (directional, point, spot) component.
    • Camera component.
    • Model component (contains a set of Meshes).
    • FPSController component (basic at the moment).
    • Text2D component (rudimentary at the moment).
    • Phong Lighting Models shader is available for decent lighting effects.
  •  Yesterday some Framework re-factoring has been done to cater for the upcoming render to texture capability. A bit more to do.
  • About to implement Mirror object as the prove of concept and unit test for render to texture functionality.
  • The screenshot of the current version.