public void Output(TargetVS targetVS, string outDirectory)
        {
            string filterFilename = namespaceName + ".vcxproj.filters";
            var    filterFile     = new FileStream(outDirectory + "\\" + filterFilename, FileMode.Create, FileAccess.Write);

            filterWriter = new StreamWriter(filterFile, Encoding.UTF8);

            WriteLine("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
            WriteLine("<Project ToolsVersion=\"4.0\" xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">");

            WriteLine("  <ItemGroup>");
            foreach (var filter in RootFilter.SubFilters)
            {
                OutputFilter(filter);
            }
            WriteLine("  </ItemGroup>");

            OutputFiles(RootFilter.GetChild("Source Files"), "ClCompile", ".cpp");
            OutputFiles(RootFilter.GetChild("Resource Files"), "ResourceCompile", "");
            OutputFiles(RootFilter.GetChild("Header Files"), "ClInclude", ".h");

            Write("</Project>");

            filterWriter.Dispose();
            filterFile.Dispose();
        }
Ejemplo n.º 2
0
        static void OutputSolution(TargetVS targetVS, DotNetParser parser)
        {
            string targetVersionString;
            switch (targetVS)
            {
                case TargetVS.VS2008:
                    targetVersionString = "2008";
                    break;
                case TargetVS.VS2010:
                    targetVersionString = "2010";
                    break;
                case TargetVS.VS2012:
                    targetVersionString = "2012";
                    break;
                case TargetVS.VS2013:
                    targetVersionString = "2013";
                    break;
                case TargetVS.VS2015:
                    targetVersionString = "2015";
                    break;
                default:
                    throw new NotImplementedException();
            }

            string slnRelDir = (targetVS == TargetVS.VS2010) ? "" : "..\\";
            string rootFolder = slnRelDir + "src\\";

            var confs = new List<ProjectConfiguration>
            {
                new ProjectConfiguration("Axiom", true, "GRAPHICS_AXIOM",
                    slnRelDir + "..\\Axiom-SDK-0.8.3376.12322\\bin\\Net35"),
                new ProjectConfiguration("Axiom", false, "GRAPHICS_AXIOM",
                    slnRelDir + "..\\Axiom-SDK-0.8.3376.12322\\bin\\Net35"),
                new ProjectConfiguration("Generic", true, "GRAPHICS_GENERIC"),
                new ProjectConfiguration("Generic", false, "GRAPHICS_GENERIC"),
                new ProjectConfiguration("Mogre", true, "GRAPHICS_MOGRE", "C:\\MogreSDK\\bin\\Debug"),
                new ProjectConfiguration("Mogre", false, "GRAPHICS_MOGRE", "C:\\MogreSDK\\bin\\Release")
            };
            if (targetVS != TargetVS.VS2008)
            {
                confs.Add(new ProjectConfiguration("MonoGame", true, "GRAPHICS_MONOGAME", "$(ProgramFiles)\\MonoGame\\v3.0\\Assemblies\\WindowsGL\\;$(ProgramFiles(x86))\\MonoGame\\v3.0\\Assemblies\\WindowsGL\\"));
                confs.Add(new ProjectConfiguration("MonoGame", false, "GRAPHICS_MONOGAME", "$(ProgramFiles)\\MonoGame\\v3.0\\Assemblies\\WindowsGL\\;$(ProgramFiles(x86))\\MonoGame\\v3.0\\Assemblies\\WindowsGL\\"));
            }
            if (targetVS != TargetVS.VS2008 && targetVS != TargetVS.VS2010)
            {
                confs.Add(new ProjectConfiguration("Numerics", true, "GRAPHICS_NUMERICS"));
                confs.Add(new ProjectConfiguration("Numerics", false, "GRAPHICS_NUMERICS"));
            }
            if (targetVS == TargetVS.VS2008)
            {
                confs.Add(new ProjectConfiguration("OpenTK", true, "GRAPHICS_OPENTK", "$(USERPROFILE)\\My Documents\\OpenTK\\1.1\\Binaries\\OpenTK\\Release"));
                confs.Add(new ProjectConfiguration("OpenTK", false, "GRAPHICS_OPENTK", "$(USERPROFILE)\\My Documents\\OpenTK\\1.1\\Binaries\\OpenTK\\Release"));
                confs.Add(new ProjectConfiguration("SharpDX", true, "GRAPHICS_SHARPDX", slnRelDir + "..\\SharpDX\\Bin\\DirectX11-net20"));
                confs.Add(new ProjectConfiguration("SharpDX", false, "GRAPHICS_SHARPDX", slnRelDir + "..\\SharpDX\\Bin\\DirectX11-net20"));
                confs.Add(new ProjectConfiguration("SharpDX Signed", true, "GRAPHICS_SHARPDX", slnRelDir + "..\\SharpDX\\Bin\\DirectX11-Signed-net20"));
                confs.Add(new ProjectConfiguration("SharpDX Signed", false, "GRAPHICS_SHARPDX", slnRelDir + "..\\SharpDX\\Bin\\DirectX11-Signed-net20"));
                confs.Add(new ProjectConfiguration("SlimDX", true, "GRAPHICS_SLIMDX", "$(PROGRAMFILES)\\SlimDX SDK (January 2012)\\Bin\\net20\\;$(PROGRAMFILES(x86))\\SlimDX SDK (June 2010)\\Bin\\net20\\"));
                confs.Add(new ProjectConfiguration("SlimDX", false, "GRAPHICS_SLIMDX", "$(PROGRAMFILES)\\SlimDX SDK (January 2012)\\Bin\\net20\\;$(PROGRAMFILES(x86))\\SlimDX SDK (June 2010)\\Bin\\net20\\"));
            }
            else
            {
                confs.Add(new ProjectConfiguration("OpenTK", true, "GRAPHICS_OPENTK")
                {
                    ConditionalRef = "OpenTK",
                    ConditionalRefAssembly = "OpenTK, Version=1.1.0.0, Culture=neutral, PublicKeyToken=bad199fe84eb3df4"
                });
                confs.Add(new ProjectConfiguration("OpenTK", false, "GRAPHICS_OPENTK")
                {
                    ConditionalRef = "OpenTK",
                    ConditionalRefAssembly = "OpenTK, Version=1.1.0.0, Culture=neutral, PublicKeyToken=bad199fe84eb3df4"
                });
                confs.Add(new ProjectConfiguration("SharpDX", true, "GRAPHICS_SHARPDX", slnRelDir + "..\\SharpDX\\Bin\\DirectX11-net40"));
                confs.Add(new ProjectConfiguration("SharpDX", false, "GRAPHICS_SHARPDX", slnRelDir + "..\\SharpDX\\Bin\\DirectX11-net40"));
                confs.Add(new ProjectConfiguration("SharpDX Signed", true, "GRAPHICS_SHARPDX", slnRelDir + "..\\SharpDX\\Bin\\DirectX11-Signed-net40"));
                confs.Add(new ProjectConfiguration("SharpDX Signed", false, "GRAPHICS_SHARPDX", slnRelDir + "..\\SharpDX\\Bin\\DirectX11-Signed-net40"));
                confs.Add(new ProjectConfiguration("SlimDX", true, "GRAPHICS_SLIMDX", "$(PROGRAMFILES)\\SlimDX SDK (January 2012)\\Bin\\net40\\;$(PROGRAMFILES(x86))\\SlimDX SDK (June 2010)\\Bin\\net40\\"));
                confs.Add(new ProjectConfiguration("SlimDX", false, "GRAPHICS_SLIMDX", "$(PROGRAMFILES)\\SlimDX SDK (January 2012)\\Bin\\net40\\;$(PROGRAMFILES(x86))\\SlimDX SDK (June 2010)\\Bin\\net40\\"));
            }
            //confs.Add(new ProjectConfiguration("SlimMath", true, "GRAPHICS_SLIMMATH", slnRelDir + "..\\SlimMath\\SlimMath\\bin\\Release"));
            //confs.Add(new ProjectConfiguration("SlimMath", false, "GRAPHICS_SLIMMATH", slnRelDir + "..\\SlimMath\\SlimMath\\bin\\Debug"));
            if (targetVS != TargetVS.VS2008)
            {
                confs.Add(new ProjectConfiguration("Windows API Code Pack", true, "GRAPHICS_WAPICODEPACK", slnRelDir + "..\\Windows API Code Pack 1.1\\binaries\\DirectX"));
                confs.Add(new ProjectConfiguration("Windows API Code Pack", false, "GRAPHICS_WAPICODEPACK", slnRelDir + "..\\Windows API Code Pack 1.1\\binaries\\DirectX"));
            }
            /*
            confs.Add(new ProjectConfiguration("XNA 3.1", true, "GRAPHICS_XNA31", "$(ProgramFiles)\\Microsoft XNA\\XNA Game Studio\\v3.1\\References\\Windows\\x86\\;$(ProgramFiles(x86))\\Microsoft XNA\\XNA Game Studio\\v3.1\\References\\Windows\\x86\\"));
            confs.Add(new ProjectConfiguration("XNA 3.1", false, "GRAPHICS_XNA31", "$(ProgramFiles)\\Microsoft XNA\\XNA Game Studio\\v3.1\\References\\Windows\\x86\\;$(ProgramFiles(x86))\\Microsoft XNA\\XNA Game Studio\\v3.1\\References\\Windows\\x86\\"));
            if (targetVS != TargetVS.VS2008)
            {
                confs.Add(new ProjectConfiguration("XNA 4.0", true, "GRAPHICS_XNA40", "$(ProgramFiles)\\Microsoft XNA\\XNA Game Studio\\v4.0\\References\\Windows\\x86\\;$(ProgramFiles(x86))\\Microsoft XNA\\XNA Game Studio\\v4.0\\References\\Windows\\x86\\"));
                confs.Add(new ProjectConfiguration("XNA 4.0", false, "GRAPHICS_XNA40", "$(ProgramFiles)\\Microsoft XNA\\XNA Game Studio\\v4.0\\References\\Windows\\x86\\;$(ProgramFiles(x86))\\Microsoft XNA\\XNA Game Studio\\v4.0\\References\\Windows\\x86\\"));
            }
            */

            var project = parser.Project;
            var filterWriter = new FilterWriter(project.NamespaceName);
            var sourceFilter = new Filter("Source Files", "4FC737F1-C7A5-4376-A066-2A32D752A2FF", "cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx");
            var headerFilter = new Filter("Header Files", "93995380-89BD-4b04-88EB-625FBE52EBFB", "h;hh;hpp;hxx;hm;inl;inc;xsd");
            var resourceFilter = new Filter("Resource Files", "67DA6AB6-F800-4c08-8B7A-83BB121AAD01", "rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms");
            filterWriter.RootFilter.Add(sourceFilter);
            filterWriter.RootFilter.Add(headerFilter);
            filterWriter.RootFilter.Add(resourceFilter);

            sourceFilter.AddFile("", rootFolder + "Stdafx");
            sourceFilter.AddFile("", rootFolder + "AssemblyInfo");
            sourceFilter.AddFile("", rootFolder + "Collections");
            sourceFilter.AddFile("", rootFolder + "Math");
            sourceFilter.AddFile("", rootFolder + "StringConv");
            sourceFilter.AddFile("", rootFolder + "DataStream");
            sourceFilter.AddFile("", rootFolder + "Matrix");
            sourceFilter.AddFile("", rootFolder + "Quaternion");
            sourceFilter.AddFile("", rootFolder + "Utilities");
            sourceFilter.AddFile("", rootFolder + "Vector3");
            sourceFilter.AddFile("", rootFolder + "Vector4");

            headerFilter.AddFile("", rootFolder + "Stdafx");
            headerFilter.AddFile("", rootFolder + "Collections");
            headerFilter.AddFile("", rootFolder + "Enums");
            headerFilter.AddFile("", rootFolder + "ITrackingDisposable");
            headerFilter.AddFile("", rootFolder + "Math");
            headerFilter.AddFile("", rootFolder + "StringConv");
            headerFilter.AddFile("", rootFolder + "Version");
            headerFilter.AddFile("", rootFolder + "DataStream");
            headerFilter.AddFile("", rootFolder + "Matrix");
            headerFilter.AddFile("", rootFolder + "Quaternion");
            headerFilter.AddFile("", rootFolder + "Utilities");
            headerFilter.AddFile("", rootFolder + "Vector3");
            headerFilter.AddFile("", rootFolder + "Vector4");

            foreach (ManagedHeader header in parser.Headers.Values)
            {
                if (header.Classes.Count == 0) continue;

                sourceFilter.AddFile(header.Native.Filename, rootFolder + header.Name);
                headerFilter.AddFile(header.Native.Filename, rootFolder + header.Name);
            }

            sourceFilter.AddFile("BulletCollision/CollisionDispatch/", rootFolder + "InternalEdgeUtility");
            sourceFilter.AddFile("BulletCollision/CollisionShapes/", rootFolder + "BulletMaterial");
            sourceFilter.AddFile("BulletCollision/NarrowPhaseCollision/", rootFolder + "SimplexSolverInterface");
            sourceFilter.AddFile("LinearMath/", rootFolder + "DebugDraw");
            sourceFilter.AddFile("SoftBody/", rootFolder + "SoftBodySolver");
            headerFilter.AddFile("BulletCollision/CollisionDispatch/", rootFolder + "InternalEdgeUtility");
            headerFilter.AddFile("BulletCollision/CollisionShapes/", rootFolder + "BulletMaterial");
            headerFilter.AddFile("BulletCollision/NarrowPhaseCollision/", rootFolder + "SimplexSolverInterface");
            headerFilter.AddFile("LinearMath/", rootFolder + "DebugDraw");
            headerFilter.AddFile("BulletDynamics/Character/", rootFolder + "ICharacterController");
            headerFilter.AddFile("LinearMath/", rootFolder + "IDebugDraw");
            headerFilter.AddFile("SoftBody/", rootFolder + "SoftBodySolver");

            resourceFilter.AddFile("", rootFolder + "Resources.rc");

            filterWriter.RootFilter.Sort();

            string bulletRoot = "..\\bullet3";

            /*
            foreach (string sourceRootFolder in project.SourceRootFolders)
            {
                string sourceRootFolderRel = WrapperProject.MakeRelativePath(project.ProjectFilePath, sourceRootFolder);
                sourceRootFolderRel.ToString();
            }
            */

            var slnWriter = new SlnWriter(filterWriter, project.NamespaceName)
            {
                IncludeDirectories = string.Format("{0}\\src;{0}\\Extras\\HACD;{0}\\Extras\\Serialize\\BulletWorldImporter;{0}\\Extras\\Serialize\\BulletXmlWorldImporter;", slnRelDir + bulletRoot),
                FilterWriter = filterWriter
            };
            if (targetVS == TargetVS.VS2008)
            {
                slnWriter.LibraryDirectoriesRelease = slnRelDir + bulletRoot + "\\msvc\\2008\\lib\\MinSizeRel";
                slnWriter.LibraryDirectoriesDebug = slnRelDir + bulletRoot + "\\msvc\\2008\\lib\\Debug";
            }
            else
            {
                slnWriter.LibraryDirectoriesRelease = slnRelDir + bulletRoot + "\\msvc\\" + targetVersionString + "\\lib\\MinSizeRel;";
                slnWriter.LibraryDirectoriesDebug = slnRelDir + bulletRoot + "\\msvc\\" + targetVersionString + "\\lib\\Debug;";
            }
            slnWriter.Output(targetVS, confs, "sln" + targetVersionString);
        }
Ejemplo n.º 3
0
        public void Output(TargetVS targetVS, IList <ProjectConfiguration> confs, string outDirectory)
        {
            Directory.CreateDirectory(outDirectory);
            var solutionFile = new FileStream(outDirectory + "\\" + namespaceName + ".sln", FileMode.Create, FileAccess.Write);

            solutionWriter = new StreamWriter(solutionFile, Encoding.UTF8);

            this.targetVS = targetVS;
            confs         = confs.OrderBy(c => !c.IsDebug).ThenBy(c => c.Name).ToList();

            var    projectGuid       = new Guid("5A0DEF7E-B7E3-45E9-A511-0F03CECFF8C0");
            string projectGuidString = projectGuid.ToString().ToUpper();

            WriteLineSln();
            WriteSln("Microsoft Visual Studio Solution File, Format Version ");
            switch (targetVS)
            {
            case TargetVS.VS2008:
                WriteLineSln("10.00");
                WriteLineSln("# Visual C++ Express 2008");
                break;

            case TargetVS.VS2010:
                WriteLineSln("11.00");
                WriteLineSln("# Visual Studio 2010");
                break;

            case TargetVS.VS2012:
                WriteLineSln("12.00");
                WriteLineSln("# Visual Studio 11");
                break;

            case TargetVS.VS2013:
                WriteLineSln("12.00");
                WriteLineSln("# Visual Studio 2013");
                WriteLineSln("VisualStudioVersion = 12.0.21005.1");
                //WriteLineSln("MinimumVisualStudioVersion = 10.0.40219.1");
                break;

            case TargetVS.VS2015:
                WriteLineSln("12.00");
                WriteLineSln("# Visual Studio 14");
                WriteLineSln("VisualStudioVersion = 14.0.23107.0");
                //WriteLineSln("MinimumVisualStudioVersion = 10.0.40219.1");
                break;

            default:
                throw new NotImplementedException();
            }

            Guid   vcppProjectType       = new Guid("8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942");
            string vcppProjectTypeString = vcppProjectType.ToString().ToUpper();

            WriteSln("Project(\"{");
            WriteSln(vcppProjectTypeString);
            WriteSln("}\") = \"");
            WriteSln(namespaceName);
            WriteSln("\", \"");
            WriteSln(namespaceName);
            if (targetVS == TargetVS.VS2008)
            {
                WriteSln(".vcproj\", \"{");
            }
            else
            {
                WriteSln(".vcxproj\", \"{");
            }
            WriteSln(projectGuidString);
            WriteLineSln("}\"");
            WriteLineSln("EndProject");

            WriteLineSln("Global");

            WriteLineSln("\tGlobalSection(SolutionConfigurationPlatforms) = preSolution");
            foreach (var conf in confs)
            {
                WriteSln("\t\t");
                WriteProjectConfigurationNameSln(conf);
                WriteSln("|Win32 = ");
                WriteProjectConfigurationNameSln(conf);
                WriteLineSln("|Win32");
                if (X64)
                {
                    WriteSln("\t\t");
                    WriteProjectConfigurationNameSln(conf);
                    WriteSln("|x64 = ");
                    WriteProjectConfigurationNameSln(conf);
                    WriteLineSln("|x64");
                }
            }
            WriteLineSln("\tEndGlobalSection");

            WriteLineSln("\tGlobalSection(ProjectConfigurationPlatforms) = postSolution");
            foreach (var conf in confs)
            {
                WriteSln("\t\t{");
                WriteSln(projectGuidString);
                WriteSln("}.");
                WriteProjectConfigurationNameSln(conf);
                WriteSln("|Win32.ActiveCfg = ");
                WriteProjectConfigurationNameSln(conf);
                WriteLineSln("|Win32");

                WriteSln("\t\t{");
                WriteSln(projectGuidString);
                WriteSln("}.");
                WriteProjectConfigurationNameSln(conf);
                WriteSln("|Win32.Build.0 = ");
                WriteProjectConfigurationNameSln(conf);
                WriteLineSln("|Win32");

                if (X64)
                {
                    WriteSln("\t\t{");
                    WriteSln(projectGuidString);
                    WriteSln("}.");
                    WriteProjectConfigurationNameSln(conf);
                    WriteSln("|x64.ActiveCfg = ");
                    WriteProjectConfigurationNameSln(conf);
                    WriteLineSln("|x64");

                    WriteSln("\t\t{");
                    WriteSln(projectGuidString);
                    WriteSln("}.");
                    WriteProjectConfigurationNameSln(conf);
                    WriteSln("|x64.Build.0 = ");
                    WriteProjectConfigurationNameSln(conf);
                    WriteLineSln("|x64");
                }
            }
            WriteLineSln("\tEndGlobalSection");

            WriteLineSln("\tGlobalSection(SolutionProperties) = preSolution");
            WriteLineSln("\t\tHideSolutionNode = FALSE");
            WriteLineSln("\tEndGlobalSection");
            WriteLineSln("EndGlobal");

            solutionWriter.Dispose();
            solutionFile.Dispose();


            string projectFilename = namespaceName + (targetVS == TargetVS.VS2008 ? ".vcproj" : ".vcxproj");
            var    projectFile     = new FileStream(outDirectory + "\\" + projectFilename, FileMode.Create, FileAccess.Write);

            projectWriter = new StreamWriter(projectFile, Encoding.UTF8);

            if (targetVS == TargetVS.VS2008)
            {
                WriteLine("<?xml version=\"1.0\" encoding=\"Windows-1252\"?>");
                WriteLine("<VisualStudioProject");
                WriteLine("\tProjectType=\"Visual C++\"");
                WriteLine("\tVersion=\"9.00\"");
                Write("\tName=\"");
                Write(namespaceName);
                WriteLine("\"");
                Write("\tProjectGUID=\"{");
                Write(projectGuidString);
                WriteLine("}\"");
                Write("\tRootNamespace=\"");
                Write(namespaceName);
                WriteLine("\"");
                WriteLine("\tKeyword=\"ManagedCProj\"");
                WriteLine("	TargetFrameworkVersion=\"131072\"");
                WriteLine("\t>");
                WriteLine("\t<Platforms>");
                WriteLine("\t\t<Platform");
                WriteLine("\t\t\tName=\"Win32\"");
                WriteLine("\t\t/>");
                WriteLine("\t</Platforms>");
                WriteLine("\t<ToolFiles>");
                WriteLine("\t</ToolFiles>");
            }
            else
            {
                WriteLine("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
                Write("<Project DefaultTargets=\"Build\" ToolsVersion=\"");
                switch (targetVS)
                {
                case TargetVS.VS2010:
                case TargetVS.VS2012:
                    Write("4.0");
                    break;

                case TargetVS.VS2013:
                    Write("12.0");
                    break;

                case TargetVS.VS2015:
                    Write("14.0");
                    break;

                default:
                    throw new NotImplementedException();
                }
                WriteLine("\" xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">");
            }

            if (targetVS == TargetVS.VS2008)
            {
                WriteLine("\t<Configurations>");
            }
            else
            {
                WriteLine("  <ItemGroup Label=\"ProjectConfigurations\">");
            }
            foreach (var conf in confs)
            {
                OutputProjectConfiguration(conf, false);
                if (X64)
                {
                    OutputProjectConfiguration(conf, true);
                }
            }
            if (targetVS == TargetVS.VS2008)
            {
                WriteLine("\t</Configurations>");
            }
            else
            {
                WriteLine("  </ItemGroup>");

                if (targetVS != TargetVS.VS2010)
                {
                    WriteLine("  <PropertyGroup Label=\"Globals\">");
                    WriteLine("    <VCTargetsPath Condition=\"\'$(VCTargetsPath11)\' != \'\' and \'$(VSVersion)\' == \'\' and \'$(VisualStudioVersion)\' == \'\'\">$(VCTargetsPath11)</VCTargetsPath>");
                    WriteLine("  </PropertyGroup>");
                }
                WriteLine("  <PropertyGroup Label=\"Globals\">");
                Write("    <ProjectGuid>{");
                Write(projectGuidString);
                WriteLine("}</ProjectGuid>");
                if (targetVS != TargetVS.VS2010)
                {
                    //WriteLine("    <TargetFrameworkVersion Condition=\"\'$(Configuration)\'==\'Debug XNA 3.1\' OR \'$(Configuration)\'==\'Release XNA 3.1\'\">v2.0</TargetFrameworkVersion>");
                    //WriteLine("    <TargetFrameworkVersion Condition=\"\'$(Configuration)\'==\'Debug XNA 4.0\' OR \'$(Configuration)\'==\'Release XNA 4.0\'\">v4.0</TargetFrameworkVersion>");
                    if (targetVS == TargetVS.VS2012)
                    {
                        WriteLine("    <TargetFrameworkVersion Condition=\"\'$(TargetFrameworkVersion)\'==\'\'\">v4.5</TargetFrameworkVersion>");
                    }
                    else if (targetVS == TargetVS.VS2013)
                    {
                        WriteLine("    <TargetFrameworkVersion Condition=\"\'$(TargetFrameworkVersion)\'==\'\'\">v4.5.1</TargetFrameworkVersion>");
                    }
                    else // if (targetVS == TargetVS.VS2015)
                    {
                        WriteLine("    <TargetFrameworkVersion Condition=\"\'$(Configuration)\'==\'Debug Numerics\' OR \'$(Configuration)\'==\'Release Numerics\'\">v4.6</TargetFrameworkVersion>");
                        WriteLine("    <TargetFrameworkVersion Condition=\"\'$(TargetFrameworkVersion)\'==\'\'\">v4.5.2</TargetFrameworkVersion>");
                    }
                }
                Write("    <RootNamespace>");
                Write(namespaceName);
                WriteLine("</RootNamespace>");
                WriteLine("    <Keyword>ManagedCProj</Keyword>");
                WriteLine("  </PropertyGroup>");


                WriteLine("  <Import Project=\"$(VCTargetsPath)\\Microsoft.Cpp.Default.props\" />");


                foreach (var conf in confs)
                {
                    OutputPropertyGroupConfiguration(conf, false);
                    if (X64)
                    {
                        OutputPropertyGroupConfiguration(conf, true);
                    }
                }

                WriteLine("  <Import Project=\"$(VCTargetsPath)\\Microsoft.Cpp.props\" />");
                WriteLine("  <ImportGroup Label=\"ExtensionSettings\">");
                WriteLine("  </ImportGroup>");


                foreach (var conf in confs)
                {
                    OutputImportGroupPropertySheets(conf);
                }


                WriteLine("  <PropertyGroup Label=\"UserMacros\" />");
                WriteLine("  <PropertyGroup>");
                WriteLine("    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>");
                foreach (var conf in confs)
                {
                    OutputPropertyGroupConfiguration2(conf, false);
                    if (X64)
                    {
                        OutputPropertyGroupConfiguration2(conf, true);
                    }
                }
                WriteLine("  </PropertyGroup>");


                foreach (var conf in confs)
                {
                    OutputItemDefinitionGroup(conf, false);
                    if (X64)
                    {
                        OutputItemDefinitionGroup(conf, true);
                    }
                }
            }

            if (targetVS == TargetVS.VS2008)
            {
                WriteLine("\t<References>");
            }
            else
            {
                WriteLine("  <ItemGroup>");
            }
            OutputItemGroupReference("System", "System, Version=2.0.0.0, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL");
            OutputItemGroupReference("System.Drawing", "System.Drawing, Version=2.0.0.0, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL");
            if (targetVS == TargetVS.VS2008)
            {
                WriteLine("\t</References>");
            }
            else
            {
                WriteLine("  </ItemGroup>");
            }

            foreach (var conf in confs)
            {
                if (conf.ConditionalRef != null && conf.ConditionalRefAssembly != null)
                {
                    if (targetVS != TargetVS.VS2008)
                    {
                        WriteLine(string.Format("  <ItemGroup Condition=\"'$(Configuration)'=='{0} {1}'\">", conf.IsDebug ? "Debug" : "Release", conf.Name));
                        WriteLine(string.Format("    <Reference Include=\"{0}\">", conf.ConditionalRefAssembly));
                        WriteLine("    </Reference>");
                        WriteLine("  </ItemGroup>");
                    }
                }
            }


            if (targetVS == TargetVS.VS2008)
            {
                filterWriter.Output2008(projectWriter, confs, outDirectory);

                WriteLine("\t<Globals>");
                WriteLine("\t</Globals>");
                WriteLine("</VisualStudioProject>");
            }
            else
            {
                WriteLine("  <ItemGroup>");
                var sourceFiles = filterWriter.RootFilter.GetChild("Source Files").GetFileList();
                foreach (var sourceFile in sourceFiles)
                {
                    Write("    <ClCompile Include=\"");
                    Write(sourceFile);
                    if (sourceFile.EndsWith("Stdafx", StringComparison.InvariantCultureIgnoreCase))
                    {
                        WriteLine(".cpp\">");
                        foreach (var conf in confs)
                        {
                            Write("      <PrecompiledHeader Condition=\"'$(Configuration)|$(Platform)'=='");
                            WriteProjectConfigurationName(conf);
                            WriteLine("|Win32'\">Create</PrecompiledHeader>");
                            if (X64)
                            {
                                Write("      <PrecompiledHeader Condition=\"'$(Configuration)|$(Platform)'=='");
                                WriteProjectConfigurationName(conf);
                                WriteLine("|x64'\">Create</PrecompiledHeader>");
                            }
                        }
                        WriteLine("    </ClCompile>");
                    }
                    else
                    {
                        WriteLine(".cpp\" />");
                    }
                }
                WriteLine("  </ItemGroup>");

                WriteLine("  <ItemGroup>");
                var resourceFiles = filterWriter.RootFilter.GetChild("Resource Files").GetFileList();
                foreach (var resourceFile in resourceFiles)
                {
                    Write("    <ResourceCompile Include=\"");
                    Write(resourceFile);
                    WriteLine("\" />");
                }
                WriteLine("  </ItemGroup>");

                WriteLine("  <ItemGroup>");
                var headerFiles = filterWriter.RootFilter.GetChild("Header Files").GetFileList();
                foreach (var headerFile in headerFiles)
                {
                    Write("    <ClInclude Include=\"");
                    Write(headerFile);
                    WriteLine(".h\" />");
                }
                WriteLine("  </ItemGroup>");

                WriteLine("  <Import Project=\"$(VCTargetsPath)\\Microsoft.Cpp.targets\" />");
                WriteLine("  <ImportGroup Label=\"ExtensionTargets\">");
                WriteLine("  </ImportGroup>");

                Write("</Project>");
            }

            projectWriter.Dispose();
            projectFile.Dispose();


            if (FilterWriter != null && targetVS != TargetVS.VS2008)
            {
                FilterWriter.Output(targetVS, outDirectory);
            }
        }
Ejemplo n.º 4
0
        static void OutputSolution(TargetVS targetVS, DotNetParser parser)
        {
            string targetVersionString;

            switch (targetVS)
            {
            case TargetVS.VS2008:
                targetVersionString = "2008";
                break;

            case TargetVS.VS2010:
                targetVersionString = "2010";
                break;

            case TargetVS.VS2012:
                targetVersionString = "2012";
                break;

            case TargetVS.VS2013:
                targetVersionString = "2013";
                break;

            case TargetVS.VS2015:
                targetVersionString = "2015";
                break;

            default:
                throw new NotImplementedException();
            }

            string slnRelDir  = (targetVS == TargetVS.VS2010) ? "" : "..\\";
            string rootFolder = slnRelDir + "src\\";

            var confs = new List <ProjectConfiguration>
            {
                new ProjectConfiguration("Axiom", true, "GRAPHICS_AXIOM",
                                         slnRelDir + "..\\Axiom-SDK-0.8.3376.12322\\bin\\Net35"),
                new ProjectConfiguration("Axiom", false, "GRAPHICS_AXIOM",
                                         slnRelDir + "..\\Axiom-SDK-0.8.3376.12322\\bin\\Net35"),
                new ProjectConfiguration("Generic", true, "GRAPHICS_GENERIC"),
                new ProjectConfiguration("Generic", false, "GRAPHICS_GENERIC"),
                new ProjectConfiguration("Mogre", true, "GRAPHICS_MOGRE", "C:\\MogreSDK\\bin\\Debug"),
                new ProjectConfiguration("Mogre", false, "GRAPHICS_MOGRE", "C:\\MogreSDK\\bin\\Release")
            };

            if (targetVS != TargetVS.VS2008)
            {
                confs.Add(new ProjectConfiguration("MonoGame", true, "GRAPHICS_MONOGAME", "$(ProgramFiles)\\MonoGame\\v3.0\\Assemblies\\WindowsGL\\;$(ProgramFiles(x86))\\MonoGame\\v3.0\\Assemblies\\WindowsGL\\"));
                confs.Add(new ProjectConfiguration("MonoGame", false, "GRAPHICS_MONOGAME", "$(ProgramFiles)\\MonoGame\\v3.0\\Assemblies\\WindowsGL\\;$(ProgramFiles(x86))\\MonoGame\\v3.0\\Assemblies\\WindowsGL\\"));
            }
            if (targetVS != TargetVS.VS2008 && targetVS != TargetVS.VS2010)
            {
                confs.Add(new ProjectConfiguration("Numerics", true, "GRAPHICS_NUMERICS"));
                confs.Add(new ProjectConfiguration("Numerics", false, "GRAPHICS_NUMERICS"));
            }
            if (targetVS == TargetVS.VS2008)
            {
                confs.Add(new ProjectConfiguration("OpenTK", true, "GRAPHICS_OPENTK", "$(USERPROFILE)\\My Documents\\OpenTK\\1.1\\Binaries\\OpenTK\\Release"));
                confs.Add(new ProjectConfiguration("OpenTK", false, "GRAPHICS_OPENTK", "$(USERPROFILE)\\My Documents\\OpenTK\\1.1\\Binaries\\OpenTK\\Release"));
                confs.Add(new ProjectConfiguration("SharpDX", true, "GRAPHICS_SHARPDX", slnRelDir + "..\\SharpDX\\Bin\\DirectX11-net20"));
                confs.Add(new ProjectConfiguration("SharpDX", false, "GRAPHICS_SHARPDX", slnRelDir + "..\\SharpDX\\Bin\\DirectX11-net20"));
                confs.Add(new ProjectConfiguration("SharpDX Signed", true, "GRAPHICS_SHARPDX", slnRelDir + "..\\SharpDX\\Bin\\DirectX11-Signed-net20"));
                confs.Add(new ProjectConfiguration("SharpDX Signed", false, "GRAPHICS_SHARPDX", slnRelDir + "..\\SharpDX\\Bin\\DirectX11-Signed-net20"));
                confs.Add(new ProjectConfiguration("SlimDX", true, "GRAPHICS_SLIMDX", "$(PROGRAMFILES)\\SlimDX SDK (January 2012)\\Bin\\net20\\;$(PROGRAMFILES(x86))\\SlimDX SDK (June 2010)\\Bin\\net20\\"));
                confs.Add(new ProjectConfiguration("SlimDX", false, "GRAPHICS_SLIMDX", "$(PROGRAMFILES)\\SlimDX SDK (January 2012)\\Bin\\net20\\;$(PROGRAMFILES(x86))\\SlimDX SDK (June 2010)\\Bin\\net20\\"));
            }
            else
            {
                confs.Add(new ProjectConfiguration("OpenTK", true, "GRAPHICS_OPENTK")
                {
                    ConditionalRef         = "OpenTK",
                    ConditionalRefAssembly = "OpenTK, Version=1.1.0.0, Culture=neutral, PublicKeyToken=bad199fe84eb3df4"
                });
                confs.Add(new ProjectConfiguration("OpenTK", false, "GRAPHICS_OPENTK")
                {
                    ConditionalRef         = "OpenTK",
                    ConditionalRefAssembly = "OpenTK, Version=1.1.0.0, Culture=neutral, PublicKeyToken=bad199fe84eb3df4"
                });
                confs.Add(new ProjectConfiguration("SharpDX", true, "GRAPHICS_SHARPDX", slnRelDir + "..\\SharpDX\\Bin\\DirectX11-net40"));
                confs.Add(new ProjectConfiguration("SharpDX", false, "GRAPHICS_SHARPDX", slnRelDir + "..\\SharpDX\\Bin\\DirectX11-net40"));
                confs.Add(new ProjectConfiguration("SharpDX Signed", true, "GRAPHICS_SHARPDX", slnRelDir + "..\\SharpDX\\Bin\\DirectX11-Signed-net40"));
                confs.Add(new ProjectConfiguration("SharpDX Signed", false, "GRAPHICS_SHARPDX", slnRelDir + "..\\SharpDX\\Bin\\DirectX11-Signed-net40"));
                confs.Add(new ProjectConfiguration("SlimDX", true, "GRAPHICS_SLIMDX", "$(PROGRAMFILES)\\SlimDX SDK (January 2012)\\Bin\\net40\\;$(PROGRAMFILES(x86))\\SlimDX SDK (June 2010)\\Bin\\net40\\"));
                confs.Add(new ProjectConfiguration("SlimDX", false, "GRAPHICS_SLIMDX", "$(PROGRAMFILES)\\SlimDX SDK (January 2012)\\Bin\\net40\\;$(PROGRAMFILES(x86))\\SlimDX SDK (June 2010)\\Bin\\net40\\"));
            }
            //confs.Add(new ProjectConfiguration("SlimMath", true, "GRAPHICS_SLIMMATH", slnRelDir + "..\\SlimMath\\SlimMath\\bin\\Release"));
            //confs.Add(new ProjectConfiguration("SlimMath", false, "GRAPHICS_SLIMMATH", slnRelDir + "..\\SlimMath\\SlimMath\\bin\\Debug"));
            if (targetVS != TargetVS.VS2008)
            {
                confs.Add(new ProjectConfiguration("Windows API Code Pack", true, "GRAPHICS_WAPICODEPACK", slnRelDir + "..\\Windows API Code Pack 1.1\\binaries\\DirectX"));
                confs.Add(new ProjectConfiguration("Windows API Code Pack", false, "GRAPHICS_WAPICODEPACK", slnRelDir + "..\\Windows API Code Pack 1.1\\binaries\\DirectX"));
            }

            /*
             * confs.Add(new ProjectConfiguration("XNA 3.1", true, "GRAPHICS_XNA31", "$(ProgramFiles)\\Microsoft XNA\\XNA Game Studio\\v3.1\\References\\Windows\\x86\\;$(ProgramFiles(x86))\\Microsoft XNA\\XNA Game Studio\\v3.1\\References\\Windows\\x86\\"));
             * confs.Add(new ProjectConfiguration("XNA 3.1", false, "GRAPHICS_XNA31", "$(ProgramFiles)\\Microsoft XNA\\XNA Game Studio\\v3.1\\References\\Windows\\x86\\;$(ProgramFiles(x86))\\Microsoft XNA\\XNA Game Studio\\v3.1\\References\\Windows\\x86\\"));
             * if (targetVS != TargetVS.VS2008)
             * {
             *  confs.Add(new ProjectConfiguration("XNA 4.0", true, "GRAPHICS_XNA40", "$(ProgramFiles)\\Microsoft XNA\\XNA Game Studio\\v4.0\\References\\Windows\\x86\\;$(ProgramFiles(x86))\\Microsoft XNA\\XNA Game Studio\\v4.0\\References\\Windows\\x86\\"));
             *  confs.Add(new ProjectConfiguration("XNA 4.0", false, "GRAPHICS_XNA40", "$(ProgramFiles)\\Microsoft XNA\\XNA Game Studio\\v4.0\\References\\Windows\\x86\\;$(ProgramFiles(x86))\\Microsoft XNA\\XNA Game Studio\\v4.0\\References\\Windows\\x86\\"));
             * }
             */

            var project        = parser.Project;
            var filterWriter   = new FilterWriter(project.NamespaceName);
            var sourceFilter   = new Filter("Source Files", "4FC737F1-C7A5-4376-A066-2A32D752A2FF", "cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx");
            var headerFilter   = new Filter("Header Files", "93995380-89BD-4b04-88EB-625FBE52EBFB", "h;hh;hpp;hxx;hm;inl;inc;xsd");
            var resourceFilter = new Filter("Resource Files", "67DA6AB6-F800-4c08-8B7A-83BB121AAD01", "rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms");

            filterWriter.RootFilter.Add(sourceFilter);
            filterWriter.RootFilter.Add(headerFilter);
            filterWriter.RootFilter.Add(resourceFilter);

            sourceFilter.AddFile("", rootFolder + "Stdafx");
            sourceFilter.AddFile("", rootFolder + "AssemblyInfo");
            sourceFilter.AddFile("", rootFolder + "Collections");
            sourceFilter.AddFile("", rootFolder + "Math");
            sourceFilter.AddFile("", rootFolder + "StringConv");
            sourceFilter.AddFile("", rootFolder + "DataStream");
            sourceFilter.AddFile("", rootFolder + "Matrix");
            sourceFilter.AddFile("", rootFolder + "Quaternion");
            sourceFilter.AddFile("", rootFolder + "Utilities");
            sourceFilter.AddFile("", rootFolder + "Vector3");
            sourceFilter.AddFile("", rootFolder + "Vector4");

            headerFilter.AddFile("", rootFolder + "Stdafx");
            headerFilter.AddFile("", rootFolder + "Collections");
            headerFilter.AddFile("", rootFolder + "Enums");
            headerFilter.AddFile("", rootFolder + "ITrackingDisposable");
            headerFilter.AddFile("", rootFolder + "Math");
            headerFilter.AddFile("", rootFolder + "StringConv");
            headerFilter.AddFile("", rootFolder + "Version");
            headerFilter.AddFile("", rootFolder + "DataStream");
            headerFilter.AddFile("", rootFolder + "Matrix");
            headerFilter.AddFile("", rootFolder + "Quaternion");
            headerFilter.AddFile("", rootFolder + "Utilities");
            headerFilter.AddFile("", rootFolder + "Vector3");
            headerFilter.AddFile("", rootFolder + "Vector4");

            foreach (ManagedHeader header in parser.Headers.Values)
            {
                if (header.Classes.Count == 0)
                {
                    continue;
                }

                sourceFilter.AddFile(header.Native.Filename, rootFolder + header.Name);
                headerFilter.AddFile(header.Native.Filename, rootFolder + header.Name);
            }

            sourceFilter.AddFile("BulletCollision/CollisionDispatch/", rootFolder + "InternalEdgeUtility");
            sourceFilter.AddFile("BulletCollision/CollisionShapes/", rootFolder + "BulletMaterial");
            sourceFilter.AddFile("BulletCollision/NarrowPhaseCollision/", rootFolder + "SimplexSolverInterface");
            sourceFilter.AddFile("LinearMath/", rootFolder + "DebugDraw");
            sourceFilter.AddFile("SoftBody/", rootFolder + "SoftBodySolver");
            headerFilter.AddFile("BulletCollision/CollisionDispatch/", rootFolder + "InternalEdgeUtility");
            headerFilter.AddFile("BulletCollision/CollisionShapes/", rootFolder + "BulletMaterial");
            headerFilter.AddFile("BulletCollision/NarrowPhaseCollision/", rootFolder + "SimplexSolverInterface");
            headerFilter.AddFile("LinearMath/", rootFolder + "DebugDraw");
            headerFilter.AddFile("BulletDynamics/Character/", rootFolder + "ICharacterController");
            headerFilter.AddFile("LinearMath/", rootFolder + "IDebugDraw");
            headerFilter.AddFile("SoftBody/", rootFolder + "SoftBodySolver");

            resourceFilter.AddFile("", rootFolder + "Resources.rc");

            filterWriter.RootFilter.Sort();

            string bulletRoot = "..\\bullet3";

            /*
             * foreach (string sourceRootFolder in project.SourceRootFolders)
             * {
             *  string sourceRootFolderRel = WrapperProject.MakeRelativePath(project.ProjectFilePath, sourceRootFolder);
             *  sourceRootFolderRel.ToString();
             * }
             */

            var slnWriter = new SlnWriter(filterWriter, project.NamespaceName)
            {
                IncludeDirectories = string.Format("{0}\\src;{0}\\Extras\\HACD;{0}\\Extras\\Serialize\\BulletWorldImporter;{0}\\Extras\\Serialize\\BulletXmlWorldImporter;", slnRelDir + bulletRoot),
                FilterWriter       = filterWriter
            };

            if (targetVS == TargetVS.VS2008)
            {
                slnWriter.LibraryDirectoriesRelease = slnRelDir + bulletRoot + "\\msvc\\2008\\lib\\MinSizeRel";
                slnWriter.LibraryDirectoriesDebug   = slnRelDir + bulletRoot + "\\msvc\\2008\\lib\\Debug";
            }
            else
            {
                slnWriter.LibraryDirectoriesRelease = slnRelDir + bulletRoot + "\\msvc\\" + targetVersionString + "\\lib\\MinSizeRel;";
                slnWriter.LibraryDirectoriesDebug   = slnRelDir + bulletRoot + "\\msvc\\" + targetVersionString + "\\lib\\Debug;";
            }
            slnWriter.Output(targetVS, confs, "sln" + targetVersionString);
        }
Ejemplo n.º 5
0
        public void Output(TargetVS targetVS, IList<ProjectConfiguration> confs, string outDirectory)
        {
            Directory.CreateDirectory(outDirectory);
            var solutionFile = new FileStream(outDirectory + "\\" + namespaceName + ".sln", FileMode.Create, FileAccess.Write);
            solutionWriter = new StreamWriter(solutionFile, Encoding.UTF8);

            this.targetVS = targetVS;
            confs = confs.OrderBy(c => !c.IsDebug).ThenBy(c => c.Name).ToList();

            var projectGuid = new Guid("5A0DEF7E-B7E3-45E9-A511-0F03CECFF8C0");
            string projectGuidString = projectGuid.ToString().ToUpper();

            WriteLineSln();
            WriteSln("Microsoft Visual Studio Solution File, Format Version ");
            switch (targetVS)
            {
                case TargetVS.VS2008:
                    WriteLineSln("10.00");
                    WriteLineSln("# Visual C++ Express 2008");
                    break;
                case TargetVS.VS2010:
                    WriteLineSln("11.00");
                    WriteLineSln("# Visual Studio 2010");
                    break;
                case TargetVS.VS2012:
                    WriteLineSln("12.00");
                    WriteLineSln("# Visual Studio 11");
                    break;
                case TargetVS.VS2013:
                    WriteLineSln("12.00");
                    WriteLineSln("# Visual Studio 2013");
                    WriteLineSln("VisualStudioVersion = 12.0.21005.1");
                    //WriteLineSln("MinimumVisualStudioVersion = 10.0.40219.1");
                    break;
                default:
                    throw new NotImplementedException();
            }

            Guid vcppProjectType = new Guid("8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942");
            string vcppProjectTypeString = vcppProjectType.ToString().ToUpper();
            WriteSln("Project(\"{");
            WriteSln(vcppProjectTypeString);
            WriteSln("}\") = \"");
            WriteSln(namespaceName);
            WriteSln("\", \"");
            WriteSln(namespaceName);
            if (targetVS == TargetVS.VS2008)
            {
                WriteSln(".vcproj\", \"{");
            }
            else
            {
                WriteSln(".vcxproj\", \"{");
            }
            WriteSln(projectGuidString);
            WriteLineSln("}\"");
            WriteLineSln("EndProject");

            WriteLineSln("Global");

            WriteLineSln("\tGlobalSection(SolutionConfigurationPlatforms) = preSolution");
            foreach (var conf in confs)
            {
                WriteSln("\t\t");
                WriteProjectConfigurationNameSln(conf);
                WriteSln("|Win32 = ");
                WriteProjectConfigurationNameSln(conf);
                WriteLineSln("|Win32");
                if (X64)
                {
                    WriteSln("\t\t");
                    WriteProjectConfigurationNameSln(conf);
                    WriteSln("|x64 = ");
                    WriteProjectConfigurationNameSln(conf);
                    WriteLineSln("|x64");
                }
            }
            WriteLineSln("\tEndGlobalSection");

            WriteLineSln("\tGlobalSection(ProjectConfigurationPlatforms) = postSolution");
            foreach (var conf in confs)
            {
                WriteSln("\t\t{");
                WriteSln(projectGuidString);
                WriteSln("}.");
                WriteProjectConfigurationNameSln(conf);
                WriteSln("|Win32.ActiveCfg = ");
                WriteProjectConfigurationNameSln(conf);
                WriteLineSln("|Win32");

                WriteSln("\t\t{");
                WriteSln(projectGuidString);
                WriteSln("}.");
                WriteProjectConfigurationNameSln(conf);
                WriteSln("|Win32.Build.0 = ");
                WriteProjectConfigurationNameSln(conf);
                WriteLineSln("|Win32");

                if (X64)
                {
                    WriteSln("\t\t{");
                    WriteSln(projectGuidString);
                    WriteSln("}.");
                    WriteProjectConfigurationNameSln(conf);
                    WriteSln("|x64.ActiveCfg = ");
                    WriteProjectConfigurationNameSln(conf);
                    WriteLineSln("|x64");

                    WriteSln("\t\t{");
                    WriteSln(projectGuidString);
                    WriteSln("}.");
                    WriteProjectConfigurationNameSln(conf);
                    WriteSln("|x64.Build.0 = ");
                    WriteProjectConfigurationNameSln(conf);
                    WriteLineSln("|x64");
                }
            }
            WriteLineSln("\tEndGlobalSection");

            WriteLineSln("\tGlobalSection(SolutionProperties) = preSolution");
            WriteLineSln("\t\tHideSolutionNode = FALSE");
            WriteLineSln("\tEndGlobalSection");
            WriteLineSln("EndGlobal");

            solutionWriter.Dispose();
            solutionFile.Dispose();

            string projectFilename = namespaceName + (targetVS == TargetVS.VS2008 ? ".vcproj" : ".vcxproj");
            var projectFile = new FileStream(outDirectory + "\\" + projectFilename, FileMode.Create, FileAccess.Write);
            projectWriter = new StreamWriter(projectFile, Encoding.UTF8);

            if (targetVS == TargetVS.VS2008)
            {
                WriteLine("<?xml version=\"1.0\" encoding=\"Windows-1252\"?>");
                WriteLine("<VisualStudioProject");
                WriteLine("\tProjectType=\"Visual C++\"");
                WriteLine("\tVersion=\"9.00\"");
                Write("\tName=\"");
                Write(namespaceName);
                WriteLine("\"");
                Write("\tProjectGUID=\"{");
                Write(projectGuidString);
                WriteLine("}\"");
                Write("\tRootNamespace=\"");
                Write(namespaceName);
                WriteLine("\"");
                WriteLine("\tKeyword=\"ManagedCProj\"");
                WriteLine("	TargetFrameworkVersion=\"131072\"");
                WriteLine("\t>");
                WriteLine("\t<Platforms>");
                WriteLine("\t\t<Platform");
                WriteLine("\t\t\tName=\"Win32\"");
                WriteLine("\t\t/>");
                WriteLine("\t</Platforms>");
                WriteLine("\t<ToolFiles>");
                WriteLine("\t</ToolFiles>");
            }
            else
            {
                WriteLine("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
                Write("<Project DefaultTargets=\"Build\" ToolsVersion=\"");
                switch (targetVS)
                {
                    case TargetVS.VS2010:
                    case TargetVS.VS2012:
                        Write("4.0");
                        break;
                    case TargetVS.VS2013:
                        Write("12.0");
                        break;
                    default:
                        throw new NotImplementedException();
                }
                WriteLine("\" xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">");
            }

            if (targetVS == TargetVS.VS2008)
            {
                WriteLine("\t<Configurations>");
            }
            else
            {
                WriteLine("  <ItemGroup Label=\"ProjectConfigurations\">");
            }
            foreach (var conf in confs)
            {
                OutputProjectConfiguration(conf, false);
                if (X64)
                {
                    OutputProjectConfiguration(conf, true);
                }
            }
            if (targetVS == TargetVS.VS2008)
            {
                WriteLine("\t</Configurations>");
            }
            else
            {
                WriteLine("  </ItemGroup>");

                if (targetVS != TargetVS.VS2010)
                {
                    WriteLine("  <PropertyGroup Label=\"Globals\">");
                    WriteLine("    <VCTargetsPath Condition=\"\'$(VCTargetsPath11)\' != \'\' and \'$(VSVersion)\' == \'\' and \'$(VisualStudioVersion)\' == \'\'\">$(VCTargetsPath11)</VCTargetsPath>");
                    WriteLine("  </PropertyGroup>");
                }
                WriteLine("  <PropertyGroup Label=\"Globals\">");
                Write("    <ProjectGuid>{");
                Write(projectGuidString);
                WriteLine("}</ProjectGuid>");
                if (targetVS != TargetVS.VS2010)
                {
                    WriteLine("    <TargetFrameworkVersion Condition=\"\'$(Configuration)\'==\'Debug XNA 3.1\' OR \'$(Configuration)\'==\'Release XNA 3.1\'\">v2.0</TargetFrameworkVersion>");
                    WriteLine("    <TargetFrameworkVersion Condition=\"\'$(Configuration)\'==\'Debug XNA 4.0\' OR \'$(Configuration)\'==\'Release XNA 4.0\'\">v4.0</TargetFrameworkVersion>");
                    if (targetVS == TargetVS.VS2012)
                    {
                        WriteLine("    <TargetFrameworkVersion Condition=\"\'$(TargetFrameworkVersion)\'==\'\'\">v4.5</TargetFrameworkVersion>");
                    }
                    else // if (targetVS == TargetVS.VS2013)
                    {
                        WriteLine("    <TargetFrameworkVersion Condition=\"\'$(TargetFrameworkVersion)\'==\'\'\">v4.5.1</TargetFrameworkVersion>");
                    }
                }
                Write("    <RootNamespace>");
                Write(namespaceName);
                WriteLine("</RootNamespace>");
                WriteLine("    <Keyword>ManagedCProj</Keyword>");
                WriteLine("  </PropertyGroup>");

                WriteLine("  <Import Project=\"$(VCTargetsPath)\\Microsoft.Cpp.Default.props\" />");

                foreach (var conf in confs)
                {
                    OutputPropertyGroupConfiguration(conf, false);
                    if (X64)
                    {
                        OutputPropertyGroupConfiguration(conf, true);
                    }
                }

                WriteLine("  <Import Project=\"$(VCTargetsPath)\\Microsoft.Cpp.props\" />");
                WriteLine("  <ImportGroup Label=\"ExtensionSettings\">");
                WriteLine("  </ImportGroup>");

                foreach (var conf in confs)
                {
                    OutputImportGroupPropertySheets(conf);
                }

                WriteLine("  <PropertyGroup Label=\"UserMacros\" />");
                WriteLine("  <PropertyGroup>");
                WriteLine("    <_ProjectFileVersion>10.0.30319.1</_ProjectFileVersion>");
                foreach (var conf in confs)
                {
                    OutputPropertyGroupConfiguration2(conf, false);
                    if (X64)
                    {
                        OutputPropertyGroupConfiguration2(conf, true);
                    }
                }
                WriteLine("  </PropertyGroup>");

                foreach (var conf in confs)
                {
                    OutputItemDefinitionGroup(conf, false);
                    if (X64)
                    {
                        OutputItemDefinitionGroup(conf, true);
                    }
                }
            }

            if (targetVS == TargetVS.VS2008)
            {
                WriteLine("\t<References>");
            }
            else
            {
                WriteLine("  <ItemGroup>");
            }
            OutputItemGroupReference("System", "System, Version=2.0.0.0, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL");
            OutputItemGroupReference("System.Drawing", "System.Drawing, Version=2.0.0.0, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL");
            if (targetVS == TargetVS.VS2008)
            {
                WriteLine("\t</References>");
            }
            else
            {
                WriteLine("  </ItemGroup>");
            }

            foreach (var conf in confs)
            {
                if (conf.ConditionalRef != null && conf.ConditionalRefAssembly != null)
                {
                    if (targetVS != TargetVS.VS2008)
                    {
                        WriteLine(string.Format("  <ItemGroup Condition=\"'$(Configuration)'=='{0} {1}'\">", conf.IsDebug ? "Debug" : "Release", conf.Name));
                        WriteLine(string.Format("    <Reference Include=\"{0}\">", conf.ConditionalRefAssembly));
                        WriteLine("    </Reference>");
                        WriteLine("  </ItemGroup>");
                    }
                }
            }

            if (targetVS == TargetVS.VS2008)
            {
                filterWriter.Output2008(projectWriter, confs, outDirectory);

                WriteLine("\t<Globals>");
                WriteLine("\t</Globals>");
                WriteLine("</VisualStudioProject>");
            }
            else
            {
                WriteLine("  <ItemGroup>");
                var sourceFiles = filterWriter.RootFilter.GetChild("Source Files").GetFileList();
                foreach (var sourceFile in sourceFiles)
                {
                    Write("    <ClCompile Include=\"");
                    Write(sourceFile);
                    if (sourceFile.EndsWith("Stdafx", StringComparison.InvariantCultureIgnoreCase))
                    {
                        WriteLine(".cpp\">");
                        foreach (var conf in confs)
                        {
                            Write("      <PrecompiledHeader Condition=\"'$(Configuration)|$(Platform)'=='");
                            WriteProjectConfigurationName(conf);
                            WriteLine("|Win32'\">Create</PrecompiledHeader>");
                            if (X64)
                            {
                                Write("      <PrecompiledHeader Condition=\"'$(Configuration)|$(Platform)'=='");
                                WriteProjectConfigurationName(conf);
                                WriteLine("|x64'\">Create</PrecompiledHeader>");
                            }
                        }
                        WriteLine("    </ClCompile>");
                    }
                    else
                    {
                        WriteLine(".cpp\" />");
                    }
                }
                WriteLine("  </ItemGroup>");

                WriteLine("  <ItemGroup>");
                var resourceFiles = filterWriter.RootFilter.GetChild("Resource Files").GetFileList();
                foreach (var resourceFile in resourceFiles)
                {
                    Write("    <ResourceCompile Include=\"");
                    Write(resourceFile);
                    WriteLine("\" />");
                }
                WriteLine("  </ItemGroup>");

                WriteLine("  <ItemGroup>");
                var headerFiles = filterWriter.RootFilter.GetChild("Header Files").GetFileList();
                foreach (var headerFile in headerFiles)
                {
                    Write("    <ClInclude Include=\"");
                    Write(headerFile);
                    WriteLine(".h\" />");
                }
                WriteLine("  </ItemGroup>");

                WriteLine("  <Import Project=\"$(VCTargetsPath)\\Microsoft.Cpp.targets\" />");
                WriteLine("  <ImportGroup Label=\"ExtensionTargets\">");
                WriteLine("  </ImportGroup>");

                Write("</Project>");
            }

            projectWriter.Dispose();
            projectFile.Dispose();

            if (FilterWriter != null && targetVS != TargetVS.VS2008)
            {
                FilterWriter.Output(targetVS, outDirectory);
            }
        }