Qt ohne Add-In, VS2012 Build Rules?

[CodingCat]

Ich würde gerne das Qt Visual Studio Add-In loswerden. Wie stelle ich das am geschicktesten an? Ich nehme an, über Build Rules o.ä.? In Visual Studio 2005 gabs für sowas noch einen hübschen Editor, vor MS-Build-"XML"-Files graut es mir. Wie ist da der aktuelle Stand in Visual Studio 2012, wo fange ich am besten an?

[eXile]

Dies ist nicht die Antwort, die du hören willst; ich werde sie trotzdem schreiben: Du kannst die rules-Datei in einer alten Visual-Studio-Version anlegen, und mittels des automatischen Konvertierungs-Wizards die in xml/props/targets-Dateien konvertieren. Das habe ich vor ca. 1,5 Jahren mal gemacht (war CUDA-relatiert). Ich selber wäre an den xml-Dateien beinahe zerbrochen.

[joggel]

Ich würde gerne das Qt Visual Studio Add-In loswerden. Wie stelle ich das am geschicktesten an?

Das kann ich Dir auch leider nicht sagen...
über "Windows > Installierte Programme > deinstallieren" geht nicht?
Hab nur VS2010 hier zu Hause, und da geht ja bekanntermaßen kein Qt-VisualStudio-Add-In...

[CodingCat]

Ich würde gerne das Qt Visual Studio Add-In loswerden. Wie stelle ich das am geschicktesten an?

Das kann ich Dir auch leider nicht sagen...
über "Windows > Installierte Programme > deinstallieren" geht nicht?
Hab nur VS2010 hier zu Hause, und da geht ja bekanntermaßen kein Qt-VisualStudio-Add-In...

Für VS 2010 gibt es längst ein Add-In, habe damit selbst einige Zeit gerbeitet. Das funktioniert möglicherweise auch direkt mit VS 2012. Mir ging es hier nicht um das Deinstallieren, habe das Add-In für VS 2012 schließlich noch gar nicht installiert, sondern darum, wie ich am besten ohne Add-In auskomme. Das Add-In nervt mich, weil ich keine Kontrolle darüber habe, was es tut.

[CodingCat]

Dies ist nicht die Antwort, die du hören willst; ich werde sie trotzdem schreiben: Du kannst die rules-Datei in einer alten Visual-Studio-Version anlegen, und mittels des automatischen Konvertierungs-Wizards die in xml/props/targets-Dateien konvertieren. Das habe ich vor ca. 1,5 Jahren mal gemacht (war CUDA-relatiert). Ich selber wäre an den xml-Dateien beinahe zerbrochen.

Ich hätte mich in der Tat eher über eine Antwort gefreut, die mir sagte, wie blind ich bin, und dass in VS 2012 doch längst wieder ein entsprechender Editor mitgeliefert sei. Aber danke für den Hinweis, wenn nichts hilft, habe ich im Moment immerhin noch VS 2008 installiert.

[joggel]

Ach verdammt. Hab mich verschrieben.

Hab nur VS2010 hier zu Hause, und da geht ja bekanntermaßen kein Qt-VisualStudio-Add-In...

Meinte VS2010-Express...

Naja, wenn Du ohne auskommen willst, dann musst Du eben alles von Hand mit dem Qt-MOC kompilieren und selbst einbinden...

[CodingCat]

Naja, wenn Du ohne auskommen willst, dann musst Du eben alles von Hand mit dem Qt-MOC kompilieren und selbst einbinden...

Genau das will ich automatisieren. Von Hand mache ich das ganz sicher nicht ...

[joggel]

So, mal etwas mit meinem VS2010(!!!) rumgespielt.
Dort kannst du ja die Eigenschaften von Headern und Cpp-Files über eigenschaften genauer spezifizieren.
zB bei Header-Dateien > Eigenschaften > Allgemein > Elementtyp => auf "Benutzerdefiniertes Buildtool" setzen, und dann über "Benutzerdefinierters Buildtool" die Befehlszeile anpassen.
Das kannst Du bestimmt auch für UI-Files machen...

Ist aber nur ein Gedanke... habe das selber noch nicht gemacht :?

[CodingCat]

Nichts anderes tut das VS Add-In, und zwar für jede Datei einzeln. Die Frage ist, wie ich das kollektiv für viele Elemente hinbekomme, damit der ganze Mist nicht mehr hundertfach dupliziert und ohne Add-In unwartbar in meinen Projektdateien rumfliegt. Am besten automatisiert in Abhängigkeit von der Dateieendung.

[joggel]

Nichts anderes tut das VS Add-In, und zwar für jede Datei einzeln.

Eben :)

http://msdn.microsoft.com/en-us/library ... 80%29.aspx
Wobei wir wieder bei eXils Post wären.

Ansonsten weiß ich auch nicht weiter...

[Schrompf]

Wir haben das immer über die Buildkonfig gemacht: Kontextmenü auf dem Headefile, "Alle Builds", "Alle Plattformen", dann "Custom Build Tool" und da einen String reinkopiert, den Du aus VS-Makros zusammenbaust, so dass er abstrakt für alle Files funktioniert. Du kannst auch viele Header auf einmal markieren und für alle zusammen diese Einstellung machen.

Einen bequemeren Weg kenne ich allerdings auch nicht.

[mnemonix]

Könnte das eventuell helfen. Das sind .targets Vorlagen für .ui und .qrc Dateien. Aber das sollte sich doch auch für moc's theoretisch anpassen lassen. So meine Idee:

Code: Alles auswählen

<?xml version="1.0" encoding="utf-8"?>
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 <ItemGroup>
 <MocFiles Include="$(MSBuildProjectDirectory)\**\*.moc" />
 </ItemGroup>

 <Target Name="CompileQtMoc" BeforeTargets="ClCompile" Inputs="@(MocFiles)" Outputs="@(MocFiles->'%(RootDir)%(Directory)moc_%(Filename).cpp')">
 <Message Text="Compiling: %(MocFiles.FullPath) using MOC" />
 <Exec Command="$(QTDIR)\bin\moc.exe %(MocFiles.FullPath) -o %(MocFiles.RootDir)%(MocFiles.Directory)moc_%(MocFiles.Filename).cpp"/>
 </Target>
</Project>

Und dann per BUILD->Build Customizations...->Find Existing... einbinden und aktivieren. Keine Ahnung ob es funktioniert, habe es noch nicht getestet. Aber vielleicht hilft es.

[CodingCat]

Wir haben das immer über die Buildkonfig gemacht: Kontextmenü auf dem Headefile, "Alle Builds", "Alle Plattformen", dann "Custom Build Tool" und da einen String reinkopiert, den Du aus VS-Makros zusammenbaust, so dass er abstrakt für alle Files funktioniert. Du kannst auch viele Header auf einmal markieren und für alle zusammen diese Einstellung machen.

Einen bequemeren Weg kenne ich allerdings auch nicht.

Ja, das hatte ich mir für den Notfall auch schon überlegt.

Könnte das eventuell helfen. Das sind .targets Vorlagen für .ui und .qrc Dateien. Aber das sollte sich doch auch für moc's theoretisch anpassen lassen. [...]

Danke! Genau so eine direkte Einweisung habe ich gesucht, auch noch mit Qt-Bezug! Das sieht ja gar nicht mal so schlimm aus, insbesondere nur eine Tagets-Datei. :D

[Jonathan]

Also ich benutze seit einiger Zeit für alle Projekte eigentlich nur noch CMake. Unter anderem, weil ich mich dank der Uni da jetzt doch so halbwegs auskenne und es viel rumgefummel in den Projektoptionen erspart. Nachteil ist, dass die erzeugen Projektdateien relativ hässlich sind.
Wie dem auch sei CMake nimmt einen in Bezug auf Qt sehr viel ab, so dass ich das Qt Addin gar nicht installiert habe.

[dot]

MSBuild wirkt am Anfang leider sehr kompliziert und verwirrend, ging mir auch so. Und ich find viele gute Quellen, auf die ich mit der Zeit so gestoßen bin, leider nicht mehr alle, aber das hier ist vielleicht mal ein Anfang: http://msdn.microsoft.com/en-us/magazine/cc163589.aspx
Und da ich mittlerweile das ein oder andere MSBuild basierte System gebaut hab, kann ich dir hier oder vielleicht per PN bzw. Skype möglicherweise helfen, die ein oder andere Unklarheit zu beseitigen... ;)

[Thoran]

Ich habe da ganze bei mir mittels CMake gelöst. CMake fügt dir eben die ganzen Kommandos für MOC, UIC etc auf Datei-Ebene in die generierte Solution ein. Aber ich vermute ja fast, dass diese weitere Ebene eh nicht das ist was du willst. Außerdem habe ich das ganze noch nicht mit VS2012 laufen lassen, da ich immer noch ganz "lame" ;) auf VS2008 arbeite.

[dot]

