OGRE (Object-Oriented Graphics Rendering Engine)

Change Log

v1.2.3 [Dagon] (17 September 2006) - Maintenance Release

• D3D9:
• Respect displayFrequency option if specified
• Use D3DFMT_UNKNOWN instead of D3DFMT_FROM_FILE for DDS loading routines, allow more fallbacks
• Make sure DestroyWindow is called in all cases on destruction in D3D9 when using OGRE-created window
• Don't try to update RTT/MRT when D3D device is lost
• Fix device lost recovery for secondary windows
• GL:
• Make sure fixed-function LBX_ADD_SMOOTH implemented, even though no direct equivalent for arbitrary GL_COMBINE in GL. GL_INTERPOLATE is the closest
• Fix a problem with the model (world) matrix being incorrectly taken into account when using fixed-function cubic reflection in GL
• TerrainSceneManager:
• Explicitly shut down page source before DLL shutdown, identified by tuan as a cause of shutdown problems in TSM under certain conditions
• Fix terrain pages not using custom assigned render queue
• Resource system:
• Move firing of resource start / end outside the isLoaded() check to ensure that the callback count is correct even if resource state changes
• Fix a bug with ResourceGroupManager::loadResourceGroup - if any resource in the group at the start changed group (because of a resource found in another location not in the group being loaded), iterators are invalidated which caused a nasty crash. Really people should sort out their group locations but detect this condition and deal with it nicely
• XSI Exporter:
• Fix exporting of tangents
• Fix bug with scaling in keyframes should be relative to original bone scale (previously assumed bind scale of UNIT_SCALE)
• Linux:
• Fix compilation of OgreSDLConfig_gtk.cpp with recent libsigc
• Ogre::SDLWindow::isFullScreen implementation
• gcc deprecated warning fixes
• Provide -DOGRE_DOUBLE_PRECISION and -DEXT_HASH through pkg-config
• OSX:
• Universal binaries support
• Dependencies update
• Updated the Ogre Config Dialog to look more like it's windows counterpart
• NOTE: Using Frame Buffer Objects (FBOs) on OSX can cause some visual artefacts, choose "PBuffer" as the "RTT Preferred Mode" when configuring the GL rendersystem until Leopard is released which should fix this problem.
• Code::Blocks:
• project format updated
• STLport no longer required, but special build of MinGW needed for correct DLL handling of std::string
• Node changes:
• If node already attached to a parent, addChild now throws an exception instead of just asserting, helpful to track down this type of bug in release build
• removeChild(Node*) now uses node name to find whether/where to erasing the child (still keep same behavior as previous), increases performance 
• Bugfix for node weighted transform scale blend: should interpolate between old and new scale rather than scaling old scale with factored new scale
• Compositors:
• Eliminate constant recompilation when compositors enabled on more than one viewport at once
• Eliminate extra memory consumption each time CompositorChain is recompiled
• ManualObject:
• Fix crash in ManualObject when silly people call begin() and end() with no data in between
• If ManualObject is already attached to a node when new geometry is added, tell parent to update so potentially new bounds are updated too
• BillboardChain:  
• changing number of elements and chains, enabling/disabling vertex colour and texture coords usage should mark index buffer dirty and rebuild later
• update render queue should take render queue into account
• Tangent calculations:
• Correct bug with shared geometry where each submesh covered only some of the vertices
• Orthogonalise tangent vectors with the vertex normal when generating
• Ensure the correct texture format / num mips is used if texture loaded through declareResource / loadResourceGroup instead of TextureManager::load
• Fixed stencil shadow bug when enabling a custom near clip plane, which in some case missing generate light/dark caps that required by zfail algorithm
• Viewport clear buffers defaults to FBT_COLOUR|FBT_DEPTH, the same as the value defaulted in Viewport::setClearEveryFrame, not 0xFF. More consistent, small speedup and resolves some compositor issues
• Overlay bugfix - when a parent container was using pixel metrics, and the child was using non-left or non-top alignment, the pixel metrics were being used as relative metrics to calculate the childs position in error
• Mesh::clone - fix pose list being empty after mesh cloning
• DeferredShading Demo now compiles under OGRE_DOUBLE_PRECISION mode
• Fix incorrect override on AnimableValue::applyDeltaValue(Real)
• Bugfixes for skeleton unloading
• Fix use of depth bias with CEGui renderer
• Tolerate compile errors in shaders, just log the errors and mark the technique as unsupported instead of requiring app to catch exception
• StaticGeometry was getting the wrong material technique which caused material LOD not to work, and for potentially unsupported techniques to be picked - fixed.
• Fix a bug in vertex morph animation where if the same keyframe was passed as both parameters for the morph (because only one keyframe in a track, or because the time exactly matched a keyframe), the same buffer was locked twice
• Root::addFrameListener now deals with the case where a listener with a given address is removed and re-added before the deferred removal is processed
• Entity::refreshAvailableAnimationState should refresh vertex animation too. Refreshing the animation state should update length if it has changed
• Virtualise a few SceneNode methods so they can be overridden
• Copy pass should copy hash value too. On demand illumination pass compiles should calculate new pass hash value immediately.
• BillboardSet: unreference main buffer when destroying buffers, so the hardware vertex buffer will release back to driver as early as possible
• Fix Ocean demo crashing if there are no supported material techniques
• Safely handle null camera in all cases in Viewport
• Fix a bug in the Milkshape exporter when exporting models imported from other formats which have less position keyframes than rotation keyframes (Milkshape never creates these)
• Fix and enhance BitmapFontBuilderTool
• Miscellaneous detail-level performance improvements
• Documentation updates

v1.2.2 [Dagon] (23 July 2006) - Maintenance Release

• D3D9: 
• when loading DDS files, se 'Ex' versions of DDS loading routines so that user mipmap preferences are preserved
• Initialise D3DTexture::mD3DPool to some value other than D3DPOOL_DEFAULT, if texture loading failed and then later it might re-create as empty texture on device lost/restore
• Fixed checking whether or not device supports mip-map texture when loading .dds texture
• Small optimisations during matrix conversion
• GL:
• updated GL uniform type names to GL2.0 spec as defined in glew.h
• added missing shadow sampler uniform types
• TextureUnitState: Reset mRecalcTexMatrix to false after texture matrix calculated, to avoid recalculating each time
• Fix bootstrap script not accepting autoconf 2.60
• Node: Avoid queueing a node for update more than once, which could result in a crash if node was destroyed
  
• Added missing initialisation of mAutoCalc for RotationalSpline
• MapIterator / ConstMapIterator - fixed peekNextValuePtr
• Fixed shadow_receiver_fragment_program usage with modulative texture shadows
• Added more tests for configure.in
• Solaris 11 (Nexenta OS Alpha 5) build compatibility
• Fixed an inappropriate unsigned casting issue in TextAreaOverlayElement introduced in 1.2.1
• OGRE_DEBUG_MEMORY_MANAGER can now be defined externally which is usefull for batch builds that need to build both versions
• Added MinGW + STLPort version of Code::Blocks project for MeshUpgrader, a few other Code::Blocks project tweaks
• SkeletonInstance::createTagPointOnBone offset position parameter should default to ZERO instead of UNIT_SCALE.
• Slight optimisation/fix of BillboardSet and ParticleSystem:
• Use list<>::splice to move billboard/particle between active and free list. As a side note that removing a billboard which doesn't exist in the active list now causes assertion fault in debug
• BBT_PERPENDICULAR_COMMON no need to generate axes and vertex offsets for every billboards (use common axes and vertex offsets instead).
• Notify particle system renderer attached node only if is configured
• Fix CEGui renderer potential bufer overrun with malformed XML
• Added MovableObject::getVisible allow direct access to the value set by MovableObject::setVisible without the additional conditions of isVisible
• SceneNode::flipVisibility should use object visible flag only, i.e. should not take object upper rendering distance into account.  
• Added missing overridden getMovableType for RibbonTrail
• Added overridden getSingleton* methods to CompositorManager for consistency
• Remove unnecessary normalize calls in normal mapping shaders for optimisation on lower end cards 
• Sphere intersection test with another sphere or point now uses squaredLength() instead of length() to avoid square root
• Fixed a naming bug in the 3dsmax exporter, can now use names with operators embedded
• Added a few missing header files to Mac OSX framework
• SceneNode::_getWorldAABB returns AxisAlignedBox by const reference instead of by value
• Some octree functions const correctness improved
• Tidy ups and minor optimisations for Vector2/3/4 classes
• SDL back-end:
• VSync support for SDL RenderSystem added
• Fix compilation of OgreSDLConfig_gtk.cpp with recent libsigc
• SDL_FreeSurface not needed for screen surfaces
• More corrections to the manual & docs

v1.2.1 [Dagon] (11 June 2006) - Maintenance Release

• Fix bug with software skinning under gcc 4.1 (an optimisation issue which does not occur on stable gcc 4.0 or MSVC)
• Remove unnecessary (and incorrect, although harmless) linker path from platform manager
  
• InputEvent's constructor should take 'when' param as a Real like the subclasses KeyEvent and MouseEvent to avoid truncation
• Fixed bug in edge list builder when dealing with degenerate triangles. Conforming vertex / index data is required to build an edge list, so      throw an exception if this condition is detected
• Fixed HLSL program populating incorrect parameter index of array parameters
• Fixed potential double inserts into mSupportedTechniques while compile materials
• Put RibbonTrail local TimeControllerValue class into unnamed namespace, avoid potential naming conflict and also marked it as private
• Minor issue in Rectangle2D - set the (unused in most cases) mBox member properly instead of some random stack variable
• Fixed animation update problem when animation state changed between end of last frame and beginning of next frame - note this changes the behaviour of AnimationStateSet::getDirtyFrameNumber, if you used this yourself, check the changes
• Fixed a bug causing the transform of an object attached to a bone to never update if its own transform is changed, when the parent skeleton animation is frozen 
• Entity shouldn't force software animation because of stencil shadows if it has shadow casting disabled
• Texture Shadow fixes:
• Fix several bugs with using global custom shadow caster / receiver materials that used vertex / fragment programs
• Fix continuous memory consumption bug when using a combination of modulative texture shadows, custom shadow receivers and spotlights
• Fix bug in setShadowTextureSettings where the previous shadow pixel format settings would be used
• Remove fog-based distance fade of additive texture shadows since it can't work; clamp to border instead
• Fix problem in BillboardSet::setTextureCoords if params are 0,0
• Add compatibility with NVPerfHUD 4.0
• Add missing 'clear' methods to BillboardChain
• Add 'SceneManager::hasCamera', 'SceneManager::hasEntity' etc as requested in the forum
• XSI exporter: Fix a bug when submesh merging is enabled and objects do not have the same geometry format (UV sets or vertex colours) - would cause objects to be leaked and not exported
• CompositionPass should take & return a Material shared pointer by const reference instead of by value
• Ensure correct values are returned from SkeletonInstance::getName, getHandle, getGroup
• Update to latest Code::Blocks project format
• OpenGL fix for parentWindowHandle option under Windows
• Eye vector normalisation fix to the bump map w/ specular shader
• Fix XMLConverter crash with more than 65536 faces
• Ocean demo fixes & enhancements:
• reflection map can now be blurred by using bias to select mipmap level during cube map sampling
• fixed rotation matrix calc for tangent space to object space transformation - Cg, HLSL, GLSL now produce the exact same image
• allow wave amplitude to be much larger now that reflections work correctly on waves
• increased mesh resolution so that large waves aren't so jagged
• SDK setup enhancements:
• Wiki page link on finish page
• Add readme checkbox on finish page so readme.html is opened after SDK finishes install
• Fixed text crop problem on finish page 
• Add shortcut link to relevant wiki page for SDK setup and usage
• Remove  unimplemented FrameEvent method declarations from ParticleSystemManager, shouldn't be there
• Documentation fixes & tweaks

v1.2.0 [Dagon] (Final: 7 May 2006) - Major Release

