NEWS

Copyright 2011-2017 dragonjoker

Verbatim copying and distribution of this entire article is permitted in any
medium, provided this notice is preserved.


Changes between version 0.11.0 and 0.10.0

  BUGS FIXED
  * CastorUtils
  *   Fixed matrix initialisation from another different size matrix.
  *   Fixed pixel buffer flip.
  *
  * OBJImporter
  *   Few fixes in face group management.

  FEATURES
  * CastorUtils
  *   Reworked castor::Matrix and castor::Point to make them hold static data, and reduce memory footprint of Matrix.
  *
  * Castor3D
  *   Castor3D now relies on Ashes rendering API, allowing support for OpenGL 4.X, OpenGL 3.X, Direct3D11 and Vulkan renderers.
  *   GlslWriter has been completely removed and replaced by ShaderLibrary, allowing the generation of shaders in the appropriate rendering API shader language.
  *   Added support for cross skyboxes.
  *   Enabled anisotropic filtering control from scene file.
  *   Added Raw and PCF shadow maps.
  *   Added sendEvent function to Engine, to be able to execute an event directly if there is an enabled device.
  *   Extracted binary write/parse classes to new files, to reduce include dependencies.
  *   Reworked mip level management for textures loaded from files.
  *   Added volumetric light scattering.
  *   MatrixUbo is now a reference, in RenderPass, hence is owned by owner classes.
  *   Upgraded scene files, meshes can now hold a default material.
  *   Render queue now uses SceneCuller from its render pass, and this culler is used for frustum culling.
  *   Cascaded shadow maps are implemented and functional.
  *   Overlays are now rendered them in their own framebuffer, and then combined with the 3D rendering.
  *   Shadow maps now use texture arrays (2D or Cube).
  *
  * RenderSystems
  *   Removed most of their code, they are now only wrappers around Ashes renderers.
  *
  * PostEffects
  *   Created LinearMotionBlur post effect.
  *
  * Samples
  *   Added CastorTestLauncher, which allows to run rendering tests through the wanted rendering API.
  *   Rehabilitated ShaderDialog, it now can be used to display tone mapping and post effect shaders.
  *   ShaderDialog now displays all the shaders for the pipeline used to display a pass.
  *   Selected submesh's bounding box now appears in yellow.
  *
  * Tools
  *   CastorMeshUpgrader tool has been added, allowing to update cmsh files with a cl tool.
  *   CastorMeshConverter tool has been added, allowing to convert "any" mesh file to cmsh mesh with a cl tool.
  *   Added DiffImage, which allows image comparison between a reference image and another one (generated through CastorTestLauncher), to automatise rendering tests.


Changes between version 0.10.0 and 0.9.0

  BUGS FIXED
  * Castor3D
  *   Fixed bounding boxes for animated meshes and skinned meshes.
  *   Repaired an reenabled frustum culling.
  *   Fixed alpha rejection.

  FEATURES
  * CastorUtils
  *   Renamed namespace Castor to castor.
  *   Added ChangeTracked and GroupChangeTracked classes, allowing to track changes to a member variable.
  *   Renamed CubeBox and SphereBox to BoundingBox and BoundingSphere.
  *   Splitted Colour in two classes: RgbColour and RgbaColour.
  *   PlaneEquation is no more a template class.
  *   Created a buddy allocator class: BuddyAllocator.
  *
  * GlslWriter
  *   GlslWriter class now holds the shader program inputs, to generate a glsl::Shader source.
  *
  * Castor3D
  *   Renamed namespace Castor3D to castor3d.
  *   Emissive in a material is now stored on a single floating point (emissive maps still hold a colour though).
  *   Implemented Physical Based Rendering, using both metallic/roughness and specular/glossiness workflows.
  *   RenderPipeline now also holds the shader program.
  *   Implemented Screen Space Subsurface Scattering (without backlit transmittance, though).
  *   The light pass result is now stored in two render targets: diffuse and specular.
  *   Vertex buffers now use a buddy allocated pool.
  *   Shadow mapping now uses variance shadow maps.
  *   Transparent meshes are now rendered using Weighted Blended OIT rendering.
  *   Screen Space Ambiant Occlusion has been improved, using Scalable Ambiant Obscurance implementation.
  *   Parallax Occlusion mapping is implemented.
  *   Reflection and refraction mapping have been implemented.
  *   Deferred rendering has been fully integrated to the engine, for opaque objects rendering.
  *   Created components for submeshes, to move functionalities out of Submesh, and make it more flexible.
  *   Rendering now uses a depth prepass.
  *   Created ColourSkybox, to handle background colour and skyboxes in the same way.
  *   Created ShaderBuffer class, to be able to handle SSBOs or TBOs in a similar way, choosing the most appropriate one, depending on running machine.
  *
  * Generators
  *   Created DiamondSquareTerrain plugin.
  *
  * Generic
  *   Events from CastorGUI are now forwarded to the user.
  *
  * Importers
  *   Removed almost every importer plugin, keeping only Assimp, OBJ, and PLY importers.
  *
  * PostEffects
  *   Created SMAA post effect.
  *   Created Kawase Light Streaks post effect.
  *   Created Film Grain post effect.
  *
  * RenderSystems
  *   Updated GlRenderSystem to support the features provided by Castor3D.
  *
  * Techniques
  *   Technique plugins have been completely removed.
  *
  * Tone mappings
  *   Created Uncharted 2 tone mapping plugin.


