Moonlight|3D

This is yet another very very late update. The new undo feature is taking shape and the UI changes planned for 0.3.0 are slowly getting there. Other than that, there is some steady polishing of the existing features. Implementing Undo/Redo in an ... [More] already existing application can be a daunting task. The required changes can be huge and the visible impact is approximately zero. In Moonlight|3D this means that every tool that the program has was heavily changed in order to enable the user to undo his actions. Yet, the only visible change in the UI are the new Undo and Redo menu entries in the Edit menu (and Ctrl+Z does it's magic, too). But working with the program feels so much better when you know that getting back the previous state is just a matter of a keypress. Experimenting with your scene becomes so much safer! Not all actions are undoable already. Some actions related to direct operator graph editing and texture mapping are still missing from the list, which is the main reason that Moonlight|3D 0.3.0 isn't out yet. The new toolchest is largely in place, though. There are a couple of small remaining bugs and some missing tool icons, but that will be sorted out eventually. Moonlight|3D 0.3.0 will also introduce "ghost objects". These are old object states that are part of the construction history of an object. They are displayed automatically in the 3D view when an operator graph node other than the last node in an object's construction history is selected. These ghosts are fully editable. This may sound abstract at first, but allows for a couple of neat tricks. For instance, it becomes possible to adjust the low resolution mesh of a subdivided object while having both the low resolution and high resolution version are visible at the same time. A new option to render mesh normals was added to the 3D view recently. This makes tracing down lighting problems or problems with normal interpolation much easier. As always, the nightly builds provide previews of the features that are to come with the next version of Moonlight|3D. However, due to the heavy internal changes that are being made to the program, these nightly builds are much less stable than usual. Feel free to try them out, but you are guaranteed to hit all kinds of bugs in them. [Less]

Moonlight|3D is well on track with the planned major changes coming along nicely. Version 0.3.0 will feature a new improved toolchest, full undo/redo support, editable "ghosts" that show older states of an object (e.g. in a state before a subdivision ... [More] operation was applied), and a much improved property editor. Moonlight|3D is undergoing a big transformation on the way to version 0.3.0 which culminate in very visible user interface improvements when they are finished. First and foremost, the toolchest will get a completely new face. The current hierarchical structure will be replaced by a flat one with icons in categories. These categories will be foldable so that you can easily hide all those icons that you don't need right now. Colorful icons make the tools much easier to find and easier to hit with the mouse. Still, the new layout can display more tools in the same space than the old text-ladden one could. Alongside this toolchest change, undo and redo functionality is currently being added to the program. The usability improvements from this feature are pretty obvious: 3D modeling can be an unforgiving task where a single accidental mouse click can ruin a lot of work - this is when a decent undo feature can save your day. Internally, each single tool needs a dedicated undo to keep overall memory usage low, so this is the single most daunting task on the transition from version 0.2.3 to 0.3.0. Another big improvement is the ability to go back in an object's history and edit an older form of it directly in 3D via "ghosts" - differently colored wireframes of the historic versions of these objects. Last, but not least, changes in the Moonlight Application Framework to the way that properties work made them more flexible. The most obvious benefit that will come from that is the ability to display them in a much more appropriate user interface - proper labels, more advanced widgets and generally a much more intuitive layout. In short, the property editor in Moonlight|3D will get much more usable. Unfortunately, all of this is still pretty much a work in progress. A lot of work remains to be done until these changes are complete. This means that Moonlight|3D 0.3.0 will appear at the end of January 2010 at the earliest. We will publish updates until then so be sure to check back regularly if you are interested. If you have questions or comments, feel free to post them in the forum. [Less]

Moonlight|3D 0.2.3 and the Moonlight Application Framework 0.1.6 are ready! This is also the first release of the Moonlight HDR Viewer tool. This is a small tool to view high dynamic range images. Grab them from the downloads page! Introducing HDR ... [More] Viewer This release cycle introduces the Moonlight HDR Viewer. This is a simple tool for viewing high dynamic range image data. The rendering of the high dynamic range data is hardware accellerated using OpenGL, which means that display updates are truely instant. Radiance RGBE and OpenEXR image files are supported. What's New in Moonlight|3D? Moonlight|3D was subject to a number of small, but noticable improvements. The most important ones are: The property editor has now a "object history" dropdown which makes it easier to select operator graph nodes that influence the currently selected object. The Transform and Extrude tools support snapping. By default, the structural wireframe of mesh objects is now properly occluded. It can also be fully disabled and fully enabled. The Create Box and Create Plane tools can now create boxes and planes with a user-defined initial subdivision (Thanks go to Stefan Altmayer for these patches). The Duplicate Objects tool is now able to apply rotation and scaling to the duplicated objects. The Wavefront OBJ exporter can export material data and is now able to export either the whole scene or selected mesh objects within it. Scenes in Moonlight|3D can easily grow to hundreds of objects with literally a thousand OG nodes containing their construction history. This release removes a few performance bottlenecks with scenes of that complexity. As with all previous releases, this one also contains fixes for lots of bugs. Barring some grave bugs which need fixing, this will be the last release in the 0.2.x series. What's New in the Moonlight Application Framework? Minor improvements have been made to the Moonlight Application Framework: Importers and exporters now can have properties which are displayed by the Import and Export menu actions. Image format detection is much faster now when loading images on a best guess basis. The Radiance RGBE and OpenEXR image format plugins have greatly improved format support and load images faster. Apart from these changes, there was the usual bug fixing. The Moonlight Application Framework will undergo considerable changes after this release, which makes this one the last release in the 0.1.x series. A Glimpse Into the Crystal Sphere: Future Developments Work on the next versions of these programs has already begun. There are a lot of new features in the pipeline. The most important ones are: Improved properties: this will lead to numerous improvements in the program. The most obvious ones will be proper descriptive labels in the UI and UI elements that are more appropriate for the specific values. Also, this will allow much more advanced features like expressions as property values that are reevaluated on the fly. Undo/Redo: implementing this efficiently requires a lot of effort, so this feature might actually be introduced incrementally. A new icon-based toolchest: the icons for the new toolchest have been presented in one of the current progress reports. Unfortunately, the code changes are not yet completed, so this feature had to be delayed. Some development work has already been made on all of the features in this list, so expect at least a considerable subset of them in Moonlight|3D 0.3.0 and the Moonlight Application Framework 0.2.0. [Less]

Moonlight|3D only has seen some bug fixes and minor feature enhancements since the last progress report. Integrating an updated version of Qt Jambi proved to be slightly harder than expected and the encountered complications will delay the next ... [More] release. Development of Moonlight|3D has almost stalled during the last couple of months. Changes since the last status report include only slightly improved mesh rendering and some slight improvements to the Wavefront OBJ exporter: it can now export several objects or the whole scene. Any new release should come with an updated version with Qt Jambi, because Qt Software (formerly Trolltech) has changed the license on the free version from GPL to LGPL. This finally allows binary versions of Moonlight|3D to keep the LGPL that the source only downloads already had. Putting this licensing quirk to rest will be a major relieve. However, upgrading to Qt Jambi 4.5.x has been stalled by some obscure issues that caused a VM crash during the startup of Moonlight|3D. Eskil Blomfeld from Qt Software provided a patch for this issue shortly after I notified him of the problem. The support that these guys give for Qt Jambi - even for users of the free version - is simply amazing. Still, Moonlight|3D has to undergo some testing with the new version of Qt Jambi before there can be another release. This will take its time and therefore we have no clue when the next version will finally appear. Just stay tuned and keep checking back! [Less]

The announced license change for Qt Jambi 4.5 will clear up licensing of Moonlight|3D and the Moonlight Application Framework. Moonlight|3D has received some important bug fixes since the last release and the Duplicate Objects and Transfrom Object ... [More] tool have been improved. There's also a completely new toolchest design being worked on that is icon based, easier to use and has a better visual structure. Nokia has announced that they will discontinue Qt Jambi development and turn it into a community managed project. How this will affect the Moonlight Application Framework and Moonlight|3D remains to be seen. The good news here is that the license will change to LGPL. This will enable us to offer the sources and the binaries under the LGPL. Up until now, only the source was under the LGPL, but the compiled binares were licensed under the GPL. This was a bit dodgy, but we can finally do away with it. The last release of Moonlight|3D contained a few quite severe bugs that appeared when one used certain combinations of the Duplicate Objects, Merge Meshes and Delete Objects tools. These are mostly fixed now in the current nightly builds. The remaining fixes will come in the next couple of days. Also, Duplicate Objects can now rotate and scale objects while duplicating and it can duplicate all children of the original scene element if so desired. This creates true copies of the scene elements rather than instances. There is now a simple snap to grid feature available for the Transform Selection tool that snaps translation, rotation and scale to fixed units. Internally, the program is capable of much more sophisticated constraints for snapping and these will be implemented gradually. These changes will probably make up most of Moonlight|3D 0.2.3, which will be released in the coming weeks. And there are already features in the pipeline for later releases. Florian Niekiel alias rageon has been working hard on a set of icons that will become part of a completely overhauled toolchest in Moonlight|3D. In this new revision of the toolchest, the only text that will remain is the category headers. Everything else will be converted to nice, big, easy to hit buttons. Here are some examples of the icons that will be shown in the toolchest: These icons are from left to right: create cylinder, create light, create simple material, delete selected, duplicate objects, make edge, select object and triangulate. Florian has also drawn an early mockup showing how the new toolchest will be structured: In unrelated news, the Moonlight Application Framework is due to get a complete overhaul for its Property and Value classes and everything related, which will effectively be a major rewrite. The goal is to move away from a hardcoded list of available types and allow property types which are provided by plugins, removing a major limitation of the current implementation. This makes it possible to store much more sophisticated data types in those properties and property sheets will display the correct editors by default more often. [Less]

After little more than 2 weeks, another version of Moonlight|3D is ready. This is mainly a bugfix release to fix some of the major bugs that have slipped into the previous release. The Moonlight Application Framework has also seen a major bug fix and ... [More] a small enhancement. Moonlight|3D has seen the following enhancements: The Delete OG Node tool can now delete nodes with one input and one output slot in addition to nodes with no connected outputs. The active 3D view can now be reset to any of the 4 default views. The following bugs were fixed: Moonlight|3D would not work with system languages that use a decimal separator other than ".". The Delete Object tool caused internal incosistency when used on scene graph nodes with parents. Grouped objects did not render at the correct position in Sunflow under certain conditions. Selection handles for grouped objects were displayed in wrong positions under certain conditions. The Generate UV Map and Merge Meshes tools checked their input insufficiently. Version 0.2.2 of Moonlight|3D is available for Linux and Windows from the downloads page. The Moonlight Application Framework now comes with an enhanced colour dialog (that is being used in Moonlight|3D). Also, a parsing bug in the property editor that occurred with decimal separator other than "." in floating point numbers was fixed. The Moonlight Application Framework 0.1.5 is available as source code for download here. [Less]

After about 6 months of development Moonlight|3D 0.2.1 is finally finished. It is available as source code and in compiled binary from for Linux/i686, Linux/x86_64 and Windows/i686. This release contains a reworked support for UV coordinate editing ... [More] and texturing, improved user control over mesh normals, tools for grouping and ungrouping objects, a tool to merge meshes and an improved operator graph editor. The Moonlight Applicaton Framework has been updated to version 0.1.4, which now provides a plugin for an extensible document file format that allows plugins to store additional data within documents. This new version of Moonlight|3D features improved support for texturing and UV coordinate editing. Textures are now loaded as resources that exist outside the operator graph. Also, there is now a working UV editor in Moonlight|3D (previous releases only contained a partially working implementation). Additionally, mesh can now have interpolated normals to make their surfaces look smooth and seamless. A couple of new tools has been added: Merge Meshes combines selected mesh objects into a single new one. Group Objects and Ungroup Objects do what their name says: grouping objects and breaking up groups of objects. Groups of objects can be transformed together and naturally, these transformations can be animated. The operator graph editor has been improved in various ways: nodes can now be rearranged freely in the editor (and the layout is preserved at all times). Nodes now have tooltips that show the scene graph fragments they emit. When the operator graph fails to evaluate for some reason, there is no longer a barrage of error message dialogs popping up at once. Instead, the operator graph editor shows the affected nodes in red. And the tooltips for these nodes contain hints about the nature of the error. Moonlight|3D 0.2.1 uses a new file format based on the extensible document format introduced in the application framework (see below for more details). This file format is incompatible with previous versions of the program. However, the support for the old file format has been retained in the form of an importer and exporter for the file format used by Moonlight|3D 0.1.5 and 0.2.0. Version 0.2.1 of Moonlight|3D is available for Linux and Windows from the downloads page. The Moonlight Application Framework has seen many bug fixes and two new plugins have been added: a command stack implementation that may serve as an implementation of undo and redo functionality in an application and a plugin for an extensible document format. This XML based file format is designed to be extensible by contributions provided by any plugin. The extensible document plugin is able to handle situations where plugins for certain contributions in a file are not present and can preserve the affected contributions. The Moonlight Application Framework 0.1.4 is available as source code for download here. [Less]

Progress has been slower than usual lately. Nonetheless, there is now a simple, but working UV editor and the support for textured objects has been reworked. A new file format has been introduced, but the old file format is still supported through an ... [More] import/export plugin. The progress that has been made in the last few months has been quite small. This means that despite my hopes for a faster release cycle, I cannot guess when the next release is actually going to happen. But everything that is mentioned in this progress report is already in the nightly builds and you are invited to try them out. If you do and find that you have a problem with one of them or comments, please feel free to leave a couple of lines in the forum. The biggest change of late has been the UV editor. Originally, this has been planned for version 0.2.2, but the work on this has been progressing much faster than anticipated. In the last couple of releases, all that was there has been an empty shell. Now it is filled with some life and can actually be used for UV editing, although it still leaves a lot of room for future improvements. Along with these improvements, the way that textures are handled in Moonlight|3D has been overhauled completely. Textures are now "resources". A resource is a file that is referenced by a Moonlight|3D scene. These live outside the scene graph structure because this simplifies handling a lot. To actually get a texture onto something, you now have to create a material that references that texture resource. All in all, this ends up being much simpler to use than the previous implementation would have been. A new file format has been introduced that enables plugins to save additional data to the Moonlight|3D files. This means that Moonlight|3D will not be able to load and save files from previous versions directly. But the old file format is still supported through an importer and an exporter for that file format. There have also been some fixes to the Wavefront .OBJ importer. In previous versions it would not read some variants of the file format correctly. Also, the exporter for Ogre .mesh.xml files has seen some minor changes that eliminate warnings from the OgreXMLConverter. [Less]

The bad news first: development has slowed almost to a stand still in the last couple of months. The good news: not all hope is lost and there has been some progress. In particular, the mesh rendering performance has improved, grouping of objects is ... [More] now possible and mesh objects can be merged into a single big mesh. Also, mesh normals are now stored explicitely and everything about UV coordinates and textures is about to be redone almost from scratch to make it work for real. Immediately after the release the development of Moonlight|3D has gone forward at quite a high speed, but real life intervened and had me concentrate on lots of other things instead. Therefore, this project is now seeing massive delays. This progress report, in particular, should have been out months ago. And the situation probably will not get better in the foreseeable future. Despite this, Moonlight|3D has seen improvements. The first one was an attempt to improve mesh performance. The changes that were made in the mesh code between 0.1.5 and 0.2.0 changed a lot of internals and prepared it for improvements in both speed and memory usage, but actually caused a performance decrease by the time Moonlight|3D 0.2.0 was released. Since the release, some additional improvements made performance in the backend increase again (but there's a catch that I'll explain in a second) and mesh rendering in the 3D view is now based on OpenGL display lists and it therefore has become a lot faster. Meshes now also have explicitly stored normals for each face vertex. These can be updated automatically so that they match the face normal (producing hard edges in renderings) or so that they match the average of the adjacent face normals (producing the impression of smooth, round surfaces in renderings). This means that rounded objects like spheres don't look awkwardly faceted any more in renderings. You can of course set this individual for each face vertex in a mesh, making it possible to have smooth areas and hard edges where you want them to be. In the future, you will also be able to edit mesh normals manually, once the user interface for this is implemented. The bad news about all of this is that automatic update of face normals mentioned above currently works with a rather low performance, typically eating up the performance improvements that the mesh code has seen otherwise, causing noticeable regressions in the current nightly builds. Also new to the nightly builds since Moonlight|3D 0.2.0 are grouping of objects and merging of mesh objects. It is now possible to group several objects and and transform the whole group. Similarly you can now merge mesh objects into a single mesh. This makes it easier to create a complex object by starting out with a whole set of primitives instead of only one. The operator graph editor is seeing some improvements. The graph view can now be zoomed in or out and graph nodes can now be moved around freely. This requires a new logic for laying out graph nodes which, unfortunately, does not yet work convincingly enough. Also, the positions of the graph nodes are not yet saved to file and are invariably lost when a file is reopened. This will be fixed in an upcoming nightly. All in all, the operator graph editor is still a big construction site and will likely remain that way for a while. Work was also started on an overhaul of all the UV coordinates and textures features in order to make them actually useful. This work will most like not be completed in the next release. Instead this will probably be temporarily utterly broken in Moonlight|3D 0.2.1, but become the main focus for Moonlight|3D 0.2.2. I cannot say when the next release of Moonlight|3D will be made because development has slowed down so much. But you are always welcome to check our nightly builds and comment on them. We really depend on your feedback! [Less]

After about 5 months of development and many unanticipated delays, Moonlight|3D 0.2.0 is finally finished. It is available as source code and in compiled binary from for Linux/i686, Linux/x86_64 and Windows/i686. The main effort for this release went ... [More] into laying the foundations for animations and higher mesh editing performance. This includes ability to create and render keyframe based animations. The Moonlight Application Framework gets an update to version 0.1.3 with many improvements to the property sheet and a new colour selection dialog. This release of Moonlight|3D adds basic support for animations. It is now possible to animate virtually any object property using keyframes. Also, Moonlight|3D can have an unlimited number of animation tracks in each scene. This will serve as the basis for many future features including non-linear animation. Naturally, animated sequences created with Moonlight|3D can be rendered in full or in part into sequences of image files using the new Render Animation feature. Moonlight|3D also gained a new tool named Split Face which cuts mesh faces into halves along a line through two user-selected vertices. Furthermore, the Delete Objects, Delete Vertices, Delete Edges and Delete Faces tools have been unified into a new, much more convenient Delete Selection tool. Other minor areas of the user interface have changed as well: The property sheets finally show much more meaningful labels and limit the number of digits that are displayed for floating point values to a handleable amount. Furthermore, there is now a new colour selection dialog which also provides the possibility to select alpha values. Future releases will extend the dialog to include additional colour space representations to make colour selection even more intuitive. The way in which Moonlight|3D manages its mesh data internally has been changed greatly in this release to reduce memory usage on big polygon meshes and to help gain performance when processing these. While this has already lead to noticeable performance improvements in some situations there are still some tools which do not yet profit from these changes yet and actually have taken a performance hit in this release. We will gradually improve this with upcoming releases and expect to see considerable improvements. Version 0.2.0 of Moonlight|3D is available for Linux and Windows from the downloads page. This release marks the start of the 0.2.x series of releases in which development will focus on three areas: animations, mesh editing performance and improved support for materials and texturing. The Moonlight Application Framework has seen some improvements and bug fixes since the last release. These are: new colour dialog property sheets are now implemented as a plugin support for alternate label texts in property sheet definitions support for alternate sets of default property editor factories for specific property sheet instances complete Hungarian transation (contributed by Gaàl Gergely) complete German transation The Moonlight Application Framework 0.1.2 is available as source code for download here. [Less]