• The core of our engine is now available under the GNU Lesser General Public License (with "static linking exception"). Basically, this allows using the engine in closed-source programs, as long as you keep open your improvements to the engine.

  I had a long thought before this decision, always and still being a free software fanatic :) I wrote a short summary of my thoughts, click here to read it (hidden by default, as may be boring to most people).

  1. The initial insight is that with strict GPL, potential proprietary users of the engine wouldn't "open" their product just to use our engine. Instead they would move their interest elsewhere. We're not the only free/open VRML/X3D engine out there, neither we're the the only free/open 3d/game engine out there, and everyone else is available under LGPL (or even more permissible licenses).

  2. The common answer to above argument is that "popularity of the engine is not all that matters". LGPL is, ultimately, a permission to make closed-source software.

     The counter-thought to this is that LGPL still protects the freedom of my engine. You still have to share modifications to the engine, so it's not like properietary software can get all the benefits in some "unfair" way.

• Victor Amat implemented demos of Screen Space Ambient Occlusion using our GeneratedShadowMap. The complete examples, with shaders, are available inside our x3d/shadow_maps/ directory in kambi_vrml_test_suite (SVN only right now). Many thanks!

  Be sure to test these examples with view3dscene from nightly builds, as various problems reported by Victor (related to generating shadow maps) were fixed along the way.

  Some demo screenshots are on the right. They show the same view with/and without SSAO. (The comparison is somewhat unfair, as "without SSAO" versions just have GLSL shaders turned off. But the point is that they don't have smooth shadows (occlusion)).

• New White Dune release supports all VRML/X3D extensions of our engine. Thanks go to Joerg "MUFTI" Scheurich.

• Documentation of our "VRML / X3D implementation status" was refactored, each X3D component has now separate page with support details. This should make it easier to read and find needed things. See the SVN documentation here.

• Also, I noticed today that our nightly builds were down for the last 3 weeks. Sorry about that, fixed now.

Implementation of NURBS is progressing very nicely. In addition to previously announced nodes (rendered curves and surfaces: NurbsPatchSurface and NurbsCurve), we now also handle X3D NURBS interpolators: NurbsPositionInterpolator, NurbsSurfaceInterpolator, NurbsOrientationInterpolator. Using them you can animate movement of objects and viewpoints along the NURBS curves and surfaces.

Also basic VRML 97 NURBS nodes are implemented, for compatibility.

Up-to-date documentation about supported NURBS nodes is here. Some demo scenes are inside kambi_vrml_test_suite in SVN, see e.g. nurbs_curve_interpolators.x3dv and nurbs_surface_interpolator.x3dv.

You can try the new features by using the nightly builds of view3dscene. Or, of course, you can wait for the next stable view3dscene 3.5 release — later this month.

Basic support for X3D NURBS is implemented. NurbsPatchSurface and NurbsCurve nodes are handled following X3D specification.

As a background info: the core of our NURBS implementation (nurbs unit) is adapted from the White_dune source code. (Licensed on GPL >= 2, just like our engine, so no problem here.)

For the next engine release, this NURBS support will be extended. I would like to cover X3D NURBS component up to level 2 and also implement most important VRML 97 NURBS nodes for compatibility (they are similar but a little incompatible to X3D ones).

For now, you can try the new features by using the nightly builds of view3dscene.

view3dscene 3.4 is released! The codename of this release should be "Everything you wanted to know about textures", as most of the new features deal with X3D advanced texturing nodes.

• All X3D multi-texturing nodes implemented. See also clarifications how MultiTexture.mode/source fields work and how to separate them for rgb and alpha channel.

• All X3D cube map nodes implemented. This includes GeneratedCubeMapTexture, very useful to make mirrors, especially with the help of WORLDSPACEREFLECTIONVECTOR extensions.

• All X3D 3D texture nodes implemented.

• DDS (DirectDraw Surface) format is supported, for all texture types (2D, 3D in ImageTexture3D, cube map in ImageCubeMapTexture). S3TC compression, explicit mipmaps are all supported, more details here. New glViewImage 1.3.0 supports reading, writing and even limited editing of DDS images.

• RenderedTexture node is implemented: a texture rendered from a specified viewpoint.

• Passing to GLSL shaders various uniform value types is implemented. This includes vectors, matrices and many more. Viewpoint.camera*Matrix may be very useful to feed to shaders. You can also pass texture nodes to GLSL shader uniforms, following X3D specification.

• New extensions to easily make projective texturing and shadow maps within your VRML/X3D worlds.

• Anisotropic texture filtering (by standard X3D TextureProperties.anisotropicDegree).

• Hardware occlusion query may be activated for rendering, this can speed browsing large scenes enormously. Try it by menu options View -> ... Occlusion Query.

• When using single texturing, you can set environment mode to replace (default is modulate).

• KambiScript functions to operate on string characters: "character_from_code", overloaded "array_set", "array_get", "array_get_count", "array_set_count" for strings.

• As usual, along with view3dscene release, we also release accompanying Kambi VRML engine (version 1.8.0) for developers. Released binaries are compiled with FPC 2.2.4, sources can also be compiled with FPC from trunk (tested on 2009-08-21). I also provide binaries for Linux/x86_64 (not only 32-bit Linux/i386), as I see a demand for it.

New features in SVN:

• RenderedTexture node is implemented: a texture rendered from a specified viewpoint. Useful for many effects. The most straightforward use would be to make a "security camera" or a "portal", through which a player can peek what happens at the other place in 3D world. (Simple example).
• Viewpoint.camera*Matrix output events are implemented, very useful for shaders.
• WORLDSPACEREFLECTIONVECTOR, WORLDSPACENORMAL extensions are documented.
• We have a clear and precise specification how MultiTexture.mode/source fields work and how to separate them for rgb and alpha channel.
• Texture handling code was refactored last week: we have much cleaner implementation now, various bump mapping fixes were done by the way, and all texture generating nodes use now OpenGL framebuffer (possibly faster, and texture dimensions no longer limited by window size).
• Examine mode improved, to be more feature-rich like Walk mode: works nicely with LOD and ProximitySensor nodes, you can click on TouchSensor and such in Examine mode, you can initiate ray-tracer in view3dscene from Examine mode.

Still no official release, but view3dscene 3.4 should be released Really Soon :) For now you can try new features by using the nightly builds.

