Axiom To Ogre v1.2 - Axiom : A 3D Rendering Engine in C#

Axiom To Ogre v1.2

From Axiom

Jump to: navigation, search
 Legend 
 Not Started or Tested
 In Progress or Partially Implemented
 Implemented and Compatible ( See notes )
 Can't or Won't Implement

Contents

OGRE v1.2 aka Dagon

ChangeLog

Compositing framework added (CompositorManager). This interface makes it possible to easily apply postprocessing and other after-effects to a viewport using shaders or stencil effects. Multiple effects can also be used in a chain if so desired.
Compositor Scripting added. Compositor scripts allow post processing special effects to be defined through script instead of hard coded. Compositor scripts are loaded on startup similar to material scripts and loading occurs after material script loading.
The Compositor Demo has been updated to show the use of both hard coded compositors and those loaded from script.
MultiRenderTarget (MRT) support. Shaders can now render to multiple simultaneous render textures on cards supporting this.
Added DeferredShading demo demonstrating the use of MultiRenderTarget to do deferred shading
Change HardwarePixelBuffer::blit prototype to be more usable (take a SharedPtr not a hard pointer)
OpenGL changes:
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)
D3D9 Changes:
Triple buffering enabled when vsync is enabled
RenderTexture changes
RenderTexture API overhaul more
Rendering to faces of cubemaps (for realistic reflections), mipmaps and slices of 3D textures is now possible.
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.
Added radix sorting routines
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
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 use 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
Unusual transparent with colour write disabled technique are now put into transparent render group. Allow rendering self-intersection object without self overlay, and still performing depth sorting for better transparent blending with other objects.
Animation enhancements
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
New 'VertexAnimationTrack' allows animation of vertex positions in a VertexData instance, either in software or hardware. Comes in 2 variants, morph animation (like MD2) and pose animation (blendable poses, e.g. facial animation)
Some optimisations
Skinning blending enhancements.
Only passing bones world matrices of a subentity that are actually used, mainly purpose is support more bones in a mesh when hardware skinning is enabled. Now the hardware skinning supports limit and is applyed to actually used bones of each submesh, not mesh. And it's possible to split up the meshes to support unlimited number of bones with hardware skinning.
Software skinning now done in object space, and additional special optimise for froze/disabled animation, kept software blended vertex data as many frames as possible.
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 changes
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 changes
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
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)
SceneManager::setWorldGeometry now accepts a stream as input as well as a filename
CEGUI renderer updated to take advantage of CEGUI HEAD which doesn't depend on Xerces-C++ anymore
Added IndexData::optimiseVertexCache to allow people to cache-optimise their triangle list indexes
Added pulse width modulation option to WaveformControllerFunction
Standardised projection matrix manipulation in Frustum so translation to rendersystem-specific versions is done later, uniform projectin matrix available to callers if they need it
Added off-axis perspective projection to Frustum and Camera. Related functions: Frustum::setFrustumOffset, Frustum::getFrustumOffset, Frustum::setFocalLength, Frustum::getFocalLength.
Added method to access 'virtual' (reflected if need) or 'real' (unreflected always) world orientation/position of the camera.
Added Root::setFrameSmoothingPeriod() to let users customise smoothing of frame time fluctuations.
Every render system config options are stored to configuration file.
Added Viewport::setSkiesEnabled() to let users hide skies for viewport individually, allow control skies displays or not more easy, especially for using multiple viewports.
VC6 & VC7.0 (2002) & VC7.1 (2003) support discontinued; officially supported Microsoft compilers is now VC8 (2005)
Direct3D7 support removed
Platform Manager Changes
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.

Porting notes

MovableObject changes