• Add NV_occlusion_query fallback for cards without ARB_occlusion_query
• Fix a couple of bugs when combining pose and skeletal animation in a single model
• Add RTLD_GLOBAL when loading dynamic libs under Linux - solves problems with DRI drivers
• Compiler2Pass now includes exclusion support for character sets
• Compositor:
• Fix knot material when HDR compositor enabled under OpenGL, now looks the same as D3D
• Gaussian blur compositor added
• Widen CEGui text widgets in compositor demo to prevent name clipping
• Fixed the initialisation of the central sample offsets for vertical blur, caused some artefacts in release mode sometimes in HDR and gaussian blur
• Code::Blocks:
• STLPort import libs no longer required.  DLL is linked directly
• Workaround a problem with STLport which caused filestream problems
• Project dependencies updated
• Removed unused defines - not using explicit dll exports for MinGW builds
• Fixed potential bug in FileSystemArchive::open - Open file stream should check ensure open succeeded
• Apply original fog settings to auto params even when fog override is enabled, since if you want to disable fixed function fog but implement fog in the shader you can't do it otherwise
• Recompile compositor if viewport colour / clear options changed since last compiled, necessary for reliably picking up viewport colours
• Shadows:
• Fixed a problem with using custom shadow caster / receiver materials and transparent objects
• Tweak validation of transparent renderables so that those with more than one pass are only rendered once into shadow textures and once for a receiver pass
• Don't hard code the avoidance of texture shadows in compositor render queue listener, detect reentrancy more generally - allows compositors to be used on texture shadows if required
• Soft shadow example added using gaussian blur compositor on shadow texture
• GLX:
• Closing windows and visibility
• Key repeat issues improved
• GLX Pointer Warp Fix
• Mouse Wheel support
• Clarify assert messages when trying to retrieve invalid software blend data
• Fixed Direct3D9 FSAA options that didn't refresh until selecting another a video mode
• Allow access to the internal inverse transforms in case external apps were using the removed _getBindingPoseInverseTransform
• Fixed memory leak of ManualObject when converted to Mesh
• Fixed issue of global new([])/delete([]) overridden when compiling in VS2005 with managed C++
• Fixed a couple of issues with the sizing / resizing of SDL surfaces
• XSI Exporter now builds successfully against the newer XSI 5.1 SDK
• Fixed a couple of multithreading issues fixed with shared pointers and resource groups

v1.2.0 [Dagon] (RC2: 17 April 2006) - Major Release

• Compatibility with Cg 1.4 (particularly affects GL); also Visual C++ Dependencies updated to Cg 1.4.1
• Code::Blocks project updates
• Compositor demo expanded and improved; now uses CEGui to present all the available compositors and includes lots of new ones including Sharpen Edges, Old Movie, Posterise and HDR
• Fix attaching objects to bones
• Fix crash bug in OgreMeshUpgrade when using meshes with no vertex colour
• Bugfix for software skin blending with position/normal shared buffer with blend position only. Also allow more flexible vertex data layout.
• Fixed bug in default intersection scene query, incrementing wrong iterator in inner loop
• Fixed bug with hardware skinning on cards that don't support UBYTE4 (Geforce 3/4)
• Fonts completely switched to address a legal issue with distributing Tahoma; now using freeware Blue Highway throughout
• Fix crash problems with glPointParameters on some cards / drivers, especially ATI
• Added capability flag for point sprites and extended point parameters; point rendering for billboardset now falls back on non-point rendering if point sprites not available
• Throw exception if trying to attaching movable which already attached to scene node or bone.
• Added missing method Animation::_getVertexTrackList.
• Manual updates
• Make MaterialSerializer match the manual for texture element - allow all optional elements
• Fix segfaults when using an animation with no tracks
• Turn on RTTI for core projects for VC7.1 (already on for VC8)
• Fix shadow volume generation for ManualObject
• More graceful handling when trying to define high-level shaders in a language not possible for the current rendersystem (GLSL on D3D, HLSL on GL). You don't get lots of errors in the log anymore, and technique fallback now works better.
• XSI exporter
• Fix vertex colour export
• Fix translation animation
• Automatically pad mesh bounds when animation takes skeleton outside the original bounds
• Milkshape exporter - fix a translation animation bug
• Fix an ambiguous method declaration on AnimableValue when using a non-const object; would pick the protected version and fail
• Remove old MSVC hash_compare override - this was only required for VC6 and VC7.0 and is no longer relevant. Can cause problems if users are relying on the default hash function.
• Fixed issues with buggy GL drivers claiming GL 1.5 compliance and not supporting ARB_vertex_buffer_object.  F
• Fixed hardware occlusion support for GL render system (should check GL 1.5 or ARB_occlusion_query instead of NV_occlusion_query)
• Binary search optimization of keyframe searching, helps with very large animations.
• Allow different resource group names to be used when creating compositors from script.  Was previously hard coded.
• Fix to SharedPtr with threading support enabled
• Calculating the bone matrices should combine scale as equivalent axes, no shearing
• Make MovableObject::_getParentNodeFullTransform return const reference of Matrix4 and avoid memory copy
• GLSL: Support arbitrary sized uniform arrays of vec4 like Cg and HLSL
• Dr_Bunsen_Head.jpg - texture was NPOT which was screwing up some ATI cards, fixed.
• Avoid divide by zero when setting fog auto gpu program parameter.
• Make 'original scene' compositor source pick up viewport background colours & clear options
• Bugfix for using wrong source in VertexData::reorganiseBuffers
• DataStream issues: 
• Fixed read, get and skip line bug when line too long. 
• readLine and skipLine now implemented in DataStream, derived class doesn't need to override unless they have more effective implementation.    
• Use temp buffer in the stack instead of in the class.  
• ConfigFile should open file in binary mode, since line reading functions might seek backward, and seeking in text mode have problem with CR/LF pairs.

v1.2.0 [Dagon] (RC1: 12 March 2006) - Major Release

• 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 describing their desired sort mode by override '_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 type: BBT_PERPENDICULAR_COMMON (perpendicular_common) and BBT_PERPENDICULAR_SELF (perpendicular_self). BBT_PERPENDICULAR_COMMON make the billboard plane perpendicular to a common direction, and BBT_PERPENDICULAR_SELF make the billboard plane perpendicular to their own direction. In other words, their facing to the given direction instead of the camera. 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 based on frame-rate to preserving 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').
  • Each billboard can now have its own custom texture coordinates instead of merely generated coordinates (which were either the whole texture or grid set)
  • Billboardset now supports an 'accurate facing' model so that billoard 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.
  • 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 set to the border colour when texture coordinates outside the range [0.0, 1.0].
  • New gpu parameter 'render_target_flipping', allow adjust position to accord with requires texture flipping when bypassed standardise projection transform.
  • New gpu parameters 'fog_colour' and 'fog_params', allow access fog parameters by gpu program if need.
  • 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 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 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
  • Both stencil and texture additive shadow technique now fully supports alpha rejection shadow receiver.
  • Texture shadow supports point light, used directional light look at target 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.
• VC6 & VC7.0 (2002) support discontinued; officially supported Microsoft compilers are now VC7.1 (2003) and VC8 (2005)
• Direct3D7 support removed

v1.0.7 [Azathoth] (12 February 2006) - Maintenance Release

• D3D9:
• Fixed device leak when destroying primary window manually rather than via shutdown()
• Potential D3D9 leaks during fatal error conditions fixed
• Fix potential leak when using DDS textures if premature shutdown encountered
• Fix another trailing state issue on device lost/restore, clear all texture units and vertex streams before resetting
• Don't create any mipmaps when building temp surface in blitToMemory
• Fixed a compile bug in double-precision mode
• Floating point texture support now correctly logged
• Fix vs_2_x/a, ps_2_x/a/b detection
• D3D7:
• Fix crash when D3D7 window is minimised
• GL:
• Fix potential performance problems with NPOT pbuffers
• Terrain plugin:
• Light list finding should be specialised for each terrain tile. 
• LOD calculation should use minimum distance between terrain tile bounding box and camera position
• Throw exception when registering a page source for a type which is already present
• Nodes:
• Fixed a bug in SceneNode::setDirection with a local natural facing of something other than +/-Z, and when dealing with different spaces
• TagPoint should always reflect parent entity scale changes
• Fixed crash in SceneManager::destroySceneNode when using auto tracking
• Shadows:
• Fix rendering of texture shadows not respecting getShadowsEnabled() flag on queue group
• Alpha-blended materials can now cast texture shadows accurately
• Correctly render stencil shadows when oblique depth projection in use (use zfail all the time)
• Free up shadow textures immediately when texture shadows no longer in use to save video memory
• Materials:
• Fix incorrect output serialisation of 'modulate' and 'colour_blend' scene blend factors from memory to .material files
• Fix splitting of passes when too many texture units used
• Bugfix for auto gpu program parameters:'view_direction', 'view_side_vector' and 'view_up_vector' should be in world space. Also viewport size params were using render target details instead of viewport
• Particles & billboards:
• Fix billboard orientation when using camera reflection
• AreaEmitter should have a different default 'up' to the default 'direction'
• Fix bug in particle scale affector - should scale from default dimensions in the first instance
• Workaround to avoid std::iostream memory leaks in VC8 (MS bug - until VC8 SP1 arrives)
• Fix Font::StrBBox for strings containing spaces
• Memory manager tweaks to improve shutdown performance when using large containers in debug
• Quaternion now outputs to stream with same element ordering as constructor
• Accessor methods added to retrieve current sky settings on SceneManager
• Add automatic fallback for Vector3.getRotationTo if 180 degree rotation is requested
• Cleaner Implementation of occlusion query delete mechanism. Added destroyHardwareOcclusionQuery and made RenderSystem clean up any remaining queries at shutdown just like RenderTarget
• Eliminate potential temp blended buffer checkout bug: occuring when call TempBlendedBufferInfo::checkoutTempCopies more than once in same frame.
• Fixed rendersystems setClipPlanes sending of user clip plane equations to device (d was inverted)
• Fix bug in edge list builder when indexStart is used
• Fix bug where Math::ASin returned the wrong value for +1.0 and -1.0
• Fix bug in border panel; uvs for centre panel should be updated at the same time as the border
• XSI exporter significant speed improvements and better progress reporting
• Timer more consistent after performance counter hiccups, and will run continuously over the 49.7 days boundary
• Move zziplib headers so external apps are no longer dependent
• Update controllers before updating scene animations in case users use controllers to manipulate scene animation
• Avoid multi-results of same object from OctreePlaneBoundedVolumeListSceneQuery
• Default mMaterialName as well as mpMaterial in SubEntity so they are consistent (issue with StaticGeometry if no material set) 
• Fix infinite loop when RenderQueueListener tried to skip a queue
• Fix crash when creating / destroying Root more than once
• 3D Studio Max exporter now supports Max 8
• New barrel and palette models added
• Many compiler warnings squashed
• Documentation clarifications

v1.0.6 [Azathoth] (20 November 2005) - Maintenance Release

• Visual C++ 2005 now supported, use Ogre_vc8.sln
• XSI Exporter
  • XSI v5 now supported (in addition to v4.0 and 4.2)
  • Material exporter now picks up custom texture transforms correctly
  • Fix for using multiple clusters with envelopes (bone assignment groups) spanning them.
  • Don't export empty submeshes (caused by starting with polys which are  later all reallocated to clusters)
• D3D9 fixes:
  • Render window writeContentsToFile method speeded up + some bugfixes
  • Avoid a memory leak when GPU programs fail to load
  • Fix potential surface leak when destroying a secondary window but not the device
• GL fixes:
  • Don't change GL context while creating a new render window if current context is available
  • Share lists between render window GL contexts
  • Fixed incorrect loaded state when creating a manual texture in GL
  • Fixed many gcc warnings on GL atifs compiler
  • Type correction for external / parent handles in GLX platform & doc corrections
• D3D7 fixes:
  • Fixed Dx7 device lost problems, switching from fullscreen to windowed and back now works in Dx7 too.
  • Fix oblique projection on D3D7 (fix bad clipping on render to texture demo)
• Mesh / Entity fixes:
  • XML format DTD
  • Range of texture_coords attribute should be 0 to 8 not 0 to 7
  • 3D texture coordinates should be considered valid in DTD
  • Mesh::getSubMesh now safely checks for an index out of bounds condition.
  • Unload mesh should clear bone assignments and removes reference to skeleton
  • Added method to access manual levels of detail for the entity. Allow user more control to the lod level (e.g. change material, attach objects).
