# /~~~~~.
# |\~~~~:   [ C A K E F O O T ] presented by dank.game
# |\\~~~|
# |#\\~~:   source code and license at https://open.shampoo.ooo/shampoo/cakefoot 
# \\#\\~|
#  \\#\\:   created using the SPACE🪐BOX engine https://open.shampoo.ooo/shampoo/spacebox
#   \\#\'
#    \\#| 
#     `-'
#
# This Makefile is used to create executables for Cakefoot. There are targets for Linux, Windows, macOS, and WebGL.
#
# NOTE: The Android rules are currently outdated.
#
# The SPACE🪐BOX source code <https://open.shampoo.ooo/shampoo/spacebox> is required.

#########
# Paths #
#########

# Location of project specific source files
SRC_DIR := src

# Locations of [SPACEBOX] source and its packaged dependencies
SB_DIR := lib/sb
SB_SRC_DIR := $(SB_DIR)/src
SB_LIB_DIR := $(SB_DIR)/lib
SDLGFX2_DIR := $(SB_LIB_DIR)/sdl2-gfx
GLEW_DIR := $(SB_LIB_DIR)/glew

# C and C++ compiler commands
CC := clang
CXX := clang++

# Location of SDL config program. See README.md for how to compile the SDL library and this utility. Define SDL_BIN_DIR when invoking
# make to use an alternate SDL installation location.
SDLCONFIG := $(SDL_BIN_DIR)sdl2-config

#############################
# Based on above parameters #
#############################

# Use SDL's utility program to get compilation and linker flags
SDL_CFLAGS = $(shell $(SDLCONFIG) --cflags)
SDL_LFLAGS := $(shell $(SDLCONFIG) --libs)

# Get all SPACEBOX header files, and get a list of object targets by replacing the .cpp suffix with .o
SB_H_FILES := $(wildcard $(addprefix $(SB_SRC_DIR)/,*.hpp))
SB_O_FILES := $(notdir $(patsubst %.cpp, %.o, $(wildcard $(addprefix $(SB_SRC_DIR)/,*.cpp))))

# Get all project header and object files
SRC_H_FILES := $(wildcard $(addprefix $(SRC_DIR)/,*.hpp))
SRC_O_FILES := $(notdir $(patsubst %.cpp, %.o, $(wildcard $(addprefix $(SRC_DIR)/,*.cpp))))

##########################################################
# Build directories where object targets will be written #
##########################################################

BUILD_ROOT := build
X64_DEBUG_BUILD_DIR := $(BUILD_ROOT)/x64_debug
X64_BUILD_DIR := $(BUILD_ROOT)/x64
WASM_BUILD_DIR := $(BUILD_ROOT)/wasm
WASM_DEBUG_BUILD_DIR := $(BUILD_ROOT)/wasm_debug
WASM_COOLMATH_BUILD_DIR := $(BUILD_ROOT)/wasm_coolmath
WASM_ITCH_BUILD_DIR := $(BUILD_ROOT)/wasm_itch
WINDOWS_BUILD_DIR := $(BUILD_ROOT)/win32
ARCADE_BUILD_DIR := $(BUILD_ROOT)/win32_arcade
DEMO_BUILD_DIR := $(BUILD_ROOT)/win32_demo
WIN64_BUILD_DIR := $(BUILD_ROOT)/win64
UBUNTU18_BUILD_DIR := $(BUILD_ROOT)/ubuntu18
MACOS_BUILD_DIR := $(BUILD_ROOT)/macos
BUILD_DIRS := $(X64_BUILD_DIR) $(X64_DEBUG_BUILD_DIR) $(WASM_BUILD_DIR) $(WASM_DEBUG_BUILD_DIR) $(WASM_COOLMATH_BUILD_DIR) \
	$(WINDOWS_BUILD_DIR) $(ARCADE_BUILD_DIR) $(DEMO_BUILD_DIR) $(WIN64_BUILD_DIR) $(UBUNTU_BUILD_DIR) $(MACOS_BUILD_DIR) \
	$(WASM_ITCH_BUILD_DIR)

$(BUILD_DIRS):
	mkdir -p $@

##################################################################
# Object files for [SPACEBOX], its dependencies, and the project #
##################################################################