'mName' has been promoted to MovableObject and thus MovableObject::getName now has a concrete implementation. You must remove any name member variables in your subclasses, and probably any getName() implementations. Include an initialisation to MovableObject(name) in your named constructors.
SceneManager::getEntityIterator, getBillboardSetIterator, getLightIterator no longer exists. Use SceneManager::getMovableObjectIterator("Entity") instead
Query flags/masks
Underlying type has changed from unsigned long to uint32 to be explicit about length on all systems.
There are now 2 sets of query flags on MovableObject and masks on SceneQuery. The existing flags/masks have been reinterpreted to mean 'instance flags/masks', which are specific to the object. The second set, called 'type flags/masks' relates to the type of object.
When a MovableObjectFactory is registered, it can request that it is allocated a type flag, which will be used by any MovableObject instances created by it. Since many factories can be plugged in independently, there is no way these flags could be unique unless allocated by the SceneManager. SceneManager will allocate flags from LSB upwards.
Custom MovableObjects not created by factories can override getTypeFlags if they want to return a specific value anyway. Must be careful about overlap here (although you can use intentional overlap if you want to classify different types the same way).
The highest significant bit on the type flag is reserved for world geometry. SceneManager::WORLD_GEOMETRY_QUERY_MASK has been renamed SceneManager::WORLD_GEOMETRY_TYPE_MASK to reflect the fact that it affects matching with the type mask on a scene query, not the instance mask.
Any custom MovableObject that is neither created from a MovableObjectFactory, nor overrides getTypeFlags, will be included in all queries since the default type flag is 0xFFFFFFFF. This preserves the previous behaviour.
It's now important to call Root::getSceneManager before you start creating objects through other managers like ParticleSystemManager; most probably do already but this is a definite requirement now, when it was not before.

Animation Changes

Animation now holds several types of tracks; to port your code which creates / reads / modifies pre 1.1.x tracks, you need to change your code as follows:
Use NodeAnimationTrack instead of AnimationTrack, and use Animation::createNodeTrack, Animation::getNodeTrack, etc
Use TransformKeyFrame instead of KeyFrame, and use NodeAnimationTrack::createNodeKeyFrame et al
AnimationState no longer derives from ControllerValue<Real>, because Controllers work via shared pointers which delete their contents automatically, and AnimationState is destroyed manually so you'll get a double-free condition. Use AnimationStateControllerValue now instead of AnimationState when wanting to change animations through a controller.

Entity changes

setRenderDetail is no longer available on Entity, instead this is all controlled via the Pass of the material as with other rendering options. It is now called setPolygonMode, previously the names used were inconsistent.
getSoftwareSkinningRequests, getSoftwareSkinningNormalsRequests, addSoftwareSkinningRequest and removeSoftwareSkinningRequest are now renamed to getSoftwareAnimationRequests, getSoftwareAnimationNormalsRequests, addSoftwareAnimationRequest and removeSoftwareAnimationRequest.
_getSkelAnimVertexData now guarantee usable only if added requests for software animation via addSoftwareAnimationRequest. Also note that the blended vertex data is now in object space instead of in world space in previous version.

Renderable changes

setRenderDetail is no longer available on Renderable, instead this is all controlled via the Pass of the material as with other rendering options. It is now called setPolygonMode, previously the names used were inconsistent.

Material Changes

Pass::setRunOncePerLight (and getter) is now called setIterateOncePerLight, since setPassIterationCount applies per light if this option is set.
Texture coordinate transform now dealing with full 4x4 matrix always, in previous version, they are treat as 3x3 or 4x4 base on the texture type. Both of TextureUnitState::getTextureTransform and TextureUnitState::setTextureTransform accept/returns full 4x4 matrix now.
GPU view and projection related matrix bindings now pick-up identity matrix base on Renderable useIdentityView/useIdentityProjection.
Identity projection matrix now take care with render system depth range in both fixed-function and programmable pipe.
Fog parameters now passing to render system even if using fragment program, allow fixed-function fog applicable in some situations.

RenderTexture Changes

