reapi/reapi/build.gradle

import org.doomedsociety.gradlecpp.GradleCppUtils
import org.doomedsociety.gradlecpp.toolchain.icc.IccCompilerPlugin
import org.doomedsociety.gradlecpp.toolchain.icc.Icc
import org.doomedsociety.gradlecpp.cfg.ToolchainConfig
import org.doomedsociety.gradlecpp.msvc.MsvcToolchainConfig
import org.doomedsociety.gradlecpp.gcc.GccToolchainConfig
import org.doomedsociety.gradlecpp.cfg.ToolchainConfigUtils
import org.gradle.language.cpp.CppSourceSet
import org.gradle.language.rc.tasks.WindowsResourceCompile
import org.gradle.nativeplatform.NativeBinarySpec
import versioning.ReapiVersionInfo
import gradlecpp.VelocityUtils

apply plugin: 'cpp'
apply plugin: 'windows-resources'
apply plugin: IccCompilerPlugin
apply plugin: GccCompilerPlugin

List<Task> getRcCompileTasks(NativeBinarySpec binary) {
	def linkTask = GradleCppUtils.getLinkTask(binary)

	def res = linkTask.taskDependencies.getDependencies(linkTask).findAll { Task t -> t instanceof WindowsResourceCompile }
	return res as List
}

void postEvaluate(NativeBinarySpec b) {
	if (GradleCppUtils.windows) {
		getRcCompileTasks(b).each { Task t ->
			t.dependsOn project.generateAppVersion
		}
	} else {
		// attach generateAppVersion task to all 'compile source' tasks
		GradleCppUtils.getCompileTasks(b).each { Task t ->
			t.dependsOn project.generateAppVersion
		}
	}
}

void setupToolchain(NativeBinarySpec b) {
	boolean useGcc = project.hasProperty("useGcc")
	ToolchainConfig cfg = rootProject.createToolchainConfig(b)
	cfg.projectInclude(project, '', '/src', '/common', '/src/mods', '/src/natives', '/include', '/include/metamod', '/include/cssdk/common', '/include/cssdk/dlls', '/include/cssdk/engine', '/include/cssdk/game_shared', '/include/cssdk/pm_shared', '/include/cssdk/public')
	cfg.singleDefines('HAVE_STRONG_TYPEDEF');

	if (cfg instanceof MsvcToolchainConfig) {
		cfg.compilerOptions.pchConfig = new MsvcToolchainConfig.PrecompiledHeadersConfig(
			enabled: true,
			pchHeader: 'precompiled.h',
			pchSourceSet: 'reapi_pch'
		)
		cfg.compilerOptions.args '/Ob2', '/Oi', '/GF', '/GS-'
		cfg.singleDefines('_CRT_SECURE_NO_WARNINGS')
	} else if (cfg instanceof GccToolchainConfig) {
		if (!useGcc) {
			cfg.compilerOptions.pchConfig = new GccToolchainConfig.PrecompilerHeaderOptions(
				enabled: true,
				pchSourceSet: 'reapi_pch'
			)
		}
		cfg.compilerOptions.languageStandard = 'c++14'
		cfg.defines([
			'_stricmp': 'strcasecmp',
			'_strnicmp': 'strncasecmp',
			'_vsnprintf': 'vsnprintf',
			'_snprintf': 'snprintf'
		])

		if (useGcc) {
			cfg.compilerOptions.args '-fno-strict-aliasing', '-finline-functions'
		} else {
			cfg.compilerOptions.args '-Qoption,cpp,--treat_func_as_string_literal_cpp', '-inline-forceinline', '-no-ansi-alias'
		}

		cfg.linkerOptions.args '-Wl,--version-script=../version_script.lds', '-Wl,--gc-sections'
		cfg.compilerOptions.args '-ffunction-sections', '-fdata-sections' // Remove unused code and data

		cfg.compilerOptions.args '-Wall', '-Wno-unknown-pragmas', '-msse2', '-fomit-frame-pointer', '-fvisibility=default', '-fvisibility-inlines-hidden', '-g0', '-s', '-fno-exceptions'
	}

	ToolchainConfigUtils.apply(project, cfg, b)

	GradleCppUtils.onTasksCreated(project, 'postEvaluate', {
		postEvaluate(b)
	})
}

model {
	buildTypes {
		debug
		release
	}

	platforms {
		x86 {
			architecture "x86"
		}
	}

	toolChains {
		visualCpp(VisualCpp)
		if (project.hasProperty("useGcc")) {
			gcc(Gcc)
		} else {
			icc(Icc)
		}
	}

	components {
		reapi(NativeLibrarySpec) {
			targetPlatform 'x86'
			baseName GradleCppUtils.windows ? 'reapi_amxx' : 'reapi_amxx_i386'

			sources {
				reapi_pch(CppSourceSet) {
					source {
						srcDirs "src"
						include "precompiled.cpp"
					}

					exportedHeaders {
						srcDirs "include", "version"
					}
				}
				reapi_src(CppSourceSet) {
					source {
						srcDirs "src", "common", "include/cssdk/public"
						include "**/*.cpp"

						exclude "precompiled.cpp"
						exclude "engine_api.cpp", "tier0/dbg.cpp"
					}

					exportedHeaders {
						srcDirs "include", "version"
					}
				}
				rc {
					source {
						srcDir "msvc"
						include "reapi.rc"
					}
					exportedHeaders {
						srcDirs "msvc"
					}
				}
			}

			binaries.all {
				NativeBinarySpec b -> project.setupToolchain(b)
			}
		}
	}
}

afterEvaluate {
	project.binaries.all {
		NativeBinarySpec binary ->
		Tool linker = binary.linker

		if (GradleCppUtils.windows) {
			linker.args "/DEF:${projectDir}\\msvc\\reapi.def"
		}
	}
}

task buildFinalize << {
	if (GradleCppUtils.windows) {
		return;
	}

	binaries.withType(SharedLibraryBinarySpec) {
		def sharedBinary = it.getSharedLibraryFile();
		if (sharedBinary.exists()) {
			sharedBinary.renameTo(new File(sharedBinary.getParent() + "/" + sharedBinary.getName().replaceFirst("^lib", "")));
		}
	}
}

task buildRelease {
	dependsOn binaries.withType(SharedLibraryBinarySpec).matching { SharedLibraryBinarySpec blib ->
		blib.buildable && blib.buildType.name == 'release'
	}
	finalizedBy buildFinalize
}

tasks.clean.doLast {
	project.file('version/appversion.h').delete()
	project.file('version/reapi_version.inc').delete()
}

task generateAppVersion {

	ReapiVersionInfo verInfo = (ReapiVersionInfo) rootProject.reapiVersionInfo
	def tplversionFileInc = project.file('version/reapi_version.vm')
	def versionFileInc = project.file('version/reapi_version.inc')

	def tplversionFile = project.file('version/appversion.vm')
	def versionFile = project.file('version/appversion.h')

	inputs.file tplversionFile
	inputs.file tplversionFileInc
	inputs.file project.file('gradle.properties')
	outputs.file versionFile
	outputs.file versionFileInc

	println "##teamcity[buildNumber '" + verInfo.asMavenVersion(false) + "']";

	doLast {
	        def templateCtx = [
	                verInfo : verInfo
	        ]

		def versionContent = VelocityUtils.renderTemplate(tplversionFile, templateCtx)
		versionFile.delete()
		versionFile.write(versionContent, 'utf-8')

		def versionContentInc = VelocityUtils.renderTemplate(tplversionFileInc, templateCtx)
		versionFileInc.delete()
		versionFileInc.write(versionContentInc, 'utf-8')
	}
}