• Hardware vertex buffer pool fixes:
  • TempBlendedBufferInfo destructor needs to make sure allocated buffer copies have been released - this bug showed up when entities using software skinned skeletal animation were removed from the scenemanager during rendering prior to frame ended finishing
  • Buffer manager must make sure that no buffer copies or free temp vertex buffers exist that are associated with a vertex buffer that is being deleted
• Logging changes:
  • Silently tolerate not having any log files to write to, so people can run logless if they really want.
  • Allow suppression of file output on Log to allow a LogListener-only setup
• Shader fixes:
  • Correct number of constants supported by ps_1_x
  • Fix ps_2_x detection; report as ps_2_a/b but assembler syntax is still called ps_2_x
  • Fixed memory/resource leak of high-level GPU program in the case qhere the high-level portion is loaded, but the low-level GPU program itself never loaded
• Shadow fixes:
  • Fix missing shadow volume extrude program parameters when shadow volume materials initialised somewhere else
  • Resolve an issue when find shadow casters for light, and the light is attached to scene node. Should use derived light position/direction to query for shadow casters
• Material fixes:
• Ensure that custom texture transforms are serialised / deserialised into .material scripts
• When material recompile required, need to unload whole content of material, avoid leak because some TUS animation/effect controllers maybe created.
• Fix cloning problems when using the ACT_TIME auto parameter
• Texture fixes:
  • TextureManager loadImage/loadRawData should be create texture as manual texture without loader, in fact the texture can't auto reload again.
  • Enable/disable 32-bit textures now work properly even if no texture exists, and only reloads the loaded and reloadable textures.
  • You can now access the original dimensions of the texture image even if the final texture dimensions (due to hardware requirements) are different
• Dependencies updated
• Freetype is now v2.1.1.0
• DevIL is now 1.6.7
• zlib is now 1.2.3
• zzliplib is now 0.13.44 (this fixes a memory leak when reloading resources from a zip file)
• CEGui remains at 0.3.x since 0.4.x requires potential changes to custom looks, users are free to upgrade themselves (but will need the source release, not the SDK)
• Particle systems:
• Delay loading of image on ColourImage particle affector to avoid startup overhead, and deal with more formats instead of assuming pixel format
• Should check for duplicates before creating/adding new particle system templates, otherwise leakage
• Disable gcc version script which causes problems in gcc v4.x
• Add the ability to raise and listen in on RenderSystem-specific events (allows people to listen in on device lost / restore if they choose to)
• Fix comparison bug in HardwarePixelBuffer::blit which would cause it to scale unnecessarily
• Solve crash when ray scene query is done without landscape loaded in TerrainSceneManager
• Open data streams one at a time while parsing scripts to avoid opening a lot of disk files simultaneously that may exceed file handle limits
• Allow archives to be unloaded
• Fixed destroying track which maybe absent, just ignore it when this situation happens
• Fix merging of CEGui flags in Linux build
• Don't allow double-load of plugins
• Gracefully deal with invalid requests to use the same SceneNode name more than once
• RenderTarget::writeContentsToTimestampedFile now writes out the date/time in correct human readable format
• Fix for "unknown property."scale" in $Biped_Object" error in 3DSMax exporter
• OverlayElement parent overlay initialisation fixed
• Several documentation corrections

v1.0.5 [Azathoth] (25 September 2005) - Maintenance Release

• D3D9: 

  • Fixed device lost issue with manual textures with manual loaders.

  • Ensure that textures which were unloaded at the time of the device lost remain unloaded after the device is restored (previously these textures would be loaded by the restore)

  • Fix restoration of specified number of mipmaps after device restore

  • Fix mipmap issue introduced in 1.0.4 with textures whose dimensions are not power of two

• GL:

  • context switching should be preserving GPU programs and depth/colour mask settings, because scene manager treat render system as ONE 'context' ONLY.

  • 'Warning texture' now bound to a texture unit if it is used but not defined, e.g. in a shader but the material definition does not include a corresponding texture unit

  • Fix a flipping issue when a viewport doesn't take up the whole of a render texture

• XSI Exporter:

  • Fix export of multiple animations where initial pose is different

  • Material prefix should apply to the exported .mesh as well as the .material

• Fix memory leak on software skinning

• Material: compile illumination passes on demand

• BillboardSet: Optimise updating of bounds when creating a new billboard

• Win32 platform fix: DInput buffer overflows resolved

• StaticGeometry::addSceneNode should cascade as documented

• Ensure HardwareBufferLicensee::licenseExpired is called in all cases

• GLXWindow::resize fixed

• Fix potential memory leak during overlay creation

• Alter bump mapping / offset mapping shaders to handle directional lights as well

• Fix a range issue on the specular bump mapping shader, looks nicer now

• Fix memory leaks when using StaticGeometry & stencil shadows

• Fix TextureUnitState clone bug: _load called after after TUS is cloned so that effect and animation controllers are constructed. Also reduced _dirtyhash() calls while cloning TUS

• Fix off-by-one bug in parseAlphaOpEx when using manual blend

• Fix potential transparencybug: passes can be transparent even if destination blend factor is zero, if source factor is destination-based

• Node: Assert that a node is parent-less before adding it in addChild, avoids inconsistency issues

• Support conversion from and to PF_FLOATxx_R pixel format

• Fix segfault in OgreXMLConverter when built with GCC 4.0

• Fix big endian compilation bug in CEGuiTexture (affects Linux on PPC and OSX)

• Some API and manual clarifications, including:

  • Finally add section on hardware pixel buffers

  • now includes minimum ATI/nVidia card specifications for shaders of a given profile

  • Remove / correct old GUI manual pages

v1.0.4 [Azathoth] (21 August 2005) - Maintenance Release

• Fix texture shadows when using basic SceneManager (not octree or bsp)

• Fix memory leaks in Demo_Water and Demo_VolumeTex

• Add isStillOutstanding method to hardware occlusion queries to promote more asynchronous behaviour

• Fix a couple of squared distance comparison bugs

• Fix OverlayElement::updateTextureGeometry being called repetitively

• D3D _makePerspectiveMatrix fix (left/top/right/bottom version)

• Demo_VolumeTex material loading bug fixed

• Fixed accumulated discrepancy in animation track optimise

• Bugfix to SceneQuery::removeQueryFlags

• Node destruction now cleaner

• Add ability to force software skinning to Entity

• D3D texture bugfixes

  • We need to check the corrected pixel format before determining hardware dynamic/auto-mipmap texture support

  • The D3D render system texture auto mipmap generation should respect the TU_AUTOMIPMAP usage

  • Should check the ability to use dyncamic textures in volume and cube maps before enabling the flag

• Fix remaining device restore problems with manual (e.g. dynamic) textures, RTTs that are never used, and colour state after restore

• Material bug - fixup best techniques container when material copied

• Fix depth bias in D3D9 on nVidia to be more reliable

• Fix iterator invalidation problem in SceneNode::removeAndDestroyChildren

• Quaternion::equals now takes negated quaternion into account, may define the same rotation

• XML Converter issues fixed:

  • crash fix - prevent FileStreamDataStream from deleting stack allocated stream

  • fixed a problem with converting manual LOD levels

• Fixed water demo crash if ESC pressed at config screen

• Fixed Viewport/Camera auto aspect ratio bug - use floating point division, not integer

• getRenderTargetIterator added to RenderSystem to allow external parsing of current targets

• Clamp projected texture in Demo_RenderToTexture to avoid artefacts on some cards

• TagPoint was not inheriting parent entity scale meaning attached object didn't scale with their parents; now they do

• Several small documentation corrections

• Fixed off-by-one bug in SimpleSpline & RotationSpline which caused incorrect interpolation over loop

• Resource group initialised flag is now reset when clearing, allowing scripts to be re-read

• Hardware skinning example shaders now handle directional as well as point lights

• Fixed CEGuiTexture so it frees shared pointer whether it deleted shared texture or not

• Fixed bug in EventProcessor shutdown: wasn't removing its registered frame listener which causes a seg fault if rendering continues

• Infinite loop bug fixed in Matrix3::QLAlgorithm

• Small compatibility fixes for VS2005

• Context switching problem in GL Render system (GLX) solved

• Some const correctness and other tidying exercises

v1.0.3 [Azathoth] (10 July 2005) - Maintenance Release

• Fixed a problem in D3D9 where GeForce 6x00 range was not enabling infinite projection

• libOgreMain.so now only exports symbols based on ogremain.map

• Fixed --enable-openexr argument for ./configure

• XSI exporter - don't crash if textures are not found, just warn instead.  Also trap cases where too many texture coordinate sets are used and warn.

• Last of D3D9 leaks removed

• Extra logging for D3D9 device lost / restore process

• Fix device restore of RTT in D3D9

• Replace SDL hard-coded constant args for SDL_ShowMouse

• Make RenderWindow::windowMovedOrResized virtual & generalised from GL/D3D since they're useful for people with externally managed windows

• Corrected type of the returned value from std::string::find_first_of and find_first_not_of

• Allow external setting of BillboardSet bounds for billboard injection

• Q3A level loader - reject lightmap indexes < 0, not just -1, for greater level compatibility

• Export TagPoint to allow post attach-to-bone modifications

• Set ambient light settings per _renderScene call incase we switch contexts in GL

• gcc 4.0 compatibility and removed the need for GCC_3_1 compiler flag

• In GL, support the GL_MAX_TEXTURE_IMAGE_UNITS_ARB number of texture units when using shader hardware instead of just GL_MAX_TEXTURE_UNITS

• Fix attaching particle systems to bones 

• Implemented vp30, vp40, fp30 and fp40 Cg profiles

• Fixed a 64 bit issue in Serializer::flipEndian

• Add conversion from GpuProgramPtr to HighLevelGpuProgramPtr, and fix mutex usage on existing reverse conversion

• CEGUI v0.3.0 now required

• Fix memory leak in ZipDataStream

• Fix to AnimationTrack::optimise - we should not eliminate all duplicate keys since the boundary values are required to preserve the interpolation shape. In fact, we need to preserve sequences of up to no more than 4 identical keys to preserve tangents for if spline interpolation is used. Any inner ones are removed.

• Matrix4::operator != should take a const reference parameter

• Node::removeAllChildren should notify those children of detachment and clear the child update list too.

• Fix a bug in StringUtil::match where a partial match after a wildcard goes wrong and the wildcard doesn't correctly consume it ready for later matches

• Fixed some variable shadowing warnings in gcc

• Don't try to prep subentities for shadow volumes if they don't have their own geometry

• Fixed DataStream::readLine returning incorrect count and not dealing with reading exactly the max length properly

• Fixed TerrainSceneManager incorrectly calculating normals

• VertexData::vertexStart bugfix for GL render system

• Fix small inconsistency in near / far clip plane in world space between rendersystems

• A few win32 resize / getMetrics fixes

• Allocate initial particle pools on demand to save memory

• 3DSMax exporter - support mirrored bones

• Fix memory leak in Bsp Collision demo

• Correct GLX initialisation issue

• Objects which are attached to bones are now properly picked up by scene queries and cast shadows properly

• Fixed carrying forward of manual loader through Material::applyDefaults

• A few other miscellaneous safety checks

v1.0.2 [Azathoth] (30 May 2005) - Maintenance Release

• Mesh::buildTangentVectors now deals with 32-bit indexes

• Re-introduce commented out degenerate face test in progressive mesh, adds quality at very low LOD levels

• Multisampling in GLX corrected

• Documentation fixes

• A few state optimisations in the rendersystem

• Removed calls to srand in Math - user might want to control random number seeding

• Addition of a few minor 'getter' methods and const-correctness

• Matrix4 * Plane should use inverse transpose to transform plane normal to deal with non-uniform scale.

• GL: throw an exception when we failed to properly initialise a texture, instead of a devide by zero

• Fix for skeleton serializer (showed up in XSI testing) - don't assume every bone has a track.

• VC7.1 + OGRE_DOUBLE_PRECISION fix

• Fix bug in getSquaredViewDepth in WireBoundingBox

• Added useful fuzzy comparison methods to Vector3 / Quaternion

• Add animation optimisation methods to eliminate tracks which do nothing and duplicate keyframes (used by default in XML converter)

• Include quake3settings.cfg in SDK distribution

• Minor particle fixes

• Allow Renderable to determine whether it can be overridden by camera as to the detail level it renders at. Allows us to view the whole scene in wireframe but keep the overlays solid by default.