New features implemented last month in our engine:

• 3D textures (full support for X3D Texturing3D component). In particular, ImageTexture3D supports 3D textures in DDS format.
• New extensions to easily make projective texturing and shadow maps within your VRML/X3D worlds.
• Anisotropic texture filtering (by standard X3D TextureProperties.anisotropicDegree field).
• Hardware occlusion query may be activated for rendering, this can speed browsing large scenes enormously. Implemented both the basic method (see GPU Gems 1, Chapter 29) and more involved algorithm Coherent Hierarchical Culling (see GPU Gems 2, Chapter 6). view3dscene has menu options (View -> ... Occlusion Query) to try it all.
• And many other things: fixes and optimizations for GeneratedCubeMapTexture, glViewImage improvements (you no longer have to open files from command-line), S3TC compressed textures (from DDS; usable as textures, also viewable in glViewImage), sorting transparent shapes (for better blending), exit shortcut for view3dscene is Ctrl+W (escape was too error-prone).

For the brave: you can test these features already by trying the nightly builds (or grabbing source code from SVN and compiling yourself, of course).

Hi! I didn't post a message here since some time, but rest assured that the development of next engine version continues :) Things already implemented in the SVN include:

• X3D multi-texturing.
• X3D cube map nodes.
• This also means that DDS file format (for ImageCubeMapTexture) is implemented (both reading and writing, you can even use glViewImage as a simple DDS editor).
• This includes generating textures on the fly (for GeneratedCubeMapTexture).
• As extensions, I added texture generation modes "WORLDSPACEREFLECTIONVECTOR" and "WORLDSPACENORMAL" (analogous to X3D standard modes in CAMERA space) to make simulating real reflections trivial.
• There is also quite cool new feature in view3dscene to catch a "screenshot" of 3D world around you as a cube map (DDS, or six separate normal images).
• Passing almost all possible VRML types to GLSL shaders is implemented.
• ..and a lot of other cool features are already implemented :)

The plan for the next release (view3dscene 3.4, engine 1.8) is to polish implementation of all above (yes, there are some known problems, also GeneratedCubeMapTexture implementation is severely unoptimal now), and add related texturing and GLSL features:

