@petersvp - Thanks for the info, we'll keep this scenario in mind and try to make sure we don't lose any flexibility.



Keep in mind that Ogre's concept of a material (a shader plus parameters and textures) is different from PolyVox's concept of a matetial (just a numeric identifier). If you like you can render your whole mesh with a single Ogre Material, and have your shader look at the numeric identifier to decide which texture to apply.

The plan going forward is that this changes slightly - the vertex data won't have a material as such but rather a copy of the whole voxel. Of course, this voxel may well include a material identifier (that's up to you) so the same principle can apply



No, unfortunately this isn't in line with the way PolyVox works and I think it would be difficult (and inefficient) to update just part of the buffer.

I think the upcoming changes are going to push PolyVox to require VS2013 on Windows.

There's now an extra level of templates involved because the vertex types are now templatized, and I'd like to hide this complexity from the user by providing an appropriate set of typedefs. C++ does not support templatized typedefs but C++11 provides a feature called 'alias template' which is basically the same.

Unfortunately this is not supported on VS2012 so VS 2013 would be required.

...and I'm with 2010

I guess it's about a time I switched to Linux GCC then eh.

Provide a compiler define that disables hiding if this complexity and allows VS2010 to be used (with the appropriate complicated example)

I don't think that you even need template aliases, I still think that this can be made easy.

I don't think that's practical - we already moved to VS 2012 and we intend to use more C++11 features as time goes on because it makes our lives easier. We don't really have the time or resources to test on older compilers or adapt for them.


Indeed, we don't really need them. Actually I haven't introduced them yet I just think they will be useful, and probably just one of several C++11 features we will want to make use of.

I do feel a bad for people who will have to upgrade, but as discussed in this blog post we want to focus on what works for us so we can push forward as fast as possible.

Would it not still work with codeblocks and mingW?

I should have been more clear - I'm only suggesting that users of VS 2012 will need to move to VS 2013. I haven't tested other compilers (GCC and Clang) on Windows but they work fine on Linux because they generally have much better C++11 support. I expect they will be fine on Windows too.

Keep in mind that Ogre only has prebuilt versions for VS2008, VS2010 and VS2012. Requiring VS2013 for PolyVox will force Ogre users to compile Ogre from source.

...And yes, this one I am afraid doing myself. And not just me. Better get stuck with 2012 and support it or ask Ogre's Gurus to support 2013 / Windows 7.

Yes, it's terrible that I have to explicitly state this, but the industry and software maintenance are somehow dictating what users do. Just switching to 2013 will force so much users get pissed off because compiling libraries like Ogre and Qt is terribly difficult. (Well. these Linux guys are definitely smarter by us, Windows guys).
In the ideal world, everything will be standardized in a way that everybody just downloads it, unpacks it, compiles it with just a command and is happy.
In the REAL world, there is a thing called CMake (and another one called Visual Studio).
They both makes the pain to compile libraries and projects a little bit not-so-painful.
Still, Visual Studio is somehow forced "standard" here on Windows. You either use precompiled libraries and drop them right into your project, or you feel the pain to compile them with some unknown version of GCC / CLANG. And when Visual Studio versions come into play, you still encounter this issue.
You can spend up entire days in order to get a library just compile for a version of a compiler that this version was untested from, instead of concentrating your efforts to work on your artistic innovative Veoxel-based piece of code