• Bugfix - when bulk-loading resources, unsupported high-level and assembler programs end up getting loaded since they are part of the declared resources in the group

• Fix resource counting bug on bulk loading

• GLX backdrop image now embedded

• StringConverter::parseUnsignedInt fixed for boundary numbers

• Fixed OgreGLTexture and compressed textures delete [] mismatch

• Timer - compensate for QueryPerformanceCounter hiccups on some chipsets

• MeshUpgrader should set mesh padding factor to nothing to avoid adding extra padding

• Material - restore manual loader and manual flag after applying defaults

• Fixed Node::getPitch/getRoll/getYaw

• Implement ParentWindowHandle for GLX - Disable FSAA for now, it's heavily unstable for NVidia

• Don't try to log exception when no LogManager exists yet

• Allow skeletons to share animations with other skeletons (requires strict skeletal structure matching) Supports a scale option to adapt animation to matching skeletons with different sizes

• D3D9 window resizing issues resolved

• Properly support downgrading to 16-bit textures again via TextureManager::getSingleton().enable32BitTextures(false)

• Small bugfix for TerrainSceneManager (texture coords wrapped at 1 vertex too high)

• Some MingW and some Linux distribution (e.g. Gentoo) build fixes

• Fix multi-pass precision issue on nVidia when using GL

• Fixed Dynlib* deleted 2 times when unloading plugins manually

• Fixed BSP plugin creating materials in wrong group

• Fixed unitialised member mQueuedForDeletion in Pass

• Gui demo control name strings fixed

• ResourceManager::load methods (and derivatives) now reload an existing Resource which is already present, but has been manually unloaded

• Fixes Linux boost linking issue when --enable-threading used.  Modified slightly to check for the existence of the library during ./configure.

• Linux - disabled RTTI and disabled the ability to use undefined symbols in plugin object files.

• Fix ordering of directional lights in GPU programs to be consistent

• Fix reloading of high-level programs

• Don't do anything in SharedPtr::setNull if already null, avoids issues with shared mutex for null shared pointers.

• PanelOverlayElement can now live with materials which have no texture units.

v1.0.1 [Azathoth] (10 April 2005) - Maintenance Release

• Support for Cg 1.3

• ConfigFile no longer crashes on empty parameter values

• Fix crash when using sharing skeleton instance between entities

• Shutdown primary rendertarget last, fix for crash on ATI OpenGL shutdown when using multiple targets.

• Fixed shutdown bug when exiting in frameEnded and using software skinned entities

• Fixed shutdown bug when using a Cg-based custom material in TerrainSceneManager

• Tolerate not having loaded a texture to allow people making editors to apply materials which have missing resources.

• Fixed the case of vertex_program in OgreGLGpuProgramManager.cpp

• Modified --with-platform=GLX to look for X11 headers.

• Fix display corruption on DDS with custom mipmaps via DevIL (ie GL); the custom mipmaps are not loaded yet so just ignore them. D3D9 unaffected.

• Fix bug when using colour_op_ex and alpha_op_ex to supply manual colour and alpha at the same time in the same texture unit

• Don't define *any* memory macros if the user doesn't want them or we are in release mode

• Add CEGUI-OGRE.pc.in back into the CEGUIRenderer.

• Fix bufferering area contention in Zip

• Fixed particle system so custom render queue id is properly passed through to renderer

• Deal with zero-volume meshes in StaticGeometry

• Actually use the left and right flags in StringUtil::trim

• cppunit m4 fix needed for some autotools versions

• Add Exception::getDescription so that it is possible to get the 'description' field of the exception without the rest. This is useful for printing or logging errors compactly.

• Make SceneManager::setSkyBox, setSkyPlane and setSkyDome only set their respective enabled flags at the end of the function. This makes sure that when an exception happens the renderloop will not crash in its next iteration.

• Added missing OgreParticleSystemRenderer.h to OgreMain/include/Makefile.am

• Fixed sysrq key for GLX

• Fixed GLX screenshot colours

• Fixed material exporting in Milkshape

• Back buffer resizing, dedicated depth stencil and lost device / destruction fixes for additional swap chains under Direct3D9

• Added many new shader auto parameters; includes support for equivalents of many RenderMonkey parameter bindings

• Allow usage of external input system (GGI, SDL) with GLX

• Fixed display of self- or common-oriented billboards that are attached to a rotated node

• Fix for CEGUI renderer under latest Linux nVidia drivers; also increases performance of CEGUI rendering

• XSI mesh and skeletal animation exporter

• Added a missing vertexbuffer unlock in MeshSerializerImpl::writeGeometry.

• Add explicitly named methods to ConfigFile to resolve ambiguity when using defaulted paramters

• Minor documentation updates

• Hardware occlusion support fixes

• Clean up some support for D3D9 buffer lock options

• Fixed modifiers getting lost on mouseup

• Frame / input event Listener removal now doesn't invalidate iterators anymore

• Fixed ResourceManager::resourceExists bug which caused it to return true when the resource didn't exist.

• Initialise mAnimController in the TextureUnitState copy contructor.

• Fixed a problem which caused SkeletonInstance::unloadImpl() not to be called on destruction.

• Remove StringConverter downcast warnings from MSVC

• Fixed a memory leak in BspSceneManager when loading multiple maps

• Custom DDS mipmaps now work in GL as well as D3D

• scene_blend now works after D3D9 lost device recovery

• Potential D3D9 blending state optimisation on some cards

• Fixed loading of axes.mesh when displaying debug skeletons

• Specular highlights now look the same in GL as D3D9, and secondary vertex colour now works correctly in GL

• Code::Blocks support and projects added

• Invisible lights are now properly excluded from shadow calculations

• FSAA support in Win32 OpenGL

v1.0.0 Final [Azathoth] (21 February 2005) - Major Release

The final 1.0.0 release includes a set of bugfixes to the original release candidate, and will also see the first emergence of a precompiled SDK for OGRE. Again, if you are upgrading from Hastur (0.15.x) please read the Azathoth Porting Notes Wiki Page.

Bugfixes & changes since RC1:

• Fixed a couple of memory leaks and a buffer overrun in StaticGeometry

• API doc introduction page added

• Fixed version numbers in Linux build system

• ResourceGroupManager iterator bugs and memory leak on removing groups fixed

• Vsync option was not being passed correctly in D3D rendersystems

• Add external access to software blend data in Entity

• Fix DynLib .so appending issue on Linux

• Depth bias fixed on D3D9 and GL

• Fixed problem with particle systems in some fullscreen modes

• Convert paletted images to RGBA automatically

• Fix a skeleton issue when unloading & reloading resources

• Disable fog when rendering shadow textures

• Allow users to configure custom texture shadows; change caster & receiver material and texture format

• Fix a shutdown problem when external apps linked directly to octree plugin

• OgreGuiRenderer project moved from CEGUI source repository to Ogre repository to simplify dependencies

• Be tolerant of externally created LogManager instances

• Fix crash on invalid DXTx surface sizes

• Image based fonts fixed

• API documentation content and style updates

• Update version of image scaling routines

• Fix a bug with the translation of scene_blend modulate

v1.0.0 RC1 [Azathoth] (5 February 2005) - Major Release

1.0.0 is a big release, and due to us wanting to freeze interfaces at the best possible level for 1.0.0 there are more interface breaking changes in 1.0.0 than is typical for previous releases. For the full lowdown on upgrading your code from Hastur (0.15.x) to Azathoth (1.0.x) , please see the Azathoth Porting Notes Wiki Page.

Enhancements and new Features:

• Resource System Overhaul:

  • Resources now addressed through shared pointers

  • Resource groups can now be defined so that you can load and unload resources in groups, and also set up group-specific search paths and scripting tasks.

  • Manual resource provision formalised; there is now a ManualLoader class that should be implemented when creating resources in code; this allows resource reloads to be possible in all cases

  • Streaming support - data is now accessed from Ogre's virtual file system solely through the DataStream class (and subclasses), meaning that accessing very large files efficiently is now possible while still using the resource system.

  • Loading progress reports; you can now register ResourceGroupListeners in order to implement loading bars

  • Thread safety - steps have been taked to make the resource system thread-safe to allow background loading. This feature is experimental and should only be used by experienced users.

• Hardware Pixel Buffers & Image enhancements:

  • Direct access to read / write to texture surfaces through the HardwarePixelBuffer class, including mip levels, cube surfaces and volume slices

  • Pixel formats have been extended, are now unambiguous across endianness, having separate 'native' endian formats and per-byte formats

  • Support for floating-point pixel formats, luminence formats, depth formats, and compressed formats

  • Image class has been tidied and enhanced to support composite images (like cube maps)

  • PixelUtil class now provides access to all pixel format conversion functions, with optimised templated conversion routines available in capable compilers

• High Dynamic Range (HDR) rendering support:

  • Create render textures in floating-point pixel formats

  • Load .hdr or .exr textures from disk using the OpenEXR plugin (optional)

• Particle System enhancements: Particle systems are no longer limited to rendering with billboards, they render through instances of ParticleSystemRenderer subclasses, which can be implemented in plugins and added at runtime. Use of these alternative renderers is scriptable and can be used to implement alternative particle types like ribbons.

• GUI changes:

  • The OGRE internal GUI has been replaced with Crazy Eddie's GUI, a superior GUI system which follows the same kind of design principles as Ogre itself (portable, clean OO code).

  • Non-interactive overlays remain within OGRE itself, the classes have been renamed *OverlayElement instead of *GuiElement to reflect their role

• Material changes:

  • alpha_rejection has been moved from the texture_unit to the pass

  • Linking vertex colours to material attributes; you can now link vertex colours to any of the diffuse, specular, emissive or ambient material attribures, (e.g. 'ambient vertexcolour') rather than the linkage being implicit.

  • You can now define the number of mipmaps to be generated when loading a texture in the material script, from '0' to 'unlimited'

• New StaticGeometry class allows you to batch up individual meshes and render thousands of them far more efficiently than if they were separate movable objects

• GL now supports render textures larger than the frame buffer (through pbuffers)

• D3D9 uses best possible filter method supported by hardware for generating Mipmaps, this can improve display quality especially when using trilinear filtering

• Support all image types that DevIL can load: bmp, gif, hdr, ico, jpeg, pnm, mng and many more

• GLX, SDL, D3D9: FSAA(Full Scene AntiAliasing) support improved

• Image codecs are now completely replaceable, if you wish to remove the use of DevIL

• Better support for 3D and compressed textures

• New and improved demos:

  • 'DynTex' shows how to procedurally generate textures using the new pixel buffer API

  • 'VolumeTex' demonstrates volume rendering and procedurally generated meshes and 3D textures

  • 'Grass' demonstrates the use of the new StaticGeometry class to batch up lots of individual meshes

  • 'Gui' has been updated to use Crazy Eddies GUI.

• Interface to RenderSystem::createWindow and RenderSystem::createRenderTexture cleaned up and made more flexible

• Support Athlon 64 in native 64-bit mode (Linux)

• Support running the OGRE core in double precision floating point mode through the use of OGRE_DOUBLE_PRECISION

• Add 'inverse transform' automatic shader parameter bindings

• MinGW/Cygwin build system using auto* tools included

• Visual C++ 2005 Beta support

Bugfixes:

• Fixed texture_view_proj shader parameter binding

• Terrain now supports texture shadows

• Fixed 4-weight hardware skinning vertex shader

• Fixed possible texture frame overflow in animated texture controller

• GLX: alt-tab now allows mouse to escape window

v0.15.2 [Hastur] (13 January 2005) - Maintenance Release

Changes:

• Stencil shadows:

  • Runtime performance improvements

  • Edge list construction can now deal with non-manifold meshes, and is faster. You can re-calculate edge lists on your affected .mesh files by using OgreXmlConverter to convert to XML and back.

  • Shadow culling fixes including in reflected camera scenarios

• TerrainSceneManager: Fixed crash when you clear the terrain scene but don't call setWorldGeometry again

• Direct3D textures: Prefer D3DFMT_X8R8G8B8 over D3DFMT_R8G8B8 for texture formats, and disable auto mipmap generation when mipmaps == 0

• BillboardSet: avoid double-free crashes under certain calling orders.

• Camera:

  • Better safety checks for bad parameters to setDirection

  • Camera::getCameraToViewportRay now works for orthographic projection