Changes between version 0.9.0 and 0.8.0

  FEATURES
  * CastorUtils
  *   Dropped libzip, and added minizip to the source tree.
  *   Added WorkderThread and ThreadPool classes.
  *   Improved Signal, by adding a Connection class, which allows disconnection without having the signal, and which can be disconnected by the signal itself.
  *   Added Range and RangedValue classes, to handle these concepts more conveniently.
  *   Added CpuInformations class, to retrieve them.
  *   Moved the platform specific implementation code into Platform/ subfolder, to ease the addition of new platforms.
  *   It now compiles on ARM (for future Android ports).
  *
  * Castor3D
  *   Entire review of the render loop: RenderPipeline is no more a unique instance, but it actually contains the states, the program, and uniform buffer bindings.
  *   It has been done to prepare the arrival of Vulkan, in which the pipeline can't be modified once it has been created, and that is now the case in Castor3D too.
  *   The rendering has been splitted in RenderPasses, that each have one or more RenderQueues, that are updated asynchronously on CPU, using a thread pool.
  *   This allows the GPU loop to be cleaned of most CPU computations.
  *   Skybox have been added.
  *   Binary export has been completely reviewed, it now uses a chunk data format (like LWO or 3DS).
  *   It is used for meshes, and skeletons.
  *   Plug-ins interface's consistency has been improved.
  *   Fog basic implementations (linear, exponential, and squared exponential) have been added.
  *   Morphing (per-vertex) animations are now supported by Castor3D.
  *   Frustum culling has been implemented.
  *   Colour picking has been implemented.
  *   Shadow mapping is implemented, lights can produce shadows, and objects can cast shadows.
  *   Particle system has been implemented, giving to the user the implementation choice (CPU through class override, GPU through Transform Feedback or Compute shaders).
  *   Fixed the lighting in GLSL, to make it behave properly without dirty hacks.
  *   Compute shaders have been integrated to Castor3D, along with Shader Storage Buffers and Atomic Counter Buffers.
  *   Textures implementation have been completely reviewed, we now have TextureLayout, which holds the TextureImage(s), and the TextureStorage per image.
  *   It has allowed the creation of cube textures.
  *   Textures transfer to RAM has been fixed.
  *   Billboard rendering no more uses a geometry shader, it now relies on hardware instantiation of a quad, and the positions are given as side attributes.
  *   UniformBuffer (formerly FrameVariableBuffer) no longer depends on ShaderProgram.
  *   A new class, UniformBufferBinding has been created which depends on both UniformBuffer and ShaderProgram.
  *   Instances of this class are held by RenderPipeline.
  *   FrameVariable class has been split in two classes: Uniform (for uniform variables contained in a UniformBuffer) and PushUniform (for uniform variables out of a UniformBuffer).
  *
  * RenderSystems
  *   Added GlES3RenderSystem, to start the Android port.
  *   Updated GlRenderSystem to support the features provided by Castor3D.
  *
  * Techniques
  *   DeferredRenderTechnique and DeferredMsaaRenderTechnique are now real deferred rendering techniques, with a light pass per light, taking care of it's impact area.
  *   DeferredRenderTechnique is now the default render technique, when none is specified.
  *
  * PostEffects
  *   Added GrayScale post effect.
  *   Added FXAA post effect.
  *
  * CastorViewer
  *   The camera has been fixed, so it doesn't look drunk anymore.


