Currently i have my engine that supports Win 7, linux, iOS, and Android. I use eclipse, xcode and visual studio 2010. However, now i want to integrate windows 8 and visual studio 2012.
My problem is, that project files have the same file extension between VS2010 and VS2012. This is nice for a few reasons, but not nice for some reasons.
When i check my code in via VS2010, and want to work on the code in VS2012, the project files get upgraded, and then they can not be checked back in.
I have checked into CMake, and it is nice, as then the project files are not part of source control, instead then would be built upon source checkout.
I like this, however, i am not very good with CMake. Does anyone have any experience with it? I use Property Sheets to setup my libraries and sample applications.
1) How do you incorporate Property Sheets into CMake
You don't use CMake to generate property sheets as the reason for them is redundant with the problems CMake solves. The general reason for property sheets is to insert include paths, libraries, preproc defines etc into the build so you don't have to constantly add all those things to individual derivative projects. CMake solves this problem in a different way which removes the need for property sheets.
The concept which is missed very often is that the output solutions/projects/makefiles/whatever are supposed to be used for a single type of build. What I mean is that you might make a "XCode" directory, cd into it and then type in "CMake ./" to build your solution on an OsX box, but that will be building a target "for" XCode and OsX by default. If you want to target the same code for some other thing (the purpose of property sheets, kinda), you need to add a target designation and put all that property sheet work into the CMake files so the generated output builds against the intended SDK (OsX versus Ios) and all the other variations. It is a pain in the ass in general but once done, it's easy to just reuse, much like the property sheets. Unfortunately I don't have an active example of this way of using CMake I can post but I will post a fairly detailed and complete (though missing all the porting items you are asking about) link to a project using CMake below.
my next issue with CMake is that the projects that it creates, sets a bunch of default values inside of the project properties.
2) How can i set the values to be "Inherit From Parent"
You can't directly. Again, CMake's purpose replaces this functionality and you need to use CMake to work around it.
3) Is there a better solution then using CMake
I wish. I both love and hate CMake. The abilities it supplies are wonderful. but the "language" sucks hairy donkey nuts. There is Premake which is quite nice except it lacks the maturity of CMake and as such misses integration with QT, *nix replacement of autoconf, etc which limits it's usability. Not to mention XCode updates tend to lag behind hugely.
Thanks much for any help
As a possible suggestion for figuring out CMake and how to inherit setup, I'll post a link to my recent rewrite of my game object system. Please keep in mind this is only a couple days old and is a complete rewrite, so if you go poking about the actual code you'll likely notice plenty of issues. But the CMake portion is fairly solid for showing how to inherit things from section to section. https://github.com/All8Up/libgo.git
I haven't fully cleaned up the CMake stuff but the general idea should be usable. I break things into little tiny libraries each with it's own CMakeLists.txt, export the information required to include/link/define needed items for inheritors etc. This is basically the concept of property sheets used in CMake.