CMake ist imo gut gemeint aber leider völlig unbrauchbar, zumindest wenn man mit einer IDE arbeitet. Denn effektiv reduziert CMake meine IDE zum Texteditor und alles, wofür ich eigentlich gern die IDE verwenden wollte, darf ich nun manuell über endlose Konfigurationsdateien erledigen. Und die vermeintliche Plattformunabhängigkeit ist am Ende auch nur eine Illusion, denn die CMake Skripte (zumindest in allen Projekten mit denen ich bisher jemals zu tun hatte) sind erst wieder voller ifs, die je nach Plattform unterschiedliche Dinge tun...

[eXile]

So sehr ich auch CMake mag, hier geht es doch um etwas anderes: Jeder, der die CUDA-Build-Targets kennt, kennt auch die Klicki-Bunti-Oberfläche. So eine wollen wir hier. Und je größer die Klicki-Bunti-Oberfläche, desto mehr Schrott steht in den xml/props/targets-Dateien. Fast unwartbar viel Schrott.

[dot]

Dem muss ich widersprechen, die von Visual C++ erzeugten MSBuild Files sind zumindest meiner Erfahrung nach erstaunlich nahe dran an dem, wie eine entsprechende handgecodete Datei aussehen würde. Ich muss aber gestehen, dass wir die CUDA Targets von NVIDIA nicht verwenden, weil wir sie mangels Linker Support durch eine eigene Lösung ersetzen mussten...

[eXile]

Ich speche nach nicht von den von Visual C++ erzeugten MSBuild-Files, sondern vom händischen Schreiben eben solcher. Damit wir wissen, wovon wir sprechen:

Code: Alles auswählen

<?xml version="1.0" encoding="utf-8"?>
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <PropertyGroup Condition="'$(CudaCompileBeforeTargets)' == '' and '$(CudaCompileAfterTargets)' == '' and '$(ConfigurationType)' != 'Makefile'">
        <CudaCompileBeforeTargets>Midl</CudaCompileBeforeTargets>
        <CudaCompileAfterTargets>CustomBuild</CudaCompileAfterTargets>
    </PropertyGroup>

    <PropertyGroup>
        <CudaToolkitDir Condition="'$(CudaToolkitDir)' == ''">$(CudaToolkitCustomDir)</CudaToolkitDir>
        <CudaToolkitVersion>v5.0</CudaToolkitVersion>
        <CudaToolkitFullVersion>5.00.0000.0000</CudaToolkitFullVersion>
    </PropertyGroup>

    <PropertyGroup>
        <!-- Check CUDA Toolkit versioned environment variable. -->
        <CudaToolkitDir Condition="'$(CudaToolkitDir)' == ''">$(CUDA_PATH_V5_0)</CudaToolkitDir>

        <!-- Last, check the new CUDA Toolkit style/Nsight toolkit registry value. -->
        <CudaToolkitDir Condition="'$(CudaToolkitDir)' == ''">$([MSBuild]::GetRegistryValueFromView('HKEY_LOCAL_MACHINE\SOFTWARE\NVIDIA Corporation\GPU Computing Toolkit\Cuda\$(CudaToolkitVersion)', 'InstallDir', null, RegistryView.Registry64, RegistryView.Registry32))</CudaToolkitDir>

        <!-- Ensure $(CudaToolkitDir) has a trailing backslash. -->
        <CudaToolkitDir Condition="'$(CudaToolkitDir)' != '' AND !HasTrailingSlash('$(CudaToolkitDir)')">$(CudaToolkitDir)\</CudaToolkitDir>

        <CudaToolkitIncludeDir Condition="'$(CudaToolkitIncludeDir)' == ''">$(CudaToolkitDir)include</CudaToolkitIncludeDir>
    </PropertyGroup>

    <PropertyGroup Condition="'$(Platform)' == 'Win32'">
        <CudaToolkitBinDir Condition="'$(CudaToolkitBinDir)' == ''">$(CudaToolkitDir)bin</CudaToolkitBinDir>

        <CudaToolkitLibDir Condition="'$(CudaToolkitLibDir)' == '' AND Exists('$(CudaToolkitDir)lib\Win32')">$(CudaToolkitDir)lib\Win32</CudaToolkitLibDir>
        <CudaToolkitLibDir Condition="'$(CudaToolkitLibDir)' == ''">$(CudaToolkitDir)lib</CudaToolkitLibDir>
    </PropertyGroup>

    <PropertyGroup Condition="'$(Platform)' == 'x64'">
        <CudaToolkitBinDir Condition="'$(CudaToolkitBinDir)' == '' AND Exists('$(CudaToolkitDir)bin64')">$(CudaToolkitDir)bin64</CudaToolkitBinDir>
        <CudaToolkitBinDir Condition="'$(CudaToolkitBinDir)' == ''">$(CudaToolkitDir)bin</CudaToolkitBinDir>

        <CudaToolkitLibDir Condition="'$(CudaToolkitLibDir)' == '' AND Exists('$(CudaToolkitDir)lib\x64')">$(CudaToolkitDir)lib\x64</CudaToolkitLibDir>
        <CudaToolkitLibDir Condition="'$(CudaToolkitLibDir)' == ''">$(CudaToolkitDir)lib64</CudaToolkitLibDir>
    </PropertyGroup>

    <PropertyGroup>
        <CudaToolkitNvccPath Condition="'$(CudaToolkitNvccPath)' == ''">$(CudaToolkitBinDir)\nvcc.exe</CudaToolkitNvccPath>

        <CudaClVersion Condition="'$(PlatformToolset)' == 'v90'">2008</CudaClVersion>
        <CudaClVersion Condition="'$(PlatformToolset)' == 'v100'">2010</CudaClVersion>

        <CudaLogStandardErrorAsError>false</CudaLogStandardErrorAsError>

        <CudaIntDir>$(IntDir)</CudaIntDir>
        <CudaIntDir Condition="HasTrailingSlash('$(CudaIntDir)')">$(CudaIntDir.Trim('\'))</CudaIntDir>
    </PropertyGroup>

    <ItemDefinitionGroup>
        <CudaCompile>
            <!-- Project schema: Common properties -->
            <CompileOut>$(IntDir)%(Filename)%(Extension).obj</CompileOut>
            <!-- <Include></Include> -->
            <Keep>false</Keep>
            <KeepDir>$(CudaIntDir)</KeepDir>
            <NvccCompilation>compile</NvccCompilation>
            <TargetMachinePlatform>32</TargetMachinePlatform>

            <!-- Project schema: Driver properties -->
            <CInterleavedPTX>false</CInterleavedPTX>
            <CodeGeneration>compute_10,sm_10</CodeGeneration>
            <GPUDebugInfo Condition="'$(Configuration)' == 'Debug'">true</GPUDebugInfo>
            <GPUDebugInfo Condition="'$(Configuration)' != 'Debug'">false</GPUDebugInfo>
            <MaxRegCount>0</MaxRegCount>
            <PtxAsOptionV>false</PtxAsOptionV>

            <!-- Project schema: Host properties -->
            <!-- <Defines></Defines> -->
            <AdditionalCompilerOptions></AdditionalCompilerOptions>
            <Emulation>false</Emulation>
            <HostDebugInfo Condition="'$(Configuration)' == 'Debug'">true</HostDebugInfo>
            <HostDebugInfo Condition="'$(Configuration)' != 'Debug'">false</HostDebugInfo>
            <FastMath>false</FastMath>
            <Optimization>Od</Optimization>
            <Runtime Condition="'$(Configuration)' == 'Debug'">MDd</Runtime>
            <Runtime Condition="'$(Configuration)' != 'Debug'">MD</Runtime>
            <RuntimeChecks>Default</RuntimeChecks>
            <TypeInfo>false</TypeInfo>
            <Warning>W3</Warning>

            <!-- Project schema: Command line properties -->
            <!-- <AdditionalOptions></AdditionalOptions> -->

            <!-- Added so that the correct platform's bin directory is used for ccbin -->
            <VCBinDir Condition="'$(Platform)' == 'Win32'">$(VCInstallDir)bin</VCBinDir>
            <VCBinDir Condition="'$(Platform)' == 'x64'">$(VCInstallDir)bin\x86_amd64</VCBinDir>
            <VCBinDir Condition="'$(Platform)' == 'x64' AND '$(PROCESSOR_ARCHITECTURE)' == 'AMD64'">$(VCInstallDir)bin\amd64</VCBinDir>

            <BaseCommandLineTemplate>-ccbin "%(VCBinDir)" [Include] [RequiredIncludes] [CInterleavedPTX] [GPUDebugInfo] [Keep] [KeepDir] [MaxRegCount] [PtxAsOptionV] [TargetMachinePlatform] [NvccCompilation] [AdditionalOptions]</BaseCommandLineTemplate>
            <BuildCommandLineTemplate>--use-local-env --cl-version $(CudaClVersion)</BuildCommandLineTemplate>
            <BuildDynamicCommandLineTemplate>[CodeGeneration]</BuildDynamicCommandLineTemplate>
            <CleanCommandLineTemplate>-clean</CleanCommandLineTemplate>
            <HostCommandLineTemplate>-Xcompiler "/EHsc /nologo [Optimization] /Zi [RuntimeChecks] [Runtime] [TypeInfo] [AdditionalCompilerOptions]"</HostCommandLineTemplate>

            <DriverApiCommandLineTemplate>%(BaseCommandLineTemplate) -o "[CompileOut]" "%(FullPath)"</DriverApiCommandLineTemplate>
            <RuntimeApiCommandLineTemplate>%(BaseCommandLineTemplate) [HostDebugInfo] [Emulation] [FastMath] [Defines] %(HostCommandLineTemplate) -o "[CompileOut]" "%(FullPath)"</RuntimeApiCommandLineTemplate>

            <CommandLineTemplate>
# (Approximate command-line, please see the output window after a build for the full command-line)

# Driver API (NVCC Compilation Type is .cubin, .gpu, or .ptx)
set CUDAFE_FLAGS=--sdk_dir "$(WindowsSdkDir)"
"$(CudaToolkitNvccPath)" %(BuildCommandLineTemplate) %(DriverApiCommandLineTemplate)

# Runtime API (NVCC Compilation Type is hybrid object or .c file)
set CUDAFE_FLAGS=--sdk_dir "$(WindowsSdkDir)"
"$(CudaToolkitNvccPath)" %(BuildCommandLineTemplate) %(RuntimeApiCommandLineTemplate)
            </CommandLineTemplate>
            <ExecutionDescription>Compiling CUDA source file %(Identity)...</ExecutionDescription>
            <ExclusionDescription>Skipping CUDA source file %(Identity) (excluded from build).</ExclusionDescription>

            <!-- Miscellaneous -->
            <DepsOutputFile>%(Filename)%(Extension).deps</DepsOutputFile>
            <DepsOutputDir>$(IntDir)%(RelativeDir)</DepsOutputDir>
            <DepsOutputPath>%(DepsOutputDir)%(DepsOutputFile)</DepsOutputPath>

            <PropsCacheOutputFile>%(Filename)%(Extension).cache</PropsCacheOutputFile>
            <PropsCacheOutputPath>$(IntDir)%(PropsCacheOutputFile)</PropsCacheOutputPath>
        </CudaCompile>

        <Link>
            <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories);$(CudaToolkitLibDir)</AdditionalLibraryDirectories>
        </Link>

        <ClCompile>
            <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories);$(CudaToolkitIncludeDir)</AdditionalIncludeDirectories>
        </ClCompile>
    </ItemDefinitionGroup>
