• published on 12/7/2016 8:44 PM

    One more release has made it before the end of the year reached us. The original plan was to focus on getting Vive support in but inspiration was surprisingly lacking and it didn’t help that I stumbled on a bug in Valves OpenVR library. They quickly fixed it once it was brought to their attention so this release now comes with oculus and vive support. It will try to start up using oculus first and if that isn’t detected it will start OpenVR for vive. There is a setting in the configuration window that you will like if you have both but prefer to use the vive instead of oculus.

    The vive is mainly a standing experience and oculus seems to moving towards that as well. This posed a rather difficult problem since the scenes now need to work in VR while sitting, standing and walking around. I think I found a good balance with this so the scene should work well in all those scenarios but it’s not perfect. All scenes have been adjusted to support this and I’m happy to say that the end result was well worth it. Adding to this difficulty I also activated the layered support for vr scenes. Since all scenes have to be in real world units this worked surprisingly well. Some scenes look just amazing together like the sphere beat combined with inside cube where you can walk around this beating sphere. It certainly brings the music to another level and this is of course just the start. In total there are now 76 scenes that works well in VR!

    But don’t worry that this is a VR only release. There are multiple major changes in other parts of the visualizer as well.

    Bloom The bloom has been rebuilt from the ground up and it looks much better now than the old bloom.

    Scene combiner Before each scene was rendered into a 8 bits per component surface and thus each scene had to do it’s own gamma correction. Since we can render up to 7 scenes at the same time this lowers the performance we get and the quality because of quantization artifacts when each scene is combined with the next. To help with this all scenes now render to HDR buffers. We then do a postprocessing pass that has the following effects

    • High quality gamma correction
    • Banding removal. Banding can completely destroy a scene and is especially easy to see in very dark colors.
    • Compute luma to improve fxaa quality
    • Simplifies scenes since all this is done for them
    • Can in the future skip gamma correction to output to HDR monitors

    Speaker setup A bug has been reported a few times that I managed to track down to users of a any speaker setup that isn’t mono, stereo or exactly 5.1 with front, center, back, sub. Those affected noticed that the spectrum were not that well matched to the music.

    Removed scenes Quite a lot of scenes have been removed in this release mostly because I didn’t think they matched the quality I wanted or just didn't fit as music visualizer scenes.

    Example of v2.5


    The full release notes


    • Support for OpenVR and HTC Vive
    • Greatly improved bloom
    • Enable anisotropy for mipmapped surfaces. Brings large quality improvements to some scenes
    • Added global dither/banding removal for all scenes
    • Changed render target to be HDR for improved quality in scene layer composition and to prepare for real HDR monitors
    • JXR, HDR loader
    • Panoramic image support
    • Support point sampled textures
    • Show how long time is left before recording is completed
    • Respect pause and quit for oculus
    • Removed individual scene gamma and made it global for all scenes
    • Let the studio application log into it's own log file
    • Set transitiontime, sceneminruntime, scenemaxruntime from command line in recording mode
    • Support damping and rate decrease/increase for waveform
    • Better shader random functions
    • Fog shader function
    • Autoflush studio log file
    • Support for height textures in materials
    • Only allow the scene to change once because of silence
    • Enable layered scenes in VR for much greater variety. Can be disabled in options if your system can't handle it.
    • Play button on each scene in the studio timeline to quickly be able to see how the scene looks in its layered form


    • Fixed issue on setups that contained anything else than exactly mono, stereo or 6 channel (front, center, back, sub) speaker setup
    • Changed to ACES tone mapping for almost all scenes to improve dark colors
    • Target OpenGL core profile
    • Take screenshots from texture and not individual windows
    • Asteroids node explosion bug
    • Dont quit when any key is pressed in windowed mode
    • Make sure we load in the correct texture during preloading
    • Improved FXAA
    • More accurate gamma correction
    • Approximate 2x improvement to video recording speed.
    • Scenes could look wrong during transitions when reduced sizes were used
    • Qt 5.7
    • Oculus SDK 1.9
    • Fixed wrong movement of close object for Oculus. Makes the VR experience much better.
    • Large quality improvement on streaks and all scenes using it
    • Limit to/from transition scale to 100% max
    • Replaced "tiles" texture used in a few scenes
    • Improved quality of a few textures

    Removed Removed Bumpy Interference, Creation,Liquid Metal,noise walker,copper bars,particle cloud,my brain hurts,spiral interference,star,Kaleidoscope,twist,Quaternion,Digital Heart,Glowing Spike Ball,2DKIFS,crystal,glow lines,ToTheRoadOfRibbon, 3part color, meta ice,star scenes,spectrum waves,dotfunnel

  • published on 3/3/2016 8:58 PM

    This releases main focus have been to create a nice smoke/fire effect, fix banding issues in scenes and also to create a recording application. I would say all of those goals have been met even though the fire effect could be more optimized. It’s another base effect that can be used in any number of ways so you can be sure you will see more fire based scenes in the future.

    It's quite a strange feeling you get when one of these natural simulations work. You add fuel and set it on fire using a high temperature and it all comes alive on it's own. It then consumes the fuel while creating an upward draft and smoke along with it. Adjust the fuel amount and the velocity it's injected with and the fire reacts accordingly. No wonder they say fire feels like its alive.

    Some of the added/updated scenes updated for v2.4

    Change history


    • Studio application to make it easier to record videos
    • Toggle if we should automatically go to next scene if left arrow key is pressed
    • Lock sound analyzer to 30Hz
    • Added damping, increase and decrease rate to sound texture
    • _screenSpaceDither,_textureBicubic,_blackBody shader function
    • Support geometry shader
    • RG & R 16bpp textures
    • Lower max detected sound level over time to handle sound spikes when normalizing audio
    • Stop screensaver if mouse click and preview fullscreen
    • Added 11 new scenes
    • Added NotSelected tag in config
    • Auto track a rough estimate of how long a scene as been worked on


    • Gone through all scenes to fix banding issues
    • Max normalization adjustment increased to 1000x. Going from high to low sound should find the new max in about 7 seconds.
    • Updated to Qt 5.5.1
    • Fix nearz,farz values
    • Fixed a missing end of line in a shader that caused AMD to fail to compile the shader in non obvious ways on some drivers


    • Removed Creation, RGBWaves, Art in motion scenes
  • published on 8/24/2015 7:03 PM

    So the time has finally come to release v2.3 of Plane9. A lot of effort has gone into this release because of the CgFX to GLSL conversion where all 260 scenes had to be manually updated. Mental note for next time is to not build software that relies on proprietary/closed source. Since when/if they stop supporting it you are on your own and will eventually have to convert the whole project to use something else. But I’m very happy that I finally managed to do this conversion since it’s been hanging over me for quite a while now.

    This conversion will however not be noticed since it’s an internal one. What however should be noticed in a major way is the addition of background loading of scenes. The problem before was that when a scene was loaded, and this could be a transition scene in addition to a layered scene for a total of 4 scenes at the same time, all the shaders in the scene had to be compiled. This process can be rather slow in OpenGL and a single shader can take 40ms to compile by the driver. Just compiling a single such shader would cause us to miss rendering a frame. This creates the potentially visible hickup or in other cases just a feeling that the visualiser isn’t as smooth as it should be. To work around this the loading and startup of the scenes are now done in the background. Threaded support in OpenGL isn’t the most robust but it has worked on all systems tested (Intel, AMD, Nvidia) with latest drivers. There is a switch to turn this off in the options window if it where to cause problems. To further reduce loading times so was a file texture cache added and also a system that only includes the needed functions into a shader.

    The other noticeable change is that since I had to go through all scenes I also took the time to update quite a few of them and add PBR (Physically based rendering) shading as well. This is the same techniques used by Unreal Engine, Unity, Frostbite, The Order 1886 and others.

    Some of the added/updated scenes updated for v2.3

    Lastly the oculus support has been updated to v0.6 to be compatible with the oculus SDK v0.7 release that should be out soon.

    Full change history


    • Preload scene on a background thread in screensaver and windowed mode to avoid hickups during scene changes. Can be turned off in options window if it causes issues.
    • Only inject shader functions we actually use. Cuts down shader compilation from 40ms to 15ms for a simple shader
    • Allow foreground scenes to use the PreviousLayer node for much better scene compositions for some scenes
    • New PBR shader including lightDirectional and lightPoint
    • Added fresnel functions, _perturbNormalTexture, _perturbNormal, _noisederiv, _rand(float)
    • Respect randomize setting during recorde mode
    • Mesh instancer will use point sprites if no mesh is connected
    • F2/Ctrl+A to toggle always on top in windowed mode
    • Prefix shader variables with "g" as in "gTime"
    • Added FormatVersion to scene files
    • Place log writer on it's own thread to avoid any hickups during log writing
    • rttscale command line option for a simple brute force form of antialiasing
    • Ignore extension when loading in textures
    • Add a 4th texture input into shader node
    • Load in normal and material textures along side diffuse texture
    • Cache any loaded file textures for future use


    • Updated to Qt 5.5.0
    • Updated to Oculus SDK 0.6
    • Updated a number of scene with PBR features
    • Changed all shaders in all scenes from CgFx to GLSL
    • Allow primary monitor to be on either side of secondary
    • Updated way to get program files folder to better handle non ascii folder names
    • Dont default to always on top in windowed mode
    • High resolution screenshots have the RB values mixed
    • If a scene fails to load then dont use a empty scene in it's place
    • Fixed normal on bevel node
    • Black screen on playlists that dont have any standalone scenes in them
    • Removed usage of depricated glTexEnvf for points. We should use gl_PointCoord
    • Fixed error in projection matrix and adjusted all scenes to match
    • FrameNr 0 should now always be the first frame rendered
    • Default Transition to scale is now at 100% instead of previous 50%. Looks better and most should have a machine that can handle it.


    • Lines node
  • published on 5/1/2015 8:12 PM

    The scenes in Plane9 are meant to be flexible so I can try and experiment with new things easily. Being a programmer and creating a program I want to use made me avoid going down the route that most full game engines have gone. That is using some form of node/dag based editor to create new shaders, if they even allow custom shaders. Instead in Plane9 you write the shaders directly into the scene files. Very powerful, especially since the editor refreshes the scene in realtime as you type. However with this there is the issue with the shading language used. When the project was started you could choose between GLSL (OpenGL), HLSL (DirectX) and CgFX (Both OpenGL and DirectX). Seeing as I wanted to support both apis the choice was quite easy since only one shader language did that.

    This worked quite well for some time but as the years passed by Nvidia stopped supporting CgFX and have since killed it off completely. Looking towards the future this means I have to change to something else sooner rather than later since each scene needs to be manually updated to the new format. The usage of CgFX also stopped some optimization like background compilation of shaders and usage of various performance tools. Since I still want to be multiplatform compatible so was the decision quite easy to go with GLSL because I also want something that most are familiar with and can use for other tasks like WebGL development. It’s also good to know that the future vulkan api/compiler will fully support it.

    However GLSL is quite difficult to work with since each and every graphics card manufacturer creates their own compiler for it, all of course with subtle differences. CgFx protected me from quite a lot of this because it converted the CgFX shader code into GLSL but now this needs to be handled manually.

    The major issues I have run into so far are that all types needs to match. So before I quite commonly did “pi.tex * 2.0 -1.0”. CgFX handled this fine but not all supports this in GLSL, the specification states it’s allowed, the reality is apparently different. So better to always match the types correctly and change the above code to “pi.tex * vec2(2.0) - vec2(1.0)”. This same type matching also goes with float to int since I have lazily used things like “float value = time * 3”. This is once again illegal and should be “time * 3.0” since time is a float value.

    Fixing these issues is difficult to do automatically so I need to go over all shaders in about 1000 scenes and do it manually. This will take some time but I’ll update them with some new features while I’m at it so something else good will come out of this work. I will also remove some scenes I don't feel add anything or where I don't feel the quality is good enough any more.

    As an example when the shader before looked like this

    struct PSInput
        float4 hpos : POSITION;
        float4 diffuse : COLOR0;
        float2 tex : TEXCOORD0;
        float3 wnormal : TEXCOORD1;
        float3 viewdir : TEXCOORD2;
        float3 worldpos : TEXCOORD3;
        float3 pos : TEXCOORD4;
        float3 viewpos : TEXCOORD5;
    PSInput VS_Program(VSInput vi)
        PSInput pi;
        float4 v    = float4(, 1.0);
        pi.pos        =;
        pi.worldpos = mul(gW, v).xyz;
        pi.viewpos   = mul(gWV, v).xyz;
        pi.hpos       = mul(gWVP, v);
        pi.tex          = vi.tex;
        pi.diffuse    = vi.col*color;
        pi.wnormal    = normalize(mul(gWIT, vi.normal).xyz);
        pi.viewdir     = normalize(float3(gVI[0).w, gVI[1).w, gVI[2).w) -;    
        // Hemisphere light
        float a = dot(pi.wnormal, float3(0, 1, 0))*0.5+0.5;
        pi.diffuse *= lerp(vec4(0.957,0.655,0.055,1.0), vec4(0.165,0.675,0.988,1.0), a);
        return pi;
    float4 PS_Program(PSInput pi) : COLOR
        float2 p = pi.tex*2.0 - 1.0;
        // return tex2D(tex1, pi.tex)*pi.diffuse;
        vec3 v = (_fbm(vec3(pi.tex.xy*10, time*0.1),3)*0.5+0.5)*pi.diffuse;
        v = pow(v, 1.0/2.2);
        return vec4(v, 1.0);

    and after the conversion it will look like the following.

        vec4 diffuse;
        vec2 tex;
        vec3 wnormal;
        vec3 viewdir;
        vec3 worldpos;
        vec3 pos;
        vec3 viewpos;
    #ifdef VERTEX
    void main()
        so.pos        =;
        so.worldpos= (gM * iPosition).xyz;
        so.viewpos    = (gMV * iPosition).xyz;
        gl_Position    = gMVP * iPosition;
        so.tex        = iTexCoord;
        so.diffuse    = iColor*color;
        so.wnormal    = normalize((mat3(gM) * iNormal);
        so.viewdir = normalize(gViewPosition - so.worldpos);    
        // Hemisphere light
        float a = dot(so.wnormal, vec3(0.0, 1.0, 0.0))*0.5+0.5;
        so.diffuse *= mix(vec4(0.957, 0.655, 0.055, 1.0), vec4(0.165, 0.675, 0.988, 1.0), a);
    #ifdef FRAGMENT
    void main()
        vec2 p = si.tex*vec2(2.0) - vec2(1.0);
        vec3 v = vec3(_fbm(vec3(si.tex.xy*vec2(10.0), time*0.1),3)*0.5+0.5)*si.diffuse.rgb;
        //vec3 v = texture(tex1, si.tex).rgb*si.diffuse.rgb;
        oColor = vec4(_tosrgb(v), 1.0);

    I prefer the new GLSL style since I find it clearer in what it does. Even though some magic types are used like “so” and “si”. The parser will make sure those always contain the “shader output” and “shader input” as needed for each shader stage. This will hide most of the complexity with working with GLSL shaders and bring some standard for the shaders.

    While I have been doing this I also managed to finalize my PBR shader so it will be easy to work with in any scenes.

    PBR Test

  • published on 2/26/2015 8:48 PM

    I got some crash reports after the v2.2 release was live so I must thank you all that sent them in. It was a bit tricky for figure out exactly what had gone wrong but eventually I found the problem. Just about all reports where related either to not having a OpenGL 3.1 graphics card or moving to the next scene too quickly. The first one will now show a message and ask that to update the drivers and the second one wont allow the scene to be changed during a transition. Without the crash reports it would have been next to impossible to figure this out.

    I had some feature requests as well and since there where quick and easy to do they made it into this release as well.


    Full patch notes


    • Show command line help using "plane9.exe -h"
    • Show help texts if pressing F1 in windowed and VR mode
    • Make sure we have a valid OpenGL 3.1 device and if not show a error
    • Disable mouse cursor in full screen windowed mode
    • Disable screensaver in full screen windowed mode
    • Allow oversized windowes during recording


    • Crash if moving to the next scene too quickly
    • Failure to start WMP plugin with a qwindowed missing message
    • Better scene randomization. Now all scenes should be shown once before reseting scene pools
    • Correct colors in recorded movies
    • Issue with starting WMP plugin
    • Exit better if no Oculus is detected in VR mode
    • Attempt for a fix of ghost image on one eye in VR mode


    • FPS counter in windowed mode

    ..and remember. Why listen to music when you can watch it!

  • published on 2/11/2015 8:48 PM

    Now Plane9 can check off Oculus Rift support on the todo list. I managed to get my hands on a DK2 last autumn and have been trying it out since then. There are very few good applications out there with VR support. I annoyingly discovered that I’m very sensitive to VR and quickly gets simulation sickness. For example when trying any of the rollercoaster demos I usually can’t even get down the first hill before I have to take the kit off. But as long as I, as the vr character, am still then I don’t have any issues.

    So this also means that the VR compatible scenes for Plane9 are geared towards this. In just about all of them so are you still while you can look around to see what happens in the scene. This should make for a rather good VR experience even for beginners. Something different than the few other VR music visualizers that exists is that Plane9 uses both transitions and uncommon postprocessing effects like embos or posterize that can give the scene a completely new direction.


    What’s quite interesting is the new feelings you can get from using a Oculus Rift. Take the 'Music star' scene. If you leave it running for a short while with some music playing, then soon enough so will you realize its just you and the particle field/life form in this world. What can then make a rather disturbing feeling is when the particle field in front of you dies with the music. Leaving you all alone in this completely black and silent world. It’s certainly not a feeling I have even had a program made me feel before.

    Music star

    Some other goodies in this release is support a new threaded engine for a smoother experience. There is also now support for 150% and 200% render targets if you have the GPU to spare for increased quality. Plane9 now tells Nvidia Optimus to use the dedicated GPU, so if you have such a laptop you might see a large performance increase. I also discovered that on multimonitor system so was the total render area rendered for each monitor. This means that if you have 3 monitors you could see an almost 200% performance boost. What took a lot of time in this release was the internal change to use Qt for window management, changing to GLM for math and adapting the OpenGL’s right handed coordinate system and upside down textures.

    Here is the full change list Added

    • Oculus Rift support! VR mode will treat background and foreground scenes as standalone.
    • Added support for 150% and 200% resolutions for improved quality for the ones that have the GPU to spare.
    • Run updates on a separate thread
    • Preload some shaders to reduce scene switching latency
    • Use Qt as main window manager
    • ScreenNode: Added look at
    • Change scene using space in windowed mode or right arrow in screensaver mode
    • Use GLM for math
    • Follow OpenGL and use right handed system with Z going out from screen
    • Tell Nvidia Optimus to use the dedicated GPU
    • 12 new scenes
    • Added ability to start a playlist in VR or Windowed mode from the configuration screen
    • Collect total and free GPU memory if we can


    • SoundTexture: Increase quality by using 16 bit texture
    • SoundTexture: Accumulate result for a better result
    • Increased quality of the fast noise
    • All screens were rendered for each monitor in a multi monitor setup.
    • Memory leak on layered scene if moving to the same scene
    • Large increase in quality of earth textures. Now requires at least 100Mb GPU memory to show just that scene
    • Qt 5.4.0
    • Last scene wasn't shown in the configuration screen


    • Removed FreeImage library. Used Qt instead
    • Removed clover and blobbies
  • published on 9/17/2014 8:21 PM

    So today marks the day v2.1 got released. It's mainly internal changes that have gone into this release where the separation between CPU and GPU work has been much more cleanly defined. This is partly so I can speed up rendering by sorting all render work but also to make it easier to change over to Qt rendering and OpenGL shaders.

    Some bug have also been fixed as reported by the crash reported and by email/facebook. This release also now correctly captures up to 18 channels of sound. Before if you used for example foobar2000 with a multichannel output plugin to get surround from your stereo music or from you true surround music then Plane9 would only capture and analyze the left and right speakers. Now he will capture all channels and analyze them. This should hopefully make for a better sound response in these cases. Quite a few scenes got updated. Specially with bloom and gamma correction. Gamma correction can change the scene quite drastically. Just a few new scenes where added in this release.

    The incomplete change list


    • Support analyzing sounds from the default recording device instead of 'what you hear'
    • Support cubemaps in folders
    • EffectNode: Allow setting alpha blending mode seperatly
    • Added a few Spherical Enviroment Map Textures
    • Added a few cubemaps
    • Enable seemless cubemaps
    • Increase max scene time in configuration windpw
    • Updated command line options. Now supports --width, --height, --rectime, --recfps, --music, --rand, --scene
    • Added foggy and foglights scenes
    • Capture up to 18 channels of sound and combine them into left and right. Before all channels except left and right front speakers where ignored.


    • Sort scenes in configuration window based on last modification time so newly changed scenes are shown first
    • Updated a lot of scenes with bloom/gamma correction/new lighting/..
    • Fixed issue where the main monitor must be to the left of any secondary monitors. Thanks to all who reported this.
    • New shader based noise functions that are 30% faster than the old one
    • Diffuse textures are now loaded as sRGB textures. So any scene using textures must gamma correct the final output to look correct.
    • Changed to a PaintJob based engine design for cleaner seperation between CPU and GPU work
    • Qt 5.3.1
    • Fixed a few crashes as reported by the crash report system
    • Corrected check that verifies that frame buffers are supported


    • The following scenes "Tunnel", "Neon world", "Cell rotation", "Cube sin", "ChasingTheDream", "into the matrix", "rainbow wave", "signal" since they looked bad/where boring
  • published on 2/16/2014 2:18 PM

    After almost 3 years Plane9 v2.0 have been released and I couldn't be happier that it's finally done. It goes without saying that this release took a lot more time to complete than I had planned. However on the other hand a lot of things got into this release that I initially didn't plan for since the main feature, the configuration rebuild, took a lot of time. So this is one feature packed release. I also wanted to get in any future breaking changes to the scene format in this release however I had to skip this since there is still a lot of work left. Mainly that the whole editor needs to be rebuilt to handle the new scene format in a better way so until that time the editor wont be included in the releases. Because of this all user uploaded scenes have sadly been removed from the webpage until the new editor is ready since the old scene format wont work with the new configuration window.

    The major new changes are

    • Completely rebuilt configuration
    • Transition scenes
    • Always active FXAA for cheap AA
    • Bloom
    • Sound normalization in screensaver mode
    • The software is now free so there is no need to get a license key to unlock any extra features. A big thanks goes out to all that have supported the software so far!

    A incomplete list of changes follows


    • 100+ scenes and 35 transitions
    • Engine: Support transition scenes
    • Float buffers to render textures
    • Engine: FXAA antialiasing
    • Engine: NormalDir factor. Use to create shaded particles.
    • ParticleNode: Turbulence Affect Size
    • ParticleNode: Velocity damping
    • ParticleNode: Time scale
    • ParticleNode: Color Var
    • ParticleNode: Velocity from motion
    • ParticleNode: Velocity random
    • ParticleNode: Direction
    • ParticleNode: Ribbon tail
    • ParticleNode: Option to store particle alive time in alpha
    • ParticleNode: Floor collision
    • ParticleNode: noise flow field
    • Engine: Expression: Let Spectrum average part of the spectrum
    • Engine: Globaly unique id and parent id to scene format
    • DiscNode: Add double sided and phase
    • CylinderNode: Add slices & rings, center
    • RenderToTextureNode: Float buffer support
    • CubeNode: Allow to define tessellation along X,Y and Z axis
    • Engine: High quality simplex noise functions added to shaders
    • Engine: Add better way to record a set of scenes with a specific song
    • Engine: Send in 'render size' to the shaders
    • Engine: Add destination size variables to effect nodes and 1/width,1/height in all size variables
    • Engine: Allow scenes to be tagged
    • Engine: License to scene format
    • Add crash hook so issues can much more easily be reported
    • Engine: Particle will interpolate emitter position to handle fast moving emitters
    • Engine: Spectrum values supports damping
    • CenterMeshNode
    • InvertFaces
    • TransformExNode
    • BloomNode
    • RollerNode
    • MirrorNode
    • NoiseNode
    • RandomizeNode
    • DeleteFaceNode
    • FacetteNode
    • BevelNode
    • SubdivideNode
    • ExtrudeNode
    • MeshInstancerNode
    • RenderToTextureNode: Effect input
    • LightningNode: WidthReduction
    • RenderToTexture: Possibility to change how long between each update of the ColorNext from the current Color texture
    • Config: Option to specify how often a postprocessing scene should be used


    • Config: Remade the whole configuration window to be easier to use
    • Engine: Improved the scene randomizer so it will always go though all scenes once before being allowed to pick the same scene again
    • Engine: Default max FPS is 60hz
    • Engine: Remade the scene format to a zip compressed storage format. Also includes screenshot.
    • Engine: Increase the resolution of the Font texture to 512x512
    • Engine: gWIT, gVI now takes scaling in the original matrices into account
    • Engine: A CPU with SSE2 is required (Any cpu after 2005 should do)
    • Engine: Grass: Fixed rendering issues
    • Engine: Optimized mesh handling
    • Engine: Improved loading/saving time of scene files
    • Engine: Store screenshots in users "Pictures" folder so they can easily be found and for example used as desktop wallpapers
    • Config: Rename scene collection to "playlist"
    • Scene: Corrected the synchronous column rain behavior that occurred in the Matrix trails scene.
    • Scene: Much improved lightning in electroSphere
    • TorusNode: U mapping has been inverted so textures are applied correctly by default
    • TorusNode: Added Arc and Phase
    • Engine: Move previouslayernode to 'special' group
    • Engine: Change expression 'clip' to 'clamp' and the function of 'clamp' to 'wrap'
    • ClearNode: Default clear nodes to set alpha to 0.0
    • Engine: Occasional occurring sound capture initialization error
    • Update existing scenes to use v2.0 capabilities better
    • Engine: Handle meshes with over 65525 vertices
    • Engine: Automatically normalize the sound


    • Editor: Temporarily removed since all shaders will be changed to GLSL in a future version
    • Config: Don't allow changing display mode. The resolution swap is too disruptive
    • CloneNode: Removed
    • Engine: Removed scene name stored in scene files. Use filename only
    • Engine: Remove camera input from RenderObject
    • Engine: Dont send detailed file statistics any more. Too much data for little gain.
    • DiscNode: Remove 'End' input

    I hope you enjoy this latest version as much as I do!

  • published on 1/5/2014 11:53 AM

    I have come to the realization that the editor needs to take a timeout and will be skipping the v2.0 release. This decision wasn't made lightly but it will make a comeback in a future version. As to why this is so here are the reasons for the curious.

    • The shaders will be changed from CgFx to GLSL. This is nothing I can fully automate so I don't want more scenes to be created using the old shader format that the creator of the scenes need to manually convert.
    • I don't want to force users to download and install .Net just for the editor
    • Mixing .Net and Native code prevents the usage of some windows features
    • I am going to convert the editor to Qt so everything is native (No .Net needed). Because of this some new features are not yet as editor friendly as I would like them since the plan is to fix them in the Qt based editor.
    • The current editor is using a commercial GUI library that is rather large The original plan was to get this into v2.0 but since the last release was 2 1/2 years ago it's time to accept the fact and not let this hold up the release any more.

    This means that if you do use the editor in v1.x you should not install v2.0 since you wont be able to edit your own scenes.

  • published on 12/21/2013 9:42 PM

    Since the first version of Plane9 I have asked for a minimal fee for anyone that wants to support the program. The idea was that you should get the program for free and be able to use it for as long as you like. If you however want to support the software you can get a key and some small reward that isn't critical to the functionally of the software. This idea came from that I dislike the normal crippled software license schema that most others use where you get to use the software but its so crippled that it's hardly useful, stops working in 10 days or shows a registration warning every minute.

    With my choice of schema the requested money amount must be low since the user already have the fully functional software. For example I ask for 5$ while most others take 20$-30$. However asking for a small amount of money from a lot of people also means more people to support for a small return. I can't say I have had a lot of support requests, most of them relating to spam filters that are a bit too eager, but there have been a few and all of them take away from time that I could spend improving the software.

    To this end I went back and tried to rethink the license system. So I wanted the license system to contain the following

    • No limits to the software
    • No license keys
    • Commercial use of the scenes would require compensation to the author of the scene if they so choose to require it So to this end for v2.0 the license system will be changed. The software will be completely free, this way I don't have to bother with license keys and can spend more time creating new features, creating scenes and fixing bugs instead.

    The other change that will take effect is that all scenes comes with their own license. This is so the author of the scene can decide how you are allowed to use their creation. If they want it to be placed in the public domain they are free to do so and if they want it to be free for non commercial use then they can do that to. The latter license is what most scenes will use that comes with Plane9. Some scenes are based on others work that have their own license and they wont be allowed to be used in any form of commercial application, they have the 'norelicense' tag attached to indicate this.

    The idea is that if you want to use a scene where you will be paid to show the scene then the actual creator of the scene should also gain something from it. But if your a home user or even a corporate entity that just want to use the scenes on all the computers in the office then your free to do so and you wont feel that you are missing out. Using this system you are also sure the scene will work before asking for a commercial license of any scene since it wont be limited in anyway.

    This means that if you like to use a scene created by me you can get in contact for license requests. Just make sure the scene in question doesn't have the 'norelicense' tag attached to it. If it does then you need to contact the original author that will be written in the description field. If you get his/her permission to use the original work commercially then you will be allowed to use the scene from Plane9 as well.

    Lastly I want to give a warm thank you to all that became supporters so far and I wish this decision doesn't diminish your reason as to why you became a supporter in the first place.