RenderTextures can be created like all other textures, with TextureManager::getSingleton().createManual. Usage parameter should be TU_RENDERTARGET
tex->getBuffer(x,y)->getRenderTarget(z) in which x is the face (for cubemaps), y is the mipmap, and z is the slice number (for rendering to 3D textures) will acquire a RenderTarget to a surface.
RenderSystem::createTexture is now deprecated
To destroy a RenderTexture, detach it from the TextureManager like you would destroy a normal texture. Removing the RenderTarget will no longer work (as there are potentially many render targets per texture)

Camera / Frustum Changes

The meaning of the projection matrix methods has changed to make it easier to understand what each of them do, and so that you can get hold of a completely standard projection matrix if you want to do manual operations on it.
getProjectionMatrix used to retrieve the rendersystem-specific projection matrix. It now returns a standard, right-handed projection matrix with depth range of [-1,1]
getStandardProjectionMatrix, which used to retrieve a standard right-handed projection matrix except that the depth-range was rendersystem-specific (for shaders), has been renamed getProjectionMatrixWithRSDepth
getProjectionMatrixRS is a new method returns the rendersystem-specific projection matrix. This is the matrix which is sent to the pipeline.
Custom view and / or projection matrices are now permitted to allow custom camera set ups if required, see setCustomViewMatrix and setCustomProjectionMatrix
setDetailLevel and getDetailLevel have been renamed setPolygonMode and getPolygonMode for consistency with other areas
getDerivedOrientation, getDerivedPosition and getDerivedDirection now respects reflected camera, their are now returns 'virtual' (reflected if need) orientation/position in the world space. This changes may break related code if they already take reflection into account.
Previous derived orientation/position behavior can still access by new method getRealOrientation, getRealPosition and getRealDirection, they are returns 'real' (unreflected always) world orientation, position and direction of the camera.
If you never dealing with reflected camera, this changes never affect you.

SceneManager Changes

removeCamera, removeEntity, removeBillboardSet, removeLight and removeStaticGeometry, as well as their removeAll* variants, have been renamed to destroyCamera, destroyEntity etc for interface consistency (create / destroy are paired, and add / remove - in this case it was create / remove which was inconsistent and some people had trouble finding them).
SceneManagers are now managed as instances of a given SceneManager type. Instead of using Root::getSceneManager initially you must now call Root::createSceneManager,and you can use a type mask (e.g. ST_GENERIC as before, or some bitwise combination of types), or you can use a specific type name (e.g. "OctreeSceneManager"). You can create more than one to maintain multiple separate scenes if you want.
If you used getSceneManager(ST_GENERIC) before, now use createSceneManager(ST_GENERIC).
Root::_getCurrentSceneManager now _strictly_ only valid during target update since support for multiple SMs. Previously was available after getSceneManager even though the docs said it was only valid during update so you can't rely on this undocumented behaviour anymore
Custom SceneManagers must implement the new getTypeName method, and have a constructor with a 'name' String parameter. You must use the same string for SceneManager::getTypeName and the SceneManagerFactory metadata.
Custom SceneManagers should come with a SceneManagerFactory to plug in to Root::addSceneManagerFactory. Should register in dllStartPlugin, unregister in dllShutdownPlugin. You can still plug a custom SM instance in manually if you want, but the SceneManagerFactory approach is recommended for flexibility.

Root changes

Automatic smoothing out of fluctuations in frame times is now disabled by default. To return to the old behaviour call Root::getSingleton().setFrameSmoothingPeriod(0.5);.
Render system config options stored in its own section, allow save/restore config options for every render system now.

Render queue Changes

All instances of RenderQueueGroupID in parameters are now uint8 to allow values in between the standard OGRE queue numbers to be used without the compiler complaining
RenderQueueListener existing method signatures have changed, check your implementations. Note also the addition of the shadowTexturesUpdated event.

Render System Changes

_setRasterisationMode has been renamed _setPolygonMode for consistency with higher level functions

Resource manager Changes