</Project>

Code: Alles auswählen

<?xml version="1.0" encoding="utf-8"?>
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    
    <ItemGroup>
        <PropertyPageSchema Include="$(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml" />
        <AvailableItemName Include="CudaCompile">
            <Targets>CudaBuild</Targets>
        </AvailableItemName>
    </ItemGroup>

    <PropertyGroup>
        <CudaBuildRulesPath>$(MSBuildThisFileDirectory)CUDA 5.0.xml</CudaBuildRulesPath>
        <CudaBuildTasksPath>$(MSBuildThisFileDirectory)Nvda.Build.CudaTasks.v5.0.dll</CudaBuildTasksPath>
    </PropertyGroup>
    
    <UsingTask TaskName="CudaCompile" TaskFactory="XamlTaskFactory" AssemblyName="Microsoft.Build.Tasks.v4.0">
        <Task>$(CudaBuildRulesPath)</Task>
    </UsingTask>

    <UsingTask TaskName="Nvda.Build.CudaTasks.CountItems" AssemblyFile="$(CudaBuildTasksPath)" />
    <UsingTask TaskName="Nvda.Build.CudaTasks.GenerateDeps" AssemblyFile="$(CudaBuildTasksPath)" />
    <UsingTask TaskName="Nvda.Build.CudaTasks.LogMetadata" AssemblyFile="$(CudaBuildTasksPath)" />
    <UsingTask TaskName="Nvda.Build.CudaTasks.ReadMetadataLinesFromItems" AssemblyFile="$(CudaBuildTasksPath)" />
    <UsingTask TaskName="Nvda.Build.CudaTasks.SanitizePaths" AssemblyFile="$(CudaBuildTasksPath)" />
    <UsingTask TaskName="Nvda.Build.CudaTasks.SetEnvironmentVariable" AssemblyFile="$(CudaBuildTasksPath)" />
    <UsingTask TaskName="Nvda.Build.CudaTasks.SplitToItemMetadata" AssemblyFile="$(CudaBuildTasksPath)" />

    <Target Name="LogCudaToolkit">
        <Message Text="CudaToolkitVersion     : '$(CudaToolkitVersion)'" />
        <Message Text="CudaToolkitFullVersion : '$(CudaToolkitFullVersion)'" />
        <Message Text="CudaToolkitDir         : '$(CudaToolkitDir)'" />
        <Message Text="CudaToolkitCustomDir   : '$(CudaToolkitCustomDir)'" />
        <Message Text="CudaToolkitBinDir      : '$(CudaToolkitBinDir)'" />
        <Message Text="CudaToolkitIncludeDir  : '$(CudaToolkitIncludeDir)'" />
        <Message Text="CudaToolkitLibDir      : '$(CudaToolkitLibDir)'" />
        <Message Text="CudaToolkitNvccPath    : '$(CudaToolkitNvccPath)'" />
    </Target>

    <Target
        Name="LogCudaCompile"
        DependsOnTargets="AddCudaCompileMetadata;LogCudaToolkit">

        <LogMetadata SourceItems="@(CudaCompile)" />
    </Target>

    <Target
        Name="CudaFilterSelectedFiles"
        Condition="'@(SelectedFiles)' != ''">
        
        <ItemGroup>
            <CudaCompile
                Condition="'%(Identity)' != '@(SelectedFiles)'"
                Remove="@(CudaCompile)" />
        </ItemGroup>
    </Target>

    <Target
        Name="AddCudaCompileMetadata"
        Outputs="%(CudaCompile.CompileOut)">
        
        <!-- Add dynamic metadata that cannot be added in the ItemDefinitionGroup for the CudaCompile item group. -->

        <ItemGroup>
            <CudaCompile Condition="'%(CudaCompile.NvccCompilation)' == 'compile' OR '%(CudaCompile.NvccCompilation)' == 'cuda'">
                <Api>Runtime</Api>
                <ApiCommandLineTemplate>%(CudaCompile.RuntimeApiCommandLineTemplate)</ApiCommandLineTemplate>
            </CudaCompile>
            
            <CudaCompile Condition="'%(CudaCompile.NvccCompilation)' == 'cubin' OR '%(CudaCompile.NvccCompilation)' == 'gpu' OR '%(CudaCompile.NvccCompilation)' == 'ptx'">
                <Api>Driver</Api>
                <ApiCommandLineTemplate>%(CudaCompile.DriverApiCommandLineTemplate)</ApiCommandLineTemplate>
            </CudaCompile>
        </ItemGroup>

        <!-- Remove trailing back slashes, multiple double quotes, etc. -->
        <SanitizePaths InputPaths="%(CudaCompile.Include)">
            <Output TaskParameter="OutputPaths" ItemName="_SanitizedIncludes" />
        </SanitizePaths>

        <ItemGroup>
            <CudaCompile>
                <Include>@(_SanitizedIncludes)</Include>
            </CudaCompile>
        </ItemGroup>

        <ReadLinesFromFile
            Condition="Exists('%(CudaCompile.DepsOutputPath)')"
            File="%(CudaCompile.DepsOutputPath)">

            <Output TaskParameter="Lines" PropertyName="_CudaCompileDeps" />
        </ReadLinesFromFile>

        <ItemGroup>
            <CudaCompile>
                <DepsFromCached>true</DepsFromCached>
                <Deps>$(_CudaCompileDeps)</Deps>

                <!--
                    Add phony dependency if compile is executed on a specific
                    file instead of the project, otherwise build target will
                    be skipped since it's up-to-date.
                -->
                <SelectedFilesDep Condition="'@(SelectedFiles)' != ''">SelectedFiles.{58e7a258-0433-4cfb-9ce7-27f320d678bc}</SelectedFilesDep>
            </CudaCompile>
        </ItemGroup>
        
        <ItemGroup>
            <CudaCompile Condition="'$(Platform)' == 'Win32'">
                <TargetMachinePlatform>32</TargetMachinePlatform>
            </CudaCompile>
            <CudaCompile Condition="'$(Platform)' == 'x64'">
                <TargetMachinePlatform>64</TargetMachinePlatform>
            </CudaCompile>
        </ItemGroup>
    </Target>

    <PropertyGroup>
        <AddCudaCompileDepsDependsOn>
            SetBuildDefaultEnvironmentVariables;
            SetUserMacroEnvironmentVariables;
            PrepareForBuild;
            AddCudaCompileMetadata;
        </AddCudaCompileDepsDependsOn>
    </PropertyGroup>

    <Target
        Name="AddCudaCompileDeps"
        DependsOnTargets="$(AddCudaCompileDepsDependsOn)"
        Inputs="%(CudaCompile.Identity);%(CudaCompile.Deps)"
        Outputs="%(CudaCompile.DepsOutputPath)">
        
        <ItemGroup>
            <_CudaClAdditionalIncludeDirs Include="$(CudaToolkitBinDir)" />
            <_CudaClAdditionalIncludeDirs Include="$(CudaToolkitIncludeDir)" />
            <_CudaClAdditionalIncludeDirs Include="." />

            <_CudaClForcedIncludeFiles Include="cuda_runtime.h" />
        </ItemGroup>

        <ItemGroup>
            <_DepsAdditionalIncludeDirs Include="%(CudaCompile.Include)" />
            <_DepsAdditionalIncludeDirs Include="@(_CudaClAdditionalIncludeDirs)" />
        </ItemGroup>

        <GenerateDeps
            Condition="'%(CudaCompile.ExcludedFromBuild)' != 'true'"
            AdditionalIncludeDirs="@(_DepsAdditionalIncludeDirs)"
            ForcedIncludeFiles="@(_CudaClForcedIncludeFiles)"
            PreprocessorDefinitions="__CUDACC__;%(CudaCompile.Defines)"
            SourceFile="%(CudaCompile.FullPath)">

            <Output TaskParameter="Deps" ItemName="_CudaCompileDeps" />
        </GenerateDeps>

        <MakeDir
            Condition="'%(CudaCompile.ExcludedFromBuild)' != 'true'"
            Directories="%(CudaCompile.DepsOutputDir)" />

        <WriteLinesToFile
            Condition="'%(CudaCompile.ExcludedFromBuild)' != 'true'"
            File="%(CudaCompile.DepsOutputPath)"
            Lines="@(_CudaCompileDeps)"
            Overwrite="true" />

        <ItemGroup>
            <CudaCompile Condition="'%(CudaCompile.Deps)' == ''">
                <DepsFromCached>false</DepsFromCached>
                <Deps>@(_CudaCompileDeps)</Deps>
            </CudaCompile>
        </ItemGroup>

        <ItemGroup>
            <_CudaClAdditionalIncludeDirs Remove="@(_CudaClAdditionalIncludeDirs)" />
            <_CudaClForcedIncludeFiles Remove="@(_CudaClForcedIncludeFiles)" />
            
            <_DepsAdditionalIncludeDirs Remove="@(_DepsAdditionalIncludeDirs)" />
            <_CudaCompileDeps Remove="@(_CudaCompileDeps)" />
        </ItemGroup>
    </Target>

    <PropertyGroup>
        <AddCudaCompilePropsDepsDependsOn>
            SetBuildDefaultEnvironmentVariables;
            SetUserMacroEnvironmentVariables;
            PrepareForBuild;
            AddCudaCompileMetadata;
        </AddCudaCompilePropsDepsDependsOn>
    </PropertyGroup>

    <Target
        Name="AddCudaCompilePropsDeps"
        DependsOnTargets="$(AddCudaCompilePropsDepsDependsOn)"
        Inputs="$(MSBuildProjectFile)"
        Outputs="%(CudaCompile.PropsCacheOutputPath)">

        <!--
            If the project file changes, determine if the changes include changes to the
            CUDA item build properties.  If so, add the project file as a dependency.

            First, read build props from previous build if available.
        -->

        <ReadLinesFromFile
            Condition="Exists('%(CudaCompile.PropsCacheOutputPath)')"
            File="%(CudaCompile.PropsCacheOutputPath)">

            <Output TaskParameter="Lines" ItemName="_CudaCompilePropsOld" />
        </ReadLinesFromFile>

        <!-- Determine build properties to read as determined by the rules file. -->
        <XmlPeek
            Namespaces="<Namespace Prefix='x' Uri='clr-namespace:Microsoft.Build.Framework.XamlTypes;assembly=Microsoft.Build.Framework' />"
            XmlInputPath="$(CudaBuildRulesPath)"
            Query="//x:BoolProperty/@Name | //x:DynamicEnumProperty/@Name | //x:EnumProperty/@Name | //x:IntProperty/@Name | //x:StringProperty/@Name | //x:StringListProperty/@Name">

            <Output TaskParameter="Result" ItemName="_CudaCompilePropNames" />
        </XmlPeek>

        <!-- Remove the CommandLineTemplate property, this has no effect on the build. -->
        <ItemGroup>
            <_CudaCompilePropNames Remove="CommandLineTemplate" />
        </ItemGroup>

        <!-- Read the CudaCompile build property names from the rules file. -->
        <ReadMetadataLinesFromItems
            Items="@(CudaCompile->Metadata('Identity'))"
            MetadataNames="@(_CudaCompilePropNames)">

            <Output TaskParameter="MetadataLines" ItemName="_CudaCompilePropsNew" />
        </ReadMetadataLinesFromItems>

        <!-- Cache build property values for comparison in successive builds. -->
        <WriteLinesToFile
            File="%(CudaCompile.PropsCacheOutputPath)"
            Lines="@(_CudaCompilePropsNew)"
            Overwrite="true" />

        <!-- If the new props differ from the old props, add the project file as a dependency.  -->
        <ItemGroup>
            <CudaCompile Condition="'@(_CudaCompilePropsOld)' != '@(_CudaCompilePropsNew)'">
                <ProjectDeps>$(MSBuildProjectFile)</ProjectDeps>
            </CudaCompile>
        </ItemGroup>
    </Target>

    <Target Name="ValidateCudaBuild">

        <!-- Validate CUDA Toolkit dir. -->
        <Error
            Condition="!Exists($(CudaToolkitDir))"
            Text="The CUDA Toolkit $(CudaToolkitVersion) directory '$(CudaToolkitDir)' does not exist.  Please verify the CUDA Toolkit is installed properly or define the CudaToolkitDir property to resolve this error." />
    </Target>

    <Target
        Name="ValidateCudaCodeGeneration"
        Outputs="%(CudaCompile.CompileOut)">

        <ItemGroup>
            <ValidateCudaCodeGenerationItems Include="%(CudaCompile.CodeGeneration)" />
        </ItemGroup>

        <CountItems InputItems="@(ValidateCudaCodeGenerationItems)">
            <Output TaskParameter="ItemCount" PropertyName="ValidateCudaCodeGenerationCount" />
        </CountItems>

        <!-- Currently only CUDA allows more than 1 code generation option at a time. -->
        <Error
            Condition="'%(CudaCompile.NvccCompilation)' != 'compile' AND $(ValidateCudaCodeGenerationCount) > 1"
            Text="More than 1 Code Generation option is specified, this is only allowed if NVCC Compilation Type is 'compile'." />
    </Target>

    <Target Name="PrepareForCudaBuild">
        <SanitizePaths InputPaths="$(WindowsSdkDir)">
            <Output TaskParameter="OutputPaths" PropertyName="CudafeWindowsSdkDir" />
        </SanitizePaths>

        <SetEnvironmentVariable 
            Name="CUDAFE_FLAGS"
            Value="--sdk_dir "$(CudafeWindowsSdkDir)"" />
    </Target>

    <PropertyGroup>
        <CudaCompileDependsOn>
            $(CudaCompileDependsOn);
            _SelectedFiles;
            CudaFilterSelectedFiles;
            AddCudaCompileMetadata;
            AddCudaCompileDeps;
            AddCudaCompilePropsDeps;
            ValidateCudaBuild;
            ValidateCudaCodeGeneration;
            ComputeCudaCompileOutput;
            PrepareForCudaBuild
        </CudaCompileDependsOn>
    </PropertyGroup>

    <Target
        Name="CudaBuild"
        BeforeTargets="$(CudaCompileBeforeTargets)"
        AfterTargets="$(CudaCompileAfterTargets)"
        Condition="'@(CudaCompile)' != ''"
        DependsOnTargets="$(CudaCompileDependsOn)"
        Inputs="
            @(CudaCompile);
            %(CudaCompile.ProjectDeps);
            %(CudaCompile.Deps);
            %(CudaCompile.AdditionalDependencies);
            %(CudaCompile.SelectedFilesDep)"
        Outputs="%(CudaCompile.CompileOut)">

        <Message
            Condition="'%(CudaCompile.ExcludedFromBuild)' != 'true'"
            Importance="High"
            Text="%(CudaCompile.ExecutionDescription)" />
        
        <Message
            Condition="'%(CudaCompile.ExcludedFromBuild)' == 'true'"
            Importance="High"
            Text="%(CudaCompile.ExclusionDescription)" />

        <ItemGroup>
            <CudaBuildCodeGenerationItems Include="%(CudaCompile.CodeGeneration)" />

            <CudaBuildCodeGenerationMetadataNames Include="Arch" />
            <CudaBuildCodeGenerationMetadataNames Include="Code" />
        </ItemGroup>

        <SplitToItemMetadata
            InputItemSpec="%(CudaCompile.Identity)"
            InputItemName="Code Generation"
            InputItems="@(CudaBuildCodeGenerationItems)"
            MetadataNames="@(CudaBuildCodeGenerationMetadataNames)"
            SplitSeparator=",">

            <Output TaskParameter="OutputItems" ItemName="CudaBuildCodeGenerationMetadataItems" />
        </SplitToItemMetadata>

        <ItemGroup>
            <CudaBuildCodeGenerationValues
                Condition="'%(CudaCompile.NvccCompilation)' == 'compile' OR '%(CudaCompile.NvccCompilation)' == 'ptx'"
                Include="@(CudaBuildCodeGenerationMetadataItems->'arch=%(Arch),code=\"%(Code),%(Arch)\"')" />

            <CudaBuildCodeGenerationValues
                Condition="'%(CudaCompile.NvccCompilation)' != 'compile' AND '%(CudaCompile.NvccCompilation)' != 'ptx'"
                Include="@(CudaBuildCodeGenerationMetadataItems->'arch=%(Arch),code=%(Code)')" />
        </ItemGroup>

        <PropertyGroup>
            <CompileOutDir>$([System.IO.Directory]::GetParent('%(CudaCompile.CompileOut)').FullName)</CompileOutDir>
        </PropertyGroup>

        <!-- nvcc will produce an error if the output directories do not exist, so ensure they are created before building. -->
        <MakeDir
            Condition="!Exists('$(CompileOutDir)')"
            Directories="$(CompileOutDir)" />

        <MakeDir
            Condition="'%(CudaCompile.Keep)' == 'true' AND !Exists('%(CudaCompile.KeepDir)')"
            Directories="%(CudaCompile.KeepDir)" />

        <CudaCompile
            Condition="'%(CudaCompile.ExcludedFromBuild)' != 'true'"
            StandardOutputImportance="High"
            LogStandardErrorAsError="$(CudaLogStandardErrorAsError)"

            AdditionalDeps="%(CudaCompile.AdditionalDeps)"
            CompileOut="%(CudaCompile.CompileOut)"
            Include="%(CudaCompile.Include)"
            NvccCompilation="%(CudaCompile.NvccCompilation)"
            NvccPath="$(CudaToolkitNvccPath)"
            RequiredIncludes="$(CudaToolkitIncludeDir)"
            TargetMachinePlatform="%(CudaCompile.TargetMachinePlatform)"

            CInterleavedPTX="%(CudaCompile.CInterleavedPTX)"
            CodeGeneration="@(CudaBuildCodeGenerationValues)"
            GPUDebugInfo="%(CudaCompile.GPUDebugInfo)"
            Keep="%(CudaCompile.Keep)"
            KeepDir="%(CudaCompile.KeepDir)"
            MaxRegCount="%(CudaCompile.MaxRegCount)"
            PtxAsOptionV="%(CudaCompile.PtxAsOptionV)"
            
            Defines="%(CudaCompile.Defines)"
            Emulation="%(CudaCompile.Emulation)"
            HostDebugInfo="%(CudaCompile.HostDebugInfo)"
            FastMath="%(CudaCompile.FastMath)"
            Optimization="%(CudaCompile.Optimization)"
            Runtime="%(CudaCompile.Runtime)"
            RuntimeChecks="%(CudaCompile.RuntimeChecks)"
            TypeInfo="%(CudaCompile.TypeInfo)"
            Warning="%(CudaCompile.Warning)"

            AdditionalOptions="%(CudaCompile.AdditionalOptions)"
            CommandLineTemplate=""$(CudaToolkitNvccPath)" %(CudaCompile.BuildDynamicCommandLineTemplate) %(CudaCompile.BuildCommandLineTemplate) %(CudaCompile.ApiCommandLineTemplate)" />

        <ItemGroup>
            <_NvccIntermediateFiles Include="%(CudaCompile.RelativeDir)tmpxft*%(CudaCompile.Filename).cpp3.o" />
        </ItemGroup>
        <Delete
            Condition="'%(CudaCompile.ExcludedFromBuild)' != 'true'"
            Files="@(_NvccIntermediateFiles)" />
    </Target>

    <PropertyGroup>
        <ComputeLinkInputsTargets>
            $(ComputeLinkInputsTargets);
            ComputeCudaCompileOutput
        </ComputeLinkInputsTargets>
    </PropertyGroup>

    <Target
        Name="ComputeCudaCompileOutput"
        Condition="'@(CudaCompile)' != ''"
        Outputs="%(CudaCompile.CompileOut)">

        <ItemGroup>
            <Link
                Condition="'%(CudaCompile.ExcludedFromBuild)' != 'true' AND '%(CudaCompile.NvccCompilation)' == 'compile' AND '$(ConfigurationType)' != 'StaticLibrary'"
                Include="@(CudaCompile->Metadata('CompileOut')->Distinct()->ClearMetadata())" />

            <Lib
                Condition="'%(CudaCompile.ExcludedFromBuild)' != 'true' AND '%(CudaCompile.NvccCompilation)' == 'compile' AND '$(ConfigurationType)' == 'StaticLibrary'"
                Include="@(CudaCompile->Metadata('CompileOut')->Distinct()->ClearMetadata())" />
        </ItemGroup>
    </Target>

    <PropertyGroup>
        <CppCleanDependsOn>
            $(CppCleanDependsOn);
            CudaClean
        </CppCleanDependsOn>

        <CudaCleanDependsOn>
            AddCudaCompileMetadata;
            ValidateCudaBuild;
        </CudaCleanDependsOn>
    </PropertyGroup>

    <Target
        Name="CudaClean"
        Condition="'@(CudaCompile)' != ''"
        DependsOnTargets="$(CudaCleanDependsOn)"
        Outputs="%(CudaCompile.CompileOut)">
        
        <!-- TODO: Refactor to only have to specify this once. -->
        <CudaCompile
            Condition="'%(CudaCompile.ExcludedFromBuild)' != 'true'"
            StandardOutputImportance="High"
            LogStandardErrorAsError="$(CudaLogStandardErrorAsError)"

            AdditionalDeps="%(CudaCompile.AdditionalDeps)"
            CompileOut="%(CudaCompile.CompileOut)"
            Include="%(CudaCompile.Include)"
            NvccCompilation="%(CudaCompile.NvccCompilation)"
            NvccPath="$(CudaToolkitNvccPath)"
            RequiredIncludes="$(CudaToolkitIncludeDir)"
            TargetMachinePlatform="%(CudaCompile.TargetMachinePlatform)"

            CInterleavedPTX="%(CudaCompile.CInterleavedPTX)"
            CodeGeneration=""
            GPUDebugInfo="%(CudaCompile.GPUDebugInfo)"
            Keep="%(CudaCompile.Keep)"
            KeepDir="%(CudaCompile.KeepDir)"
            MaxRegCount="%(CudaCompile.MaxRegCount)"
            PtxAsOptionV="%(CudaCompile.PtxAsOptionV)"
            
            Defines="%(CudaCompile.Defines)"
            Emulation="%(CudaCompile.Emulation)"
            HostDebugInfo="%(CudaCompile.HostDebugInfo)"
            FastMath="%(CudaCompile.FastMath)"
            Optimization="%(CudaCompile.Optimization)"
            Runtime="%(CudaCompile.Runtime)"
            RuntimeChecks="%(CudaCompile.RuntimeChecks)"
            TypeInfo="%(CudaCompile.TypeInfo)"
            Warning="%(CudaCompile.Warning)"

            AdditionalOptions="%(CudaCompile.AdditionalOptions)"
            CommandLineTemplate=""$(CudaToolkitNvccPath)" %(CudaCompile.ApiCommandLineTemplate) %(CudaCompile.CleanCommandLineTemplate)" />

        <Delete Files="%(CudaCompile.DepsOutputPath)" />
    </Target>
