kotofyt/funnygame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

no engine anymore

Browse Source
This commit is contained in:
kotofyt
2025-07-30 23:53:26 +03:00
parent 8a29e6b86f
commit 395ced9e28
159 changed files with 2767 additions and 9484 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
fpc/Makefile
View File

@@ -1,5 +1,6 @@
TIER_FILES := ../tier0/lib.cpp ../tier0/mem.cpp ../tier0/platform.cpp ../tier1/utlbuffer.cpp ../tier1/utlstring.cpp ../tier1/utlvector.cpp ../tier1/utlmap.cpp ../tier1/commandline.cpp
FPC_FILES := main.cpp library/runner.cpp library/helper.cpp library/c.cpp library/ld.cpp library/target.cpp
# We want to build just enough to use other stuff
TIER_FILES := ../tier0/lib.cpp ../tier0/mem.cpp ../tier0/platform.cpp ../tier1/utlbuffer.cpp ../tier1/interface.cpp ../tier1/utlstring.cpp ../tier1/utlvector.cpp ../tier1/utlmap.cpp ../tier1/commandline.cpp
FPC_FILES := main.cpp library/runner.cpp library/helper.cpp library/c.cpp library/ld.cpp library/clang/c.cpp library/clang/ld.cpp library/target.cpp
CC = clang
OUTPUT_DIR = fpc
CCFLAGS = -I../public -Ipublic -lc -lstdc++

34
fpc/README Normal file
View File

@@ -0,0 +1,34 @@
funny project compiler
fpc is a simple project manager written in C++ without usage of STL.
Instead it uses C++ files for building stuff with quite simple API.
It also generates compile_commands.json.
basics cheat sheet
With this toolset it should be sufficient enough to build any simple application.
DECLARE_BUILD_STAGE( stage_name, function ) - Declares build stage
CProject - compiler output base;
CShaderProject - shader compiler output base (NOT IMPLEMENTED)
CCProject - C, C++, Objective-C, Objective-C++ compiler
CLDProject - linker
IFileSystem2 - simple filesystem for creating, deleting and copying stuff
usage parameters cheat sheet
-os - sets target kernel
windows
linux
macos
ios
android
-arch - sets target arch
x86_64
aarch64
-fpcdebug - shows shell command used to run the command

39
fpc/build.cpp
View File