$(addsuffix /SDL2_framerate.o, $(BUILD_DIRS)): $(SDLGFX2_DIR)/SDL2_framerate.c $(wildcard $(SDLGFX2_DIR)/*.h) | $(BUILD_DIRS)
	$(CC) $< $(CFLAGS) -c -o $@

$(addsuffix /SDL2_gfxPrimitives.o, $(BUILD_DIRS)): $(SDLGFX2_DIR)/SDL2_gfxPrimitives.c $(wildcard $(SDLGFX2_DIR)/*.h) | $(BUILD_DIRS)
	$(CC) $< $(CFLAGS) -c -o $@

$(addsuffix /SDL2_imageFilter.o, $(BUILD_DIRS)): $(SDLGFX2_DIR)/SDL2_imageFilter.c $(wildcard $(SDLGFX2_DIR)/*.h) | $(BUILD_DIRS)
	$(CC) $< $(CFLAGS) -c -o $@

$(addsuffix /SDL2_rotozoom.o, $(BUILD_DIRS)): $(SDLGFX2_DIR)/SDL2_rotozoom.c $(wildcard $(SDLGFX2_DIR)/*.h) | $(BUILD_DIRS)
	$(CC) $< $(CFLAGS) -c -o $@

$(addsuffix /glew.o, $(BUILD_DIRS)): $(GLEW_DIR)/glew.c $(wildcard $(GLEW_DIR)/*.h) | $(BUILD_DIRS)
	$(CC) $< $(CFLAGS) -c -o $@

$(addsuffix /extension.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, extension.cpp extension.hpp Box.hpp Segment.hpp Color.hpp \
		filesystem.hpp Pixels.hpp Log.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Node.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Node.cpp Node.hpp Game.hpp Configuration.hpp Delegate.hpp \
		Display.hpp Input.hpp Box.hpp Audio.hpp Log.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Game.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Game.cpp Game.hpp extension.hpp Node.hpp Recorder.hpp Input.hpp \
		Configuration.hpp Delegate.hpp Audio.hpp Log.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Animation.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Animation.cpp Animation.hpp Node.hpp Timer.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Recorder.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Recorder.cpp Recorder.hpp Node.hpp Game.hpp Configuration.hpp \
		Delegate.hpp Animation.hpp extension.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Input.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Input.cpp Input.hpp Node.hpp Animation.hpp Configuration.hpp \
		Delegate.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Configuration.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Configuration.cpp Configuration.hpp Animation.hpp Log.hpp \
		extension.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Delegate.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Delegate.cpp Delegate.hpp Node.hpp Game.hpp Input.hpp) \
		| $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Display.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Display.cpp Display.hpp Node.hpp Game.hpp Box.hpp \
		Configuration.hpp Delegate.hpp Log.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Box.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Box.cpp Box.hpp extension.hpp Segment.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Segment.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Segment.cpp Segment.hpp extension.hpp Box.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Pixels.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Pixels.cpp Pixels.hpp Box.hpp extension.hpp Log.hpp math.hpp) \
		| $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Audio.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Audio.cpp Audio.hpp Node.hpp filesystem.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /GLObject.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, GLObject.cpp GLObject.hpp Log.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Texture.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Texture.cpp Texture.hpp GLObject.hpp filesystem.hpp Log.hpp) \
		| $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /VBO.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, VBO.cpp VBO.hpp Log.hpp GLObject.hpp Attributes.hpp extension.hpp) \
		| $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Attributes.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Attributes.cpp Attributes.hpp Log.hpp extension.hpp) \
		| $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Model.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Model.cpp Model.hpp extension.hpp Attributes.hpp Texture.hpp \
		Carousel.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Text.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Text.cpp Text.hpp Model.hpp Color.hpp Log.hpp Texture.hpp) \
		| $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Color.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Color.cpp Color.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Log.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Log.cpp Log.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /math.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, math.cpp math.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Timer.o, $(BUILD_DIRS)): $(addprefix $(SB_SRC_DIR)/, Timer.cpp Timer.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Curve.o, $(BUILD_DIRS)): $(addprefix $(SRC_DIR)/, Curve.cpp Curve.hpp) $(addprefix $(SB_SRC_DIR)/, Attributes.hpp \
		math.hpp extension.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Character.o, $(BUILD_DIRS)): $(addprefix $(SRC_DIR)/, Character.cpp Character.hpp Curve.hpp) \
		$(addprefix $(SB_SRC_DIR)/, Configuration.hpp Switch.hpp Selection.hpp Segment.hpp Timer.hpp Sprite.hpp) \
		| $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Enemy.o, $(BUILD_DIRS)): $(addprefix $(SRC_DIR)/, Enemy.cpp Enemy.hpp Curve.hpp Character.hpp) \
		$(addprefix $(SB_SRC_DIR)/, Timer.hpp Animation.hpp Box.hpp Sprite.hpp) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

$(addsuffix /Cakefoot.o, $(BUILD_DIRS)): $(SRC_DIR)/Cakefoot.cpp $(SRC_H_FILES) $(SB_H_FILES) | $(BUILD_DIRS)
	$(CXX) $(CXXFLAGS) $< -c -o $@

###############
# Linux build #
###############

LINUX_CFLAGS = -c -I$(SB_LIB_DIR) -I$(SB_SRC_DIR) $(SDL_CFLAGS) -DGLEW_STATIC -DGLEW_NO_GLU
LINUX_CXXFLAGS = $(CFLAGS) --std=c++17
LINUX_LFLAGS = $(SDL_LFLAGS) -lpthread -lGL -lGLESv2 -lSDL2_image -lSDL2_ttf -lSDL2_mixer -lstdc++fs -static-libstdc++ -static-libgcc
LINUX_OBJ = $(addprefix $(X64_BUILD_DIR)/, glew.o SDL2_rotozoom.o SDL2_gfxPrimitives.o $(SB_O_FILES) $(SRC_O_FILES))
LINUX_DEBUG_OBJ = $(addprefix $(X64_DEBUG_BUILD_DIR)/, glew.o SDL2_rotozoom.o SDL2_gfxPrimitives.o $(SB_O_FILES) $(SRC_O_FILES))
X64_BUILD_LIB_DIR = lib/

# EXTRA_PLATFORM_FLAGS refers to extra preprocessor definitions, for example -D__UBUNTU18__, to trigger code blocks specific to that
# platform or architecture

Cakefoot-linux.x64 : CFLAGS = $(LINUX_CFLAGS) -O3 $(EXTRA_PLATFORM_FLAGS)
Cakefoot-linux.x64 : CXXFLAGS = $(LINUX_CXXFLAGS)
Cakefoot-linux.x64 : LFLAGS = $(LINUX_LFLAGS) -Wl,-rpath $(X64_BUILD_LIB_DIR)
Cakefoot-linux.x64 : $(LINUX_OBJ)
	$(CXX) $^ $(LFLAGS) -o $(X64_BUILD_DIR)/$@

# Build a distributable archive

	mkdir -p ${basename $@}/$(X64_BUILD_LIB_DIR)
	cp $$(ldd $(X64_BUILD_DIR)/$@ | grep libSDL2-2.0 | cut -d" " -f3) \
		$$(ldd $(X64_BUILD_DIR)/$@ | grep libSDL2_image | cut -d" " -f3) \
		$$(ldd $(X64_BUILD_DIR)/$@ | grep libSDL2_ttf | cut -d" " -f3) \
		$$(ldd $(X64_BUILD_DIR)/$@ | grep libSDL2_mixer | cut -d" " -f3) ${basename $@}/$(X64_BUILD_LIB_DIR)
	rsync -arRL resource/ src/shaders/ config.json ${basename $@}
	cp $(X64_BUILD_DIR)/$@ ${basename $@}
	zip -r ${@:x64=zip} ${basename $@}
	mv ${@:x64=zip} $(X64_BUILD_DIR)
	mv ${basename $@} /tmp
	rm -rf /tmp/${basename $@}

Cakefoot-linux_debug.x64 : CFLAGS = $(LINUX_CFLAGS) -g -Wall -Wextra -O0 -fsanitize=undefined
Cakefoot-linux_debug.x64 : CXXFLAGS = $(LINUX_CXXFLAGS)
Cakefoot-linux_debug.x64 : LFLAGS = $(LINUX_LFLAGS) -fsanitize=undefined
Cakefoot-linux_debug.x64 : $(LINUX_DEBUG_OBJ)
	$(CXX) $^ $(LFLAGS) -D__LINUX__ -o $(X64_DEBUG_BUILD_DIR)/$@

# Launch a docker container to build the game on Ubuntu 18.04 for compatibility with older Linux distributions. This requires
# Docker to be installed on the host system with the image cakefoot-ubuntu18. Use `src/ubuntu18/Dockerfile` to build the image
# before attempting this build if the image was not built yet.
#
#     sudo docker build src/ubuntu18/

Ubuntu-18 :
	sudo docker run --rm -v "$(shell pwd)/$(UBUNTU18_BUILD_DIR):/cakefoot/$(X64_BUILD_DIR)" cakefoot-ubuntu18 sh -c \
		"cd cakefoot && git submodule foreach --recursive git pull origin main && git pull origin main &&\
		make CC=clang-8 CXX=clang++-8 EXTRA_PLATFORM_FLAGS='-D__UBUNTU18__' -j7 Cakefoot-linux.x64 &&\
		useradd $(USER) && chgrp $(USER) $(X64_BUILD_DIR) -R && chown $(USER) $(X64_BUILD_DIR) -R"
#############
# Web build #
#############

# Use Emscripten to output JavaScript

EMSCRIPTENHOME = $(HOME)/ext/software/emsdk/upstream/emscripten
EMSCRIPTEN_CFLAGS = -Oz -Wall -s USE_SDL=2 -s USE_SDL_IMAGE=2 -s SDL2_IMAGE_FORMATS="['png', 'jpg']" -s USE_SDL_TTF=2 \
	-s USE_SDL_MIXER=2 -I $(SB_LIB_DIR) -I $(SB_SRC_DIR)
EMSCRIPTEN_LFLAGS = -s MIN_WEBGL_VERSION=2 -s EXPORTED_FUNCTIONS="['_main', '_malloc', '_pause_for_ads', '_unpause_for_ads']" \
	-s LLD_REPORT_UNDEFINED -s NO_DISABLE_EXCEPTION_CATCHING -s FULL_ES3=1 -lidbfs.js -s ALLOW_MEMORY_GROWTH=1
EMSCRIPTEN_PRELOADS = --preload-file "config.json" --preload-file "resource/" --preload-file "src/shaders/" \
	--preload-file "src/config_wasm.json" --pre-js "src/pre_js.js"
EMSCRIPTEN_GAME_CONFIGS = config.json src/config_wasm.json resource/levels.json

cakefoot.js : CC = $(EMSCRIPTENHOME)/emcc
cakefoot.js : CXX = $(EMSCRIPTENHOME)/em++
cakefoot.js : CFLAGS = $(EMSCRIPTEN_CFLAGS)
cakefoot.js : CXXFLAGS = $(CFLAGS) --std=c++17
cakefoot.js : $(addprefix $(WASM_BUILD_DIR)/, SDL2_rotozoom.o SDL2_gfxPrimitives.o $(SB_O_FILES) $(SRC_O_FILES)) \
		$(EMSCRIPTEN_GAME_CONFIGS)
	$(CXX) $(filter-out $(EMSCRIPTEN_GAME_CONFIGS), $^) $(CXXFLAGS) $(EMSCRIPTEN_LFLAGS) $(EMSCRIPTEN_PRELOADS) \
		--pre-js "src/pre_js_collect.js" -o $(WASM_BUILD_DIR)/$@

cakefoot_debug.html : CC = $(EMSCRIPTENHOME)/emcc
cakefoot_debug.html : CXX = $(EMSCRIPTENHOME)/em++
cakefoot_debug.html : CFLAGS = $(EMSCRIPTEN_CFLAGS) -g2
cakefoot_debug.html : CXXFLAGS = $(CFLAGS) --std=c++17
cakefoot_debug.html : $(addprefix $(WASM_DEBUG_BUILD_DIR)/, SDL2_rotozoom.o SDL2_gfxPrimitives.o $(SB_O_FILES) $(SRC_O_FILES)) \
		$(EMSCRIPTEN_GAME_CONFIGS)
	$(CXX) $(filter-out $(EMSCRIPTEN_GAME_CONFIGS), $^) $(CXXFLAGS) $(EMSCRIPTEN_LFLAGS) $(EMSCRIPTEN_PRELOADS) --memoryprofiler \
		--cpuprofiler -o $(WASM_DEBUG_BUILD_DIR)/$@

cakefoot_coolmath.js : CC = $(EMSCRIPTENHOME)/emcc
cakefoot_coolmath.js : CXX = $(EMSCRIPTENHOME)/em++
cakefoot_coolmath.js : CFLAGS = $(EMSCRIPTEN_CFLAGS) -D__COOLMATH__
cakefoot_coolmath.js : CXXFLAGS = $(CFLAGS) --std=c++17
cakefoot_coolmath.js : EMSCRIPTEN_GAME_CONFIGS += src/config_coolmath.json
cakefoot_coolmath.js : $(addprefix $(WASM_COOLMATH_BUILD_DIR)/, SDL2_rotozoom.o SDL2_gfxPrimitives.o $(SB_O_FILES) $(SRC_O_FILES)) \
		$(EMSCRIPTEN_GAME_CONFIGS) src/index_coolmath.html src/embed_style.css
	$(CXX) $(filter-out $(EMSCRIPTEN_GAME_CONFIGS) src/index_coolmath.html src/embed_style.css, $^) $(CXXFLAGS) $(EMSCRIPTEN_LFLAGS) \
		-D__COOLMATH__ $(EMSCRIPTEN_PRELOADS) --preload-file "src/config_coolmath.json" -o $(WASM_COOLMATH_BUILD_DIR)/$@
	cp src/index_coolmath.html $(WASM_COOLMATH_BUILD_DIR)/index.html
	cp src/embed_style.css $(WASM_COOLMATH_BUILD_DIR)
	cd $(WASM_COOLMATH_BUILD_DIR) && \
		zip -r Cakefoot_coolmath.zip cakefoot_* index.html embed_style.css && \
		rm cakefoot_* index.html embed_style.css && cd -

cakefoot_itch.js : CC = $(EMSCRIPTENHOME)/emcc
cakefoot_itch.js : CXX = $(EMSCRIPTENHOME)/em++
cakefoot_itch.js : CFLAGS = $(EMSCRIPTEN_CFLAGS) -D__ITCH__
cakefoot_itch.js : CXXFLAGS = $(CFLAGS) --std=c++17
cakefoot_itch.js : $(addprefix $(WASM_ITCH_BUILD_DIR)/, SDL2_rotozoom.o SDL2_gfxPrimitives.o $(SB_O_FILES) $(SRC_O_FILES)) \
		$(EMSCRIPTEN_GAME_CONFIGS) src/index_itch.html src/embed_style.css
	$(CXX) $(filter-out $(EMSCRIPTEN_GAME_CONFIGS) src/embed_style.css src/index_itch.html, $^) $(CXXFLAGS) $(EMSCRIPTEN_LFLAGS) \
		$(EMSCRIPTEN_PRELOADS) --preload-file "src/config_itch.json" -o $(WASM_ITCH_BUILD_DIR)/$@
	cp src/index_itch.html $(WASM_ITCH_BUILD_DIR)/index.html
	cp src/embed_style.css $(WASM_ITCH_BUILD_DIR)
	cd $(WASM_ITCH_BUILD_DIR) && \
		zip -r Cakefoot_itch.zip cakefoot_* index.html embed_style.css && \
		rm cakefoot_* index.html embed_style.css && cd -

###############
# MacOS build #
###############

# This is intended to build a signed MacOS universal (x86_64 and arm64 in one) application bundle on Linux using the cross-compiler
# project osxcross (https://github.com/tpoechtrager/osxcross). It could probably be edited to work with any MacOS compiler, though.
# The program rcodesign (https://gregoryszorc.com/docs/apple-codesign/0.27.0/apple_codesign_getting_started.html) is required for
# signing the application bundle along with a certificate generated through Apple's developer tools portal.

MACOS_CROSS_ROOT = /media/gdrive/osxcross
MACOS_CROSS_FW = $(MACOS_CROSS_ROOT)/local/Frameworks
MACOS_CFLAGS = -Wall -Wextra -O3 -c -I$(SB_LIB_DIR) -I$(SB_SRC_DIR) -DGLEW_STATIC -DGLEW_NO_GLU -F$(MACOS_CROSS_FW) \
	-I$(MACOS_CROSS_FW)/SDL2.framework/Headers -I$(MACOS_CROSS_FW)/SDL2_image.framework/Headers \
	-I$(MACOS_CROSS_FW)/SDL2_ttf.framework/Headers -I$(MACOS_CROSS_FW)/SDL2_mixer.framework/Headers -D__MACOS__ -D__APPLE__
MACOS_CXXFLAGS = $(CFLAGS) --std=c++17
MACOS_LFLAGS =  -Wl,-rpath,@executable_path/../Frameworks -pthread -F$(MACOS_CROSS_FW) -framework SDL2 \
	-framework SDL2_image -framework SDL2_ttf -framework SDL2_mixer -framework OpenGL
MACOS_OBJ = $(addprefix $(MACOS_BUILD_DIR)/, glew.o SDL2_rotozoom.o SDL2_gfxPrimitives.o $(SB_O_FILES) $(SRC_O_FILES))
MACOS_BUNDLE = $(MACOS_BUILD_DIR)/dmg/$@
MACOS_BUNDLE_CONTENTS = $(MACOS_BUILD_DIR)/dmg/$@/Contents
MACOS_CROSS_BIN = $(MACOS_CROSS_ROOT)/target/bin
MACOS_CERTIFICATE = local/Cakefoot_MacOS_DeveloperID_Application.pem
MACOS_RCODESIGN = ~/ext/software/apple-codesign-0.27.0/rcodesign

Cakefoot.app : CC = MACOSX_DEPLOYMENT_TARGET=11.3 PATH=$(PATH):$(MACOS_CROSS_BIN) o64-clang -arch arm64 -arch x86_64
Cakefoot.app : CXX = MACOSX_DEPLOYMENT_TARGET=11.3 PATH=$(PATH):$(MACOS_CROSS_BIN) o64-clang++ -arch arm64 -arch x86_64
Cakefoot.app : CFLAGS = $(MACOS_CFLAGS)
Cakefoot.app : CXXFLAGS = $(MACOS_CXXFLAGS)
Cakefoot.app : LFLAGS = $(MACOS_LFLAGS)
Cakefoot.app : $(MACOS_OBJ)
	mkdir -p $(MACOS_BUNDLE_CONTENTS)/MacOS $(MACOS_BUNDLE_CONTENTS)/Frameworks $(MACOS_BUNDLE_CONTENTS)/Resources
	cp src/Info.plist $(MACOS_BUNDLE_CONTENTS)
	cp -r $(MACOS_CROSS_FW)/SDL2*.framework $(MACOS_BUNDLE_CONTENTS)/Frameworks
	$(CXX) $^ $(LFLAGS) -o $(MACOS_BUNDLE_CONTENTS)/MacOS/$(basename $@)
	rsync -arRL resource/ src/shaders/ config.json $(MACOS_BUNDLE_CONTENTS)/Resources
	$(MACOS_RCODESIGN) sign --for-notarization --code-signature-flags runtime --pem-file $(MACOS_CERTIFICATE) $(MACOS_BUNDLE)

notarize :
	$(MACOS_RCODESIGN) notary-submit --api-key-file local/Cakefoot_App_Store_Connect_API_key.json --staple \
		$(MACOS_BUILD_DIR)/dmg/Cakefoot.app
	cd $(MACOS_BUILD_DIR) && genisoimage -V Cakefoot -D -R -apple -no-pad -hide-rr-moved -o Cakefoot.dmg dmg && cd -

# Use this to transfer the app folder with symbolic links to the emulator running at port 50922
#
#     rsync -Wav -e 'ssh -p 50922' --progress build/macos/dmg/Cakefoot.app frank@localhost:/Users/frank/

#################
# Android build #
#################

# Detailed info on how this build target was originally created for the fill_screen demo is in README.md at the root of the
# repository. It requires the Android SDK and the source packages for SDL. The paths below should be edited to match the local
# system. Icon creation requires Imagemagick's convert tool from <https://imagemagick.org/>.

SDL_SRC := $(HOME)/ext/software/SDL2-2.26.3
SDL_IMAGE_SRC := $(HOME)/ext/software/SDL2_image-2.6.2-android
SDL_MIXER_SRC := $(HOME)/ext/software/SDL2_mixer-2.6.2-android
SDL_TTF_SRC := $(HOME)/ext/software/SDL2_ttf-2.20.1-android
SDL_ANDROID_PROJECT := $(SDL_SRC)/android-project
ANDROID_MK := app/jni/src/Android.mk
ANDROID_APP_MK := app/jni/Application.mk
ANDROID_MANIFEST := app/src/main/AndroidManifest.xml
ANDROID_SDK := $(HOME)/local/Android
ANDROID_PACKAGE := ooo.shampoo.foam
ANDROID_BUILD_DIR := build/android/$(ANDROID_PACKAGE)
ANDROID_CLASS := Cakefoot
ANDROID_CLASS_DIR := app/src/main/java/$(subst .,/,$(ANDROID_PACKAGE))

# The skeleton for the Android build is based on the SDL android-project. The libraries are symlinked in. If the script that
# rewrites the skeleton has changed, start with a fresh skeleton. Use the SPACEBOX revise skeleton script to edit the SDL
# android-project parameters.
$(ANDROID_BUILD_DIR): $(SDL_SRC)/android-project/ $(SB_SRC_DIR)/android/revise_skeleton.sh
	-mkdir -p $(ANDROID_BUILD_DIR)
	rsync -ar $(SDL_SRC)/android-project/ $(ANDROID_BUILD_DIR)
	ln -nsf $(SDL_SRC) $(ANDROID_BUILD_DIR)/app/jni/SDL
	ln -nsf $(SDL_IMAGE_SRC) $(ANDROID_BUILD_DIR)/app/jni/SDL2_image
	ln -nsf $(SDL_MIXER_SRC) $(ANDROID_BUILD_DIR)/app/jni/SDL2_mixer
	ln -nsf $(SDL_TTF_SRC) $(ANDROID_BUILD_DIR)/app/jni/SDL2_ttf
	$(SB_SRC_DIR)/android/revise_skeleton.sh $(ANDROID_PACKAGE) $(ANDROID_BUILD_DIR) $(ANDROID_MANIFEST) $(ANDROID_APP_MK) \
		$(ANDROID_MK) $(ANDROID_CLASS) $(ANDROID_APP_NAME) $(ANDROID_MIN_TARGET) $(ANDROID_NDK) \
		"Cakefoot" "21" "24.0.8215888" $(SB_SRC_DIR) $(SB_LIB_DIR) $(SRC_DIR)
	ln -nsf $(OPENCV_ANDROID_SDK)/sdk/native/libs $(ANDROID_BUILD_DIR)/app/jni/src/opencv
	ln -nsf $(CURL_ANDROID)/jni/build/curl $(ANDROID_BUILD_DIR)/app/jni/src/curl
	ln -nsf $(CURL_ANDROID)/jni/build/openssl $(ANDROID_BUILD_DIR)/app/jni/src/openssl
	sed -i "s/^APP_CPPFLAGS.*/& -nostartfiles/" "$(ANDROID_BUILD_DIR)/$(ANDROID_APP_MK)"
	sed -i "s/org.libsdl.app/$(ANDROID_PACKAGE)/" "$(ANDROID_BUILD_DIR)/app/build.gradle" \
		"$(ANDROID_BUILD_DIR)/$(ANDROID_MANIFEST)"

# Extend the SDLActivity class
$(ANDROID_BUILD_DIR)/$(ANDROID_CLASS_DIR)/$(ANDROID_CLASS).java: $(SB_SRC_DIR)/android/main_class.sh
	$(SB_SRC_DIR)/android/main_class.sh  $(ANDROID_PACKAGE) $(ANDROID_CLASS) $(ANDROID_BUILD_DIR)/$(ANDROID_CLASS_DIR)

# Generate icon
$(ANDROID_BUILD_DIR)/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml: $(SB_SRC_DIR)/android/generate_icon.sh $(SB_DIR)/icon
	$(SB_SRC_DIR)/android/generate_icon.sh $(ANDROID_BUILD_DIR) "$(SB_DIR)/icon/foreground.png" "$(SB_DIR)/icon/background.png"

# Custom assets
$(ANDROID_BUILD_DIR)/app/src/main/assets: config*.json $(shell find resource/) $(shell find src/shaders)
	-mkdir -p $(ANDROID_BUILD_DIR)/app/src/main/assets
	rsync -ar --relative config*.json resource src/shaders $(ANDROID_BUILD_DIR)/app/src/main/assets

# Run gradle and generate an APK
$(ANDROID_BUILD_DIR)/app-debug.apk: $(ANDROID_BUILD_DIR) $(ANDROID_BUILD_DIR)/$(ANDROID_CLASS_DIR)/$(ANDROID_CLASS).java \
	$(ANDROID_BUILD_DIR)/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml $(ANDROID_BUILD_DIR)/app/src/main/assets
	ANDROID_SDK_ROOT=$(ANDROID_SDK) $(ANDROID_BUILD_DIR)/gradlew -p $(ANDROID_BUILD_DIR) build
	ln -nsf app/build/outputs/apk/debug/app-debug.apk $(ANDROID_BUILD_DIR)
	ln -nsf app/build/outputs/apk/debug/app-release-unsigned.apk $(ANDROID_BUILD_DIR)

###########
# Windows #
###########

# Set the paths to the directories for the SDL MinGW libraries

WIN_ARCH := i686
SDL_MINGW_ROOT := $(HOME)/ext/software/SDL2-mingw
SDL_MINGW = $(SDL_MINGW_ROOT)/SDL2-2.24.2/$(WIN_ARCH)-w64-mingw32
SDL_IMG_MINGW = $(SDL_MINGW_ROOT)/SDL2_image-2.5.2/$(WIN_ARCH)-w64-mingw32
SDL_TTF_MINGW = $(SDL_MINGW_ROOT)/SDL2_ttf-2.0.15/$(WIN_ARCH)-w64-mingw32
SDL_MIXER_MINGW = $(SDL_MINGW_ROOT)/SDL2_mixer-2.5.2/$(WIN_ARCH)-w64-mingw32
WINDOWS_CFLAGS = -Wall -Wextra -O3 -c -I$(SB_LIB_DIR) -I$(SB_SRC_DIR) -DGLEW_STATIC -DGLEW_NO_GLU -I$(SDL_MINGW)/include/SDL2 \
	-I$(SDL_IMG_MINGW)/include/SDL2 -I$(SDL_TTF_MINGW)/include/SDL2 -I$(SDL_MIXER_MINGW)/include/SDL2
WINDOWS_LFLAGS = -lpthread -lstdc++fs -L$(SDL_MINGW)/lib -L$(SDL_IMG_MINGW)/lib -L$(SDL_TTF_MINGW)/lib -L$(SDL_MIXER_MINGW)/lib \
	-lmingw32 -lSDL2_image -lSDL2_ttf -lSDL2_mixer -lSDL2main -lSDL2 -lopengl32 -static-libstdc++ -static-libgcc -mwindows

# Set the compiler to the MinGW compilers

Cakefoot-win32.exe: CC = $(WIN_ARCH)-w64-mingw32-gcc-posix
Cakefoot-win32.exe: CXX = $(WIN_ARCH)-w64-mingw32-g++-posix
Cakefoot-win32.exe: CFLAGS = $(WINDOWS_CFLAGS)
Cakefoot-win32.exe: CXXFLAGS = $(CFLAGS) --std=c++17
Cakefoot-win32.exe: LFLAGS = $(WINDOWS_LFLAGS)
Cakefoot-win32.exe: $(addprefix $(WINDOWS_BUILD_DIR)/, glew.o SDL2_rotozoom.o SDL2_gfxPrimitives.o $(SB_O_FILES) $(SRC_O_FILES)) \
		config.json
	$(CXX) $(filter-out config.json, $^) $(LFLAGS) -o $(WINDOWS_BUILD_DIR)/$@
	mkdir ${basename $@}
	cp $(SDL_MINGW)/bin/*.dll $(SDL_IMG_MINGW)/bin/*.dll $(SDL_TTF_MINGW)/bin/*.dll $(SDL_MIXER_MINGW)/bin/*.dll ${basename $@}
	cp /usr/$(WIN_ARCH)-w64-mingw32/lib/libwinpthread-1.dll ${basename $@}
	rsync -arRL resource/ src/shaders/ config.json ${basename $@}
	cp $(WINDOWS_BUILD_DIR)/$@ ${basename $@}
	zip -r ${@:exe=zip} ${basename $@}
	mv ${basename $@} /tmp
	rm -rf /tmp/${basename $@}
	mv ${@:exe=zip} $(WINDOWS_BUILD_DIR)

Cakefoot-win64.exe: WIN_ARCH = x86_64
Cakefoot-win64.exe: CC = $(WIN_ARCH)-w64-mingw32-gcc-posix
Cakefoot-win64.exe: CXX = $(WIN_ARCH)-w64-mingw32-g++-posix
Cakefoot-win64.exe: CFLAGS = $(WINDOWS_CFLAGS)
Cakefoot-win64.exe: CXXFLAGS = $(CFLAGS) --std=c++17
Cakefoot-win64.exe: LFLAGS = $(WINDOWS_LFLAGS)
Cakefoot-win64.exe: $(addprefix $(WIN64_BUILD_DIR)/, glew.o SDL2_rotozoom.o SDL2_gfxPrimitives.o $(SB_O_FILES) $(SRC_O_FILES)) \
		config.json
	$(CXX) $(filter-out config.json, $^) $(LFLAGS) -o $(WIN64_BUILD_DIR)/$@
	mkdir ${basename $@}
	cp $(SDL_MINGW)/bin/*.dll $(SDL_IMG_MINGW)/bin/*.dll $(SDL_TTF_MINGW)/bin/*.dll $(SDL_MIXER_MINGW)/bin/*.dll ${basename $@}
	cp /usr/$(WIN_ARCH)-w64-mingw32/lib/libwinpthread-1.dll ${basename $@}
	rsync -arRL resource/ src/shaders/ config.json ${basename $@}
	cp $(WIN64_BUILD_DIR)/$@ ${basename $@}
	zip -r ${@:exe=zip} ${basename $@}
	mv ${basename $@} /tmp
	rm -rf /tmp/${basename $@}
	mv ${@:exe=zip} $(WIN64_BUILD_DIR)

Cakefoot-win32-ARCADE_ONLY.exe: CC = $(WIN_ARCH)-w64-mingw32-gcc-posix
Cakefoot-win32-ARCADE_ONLY.exe: CXX = $(WIN_ARCH)-w64-mingw32-g++-posix
Cakefoot-win32-ARCADE_ONLY.exe: CFLAGS = $(WINDOWS_CFLAGS) -D__ARCADE_ONLY__
Cakefoot-win32-ARCADE_ONLY.exe: CXXFLAGS = $(CFLAGS) --std=c++17
Cakefoot-win32-ARCADE_ONLY.exe: LFLAGS = $(WINDOWS_LFLAGS) -D__ARCADE_ONLY__
Cakefoot-win32-ARCADE_ONLY.exe: $(addprefix $(ARCADE_BUILD_DIR)/, glew.o SDL2_rotozoom.o SDL2_gfxPrimitives.o $(SB_O_FILES) \
		$(SRC_O_FILES)) config.json src/config_arcade.json
	$(CXX) $(filter-out config.json src/config_arcade.json, $^) $(LFLAGS) -o $(ARCADE_BUILD_DIR)/$@
	mkdir ${basename $@}
	cp $(SDL_MINGW)/bin/*.dll $(SDL_IMG_MINGW)/bin/*.dll $(SDL_TTF_MINGW)/bin/*.dll $(SDL_MIXER_MINGW)/bin/*.dll ${basename $@}
	cp /usr/$(WIN_ARCH)-w64-mingw32/lib/libwinpthread-1.dll ${basename $@}
	rsync -arRL resource/ src/shaders/ src/config_arcade.json config.json ${basename $@}
	mv $(ARCADE_BUILD_DIR)/$@ ${basename $@}
	zip -r ${@:exe=zip} ${basename $@}
	mv ${basename $@} /tmp
	rm -rf /tmp/${basename $@}
	mv ${@:exe=zip} $(ARCADE_BUILD_DIR)

Cakefoot-win32-DEMO.exe: CC = $(WIN_ARCH)-w64-mingw32-gcc-posix
Cakefoot-win32-DEMO.exe: CXX = $(WIN_ARCH)-w64-mingw32-g++-posix
Cakefoot-win32-DEMO.exe: CFLAGS = $(WINDOWS_CFLAGS) -D__DEMO__
Cakefoot-win32-DEMO.exe: CXXFLAGS = $(CFLAGS) --std=c++17
Cakefoot-win32-DEMO.exe: LFLAGS = $(WINDOWS_LFLAGS) -D__DEMO__
Cakefoot-win32-DEMO.exe: $(addprefix $(DEMO_BUILD_DIR)/, glew.o SDL2_rotozoom.o SDL2_gfxPrimitives.o $(SB_O_FILES) \
		$(SRC_O_FILES)) config.json src/config_demo.json
	$(CXX) $(filter-out config.json src/config_demo.json, $^) $(LFLAGS) -o $(DEMO_BUILD_DIR)/$@
	mkdir ${basename $@}
	cp $(SDL_MINGW)/bin/*.dll $(SDL_IMG_MINGW)/bin/*.dll $(SDL_TTF_MINGW)/bin/*.dll $(SDL_MIXER_MINGW)/bin/*.dll ${basename $@}
	cp /usr/$(WIN_ARCH)-w64-mingw32/lib/libwinpthread-1.dll ${basename $@}
	rsync -arRL resource/ src/shaders/ src/config_demo.json config.json ${basename $@}
	mv $(DEMO_BUILD_DIR)/$@ ${basename $@}
	zip -r ${@:exe=zip} ${basename $@}
	mv ${basename $@} /tmp
	rm -rf /tmp/${basename $@}
	mv ${@:exe=zip} $(DEMO_BUILD_DIR)

#############
# Press kit #
#############

# Generate an HTML page from the Press Kit Markdown file. This requires the document conversion tool Pandoc <https://pandoc.org/>.

press :
	pandoc -H "src/Press_kit_style.html" --metadata-file="src/Press_kit_metadata.yml" \
		--template "src/Press_kit_template.html" -s -o press.html Press_Kit.md

###################
# Make all builds #
###################

all : Cakefoot-linux.x64 Cakefoot-linux_debug.x64 cakefoot.js cakefoot_debug.html cakefoot_coolmath.js Cakefoot-win32.exe \
	Cakefoot-win64.exe Cakefoot-win32-ARCADE_ONLY.exe Cakefoot-win32-DEMO.exe press Cakefoot.app Ubuntu-18 cakefoot_itch.js

#########################
# Clean up object files #
#########################

clean :
	rm -rf build/

#############
# compiledb #
#############

# Generate a clang JSON compilation database file. This can be useful for example for code completion. It requires a
# compiledb binary (https://pypi.org/project/compiledb/). It should be generated manually every time a file is added,
# renamed, or the compilation flags change. The generated database is based on the Linux build.

PATH_TO_COMPILEDB = $(HOME)/ext/software/compiledb/bin/compiledb
compiledb: CC = clang-16
compiledb: CXX = clang++-16
compiledb :
	-$(PATH_TO_COMPILEDB) -n make Cakefoot-linux_debug.x64 -k