</Project>

Code: Alles auswählen

<?xml version="1.0" encoding="utf-8"?>
<ProjectSchemaDefinitions
    xmlns="clr-namespace:Microsoft.Build.Framework.XamlTypes;assembly=Microsoft.Build.Framework"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:sys="clr-namespace:System;assembly=mscorlib">

    <!--
        Common properties:
            AdditionalDeps
            CompileOut
            Include
            Keep
            NvccCompilation
            NvccPath
            RequiredIncludes
            TargetMachinePlatform

        Device properties:
            Arch
            CInterleavedPTX
            GPUDebugInfo
            MaxRegCount
            PtxAsOptionV

        Host properties:
            Defines
            Emulation
            HostDebugInfo
            FastMath
            Optimization
            Runtime
            RuntimeChecks
            TypeInfo
            Warning

        Command Line properties:
            AdditionalOptions
            CommandLineTemplate

        Unused?:
            DontUseProfile (-noprof)
            LibraryPaths (-L)
            Library (-l)
            CompilerOptions (-Xcompiler)
            LinkerOptions (-Xlinker)
            PreInclude (-pre-include)
    -->

    <ItemType Name="CudaCompile" DisplayName="CUDA C/C++" />

    <FileExtension Name="*.cu" ContentType="CudaCompile" />

    <ContentType Name="CudaCompile" DisplayName="CUDA C/C++" ItemType="CudaCompile" />

    <Rule Name="CudaCompile" PageTemplate="tool" DisplayName="CUDA C/C++" Order="12">
        <Rule.DataSource>
            <DataSource Persistence="ProjectFile" ItemType="CudaCompile" />
        </Rule.DataSource>

        <Rule.Categories>
            <Category Name="Common" DisplayName="Common" />
            <Category Name="Device" DisplayName="Device" />
            <Category Name="Host" DisplayName="Host" />
            <Category Name="Command Line" DisplayName="Command Line" Subtype="CommandLine" />
        </Rule.Categories>

        <Rule.Properties>
            <!-- /////////////////////////////////////////////////////////////////////////////////// Common properties -->
            <StringProperty
                Name="CudaToolkitCustomDir"
                Subtype="folder"
                DisplayName="CUDA Toolkit Custom Dir"
                Category="Common"
                Description="Custom path to the CUDA Toolkit."
                IncludeInCommandLine="False">
                <StringProperty.DataSource>
                    <DataSource Persistence="ProjectFile" HasConfigurationCondition="false" Label="Globals" />
                </StringProperty.DataSource>
            </StringProperty>

            <StringListProperty
                Name="AdditionalDeps"
                DisplayName="Source Dependencies"
                Category="Common"
                Description="Add additional source file dependencies.  Dependencies that are #include'd do not have to be explicitly specified here."
                Switch="[value]" />

            <StringProperty
                Name="CompileOut"
                DisplayName="Compiler Output (obj/cubin)"
                Category="Common"
                Subcategory="Compiler"
                Description="Sets output as an obj or cubin file."
                Switch="[value]" />

            <StringListProperty
                Name="Include"
                DisplayName="Additional Include Directories"
                Category="Common"
                Description="Specifies one or more directories to add to the include path; use semi-colon delimited list if more than one. (/I[path])"
                Switch="-I"[value]""
                RendererValueSeparator=";" />

            <BoolProperty
                Name="Keep"
                DisplayName="Keep Preprocessed Files"
                Category="Common"
                Description="Specifies that preprocessor files generated by the CUDA compiler are not deleted, i.e., .ptx, .cubin, .cudafe1.c, etc. (--keep)"
                Switch="--keep" />

            <StringProperty
                Name="KeepDir"
                Subtype="folder"
                DisplayName="Keep Directory"
                Category="Common"
                Description="Path to the directory where preprocessor files generated by the CUDA compiler will be kept."
                Switch="--keep-dir "[value]"" />

            <EnumProperty
                Name="NvccCompilation"
                DisplayName="NVCC Compilation Type"
                Category="Common"
                Subcategory="Compiler"
                Description="Selected desired output of NVCC compilation (-c/-compile, -cuda, -gpu, -cubin, -ptx).">

                <EnumValue
                    Name="compile"
                    DisplayName="Generate hybrid object file"
                    Switch="--compile" />

                <EnumValue
                    Name="cuda"
                    DisplayName="Generate hybrid .c file"
                    Switch="-cuda" />

                <EnumValue
                    Name="gpu"
                    DisplayName="Generate .gpu file file"
                    Switch="-gpu" />

                <EnumValue
                    Name="cubin"
                    DisplayName="Generate .cubin file"
                    Switch="-cubin" />

                <EnumValue
                    Name="ptx"
                    DisplayName="Generate .ptx file"
                    Switch="-ptx" />
            </EnumProperty>

            <StringProperty
                Name="NvccPath"
                DisplayName="Compiler Path"
                Category="Common"
                ReadOnly="true"
                Description="Designated path to nvcc.exe."
                Switch=""[value]""
                Visible="false" />

            <StringListProperty
                Name="RequiredIncludes"
                DisplayName="Required Include Directories"
                Category="Common"
                ReadOnly="true"
                Description="This include must exist for CUDA headers to be accessed."
                Switch="-I"[value]""
                RendererValueSeparator=";"
                Visible="false" />

            <EnumProperty
                Name="TargetMachinePlatform"
                DisplayName="Target Machine Platform"
                Category="Common"
                Description="Select the platform for the target machine (x86 or x64).">

                <EnumValue
                    Name="32"
                    DisplayName="32-bit"
                    Switch="--machine 32" />

                <EnumValue
                    Name="64"
                    DisplayName="64-bit"
                    Switch="--machine 64" />
            </EnumProperty>

            <!-- /////////////////////////////////////////////////////////////////////////////////// Device properties -->

            <BoolProperty
                Name="CInterleavedPTX"
                DisplayName="C interleaved in PTXAS Output"
                Category="Device"
                Description="Insert source code in generated PTX."
                Switch="--opencc-options -LIST:source=on" />

            <StringListProperty
                Name="CodeGeneration"
                DisplayName="Code Generation"
                Category="Device"
                Description="Specifies the names of the NVIDIA GPUs to generate code for and the class of the NVIDIA GPU architectures for which the input files must be compiled.  Specify the architecture and code in the format [arch],[code], multiple arch/code pairs may be specified separated by a ; character if the NVCC Compilation Type is compile (CUDART).  Valid values for arch and code are compute_10, compute_11, compute_12, compute_13, compute_20, compute_30, sm_10, sm_11, sm_12, sm_13, sm_20, sm_21, sm_30."
                Switch="-gencode=[value]"
                RendererValueSeparator=";" />

            <BoolProperty
                Name="GPUDebugInfo"
                DisplayName="Generate GPU Debug Information"
                Category="Device"
                Description="Specifies whether or not GPU debugging information is generated by the CUDA Compiler. (-G)"
                Switch="-G" />

            <IntProperty
                Name="MaxRegCount"
                DisplayName="Max Used Register"
                Category="Device"
                Description="Specify the maximum amount of registers that GPU functions can use. (-maxrregcount)"
                Switch="-maxrregcount=[value]" />

            <BoolProperty
                Name="PtxAsOptionV"
                DisplayName="Verbose PTXAS Output"
                Category="Device"
                Description=""
                Switch="--ptxas-options=-v" />

            <!-- /////////////////////////////////////////////////////////////////////////////////// Host properties -->

            <StringProperty
                Name="AdditionalCompilerOptions"
                DisplayName="Additional Compiler Options"
                Category="Host"
                Description="Additional host compiler options that are not supported by the host project properties." />

            <StringListProperty
                Name="Defines"
                DisplayName="Preprocessor Definitions"
                Category="Host"
                Description="Specifies one or more preprocessor defines.  (-D[macro])"
                Switch="-D[value]"
                RendererValueSeparator=";" />

            <BoolProperty
                Name="Emulation"
                DisplayName="Emulation"
                Category="Host"
                Description="Specifies whether or not to generate emulated code.  (-deviceemu)"
                Switch="-deviceemu -D_DEVICEEMU" />

            <BoolProperty
                Name="HostDebugInfo"
                DisplayName="Generate Host Debug Information"
                Category="Host"
                Description="Specifies whether or not host debugging information is generated by the CUDA compiler. (-g)"
                Switch="-g" />

            <BoolProperty
                Name="FastMath"
                DisplayName="Use Fast Math"
                Category="Host"
                Description="Make use of the fast math library."
                Switch="-use_fast_math" />

            <EnumProperty
                Name="Optimization"
                DisplayName="Optimization"
                Category="Host"
                Description="Select option for code optimization; choose Custom to use specific optimization options. (/Od, /O1, /O2, /Ox)">

                <EnumValue
                    Name="Od"
                    DisplayName="Disabled"
                    Switch="/Od" />

                <EnumValue
                    Name="O1"
                    DisplayName="Minimize Size"
                    Switch="/O1" />

                <EnumValue
                    Name="O2"
                    DisplayName="Maximize Speed"
                    Switch="/O2" />

                <EnumValue
                    Name="O3"
                    DisplayName="Full Optimization"
                    Switch="/Ox" />
            </EnumProperty>

            <EnumProperty
                Name="Runtime"
                DisplayName="Runtime Library"
                Category="Host"
                Description="Specify runtime library for linking. (/Mt, /MTd, /MD, /MDd, /ML, /MLd)">

                <EnumValue
                    Name="MT"
                    DisplayName="Multi-Threaded"
                    Switch="/MT" />

                <EnumValue
                    Name="MTd"
                    DisplayName="Multi-Threaded Debug"
                    Switch="/MTd" />

                <EnumValue
                    Name="MD"
                    DisplayName="Multi-Threaded DLL"
                    Switch="/MD" />

                <EnumValue
                    Name="MDd"
                    DisplayName="Multi-threaded Debug DLL"
                    Switch="/MDd" />

                <EnumValue
                    Name="ML"
                    DisplayName="Single-Threaded"
                    Switch="/ML" />

                <EnumValue
                    Name="MLd"
                    DisplayName="Single-Threaded Debug"
                    Switch="/MLd" />
            </EnumProperty>

            <EnumProperty
                Name="RuntimeChecks"
                DisplayName="Basic Runtime Checks"
                Category="Host"
                Description="Perform basic runtime error checks, incompatible with any optimization type other than debug. (/RTCs, /RTCu, RTC1)">

                <EnumValue
                    Name="Default"
                    DisplayName="Default"
                    Switch="" />

                <EnumValue
                    Name="RTCs"
                    DisplayName="Stack Frames"
                    Switch="/RTCs" />

                <EnumValue
                    Name="RTCu"
                    DisplayName="Uninitialized Variables"
                    Switch="/RTCu" />

                <EnumValue
                    Name="RTC1"
                    DisplayName="Both"
                    Switch="/RTC1" />
            </EnumProperty>

            <BoolProperty
                Name="TypeInfo"
                DisplayName="Enable Run-Time Type Info"
                Category="Host"
                Description="Adds code for checking C++ object types at run time (runtime type information). (/GR)"
                Switch="/GR" />

            <EnumProperty
                Name="Warning"
                DisplayName="Warning Level"
                Category="Host"
                Description="Select how strict you want the compiler to be about checking for potentially suspect constructs. (/W0 - /W4)">

                <EnumValue
                    Name="W0"
                    DisplayName="Off: Turn Off All Warnings"
                    Switch="/W0" />

                <EnumValue
                    Name="W1"
                    DisplayName="Level 1"
                    Switch="/W1" />

                <EnumValue
                    Name="W2"
                    DisplayName="Level 2"
                    Switch="/W2" />

                <EnumValue
                    Name="W3"
                    DisplayName="Level 3"
                    Switch="/W3" />

                <EnumValue
                    Name="W4"
                    DisplayName="Level 4"
                    Switch="/W4" />
            </EnumProperty>

            <!-- /////////////////////////////////////////////////////////////////////////////////// Command line properties -->

            <StringProperty
                Name="AdditionalOptions"
                DisplayName="Additional Options"
                Category="Command Line"
                Description="Additional Options" />

            <StringProperty
                Name="CommandLineTemplate"
                DisplayName="Command Line"
                Category="Command Line"
                Visible="False"
                IncludeInCommandLine="False" />

        </Rule.Properties>
    </Rule>