• GL:

  • Added virtual keyword to GLSupport::setExternalWindowHandle

  • Fix a couple of potential consistency issues in fixed-function lighting states

• Scene Queries:

  • Query mask flags for world geometry made more explicit

  • Boolean result from query listeners consistently respected

  • Added specialised BspRaySceneQuery for fast BSP ray results

  • Don't match objects which are attached to detached subtrees of the scene graph

• Font: several fixes to make on-screen fonts much crisper

• Windows: requested size now translated to client area size in windowed mode (except if full window size exceeds the desktop size)

• Material scripts: automatic GPU program parameter 'projection_matrix' now parsed correctly

• VC7.1+ STL: Avoid long shutdown in debug mode

• VC6: Added /Zm option to VC6 to avoid compiler out of heap space errors

• Blender exporter:

  • Fixed calculation of initial bone rotation.

  • Restored possibility to export an armature as mesh.

  • Option to export in objects local coordinates.

  • Allow image textures to be assigned via a material texture channel.

  • Preliminary bump map support.

  • Option to run OgreXMLConverter automatically

• 3DS exporter:

  • Export vertex alpha export as the a component of the vertex color

  • Fixed a couple of bugs in UV export (inc multi-UV export)

  • Fix a bug for IK export

  • Speed up the mesh export process. No very easy to notice for small objects but great speed improvements for very big objects.

  • Any kind of objects can now be part of the hierarchy if they are part of the Skin/Physique modifier.

  • Log a warning when there is a vertex with more than 4 bones assigned.

  • Scale of 0.0 is no longer possible. 0.0 is replaced by 1.0 when used.

  • Animation names are properly exported when using multiple animations.

• Memory manager: Fix use of memory macros without namespace Ogre

• Manual updates:

  • Mention optional alpha components to ambient / diffuse / specular / emissive

  • Documented additional community-contributed particle emitters / affectors

v0.15.1 [Hastur] (28 November 2004) - Maintenance Release

Bugfixes:

• Particle system performance improved

• Blender exporter fixes & enhancements:

  • vertex colours supported

  • initial bone rotation bug fixed

  • location keyframe export bug fixed

• 3DS Max exporter fixes and enhancements
  (Note you must completely delete your existing exporter files and add the new 'Ogre Exporter' button to your interface)

  • Smoothing groups now work correctly

  • Bones without any vertices assignements will be exported correctly

  • Biped export is now automatic and is fixed up

  • Specify edge list precalculation, tangent vector precalculation (normal mapping) and LOD generation

  • Multiple UV channels supported

  • Multiple animation support

  • IK sampling (experimental)

• Lightwave exporter now compatible with 0.15

• Removing texture effects did not remove properly controllers

• MipFilter now set correctly when using TextureUnitState::setTextureFiltering

• Mesh fix: allow manual LOD to be created even after edge lists have been built

• Fixed handling of overlays with 3D elements

• Octree scene queries now deal with null AABBs correctly

• Prevent a memory leak when closing a D3D7 or D3D9 window using WM_CLOSE (e.g. the 'X')

• Added missing toLowerCase call in MaterialSerializer

• Particle System: fix parameter types and descriptions

• Fixed missing _dirtyHash in TextureUnitState constructor

• Fixed a couple of typos in the manual

• Fixed errors when undefining OGRE_FORCE_ANGLE_TYPES

• Fixed bug with aspect ratio of text in relative metrics mode

• Set Terrain query flags so it can be excluded / included specifically in scene queries

• Added stl_user_config.h to ensure use of _STLP_DEBUG is consistent

• BillboardSet did not add billboards back to the free list on clear()

• TerrainSceneManager fix when calling clearScene()

v0.15.0 [Hastur] (23 October 2004) - Major Release

Note: Ogre development branches will now have code names; the 0.15 stable branch is known as 'Hastur', the continuing development branch (which will be released as 1.0) is called 'Azathoth'.

Enhancements:

• Binary mesh format enhanced. Previously the binary mesh format did not support all the flexibility you could attain when you built meshes programmatically. This has been addressed, and the mesh can now store arbitrary vertex buffer formats, precomputed edge lists (for stencil shadows), and tangent-space vectors (for normal mapping). You are strongly adviced to use the OgreMeshUpgrade tool on all your meshes to uprade them to the latest version, and choose 'y' when asked if you want to reorganise your vertex buffers. The 'automatic' option is the quickest way to get your meshes up to date, and you may find them slightly faster to render as a result.
  Bear in mind that the .mesh size will increase because edge lists are precomputed and stored by default - if you don't intend to use stencil shadows then you can disable this with the '-e' parameter.

• OpenGL Shading Language (GLSL) support. This means Ogre now supports programmable shaders written in Cg, HLSL, GLSL and all variants of assembler (DirectX and GL).

• Explicit Radian, Degree and AngleUnit classes. To resolve ambiguity as to which angle unit is being used, all methods which take an angle now take a Radian class. You can pass Degree instances to this too and get automatic degree-to-radian conversion. You can also use the AngleUnit class which defaults to the current angle units (see Math). Note that conversions are inlined and are thus very cheap; although if you want to avoid them entirely, use Radian. This is an interface breaking change, so you will need to update your code to use Radian(radianValue) or Degree(degreeValue) where you are using basic types to store angles.

• Reflection enhancements. Automatic reflections using dynamic planes are now simple to create using MovablePlane, and 'custom near clip planes' (oblique depth projection) are available to allow you to clip reflected geometry to an arbitrary plane without requiring additional hardware support such as user clip planes.

• Per-Renderable custom parameters can now be mapped into vertex / fragment programs (using ACT_CUSTOM) to better customise the look of your programmably shaded objects

• Skeletal animation optimisation: by default it now uses an approximation of true rotational interpolation which is slightly faster; true spherical interpolation is still an option if more accuracy is required.

• Edge list improvements; Ogre can now deal with even more model construction variants while still retaining stencil shadow integrity

• Billboard / particle system index and vertex buffers are now deferred loading

• Blender and Milkshape exporters updated

• GL now has a FSAA option like D3D

• Specialised scene queries for the OctreeSceneManager

• Mesh bounds padding is now more configurable

• Skeleton instances can now be shared between multiple entities to allow optional add-ons to animated meshes

• Transparent materials can now cast texture shadows, if an option is enabled in their material (useful for alpha rejection textures)

• Added GLX platform manager, enabling the use of OGRE on Linux without using SDL. This also has a nice configuration dialog instead of the text based one.

Bugfixes:

• Ogre::String is no longer a subclass of std::string, but a typedef to it. All extra methods which were on Ogre::String are now on the Ogre::StringUtil class. This is to resolve compatibility issues on some STLs; this is an interface breaking change so you will need to update your code to use the equivalent StringUtil methods.

• DirectX no longer prefers W buffers over Z buffers unless 16-bit colour is being used

• DirectInput usage now plays nicer with other apps

• Fixed the number of textures used when a custom number of shadow textures were specified

• Fixed TS_PARENT and TS_WORLD Node transform options

• Fixed LBX_BLEND_MANUAL in GL

• Fixed finding of nearby lights so it takes into account bounds of node

• Avoided ATI shutdown issues in GL/Linux by making the shutdown sequence more explicit

• Initialisation of shadow materials now works when more than one SceneManager is active

• Some frustum calculation issues were resolved, especially calculation of corners and planes in orthographic mode

• use32bitindexes was not being read from XML correctly

• Fixed memory leak when attaching and detaching objects from bones

• Stencil shadows were not working correctly when 2-sided stencilling was not available and there was more than one SubMesh with it's own geometry

• Various other minor issues

Deprecation warnings:

• SceneNode::attachCamera and SceneNode::attachLight, which have been deprecated for some time, have been removed. Use SceneNode::attachObject.

• Internal GUI classes; in the next release, the internal GUI will be removed in favour of Crazy Eddie's GUI, and we advise all users to begin migrating their code now. This covers the interactive GUIs (ie buttons, scroll bars etc) and not static overlays, which will still be available in Ogre.

• NatureSceneManager; this will be moved to ogreaddons in the next version incase anyone wishes to continue to maintain it. The Ogre team have no plans to support this scene manager since TerrainSceneManager and PagingLandscape (in ogreaddons) provide better terrain rendering options.

v0.14.1 (28 July 2004) - Maintenance Release

Enhancements:

• TerrainSceneManager improved

  • Vertex program morphing allows for almost imperceptible leve l-of-detail changes

  • Improved efficiency allows for larger terrains

  • Improved LOD calculation leads to more accurate rendering with the same or fewer triangles

  • Custom terrain materials can now be used

  • Pluggable terrain data sources allow terrain data to come from any source

  • Demo now demonstrates the use of RaySceneQuery to 'stick' the camera to the terrain

• Maya, Blender and 3DS exporters updated