@@ -5,20 +5,28 @@
#include "signal.h"
CUtlVector<CUtlString> g_CompiledFiles = {
"../tier0/lib.cpp",
"../tier0/mem.cpp",
"../tier0/platform.cpp",
"../tier1/interface.cpp",
"../tier1/utlbuffer.cpp",
"../tier1/utlstring.cpp",
"../tier1/utlvector.cpp",
"../tier1/utlmap.cpp",
"../tier1/commandline.cpp",
"main.cpp",
"library/runner.cpp",
"library/helper.cpp",
"library/c.cpp",
"library/ld.cpp",
"library/target.cpp",
"../tier0/lib.cpp",
"../tier0/mem.cpp",
"../tier0/platform.cpp",
"../tier1/utlbuffer.cpp",
"../tier1/utlstring.cpp",
"../tier1/utlvector.cpp",
"../tier1/utlmap.cpp",
"../tier1/commandline.cpp",
"library/android/apktool.cpp",
"library/clang/c.cpp",
"library/clang/ld.cpp",
};
CUtlVector<CUtlString> g_IncludeDirectories = {
@@ -27,21 +35,20 @@ CUtlVector<CUtlString> g_IncludeDirectories = {
};
int build_fpc()
DECLARE_BUILD_STAGE(fpc)
{
CCProject compileProject = {};
CLDProject ldProject = {};
CProject_t compileProject = {};
LinkProject_t ldProject = {};
compileProject.m_szName = "fpc";
compileProject.files = g_CompiledFiles;
compileProject.includeDirectories = g_IncludeDirectories;
ldProject = compileProject.Compile();
ldProject = ccompiler->Compile(&compileProject);
CUtlString outputProject = ldProject.Link();
CUtlString outputProject = linker->Link(&ldProject);
IFileSystem2::MakeDirectory("../build/tools");
IFileSystem2::CopyFile("fpc_temp", outputProject);
filesystem2->MakeDirectory("../build/tools");
filesystem2->CopyFile("fpc_temp", outputProject);
return 0;
};
DECLARE_BUILD_STAGE(fpc, build_fpc);

139
fpc/library/android/apktool.cpp Normal file
View File

@@ -0,0 +1,139 @@
#include "apktool.h"
#include "helper.h"
#include "tier0/lib.h"
#include "tier0/platform.h"
#include "tier1/commandline.h"
#include "tier1/interface.h"
#include "runner.h"
#include "tier1/utlstring.h"
#include "tier1/utlvector.h"
void AndroidManifest_t::SetPackageVersion( CUtlString szVersion )
{
m_szVersion = szVersion;
}
void AndroidManifest_t::SetPackageBuild( uint64_t nBuild )
{
m_nBuild = nBuild;
}
void AndroidManifest_t::SetPackageID( CUtlString szPackageID )
{
m_szPackageID = szPackageID;
}
void AndroidManifest_t::SetPackageName( CUtlString szPackageName )
{
m_szPackageName = szPackageName;
}
void AndroidManifest_t::SetTargetSDKVersion( uint64_t nTargetVersion )
{
m_nTargetVersion = nTargetVersion;
}
void AndroidManifest_t::SetMinSDKVersion( uint64_t nMinVersion )
{
m_nMinVersion = nMinVersion;
}
void AndroidManifest_t::AddUserFeature( CUtlString szName, bool bIsRequired, uint64_t nVersion )
{
}
void AndroidManifest_t::AddUserLibrary( CUtlString szPath )
{
}
CUtlString AndroidManifest_t::BuildManifest()
{
CPUProject_t project = {};
project.m_szName = m_szPackageName;
unsigned int hash = project.GenerateProjectHash();
CUtlString szOutputDir = CUtlString("%s/%s/android/%u_%s/",FPC_TEMPORAL_DIRNAME, project.m_target.GetTriplet().GetString(), hash, m_szPackageID.GetString());
filesystem2->MakeDirectory(szOutputDir);
filesystem2->MakeDirectory(CUtlString("%s/res", szOutputDir.GetString()));
CUtlString szAndroidManifestPath = CUtlString("%s/AndroidManifest.xml", szOutputDir.GetString());
FILE *pAndroidManifest = V_fopen(szAndroidManifestPath, "wb");
V_fprintf(pAndroidManifest, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n");
V_fprintf(pAndroidManifest, "<manifest xmlns:android=\"http://schemas.android.com/apk/res/android\" package=\"%s\">\n", m_szPackageID.GetString());
V_fprintf(pAndroidManifest, "<uses-sdk android:minSdkVersion=\"%lu\" android:targetSdkVersion=\"%lu\" />\n",m_nMinVersion, m_nTargetVersion);
V_fprintf(pAndroidManifest, "<application android:label=\"%s\" android:hasCode=\"false\" android:debuggable=\"true\">\n", m_szPackageName.GetString());
V_fprintf(pAndroidManifest, "<activity android:name=\"android.app.NativeActivity\" android:label=\"%s\" android:exported=\"true\">\n", m_szPackageName.GetString());
V_fprintf(pAndroidManifest, "<meta-data android:name=\"android.app.lib_name\" android:value=\"native-app\" />\n");
V_fprintf(pAndroidManifest, "<intent-filter>\n");
V_fprintf(pAndroidManifest, "<action android:name=\"android.intent.action.MAIN\" />\n");
V_fprintf(pAndroidManifest, "<category android:name=\"android.intent.category.LAUNCHER\" />\n");
V_fprintf(pAndroidManifest, "</intent-filter>\n");
V_fprintf(pAndroidManifest, "</activity>\n");
V_fprintf(pAndroidManifest, "</application>\n");
V_fprintf(pAndroidManifest, "</manifest>\n");
V_fclose(pAndroidManifest);
return szOutputDir;
};
class CAPKTool : public IAPKTool
{
public:
virtual CUtlString BuildPackage( AndroidManifest_t manifest, CUtlString szManifestDir ) override;
private:
};
CUtlString CAPKTool::BuildPackage( AndroidManifest_t manifest, CUtlString szManifestDir )
{
V_printf(" APKTOOL %s\n", manifest.m_szPackageID.GetString());
if (CommandLine()->ParamValue("-android_build_tools"))
{
CUtlVector<CUtlString> args = {
"package",
"-f",
"-M",
"AndroidManifest.xml",
"-S",
"res",
"-I",
CUtlString("%s/../../platforms/android-%lu/android.jar", CommandLine()->ParamValue("-android_build_tools"), manifest.m_nTargetVersion),
"-F",
CUtlString("%s.unaligned.apk", manifest.m_szPackageID.GetString()),
};
CUtlString szAndroidSDK = CommandLine()->ParamValue("-android_build_tools");
runner->Run(CUtlString("%s/aapt",szAndroidSDK.GetString()),szManifestDir,args);
runner->Wait();
args = {
"-u",
CUtlString("%s.unaligned.apk", manifest.m_szPackageID.GetString()),
"lib/x86_64/libnative-app.so",
};
runner->Run("zip",szManifestDir, args);
runner->Wait();
args = {
"-f",
"-v",
"4",
CUtlString("%s.unaligned.apk", manifest.m_szPackageID.GetString()),
CUtlString("%s.apk", manifest.m_szPackageID.GetString()),
};
runner->Run(CUtlString("%s/zipalign",szAndroidSDK.GetString()),szManifestDir,args);
} else
Plat_FatalErrorFunc("-android_build_tools was not specified.");
return 0;
}
IAPKTool *APKTool()
{
static CAPKTool s_apktool = {};
return &s_apktool;
}

23
fpc/library/android/signtool.cpp Normal file
View File

@@ -0,0 +1,23 @@
#include "signtool.h"
#include "tier0/platform.h"
#include "tier1/interface.h"
class CAndroidSignTool : public ISignTool
{
public:
virtual void SignFile( CUtlString szFile ) override;
virtual void SignDirectory( CUtlString szDirectory ) override;
};
EXPOSE_INTERFACE(CAndroidSignTool, ISignTool, ANDROID_SIGN_TOOL_INTERFACE_NAME);
void CAndroidSignTool::SignFile( CUtlString szFile )
{
}
void CAndroidSignTool::SignDirectory( CUtlString szDirectory )
{
V_printf("Android doesn't support signing of directories\n");
}

122
fpc/library/c.cpp
View File

@@ -1,123 +1,3 @@
#include "c.h"
#include "filesystem.h"
#include "helper.h"
#include "target.h"
#include "tier0/lib.h"
#include "tier0/platform.h"
#include "tier1/utlvector.h"
#include "libgen.h"
#include "ctype.h"
struct ClangFile_t
{
CUtlString m_szName;
CUtlVector<CUtlString> m_szArguments;
};
CUtlVector<ClangFile_t> g_clangFiles;
CLDProject CCProject::Compile()
{
CLDProject proj = {};
proj.m_szName = m_szName;
unsigned int hash = GenerateProjectHash();
for (auto &file: files)
{
CUtlString szTarget = m_target.GetTriplet();
CUtlString szOutputFile = CUtlString("%s/%s/cc/%u_%s/%s/%s.o",FPC_TEMPORAL_DIRNAME, szTarget.GetString(), hash, m_szName.GetString(), IFileSystem2::BuildDirectory(), file.GetString());
CUtlString szOutputDir = szOutputFile;
szOutputDir = dirname(szOutputDir);
IFileSystem2::MakeDirectory(szOutputDir);
}
for (auto &file: files)
{
CUtlVector<CUtlString> args;
V_printf(" CC %s\n", file.GetString());
CUtlString szTarget = m_target.GetTriplet();
CUtlString szOutputFile = CUtlString("%s/%s/cc/%u_%s/%s/%s.o",FPC_TEMPORAL_DIRNAME, szTarget.GetString(), hash, m_szName.GetString(), IFileSystem2::BuildDirectory(), file.GetString());
args = {
"-target",
szTarget,
"-g",
"-c",
"-o",
szOutputFile,
file,
};
if (!strcmp(Plat_GetExtension(file),"cpp"))
args.AppendTail("-std=c++17");
else if (!strcmp(Plat_GetExtension(file),"mm"))
;
else
args.AppendTail("-std=c99");
if (m_target.kernel == TARGET_KERNEL_DARWIN)
{
args.AppendTail("-isysroot");
args.AppendTail("/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk");
}
if (m_target.kernel == TARGET_KERNEL_IOS)
{
args.AppendTail("-isysroot");
args.AppendTail("/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk");
args.AppendTail("-miphoneos-version-min=18.0 ");
args.AppendTail("-fembed-bitcode");
}
if (bFPIC)
args.AppendTail("-fPIC");
if (bFPIE)
args.AppendTail("-fPIE");
for (auto &macro: macros)
{
args.AppendTail("-D");
args.AppendTail(CUtlString("%s=%s", (char*)macro.szName, (char*)macro.szValue));
}
for (auto &include: includeDirectories)
{
args.AppendTail("-I");
args.AppendTail(include);
}
for (auto &include: includeFiles)
{
args.AppendTail("-include");
args.AppendTail(include);
}
if (!IFileSystem2::ShouldRecompile(file, szOutputFile))
goto skipcompile;
IRunner::Run("clang", args);
skipcompile:
proj.objects.AppendTail((CObject){szOutputFile});
ClangFile_t cfile = {};
cfile.m_szName = file;
cfile.m_szArguments = args;
g_clangFiles.AppendTail(cfile);
}
return proj;
}
void CCProject::GenerateCompileCommands()
{
FILE* f = V_fopen("compile_commands.json", "w");
V_fprintf(f, "[\n");
uint32_t i = 0;
for (auto &file: g_clangFiles)
{
V_fprintf(f, "\t{\n");
V_fprintf(f, "\t\t\"arguments\": [\n");
V_fprintf(f, "\t\t\t\"clang\",\n");
for (auto &arg: file.m_szArguments)
V_fprintf(f, "\t\t\t\"%s\",\n",arg.GetString());
V_fseek(f, -2, SEEK_CUR);
V_fprintf(f, "\n\t\t],\n");
V_fprintf(f, "\t\t\"file\": \"%s\",\n", file.m_szName.GetString());
V_fprintf(f, "\t\t\"directory\": \"%s\"\n", IFileSystem2::BuildDirectory());
V_fprintf(f, "\t},\n");
};
V_fseek(f, -2, SEEK_CUR);
V_fprintf(f, "\n]\n");
V_fclose(f);
};
ICCompiler *ccompiler;

164
fpc/library/clang/c.cpp Normal file
View File

@@ -0,0 +1,164 @@
#include "c.h"
#include "helper.h"
#include "obj.h"
#include "target.h"
#include "tier0/lib.h"
#include "tier0/platform.h"
#include "tier1/interface.h"
#include "tier1/utlstring.h"
#include "tier1/utlvector.h"
#include "libgen.h"
#include "ctype.h"
struct ClangFile_t
{
CUtlString m_szName;
CUtlVector<CUtlString> m_szArguments;
};
class CClangCompiler : public ICCompiler
{
public:
virtual LinkProject_t Compile( CProject_t *pProject ) override;
virtual void GenerateLinterData( void ) override;
};
EXPOSE_INTERFACE(CClangCompiler, ICCompiler, CLANG_C_COMPILER_INTERFACE_NAME);
CUtlVector<ClangFile_t> g_clangFiles;
LinkProject_t CClangCompiler::Compile( CProject_t *pProject )
{
LinkProject_t proj = {};
proj.m_szName = pProject->m_szName;
proj.m_target = pProject->m_target;
proj.m_androidmanifest = pProject->m_androidmanifest;
unsigned int hash = pProject->GenerateProjectHash();
for (auto &file: pProject->files)
{
CUtlString szTarget = pProject->m_target.GetTriplet();
CUtlString szOutputFile = CUtlString("%s/%s/cc/%u_%s/%s/%s.o",FPC_TEMPORAL_DIRNAME, szTarget.GetString(), hash, pProject->m_szName.GetString(), filesystem2->BuildDirectory(), file.GetString());
CUtlString szOutputDir = szOutputFile;
szOutputDir = dirname(szOutputDir);
filesystem2->MakeDirectory(szOutputDir);
}
for (auto &file: pProject->files)
{
CUtlVector<CUtlString> args;
V_printf(" CC %s\n", file.GetString());
CUtlString szTarget = pProject->m_target.GetTriplet();
CUtlString szCompiledTarget = szTarget;
if (pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
{
szCompiledTarget = CUtlString("%s%u", szTarget.GetString(), pProject->m_androidmanifest.m_nTargetVersion);
}
CUtlString szOutputFile = CUtlString("%s/%s/cc/%u_%s/%s/%s.o",FPC_TEMPORAL_DIRNAME, szTarget.GetString(), hash, pProject->m_szName.GetString(), filesystem2->BuildDirectory(), file.GetString());
args = {
"-target",
szCompiledTarget,
"-g",
"-c",
"-o",
szOutputFile,
file,
};
if (!strcmp(Plat_GetExtension(file),"cpp"))
args.AppendTail("-std=c++17");
else if (!strcmp(Plat_GetExtension(file),"mm"))
;
else
args.AppendTail("-std=c99");
if (pProject->m_target.kernel == TARGET_KERNEL_DARWIN)
{
args.AppendTail("-isysroot");
args.AppendTail("/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk");
} else if (pProject->m_target.kernel == TARGET_KERNEL_IOS)
{
args.AppendTail("-isysroot");
args.AppendTail("/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk");
args.AppendTail("-miphoneos-version-min=18.0 ");
args.AppendTail("-fembed-bitcode");
}
if (pProject->m_target.szSysroot)
{
args.AppendTail(CUtlString("--sysroot=%s", pProject->m_target.szSysroot));
}
if (pProject->bFPIC)
args.AppendTail("-fPIC");
if (pProject->bFPIE)
args.AppendTail("-fPIE");
for (auto &macro: pProject->macros)
{
args.AppendTail("-D");
args.AppendTail(CUtlString("%s=%s", (char*)macro.szName, (char*)macro.szValue));
}
for (auto &include: pProject->includeDirectories)
{
args.AppendTail("-I");
args.AppendTail(include);
}
for (auto &include: pProject->includeFiles)
{
args.AppendTail("-include");
args.AppendTail(include);
}
if (!filesystem2->ShouldRecompile(file, szOutputFile))
goto skipcompile;
if (pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
{
if (!pProject->m_target.szSysroot)
Plat_FatalErrorFunc("-sysroot must be specified for android\n");
runner->Run(CUtlString("%s/bin/clang",pProject->m_target.szSysroot), args);
}
else
{
runner->Run("clang", args);
}
skipcompile:
proj.objects.AppendTail((Object_t){szOutputFile});
ClangFile_t cfile = {};
cfile.m_szName = file;
cfile.m_szArguments = args;
if (pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
{
if (!pProject->m_target.szSysroot)
Plat_FatalErrorFunc("-sysroot must be specified for android\n");
cfile.m_szArguments.AppendHead(CUtlString("%s/bin/clang",pProject->m_target.szSysroot));
}
else
cfile.m_szArguments.AppendHead("clang");
g_clangFiles.AppendTail(cfile);
}
return proj;
}
void CClangCompiler::GenerateLinterData()
{
FILE* f = V_fopen("compile_commands.json", "wb");
V_fprintf(f, "[\n");
uint32_t i = 0;
for (auto &file: g_clangFiles)
{
V_fprintf(f, "\t{\n");
V_fprintf(f, "\t\t\"arguments\": [\n");
for (auto &arg: file.m_szArguments)
V_fprintf(f, "\t\t\t\"%s\",\n",arg.GetString());
V_fseek(f, -2, SEEK_CUR);
V_fprintf(f, "\n\t\t],\n");
V_fprintf(f, "\t\t\"file\": \"%s\",\n", file.m_szName.GetString());
V_fprintf(f, "\t\t\"directory\": \"%s\"\n", filesystem2->BuildDirectory());
V_fprintf(f, "\t},\n");
};
V_fseek(f, -2, SEEK_CUR);
V_fprintf(f, "\n]\n");
V_fclose(f);
};

175
fpc/library/clang/ld.cpp Normal file
View File

@@ -0,0 +1,175 @@
#include "ld.h"
#include "helper.h"
#include "libgen.h"
#include "target.h"
#include "tier0/platform.h"
#include "tier1/interface.h"
#include "tier1/utlstring.h"
class CClangLinker : public ILinker
{
public:
virtual CUtlString Link( LinkProject_t *pProject ) override;
};
EXPOSE_INTERFACE(CClangLinker, ILinker, CLANG_LINKER_INTERFACE_NAME);
CUtlString CClangLinker::Link( LinkProject_t *pProject )
{
CUtlString szFileName;
unsigned int hash = pProject->GenerateProjectHash();
switch(pProject->linkType)
{
case ELINK_EXECUTABLE:
if (pProject->m_target.kernel == TARGET_KERNEL_WINDOWS)
szFileName = CUtlString("%s.exe", pProject->m_szName.GetString());
else if (pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
szFileName = CUtlString("lib%s.so", pProject->m_szName.GetString());
else
szFileName = CUtlString("%s", pProject->m_szName.GetString());
break;
case ELINK_STATIC_LIBRARY:
szFileName = CUtlString("lib%s.a", pProject->m_szName.GetString());
break;
case ELINK_DYNAMIC_LIBRARY:
if (pProject->m_target.kernel == TARGET_KERNEL_DARWIN)
szFileName = CUtlString("lib%s.dylib", pProject->m_szName.GetString());
if (pProject->m_target.kernel == TARGET_KERNEL_LINUX)
szFileName = CUtlString("lib%s.so", pProject->m_szName.GetString());
break;
}
CUtlString szTarget = pProject->m_target.GetTriplet();
CUtlString szOutputFile = CUtlString("%s/%s/ld/%u_%s/%s",FPC_TEMPORAL_DIRNAME, szTarget.GetString(), hash, pProject->m_szName.GetString(), szFileName.GetString());
CUtlString szOutputDir = szOutputFile;
szOutputDir = dirname(szOutputDir);
filesystem2->MakeDirectory(szOutputDir);
if (pProject->linkType == ELINK_STATIC_LIBRARY)
{
V_printf(" AR %s\n", pProject->m_szName.GetString());
bool shouldRecompile = false;
CUtlVector<CUtlString> args;
for (auto object: pProject->objects)
{
if (filesystem2->ShouldRecompile(object.m_szObjectFile,szOutputFile))
{
shouldRecompile = true;
break;
}
}
if (!shouldRecompile)
goto compiled;
args = {
"rcs",
szOutputFile
};
for (auto object: pProject->objects)
args.AppendTail(object.m_szObjectFile);
runner->Run("ar", args);
runner->Wait();
} else {
V_printf(" LINK %s\n", pProject->m_szName.GetString());
bool shouldRecompile = false;
CUtlVector<CUtlString> args;
for (auto object: pProject->objects)
{
if (filesystem2->ShouldRecompile(object.m_szObjectFile,szOutputFile))
{
shouldRecompile = true;
break;
}
}
if (!shouldRecompile)
goto compiled;
CUtlString szTarget = pProject->m_target.GetTriplet();
CUtlString szCompiledTarget = szTarget;
if (pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
{
szCompiledTarget = CUtlString("%s%u", szTarget.GetString(), pProject->m_androidmanifest.m_nTargetVersion);
}
args = {
"-o",
szOutputFile,
"-target",
szCompiledTarget,
};
if (pProject->bNoStdLib)
{
args.AppendTail("-nostdlib");
}
if (pProject->m_target.kernel == TARGET_KERNEL_DARWIN)
{
args.AppendTail("-isysroot");
args.AppendTail("/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk");
args.AppendTail("-Wl,-export_dynamic");
args.AppendTail("-undefined");
args.AppendTail("dynamic_lookup");
}
else if (pProject->m_target.kernel == TARGET_KERNEL_IOS)
{
args.AppendTail("-isysroot");
args.AppendTail("/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk");
args.AppendTail("-miphoneos-version-min=18.0 ");
args.AppendTail("-fembed-bitcode");
args.AppendTail("-Wl,-rpath,@executable_path");
args.AppendTail("-Wl,-all_load");
args.AppendTail("-w");
}
else if (pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
{
args.AppendTail(CUtlString("--sysroot=%s/sysroot", pProject->m_target.szSysroot));
args.AppendTail("-static-libstdc++");
}
else if (pProject->m_target.szSysroot)
{
args.AppendTail(CUtlString("--sysroot=%s", pProject->m_target.szSysroot));
}
if (pProject->m_target.kernel == TARGET_KERNEL_WINDOWS)
{
args.AppendTail("-fuse-ld=ld");
}
if (pProject->m_target.kernel == TARGET_KERNEL_LINUX || pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
{
args.AppendTail("-rdynamic");
}
if (pProject->linkType == ELINK_DYNAMIC_LIBRARY || pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
{
args.AppendTail("-shared");
}
if (pProject->m_target.kernel == TARGET_KERNEL_WINDOWS || pProject->m_target.kernel == TARGET_KERNEL_LINUX || pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
args.AppendTail("-Wl,--whole-archive");
for (auto object: pProject->objects)
args.AppendTail(object.m_szObjectFile);
if (pProject->m_target.kernel == TARGET_KERNEL_WINDOWS || pProject->m_target.kernel == TARGET_KERNEL_LINUX || pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
args.AppendTail("-Wl,--no-whole-archive");
for (auto lib: pProject->libraries)
{
args.AppendTail("-l");
args.AppendTail(lib);
}
for (auto &directory: pProject->frameworkDirectories)
{
args.AppendTail("-F");
args.AppendTail(directory);
}
for (auto &framework: pProject->frameworks)
{
args.AppendTail("-framework");
args.AppendTail(framework);
}
if (pProject->m_target.kernel == TARGET_KERNEL_ANDROID)
{
if (!pProject->m_target.szSysroot)
Plat_FatalErrorFunc("-sysroot must be specified for android\n");
runner->Run(CUtlString("%s/bin/clang++",pProject->m_target.szSysroot), args);
}
else
{
runner->Run("clang++", args);
}
runner->Wait();
}
compiled:
return szOutputFile;
};

0
fpc/library/generator/makefile.cpp Normal file
View File

50
fpc/library/helper.cpp
View File

@@ -6,12 +6,13 @@
#include "unistd.h"
#include "libgen.h"
#include "sys/stat.h"
#include "tier1/interface.h"
#ifdef __APPLE__
#include <mach-o/dyld.h>
#endif
unsigned int g_hashState = 102851263;
unsigned int CProject::GenerateProjectHash( void )
unsigned int BaseProject_t::GenerateProjectHash( void )
{
unsigned int hash = 5381+g_hashState;
int c;
@@ -31,50 +32,65 @@ static ssize_t pathSize = readlink("/proc/self/exe", path, sizeof(path) - 1);
#endif
#ifdef __APPLE__
static uint32_t pathSize = sizeof(path);
int pathResult = _NSGetExecutablePath(path, &pathSize);
static int pathResult = _NSGetExecutablePath(path, &pathSize);
#endif
char *szPathDir = dirname(path);
char *szBuildDir = 0;
char *IFileSystem2::OwnDirectory()
static char *szPathDir = dirname(path);
char *g_szBuildDir = 0;
class CPOSIXFileSystem2: public IFileSystem2
{
public:
virtual char *OwnDirectory() override;
virtual char *BuildDirectory() override;
virtual void MakeDirectory( const char *psz ) override;
virtual void CopyFile( const char *szDestination, const char *szOrigin ) override;
virtual void CopyDirectory( const char *szDestination, const char *szOrigin ) override;
virtual bool ShouldRecompile( const char *szSource, const char *szOutput ) override;
};
EXPOSE_INTERFACE(CPOSIXFileSystem2, IFileSystem2, FILE_SYSTEM_2_INTERFACE_NAME);
IFileSystem2 *filesystem2;
char *CPOSIXFileSystem2::OwnDirectory()
{
return szPathDir;
};
char *IFileSystem2::BuildDirectory()
char *CPOSIXFileSystem2::BuildDirectory()
{
return szBuildDir;
return g_szBuildDir;
};
void IFileSystem2::CopyFile( const char *szDestination, const char *szOrigin )
void CPOSIXFileSystem2::CopyFile( const char *szDestination, const char *szOrigin )
{
CUtlVector<CUtlString> args = {
CUtlString(szOrigin),
CUtlString(szDestination),
};
IRunner::Run("cp", args);
IRunner::Wait();
runner->Run("cp", args);
runner->Wait();
}
void IFileSystem2::CopyDirectory( const char *szDestination, const char *szOrigin )
void CPOSIXFileSystem2::CopyDirectory( const char *szDestination, const char *szOrigin )
{
CUtlVector<CUtlString> args = {
"-r",
CUtlString(szOrigin),
CUtlString(szDestination),
};
IRunner::Run("cp", args);
IRunner::Wait();
runner->Run("cp", args);
runner->Wait();
}
void IFileSystem2::MakeDirectory( const char *psz )
void CPOSIXFileSystem2::MakeDirectory( const char *psz )
{
CUtlVector<CUtlString> args = {
"-p",
CUtlString(psz),
};
IRunner::Run("mkdir", args);
IRunner::Wait();
runner->Run("mkdir", args);
runner->Wait();
};
bool IFileSystem2::ShouldRecompile(const char *szSource, const char *szOutput)
bool CPOSIXFileSystem2::ShouldRecompile(const char *szSource, const char *szOutput)
{
struct stat srcbuf;
struct stat outbuf;

133
fpc/library/ld.cpp
View File

@@ -1,134 +1,3 @@
#include "ld.h"
#include "helper.h"
#include "libgen.h"
#include "target.h"
CUtlString CLDProject::Link( void )
{
CUtlString szFileName;
unsigned int hash = GenerateProjectHash();
switch(linkType)
{
case ELINK_EXECUTABLE:
if (m_target.kernel == TARGET_KERNEL_WINDOWS)
szFileName = CUtlString("%s.exe", m_szName.GetString());
else
szFileName = CUtlString("%s", m_szName.GetString());
break;
case ELINK_STATIC_LIBRARY:
szFileName = CUtlString("lib%s.a", m_szName.GetString());
break;
case ELINK_DYNAMIC_LIBRARY:
if (m_target.kernel == TARGET_KERNEL_DARWIN)
szFileName = CUtlString("lib%s.dylib", m_szName.GetString());
if (m_target.kernel == TARGET_KERNEL_LINUX)
szFileName = CUtlString("lib%s.so", m_szName.GetString());
break;
}
CUtlString szTarget = m_target.GetTriplet();
CUtlString szOutputFile = CUtlString("%s/%s/ld/%u_%s/%s",FPC_TEMPORAL_DIRNAME, szTarget.GetString(), hash, m_szName.GetString(), szFileName.GetString());
CUtlString szOutputDir = szOutputFile;
szOutputDir = dirname(szOutputDir);
IFileSystem2::MakeDirectory(szOutputDir);
if (linkType == ELINK_STATIC_LIBRARY)
{
V_printf(" AR %s\n", m_szName.GetString());
bool shouldRecompile = false;
CUtlVector<CUtlString> args;
for (auto object: objects)
{
if (IFileSystem2::ShouldRecompile(object.m_szObjectFile,szOutputFile))
{
shouldRecompile = true;
break;
}
}
if (!shouldRecompile)
goto compiled;
args = {
"rcs",
szOutputFile
};
for (auto object: objects)
args.AppendTail(object.m_szObjectFile);
IRunner::Run("ar", args);
IRunner::Wait();
} else {
V_printf(" LINK %s\n", m_szName.GetString());
bool shouldRecompile = false;
CUtlVector<CUtlString> args;
for (auto object: objects)
{
if (IFileSystem2::ShouldRecompile(object.m_szObjectFile,szOutputFile))
{
shouldRecompile = true;
break;
}
}
if (!shouldRecompile)
goto compiled;
args = {
"-o",
szOutputFile,
"-target",
m_target.GetTriplet(),
};
if (m_target.kernel == TARGET_KERNEL_DARWIN)
{
args.AppendTail("-isysroot");
args.AppendTail("/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk");
args.AppendTail("-Wl,-export_dynamic");
args.AppendTail("-undefined");
args.AppendTail("dynamic_lookup");
}
if (m_target.kernel == TARGET_KERNEL_IOS)
{
args.AppendTail("-isysroot");
args.AppendTail("/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk");
args.AppendTail("-miphoneos-version-min=18.0 ");
args.AppendTail("-fembed-bitcode");
args.AppendTail("-Wl,-rpath,@executable_path");
args.AppendTail("-Wl,-all_load");
args.AppendTail("-w");
}
if (m_target.kernel == TARGET_KERNEL_WINDOWS)
{
args.AppendTail("-fuse-ld=ld");
}
if (m_target.kernel == TARGET_KERNEL_LINUX)
{
args.AppendTail("-rdynamic");
}
if (linkType == ELINK_DYNAMIC_LIBRARY)
{
args.AppendTail("-shared");
}
if (m_target.kernel == TARGET_KERNEL_WINDOWS || m_target.kernel == TARGET_KERNEL_LINUX)
args.AppendTail("-Wl,--whole-archive");
for (auto object: objects)
args.AppendTail(object.m_szObjectFile);
if (m_target.kernel == TARGET_KERNEL_WINDOWS || m_target.kernel == TARGET_KERNEL_LINUX)
args.AppendTail("-Wl,--no-whole-archive");
for (auto lib: libraries)
{
args.AppendTail("-l");
args.AppendTail(lib);
}
for (auto &directory: frameworkDirectories)
{
args.AppendTail("-F");
args.AppendTail(directory);
}
for (auto &framework: frameworks)
{
args.AppendTail("-framework");
args.AppendTail(framework);
}
IRunner::Run("clang++", args);
IRunner::Wait();
}
compiled:
return szOutputFile;
};
ILinker *linker;

34
fpc/library/runner.cpp
View File

@@ -1,5 +1,6 @@
#include "runner.h"
#include "tier0/platform.h"
#include "tier1/interface.h"
#include "tier1/utlstring.h"
#include "tier1/utlvector.h"
#include "unistd.h"
@@ -7,7 +8,20 @@
#include "tier1/commandline.h"
CUtlVector<pid_t> g_processes;
int IRunner::Run(CUtlString szName, CUtlVector<CUtlString>& args)
class CPOSIXRunner: public IRunner
{
public:
virtual int Run( CUtlString szName, CUtlVector<CUtlString>& args ) override;
virtual int Run( CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlString>& args ) override;
virtual int Run( CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlString>& args, CUtlVector<CUtlString>& environment ) override;
virtual int Wait( void ) override;
};
EXPOSE_INTERFACE(CPOSIXRunner, IRunner, RUNNER_INTERFACE_NAME);
IRunner *runner;
int CPOSIXRunner::Run(CUtlString szName, CUtlVector<CUtlString>& args)
{
pid_t pid = fork();
if (pid < 0)
@@ -17,15 +31,15 @@ int IRunner::Run(CUtlString szName, CUtlVector<CUtlString>& args)
{
CUtlVector<const char*> execargs;
execargs.AppendTail(szName);
if (ICommandLine::CheckParam("-fpcdebug"))
if (CommandLine()->CheckParam("-fpcdebug"))
V_printf("%s",szName.GetString());
for (auto &arg: args)
{
execargs.AppendTail(arg);
if (ICommandLine::CheckParam("-fpcdebug"))
if (CommandLine()->CheckParam("-fpcdebug"))
V_printf(" %s",arg.GetString());
}
if (ICommandLine::CheckParam("-fpcdebug"))
if (CommandLine()->CheckParam("-fpcdebug"))
V_printf("\n");
execargs.AppendTail(0);
if ( execvp(szName, (char *const*)execargs.GetData()) == -1 )
@@ -38,7 +52,7 @@ int IRunner::Run(CUtlString szName, CUtlVector<CUtlString>& args)
return 0;
}
int IRunner::Run(CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlString>& args)
int CPOSIXRunner::Run(CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlString>& args)
{
pid_t pid = fork();
if (pid < 0)
@@ -48,10 +62,16 @@ int IRunner::Run(CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlStrin
{
CUtlVector<const char*> execargs;
execargs.AppendTail(szName);
if (CommandLine()->CheckParam("-fpcdebug"))
V_printf("%s",szName.GetString());
for (auto &arg: args)
{
execargs.AppendTail(arg);
if (CommandLine()->CheckParam("-fpcdebug"))
V_printf(" %s",arg.GetString());
}
if (CommandLine()->CheckParam("-fpcdebug"))
V_printf("\n");
execargs.AppendTail(0);
chdir(szDirectory.GetString());
if ( execvp(szName, (char *const*)execargs.GetData()) == -1 )
@@ -65,12 +85,12 @@ int IRunner::Run(CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlStrin
return 0;
}
int IRunner::Run(CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlString>& args, CUtlVector<CUtlString>& environment)
int CPOSIXRunner::Run(CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlString>& args, CUtlVector<CUtlString>& environment)
{
}
int IRunner::Wait( void )
int CPOSIXRunner::Wait( void )
{
for (auto &process: g_processes)
{

36
fpc/library/target.cpp
View File

@@ -1,8 +1,10 @@
#include "target.h"
#include "tier1/commandline.h"
#include "tier1/utlstring.h"
//-----------------------------------------------------------------------------
// Generates triplet suitable for most compilers.
//-----------------------------------------------------------------------------
CUtlString Target_t::GetTriplet()
{
CUtlString triplet = "";
@@ -11,15 +13,25 @@ CUtlString Target_t::GetTriplet()
triplet.AppendTail("x86_64");
if ( cpu == TARGET_CPU_AARCH64 )
triplet.AppendTail("aarch64");
if ( cpu == TARGET_CPU_WASM32 )
triplet.AppendTail("wasm32");
triplet.AppendTail("-");
if ( kernel == TARGET_KERNEL_WINDOWS )
triplet.AppendTail("pc-windows-gnu");
if ( kernel == TARGET_KERNEL_UNKNOWN )
triplet.AppendTail("unknown-unknown");
if ( kernel == TARGET_KERNEL_LINUX )
triplet.AppendTail("unknown-linux-gnu");
if ( kernel == TARGET_KERNEL_WINDOWS )
triplet.AppendTail("pc-windows-gnu");
if ( kernel == TARGET_KERNEL_DARWIN )
triplet.AppendTail("apple-darwin");
if ( kernel == TARGET_KERNEL_IOS )
triplet.AppendTail("apple-ios");
if ( kernel == TARGET_KERNEL_ANDROID )
triplet.AppendTail("linux-android");
if ( kernel == TARGET_KERNEL_WASI )
triplet.AppendTail("unknown-wasi");
if ( kernel == TARGET_KERNEL_EMSCRIPTEN )
triplet.AppendTail("unknown-emscripten");
return triplet;
@@ -40,11 +52,15 @@ Target_t Target_t::HostTarget()
.optimization = TARGET_DEBUG,
};
};
//-----------------------------------------------------------------------------
// Returns default target for build
//-----------------------------------------------------------------------------
Target_t Target_t::DefaultTarget()
{
CUtlString szDevice = ICommandLine::ParamValue("-device");
CUtlString szOS = ICommandLine::ParamValue("-os");
CUtlString szArch = ICommandLine::ParamValue("-arch");
CUtlString szDevice = CommandLine()->ParamValue("-device");
CUtlString szOS = CommandLine()->ParamValue("-os");
CUtlString szArch = CommandLine()->ParamValue("-arch");
ETargetKernel kernel =
#if defined(__linux__)
@@ -58,8 +74,12 @@ Target_t Target_t::DefaultTarget()
cpu = TARGET_CPU_AMD64;
else if ( szArch == "aarch64" )
cpu = TARGET_CPU_AARCH64;
else if ( szArch == "wasm32" )
cpu = TARGET_CPU_WASM32;
if ( szOS == "windows" )
if ( szOS == "unknown" )
kernel = TARGET_KERNEL_UNKNOWN;
else if ( szOS == "windows" )
kernel = TARGET_KERNEL_WINDOWS;
else if ( szOS == "linux" )
kernel = TARGET_KERNEL_LINUX;
@@ -67,6 +87,8 @@ Target_t Target_t::DefaultTarget()
kernel = TARGET_KERNEL_DARWIN;
else if ( szOS == "ios" )
kernel = TARGET_KERNEL_IOS;
else if ( szOS == "android" )
kernel = TARGET_KERNEL_ANDROID;
else if ( szOS != 0 )
V_printf("Unknown OS: %s\n", szOS.GetString());

0
fpc/library/windows/windres.cpp Normal file
View File

31
fpc/main.cpp
View File

@@ -2,34 +2,43 @@
#include "public/helper.h"
#include "public/ld.h"
#include "public/target.h"
#include "runner.h"
#include "tier0/platform.h"
#include "tier1/commandline.h"
#include "c.h"
#include "tier1/interface.h"
#include "tier1/utlvector.h"
#include "signal.h"
#include "libgen.h"
#include <unistd.h>
CUtlString owndir;
extern char *g_szBuildDir;
int build()
{
extern char *szBuildDir;
CCProject compileScriptProject = {};
runner = (IRunner*)CreateInterface(RUNNER_INTERFACE_NAME, NULL);
filesystem2 = (IFileSystem2*)CreateInterface(FILE_SYSTEM_2_INTERFACE_NAME, NULL);
ccompiler = (ICCompiler*)CreateInterface(CLANG_C_COMPILER_INTERFACE_NAME, NULL);
linker = (ILinker*)CreateInterface(CLANG_LINKER_INTERFACE_NAME, NULL);
CProject_t compileScriptProject = {};
compileScriptProject.m_szName = "build";
compileScriptProject.files = {"build.cpp"};
compileScriptProject.includeDirectories = {CUtlString("%s/public",IFileSystem2::OwnDirectory()),CUtlString("%s/public", IFileSystem2::BuildDirectory()), CUtlString("%s/../public",IFileSystem2::OwnDirectory()),CUtlString("%s/../public", IFileSystem2::BuildDirectory())};
compileScriptProject.includeDirectories = {CUtlString("%s/public",filesystem2->OwnDirectory()),CUtlString("%s/public", filesystem2->BuildDirectory()), CUtlString("%s/../public",filesystem2->OwnDirectory()),CUtlString("%s/../public", filesystem2->BuildDirectory())};
compileScriptProject.bFPIC = true;
compileScriptProject.m_target = Target_t::HostTarget();
CLDProject linkScriptProject = compileScriptProject.Compile();
LinkProject_t linkScriptProject = ccompiler->Compile(&compileScriptProject);
linkScriptProject.linkType = ELINK_DYNAMIC_LIBRARY;
linkScriptProject.m_target = Target_t::HostTarget();
CUtlString script = linkScriptProject.Link();
CUtlString script = linker->Link(&linkScriptProject);
void *scriptDLL = Plat_LoadLibrary(script);
auto PreinitFn = (void(*)())Plat_GetProc(scriptDLL, "Preinit");
V_printf("%p\n",PreinitFn);
if (PreinitFn)
PreinitFn();
@@ -38,7 +47,8 @@ int build()
build->m_pMainFn();
};
Plat_UnloadLibrary(scriptDLL);
CCProject::GenerateCompileCommands();
ccompiler->GenerateLinterData();
return 0;
};
@@ -80,8 +90,7 @@ findbuild:
} else {
V_fclose(file);
}
extern char *szBuildDir;
szBuildDir = szBuildcppDir;
g_szBuildDir = szBuildcppDir;
#ifdef __linux
signal(SIGHUP, IEngine_Signal);
@@ -95,8 +104,8 @@ findbuild:
signal(SIGSEGV, IEngine_Signal);
signal(SIGTERM, IEngine_Signal);
#endif
ICommandLine::CreateCommandLine(c, v);
if (ICommandLine::CheckParam("build"))
CommandLine()->CreateCommandLine(c, v);
if (CommandLine()->CheckParam("build"))
return build();
return 0;
};

39
fpc/public/apktool.h Normal file
View File

@@ -0,0 +1,39 @@
#ifndef APK_TOOL_H
#define APK_TOOL_H
#include "tier0/platform.h"
#include "tier1/utlstring.h"
struct AndroidManifest_t
{
public:
void SetPackageVersion( CUtlString szVersion );
void SetPackageBuild( uint64_t nBuild );
void SetPackageID( CUtlString szPackageID );
void SetPackageName( CUtlString szPackageName );
void SetTargetSDKVersion( uint64_t nTargetVersion );
void SetMinSDKVersion( uint64_t nMinVersion );
void AddUserFeature( CUtlString szName, bool bIsRequired, uint64_t nVersion );
void AddUserLibrary( CUtlString szPath );
CUtlString BuildManifest();
CUtlString m_szPackageName;
CUtlString m_szPackageID;
uint64_t m_nBuild;
CUtlString m_szVersion;
uint64_t m_nTargetVersion;
uint64_t m_nMinVersion;
};
abstract_class IAPKTool
{
public:
virtual CUtlString BuildPackage( AndroidManifest_t manifest, CUtlString szManifestDir ) = 0;
};
IAPKTool *APKTool();
#endif

26
fpc/public/c.h
View File

@@ -1,6 +1,7 @@
#ifndef C_H
#define C_H
#include "tier0/platform.h"
#include "tier1/utlstring.h"
#include "tier1/utlvector.h"
#include "runner.h"
@@ -35,20 +36,35 @@ enum ECPPVersion
CPPVERSION_2C = 6,
};
class CCProject : public CProject
struct CProject_t : public CPUProject_t
{
public:
CUtlVector<CUtlString> files = {};
CUtlVector<C_Macro_t> macros = {};
CUtlVector<CUtlString> includeDirectories = {};
CUtlVector<CUtlString> includeFiles = {};
CUtlVector<C_Macro_t> macros = {};
bool bFPIE = false;
bool bFPIC = false;
bool bDebug = m_target.optimization == TARGET_DEBUG;
ECVersion cVersion;
ECPPVersion cppVersion;
CLDProject Compile();
static void GenerateCompileCommands();
AndroidManifest_t m_androidmanifest;
};
#define C_COMPILER_INTERFACE_NAME "CCompiler001"
#define CLANG_C_COMPILER_INTERFACE_NAME "ClangCCompiler001"
#define GCC_C_COMPILER_INTERFACE_NAME "GCCCCompiler001"
#define MSVC_C_COMPILER_INTERFACE_NAME "MSVCCCompiler001"
abstract_class ICCompiler
{
public:
virtual LinkProject_t Compile( CProject_t *pProject ) = 0;
virtual void GenerateLinterData( void ) = 0;
};
extern ICCompiler *ccompiler;
#endif

56
fpc/public/helper.h
View File

@@ -1,30 +1,62 @@
#ifndef HELPER_H
#define HELPER_H
#include "apktool.h"
#include "tier1/utlstring.h"
#include "target.h"
#define FPC_TEMPORAL_DIRNAME ".fpc"
class CProject
struct BaseProject_t
{
public:
Target_t m_target = Target_t::DefaultTarget();
CUtlString m_szName;
unsigned int GenerateProjectHash( void );
};
interface IFileSystem2
struct CPUProject_t : public BaseProject_t
{
public:
static char *OwnDirectory();
static char *BuildDirectory();
static void MakeDirectory( const char *psz );
static void CopyFile( const char *szDestination, const char *szOrigin );
static void CopyDirectory( const char *szDestination, const char *szOrigin );
static bool ShouldRecompile( const char *szSource, const char *szOutput );
Target_t m_target = Target_t::DefaultTarget();
};
struct ShaderProject_t : public BaseProject_t
{
public:
EShaderTarget m_eTarget;
};
//-----------------------------------------------------------------------------
// File system.
//-----------------------------------------------------------------------------
#define FILE_SYSTEM_2_INTERFACE_NAME "FileSystem2_001"
abstract_class IFileSystem2
{
public:
// Returns a directory of fpc executable
virtual char *OwnDirectory() = 0;
// Returns directory of build.cpp
virtual char *BuildDirectory() = 0;
virtual void MakeDirectory( const char *psz ) = 0;
virtual void CopyFile( const char *szDestination, const char *szOrigin ) = 0;
virtual void CopyDirectory( const char *szDestination, const char *szOrigin ) = 0;
virtual bool ShouldRecompile( const char *szSource, const char *szOutput ) = 0;
};
extern IFileSystem2 *filesystem2;
//-----------------------------------------------------------------------------
// Build stage.
//-----------------------------------------------------------------------------
class CBuildStage
{
public:
@@ -33,8 +65,10 @@ public:
int(*m_pMainFn)();
};
#define DECLARE_BUILD_STAGE(sz, fn) \
CBuildStage __##sz##_build_stage(#sz, fn);
#define DECLARE_BUILD_STAGE(sz) \
int __build_stage_##sz(); \
CBuildStage __##sz##_build_stage(#sz, __build_stage_##sz); \
int __build_stage_##sz()
CUtlVector<CBuildStage*>& BuildStages();

25
fpc/public/ld.h
View File

@@ -5,6 +5,7 @@
#include "runner.h"
#include "helper.h"
#include "obj.h"
#include "tier0/platform.h"
#include "tier1/utlstring.h"
enum ELinkType
@@ -14,22 +15,32 @@ enum ELinkType
ELINK_STATIC_LIBRARY,
};
class CLDProject: public CProject
struct LinkProject_t: public CPUProject_t
{
public:
void AddObject( CObject& object );
void AddLibrary( CUtlString psz );
void AddLibraryByPath( CUtlString szPath );
void AddLibraryDirectory( CUtlString szPath );
CUtlString Link( void );
void AddObject( Object_t& object );
ELinkType linkType;
CUtlVector<CObject> objects = {};
CUtlVector<Object_t> objects = {};
CUtlVector<CUtlString> libraries ={};
CUtlVector<CUtlString> libraryDirectories = {};
CUtlVector<CUtlString> libraryObjects = {};
CUtlVector<CUtlString> frameworkDirectories = {};
CUtlVector<CUtlString> frameworks = {};
AndroidManifest_t m_androidmanifest;
bool bNoStdLib;
};
#define LINKER_INTERFACE_NAME "Linker001"
#define CLANG_LINKER_INTERFACE_NAME "ClangLinker001"
abstract_class ILinker
{
public:
virtual CUtlString Link( LinkProject_t *pProject ) = 0;
};
extern ILinker *linker;
#endif

2
fpc/public/obj.h
View File

@@ -3,7 +3,7 @@
#include "tier1/utlstring.h"
class CObject
struct Object_t
{
public:
CUtlString m_szObjectFile;

15
fpc/public/runner.h
View File

@@ -1,16 +1,21 @@
#ifndef RUNNER_H
#define RUNNER_H
#include "tier0/platform.h"
#include "tier1/utlvector.h"
#include "tier1/utlstring.h"
interface IRunner
#define RUNNER_INTERFACE_NAME "Runner001"
abstract_class IRunner
{
public:
static int Run( CUtlString szName, CUtlVector<CUtlString>& args );
static int Run( CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlString>& args );
static int Run( CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlString>& args, CUtlVector<CUtlString>& environment );
static int Wait( void );
virtual int Run( CUtlString szName, CUtlVector<CUtlString>& args ) = 0;
virtual int Run( CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlString>& args ) = 0;
virtual int Run( CUtlString szName, CUtlString szDirectory, CUtlVector<CUtlString>& args, CUtlVector<CUtlString>& environment ) = 0;
virtual int Wait( void ) = 0;
};
extern IRunner *runner;
#endif

21
fpc/public/signtool.h Normal file
View File

@@ -0,0 +1,21 @@
#ifndef SIGN_TOOL_H
#define SIGN_TOOL_H
#include "tier0/platform.h"
#include "tier1/utlstring.h"
#define APPLE_SIGN_TOOL_INTERFACE_NAME "SignToolApple001"
#define ANDROID_SIGN_TOOL_INTERFACE_NAME "SignToolAndroid001"
abstract_class ISignTool
{
public:
virtual void SetSignPassword( CUtlString szPassword ) = 0;
virtual void SignFile( CUtlString szFile ) = 0;
virtual void SignDirectory( CUtlString szDirectory ) = 0;
};
extern ISignTool *signtool_android;
extern ISignTool *signtool_apple;
#endif

0
fpc/public/slang.h Normal file
View File

22
fpc/public/target.h
View File

@@ -2,20 +2,30 @@
#define TARGET_T
#include "tier1/utlstring.h"
#include "tier1/commandline.h"
enum ETargetKernel
{
TARGET_KERNEL_UNKNOWN,
TARGET_KERNEL_LINUX,
TARGET_KERNEL_WINDOWS,
TARGET_KERNEL_DARWIN,
TARGET_KERNEL_IOS,
TARGET_KERNEL_ANDROID,
TARGET_KERNEL_WASI,
TARGET_KERNEL_EMSCRIPTEN,
};
enum ETargetCPU
{
TARGET_CPU_AMD64,
TARGET_CPU_I286,
TARGET_CPU_I386,
TARGET_CPU_I486,
TARGET_CPU_I586,
TARGET_CPU_I686,
TARGET_CPU_AARCH64,
TARGET_CPU_WASM32,
};
enum ETargetOptimization
@@ -30,9 +40,21 @@ struct Target_t
ETargetKernel kernel;
ETargetCPU cpu;
ETargetOptimization optimization;
const char *szSysroot = CommandLine()->ParamValue("-sysroot");
CUtlString GetTriplet();
static Target_t HostTarget();
static Target_t DefaultTarget();
};
enum EShaderTarget
{
SHADER_TARGET_VULKAN_SPIRV,
SHADER_TARGET_OPENGL_SPIRV,
SHADER_TARGET_GLSL,
SHADER_TARGET_HLSL,
SHADER_TARGET_MSL,
};
#endif

0
fpc/public/windres.h Normal file
View File

443
fpc/tests/android_build/android_native_app_glue.c Normal file
View File

@@ -0,0 +1,443 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#include <jni.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/resource.h>
#include <stdlib.h>
#include "android_native_app_glue.h"
#include <android/log.h>
#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "threaded_app", __VA_ARGS__))
#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, "threaded_app", __VA_ARGS__))
/* For debug builds, always enable the debug traces in this library */
#ifndef NDEBUG
# define LOGV(...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, "threaded_app", __VA_ARGS__))
#else
# define LOGV(...) ((void)0)
#endif
static void free_saved_state(struct android_app* android_app) {
pthread_mutex_lock(&android_app->mutex);
if (android_app->savedState != NULL) {
free(android_app->savedState);
android_app->savedState = NULL;
android_app->savedStateSize = 0;
}
pthread_mutex_unlock(&android_app->mutex);
}
int8_t android_app_read_cmd(struct android_app* android_app) {
int8_t cmd;
if (read(android_app->msgread, &cmd, sizeof(cmd)) == sizeof(cmd)) {
switch (cmd) {
case APP_CMD_SAVE_STATE:
free_saved_state(android_app);
break;
}
return cmd;
} else {
LOGE("No data on command pipe!");
}
return -1;
}
static void print_cur_config(struct android_app* android_app) {
char lang[2], country[2];
AConfiguration_getLanguage(android_app->config, lang);
AConfiguration_getCountry(android_app->config, country);
LOGV("Config: mcc=%d mnc=%d lang=%c%c cnt=%c%c orien=%d touch=%d dens=%d "
"keys=%d nav=%d keysHid=%d navHid=%d sdk=%d size=%d long=%d "
"modetype=%d modenight=%d",
AConfiguration_getMcc(android_app->config),
AConfiguration_getMnc(android_app->config),
lang[0], lang[1], country[0], country[1],
AConfiguration_getOrientation(android_app->config),
AConfiguration_getTouchscreen(android_app->config),
AConfiguration_getDensity(android_app->config),
AConfiguration_getKeyboard(android_app->config),
AConfiguration_getNavigation(android_app->config),
AConfiguration_getKeysHidden(android_app->config),
AConfiguration_getNavHidden(android_app->config),
AConfiguration_getSdkVersion(android_app->config),
AConfiguration_getScreenSize(android_app->config),
AConfiguration_getScreenLong(android_app->config),
AConfiguration_getUiModeType(android_app->config),
AConfiguration_getUiModeNight(android_app->config));
}
void android_app_pre_exec_cmd(struct android_app* android_app, int8_t cmd) {
switch (cmd) {
case APP_CMD_INPUT_CHANGED:
LOGV("APP_CMD_INPUT_CHANGED\n");
pthread_mutex_lock(&android_app->mutex);
if (android_app->inputQueue != NULL) {
AInputQueue_detachLooper(android_app->inputQueue);
}
android_app->inputQueue = android_app->pendingInputQueue;
if (android_app->inputQueue != NULL) {
LOGV("Attaching input queue to looper");
AInputQueue_attachLooper(android_app->inputQueue,
android_app->looper, LOOPER_ID_INPUT, NULL,
&android_app->inputPollSource);
}
pthread_cond_broadcast(&android_app->cond);
pthread_mutex_unlock(&android_app->mutex);
break;
case APP_CMD_INIT_WINDOW:
LOGV("APP_CMD_INIT_WINDOW\n");
pthread_mutex_lock(&android_app->mutex);
android_app->window = android_app->pendingWindow;
pthread_cond_broadcast(&android_app->cond);
pthread_mutex_unlock(&android_app->mutex);
break;
case APP_CMD_TERM_WINDOW:
LOGV("APP_CMD_TERM_WINDOW\n");
pthread_cond_broadcast(&android_app->cond);
break;
case APP_CMD_RESUME:
case APP_CMD_START:
case APP_CMD_PAUSE:
case APP_CMD_STOP:
LOGV("activityState=%d\n", cmd);
pthread_mutex_lock(&android_app->mutex);
android_app->activityState = cmd;
pthread_cond_broadcast(&android_app->cond);
pthread_mutex_unlock(&android_app->mutex);
break;
case APP_CMD_CONFIG_CHANGED:
LOGV("APP_CMD_CONFIG_CHANGED\n");
AConfiguration_fromAssetManager(android_app->config,
android_app->activity->assetManager);
print_cur_config(android_app);
break;
case APP_CMD_DESTROY:
LOGV("APP_CMD_DESTROY\n");
android_app->destroyRequested = 1;
break;
}
}
void android_app_post_exec_cmd(struct android_app* android_app, int8_t cmd) {
switch (cmd) {
case APP_CMD_TERM_WINDOW:
LOGV("APP_CMD_TERM_WINDOW\n");
pthread_mutex_lock(&android_app->mutex);
android_app->window = NULL;
pthread_cond_broadcast(&android_app->cond);
pthread_mutex_unlock(&android_app->mutex);
break;
case APP_CMD_SAVE_STATE:
LOGV("APP_CMD_SAVE_STATE\n");
pthread_mutex_lock(&android_app->mutex);
android_app->stateSaved = 1;
pthread_cond_broadcast(&android_app->cond);
pthread_mutex_unlock(&android_app->mutex);
break;
case APP_CMD_RESUME:
free_saved_state(android_app);
break;
}
}
void app_dummy() {
}
static void android_app_destroy(struct android_app* android_app) {
LOGV("android_app_destroy!");
free_saved_state(android_app);
pthread_mutex_lock(&android_app->mutex);
if (android_app->inputQueue != NULL) {
AInputQueue_detachLooper(android_app->inputQueue);
}
AConfiguration_delete(android_app->config);
android_app->destroyed = 1;
pthread_cond_broadcast(&android_app->cond);
pthread_mutex_unlock(&android_app->mutex);
// Can't touch android_app object after this.
}
static void process_input(struct android_app* app, struct android_poll_source* source) {
AInputEvent* event = NULL;
if (AInputQueue_getEvent(app->inputQueue, &event) >= 0) {
LOGV("New input event: type=%d\n", AInputEvent_getType(event));
if (AInputQueue_preDispatchEvent(app->inputQueue, event)) {
return;
}
int32_t handled = 0;
if (app->onInputEvent != NULL) handled = app->onInputEvent(app, event);
AInputQueue_finishEvent(app->inputQueue, event, handled);
} else {
LOGE("Failure reading next input event: %s\n", strerror(errno));
}
}
static void process_cmd(struct android_app* app, struct android_poll_source* source) {
int8_t cmd = android_app_read_cmd(app);
android_app_pre_exec_cmd(app, cmd);
if (app->onAppCmd != NULL) app->onAppCmd(app, cmd);
android_app_post_exec_cmd(app, cmd);
}
static void* android_app_entry(void* param) {
struct android_app* android_app = (struct android_app*)param;
android_app->config = AConfiguration_new();
AConfiguration_fromAssetManager(android_app->config, android_app->activity->assetManager);
print_cur_config(android_app);
android_app->cmdPollSource.id = LOOPER_ID_MAIN;
android_app->cmdPollSource.app = android_app;
android_app->cmdPollSource.process = process_cmd;
android_app->inputPollSource.id = LOOPER_ID_INPUT;
android_app->inputPollSource.app = android_app;
android_app->inputPollSource.process = process_input;
ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
ALooper_addFd(looper, android_app->msgread, LOOPER_ID_MAIN, ALOOPER_EVENT_INPUT, NULL,
&android_app->cmdPollSource);
android_app->looper = looper;
pthread_mutex_lock(&android_app->mutex);
android_app->running = 1;
pthread_cond_broadcast(&android_app->cond);
pthread_mutex_unlock(&android_app->mutex);
android_main(android_app);
android_app_destroy(android_app);
return NULL;
}
// --------------------------------------------------------------------
// Native activity interaction (called from main thread)
// --------------------------------------------------------------------
static struct android_app* android_app_create(ANativeActivity* activity,
void* savedState, size_t savedStateSize) {
struct android_app* android_app = (struct android_app*)malloc(sizeof(struct android_app));
memset(android_app, 0, sizeof(struct android_app));
android_app->activity = activity;
pthread_mutex_init(&android_app->mutex, NULL);
pthread_cond_init(&android_app->cond, NULL);
if (savedState != NULL) {
android_app->savedState = malloc(savedStateSize);
android_app->savedStateSize = savedStateSize;
memcpy(android_app->savedState, savedState, savedStateSize);
}
int msgpipe[2];
if (pipe(msgpipe)) {
LOGE("could not create pipe: %s", strerror(errno));
return NULL;
}
android_app->msgread = msgpipe[0];
android_app->msgwrite = msgpipe[1];
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
pthread_create(&android_app->thread, &attr, android_app_entry, android_app);
// Wait for thread to start.
pthread_mutex_lock(&android_app->mutex);
while (!android_app->running) {
pthread_cond_wait(&android_app->cond, &android_app->mutex);
}
pthread_mutex_unlock(&android_app->mutex);
return android_app;
}
static void android_app_write_cmd(struct android_app* android_app, int8_t cmd) {
if (write(android_app->msgwrite, &cmd, sizeof(cmd)) != sizeof(cmd)) {
LOGE("Failure writing android_app cmd: %s\n", strerror(errno));
}
}
static void android_app_set_input(struct android_app* android_app, AInputQueue* inputQueue) {
pthread_mutex_lock(&android_app->mutex);
android_app->pendingInputQueue = inputQueue;
android_app_write_cmd(android_app, APP_CMD_INPUT_CHANGED);
while (android_app->inputQueue != android_app->pendingInputQueue) {
pthread_cond_wait(&android_app->cond, &android_app->mutex);
}
pthread_mutex_unlock(&android_app->mutex);
}
static void android_app_set_window(struct android_app* android_app, ANativeWindow* window) {
pthread_mutex_lock(&android_app->mutex);
if (android_app->pendingWindow != NULL) {
android_app_write_cmd(android_app, APP_CMD_TERM_WINDOW);
}
android_app->pendingWindow = window;
if (window != NULL) {
android_app_write_cmd(android_app, APP_CMD_INIT_WINDOW);
}
while (android_app->window != android_app->pendingWindow) {
pthread_cond_wait(&android_app->cond, &android_app->mutex);
}
pthread_mutex_unlock(&android_app->mutex);
}
static void android_app_set_activity_state(struct android_app* android_app, int8_t cmd) {
pthread_mutex_lock(&android_app->mutex);
android_app_write_cmd(android_app, cmd);
while (android_app->activityState != cmd) {
pthread_cond_wait(&android_app->cond, &android_app->mutex);
}
pthread_mutex_unlock(&android_app->mutex);
}
static void android_app_free(struct android_app* android_app) {
pthread_mutex_lock(&android_app->mutex);
android_app_write_cmd(android_app, APP_CMD_DESTROY);
while (!android_app->destroyed) {
pthread_cond_wait(&android_app->cond, &android_app->mutex);
}
pthread_mutex_unlock(&android_app->mutex);
close(android_app->msgread);
close(android_app->msgwrite);
pthread_cond_destroy(&android_app->cond);
pthread_mutex_destroy(&android_app->mutex);
free(android_app);
}
static void onDestroy(ANativeActivity* activity) {
LOGV("Destroy: %p\n", activity);
android_app_free((struct android_app*)activity->instance);
}
static void onStart(ANativeActivity* activity) {
LOGV("Start: %p\n", activity);
android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_START);
}
static void onResume(ANativeActivity* activity) {
LOGV("Resume: %p\n", activity);
android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_RESUME);
}
static void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen) {
struct android_app* android_app = (struct android_app*)activity->instance;
void* savedState = NULL;
LOGV("SaveInstanceState: %p\n", activity);
pthread_mutex_lock(&android_app->mutex);
android_app->stateSaved = 0;
android_app_write_cmd(android_app, APP_CMD_SAVE_STATE);
while (!android_app->stateSaved) {
pthread_cond_wait(&android_app->cond, &android_app->mutex);
}
if (android_app->savedState != NULL) {
savedState = android_app->savedState;
*outLen = android_app->savedStateSize;
android_app->savedState = NULL;
android_app->savedStateSize = 0;
}
pthread_mutex_unlock(&android_app->mutex);
return savedState;
}
static void onPause(ANativeActivity* activity) {
LOGV("Pause: %p\n", activity);
android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_PAUSE);
}
static void onStop(ANativeActivity* activity) {
LOGV("Stop: %p\n", activity);
android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_STOP);
}
static void onConfigurationChanged(ANativeActivity* activity) {
struct android_app* android_app = (struct android_app*)activity->instance;
LOGV("ConfigurationChanged: %p\n", activity);
android_app_write_cmd(android_app, APP_CMD_CONFIG_CHANGED);
}
static void onLowMemory(ANativeActivity* activity) {
struct android_app* android_app = (struct android_app*)activity->instance;
LOGV("LowMemory: %p\n", activity);
android_app_write_cmd(android_app, APP_CMD_LOW_MEMORY);
}
static void onWindowFocusChanged(ANativeActivity* activity, int focused) {
LOGV("WindowFocusChanged: %p -- %d\n", activity, focused);
android_app_write_cmd((struct android_app*)activity->instance,
focused ? APP_CMD_GAINED_FOCUS : APP_CMD_LOST_FOCUS);
}
static void onNativeWindowCreated(ANativeActivity* activity, ANativeWindow* window) {
LOGV("NativeWindowCreated: %p -- %p\n", activity, window);
android_app_set_window((struct android_app*)activity->instance, window);
}
static void onNativeWindowDestroyed(ANativeActivity* activity, ANativeWindow* window) {
LOGV("NativeWindowDestroyed: %p -- %p\n", activity, window);
android_app_set_window((struct android_app*)activity->instance, NULL);
}
static void onInputQueueCreated(ANativeActivity* activity, AInputQueue* queue) {
LOGV("InputQueueCreated: %p -- %p\n", activity, queue);
android_app_set_input((struct android_app*)activity->instance, queue);
}
static void onInputQueueDestroyed(ANativeActivity* activity, AInputQueue* queue) {
LOGV("InputQueueDestroyed: %p -- %p\n", activity, queue);
android_app_set_input((struct android_app*)activity->instance, NULL);
}
void ANativeActivity_onCreate(ANativeActivity* activity,
void* savedState, size_t savedStateSize) {
LOGV("Creating: %p\n", activity);
activity->callbacks->onDestroy = onDestroy;
activity->callbacks->onStart = onStart;
activity->callbacks->onResume = onResume;
activity->callbacks->onSaveInstanceState = onSaveInstanceState;
activity->callbacks->onPause = onPause;
activity->callbacks->onStop = onStop;
activity->callbacks->onConfigurationChanged = onConfigurationChanged;
activity->callbacks->onLowMemory = onLowMemory;
activity->callbacks->onWindowFocusChanged = onWindowFocusChanged;
activity->callbacks->onNativeWindowCreated = onNativeWindowCreated;
activity->callbacks->onNativeWindowDestroyed = onNativeWindowDestroyed;
activity->callbacks->onInputQueueCreated = onInputQueueCreated;
activity->callbacks->onInputQueueDestroyed = onInputQueueDestroyed;
activity->instance = android_app_create(activity, savedState, savedStateSize);
}

349
fpc/tests/android_build/android_native_app_glue.h Normal file
View File

@@ -0,0 +1,349 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
#ifndef _ANDROID_NATIVE_APP_GLUE_H
#define _ANDROID_NATIVE_APP_GLUE_H
#include <poll.h>
#include <pthread.h>
#include <sched.h>
#include <android/configuration.h>
#include <android/looper.h>
#include <android/native_activity.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* The native activity interface provided by <android/native_activity.h>
* is based on a set of application-provided callbacks that will be called
* by the Activity's main thread when certain events occur.
*
* This means that each one of this callbacks _should_ _not_ block, or they
* risk having the system force-close the application. This programming
* model is direct, lightweight, but constraining.
*
* The 'threaded_native_app' static library is used to provide a different
* execution model where the application can implement its own main event
* loop in a different thread instead. Here's how it works:
*
* 1/ The application must provide a function named "android_main()" that
* will be called when the activity is created, in a new thread that is
* distinct from the activity's main thread.
*
* 2/ android_main() receives a pointer to a valid "android_app" structure
* that contains references to other important objects, e.g. the
* ANativeActivity obejct instance the application is running in.
*
* 3/ the "android_app" object holds an ALooper instance that already
* listens to two important things:
*
* - activity lifecycle events (e.g. "pause", "resume"). See APP_CMD_XXX
* declarations below.
*
* - input events coming from the AInputQueue attached to the activity.
*
* Each of these correspond to an ALooper identifier returned by
* ALooper_pollOnce with values of LOOPER_ID_MAIN and LOOPER_ID_INPUT,
* respectively.
*
* Your application can use the same ALooper to listen to additional
* file-descriptors. They can either be callback based, or with return
* identifiers starting with LOOPER_ID_USER.
*
* 4/ Whenever you receive a LOOPER_ID_MAIN or LOOPER_ID_INPUT event,
* the returned data will point to an android_poll_source structure. You
* can call the process() function on it, and fill in android_app->onAppCmd
* and android_app->onInputEvent to be called for your own processing
* of the event.
*
* Alternatively, you can call the low-level functions to read and process
* the data directly... look at the process_cmd() and process_input()
* implementations in the glue to see how to do this.
*
* See the sample named "native-activity" that comes with the NDK with a
* full usage example. Also look at the JavaDoc of NativeActivity.
*/
struct android_app;
/**
* Data associated with an ALooper fd that will be returned as the "outData"
* when that source has data ready.
*/
struct android_poll_source {
// The identifier of this source. May be LOOPER_ID_MAIN or
// LOOPER_ID_INPUT.
int32_t id;
// The android_app this ident is associated with.
struct android_app* app;
// Function to call to perform the standard processing of data from
// this source.
void (*process)(struct android_app* app, struct android_poll_source* source);
};
/**
* This is the interface for the standard glue code of a threaded
* application. In this model, the application's code is running
* in its own thread separate from the main thread of the process.
* It is not required that this thread be associated with the Java
* VM, although it will need to be in order to make JNI calls any
* Java objects.
*/
struct android_app {
// The application can place a pointer to its own state object
// here if it likes.
void* userData;
// Fill this in with the function to process main app commands (APP_CMD_*)
void (*onAppCmd)(struct android_app* app, int32_t cmd);
// Fill this in with the function to process input events. At this point
// the event has already been pre-dispatched, and it will be finished upon
// return. Return 1 if you have handled the event, 0 for any default
// dispatching.
int32_t (*onInputEvent)(struct android_app* app, AInputEvent* event);
// The ANativeActivity object instance that this app is running in.
ANativeActivity* activity;
// The current configuration the app is running in.
AConfiguration* config;
// This is the last instance's saved state, as provided at creation time.
// It is NULL if there was no state. You can use this as you need; the
// memory will remain around until you call android_app_exec_cmd() for
// APP_CMD_RESUME, at which point it will be freed and savedState set to NULL.
// These variables should only be changed when processing a APP_CMD_SAVE_STATE,
// at which point they will be initialized to NULL and you can malloc your
// state and place the information here. In that case the memory will be
// freed for you later.
void* savedState;
size_t savedStateSize;
// The ALooper associated with the app's thread.
ALooper* looper;
// When non-NULL, this is the input queue from which the app will
// receive user input events.
AInputQueue* inputQueue;
// When non-NULL, this is the window surface that the app can draw in.
ANativeWindow* window;
// Current content rectangle of the window; this is the area where the
// window's content should be placed to be seen by the user.
ARect contentRect;
// Current state of the app's activity. May be either APP_CMD_START,
// APP_CMD_RESUME, APP_CMD_PAUSE, or APP_CMD_STOP; see below.
int activityState;
// This is non-zero when the application's NativeActivity is being
// destroyed and waiting for the app thread to complete.
int destroyRequested;
// -------------------------------------------------
// Below are "private" implementation of the glue code.
pthread_mutex_t mutex;
pthread_cond_t cond;
int msgread;
int msgwrite;
pthread_t thread;
struct android_poll_source cmdPollSource;
struct android_poll_source inputPollSource;
int running;
int stateSaved;
int destroyed;
int redrawNeeded;
AInputQueue* pendingInputQueue;
ANativeWindow* pendingWindow;
ARect pendingContentRect;
};
enum {
/**
* Looper data ID of commands coming from the app's main thread, which
* is returned as an identifier from ALooper_pollOnce(). The data for this
* identifier is a pointer to an android_poll_source structure.
* These can be retrieved and processed with android_app_read_cmd()
* and android_app_exec_cmd().
*/
LOOPER_ID_MAIN = 1,
/**
* Looper data ID of events coming from the AInputQueue of the
* application's window, which is returned as an identifier from
* ALooper_pollOnce(). The data for this identifier is a pointer to an
* android_poll_source structure. These can be read via the inputQueue
* object of android_app.
*/
LOOPER_ID_INPUT = 2,
/**
* Start of user-defined ALooper identifiers.
*/
LOOPER_ID_USER = 3,
};
enum {
/**
* Command from main thread: the AInputQueue has changed. Upon processing
* this command, android_app->inputQueue will be updated to the new queue
* (or NULL).
*/
APP_CMD_INPUT_CHANGED,
/**
* Command from main thread: a new ANativeWindow is ready for use. Upon
* receiving this command, android_app->window will contain the new window
* surface.
*/
APP_CMD_INIT_WINDOW,
/**
* Command from main thread: the existing ANativeWindow needs to be
* terminated. Upon receiving this command, android_app->window still
* contains the existing window; after calling android_app_exec_cmd
* it will be set to NULL.
*/
APP_CMD_TERM_WINDOW,
/**
* Command from main thread: the current ANativeWindow has been resized.
* Please redraw with its new size.
*/
APP_CMD_WINDOW_RESIZED,
/**
* Command from main thread: the system needs that the current ANativeWindow
* be redrawn. You should redraw the window before handing this to
* android_app_exec_cmd() in order to avoid transient drawing glitches.
*/
APP_CMD_WINDOW_REDRAW_NEEDED,
/**
* Command from main thread: the content area of the window has changed,
* such as from the soft input window being shown or hidden. You can
* find the new content rect in android_app::contentRect.
*/
APP_CMD_CONTENT_RECT_CHANGED,
/**
* Command from main thread: the app's activity window has gained
* input focus.
*/
APP_CMD_GAINED_FOCUS,
/**
* Command from main thread: the app's activity window has lost
* input focus.
*/
APP_CMD_LOST_FOCUS,
/**
* Command from main thread: the current device configuration has changed.
*/
APP_CMD_CONFIG_CHANGED,
/**
* Command from main thread: the system is running low on memory.
* Try to reduce your memory use.
*/
APP_CMD_LOW_MEMORY,
/**
* Command from main thread: the app's activity has been started.
*/
APP_CMD_START,
/**
* Command from main thread: the app's activity has been resumed.
*/
APP_CMD_RESUME,
/**
* Command from main thread: the app should generate a new saved state
* for itself, to restore from later if needed. If you have saved state,
* allocate it with malloc and place it in android_app.savedState with
* the size in android_app.savedStateSize. The will be freed for you
* later.
*/
APP_CMD_SAVE_STATE,
/**
* Command from main thread: the app's activity has been paused.
*/
APP_CMD_PAUSE,
/**
* Command from main thread: the app's activity has been stopped.
*/
APP_CMD_STOP,
/**
* Command from main thread: the app's activity is being destroyed,
* and waiting for the app thread to clean up and exit before proceeding.
*/
APP_CMD_DESTROY,
};
/**
* Call when ALooper_pollAll() returns LOOPER_ID_MAIN, reading the next
* app command message.
*/
int8_t android_app_read_cmd(struct android_app* android_app);
/**
* Call with the command returned by android_app_read_cmd() to do the
* initial pre-processing of the given command. You can perform your own
* actions for the command after calling this function.
*/
void android_app_pre_exec_cmd(struct android_app* android_app, int8_t cmd);
/**
* Call with the command returned by android_app_read_cmd() to do the
* final post-processing of the given command. You must have done your own
* actions for the command before calling this function.
*/
void android_app_post_exec_cmd(struct android_app* android_app, int8_t cmd);
/**
* Dummy function you can call to ensure glue code isn't stripped.
*/
void app_dummy();
/**
* This is the function that application code must implement, representing
* the main entry to the app.
*/
extern void android_main(struct android_app* app);
#ifdef __cplusplus
}
#endif
#endif /* _ANDROID_NATIVE_APP_GLUE_H */

35
fpc/tests/android_build/build.cpp Normal file
View File

@@ -0,0 +1,35 @@
#include "helper.h"
#include "c.h"
#include "ld.h"
#include "tier1/utlstring.h"
DECLARE_BUILD_STAGE(android_build)
{
AndroidManifest_t manifest = {};
manifest.SetMinSDKVersion(21);
manifest.SetTargetSDKVersion(35);
manifest.SetPackageName("FPC Testing facility");
manifest.SetPackageID("com.example.testfpc");
CUtlString szManifestDir = manifest.BuildManifest();
CProject_t compileProject = {};
compileProject.m_szName = "android_app";
compileProject.m_androidmanifest = manifest;
compileProject.bFPIC = true;
compileProject.files = {
"main.c",
};
LinkProject_t ldProject = ccompiler->Compile(&compileProject);
ldProject.libraries = {
"android",
"log",
};
CUtlString szOutputDir = linker->Link(&ldProject);
filesystem2->MakeDirectory(CUtlString("%s/lib/x86_64",szManifestDir.GetString()));
filesystem2->CopyFile(CUtlString("%s/lib/x86_64/libnative-app.so",szManifestDir.GetString()), szOutputDir);
APKTool()->BuildPackage(manifest, szManifestDir);
return 0;
}

BIN
fpc/tests/android_build/com.example.testfpc.signed.apk Normal file
View File

Binary file not shown.

BIN
fpc/tests/android_build/com.example.testfpc.signed.apk.idsig Normal file
View File

Binary file not shown.

42
fpc/tests/android_build/main.c Normal file
View File

@@ -0,0 +1,42 @@
#include "android_native_app_glue.h"
#include <android/log.h>
#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "NativeApp", __VA_ARGS__))
// Handle lifecycle events
static void handle_cmd(struct android_app* app, int32_t cmd) {
switch (cmd) {
case APP_CMD_INIT_WINDOW:
LOGI("Window created");
// You could init OpenGL/Vulkan here
break;
case APP_CMD_TERM_WINDOW:
LOGI("Window destroyed");
break;
}
}
// Entry point for native app
void android_main(struct android_app* app) {
app->onAppCmd = handle_cmd;
LOGI("Native app started");
int events;
struct android_poll_source* source;
// Main event loop
while (1) {
int ident;
while ((ident = ALooper_pollOnce(0, NULL, &events, (void**)&source)) >= 0) {
if (source) source->process(app, source);
if (app->destroyRequested) {
LOGI("App destroy requested");
return;
}
}
// Here you can update your game/render loop
}
}

0
fpc/tests/ios_build/build.cpp Normal file
View File