</ProjectSchemaDefinitions>

[dot]

Nun, abgesehen davon, dass XML, wie wir alle wissen, leider relativ viel Noise erzeugt, seh ich nicht ganz, wo das Problem liegt!?

[CodingCat]

So sehr ich auch CMake mag, hier geht es doch um etwas anderes: Jeder, der die CUDA-Build-Targets kennt, kennt auch die Klicki-Bunti-Oberfläche. So eine wollen wir hier. Und je größer die Klicki-Bunti-Oberfläche, desto mehr Schrott steht in den xml/props/targets-Dateien. Fast unwartbar viel Schrott.

Ich speche nach nicht von den von Visual C++ erzeugten MSBuild-Files, sondern vom händischen Schreiben eben solcher. Damit wir wissen, wovon wir sprechen: [...]

Ich habe mich da ja gestern etwas durchgelesen. Wenn ich das richtig verstehe, ist die XML-Datei für die Oberfläche zuständig - über allzu viel überflüssigen Mist kann man sich da wirklich nicht beklagen - nur über die Nichtauffindbarkeit der verwendeten Elemente in der MS Build Referenz. Diese finden sich offensichtlich nur hier vergraben.

Die Targets-Datei definiert offenbar einen sehr modularen Build-Prozess, hier rätsele ich am meisten über die Relevanz einzelner Punkte. Die Props-Datei definiert wenn ich das richtig sehe einfach nur Defaults für jene Eigenschaften, die von den anderen beiden Dateien definiert wurden. Eine solche Props-Datei sollte sich bei hinzugefügter Targets-Datei komfortabel mit dem Property-Sheet-Editor in VS 2010/2012 erstellen und bearbeiten lassen.

