OGRE 1.2.0 RC1 [Dagon] Released!

by | Mar 12, 2006 | News

{mosimage}This is a really big day for us. 'Dagon', now known officially as OGRE 1.2.x (we've adopted the 'even numbers mean stable' standard), is now ready for stable release. This means that all external interfaces on this version are now frozen, and we consider it ready for prime time – all interface breaking development will now move to a new branch of CVS, codenamed 'Eihort', and only bugfixes and other non-interface breaking changes will be made to Dagon from now on.

There is an awful lot to be excited about in this release – if you haven't been following it already, see the full detail of this post for the lowdown. Some interfaces have changed since the
1.0.x branch (Azathoth), for full information on porting your
application from the previous version of OGRE, see the Dagon Porting Notes in the OGRE Wiki.

As with the previous stable version, we're going to release two public 'release candidates' to shake out as many of the last-minute kinks as we can before the final. Having said that, many people have been using Dagon from CVS in earnest for some
weeks or even months without issues, which has been a critical part of establishing Dagon as ready for release, so we're not expecting any major issues – just a few little annoying ones, as is par for the course with these things 😉

In the downloads area you will find new versions of the source code, the SDKs, the XSI exporter and command line tools, and precompiled demos. SDKs for Code::Blocks will also be forthcoming in the very near future. Note that if your modelling tool of choice doesn't have a 1.2.x exporter yet, don't worry- you can continue to use the exporters from 1.0.x, it just means your modeller won't support the new Dagon animation features yet.

Lastly, if you use Visual C++, note that we have dropped support for old versions and officially support only VC7.1 (.Net 2003) and VC8 (.Net 2005) with this release. The standards support in older versions of VC++ (especially VC6) was just too bug ridden to tolerate any longer since it was constraining our development, and the upgrade path to VC8 Express is free, so there is no reason to continue to use outdated versions. You also have the choice of Code::Blocks.

We hope you enjoy this new release!

(Those who prefer to use cvs can switch to the Dagon branch by requesting branch 'v1-2' with your cvs client)


New Features in 1.2.0:

  • Compositing framework
    • Full-screen post-processing effects made simple
    • Easily render to multiple targets, potentially multiple times, and combine the results through shaders
    • Chain multiple compositors together flexibly so post-processing results can be combined simply
    • Scriptable through .compositor scripts so you can write less code
    • Demo_Compositor shows you how to create compositors in code and through script
  • Multiple Render Target (MRT) support
    • Render to multiple targets simultaneously in the same rendering operation
    • Perform advanced effects like deferred shading (demo included)
    • Requires a card which supports MRT
  • RenderTexture enhancements
    • RenderTextures are now created like all other textures, with
      TextureManager::getSingleton().createManual; you just need to set a usage parameter of
      TU_RENDERTARGET
    • Render to the faces of cube maps and to volume slices
    • Retrieve the content of these sub-faces by accessing the
      HardwarePixelBuffer like so:
      tex->getBuffer(x,y)->getRenderTarget(z)
    • RenderTarget::writeContentsToDisk now implemented for all RenderTextures
    • D3D9: RenderTextures of compatible formats now share one DepthStencil surface to conserve memory
    • GL: For faster and more flexible rendertextures use GL_EXT_framebuffer_object instead of pbuffers (if available)
    • GL: PBuffers only used when rendertarget is smaller than frame buffer. If smaller, the framebuffer is used, as this is faster
    • GL: PBuffers are shared between RenderTextures to conserve memory
  • MovableObject changes
    • All MovableObjects are now created through
      MovableObjectFactory, and new factories can be registered by plugins.
      Plugging in new object types generically is now simple
    • SceneQueries can now exclude entire MovableObject types as well as individual objects
    • Added MovableObject::setRenderingDistance which operates like
      the same method of StaticGeometry, effectively limiting the view
      distance of individual objects
    • MovableObject::setVisibilityFlags controls the visibility of
      objects based on a mask set in SceneManager::setVisibilityMask, in the
      same way as SceneQuery works. This is yet another way for you to
      control object visibility, and makes it simpler to turn categories of
      object on / off quickly and efficiently
    • The default values for MovableObject::setQueryFlags and
      MovableObject::setVisibilityFlags on creation of the MovableObject are
      now defined in the static methods MovableObject::setDefaultQueryFlags
      and MovableObject::setDefaultVisibilityFlags. These defaults start out
      at 0xFFFFFFFF to preserve previous behaviour.
  • Billboard / particle enhancements
    • Billboards can now be sorted individually relative to the
      camera to provide correct transparency effects (also applies to
      BillboardParticleRenderer, and a new 'sorted' attribute is available in
      particle scripts)
    • ParticleSystemRenderer can now describe their desired sort mode by overriding '_getSortMode'.
    • Billboards can now have their own individual texture
      coordinates to allow you to display subsets of a texture per billboard
      (e.g. for billboard based text)
    • Particles can now be kept in local space rather than world space
    • Added two new billboard/particle types:
      BBT_PERPENDICULAR_COMMON (perpendicular_common) and
      BBT_PERPENDICULAR_SELF (perpendicular_self). BBT_PERPENDICULAR_COMMON
      makes the billboard plane perpendicular to a common direction, and
      BBT_PERPENDICULAR_SELF makes the billboard plane perpendicular to their
      own direction. It's useful for an aureola around the player and
      parallel to the ground etc. Both of them use an additional up-vector to
      determine the billboard X and Y axis.
    • Added billboard/particle rotation type setting, allowing you
      to rotate vertices or rotate texture coordinates. Defaults to rotate
      texture coordinates to preserve previous behavior. Use new
      'billboard_rotation_type' attribute to set rotate type in particle
      scripts when using BillboardParticleRenderer.
    • Billboard particle renderer now supports setting the billboard origin in particle scripts via 'billboard_origin'.
    • Particle system now allows the user to configure the sampling
      interval, either fixed or based on frame-rate. Default is based on
      frame-rate to preserve previous behavior. Use
      'ParticleSystem::setIterationInterval' to configure iteration interval
      per particle system, or use
      'ParticleSystem::setDefaultIterationInterval' to set the default
      iteration interval for all ParticleSystem instances that don't have
      their own setting. Available in script as 'iteration_interval'.
    • ParticleSystem now supports a 'nonvisible update timeout'
      which means that if a particle system is not visible from any camera
      for the time specified, it will cease to update, saving the expense.
      You can set the default for all systems without their own setting
      through ParticleSystem::setDefaultNonvisibleUpdateTimeout, or set it
      per system (through script as 'nonvisible_update_timeout').
    • Billboardset now supports an 'accurate facing' model so that
      billboard orientation is calculated based on the relative positions of
      the camera and each billboard, which is more accurate but slower than
      the default method (which is to use the camera axes for all
      billboards). This option is available through particle systems as
      'accurate_facing true' too.
    • New BillboardChain and RibbonTrail classes allow you to do 'beam' effects like jet trails and lightning arcs
  • SceneManager enhancements
    • SceneManagers are now constructed from SceneManagerFactory instances, allowing more than one instance of the same type of SM
    • SceneManagers must be constructed first using
      Root::createSceneManager, and can be created based on a scene type mask
      (a binary combination of requested types), or an explicit name
    • Available SceneManager types can be iterated over using
      Root::getSceneManagerMetaDataIterator, each with a type name,
      description, scene type mask and world geometry support flag
    • Using multiple simultaneous SceneManagers, of the same type or different types, is now safe
    • SceneManager::setWorldGeometry now accepts a stream as input as well as a filename
  • Material enhancements
    • Techniques, passes, and Texture unit states can now be named
    • Materials can now extend other materials, through the script
      syntax 'material DerivedMaterial : BaseMaterial', to allow simple
      refinement of existing materials
    • matrix4x4, float4, float9, and float16 in material script now properly load matrices for use with GLSL shader unitforms
    • New auto parameter binding 'pass_number'
    • Serializer now writes out all shader bindings (for tools)
    • Passes can now iterate an arbitrary number of times, either globally or per light
    • New auto parameter binding 'pass_iteration_number'
    • There is no limit on the number of frames for animated textures. There used to be a limit of 32.
    • matrix4x4 in material script now uses same matrix element layout for Cg, HLSL, GLSL
    • New TextureUnitState blending option, blend_diffuse_colour,
      allows you to use the RGB luminence of vertex colours as an additional
      blending parametric
    • New texture addressing mode 'border' and texture unit
      attribute 'tex_border_colour'. 'border' addressing mode will use the
      border colour when texture coordinates outside the range [0.0, 1.0].
    • New gpu parameter 'render_target_flipping', which allows you to adjust
      the position to match with the 'requires texture flipping' flag on render targets when bypassing the standard projection transform.
    • New gpu parameters 'fog_colour' and 'fog_params', allow access fog parameters in the gpu program if needed.
    • New pass attribute 'polygon_mode', allowing you to specify
      solid, wireframe or point rendering on a per-pass basis (instead of
      just an object basis as before)
    • New feature 'material schemes' – every technique can be
      allocated to a scheme ('scheme blah' in technique block), and viewports
      can have a preferred scheme. This allows wholesale switching between
      techniques per viewport, or just globally to do scalable effects, or
      hdr paths etc
    • New Ocean Demo added showing use of CEGUI manipulating programable shader parameters in realtime.
    • New 'alpha' option on texture loading within texture_unit to load a
      single-channel luminence texture into alpha, useful for fixed-function
      alpha textures
  • Animation enhancements
    • Morph and Pose animation
      • Animation of vertex positions in either hardware or software
      • 'Morph' variant is similar to old-skool vertex keyframe
        animation; this is recommended only for legacy applications (e.g.
        MD2)
      • 'Pose' variant is a modern, blendable pose based system
        which allows you to perform much more sophisticated vertex animation
        such as facial animation (using expression and mouth shape keys), and
        can be combined with skeletal animation.
    • Existing animation tracks are now just one type of track, ie NodeAnimationTrack
    • New 'NumericAnimationTrack' allows the animation of any numeric value through the AnimableValue abstraction
    • Significant number of optimisations means that animation is now even faster than before
  • Skinning blending enhancements.
    • Larger skeletons are now possible with hardware skinning.
      OGRE now only passes world matrices for the bones of a subentity
      that are
      actually used, saving shader constants if you split up your mesh,
      should your skeleton get too large for the constraints of the target
      shader model. 
    • Software skinning is now more efficient
      • Temporary blended buffers are now held for a period of time
        per entity before being released back to the pool, which allows better
        frame coherency on these buffers
      • software skinning is now done in object space,
        with additional
        special optimisations for frozen/disabled animation, so that
        the software blended
        vertex datacan be kept for as many frames as practical without
        recalculating it (it will only get released when the entity has been
        out of frame for some time)
  • ManualObject added to make custom geometry creation more accessible
    • Closely mirrors the GL immediate mode interface; create geometry using begin(); position(); normal(); texCoord(); end();
    • Builds data into regular hardware buffers for performance
    • Supports all types of shadows
    • Can convert the result to Mesh if desired for instancing
  • Node enhancements
    • Node::Listener added so you can use Node::setListener to get callbacks when the transform changes
    • Node::setInheritOrientation/getInheritOrientation added
      allows configure the node whether it should inherit orientation from
      it's parent node.
  • Render queue enhancements
    • Render queue groups can now be given an arbitrary uint8 identifier rather than just one of a fixed set of enums
    • Custom render queue invocation sequence per viewport if required
    • Allow suppression of shadow processing and render state changes during custom invocation
    • Ordering / grouping of non-transparents can be changed per invocation
  • Shadow enhancements
    • New shadow type SHADOWTYPE_TEXTURE_ADDITIVE, allowing the
      lighting accuracy of additive shadows with the GPU speed of texture
      shadows
    • You can now disable the rendering of shadows per viewport, to save time in mini-maps / RTTs etc
    • ShadowListener interface added
      • shadowTexturesUpdated allows you to hook into the time
        when shadow textures have been rendered to, but before they are used.
        You can use this to perform custom shadow behaviour such as filtering
      • shadowTextureCasterPreViewProj and shadowTextureReceiverPreViewProj
        fires before the view & projection matrices are set for the shadow
        caster / receiver renders respectively; you can use these hooks to
        provide a specialised camera setup if you want to define custom shadow
        systems
    • Texture shadow casting now fully supports alpha blended / alpha rejection materials for both additive and modulative modes
    • Both stencil and texture additive shadow techniques now fully support alpha rejection on the shadow receiver.
    • Texture shadows now support point lights, uses a directional light
      'look at' targeting mechanism and 120 degree FOV (similar spotlight)
      behavior.
  • Resource management enhancements
    • Added a new predefined resource group called
      ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME ("Internal") for
      dealing with resources created internally by the engine; you can now
      safely unload the default resource group if you choose without
      affecting these internal resources.
    • Added a new meta resource group called
      ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME ("Autodetect"); if
      you use this group name, the real resource group is detected at
      load time based on where the resource is found in the configured
      resource locations. Entity now uses this method by default to load
      meshes so you no longer have to preload meshes in custom resource
      groups if you don't want to (although preloading is often a good idea
      anyway for performance).
    • Resource loading group fallback
      • When a resource is not found in the requested resource group, look for it in the others based on resource locations
      • The group ownership of resources changes when this happens
      • This allows you to load a material from a custom group and have it load textures into a general resource group dynamically
    • ResourceGroupManager::unloadUnreferencedResourcesInGroup now available to unload only resources which are not currently being used
    • ResourceManager::unloadUnreferencedResources / ResourceManager::reloadUnreferencedResources now available to unload / reload only resources which are not currently being used
  • Platform Manager enhancements
    • Added Ogre::PlatformManager::messagePump(RenderWindow*) to the
      platform manager – This moves the Win32 message pump from Ogre::Root to
      the Win32Platform Manager, and the GLX platform messages to the GLX
      Platform manager. On other platforms (Mac & SDL) this has no
      effect. Call this method if not using startRendering (as startRendering
      calls this everyloop for the default renderwindow) to pump messages
      into Ogre while avoiding the OS pcific issues in your own code – allows
      alt-tabbing, etc to work correctly.
    • Timer stability on dual core systems
    • GLX Platform only listens to Window X events when not using
      Ogre input system – allows ability to plug in other input systems
      easier, while not having to pump specific X events into Ogre manually.
    • Added Viewport::setSkiesEnabled() to let users hide skies for
      viewport individually, allow control skies displays or not more easy,
      especially for using multiple viewports.
  • D3D9 enhancements
    • Triple buffering enabled when vsync is enabled
  • GL enhancements
    • Two sided stencil is always supported for GL 2.0 compliant drivers, even ATI
    • Fast texture-to-texture blit, blitFromMemory, and hardware
      accelerated bi/trilinear scaling using FBO. This improves loading time
      in the common case that some textures need to be scaled to power-of-two
      size.
    • Implement Texture::copyToTexture for GL, which was already
      implemented for DX9 (useful for longer term storage of graphics
      rendered to a texture)
  • Camera / Viewport Enhancements
    • Cameras & Frustums can now have custom view and / or projection matrices if required
    • Viewports now have a setting to say which buffers they clear if clearing is enabled (colour, depth, stencil)
    • Added off-axis perspective projection to Frustum and Camera.
      Related functions: Frustum::setFrustumOffset,
      Frustum::getFrustumOffset, Frustum::setFocalLength,
      Frustum::getFocalLength.
    • Added methods to access 'virtual' (reflected if need) or 'real' (unreflected always) world orientation/position of the camera.
  • Added radix sorting routines to allow for faster sorting
  • CEGUI renderer updated to v0.4.x
  • Added IndexData::optimiseVertexCache to allow people to cache-optimise their triangle list indexes
  • Added pulse width modulation option to WaveformControllerFunction
  • Added Root::setFrameSmoothingPeriod() to let users customise smoothing of frame time fluctuations.
  • Every render system config options are stored to configuration file, allowing you to preserve per-rendersystem options even when switching between rendersystems
  • VC6 & VC7.0 (2002) support discontinued; officially supported Microsoft compilers are now VC7.1 (2003) and VC8 (2005)
  • Direct3D7 support removed