Changes between version 0.8.0 and 0.7.0

  BUGS FIXED
  * CastorUtils
  *   Fixed transformation matrices.
  *
  * Castor3D
  *   Fixed hardware instantiation, and instantiation, for meshes with
  *   different materials.
  *   Fixed a bug in border panel overlays material management.
  *   Fixed an overlays bug, on Intel GPU (was due to a real bug in AMD driver
  *   that hid the bug).
  *   The billboards are now fixed.
  *
  * Subdividers
  *   Fixed PN Triangles subdivider, to use Bezier patches.
  *   Updated Loop subdivider.
  *
  * GlRenderSystem
  *   Fixed a crash on Linux, with Intel GPUs.

  FEATURES
  * General
  *   Compiles now with VS >= 2013 and GCC >= 4.9.
  *   Direct3D support has eventually been dropped, I don't have time for it.
  *
  * CastorUtils
  *   Point4f and Matrix4x4f can now use SSE2 instructions for computations.
  *   All Castor projects are now using UTF-8 texts, using std::string.
  *
  * Castor3D
  *   The skeleton animation system is now finished and working.
  *   Removed every XxxRenderer class, except for OverlayRenderer.
  *   The topology type is no longer in Camera, but in GeometryBuffers.
  *   Engine has been splitted, creating a RenderLoop class, and Managers to
  *   create elements, collect them, and retrieve them.
  *   SceneFileParser has been extended, to be able to use parsers from
  *   external plugins.
  *   The back frame buffers are retrieved and bindable like other FrameBuffers
  *   though you can't create or add attachments to it.
  *   Added a debug GPU objects tracking system, to ensure their destruction is
  *   made before context destruction.
  *   Can now read scenes from zip archive files.
  *   The text overlays now can have a horizontal and a vertical alignment.
  *   Added an initial zip data folder, Core.zip, which contains basic materials
  *   and debug overlays.
  *   The shader lighting has been reviewed and fixed.
  *   The Scene class has been reworked, to use ObjectManager classes, and 
  *   ResourceManager views.
  *   Now, the ShaderProgram retrieves the vertex inputs layout. This layout is
  *   used in Submesh, to create the appropriate GeometryBuffers.
  *   Castor3D now renders the scenes using HDR and tone mapping. The default
  *   tone mapping configuration will make the render look like there were no
  *   HDR enabled.
  *
  * GlRenderSystem
  *   Lights texture now uses Texture Buffer Objects.
  *   Removed every GlXxxRenderer class, except for GlOverlayRenderer.
  *   Support for OpenGL 1.x has been removed.
  *   Support for OpenGL 3.x has been enforced, forcing UBOs, for example.
  *   Implemented a GlslWriter, to write GLSL code from C++ source.
  *
  * Subdividers
  *   Implemented a Phong tessellation subdivider.
  *
  * Importers
  *   Implemented a FBX importer plug-in.
  *
  * Techniques
  *   Each render technique is now implemented in its own plugin.
  *
  * PostEffects
  *   The first post effect plugin has been implemented: Bloom.
  *
  * CastorGUI
  *   New plugin, allowing creation of GUIs inside Castor3D scenes.
  *
  * GuiCommon
  *   The whole look and feel has been reworked, using wxAuiManager
  *   Properties are displayed through wxTreeCtrl and wxPropertyGrid, to list
  *   objects and view their properties.