Wie dot anspricht, finde ich vor allem die XML-Notation bei spärlicher Dokumentation extrem gewöhnungsbedürftig/unhandlich.

[eXile]

Nun, abgesehen davon, dass XML leider relativ viel Noise erzeugt, seh ich nicht ganz, wo das Problem liegt!?

Das Problem ist, dass man das eben per Hand schreiben muss, muss so eine Oberfläche zu kriegen; früher ging das relativ automatisch. Damit muss du auch die Zeit investieren, das zu verstehen, selbst schreiben zu können und zu debuggen. Diese Zeit wird einem effektiv genommen. Was für dich jetzt wohl kein Problem ist, weil du dich mit MSBuild auskennen scheinst; das ist wohl aber nur in einer Minderheit der Fall.

Random-Pick zum Verständis: Wofür steht beispielsweise XmlPeek?

[CodingCat]

Random-Pick zum Verständis: Wofür steht beispielsweise XmlPeek?

Das ist sogar dokumentiert: http://msdn.microsoft.com/en-us/library/ff598684.aspx ;) Ich finde es auch ärgerlich, dass es keinen einfachen Editor mehr dafür gibt, zumal der mit etwas MS Build-Verständnis vermutlich schnell geschrieben wäre.

[dot]

Was die ominöse .xml Datei betrifft, konnte ich leider noch keine offizielle Dokumentation finden. Die .xml Dateien des Visual Studio Buildsystems sind imo aber ziemlich selbsterklärend. Ansonsten fand ich z.B. diesen Blogpost sehr hilfreich: http://blogs.msdn.com/b/vsproject/archi ... art-2.aspx