New predefined resource group called ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME ("Internal"). All engine internal created resources (shadow materials/textures, default materials, compositor internal resources, etc) will use this group. And this special resource group are supposed to used by engine internal only, user shouldn't modify, unload or remove the resources that in this group.
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

Billboard changes

Billboard member function setTexCoords and getTexCoords renamed to setTexcoordIndex and getTexcoordIndex, which set billboard use generated texture coordinates. Also added function setTexcoordRect to set its own custom texture coordinates, and new function isUseTexcoordRect to determinant which is being used.

Particle System Changes

ParticleSystem can now only be created and retrieved via SceneManager like all other MovableObject types, using the generic createMovableObject or the specific createParticleSystem. ParticleSystemManager is still used for registering emitter / affector / renderer factories and creating templates.
ParticleSystemManager::setTimeFactor is no longer available in favour of the more generic (and therefore consistent) ControllerManager::setTimeFactor. This is more useful if you're trying to globally change the perceived time, and you still have the per-particle system speed factor for per-system adjustments anyway.
When using oriented_self, the size of particles is now always consistent and is no longer affected by particle velocity. You may need to adjust the height of your particles to compensate for this change, but particle size will now be more predictable when you have variable velocities.
ParticleSystemRenderer derived class must be override _getSortMode to describing their desired sort mode.

Vertex element changes

Vertex colour changes
The VET_COLOUR has been replaced by VET_COLOUR_ARGB (in D3D) and VET_COLOUR_ABGR (in GL) to make sure the internal format is unambiguous, and to allow automatic conversion.
On loading, colour formats are automatically converted if they are not native to the rendersystem
You can still use VET_COLOUR when creating geometry in memory, but it will be automatically changed to one of the specific variants when VertexDeclaration::addElement is called
If you read out VET_COLOUR from vertex buffers (say in a case statement) you need to detect the other 2 variants too.
Use VertexElement::convertColourValue to convert between types, and VertexElement::getBestColourElementType to get the recommended format for the current rendersystem.
RenderSystem::convertColourValue is still available for packing colours into buffers but you are recommended to use VertexElement::convertColourValue now since it's more generally applicable (works with no RenderSystem loaded)
If you have any existing meshes that use vertex colour, run them through OgreMeshUpgrade to convert the colours to a specific type
OgreXmlConverter defaults to writing VET_COLOUR_ARGB on Windows, and VET_COLOUR_ABGR on other platforms (conversion is seamless). If you want to change this, use the -d3d or -gl options.

CEGui Renderer Changes

Due to the new flexibility in SceneManager construction, you must either pass the SceneManager to the OgreCEGUIRenderer constructor, or call setTargetSceneManager sometime afterwards otherwise your GUI will not render (it cannot assume which SM to use anymore)
setTargetSceneManager only takes an explicit SceneManager pointer now, there is no SceneType option anymore (since SceneType does not lead to a unique SM anymore). The same goes for the constructor.

Overlay changes

Overlay scripts no longer support defining 'entity' as a 3D element; if you want to use 3D elements you have to define them at runtime. This is because ownership of Entity instances is at a SceneManager level, and SceneManager instantiation is much more flexible now.

TextureUnit changes

Effect ET_SCROLL is replaced by ET_UVSCROLL, ET_USCROLL and ET_VSCROLL

Controller changes

ControllerManager::createTextureScroller is replaced with ControllerManager::createTextureUVScroller, ControllerManager::createTextureUScroller and ControllerManager::createTextureVScroller

Misc

The SceneDetailLevel enum has been renamed PolygonMode, as have the enum values (SDL_SOLID is now PM_SOLID)
TerrainSceneManager's TerrainPageSourceListener has an additional parameter to the pageConstructed event, a SceneManager pointer, so you must change your listener signatures if you use this

Remaining issues

Point Attenuation causes segfault on Linux / ATI, but is fine on all other hardware?
Views
Powered by MediaWiki GNU Free Documentation License 1.2