• RenderSystem can now report the texel offset differences between systems (required for CrazyEddie's GUI)

• Code is now more 'MingW friendly', although this is still not officially supported, community supported DevPaks are available from The Agency

Bugfixes:

• Visibility of child objects attached to the skeleton of an Entity was being ignored

• Fixed infinite loop in resize() methods of D3D windows

• Fixed XMLConverter bug when using constant reduction in interactive mode

• Made the XML mesh serializer properly assume 'false' for usesharedvertices and use32bitindexes

• Skeletally animated meshes with a vertex program which did not implement hardware skinning were transformed incorrectly.

• Fixed some driver crashes on GL

• Fixed a few memory leaks, especially when no rendering is performed before shutdown

• Prevented multiple instances of HollowEllipsoidEmitter and RingEmitter from adding their custom params to the dictionary twice.

• Math::UnitRandom should have been Math::SymmetricRandom in RingEmitter

• Corrected docs for TextureUnitState::setAnimatedTextureName

• Fixed light update so that lights attached to nodes update properly even when the node does not change.

• Assign queue groups to manual LOD entities too

• Fix to the early-exit in Overlay::_findVisibleObjects could cause important updates to be missed if the overlay wasn't visible on startup

• Patched the EdgeBuilder (calculates stencil shadow structures) so that it detects when there are too many triangles attached to a single edge, and reverts to not welding vertices across vertex sets. This allow it to deal with multiple capped submeshes with their own geometry (which are manifold in themselves) even if they touch at the boundaries. At the same time it still deals with the case where a model is only manifold when all submeshes are combined (it tries to find this case first).

v0.14.0 (12 May 2004) - Major Release

Enhancements:

• Shadows

  • 3 different techniques:

    • Modulative stencil shadows (simple extra pass darkens the shadowed areas)

    • Additive stencil shadows (masking of light contribution, aka Doom3-style, including a smart pass categoriser / splitter which means you don't need to rewrite your materials)

    • Modulative projective texture shadows

  • Multiple stencil shadow optimisations, including vertex program extrusion, smart light and shadow caster culling, integration with mesh LOD, zpass and zfail methods, 2-sided stencilling, scissor region clipping

  • Texture shadows fade out at the far distance and around the edges of spotlight, hiding the finite edges of these shadow types

  • Important: Those writing custom SceneManager implementations will have to review the changes to the render queues and render sequence when shadows are enabled, since supporting several types of shadows has required these processes to be significantly enhanced and decomposed into multiple parts (which should lend themselves to customisation in your SMs if you need them). In particular, note that the signature of SceneManager::_findVisibleObjects has changed so if you override this you will need to alter yours too - the compiler will not tell you about this!

• Hardware Skinning

  • Skeletal animation can now be driven using vertex programs

  • Number of bones limited only by your target vertex program version

• General purpose projective texturing. Projective texturing was possible in Ogre before, but it required you to manually set up the texture matrices. Now there is a simple 1-method call which allows you to link a texture unit to a Frustum instance, and it will automatically sync the projection of the texture with changes to the frustum.

• Node/SceneNode enhancements. You can now make a node automatically track (constantly look at) another node, and all transforms now take a 'transform space' parameter to make it easier to perform transformations relative to any space.

• Skeleton instances. The sharing of skeletons between multiple animated objects has been made more flexible so that you can now more easily hook up external effects on the bones on particular instances of that skeleton (in entities); applications such as manually controlling bones or ragdoll simulations benefit from these enhancements.

• External Texture Sources. You can now register external texture sources in order to feed texture data in from another source; this has been used to render video through a texture for example, although the technique can be used for many other things.

• Updated GTK demo showing you how to embed an Ogre window in a GTK application.

• Added an offset (parallax) mapping example to the Dot3Bump demo, along with a normal mapped statue

• Mac OSX now supports Cg so the plugin has been enabled

• Introduced the Frustum class as a superclass of Camera, abstracting many of the features so they can be reused in other situations like texture projection.

• Updated Blender and Lightwave exporters

• SubEntities can now have their visibility toggled individually

• Hardware occlusion query support

• Animation looping can now be disabled on AnimationState

Bugfixes:

• Too many to list individually; please read the CVS log for a full account.

v0.13.1 (1 March 2004) - Maintenance Release

Enhancements:

• Updated Blender exporter, now includes a GUI and full skeletal animation support

Bugfixes:

• Removed redundant Demo_TechDemo.vcproj link from Ogre.sln

• Removed the forced normal normalisation code from the D3D renderers, it is not required so long as the models have unit-length normals, and this is now fixable on a per-Entity basis. Including this code in the render system caused some state management problems with SceneManager.

• D3D7 now correctly records all capabilities (inc cubemapping, anisotropy)

• Fixed a bug with multiple attachments of objects to bones. Previously attached objects were not always properly visible and/or did not move correctly.

• Fixed a crash bug with ConfigFile when an empty value was specified

• Win32Input8::capture() should not capture input types which are disabled

• Fixed Wings exporter 'v' texture coordinates

• Fixed AxisAlignedBox::scale

• Particle fix, could result in stuttery particle emission in some cases

• Fixed a couple of problems with the pass map custom sort handler which resulted in "Error inserting new pass entry into SolidRenderablePassMap" assert.

• Small refapp fix for segfault when using objects without an ODE body

• Fix for HardwareVertexBufferBinding::getNextIndex not incrementing the next index properly.

• Added pthread check to configure.in

• bootstrap now deals with automake 1.8

• Relative mouse coordinate fixes on linux

v0.13.0 (18 January 2004) - Major Release

Changes since 0.12.3:

• Major material upgrade! This is a subsection of it's own..

  • Support for vertex and fragment programs (shaders), including:

    • Low-level assembler programs under D3D9 (vs_1_1, vs_2_x, ps_1_x, ps_2_x) and GL (NV_texture_shader, NV_register_combiners, arbvp1, arbfp1, ATI_fragment_shader)

    • High-level program support via plugins, so far we support Cg and D3D9 HLSL. Cg compiles down to D3D and GL assembler, and includes converters to non-assembler formats including NV_register_combiners and ATI_fragment_shader so you can write a single program for all targets.

    • Support for automatically updated parameter bindings such as 'object space camera position', 'object space light direction' and many more

    • Programs can be defined and reused many times with different parameters, all through .material scripts

  • Materials now support multiple 'techniques', which can be used as automatic fallbacks for older cards which don't support the requisite features for your preferred shading approach

  • Material LOD - you can tell materials to change technique over distance to save rendering power on distant objects; this is subject to the same control parameters (camera bias and entity bias) that is used for mesh LOD so you can tweak it heavily

  • Scriptable multipass rendering; you can now specify multiple passes in one material if you wish, and those passes can also be iterated once per light automatically, and the engine will call the pass with each nearby light

  • The .material script format has been extensively upgraded to handle all these new options; however if you have 0.12.x or previous scripts you can automatically update them using the OgreMaterialUpgrade tool

• Light management upgraded; you can now have an unlimited number of lights in the scene, and OGRE will pick and use the 'n' closest lights ('n' is configurable per pass in the material scripts) which are within their attenuation range when rendering an object. This makes light management much more practical, especially when using vertex and fragment programs. As mentioned above, passes can even be configured to iterate using the 'n' nearest lights.

• More texture formats supported: we now support 1D textures, compressed textures (DXT formats), volume textures (true 3D textures, not just 6 faces like cube maps), and loading all of the above from the .dds format, even in GL.

• XCode IDE support on Mac OSX

• Precompiled header support on VC6 and VC7, this makes compilation a lot faster.

• Updated 3DS and Maya exporters

• Frame events can now be raised externally, which makes it easier to update the internal state of particle systems, controllers et al when you're running your own rendering loop instead of using Root::startRendering.

• Texture filtering can now be controlled more finely by optionally setting the min, mag an mip filter instead of one abstracted filter type.

• Fonts now look cleaner, texture size has been optimised and filtering tuned

• The 'v' texture coordinate has been flipped so that the origin is now in the top-left, this removes the need to flip textures and improves loading times as well as making compressed texture support feasible. The .mesh format will be converted on the fly automatically, but you should use OgreMeshUpgrade to fix it permanently

v0.12.3 (4 January 2004) - Maintenance Release

Changes since 0.12.2:

• Fixed a problem with overlay sizes when using multiple render targets

• Fixed a bug with frame rate stats when using multiple render targets

• Fixed a few boundary conditions in the mesh LOD generation which could cause crashes

• GL render system now pumps events properly in Windows

• RenderTarget::writeContentsToTimestampedFile erroneous characters removed

• Compatibility with new STLport version (4.6)

• Fixed a few memory leaks in D3D

• Fixed a buffer overrun problem in TextAreaGuiElement when using '\n'

• Fixed a precompiled header option which sneaked into 0.12 in VC6 OgreMain

v0.12.2 (21 November 2003) - Maintenance Release

Changes since 0.12.1:

• Blender exporter updated; now supports the latest version of Blender, and also supports animation

• Wings3D exporter updated, now supports the new uv exporting format of 0.98.16b

• Fixed bug in BspIntersectionQuery which caused intersectins to be reported between entities and the world when collision was disabled

• Meshes exported with more than 4 bone assignments per vertex now have their weights rebalanced to just 4 automatically on conversion to .mesh

• Fixed a bug in Quaternion::Slerp which resulted in a non-unit Quaternion being returned sometimes when the 'shortestPath' option was used. This manifested itself as oddly scaling bones when animating an entity

• Fixed a bug in ray / plane intersection where it was incorrectly concluded that the ray was parallel to the plane

• Fixed some D3D memory leaks

• Fixed some Mesh automatic loading and unloading issues

• Colour values in XML files are now parsed as r,g,b,a instead of a packed long

v0.12.1 (12 October 2003) - Maintenance Release

Changes since 0.12.0:

• Added new, improved Maya exporter from macross and fifty1

• Fixed bug in the TerrainSceneManager where we were locking a write-only buffer for reading

• Added lines in bootstrap to make sure the correct versions of auto* tools are used on Gentoo

• Fixed screenshot taking bug in Direct3D9 on some older cards

• Fixed bounding boxes on skeletally animated entities with other entities attached to bones

• Fixed particle display problem in VC6 release mode

• Fixed links in tutorials index

• Fixed bug in BillboardSet::removeBillboard and getBillboard when indexing a billboard in the latter part of the list

• XMLConverter now deals with multiple texture coordinate sets properly

• Fixed minor issue in StringConverter's quaternion handling

• NatureSceneManager now clears down terrain data properly

• New option in ConfigFile to turn off trimming of values, used in loading ogre.cfg since some ATI drivers have a trailing space

v0.12.0 (23 September 2003) - Major Release

Changes since 0.11.0:

• Complete overhaul of core geometry usage resulting in optimised use of hardware vertex and index buffers, providing significant speed boosts on all cards, typically of between 50 and 200% depending on the application. ATI 9500+ cards on DirectX9 will see particularly large increases (often five-fold) due to their particular affinity to this approach.

• Geometry structures redesigned to support the above and also to provide the basis for vertex and pixel shaders. This will not affect you unless you manipulated geometry structures such as the old GeometryData directly - those who did should read about the details of the changes.

• Transparent materials no longer assume that depth writing needs to be off, this setting was causing some problems with those using alpha blending. Those of you using transparent materials which do need depth writing to be turned off will need to set it in your material scripts

• DirectX 8 rendersystem retired, the current DirectX rendersystem is now DirectX9, with legacy cards supported through the DirectX7 rendersystem or OpenGL

• Support for cubic textures and cubic reflection mapping added

• Support for DOT3 bump mapping added

• Significant speed improvements on rebuilding bezier patch surfaces, changing detail level is now a lot faster

• Binary .mesh format updated - please run 'OgreMeshUpgrade' (from Tools/MeshUpgrader) on your old meshes, they may not work properly unless you do this

• OgreXmlConverter now includes parameters to allow you to generate LODs as you convert

• Mesh serializer now rationalises bone assignments so that only 4 are included per vertex

• DTDs for .mesh.xml and .skeleton.xml added

• Added Gtk platform manager with support for ogre as a Gtk/GL widget

• 3D Studio Exporter now supports IK and Biped

• Lightwave converter added

• Wings3D converter added

• Memory leaks with controllers removed

• Visual real-time profiling tool added

• Many bugfixes and minor enhancements

v0.11.0 (18 June 2003)

Changes since 0.10.0:

• SceneQuery introduced; a generic way to query the SceneManager database of objects and world geometry in a way which is optimised per scene management technique but transparent for the client application. Currently only IntersectionSceneQuery is implemented but RaySceneQuery, SphereSceneQuery and others will soon be available too

• ReferenceApplication introduced; this is a new library which sits on top of the main OGRE library in order to provide a reference implementation of combining OGRE with other libraries for use in a full application. Currently combines OGRE and ODE to provide an easy to use collision and realistic physics system, utilising the new SceneQuery functions for generic collision detection. Object to object collision is currently supported, together this object to world collision for the BspSceneManager (ie collision against Quake3 levels), see the BspCollision demo for an example. Per-object friction, bounciness and mass parameters are all definable, also most of the ODE joint types ie ball, hinge, hinge2, universal. World collision for the terrain managers will be added shortly.

• Many structural enhancements to the GLRenderSystem, including an extension manager, separation of window creation etc into a GLSupport class (to enable platform specific window management). Win32GLSupport added so Win32 no longer uses SDL for window management.

• Hardware mipmap generation supported in GL 1.3+

• New demos: BspCollision and Demo_Water

• RenderTargetListener now supports pre and post Viewport update events

• RenderSystem now supports anisotropic texture filtering and dot3 texture operations

• Significant updates to the 3D Studio Max exporter, now very mature

• Added 3 more basic mesh exporters / converters: Maya, Wings3D and VRML 97

• Attaching objects to a skeleton: any MovableObject (entities, particle systems etc) can now be attached to any bone on an entity, and will move correctly with the animation

• XMLConverter can now generate / update LOD information for meshes too

• Bones can now be manually controlled in combination with animation tracks much more easily, allowing you to do things like tilt a characters head toward a target while playing other animations, make a character bend at the waist etc.

• New particle affectors: ScaleAffector (particle resizing) and ColourFaderAffector2 (dual-state colour affector which changes behaviour based on a particle's TTL)

• Alternative terrain engine added (NatureSceneManager), supports paging and very large areas

• Significant speed enhancements to Node, in particular skeletal animation is now many times faster for large skeletons

• Interface breaking change since 0.10.0: SceneNode::createChild now returns a Node* rather than a SceneNode*, you will have to cast it. This was to resolve virtualisation problems

• Platform-specific Timer classes and general timing improvements mean that accuracy and consistency is much better

• Rendering to texture now supported in GL as well as D3D

• SDLRenderSystem renamed to GLRenderSystem

• Python support resurrected, Linux only for now due to Boost problems with VC

• Gui enhancements, including pop up menus and scrollable text areas and being able to #include in .overlay files to reuse definitions (NB: the event and gui classes will shortly be moved into a separate plugin)

• Added ability to switch between buffered and unbuffered input on demand

• VC++.Net 2003 support added

• MaterialSerializer for writing .material scripts from an in-memory version

• Many bugfixes, including the removal of all remaining memory leaks

v0.10.0 (28 Feb 2003)

Changes since 0.9.7:

• Major speed increases for large scenes. Scenes with more than 1500 objects are now feasible at high frame rates.

• 3D Studio Max 4 / 5 script for exporting meshes and skeletons to XML (which can then be converted to binary using XMLConverter)

• Major updates to the Python bindings

• Added UserDefinedObject to allow references back to external app objects from OGRE objects

• Experimental Direct3D 9 Render System

• Skeletal animation now supports additive blending of multiple animations as well as average blending

• Bugfixes & small feature enhancements

v0.9.7 (26 January 2003)

Changes since 0.99f:

• Mac OSX support added

• Mesh LOD support: both automatic algorithmic detail reduction, and manual LOD assignment

• Milkshape exporter extended to support generation of LODs

• Rendering to a texture (supported in Direct3D only for now, GL support to follow)

• Screenshot support

• DevIL now used for image loading / saving

• Blender export script

• Initial GUI support and buffered input support

• Updates to the Python exports

• A few vector / quaternion optimisations

• Linux / Mac 'install' target paths rationalised

• Bugfixes (including GL lighting and texture effect problems, many memory leaks fixed)

• Version numbering change (to more standard format)

v0.99f (1 December 2002)

Changes since 0.99e:

• Terrain rendering through the OctreeSceneManager subclass TerrainSceneManager, including detail texturing and vertex colouring options

• Overlays can now have pixel metrics as well as relative metrics, and can be flexibly aligned

• New debug overlay

• Curved sky planes (fog-friendly alternative to sky domes)

• Animation tracks can now scale nodes as well as rotate and translate

• Depth bias now available as a material option, for doing decals

• Stencil buffer operations now supported

• RenderQueueListener allows custom filters to be plugged in, compositing operations to be performed

• New version of 3DSMax exporter

• Many bugfixes (as usual)

v0.99e (25 October 2002)

Changes since 0.99d:

• Overlay support (HUDs, menus)

• Font rendering

• Octree scene manager added

• XMLConverter allows conversion of .mesh and .skeleton files to XML (XML to .mesh and .skeleton is not finished yet)

• DirectX 8 render system

• Spline interpolation of animation, both for skeletal animation and for animating any SceneNode

• Automatic camera tracking, spline animations can be used to script smooth camera sweeps

• Many bugfixes

v0.99d (5 September 2002)

Changes since 0.99c:

• Full Linux support!

• Debug memory manager tracing memory leaks

• Generic animation support via Animation, AnimationTrack and KeyFrame classes

• Skeletal animation on meshes, including multiple bone assignments and animation blending

• Updated Milkshape exporter, exports skeleton and animations, can split the combined sequence into many separate animations

• Codec structure, used for loading images more generically and can be used for general coding / decoding

• Many bugfixes

• New tutorials

v0.99c (19 July 2002)

Changes since 0.99b:

Enhancements:

• New MeshSerializer class for importing / exporting mesh data, to be used as the framework for all future modelling tool exporters

• Milkshape3D exporter provided, which uses MeshSerializer to export to the new .mesh file format. This replaces the 3ds2oof utility which along with the .oof is now deprecated, although .oof models can still be loaded. In this version the Milkshape exporter only exports static mesh data without bones or animation.

• SceneNode now supports scaling (uniform and non-uniform), including the option to inherit parent scale or just use own

• Completely new source code folder layout; should be more obvious than the old one. All dependencies are now included in the code structure to avoid having to distribute binary libraries

• Boost added to the Dependencies area

• New tutorial added, kindly written by Nicholas Green

Work-in-progress:

• Linux makefiles now present, buildable with gcc 3+

• SDL / OpenGL render system implementation provided, not totally complete yet but almost there

• Skeletal animation classes (Animation, AnimationTrack, KeyFrame, Skeleton, Bone)

Bugfixes:

• Math::NEG_INFINITY now correctly defined

• ColourValue getAsLongARGB alpha bug fixed

• Problems with camera positioning & lookat behaviour when attached to a SceneNode fixed

v0.99b (9 June 2002)

Changes since 0.98b:

Enhancements:

• Particle systems implemented, including customisable emitters / affectors through the use of plugins, defining particle system templates through text scripts for easy modification, flexible culling options, flat and oriented billboards for point or directional particles, fast-forwarding of systems to avoid obvious particle system startup, force application, randomised colours & emission angles, randomised velocities and lifetimes and much more.

• Billboarding support (used by particle systems, but can also be used on their own to create backgrounds, static light flares etc)

• Now builds under VC.Net (VC7), .sln and .vcproj files are now included in the distribution

• Zip archives now cache a file index for more efficient retrieval

• StringInterface base class and helper classes like ParamCommand and StringConverter now available to make scriptable classes easier to create

Bugfixes:

• Several bugs in 3DS2OOF 3D Studio converter fixed, such as exported files including camera & lights (these are now ignored), objects with missing SmoothGroups, and issue with merging multiple objects

• Environment mapping bug which caused incorrect wrapping is now fixed

• All container 'wrappers' have now been replaced with the original STL class since we are now using STLport and don't have the dll boundary problems present in theMicrosoft STL implementation

• SceneNodes now derive their orientation & position on demand if they are out of date

v0.98b (29 March 2002)

Changes since 0.97e:

• Material scripts. All materials can now be specified in .material files, which are loaded at startup and can be altered without recompiling your application. Tweak to your hearts content! See the material scripting section in the Tutorials for more information.

• Landscape rendering - a ROAM scene manager example implementation is now included in the distribution, together with an example demo. Whilst the ROAM approach will not be developed further due to it's relatively high CPU overhead, it serves as an example of how vastly different scene managers can be plugged into Ogre.

• Billboarding. Billboards can now be used to create special effects. Particle systems using this facility are under development.

• Better culling on the standard scene manager. The standard non-scene-specific scene manager now hierarchically culls movables based on their bounding boxes. A triangle counter monitors culling performance.

• Refactored the methods called in the main rendering loop in SceneManager to allow subclasses to modify the behaviour more easily without having to duplicate code.

• Better compliance with STL standards. Ogre is now built using STLport on both Windows and Linux, and this has necessitated a closer fit with the STL standard rather than the Microsoft implementation.

v0.97e (16 Feb 2002)

Changes since 0.97b:

• Archive driver system is in! Say bye-bye to the Ogre::Archive class and welcome to dynamically-loaded archive codecs!

• Two archive codecs are provided: FileSystem codec (works like a normal directory) and Zip Archive codec (works with Zip archives)

• Changed all examples and the Indoor Engine to work with the new codecs

• Modified the way ResourceManager::_findResourceData returns data: now it takes a pointer to a DataChunk and fills the pointed object with all the data, thus avoiding unnecesary memory copying (and eventually fragmentation)

• Some cosmetic changes to the way plug-ins are loaded - no need to specify the extension of the plug-in anymore, and it is registered as given in the Plugins.cfg file. This is because we don't want to load a Dll two times - the first time as [PluginPath]\PluginName.dll and the second time as plain PluginName

• Cosmetic changes in projects and workspaces. They should give no error when compiling and you shouldn't need to create the necessary directories yourselves

• The Resources folder has changed. The two .oof models and their textures now reside in zip archives to reflect the usage of the new Archive codecs.

v0.97b (6 Feb 2002)

Changes since 0.96b:

• Added some more standard Controller objects to allow easy texture scrolling, rotating and scaling. Added support for these to the Quake3 renderer .

• Wave-based controllers allow texture modifications (among other things) to be based on wave types rather than just constant effects

• Added more friendly error dialog when an unhandled exception is thrown

• Fixed a couple of bugs in the config dialog which causes crashes

• Fogging enabled - scene-wide or customised per material

v0.96b (6 January 2002)

I've changed this log a little to be more concise regarding changes made between snapshot versions.

Changes since 0.95b:

• Animated tetxure support. Each texture layer can have multiple frames, with one being active at a time.

• Controller architecture. Controller allow object properties to be updated based on other events or values whilst only loosely coupling the source and destination objects together. In this version Controllers are used for animating texture layers by setting the active texture frame based on a frame timer object.

• Quake 3 .shader script support. Animated textures, multilayer textures etc now being loaded in. No scrolling, rotating or stretching effects yet though

• Skyplanes, skydomes and skyboxes are now supported

• Major improvement in rendering speed thanks to a far smarter render state management approach.

• Transparent objects now always render correctly when in front of solid objects.

6 January 2002

Most bugs in shader parsing sorted out. A few shader effects are not supported yet, but most are there and look good. Texture coordinate modifications are missing for the moment, but environment mapping is in (albeit a little different from Q3A's method - I chose to use cameraspace reflection vectors to produce the effect because these are hardware accelerable, whilst Q3A's method of using the vector from camera location to vertex is not), as are all the shafts of light, animated flames etc.

No MD3 models are being rendered so there are a few blank spots in the level where a gargoyle, wall sconce etc should be. I'm not going to implement this for now, I've proved the point I wanted to prove which is that Ogre can handle this type of scene well. It's just a few Q3-specific details which are missing which is no big deal, I never set out to produce a working copy of Q3A.

I will be releasing another snapshot based on this codebase, and also will release binary demos of all the examples.

Next: texture coordinate modifications, extensions to the controller classes. Then particle systems.

5 January 2002

Skydomes and skyboxes are in and working, giving you 3 types of sky to play with. Skyboxes are for static, wrap-around environment textures like space, whilst skydomes are like skyplanes, but curved.

Quake3 shader script conversion is going well, Ogre loads in the .shader files and converts them to Material objects as required, meaning that you can now see flames, shafts of light, TV screens etc inside Ogre. Animated textures are being loaded but not animated yet - I'm going to try and get animation working within a nice generic OO controller framework if I can rather than bash out a single-use approach.

One thing I've noticed now the sky is being displayed is there are 'sparklies' around the curved surfaces visible mostly when there is a light-coloured sky. Damn. It appears the points generated from the bezier patches don't quite match up with the surrounding static geometry, meaning there are small gaps. This is a TODO.

I still need to fix the odd crash point and a few shaders aren't being loaded properly. Also environment mapping needs a bit of work since Quake3 bases them on camera position -> vertex rather than camera eye vector -> normal, which means they look wrong. I should alos render the 'models' in the level i.e. geometry that doesn't have lightmaps like gargoyles.

27 December 2001

Skyplanes are now working. You can now create a plane which is at contant distance from the camera at and orientation for use as a sky. I'll be moving on to skyboxes imminently which will allow full wrap-around skies.

I have also totally revamped the example code that is included with the engine. Instead of the single TestApp project, there is now an Examples folder with multiple projects under this which demo each effect. I have also created an object-oriented framework for the examples too, meaning they are now a lot better structured and hopefully better to understand.

I also intend to release some binary demos soon so people can quickly see what the engine is capable of without having to build from the source. The good news this week is that I just did a Release build of the Quake3 level renderer, and it runs at a very sweet 170fps in windowed mode on my Athlon 1Ghz and GeForce 2. In fullscreen mode at 1024x768 at 32-bit colour it still manages between 50 and 80 fps. I'm very pleased indeed. I would like to tidy up some of the missing textures before I do a binary release so I'll be sorting out the skybox support and other texture effects first.

24 December 2001

Refactored the entity rendering routines in the base SceneManager class to make them easier to reuse in subclasses.

Material class enhanced to contain all the other render settings such as depth buffer parameters, culling modes, texture filtering etc. It is now possible to drive all the rendering settings via the Material class now so that no calls are required to the RenderSystem class. This makes the settings more intuitive to use, and ensures that you can have different settings per object if you want by assigning different materials, and the SceneManager controls the changes to the rendering settings.

Major rewrite of SceneManager::setMaterial and added RenderSystem::_setTextureUnitSettings (used by the former) so that only changes to the material settings are sent to the RenderSystem. This ensures that rendering state changes are minimised and that custom settings are reset only when required. This has improved the framerate across the board by about 50%. A further optimisation which is still to be made is ordering the materials in the render sequence to minimise the render state changes still further, e.g. scheduling 2 materials that have the same layer 0 texture but different layer 1 textures next to each other.

Started adding sky plane and sky box support to the SceneManager class, but this is not yet functional.

Merry Xmas!

4 December 2001

General Bezier Patch support through the PatchSurface class.

Quake3 level loading uses curved surface support to display Q3A's bezier curves. Custom shader scripts still to be done.

IMPORTANT: To compile & run the TestApp demo application you will need to change line 414 of WinMainTest.cpp to point at your Quake3Arena pak0.pk3, since I can't distribute Q3A levels and textures for size and copyright reasons.

11 November 2001

First Quake3 level rendering release. No support for shader scripts or curved surfaces yet.

12 October 2001

Modified the material blending routines to make it more reliable to fall back on multipass rendering whilst preserving all the correct effects. To do this I had to simplify the basic multitexture blending operations which automatically fall back to multipass, and require that the application explicitly specifies a fallback blend multipass operation if it chooses to use the more complex blending modes which are only available under multitexture hardware. I hope by doing this I keep it simple for most cases (people normally use jusy ADD, MODULATE, REPLACE or ALPHABLEND anyway) whilst still allowing complete flexibility for those who like to tinker with the obscure modes.

Decided to make another point release even without the finished Quake3 stuff because there's so much that's useful.

9 October 2001

Object/scene blending operations (as opposed to multiple texture layer blending on the same object) support has been added, allowing new effects like transparency.

I keep getting distracted from my Quake3 level work but I am progressing - the reason why I switched to this subject is that I realised my fallback technique to multipass rendering when not enough multitexturing hardware was available was not correct, and in order to be able to fix it I needed these new blending options. I'm now wondering whether to fix the multipass fallback now I have the tools or to leave it until later. Right now, if you use more texture layers than the hardware supports in a single pass, things won't look right. I'll get to it.

6 October 2001

Ok, remember the problem from 16 September re texture coordinates and confusion over whether (0,0) was the top or bottom left corner of the texture? Well it turns out that once again Direct3D is the odd one out, and 3DS is actually using the more common convention, i.e. (0,0) is the bottom left corner. I have therefore changed the 3ds2oof routine back to how it was before (using 3DS UV corrdinates directly) and am flipping the texture itself in the Y-axis when loading it in the Direct3D texture implementation to compensate (D3DTexture.cpp). I should have checked more thoroughly before changing things to be in line with D3D, I should have known it would probably be the odd one.

I've done this because I want Ogre to follow industry standards (e.g. right-handed coordinates, anticlockwise vertex winding) rather than Direct3D's viewpoint which is usually the opposite, even though it's Direct3D I'm working on at the moment. I do this because it's what everybody will be used to when they come from maths texts or modelling tools, and is the same as the OpenGL approach (so the OpenGL port should be easier than Direct3D). I just compensate inside my Direct3D-specific classes (e.g. by flipping the Z axis, changing the culling mode, or flipping the texture as above).

5 October 2001

Progressive updates are being made to the OgreEngineIndoor module in CVS. Quake3 levels are being loaded and coversion is in progress.

I have also fixed a couple more bugs: the ColourValue class was implementing colours a little too bright and wrapped around to black when pure white was specified. This has been fixed. In addition, the mipmap generation was not generating enough mipmaps under Direct3D because D3DX ignores requests for the number of mipmaps and generates as many as required to reduce to a 1x1 texture. This caused smaller mipmaps to be black and thus textures would wink out at long distances. This has been fixed.

16 September 2001

Slow going due to moving house. However, fixed a problem with texture coordinates as converted from 3DS using 3ds2oof - I just realised that 3DS uses UV coordinates where V=0.0 is at the bottom of the texture map, instead of the top as with everything else! That explains the strange textures on some models. Fixed 3ds2oof to make V=(1.0 - V) during the conversion. Reconvert your models!

29 August 2001

Ogre now supports loading of resources from more flexible locations, including compressed archives (.zip and Quake3 .pk3 files). You can specify a list of search paths and archives which are either general across the whole of Ogre or specific to a resource type (e.g. textures, meshes).

I've also added support for loading TGA images as well, since Quake3 maps use them in places.

I have also dropped support for BMP files. This is because I have had to implement memory-based versions of the image decoders to support loading from archives, and to be frank I couldn't be bothered to implement one for BMP since it's a naff format in my opinion and tied to the Windows platform anyway. Ogre supports JPEG, PNG and TGA which should be plenty of flexibility. Personally I think when you've got PNG (for lossless) and JPEG (for lossy), you don't need anything else.

10 August 2001

Texture blending is now in and working! The new TestApp demonstrates the functionality by loading a base model with a standard texture, then adding a second texture layer and applying an environment map to it. The keys 0-7 change the texture blending mode to show what effects different parameters have.

I'm now moving onto other features; I want to look at Quake3 file loading - there are a couple of things nagging me about managing materials and entities that I'd like to look at but I'd really like to get started on Q3A bsp files now. I also wanted to work on animation, both within models (skeletal animation & bones) and for paths of objects (bezier curves & bsplines), but I just don't have time to do everything I want to! Q3A files first.

5 August 2001

Back from a break for holidays!

The Camera class now allows a SceneNode to override it's position and orientation when the Camera is attached to a SceneNode. This will allow cameras attached to world objects etc.

Started implementing the texture blending operations - the interface is complete, I'm now moving onto the Direct3D implementation. For the moment I'm not worrying about minimising the number of times that changes to blending parameters are made during a frame - I'm still concentrating on minimising the texture changes, which is the main overhead anyway. More optimisation will likely come along with new SceneManager subclasses.

21 July 2001

The Camera class now uses quaternions too. Camera rotation is a lot more concise now (instead of storing & trying to update 3 vectors I just have a single quaternion) and is more predictable and hopefully more flexible for the future. 

You can attach a Camera to a SceneNode (this is meant for use in having cameras tracking other objects in the world) but I have yet to implement this - I intend now that they're both on the same basis that if you choose to attach a camera to a scene node then the SceneNode overrides the camera's own position and direction, and maybe even that they update each other (so telling a camera to look somewhere would update the orientation of it's SceneNode too).

19 July 2001

Updated SceneNode class to use quaternions internally for all orientations / rotations. This should both be faster and give me more flexibility for the future. Also added a lot more manipulation routines the SceneNode class which were sorely lacking before if you wanted to move stuff around. The Camera class still uses matrices internally but I intend to change that so that a Camera depends on the SceneNode it is attached to for positioning rather than doing it itself. To this end I will need to add extra features to the SceneNode class to replicate functions like lookAt(), which is ok since this will be handy for pointing other objects at each other too.

17 July 2001

Fixed an issue with the 3ds2oof utility - it now generates vertex normals based on smooth groups rather than just averaging based on the faces which use the vertex. This removes artefacts along model 'seams' e.g. the point where a texture wraps around on the model.

Reimplemented environment mapping using the new Material::TextureLayer structure. Started work on adding more manipulation features to the SceneNode class (body code still to do).

4 July 2001

Python now has full access to the engine, and it's working great. I've also enabled callbacks into Python from the engine, so you can register a Python class as a listener for frame update events so C++ calls Python every frame. Nice.

Future Python developments include an embedded version of Python in Ogre so you can build a compiled application which still used interpreted scripts for some things - this will be useful for level scripting etc where the script can be kept in the level data. For now though I'm going back to developing the core engine features .

20 June 2001

Spending an awful lot of time exposing all the necessary objects and their interfaces to Python (up till now I have it working but only a few interfaces were exposed). About 90% there now, with a few issues to iron out - I had to extend the compiler heap limit to get it to compile so far since the heavy usage of templates puts a great strain on the compiler memory usage. In a few days I should be in a position to do all my engine testing through Python as well as through a custom C++ application (currently TestApp).

13 June 2001

Added FrameListener and FrameEvent classes in order to represent the frame update callback functions in a more object-oriented way. User applications now extend FrameListener and register their interest in receiving frame events - this is based on the Java model of event listening. Note that a boon of this method is that Boost Python allows you to extend existing C++ classes so this provides a perfect mechanism to have C++ call Python scripts when events occur.

I intend to extend this pattern to other events like collisions when I implement them.

10 June 2001

Changed from using SWIG to Boost Python for Python script integration. I changed because Boost Python supports C++ features much beter (including catching C++ exceptions and turning them into Python exceptions, support for namespaces and overloaded operators), it integrates better with my build cycle (doesn't require a separate generate from interface files and can be built directly into the library), and is more up-to-date with the latest Python libraries. I was finding that SWIG's emphasis on pure C as opposed to C++ was getting in the way, and Boost has definitely addressed this.

Introduced PythonLink class to expose classes to Python.

7 June 2001

Implemented Python integration using SWIG (Simplified Wrapper and Interface Generator). You can now start and initialise Ogre from a Python console and drive it interactively. More work required to expose the full interface to Python however.

31 May 2001

Cut over to CVS - CVS repository is now up and running at SourceForge.

20 May 2001

SceneNode class integrated with Entity / SubEntity classes. Working basic scene graph. Also reimplemented my previous hack using DirectInput as a proper platform-specific user input class - added the OgreUtility module for this purpose.

15 May 2001

SubEntity implementation complete, together with customisable Materials at the SubEntity level. Material usage by SubEntities is now indexed by the SceneManager so that rendering can be grouped by Material such that as few as possible render state changes take place. Note that this does not currently deal with transparency.

13 May 2001

Bugs with the new Mesh loading routines now ironed out.

24 April 2001

Implemented Mesh, SubMesh and MeshManager classes for loading Ogre Object Format files (converted from .3ds using the Ogre 3ds2oof tool). Decided to allow the original 3ds mesh to be broken down into chunks specific per material or grouped as a whole depending on requirements. The 3ds2oof utility makes a goos guess as to what is best, based on the percentage of the vertices each SubMesh uses out of the whole model - the lower the percentage the greater chance it will have a dedicated vertex list rather than sharing the whole since that saves sending unnecessary vertices to the pipeline. However this can be customised with parameters since you may want to use vertex buffers where it's more efficient to store 1 buffer even if you only use parts of it.

1 April 2001

Began overhaul of Mesh loading routines.

30 March 2001

Switched to Doxygen for document generation since ccdoc still doesn't support namespaces. Doxygen is better at cross-referencing anyway and draws nice diagrams.

24 March 2001

Added JPEG loading support, and moved this and existing image loading code (PNG) into the Image class. BMP loading is still supported but only on Windows platforms so this is still residing in the D3DTexture class as a special case.

Improved the handling of non-square textures on hardware that supports only square textures. The image is now stretched into the square area so that the relative texture coordinates are still valid and no black bands appear on the model.

23 March 2001

Multiple viewports per window is implemented and working Ok. Z-Order also applies so picture-in-picture views are possible by placing a smaller viewport on top of another larger one.

11 March 2001

Changed the default mechanism for supplying vertex components (position, normals, texture coords, colours) to the RenderOperation class. They were previously assumed to be part of the same buffer with flags indicating which were present. However this was too restrictive and prevented you using entirely separate memory areas for different components, and adding extra components to vertices on the fly.

Instead the RenderOperation class now takes pointers for each component, and a 'span' value determines the gap between each value. This allows you to use separate buffers if you like, but also use a combined buffer if that suits you (by using the 'span' value to skip over values in between).

6 March 2001

Implemented a 3DStudio conversion tool that works directly from the .3DS files rather than from ASCII exports (as previously) or from a MAX plugin as some others do, which requires a 3DS license. I based my code on an existing open source routine but I have exteded it since it had a few shortcomings. The tool is called '3ds2oof' because it converts 3DS files to a proprietary format, .OOF (Ogre Object File). This is because it's more efficient for me to do extra processing at conversion time like calculating bounding boxes, splitting vertex buffers, strippifying etc (not that I'm doing all this yet, but I can) rather than at load time as I would have to do if I loaded direct from 3DS inside Ogre.

1 March 2001

Over the last 2 weeks I reimplemented my interface to the DirectX rendering pipeline in the new Ogre structure, under the D3DRenderSystem class. Rendering requests are now packaged up in the RenderOperation class, giving me more flexibility on how rendering requests are submitted and handled. Now all the support classes (mesh loading, scene management) are needed.

11 February 2001

I've been picking apart the platform dependencies in Ogre so it'll be more portable. I'm also making it flexible enough to handle any number of rendering windows and viewports within thse windows, and also giving you the choice of an automatic rendering loop (max frame rate) and a render-on-demand interface much like you would need for an application like a modelling tool where you want to free up cycles when things don't move and frae rate isn't the most important thing.

I now have a nice hierarchy crossing the OgreEngine and OgreWin32Platform modules, with functionality broken down into RenderTarget, RenderWindow and Win32RenderWindow classes. Other platforms can be implemented later, just replacing the Win32RenderWindow maybe with XRenderWindow or MacRenderWindow.

29 December 2000

Ogre development starts again after almost a year's break while I finished my degree. Lots of research and design work at this stage to work out how I should structure the object model.