[eXile]

Das ist sogar dokumentiert: http://msdn.microsoft.com/en-us/library/ff598684.aspx ;)

XmlPeek Task
Returns values as specified by XPath Query from an XML file.

Achso :)

Ich finde es auch ärgerlich, dass es keinen einfachen Editor mehr dafür gibt, zumal der mit etwas MS Build-Verständnis vermutlich schnell geschrieben wäre.

Ja. Vielleicht war ich mit meiner Titulierung als „Schrott“ etwas vorschnell; jedoch bleibe ich dabei, dass ich mit dem händischen Schreiben der Dateien am liebsten nichts zu tun hätte. Wenn du da tatsächlich durchsteigst und es zu fertigen Qt-Dateien bringst, hast du damit einen ziemlichen Dienst für die Menschheit vollbracht.

[dot]

Nun, abgesehen davon, dass XML leider relativ viel Noise erzeugt, seh ich nicht ganz, wo das Problem liegt!?

Das Problem ist, dass man das eben per Hand schreiben muss, muss so eine Oberfläche zu kriegen; früher ging das relativ automatisch.

Ich verstehe deine Frustration. Mich in MSBuild einzuarbeiten war alles andere als ein Zuckerschlecken; zu sagen, dass die Dokumentation auf jeden Fall besser sein könnte, ist da noch sehr freundlich untertrieben (mittlerweile hab ich das Gefühl, dass die offenbar doch zahlreichen Bücher zum Thema eine gewisse inoffizielle Dokumentation darstellen sollen, MSBuild ist außerdem wohl auch noch in einem sehr regen Entwicklungsprozess). Wenn ich in Richtung Direct3D oder DirectWrite blicke, scheint mir das im Moment aber leider irgendwie ein prinzipielles Problem zu sein. Nichts desto trotz kann ich nur sagen, dass es sich lohnt. Ich würde das alte System um keinen Preis der Welt zurück haben wollen, MBuild ist einfach um so viele Größenordnungen sauberer und mächtiger...

Von Qt hab ich leider nur wenig Ahnung und MOC ist gerade der Hauptgrund, wieso mir das nicht ins Haus kommt, aber um vielleicht ein bisschen Licht ins Dunkel zu bringen:

Die Targets-Datei definiert offenbar einen sehr modularen Build-Prozess, hier rätsele ich am meisten über die Relevanz einzelner Punkte. Die Props-Datei definiert wenn ich das richtig sehe einfach nur Defaults für jene Eigenschaften, die von den anderen beiden Dateien definiert wurden. Eine solche Props-Datei sollte sich bei hinzugefügter Targets-Datei komfortabel mit dem Property-Sheet-Editor in VS 2010/2012 erstellen und bearbeiten lassen.

Im Prinzip kann man sich ein MSBuild basiertes System wie einen Filtergraphen vorstellen. Targets sind die Knoten und Items sind die Daten, die von einem Knoten zum nächsten wandern. Die Targets transformieren Items in andere Items. Der C++ Compiler beispielsweise nimmt Items vom Typ ClCompile (.cpp Files) und generiert daraus Items vom Typ Link (Object Files). Jedes Item besteht dabei aus einer Reihe von Key Value Pairs (Metadata in MSBuild-speak). Im Falle von ClCompile gibt es z.B. für jedes Compilerflag entsprechende Metadata.

Inputs in das Buildsystem generiert man, indem man eben einfach einen Haufen Items definiert:

Code: Alles auswählen

<ItemGroup>
  <FancyCompile Include="bla.cpp">
    <Metadata1>blub</Metadata1>
  </FancyCompile>
  <FancyCompile Include="*.fancycpp" />
  ...
</ItemGroup>