Changes between version 0.7.0.0 and 0.6.5.0

  BUGS FIXED
  * General
  *     Added Destroy functions for each Create function in plugins, so
  *         creation and deletion is made in DLL memory space (for Windows).
  *     Added ASSIMP importer plugin to import actually unsupported file types,
  *         modified ImporterPlugin::GetExtensions to be able to retrieve an
  *         array of pairs <extension, file type>.
  *     Modified Importers so no more memory leaks are detected with Visual
  *         Studio.
  *
  * CMake
  *     Added possibility to change binaries directory and also MSVC
  *         temporary binaries directory, through PROJECTS_BINARIES_OUTPUT_PATH
  *         and PROJECTS_BINTEMP_OUTPUT_PATH.
  *     Added possibility to activate code profiling with MSVC through
  *         PROJECTS_PROFILING boolean value.
  *
  * CastorUtils
  *     Modified Image to make FreeImage load images by path and no more by
  *         handle (caused trouble with some formats).
  *     Repaired a matrix trouble when rendering overlays.
  *     Corrected recursive transformations.
  *
  * Castor3D
  *     Repaired alpha submeshes that were not displayed.
  *     Corrected mipmaps generation.
  *
  * CastorViewer
  *     Moved m_pCastor3D destruction and ImageLoader::Cleanup in the OnDestroy
  *         event handler.
  *
  * GlRenderSystem
  *     Corrected a bug in DoGetDeferredShaderSource.
  *     Corrected mipmaps generation in GlStaticTexture and GlDynamicTexture.
  *     Corrected the gloss map in GLSL computed programs.
  *
  * ObjImporter
  *     Corrected materials and textures import.
  *
  FEATURES
  * General
  *     Supports x64 compilation
  *     Cleaned up a FrameBuffer, GlFrameBuffer and Dx11FrameBuffer.
  *     Linux and wxWidgets 2.8 compatibility improved.
  *     Added AStyle support.
  *
  * CastorUtils
  *     Modified DynamicLibrary::GetFunction, added a template parameter that
  *         is the function type, and a method parameter that is the pointer
  *         to the function to retrieve so no more casts when using
  *         DynamicLibrary::GetFunction.
  *     Added log level support for Logger.
  *     Implemented intersection function in Line3D.
  *     That class now has to named constructors : FromPointAndSlope and 
  *         FromPoints, to avoid confusion between them.
  *     Created two classes Size and Position instead of just having a typedef
  *         for these.
  *     Improved FileParser, now functions have parameters and not only
  *         parameters types, and parameters parse themselves.
  *     Castor::Point now holds a static array as it's members instead of a
  *         dynamic one.
  *     Removed Unicode file encoding.
  *     Added stream indentation support.
  *
  * Castor3D
  *     Modified shaders, they now take care of the shader model, they hold all
  *         defined files and sources for each model. The choice of the source
  *         is made at compile time, taking the source with the highest
  *         supported model.
  *     Improved memory occupation, limited overhead of Vertex (152 to
  *         24 bytes) and Face (140 to 16 bytes).
  *     Modified Subdivision, now only in Subdivider, no more in Geometry, mesh
  *         or Submesh.
  *     Implemented Implemented Lights in texture.
  *     Added HasParameter and SetParameter functions in ShaderObject, to apply
  *         matrices from Pipeline.
  *     Removed ApplyXXXMatrix from IPipelineImpl, now the Pipeline applies
  *         matrices itself.
  *     Added channel for textures (colour, ambient, diffuse, specular, normal,
  *	        height).
  *     Implemented MSAA.
  *     Implemented Alpha to Coverage when MSAA is activated.
  *     Modified default sources in GlShaderProgram and Dx9ShaderProgram, they
  *	        are now computed and no more external shader file is needed.
  *     Implemented Frame buffers.
  *     Submeshes are sorted by Material's alpha in order to render submeshes
  *         without alpha before others.
  *     Added functions Begin and End in Mesh class to be able to
  *         iterate through submeshes without using GetSubmesh and
  *         GetSubmeshCount.
  *     Added Material functions Begin and End to retrieve passes in standard
  *         way.
  *     Added possibility to activate or deactivate deferred rendering, this is
  *         also possible from cscn files.
  *     Created TechniqueParameters class to be able to pass generic parameters
  *         instead of, for example, the samples count.
  *     Introducing SamplerState class to group calls to SetSamplerState and
  *         all relative stuff.
  *     Reviewed sizes a bit : Viewport holds the internal size, RenderTarget
  *         and RenderWindow hold external size. Modified  SceneFileParser,
  *         added <size> directive for viewport.
  *     Splitted eBUFFER_MODE in eBUFFER_ACCESS_TYPE and eBUFFER_ACCESS_NATURE.
  *     Modified a bit FrameVariable in order to take care of 
  *         eFRAME_VARIABLE_TYPE previously defined for SceneFileParser.
  *     Modified Submesh::AddPoints so it takes a stVERTEX_GROUP structure as a
  *         parameter.
  *     Introducing FrameVariableBuffer to manage frame variables with OpenGl
  *         UBO or DirectX 11 Constants buffer.
  *     Implemented initialisation and cleanup of GPU side objects in two
  *         events : InitialiseEvent and CleanupEvent.
  *     Merged GpuBuffer::Initialise and GpuBuffer::SetShaderProgram functions
  *         to ease their use.
  *     Removed auto mipmap generation, now if user wants it, he does it with
  *         DynamicTexture::GenerateMipmaps function.
  *     Added DepthStencilState class to manage those buffers states like
  *         Direct3D 11 (who does it well).
  *     Added blend state, implemented raster state.
  *     Put a BlendState instance in Pass and removed rgb/alpha blending from
  *         the pass.
  *     Removed Context::Enable and Context::Disable, removed RenderState
  *         class.
  *     Removed SetPolygonMode from Context.
  *     Moved Render to buffer common code (from FrameBuffer and
  *         RenderWindow) into Context::BtoBRender.
  *     Implemented mesh instantiation on hardware.
  *     Modified Submesh normals generation.
  *     Moved materials from Submesh to Geometry.
  *     Modified submeshes instance count, to make it specific to
  *         the materials used by the submesh instances.
  *
  * GuiCommon
  *     Now ShaderDialog uses wxSizers.
  *     Using wxStcEditor to view and edit shaders.
  *     Materials windows now use wxSizer classes to place and resize elements.
  *     Added possibility to change the material used by a submesh in
  *         wxGeometriesListFrame.
  *     Corrected few bugs in images loading.
  *     Improved StcTextEditor in order to have a better syntactic
  *         coloration.
  *
  * CastorViewer
  *     Now MainFrame uses wxSizers.
  *     Added command line options : 
  *         -f/--file to load a scene on startup
  *         -h/--help to display help
  *         -l/--level to define log level : - 0 for debug to errors
  *                                          - 1 for release to errors
  *                                          - 2 for warnings to errors
  *                                          - 3 for errors only.
  *     Now loads plugins in a thread.
  *     Added an "Export" button.
  *
  * GlRenderSystem
  *     Removed GLEW dependency.
  *     Implemented OpenGL debug output so I have more verbose debug outputs
  *         for OpenGL too.
  *     Added GL_MIRRORED_REPEAT.
  *     Added GL_TEXTURE_MAX_ANISOTROPY.

  MISC
  * General
  *     Splitted file to have one class per file.
  *
  * CMake
  *     Updated UnitTest integration, Enabled CTest.
  *
  * CastorUtils
  *     Removed all static members and globals.
  *     Removed String class, added str_utils.
  *     Removed all dependencies to boost, except for thread, for non C++11
  *         compilers.
  *     Modified Point, moved functions that shouldn't be in that class in a
  *         small helper class : point. It holds normalise, get_normalised,
  *         dot, all distance functions, cos_theta, negate.
  *     Modified FileParser in order to be able to ignore complete sections
  *         without commenting it (such as HLSL shader blocks in
  *         GlRenderSystem...).
  *     Modified FileParser to take care of parsers parameters.
  *     Reduced images memory occupation.
  *     Removed Point::link, Point::copy/clopy/clone functions.
  *     Replaced macros for cstrnlen, cstrftime, cstrncpy, cfopen, cfopen64,
  *         cfseek and cftell by functions in namespace Castor.
  *     Modified Colour class, it doesn't extend Point4f anymore.
  *     Removed macro DECLARE_SHARED_PTR, now using  DECLARE_SMART_PTR, so I
  *         replaced each XXxPtr by it's equivalent XxxSPtr.
  *
  * Castor3D
  *     Merged Submesh and SmoothingGroup classes.
  *     Reduced memory size of vertex buffers.
  *     Modified Submesh::ComputeTangents to take care of each vertex normal.
  *     Modified BufferElementGroup so it can't hold anymore its buffer.
  *     When initialising Pass, the texture units are re-ordered so the ones 
  *         with a defined channel come first.
  *     Passes now initialise their shaders in Pass::Initialiser instead of
  *	        trying to do it at each frame.
  *     Changed RenderTarget : now it only holds frame buffer and all needed
  *         for that. It is now a Renderable so TargetRenderer has been
  *         created.
  *     RenderWindow no longer extends RenderTarget, but now it has a
  *	        RenderTarget as a private class member.
  *     Created TextureBase class, StaticTexture and DynamicTexture to help
  *	        implementing render targets.
  *     RenderTarget now uses RenderTechnique to make its rendering.
  *     Created GeometryBuffers class which holds a Vertex buffer and an Index
  *	        buffer, they are created by the RenderSystem.
  *     Moved RenderTechnique basic frame buffer, texture and depth buffer into
  *         RenderTarget.
  *     Moved TargetRenderer::PostRender code into RenderWindow.
  *     Created WindowRenderer::EndScene function to prepare the render of the
  *         RenderTarget's frame buffer into the window.
  *     Removed calls to ShaderObject in order to make it more internal to
  *         Castor3D.
  *     Overlays are no more Renderable, there is one instance of OverlayRenderer
  *         class in the OverlayManager. All overlays will be rendered through
  *         this instance by the OverlayManager.
  *     Modified Scene, added template functions to add, remove or get
  *         an object whatever it's type may be (Light, Geometry, Camera, 
  *         SceneNode).
  *
  * GlRenderSystem
  *     Reviewed Vertex Array Objects, they now hold their buffers so the
  *         choice of using it or not is wrapped into it.
  *     Geometry shader work in OpenGL, created a shader to show wireframe
  *         models with Normals, Tangents and Bitangents.