• 3D texturing (that's easy since we already have DDS).
• Basic implementation of RenderedTexture from InstantReality (that's easy since it's internally simpler than GeneratedCubeMapTexture).
• Finish GLSL stuff by supporting X3D attributes nodes.

For the impatient: nightly builds of vrmlengine binaries (including view3dscene) are available. They are build automatically every night using current SVN code. Use at your own risk, of course — they do contain some known bugs. For now, they are made for Linux and Windows (32-bit).

This week I implemented a demo of Dynamic Ambient Occlusion using our engine.

In related news, last month I also implemented a demo of Shadow Fields. (I forgot to brag about it earlier, so I'm doing it now :) ).

An extremely short summary: both techniques strive to make low-frequency soft shadows (in other words, the kind of shadows you usually see in the Real World) in dynamic 3D environment.

For now, they are just implemented as demos, and are not easily available for non-programmers. You have to actually get the source and compile some example programs to try out this stuff. (Although I think I'll make at least dynamic ambient occlusion available as an easy option inside view3dscene in the future.) The full source code, and example models, are available in SVN, naturally. Simple instructions:

$ svn checkout https://vrmlengine.svn.sourceforge.net/svnroot/vrmlengine/trunk/kambi_vrml_game_engine/

$ cd kambi_vrml_game_engine/3dmodels.gl/examples/shadow_fields
$ ./shadow_fields_compile.sh
$ ./shadow_fields

$ cd ../dynamic_ambient_occlusion
$ ./dynamic_ambient_occlusion_compile.sh
$ ./dynamic_ambient_occlusion models/peach.wrl.gz

There are more sample models in the models subdirectories, and you can test both demos with your own models. Both techniques require highly-tesselated models to make shadows look nice. Shadow fields require preprocessing by included precompute_shadow_field program. Dynamic ambient occlusion doesn't require any preprocessing, but it requires really good GPU (it does ~thousands of texture fetches per pixel in GLSL fragment shader). You can find a lot of notes and links in the README files inside the source directories.

Have fun!

• LOD (level-of-detail) node proper handling.
• Collision.proxy handling (very handy, allows you to make non-collidable but visible geometry, or approximate complex geometry with simpler for collision detection).
• KambiOctreeProperties, an extensions to specify octree limits for your scene. Section "Octrees for dynamic worlds" added to the documentation, to explain how octree works since 1.6.0 version. The shape octree was speed up by mailboxes.
• Various workarounds for Mesa bugs (in particular on Intel GPUs) and Mesa detection improved. This should significantly improve stability for Unix users with cheaper graphic cards. Because of this, also castle 0.8.3 and glcaps 1.1.4 are released, to get these fixes too.
• Various frustum culling optimizations.
• Small improvements in the view3dscene interface: blend status text, a shapes count fix, and keeping the selected triangle when transforming shape.
• The path tracer honors VRML >= 2.0 materials, and VRML >= 2.0 materials have the physical fields. Because of this, also rayhunter 1.3.0 is released.

Arch Linux users may now install view3dscene from SVN easily by view3dscene Arch Linux package. Thanks to Antonio Bonifati! ]]> Sat, 03 Jan 2009 12:00:00 +0000 http://vrmlengine.sourceforge.net/ 2009-01-03 view3dscene 3.2 is released, with a lot of improvements and optimizations for dynamic VRML/X3D worlds. As usual, this is accompanied by underlying Kambi VRML game engine 1.6.0 release. Major changes:

• Our spatial data structure has undergone serious rework, which in English means that your whole scene can be now much more dynamic. Everything can move and transform, and things will work smoothly and fast. All collision detection routines will "see" the most current scene state, which means that you can e.g. click on moving targets, and you will fall down if a hole opens under your feet, and generally you can interact with every dynamic part of your scene without problems.

  I prepared a video showing a simple dynamic world written in X3D and played with view3dscene, see it on the right. The video is only a poor substitute for actually running and playing with this yourself, feeling the smoothness of all editing (the poor framerate of the video is only because of the capturing process...). So after downloading view3dscene, you're welcome to also download this demo dynamic_world.x3dv (or just grab it along with the rest of Kambi VRML test suite) and open it. It shows how you can edit the world by KambiScript, how changing transformations works fast, and how it all cooperates with collision detection — whatever scene you will build, your avatar will move honoring collision detection.

• Changing Switch.whichChoice is greatly optimized. Previously this was very costly operation, now it's instantaneous (almost no work is required). Many other optimizations were done for dynamic worlds, including faster Transform traversing, faster sensor's enabled switching, more reliable starting of time-dependent nodes and many more.

  Thanks to De-Panther for pushing me to implement a lot of these features!

• Dynamic shadows support is greatly improved, finally view3dscene can render with shadows, honoring our shadow's extensions. We also have new shadowCaster extension. Oh, and shadows rendering with transparent objects is fixed. Just try the file x3d/kambi_extensions/shadows_dynamic.x3dv from Kambi VRML test suite in new view3dscene.

  view3dscene has now view mode Fill Mode -> Silhouette and Border Edges, this is very handy for checking whether your models are correctly manifold (this is important for shadow volumes).

• ProximitySensor.orientation_changed, X3DSequencerNode, BooleanSequencer, IntegerSequencer implemented.

  alphaChannel extension field added to all texture nodes.

• Bugfix for open file dialog under GTK 2.14 (like Ubuntu 8.10). Thanks to Graham Seed for reporting.

I implemented a demo of Precomputed Radiance Transfer using our engine.

In a few words, this is a technique to make very cool self-shadowing by soft shadows under dynamic lighting. (Actually it's possible to go much further, see the papers about PRT linked from my README). You can see the screenshots on the right: 1st shows normal OpenGL lighting (without PRT), 2nd shows the simple ambient occlusion per-vertex (this is, in some sense, a special case of PRT), and the 3rd screenshot shows PRT technique in all it's glory.

The full source code is available, naturally. Simple instructions:

$ svn checkout https://vrmlengine.svn.sourceforge.net/svnroot/vrmlengine/trunk/kambi_vrml_game_engine/
$ cd kambi_vrml_game_engine/3dmodels.gl/examples/radiance_transfer
$ ./radiance_transfer_compile.sh
$ ./radiance_transfer models/chinchilla_with_prt.wrl.gz

Inside that directory there are also other models ready to test with PRT. There's also precompute_radiance_transfer to process any 3D model (readable by my engine — VRML, X3D, 3DS, Wavefront, Collada...) into a VRML model that can be displayed using radiance_transfer with PRT effects. There's also show_sh program to view 25 first spherical harmonics (this will be useful if you'll want to understand how PRT works :) ).]]> Sun, 09 Nov 2008 12:00:00 +0000 http://vrmlengine.sourceforge.net/ 2008-11-09 view3dscene 3.1.0 release, along with underlying Kambi VRML game engine 1.5.0 release. Most notable improvements are:

• Scripting in KambiScript language. KambiScript is a simple scripting language, invented specially for our engine. It's powerful enough for many tasks, you can process all VRML data types with it (including vectors, matrices, arrays, images).

  Screenshots on the right show example uses of KambiScript. Endless possibilities are available now for VRML authors, you can write complete interactive 3D games and run them with view3dscene (or any other VRML browser using our engine). Kambi VRML test suite 2.3.0 contains source VRML files with KambiScript tests (see x3d/kambi_extensions/kambi_script_* in there, like kambi_script_ball_game.x3dv or kambi_script_particles.x3dv), you can simply open them in view3dscene.

• Animating camera by animating Viewpoint position (or it's transformation) works.

• Various navigation improvements for scripted worlds: NavigationInfo.type = "NONE" and NavigationInfo.speed = 0 cases are supported. They are useful when you implement whole navigation yourself, by KeySensor and scripting.

  Also view3dscene key shortcuts changed, to allow easily avoiding collisions with keys that you handle through KeySensor and scripting. All menu shortcuts are now with Ctrl modifier (for example, previously you switched collision detection with C, now you have to press Ctrl+C).

• For programmers using our engine, we have VRML browser components. Two flavors: TGLWindowVRMLBrowser (a descendant of our TGLWindow) and, for Lazarus LCL, TKamVRMLBrowser (a descendant of TOpenGLControl). Using them is trivial, just drop TKamVRMLBrowser on the form and call it's Load method — whole rendering and navigation will automatically work. Other Lazarus packages fixes were made, to make them more easily usable. Thanks to De-Panther for pushing me to implement this :)

• Script protocol "compiled:" is implemented, to easily link VRML scripts with compiled-in (written in ObjectPascal) handlers.

• Other improvements: using quaternions for EXAMINE navigation, simple nodes Circle2D, TextureTransformMatrix3D, TextureTransform3D, MultiTextureTransform.

Plans for the next release: first of all octree updating problems will be solved. Right now they are a weak point of our engine — animating geometry by VRML events is unnecessarily time-consuming when collision detection has to be up-to-date. Also more rendering optimizations for animating by VRML events will be done (optimize case when you often change Switch choice, automatically detect when roSeparateShapeStates / ...NoTransform / roNone is suitable).

New features of the engine and view3dscene:

• X3D support (both XML and classic encoding). Our VRML implementation status page has detailed information about supported features.

• Events mechanism (routes, exposed events, sensors, interpolators etc.) is implemented. This allows you to define interactions and animations of 3D world within a single VRML/X3D file, as envisioned in the specifications.

  Four basic sensors are implemented now: TimeSensor, TouchSensor, KeySensor and ProximitySensor. Also Anchor is "clickable" now. For now you have to be in Walk mode with Collision Checking enabled to have picking (TouchSensor, Anchor) working.

  Linear interpolators are also implemented. Some "event utilities" nodes are implemented (including useful Logger node from Avalon extensions). Events to work with bindable nodes (Background, Fog and such) work. Routing events to GLSL shaders uniform variables works perfectly.. Events to control behavior of Inline (and InlineLoadControl for VRML 97) work too. Prototypes and external prototypes also work 100% with events according to specification, so you can pass events to/from prototypes. New Kambi VRML test suite 2.2.0 has some simple demos of our events implementation.

• MovieTexture is handled, with very useful extension to load movie from a sequence of images (with possible alpha channel), this is great for pre-rendered animations of flames, smoke etc. Normal movie formats are also handled if ffmpeg is installed and available on $PATH.

• Recording movies from view3dscene is possible. This allows recording 3D animations to a movie file (with perfect quality, as opposed to using independent programs that capture OpenGL output).

• GNOME users will be happy to hear that view3dscene can be easily used as nautilus thumbnailer, so you can see thumbnails of your VRML / X3D and other 3D model files.

• Many other features, including

  • Extrusion node handling,
  • BlendMode extension,
  • KambiInline extension to automatically replace nodes within inlined content,
  • extension to force VRML time-origin to start at loading time, because standard VRML time origin is uncomfortable in my opinion,
  • new X3D Indexed Triangles/Quads primitives (thanks to completely reorganized mesh renderer code),
  • HAnim nodes support.

• "The Castle" 0.8.2 release also deserves mention, as it fixes support for OpenAL Soft implementation (available on newer Linux distros). It also allows creators of future levels and creatures to use X3D, animating with standard VRML/X3D interpolators, defining level interactions by VRML events etc.

Have fun! You may also enjoy reading an interview with me about our VRML engine on Hiperia3D News (regards go to Jordi R. Cardona!).

We have 2 sensor nodes working already (TimeSensor and KeySensor), 7 linear interpolator nodes, and 5 event utilities nodes (including Avalon Logger node, a useful debugger for events). All exposed fields of other nodes also work, obviously. This is all available only in SVN for now. When I get back from vacation (at the end of August) this work will be continued (many other sensors are easy to implement now, and some existing code should be cleaned and optimized) and it will all be released as view3dscene 3.0.

As a demo, see the 6-second movie on the right. It shows animation in X3D done by routing TimeSensor to CoordinateInterpolator to IndexedFaceSet. The model is "Laetitia Sprints" from web3d.org examples.

Being on SourceForge gives us many new features, most important ones: file downloads use all the power and speed of SF mirrors, development is done inside publicly visible SVN repository, we have a public vrmlengine-main mailing list, we have trackers for bugs, feature requests, patches, there's RSS feed to monitor new releases.

Also, some things now get version numbers: Kambi VRML game engine (1.0.0), Kambi VRML test suite (1.0.0).