Das erzeugt Items für bla.cpp und alle *.fancycpp Dateien im Projektordner, wobei "Metadata1" für bla.cpp den Wert "blub" bekommt.

Seit Visual Studio 2010 ist auch Visual C++ nurmehr ein GUI Frontend für MSBuild (im .NET Sektor war das schon viel länger, wenn nicht schon immer der Fall), .vcxproj Dateien sind einfach nur nach einem bestimmten Schema aufgebaute MSBuild Projekte und VC drückt die entsprechenden Tasten. Der ganze Kram von wegen .targets und .props Files ist lediglich eine Konvention mit der Visual Studio umzugehen weiß, am Ende des Tages sind das nur stinknormale MSBuild Files wie alles andere auch, die einfach vom Hauptprojekt inkludiert werden. .props Files enthalten laut Konvention eben unter anderem ItemDefinitionGroups (der Property Sheet Editor in VS ist einfach nur eine GUI für die ItemDefinitionGroup Elemente in einer Datei). Eine ItemDefinitionGroup definiert einfach Defaultwerte für die Metadata bestimmter Item Typen. Wobei das ein additiver Prozess ist: Die Überlagerung aller ItemDefinitionGroups im ganzen Projekt ergibt den Satz an Metadaten, die jedes in diesem Projekt definierte Item von Haus aus erhält. Theoretisch könntest du das alles statt in ein .props File auch direkt in das .vcxproj reinschreiben (genau das tut VS, wenn du die globalen Properties eines Projektes editierst).

Theoretisch bräuchtest du für eine Build Customization afaik weder eine .props noch eine .xml Datei, lediglich eine .targets Datei. VS sorgt lediglich dafür, dass eine etwaig vorhandene, gleichnamige .props Datei mit der .targets Datei gemeinsam inkludiert wird. Die .xml Datei ist das einzig besondere hier, da sie nichts mit MSBuild zu tun hat. Diese .xml Dateien sagen Visual Studio Dinge wie z.B. auf welche MSBuild Item Typen Dateien mit bestimmter Endung mappen und definieren die Struktur des für diese Item Typen zu erzeugenden User Interface, welches am Ende nichts anderes ist als eine GUI für die Item Metadata.

[CodingCat]

Ich habe mal begonnen, anhand der CUDA-Dateien ein MOC-Target zusammenzuschustern. Ich bin zwischenzeitlich mehrfach verzweifelt, zumindest die IDE-Integration scheint aber schonmal zu klappen. Gebaut habe ich damit noch nichts, vermutlich geht es auch noch nicht.

XML:

Code: Alles auswählen

<?xml version="1.0" encoding="utf-8"?>
<ProjectSchemaDefinitions
	xmlns="clr-namespace:Microsoft.Build.Framework.XamlTypes;assembly=Microsoft.Build.Framework"
	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
	xmlns:sys="clr-namespace:System;assembly=mscorlib">
	
	<ItemType Name="QtCompile" DisplayName="Qt C/C++" />

	<FileExtension Name="*.h" ContentType="QtCompile" />
	<FileExtension Name="*.hpp" ContentType="QtCompile" />

	<ContentType Name="QtCompile" DisplayName="Qt C/C++" ItemType="QtCompile" />

	<Rule Name="QtCompile" PageTemplate="tool" DisplayName="Qt C/C++" Order="12">
		<Rule.DataSource>
			<DataSource Persistence="ProjectFile" ItemType="QtCompile" />
		</Rule.DataSource>

		<Rule.Categories>
			<Category Name="Common" DisplayName="Common" />
			<Category Name="Command Line" DisplayName="Command Line" Subtype="CommandLine" />
		</Rule.Categories>

		<Rule.Properties>
			<StringProperty
				Name="CompileOut"
				DisplayName="Compiler Output"
				Category="Common"
				Subcategory="Compiler"
				Description="Sets the output file."
				Switch="-o" /> <!-- "[value]" -->

			<StringListProperty
				Name="Defines"
				DisplayName="Preprocessor Definitions"
				Category="Common"
				Description="Specifies one or more preprocessor defines."
				Switch="-D"
				RendererValueSeparator=";" /> <!-- [value] -->

			<StringListProperty
				Name="Include"
				DisplayName="Additional Include Directories"
				Category="Common"
				Description="Specifies one or more directories to add to the include path; use semi-colon delimited list if more than one. (/I[path])"
				Switch="-I"
				RendererValueSeparator=";" /> <!-- "[value]" -->

            <StringListProperty
                Name="AdditionalDeps"
                DisplayName="Source Dependencies"
                Category="Common"
                Description="Add additional source file dependencies. Dependencies that are #include'd do not have to be explicitly specified here."
                Switch="-f"
				RendererValueSeparator=";" /> <!-- "[value]" -->

			<StringProperty
				Name="MOCPath"
				DisplayName="Compiler Path"
				Category="Common"
				Description="Designated path to moc.exe."
				Switch="" /> <!-- "[value]" -->
<!--			Visible="false" -->
<!--			ReadOnly="true" -->

			<StringProperty
				Name="AdditionalOptions"
				DisplayName="Additional Options"
				Category="Command Line"
				Description="Additional Options" />

			<StringProperty
				Name="CommandLineTemplate"
				DisplayName="Command Line"
				Category="Command Line"
				ReadOnly="true"
				IncludeInCommandLine="False" />

		</Rule.Properties>
	</Rule>
</ProjectSchemaDefinitions>

Props:

Code: Alles auswählen

<?xml version="1.0" encoding="utf-8"?>
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
	
	<PropertyGroup>
		<QtMOCPath Condition="'$(QtMOCPath)' == ''">$(QTDIR)\bin\moc.exe</QtMOCPath>
	</PropertyGroup>

	<ItemDefinitionGroup>
		<QtCompile>
			<CompileOut>$(ProjectDir)GeneratedFiles\$(Configuration)\moc_%(Filename).cpp</CompileOut>
			<Defines>%(ClCompile.PreprocessorDefinitions)</Defines>
			<Include>%(ClCompile.AdditionalIncludeDirectories)</Include>
			<MOCPath>$(QtMOCPath)</MOCPath>
			<AdditionalDeps>%(Identity)</AdditionalDeps>
			<CommandLineTemplate>%(BuildCommandLineTemplate)</CommandLineTemplate>
		</QtCompile>
	</ItemDefinitionGroup>
	
</Project>

Targets:

Code: Alles auswählen

<?xml version="1.0" encoding="utf-8"?>
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

	<ItemGroup>
		<PropertyPageSchema Include="$(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml" />
		<AvailableItemName Include="QtCompile">
			<Targets>QtCompile</Targets>
		</AvailableItemName>
	</ItemGroup>

	<PropertyGroup>
		<QtCompileRulesPath>$(MSBuildThisFileDirectory)$(MSBuildThisFileName).xml</QtCompileRulesPath>
	</PropertyGroup>

	<Target Name="QtCompile" BeforeTargets="ClCompile"
		Condition="'@(QtCompile)' != ''"
        Inputs="@(QtCompile)"
        Outputs="@(QtCompile->'%(CompileOut)')">
		
		<Message Text="Compiling: %(QtCompile) using MOC" />
		<Exec Command="$(QtCompile.MOCPath)\moc.exe %(QtCompile.FullPath) %(QtCompile.CommandLineTemplate)"/>
	</Target>
	
</Project>

Dabei ist mir aufgefallen, dass die CUDA-Files wohl auch alles andere als sauber sind, für genauere Aussagen bin ich allerdings noch viel zu wenig mit MS Build vertraut.

[dot]

Ja, die CUDA Build Targets sehen mir alles andere als sauber und einfach aus. Ich hab dir mal einen Schnappschuss meines Shaderbuildsystems per PN geschickt. Ansonsten kannst du auch mal einen Blick auf das CUDA Build System, das ich für SoftShell gebaut hab werfen (findet sich unter tools/), das dürfte auf jeden Fall einfacher zu verstehen sein. Ich hab leider keine Zeit die Dinger zu dokumentieren, aber vielleicht hilft das schon was. Deine Versuche oben schauen mir aber auf den ersten Blick auch schonmal ganz gut aus...

[CodingCat]

Habe gerade mal reingesehen, dass da auch noch C# drinhängt, schreckt mich jetzt erst recht. ;) Nein, eigentlich sollte dieser ganze XML-Quark zur Hölle fahren, warum nicht gleich alles in lesbarem C#.

Im Moment scheitere ich daran, die Command-Line-Argumente mit %(QtCompile.CommandLineTemplate) im Target zu referenzieren, ich erhalte einfach einen leeren String. Davon abgesehen kann ich wohl auch nicht mit %(ClCompile.PreprocessorDefinitions) einfach auf die Eigenschaften anderer Targets zugreifen. Zum Heulen ist das. Ich verstehe überhaupt nicht, wo meine Variablen eigentlich herkommen, wann und ob sie existieren, wieso ich mit dem gleichen Identifier mal Listen und mal Elemente referenziere ...