├── launch.sh
├── include
    ├── shader_strings.h
    ├── GridFunctionLibrary.h
    ├── GridFunctionParameter.h
    ├── ParallelAnimationGroup.h
    ├── SequentialAnimationGroup.h
    ├── singletons.h
    ├── gui
    │   ├── gui_common.h
    │   ├── CanvasGuiSection.h
    │   ├── RenderGuiWindow.h
    │   ├── FileDialog.h
    │   ├── gui_tips.h
    │   └── UserInterface.h
    ├── AnimationGroup.h
    ├── Script.h
    ├── SerializerContext.h
    ├── ScriptAnimation.h
    ├── main.h
    ├── CurveAnimation.h
    ├── GridAnimation.h
    ├── SpriteManager.h
    ├── RenderingResources.h
    ├── Canvas.h
    ├── Texture.h
    ├── Configuration.h
    ├── PropertyAnimation.h
    ├── LuaSaver.h
    ├── AnimationManager.h
    ├── LoopComponent.h
    ├── EasingCurve.h
    ├── IAnimation.h
    ├── SpriteEntry.h
    ├── Serializers.h
    ├── GridFunction.h
    ├── ScriptManager.h
    └── Sprite.h
├── src
    ├── singletons.cpp
    ├── gui
    │   ├── openfile.cpp
    │   ├── gui_common.cpp
    │   ├── style.cpp
    │   ├── CanvasGuiSection.cpp
    │   └── config_window.cpp
    ├── LoopComponent.cpp
    ├── GridFunction.cpp
    ├── IAnimation.cpp
    ├── Script.cpp
    ├── GridAnimation.cpp
    ├── AnimationGroup.cpp
    ├── shader_strings.cpp
    ├── RenderingResources.cpp
    ├── CurveAnimation.cpp
    ├── ScriptAnimation.cpp
    ├── SpriteEntry.cpp
    ├── PropertyAnimation.cpp
    ├── EasingCurve.cpp
    ├── ParallelAnimationGroup.cpp
    ├── Canvas.cpp
    ├── Texture.cpp
    ├── SpriteManager.cpp
    ├── SequentialAnimationGroup.cpp
    ├── LuaSaver.cpp
    └── GridFunctionLibrary.cpp
├── cmake
    ├── custom_fontawesome_download.in
    ├── custom_iconfontcppheaders_download.in
    ├── custom_fontawesome.cmake
    └── custom_iconfontcppheaders.cmake
├── .itch.toml
├── LICENSE
├── README.md
└── .github
    └── workflows
        ├── codeql-analysis.yml
        ├── android.yml
        ├── macos.yml
        ├── emscripten.yml
        ├── windows.yml
        ├── linux.yml
        └── mingw.yml


/launch.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | 
3 | cd "`dirname "$0"`"
4 | 
5 | export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD/lib64
6 | cd bin && exec ./spookyghost "$@"
7 | 


--------------------------------------------------------------------------------
/include/shader_strings.h:
--------------------------------------------------------------------------------
 1 | struct ShaderStrings
 2 | {
 3 | 	static char const *const texture_vs;
 4 | 	static char const *const texture_fs;
 5 | 
 6 | 	static char const *const sprite_vs;
 7 | 	static char const *const sprite_fs;
 8 | 	static char const *const meshsprite_vs;
 9 | 	static char const *const meshsprite_snap_vs;
10 | };
11 | 


--------------------------------------------------------------------------------
/src/singletons.cpp:
--------------------------------------------------------------------------------
 1 | #include "singletons.h"
 2 | 
 3 | Configuration theCfg;
 4 | nctl::UniquePtr<Canvas> theCanvas;
 5 | nctl::UniquePtr<Canvas> theResizedCanvas;
 6 | nctl::UniquePtr<Canvas> theSpritesheet;
 7 | nctl::UniquePtr<SpriteManager> theSpriteMgr;
 8 | nctl::UniquePtr<AnimationManager> theAnimMgr;
 9 | nctl::UniquePtr<LuaSaver> theSaver;
10 | nctl::UniquePtr<ScriptManager> theScriptingMgr;
11 | 


--------------------------------------------------------------------------------
/include/GridFunctionLibrary.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_GRIDFUNCTIONLIBRARY
 2 | #define CLASS_GRIDFUNCTIONLIBRARY
 3 | 
 4 | #include "GridFunction.h"
 5 | 
 6 | namespace nc = ncine;
 7 | 
 8 | class GridFunctionLibrary
 9 | {
10 |   public:
11 | 	static void init();
12 | 	static const nctl::Array<GridFunction> &gridFunctions() { return gridFunctions_; }
13 | 
14 |   private:
15 | 	static nctl::Array<GridFunction> gridFunctions_;
16 | };
17 | 
18 | #endif
19 | 


--------------------------------------------------------------------------------
/cmake/custom_fontawesome_download.in:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.8.12)
 2 | 
 3 | project(fontawesome-download NONE)
 4 | 
 5 | include(ExternalProject)
 6 | ExternalProject_Add(fontawesome
 7 | 	GIT_REPOSITORY    https://github.com/FortAwesome/Font-Awesome.git
 8 | 	GIT_TAG           "${FONTAWESOME_VERSION_TAG}"
 9 | 	GIT_SHALLOW       TRUE
10 | 	SOURCE_DIR        "${CMAKE_BINARY_DIR}/fontawesome-src"
11 | 	CONFIGURE_COMMAND ""
12 | 	BUILD_COMMAND     ""
13 | 	INSTALL_COMMAND   ""
14 | 	TEST_COMMAND      ""
15 | )
16 | 


--------------------------------------------------------------------------------
/include/GridFunctionParameter.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_GRIDFUNCTIONPARAMETER
 2 | #define CLASS_GRIDFUNCTIONPARAMETER
 3 | 
 4 | /// The actual parameter value for a grid function
 5 | struct GridFunctionParameter
 6 | {
 7 | 	GridFunctionParameter()
 8 | 	    : value0(0.0f), value1(0.0) {}
 9 | 	GridFunctionParameter(float v0, float v1)
10 | 	    : value0(v0), value1(v1) {}
11 | 
12 | 	inline void set(float v0, float v1)
13 | 	{
14 | 		value0 = v0;
15 | 		value1 = v1;
16 | 	}
17 | 
18 | 	float value0;
19 | 	float value1;
20 | };
21 | 
22 | #endif
23 | 


--------------------------------------------------------------------------------
/include/ParallelAnimationGroup.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_PARALLELANIMATIONGROUP
 2 | #define CLASS_PARALLELANIMATIONGROUP
 3 | 
 4 | #include "AnimationGroup.h"
 5 | 
 6 | /// The parallel animation group
 7 | class ParallelAnimationGroup : public AnimationGroup
 8 | {
 9 |   public:
10 | 	nctl::UniquePtr<IAnimation> clone() const override;
11 | 
12 | 	inline Type type() const override { return Type::PARALLEL_GROUP; }
13 | 
14 | 	void pause() override;
15 | 	void play() override;
16 | 
17 | 	void update(float deltaTime) override;
18 | };
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/cmake/custom_iconfontcppheaders_download.in:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.8.12)
 2 | 
 3 | project(iconfontcppheaders-download NONE)
 4 | 
 5 | include(ExternalProject)
 6 | ExternalProject_Add(iconfontcppheaders
 7 | 	GIT_REPOSITORY    https://github.com/juliettef/IconFontCppHeaders.git
 8 | 	GIT_TAG           "${ICONFONTCPPHEADERS_VERSION_TAG}"
 9 | 	GIT_SHALLOW       TRUE
10 | 	SOURCE_DIR        "${CMAKE_BINARY_DIR}/iconfontcppheaders-src"
11 | 	CONFIGURE_COMMAND ""
12 | 	BUILD_COMMAND     ""
13 | 	INSTALL_COMMAND   ""
14 | 	TEST_COMMAND      ""
15 | )
16 | 


--------------------------------------------------------------------------------
/include/SequentialAnimationGroup.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_SEQUENTIALANIMATIONGROUP
 2 | #define CLASS_SEQUENTIALANIMATIONGROUP
 3 | 
 4 | #include "AnimationGroup.h"
 5 | 
 6 | /// The sequential animation group class
 7 | class SequentialAnimationGroup : public AnimationGroup
 8 | {
 9 |   public:
10 | 	nctl::UniquePtr<IAnimation> clone() const override;
11 | 
12 | 	inline Type type() const override { return Type::SEQUENTIAL_GROUP; }
13 | 
14 | 	void pause() override;
15 | 	void play() override;
16 | 
17 | 	void update(float deltaTime) override;
18 | 
19 |   private:
20 | 	int nextPlayingIndex(int playingIndex);
21 | };
22 | 
23 | #endif
24 | 


--------------------------------------------------------------------------------
/include/singletons.h:
--------------------------------------------------------------------------------
 1 | #ifndef SINGLETONS_H
 2 | #define SINGLETONS_H
 3 | 
 4 | #include <nctl/UniquePtr.h>
 5 | #include "Configuration.h"
 6 | 
 7 | class Canvas;
 8 | class SpriteManager;
 9 | class AnimationManager;
10 | class UserInterface;
11 | class LuaSaver;
12 | class ScriptManager;
13 | 
14 | extern Configuration theCfg;
15 | extern nctl::UniquePtr<Canvas> theCanvas;
16 | extern nctl::UniquePtr<Canvas> theResizedCanvas;
17 | extern nctl::UniquePtr<Canvas> theSpritesheet;
18 | extern nctl::UniquePtr<SpriteManager> theSpriteMgr;
19 | extern nctl::UniquePtr<AnimationManager> theAnimMgr;
20 | extern nctl::UniquePtr<LuaSaver> theSaver;
21 | extern nctl::UniquePtr<ScriptManager> theScriptingMgr;
22 | 
23 | #endif
24 | 


--------------------------------------------------------------------------------
/.itch.toml:
--------------------------------------------------------------------------------
 1 | [[actions]]
 2 | name = "play"
 3 | path = "bin/spookyghost.exe"
 4 | platform = "windows"
 5 | 
 6 | [[actions]]
 7 | name = "play"
 8 | path = "SpookyGhost.app"
 9 | platform = "osx"
10 | 
11 | [[actions]]
12 | name = "play"
13 | path = "launch.sh"
14 | platform = "linux"
15 | 
16 | [[prereqs]]
17 | name = "vcredist-2019-x64"
18 | 
19 | [[actions]]
20 | name = "manual"
21 | path = "docs/documentation.html"
22 | platform = "windows"
23 | 
24 | [[actions]]
25 | name = "manual"
26 | path = "SpookyGhost.app/Contents/Resources/docs/documentation.html"
27 | platform = "osx"
28 | 
29 | [[actions]]
30 | name = "manual"
31 | path = "share/doc/spookyghost/documentation.html"
32 | platform = "linux"
33 | 
34 | [[actions]]
35 | name = "forums"
36 | path = "https://encelo.itch.io/SpookyGhost/community"
37 | 


--------------------------------------------------------------------------------
/src/gui/openfile.cpp:
--------------------------------------------------------------------------------
 1 | #ifdef _WIN32
 2 | 	#include <ncine/common_windefines.h>
 3 | 	#include <windef.h>
 4 | 	#include <WinBase.h>
 5 | 	#include <winuser.h>
 6 | 	#include <shellapi.h>
 7 | 	#include <fileapi.h>
 8 | #endif
 9 | 
10 | #include "gui/UserInterface.h"
11 | 
12 | void UserInterface::openFile(const char *filename)
13 | {
14 | #if defined(_WIN32)
15 | 	static char buffer[256];
16 | 	_fullpath(buffer, filename, 256);
17 | 	ShellExecute(NULL, "open", buffer, NULL, NULL, SW_SHOWNORMAL);
18 | #elif defined(__APPLE__)
19 | 	static nctl::String execString(256);
20 | 	execString.format("open %s", filename);
21 | 	system(execString.data());
22 | #elif defined(__linux__)
23 | 	static nctl::String execString(256);
24 | 	execString.format("xdg-open %s", filename);
25 | 	system(execString.data());
26 | #endif
27 | }
28 | 


--------------------------------------------------------------------------------
/include/gui/gui_common.h:
--------------------------------------------------------------------------------
 1 | #ifndef COMMON_GUI_H
 2 | #define COMMON_GUI_H
 3 | 
 4 | #include <ncine/imgui.h>
 5 | #include <nctl/String.h>
 6 | 
 7 | namespace nc = ncine;
 8 | 
 9 | namespace ncine {
10 | class DropEvent;
11 | }
12 | 
13 | namespace ui {
14 | 
15 | static const unsigned int MaxStringLength = 256;
16 | 
17 | extern nctl::String comboString;
18 | extern nctl::String auxString;
19 | 
20 | #ifdef __ANDROID__
21 | extern nctl::String androidCfgDir;
22 | extern nctl::String androidSaveDir;
23 | #endif
24 | 
25 | extern nctl::String projectsDataDir;
26 | extern nctl::String texturesDataDir;
27 | extern nctl::String scriptsDataDir;
28 | 
29 | int inputTextCallback(ImGuiInputTextCallbackData *data);
30 | 
31 | extern const nc::DropEvent *dropEvent;
32 | extern unsigned int dropUpdateFrames;
33 | }
34 | 
35 | #endif
36 | 


--------------------------------------------------------------------------------
/include/AnimationGroup.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_ANIMATIONGROUP
 2 | #define CLASS_ANIMATIONGROUP
 3 | 
 4 | #include <nctl/Array.h>
 5 | #include "IAnimation.h"
 6 | #include "LoopComponent.h"
 7 | 
 8 | /// The animation group abstract class
 9 | class AnimationGroup : public IAnimation
10 | {
11 |   public:
12 | 	AnimationGroup();
13 | 
14 | 	inline nctl::Array<nctl::UniquePtr<IAnimation>> &anims() { return anims_; }
15 | 	inline const nctl::Array<nctl::UniquePtr<IAnimation>> &anims() const { return anims_; }
16 | 
17 | 	inline const LoopComponent &loop() const { return loop_; }
18 | 	inline LoopComponent &loop() { return loop_; }
19 | 
20 | 	void stop() override;
21 | 
22 |   protected:
23 | 	LoopComponent loop_;
24 | 	nctl::Array<nctl::UniquePtr<IAnimation>> anims_;
25 | 
26 | 	void cloneTo(AnimationGroup &other) const;
27 | 
28 | 	void stopAnimations();
29 | 	bool shouldReverseAnimDirection();
30 | 	void reverseAnimDirection(IAnimation &anim);
31 | };
32 | 
33 | #endif
34 | 


--------------------------------------------------------------------------------
/include/Script.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_SCRIPT
 2 | #define CLASS_SCRIPT
 3 | 
 4 | #include <nctl/String.h>
 5 | #include <ncine/LuaStateManager.h>
 6 | 
 7 | struct lua_State;
 8 | 
 9 | class Sprite;
10 | 
11 | namespace nc = ncine;
12 | 
13 | /// The class representing a single Lua script
14 | class Script
15 | {
16 |   public:
17 | 	Script();
18 | 	Script(const char *filename);
19 | 
20 | 	inline bool canRun() const { return canRun_; }
21 | 
22 | 	inline const nctl::String &name() const { return name_; }
23 | 	inline void setName(const nctl::String &name) { name_ = name; }
24 | 
25 | 	inline const char *errorMsg() const { return errorMessage_.data(); }
26 | 
27 | 	bool load(const char *filename);
28 | 	bool reload();
29 | 
30 |   private:
31 | 	bool canRun_;
32 | 	nctl::String name_;
33 | 	nctl::String errorMessage_;
34 | 	nc::LuaStateManager luaState_;
35 | 
36 | 	bool run(const char *filename, const char *chunkName);
37 | 
38 | 	friend class ScriptAnimation;
39 | };
40 | 
41 | #endif
42 | 


--------------------------------------------------------------------------------
/src/gui/gui_common.cpp:
--------------------------------------------------------------------------------
 1 | #include "gui/gui_common.h"
 2 | 
 3 | namespace ui {
 4 | 
 5 | nctl::String comboString(1024 * 4);
 6 | nctl::String auxString(MaxStringLength);
 7 | 
 8 | #ifdef __ANDROID__
 9 | nctl::String androidCfgDir(MaxStringLength);
10 | nctl::String androidSaveDir(MaxStringLength);
11 | #endif
12 | 
13 | nctl::String projectsDataDir(MaxStringLength);
14 | nctl::String texturesDataDir(MaxStringLength);
15 | nctl::String scriptsDataDir(MaxStringLength);
16 | 
17 | int inputTextCallback(ImGuiInputTextCallbackData *data)
18 | {
19 | 	nctl::String *string = reinterpret_cast<nctl::String *>(data->UserData);
20 | 	if (data->EventFlag == ImGuiInputTextFlags_CallbackResize)
21 | 	{
22 | 		// Resize string callback
23 | 		ASSERT(data->Buf == string->data());
24 | 		string->setLength(static_cast<unsigned int>(data->BufTextLen));
25 | 		data->Buf = string->data();
26 | 	}
27 | 	return 0;
28 | }
29 | 
30 | const nc::DropEvent *dropEvent = nullptr;
31 | unsigned int dropUpdateFrames = 0;
32 | 
33 | }
34 | 


--------------------------------------------------------------------------------
/include/SerializerContext.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_SERIALIZERCONTEXT
 2 | #define CLASS_SERIALIZERCONTEXT
 3 | 
 4 | #include <nctl/UniquePtr.h>
 5 | #include <nctl/HashMap.h>
 6 | #include <nctl/Array.h>
 7 | 
 8 | struct SerializerContext
 9 | {
10 | 	nctl::UniquePtr<nctl::HashMap<const Texture *, unsigned int>> textureHash;
11 | 	nctl::UniquePtr<nctl::HashMap<const SpriteEntry *, unsigned int>> spriteEntryHash;
12 | 	nctl::UniquePtr<nctl::HashMap<const Script *, unsigned int>> scriptHash;
13 | 	nctl::UniquePtr<nctl::HashMap<const IAnimation *, unsigned int>> animationHash;
14 | };
15 | 
16 | struct DeserializerContext
17 | {
18 | 	int version = 0;
19 | 	nctl::Array<nctl::UniquePtr<Texture>> *textures = nullptr;
20 | 	nctl::Array<nctl::UniquePtr<SpriteEntry>> *spriteEntries = nullptr;
21 | 	nctl::Array<nctl::UniquePtr<Script>> *scripts = nullptr;
22 | 	nctl::Array<nctl::UniquePtr<IAnimation>> *animations = nullptr;
23 | 	nctl::HashMap<const char *, const GridFunction *> *functionHash = nullptr;
24 | };
25 | 
26 | #endif
27 | 


--------------------------------------------------------------------------------
/include/ScriptAnimation.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_SCRIPTANIMATION
 2 | #define CLASS_SCRIPTANIMATION
 3 | 
 4 | #include "CurveAnimation.h"
 5 | 
 6 | class Sprite;
 7 | class Script;
 8 | 
 9 | /// The script animation class
10 | class ScriptAnimation : public CurveAnimation
11 | {
12 |   public:
13 | 	ScriptAnimation();
14 | 	ScriptAnimation(Sprite *sprite, Script *script);
15 | 
16 | 	nctl::UniquePtr<IAnimation> clone() const override;
17 | 
18 | 	inline Type type() const override { return Type::SCRIPT; }
19 | 
20 | 	void play() override;
21 | 	void perform() override;
22 | 
23 | 	inline const Sprite *sprite() const { return sprite_; }
24 | 	inline Sprite *sprite() { return sprite_; }
25 | 	void setSprite(Sprite *sprite);
26 | 
27 | 	inline const Script *script() const { return script_; }
28 | 	inline Script *script() { return script_; }
29 | 	void setScript(Script *script);
30 | 
31 |   private:
32 | 	Sprite *sprite_;
33 | 	Script *script_;
34 | 
35 | 	bool runScript(const char *functionName, float value);
36 | };
37 | 
38 | #endif
39 | 


--------------------------------------------------------------------------------
/include/main.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_MYEVENTHANDLER
 2 | #define CLASS_MYEVENTHANDLER
 3 | 
 4 | #include <ncine/IAppEventHandler.h>
 5 | #include <ncine/IInputEventHandler.h>
 6 | #include <nctl/UniquePtr.h>
 7 | 
 8 | namespace ncine {
 9 | 
10 | class AppConfiguration;
11 | 
12 | }
13 | 
14 | class UserInterface;
15 | 
16 | namespace nc = ncine;
17 | 
18 | /// My nCine event handler
19 | class MyEventHandler :
20 |     public nc::IAppEventHandler,
21 |     public nc::IInputEventHandler
22 | {
23 |   public:
24 | 	void onPreInit(nc::AppConfiguration &config) override;
25 | 	void onInit() override;
26 | 	void onShutdown() override;
27 | 	void onFrameStart() override;
28 | 	void onChangeScalingFactor(float factor) override;
29 | 
30 | 	void onKeyPressed(const nc::KeyboardEvent &event) override;
31 | 	void onKeyReleased(const nc::KeyboardEvent &event) override;
32 | 	void onFilesDropped(const nc::DropEvent &event) override;
33 | 	bool onQuitRequest() override;
34 | 
35 |   private:
36 | 	nctl::UniquePtr<UserInterface> ui_;
37 | };
38 | 
39 | #endif
40 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2020-2025 Angelo Theodorou
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a
 4 | copy of this software and associated documentation files (the "Software"),
 5 | to deal in the Software without restriction, including without limitation
 6 | the rights to use, copy, modify, merge, publish, distribute, sublicense,
 7 | and/or sell copies of the Software, and to permit persons to whom the
 8 | Software is furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
14 | OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
18 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
19 | DEALINGS IN THE SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/include/CurveAnimation.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_CURVEANIMATION
 2 | #define CLASS_CURVEANIMATION
 3 | 
 4 | #include "IAnimation.h"
 5 | #include "EasingCurve.h"
 6 | 
 7 | /// The curve animation abstract class
 8 | class CurveAnimation : public IAnimation
 9 | {
10 |   public:
11 | 	CurveAnimation();
12 | 	CurveAnimation(EasingCurve::Type curveType, Loop::Mode loopMode);
13 | 
14 | 	/// Returns true if the curve value is applied at every update even if the animation is stopped
15 | 	inline bool isLocked() const { return isLocked_; }
16 | 	void setLocked(bool locked) { isLocked_ = locked; }
17 | 
18 | 	void stop() override;
19 | 	void play() override;
20 | 
21 | 	void update(float deltaTime) override;
22 | 	virtual void perform() = 0;
23 | 
24 | 	inline const EasingCurve &curve() const { return curve_; }
25 | 	inline EasingCurve &curve() { return curve_; }
26 | 
27 | 	inline float speed() const { return speed_; }
28 | 	inline float &speed() { return speed_; }
29 | 	inline void setSpeed(float speed) { speed_ = speed; }
30 | 
31 |   protected:
32 | 	bool isLocked_;
33 | 	EasingCurve curve_;
34 | 	float speed_;
35 | 
36 | 	void cloneTo(CurveAnimation &other) const;
37 | };
38 | 
39 | #endif
40 | 


--------------------------------------------------------------------------------
/include/GridAnimation.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_GRIDANIMATION
 2 | #define CLASS_GRIDANIMATION
 3 | 
 4 | #include <nctl/Array.h>
 5 | #include <ncine/Vector2.h>
 6 | #include "CurveAnimation.h"
 7 | #include "GridFunctionParameter.h"
 8 | 
 9 | class Sprite;
10 | class GridFunction;
11 | 
12 | /// The grid animation class
13 | class GridAnimation : public CurveAnimation
14 | {
15 |   public:
16 | 	GridAnimation();
17 | 	GridAnimation(Sprite *sprite);
18 | 
19 | 	nctl::UniquePtr<IAnimation> clone() const override;
20 | 
21 | 	inline Type type() const override { return Type::GRID; }
22 | 
23 | 	void perform() override;
24 | 
25 | 	inline const Sprite *sprite() const { return sprite_; }
26 | 	inline Sprite *sprite() { return sprite_; }
27 | 	void setSprite(Sprite *sprite);
28 | 
29 | 	inline const GridFunction *function() const { return gridFunction_; }
30 | 	void setFunction(const GridFunction *function);
31 | 
32 | 	inline const nctl::Array<GridFunctionParameter> &parameters() const { return params_; }
33 | 	inline nctl::Array<GridFunctionParameter> &parameters() { return params_; }
34 | 
35 |   private:
36 | 	Sprite *sprite_;
37 | 	const GridFunction *gridFunction_;
38 | 	nctl::Array<GridFunctionParameter> params_;
39 | };
40 | 
41 | #endif
42 | 


--------------------------------------------------------------------------------
/include/gui/CanvasGuiSection.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_CANVASGUISECTION
 2 | #define CLASS_CANVASGUISECTION
 3 | 
 4 | #include <ncine/Vector2.h>
 5 | 
 6 | namespace nc = ncine;
 7 | 
 8 | class Canvas;
 9 | 
10 | /// The class handling the zoom controls of the canvas window
11 | class CanvasGuiSection
12 | {
13 |   public:
14 | 	void create(Canvas &canvas);
15 | 
16 | 	void setResize(const nc::Vector2i &size);
17 | 	void setResize(int width, int height);
18 | 	float zoomAmount() const;
19 | 
20 | 	void resetZoom();
21 | 	void increaseZoom();
22 | 	void decreaseZoom();
23 | 
24 | 	inline bool showBorders() const { return showBorders_; }
25 | 
26 |   private:
27 | 	enum ZoomLevel
28 | 	{
29 | 		X1_8,
30 | 		X1_4,
31 | 		X1_2,
32 | 		X1,
33 | 		X2,
34 | 		X4,
35 | 		X8
36 | 	};
37 | 
38 | 	enum ResizePreset
39 | 	{
40 | 		SIZE16,
41 | 		SIZE32,
42 | 		SIZE64,
43 | 		SIZE128,
44 | 		SIZE256,
45 | 		SIZE512,
46 | 		CUSTOM
47 | 	};
48 | 
49 | 	ZoomLevel zoomLevel_ = ZoomLevel::X1;
50 | 	ResizePreset resizePreset_ = ResizePreset::SIZE256;
51 | 	nc::Vector2i customCanvasSize_;
52 | 	int canvasZoomRadio_ = CanvasGuiSection::ZoomLevel::X1;
53 | 	bool showBorders_ = false;
54 | 
55 | 	nc::Vector2i resizeVector(ResizePreset resizePreset);
56 | 	nc::Vector2i resizeVector();
57 | };
58 | 
59 | #endif
60 | 


--------------------------------------------------------------------------------
/include/SpriteManager.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_SPRITEMANAGER
 2 | #define CLASS_SPRITEMANAGER
 3 | 
 4 | #include <nctl/Array.h>
 5 | 
 6 | class SpriteEntry;
 7 | class SpriteGroup;
 8 | class Sprite;
 9 | class Texture;
10 | 
11 | /// The sprite manager class
12 | class SpriteManager
13 | {
14 |   public:
15 | 	SpriteManager();
16 | 
17 | 	inline nctl::Array<nctl::UniquePtr<Texture>> &textures() { return textures_; }
18 | 	inline const nctl::Array<nctl::UniquePtr<Texture>> &textures() const { return textures_; }
19 | 
20 | 	inline SpriteGroup &root() { return *root_; }
21 | 	inline const SpriteGroup &root() const { return *root_; }
22 | 
23 | 	nctl::Array<nctl::UniquePtr<SpriteEntry>> &children();
24 | 	const nctl::Array<nctl::UniquePtr<SpriteEntry>> &children() const;
25 | 
26 | 	inline nctl::Array<Sprite *> &sprites() { return spritesArray_; }
27 | 	inline const nctl::Array<Sprite *> &sprites() const { return spritesArray_; }
28 | 
29 | 	void updateSpritesArray();
30 | 	void update();
31 | 
32 | 	int textureIndex(const Texture *texture) const;
33 | 
34 | 	SpriteGroup *addGroup(SpriteEntry *selected);
35 | 	Sprite *addSprite(SpriteEntry *selected, Texture *texture);
36 | 	void clear();
37 | 
38 |   private:
39 | 	nctl::Array<nctl::UniquePtr<Texture>> textures_;
40 | 	nctl::UniquePtr<SpriteGroup> root_;
41 | 
42 | 	nctl::Array<Sprite *> spritesWithoutParent_;
43 | 	nctl::Array<Sprite *> spritesArray_;
44 | 
45 | 	void transform(Sprite *sprite);
46 | 	void draw(Sprite *sprite);
47 | };
48 | 
49 | #endif
50 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | [![Linux](https://github.com/SpookyGhost2D/SpookyGhost/workflows/Linux/badge.svg)](https://github.com/SpookyGhost2D/SpookyGhost/actions?workflow=Linux)
 2 | [![macOS](https://github.com/SpookyGhost2D/SpookyGhost/workflows/macOS/badge.svg)](https://github.com/SpookyGhost2D/SpookyGhost/actions?workflow=macOS)
 3 | [![Windows](https://github.com/SpookyGhost2D/SpookyGhost/workflows/Windows/badge.svg)](https://github.com/SpookyGhost2D/SpookyGhost/actions?workflow=Windows)
 4 | [![MinGW](https://github.com/SpookyGhost2D/SpookyGhost/workflows/MinGW/badge.svg)](https://github.com/SpookyGhost2D/SpookyGhost/actions?workflow=MinGW)
 5 | [![Emscripten](https://github.com/SpookyGhost2D/SpookyGhost/workflows/Emscripten/badge.svg)](https://github.com/SpookyGhost2D/SpookyGhost/actions?workflow=Emscripten)
 6 | [![Android](https://github.com/SpookyGhost2D/SpookyGhost/workflows/Android/badge.svg)](https://github.com/SpookyGhost2D/SpookyGhost/actions?workflow=Android)
 7 | [![CodeQL](https://github.com/SpookyGhost2D/SpookyGhost/workflows/CodeQL/badge.svg)](https://github.com/SpookyGhost2D/SpookyGhost/actions?workflow=CodeQL)
 8 | 
 9 | # SpookyGhost
10 | ![Screenshot](https://spookyghost2d.github.io/spookyghost.png "Screenshot")
11 | 
12 | A procedural sprite animation tool made with the [nCine](https://ncine.github.io/).
13 | 
14 | You can read the manual [online](https://spookyghost2d.github.io/docs/) or you can access it by pressing F1 in the program.
15 | 
16 | For more information: https://encelo.itch.io/spookyghost
17 | 


--------------------------------------------------------------------------------
/include/RenderingResources.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_RENDERINGRESOURCES
 2 | #define CLASS_RENDERINGRESOURCES
 3 | 
 4 | #include <nctl/UniquePtr.h>
 5 | #include <ncine/Matrix4x4.h>
 6 | 
 7 | namespace ncine {
 8 | 
 9 | class GLShaderProgram;
10 | 
11 | }
12 | 
13 | namespace nc = ncine;
14 | 
15 | /// The class that creates and handles some common rendering resources
16 | class RenderingResources
17 | {
18 |   public:
19 | 	static inline nc::GLShaderProgram *spriteShaderProgram() { return spriteShaderProgram_.get(); }
20 | 	static inline nc::GLShaderProgram *meshSpriteShaderProgram() { return meshSpriteShaderProgram_.get(); }
21 | 	static inline const nc::Matrix4x4f &projectionMatrix() { return projectionMatrix_; }
22 | 
23 | 	static inline const nc::Vector2f &canvasSize() { return canvasSize_; }
24 | 	static void setCanvasSize(int width, int height);
25 | 
26 | 	static void create();
27 | 	static void dispose();
28 | 
29 |   private:
30 | 	static nctl::UniquePtr<nc::GLShaderProgram> spriteShaderProgram_;
31 | 	static nctl::UniquePtr<nc::GLShaderProgram> meshSpriteShaderProgram_;
32 | 
33 | 	static nc::Vector2f canvasSize_;
34 | 	static nc::Matrix4x4f projectionMatrix_;
35 | 
36 | 	/// Static class, deleted constructor
37 | 	RenderingResources() = delete;
38 | 	/// Static class, deleted copy constructor
39 | 	RenderingResources(const RenderingResources &other) = delete;
40 | 	/// Static class, deleted assignement operator
41 | 	RenderingResources &operator=(const RenderingResources &other) = delete;
42 | };
43 | 
44 | #endif
45 | 


--------------------------------------------------------------------------------
/include/Canvas.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_CANVAS
 2 | #define CLASS_CANVAS
 3 | 
 4 | #include <nctl/UniquePtr.h>
 5 | #include <ncine/Vector2.h>
 6 | #include <ncine/Colorf.h>
 7 | 
 8 | namespace ncine {
 9 | 
10 | class GLTexture;
11 | class GLFramebufferObject;
12 | 
13 | }
14 | 
15 | namespace nc = ncine;
16 | 
17 | /// The canvas texture to display the results
18 | class Canvas
19 | {
20 |   public:
21 | 	nc::Colorf backgroundColor;
22 | 
23 | 	Canvas();
24 | 	Canvas(int width, int height);
25 | 
26 | 	inline void resizeTexture(const nc::Vector2i &size) { resizeTexture(size.x, size.y); }
27 | 	void resizeTexture(int width, int height);
28 | 
29 | 	void bindTexture();
30 | 	void unbindTexture();
31 | 
32 | 	void bindRead();
33 | 	void bindDraw();
34 | 	void bind();
35 | 	void unbind();
36 | 
37 | 	void save(const char *filename);
38 | 
39 | 	inline int maxTextureSize() const { return maxTextureSize_; }
40 | 
41 | 	inline int texWidth() const { return texWidth_; }
42 | 	inline int texHeight() const { return texHeight_; }
43 | 	inline nc::Vector2i size() const { return nc::Vector2i(texWidth_, texHeight_); }
44 | 
45 | 	inline unsigned int texSizeInBytes() const { return texSizeInBytes_; }
46 | 	inline unsigned char *texPixels() { return pixels_.get(); }
47 | 
48 | 	void *imguiTexId();
49 | 
50 |   private:
51 | 	int maxTextureSize_;
52 | 	int texWidth_;
53 | 	int texHeight_;
54 | 	unsigned int texSizeInBytes_;
55 | 
56 | 	nctl::UniquePtr<unsigned char[]> pixels_;
57 | 	nctl::UniquePtr<nc::GLTexture> texture_;
58 | 
59 | 	nctl::UniquePtr<nc::GLFramebufferObject> fbo_;
60 | };
61 | 
62 | #endif
63 | 


--------------------------------------------------------------------------------
/include/Texture.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_TEXTURE
 2 | #define CLASS_TEXTURE
 3 | 
 4 | #include <nctl/UniquePtr.h>
 5 | #include <nctl/String.h>
 6 | #include <ncine/Vector2.h>
 7 | 
 8 | namespace ncine {
 9 | 
10 | class GLTexture;
11 | class ITextureLoader;
12 | 
13 | }
14 | 
15 | namespace nc = ncine;
16 | 
17 | /// The texture wrapper class
18 | class Texture
19 | {
20 |   public:
21 | 	static const unsigned int MaxNameLength = 64;
22 | 
23 | 	Texture(const char *filename);
24 | 	Texture(const char *bufferName, const unsigned char *bufferPtr, unsigned long int bufferSize);
25 | 
26 | 	inline const nctl::String &name() const { return name_; }
27 | 	inline void setName(const nctl::String &name) { name_ = name; }
28 | 
29 | 	inline nc::Vector2i size() const { return nc::Vector2i(width_, height_); }
30 | 	inline int width() const { return width_; }
31 | 	inline int height() const { return height_; }
32 | 
33 | 	inline unsigned int numChannels() const { return numChannels_; }
34 | 	inline unsigned int dataSize() const { return dataSize_; }
35 | 
36 | 	bool loadFromFile(const char *filename);
37 | 	bool loadFromMemory(const char *bufferName, const unsigned char *bufferPtr, unsigned long int bufferSize);
38 | 
39 | 	void bind();
40 | 	void *imguiTexId();
41 | 
42 |   private:
43 | 	nctl::UniquePtr<nc::GLTexture> glTexture_;
44 | 	nctl::String name_;
45 | 	int width_;
46 | 	int height_;
47 | 	unsigned int numChannels_;
48 | 	unsigned long dataSize_;
49 | 
50 | 	void initialize(const nc::ITextureLoader &texLoader);
51 | 	void load(const nc::ITextureLoader &texLoader);
52 | 
53 | 	friend class Sprite;
54 | };
55 | 
56 | #endif
57 | 


--------------------------------------------------------------------------------
/include/Configuration.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_CONFIGURATION
 2 | #define CLASS_CONFIGURATION
 3 | 
 4 | #include <nctl/Array.h>
 5 | #include <nctl/String.h>
 6 | #include <ncine/Vector2.h>
 7 | #include <ncine/AppConfiguration.h>
 8 | #include "gui/gui_common.h"
 9 | 
10 | namespace nc = ncine;
11 | 
12 | /// The configuration to be loaded or saved
13 | struct Configuration
14 | {
15 | 	const int version = 6;
16 | 
17 | 	int width = 1280;
18 | 	int height = 720;
19 | 	float refreshRate = 0.0f; // Added in version 6
20 | 	int windowPositionX = nc::AppConfiguration::WindowPositionIgnore; // Added in version 6
21 | 	int windowPositionY = nc::AppConfiguration::WindowPositionIgnore; // Added in version 6
22 | 	bool fullScreen = false;
23 | 	bool resizable = true;
24 | 
25 | 	bool withVSync = true;
26 | 	int frameLimit = 0;
27 | 
28 | 	int canvasWidth = 256;
29 | 	int canvasHeight = 256;
30 | 
31 | 	bool autoGuiScaling = true; // Added in version 6
32 | #ifdef __ANDROID__
33 | 	float guiScaling = 2.0f; // Added in version 2
34 | #else
35 | 	float guiScaling = 1.0f; // Added in version 2
36 | #endif
37 | 	nctl::String startupProjectName = nctl::String(ui::MaxStringLength); // Renamed in version 3
38 | 	bool autoPlayOnStart = true;
39 | 
40 | 	nctl::String projectsPath = nctl::String(ui::MaxStringLength); // Renamed in version 3
41 | 	nctl::String texturesPath = nctl::String(ui::MaxStringLength);
42 | 	nctl::String scriptsPath = nctl::String(ui::MaxStringLength); // Added in version 3
43 | 
44 | 	bool showTipsOnStart = true; // Added in version 4
45 | 	nctl::Array<nctl::String> pinnedDirectories = nctl::Array<nctl::String>(8); // Added in version 5
46 | };
47 | 
48 | #endif
49 | 


--------------------------------------------------------------------------------
/include/PropertyAnimation.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_PROPERTYANIMATION
 2 | #define CLASS_PROPERTYANIMATION
 3 | 
 4 | #include <nctl/String.h>
 5 | #include "CurveAnimation.h"
 6 | 
 7 | class Sprite;
 8 | 
 9 | namespace Properties {
10 | 
11 | const unsigned int Count = 12;
12 | static const char *Strings[Count] = { "None", "Position X", "Position Y", "Rotation",
13 | 	                                  "Scale X", "Scale Y", "AnchorPoint X", "AnchorPoint Y",
14 | 	                                  "Opacity", "Red Channel", "Green Channel", "Blue Channel" };
15 | 
16 | enum Types
17 | {
18 | 	NONE,
19 | 	POSITION_X,
20 | 	POSITION_Y,
21 | 	ROTATION,
22 | 	SCALE_X,
23 | 	SCALE_Y,
24 | 	ANCHOR_X,
25 | 	ANCHOR_Y,
26 | 	OPACITY,
27 | 	COLOR_R,
28 | 	COLOR_G,
29 | 	COLOR_B
30 | };
31 | 
32 | }
33 | 
34 | /// The property animation class
35 | class PropertyAnimation : public CurveAnimation
36 | {
37 |   public:
38 | 	PropertyAnimation();
39 | 	PropertyAnimation(Sprite *sprite);
40 | 
41 | 	nctl::UniquePtr<IAnimation> clone() const override;
42 | 
43 | 	inline Type type() const override { return Type::PROPERTY; }
44 | 
45 | 	void perform() override;
46 | 
47 | 	inline Properties::Types propertyType() const { return propertyType_; }
48 | 	const char *propertyName() const;
49 | 	void setProperty(Properties::Types propertyType);
50 | 	void setProperty(const char *name);
51 | 
52 | 	inline const Sprite *sprite() const { return sprite_; }
53 | 	inline Sprite *sprite() { return sprite_; }
54 | 	void setSprite(Sprite *sprite);
55 | 
56 | 	inline const float *property() const { return property_; }
57 | 
58 |   private:
59 | 	Properties::Types propertyType_;
60 | 	float *property_;
61 | 	Sprite *sprite_;
62 | };
63 | 
64 | #endif
65 | 


--------------------------------------------------------------------------------
/src/LoopComponent.cpp:
--------------------------------------------------------------------------------
 1 | #include <ncine/common_constants.h>
 2 | #include "LoopComponent.h"
 3 | 
 4 | ///////////////////////////////////////////////////////////
 5 | // CONSTRUCTORS and DESTRUCTOR
 6 | ///////////////////////////////////////////////////////////
 7 | 
 8 | LoopComponent::LoopComponent(Loop::Mode mode, Loop::Direction direction)
 9 |     : mode_(mode), direction_(direction),
10 |       forward_(true), hasJustReset_(false),
11 |       delay_(0.0f), currentDelay_(0.0f), waitDelay_(false)
12 | {
13 | }
14 | 
15 | LoopComponent::LoopComponent(Loop::Mode mode)
16 |     : LoopComponent(mode, Loop::Direction::FORWARD)
17 | {
18 | }
19 | 
20 | LoopComponent::LoopComponent()
21 |     : LoopComponent(Loop::Mode::DISABLED, Loop::Direction::FORWARD)
22 | {
23 | }
24 | 
25 | ///////////////////////////////////////////////////////////
26 | // PUBLIC FUNCTIONS
27 | ///////////////////////////////////////////////////////////
28 | 
29 | void LoopComponent::reverseDirection()
30 | {
31 | 	if (direction_ == Loop::Direction::FORWARD)
32 | 		direction_ = Loop::Direction::BACKWARD;
33 | 	else
34 | 		direction_ = Loop::Direction::FORWARD;
35 | }
36 | 
37 | void LoopComponent::resetDelay()
38 | {
39 | 	hasJustReset_ = false;
40 | 	currentDelay_ = 0.0f;
41 | 	waitDelay_ = false;
42 | }
43 | 
44 | bool LoopComponent::shouldWaitDelay(float deltaTime)
45 | {
46 | 	if (waitDelay_)
47 | 	{
48 | 		currentDelay_ += deltaTime;
49 | 		if (currentDelay_ >= delay_)
50 | 		{
51 | 			currentDelay_ = 0.0f;
52 | 			waitDelay_ = false;
53 | 		}
54 | 		else
55 | 			return true;
56 | 	}
57 | 
58 | 	if (waitDelay_ == false && hasJustReset_)
59 | 	{
60 | 		waitDelay_ = true;
61 | 		hasJustReset_ = false;
62 | 	}
63 | 
64 | 	return false;
65 | }
66 | 


--------------------------------------------------------------------------------
/include/LuaSaver.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_LUASAVER
 2 | #define CLASS_LUASAVER
 3 | 
 4 | #include <nctl/UniquePtr.h>
 5 | #include <nctl/String.h>
 6 | 
 7 | class LuaSerializer;
 8 | class UserInterface;
 9 | class Canvas;
10 | class SpriteManager;
11 | class ScriptManager;
12 | class AnimationManager;
13 | struct Configuration;
14 | 
15 | /// The class that helps with Lua serialization
16 | class LuaSaver
17 | {
18 |   public:
19 | 	struct Data
20 | 	{
21 | 		Data(Canvas &ca, SpriteManager &spm, ScriptManager &scm, AnimationManager &am)
22 | 		    : canvas(ca), spriteMgr(spm), scriptMgr(scm), animMgr(am) {}
23 | 
24 | 		Canvas &canvas;
25 | 		SpriteManager &spriteMgr;
26 | 		ScriptManager &scriptMgr;
27 | 		AnimationManager &animMgr;
28 | 	};
29 | 
30 | 	LuaSaver(unsigned int bufferSize);
31 | 
32 | 	bool load(const char *filename, Data &data);
33 | 	void save(const char *filename, const Data &data);
34 | 
35 | 	bool loadCfg(const char *filename, Configuration &cfg);
36 | 	void saveCfg(const char *filename, const Configuration &cfg);
37 | 
38 | 	/// Returns the default configuration file
39 | 	static const nctl::String &defaultCfgFile() { return defaultCfgFile_; }
40 | 	/// Sets the default configuration file
41 | 	static void setDefaultCfgFile(const char *filename) { defaultCfgFile_ = filename; }
42 | 
43 | 	/// Loads the configuration using the default file
44 | 	inline bool loadCfg(Configuration &cfg) { return loadCfg(defaultCfgFile_.data(), cfg); }
45 | 	/// Saves the configuration using the default file
46 | 	inline void saveCfg(const Configuration &cfg) { saveCfg(defaultCfgFile_.data(), cfg); }
47 | 
48 |   private:
49 | 	nctl::UniquePtr<LuaSerializer> serializer_;
50 | 	static nctl::String defaultCfgFile_;
51 | };
52 | 
53 | #endif
54 | 


--------------------------------------------------------------------------------
/include/AnimationManager.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_ANIMATIONMANAGER
 2 | #define CLASS_ANIMATIONMANAGER
 3 | 
 4 | #include <nctl/UniquePtr.h>
 5 | #include "AnimationGroup.h"
 6 | 
 7 | class Sprite;
 8 | class Script;
 9 | 
10 | /// The animation manager class
11 | class AnimationManager
12 | {
13 |   public:
14 | 	AnimationManager();
15 | 
16 | 	inline AnimationGroup &animGroup() { return *animGroup_; }
17 | 	inline const AnimationGroup &animGroup() const { return *animGroup_; }
18 | 
19 | 	inline nctl::Array<nctl::UniquePtr<IAnimation>> &anims() { return (*animGroup_).anims(); }
20 | 	inline const nctl::Array<nctl::UniquePtr<IAnimation>> &anims() const { return (*animGroup_).anims(); }
21 | 
22 | 	inline IAnimation::State state() const { return animGroup_->state(); }
23 | 
24 | 	inline float speedMultiplier() const { return speedMultiplier_; }
25 | 	inline float &speedMultiplier() { return speedMultiplier_; }
26 | 	inline void setSpeedMultiplier(float speedMultiplier) { speedMultiplier_ = speedMultiplier; }
27 | 
28 | 	inline void stop() { animGroup_->stop(); }
29 | 	inline void pause() { animGroup_->pause(); }
30 | 	inline void play() { animGroup_->play(); }
31 | 
32 | 	void update(float deltaTime);
33 | 	void clear();
34 | 
35 | 	void removeAnimation(IAnimation *anim);
36 | 	void removeSprite(Sprite *sprite);
37 | 	void assignGridAnchorToParameters(Sprite *sprite);
38 | 	void removeScript(Script *script);
39 | 	void reloadScript(Script *script);
40 | 	void initScriptsForSprite(Sprite *sprite);
41 | 	void overrideSprite(AnimationGroup &animGroup, Sprite *sprite);
42 | 	void cloneSpriteAnimations(const Sprite *fromSprite, Sprite *toSprite);
43 | 
44 |   private:
45 | 	float speedMultiplier_;
46 | 	nctl::UniquePtr<AnimationGroup> animGroup_;
47 | };
48 | 
49 | #endif
50 | 


--------------------------------------------------------------------------------
/include/gui/RenderGuiWindow.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_RENDERGUIWINDOW
 2 | #define CLASS_RENDERGUIWINDOW
 3 | 
 4 | #include <ncine/Vector2.h>
 5 | #include "gui/gui_common.h"
 6 | 
 7 | namespace nc = ncine;
 8 | 
 9 | class UserInterface;
10 | 
11 | struct SaveAnim
12 | {
13 | 	inline float inverseFps() const { return 1.0f / static_cast<float>(fps); }
14 | 
15 | 	nctl::String filename = nctl::String(ui::MaxStringLength);
16 | 	unsigned int numSavedFrames = 0;
17 | 	int numFrames = 60;
18 | 	int fps = 60;
19 | 	float canvasResize = 1.0f;
20 | 	nc::Vector2i sheetDestPos;
21 | };
22 | 
23 | /// The render gui window class
24 | class RenderGuiWindow
25 | {
26 |   public:
27 | 	enum ResizeLevel
28 | 	{
29 | 		X1_8,
30 | 		X1_4,
31 | 		X1_2,
32 | 		X1,
33 | 		X2,
34 | 		X4,
35 | 		X8
36 | 	};
37 | 
38 | 	enum SpritesheetLayout
39 | 	{
40 | 		HRECTANGLE,
41 | 		VRECTANGLE,
42 | 		HSTRIP,
43 | 		VSTRIP,
44 | 		CUSTOM,
45 | 	};
46 | 
47 | 	ResizeLevel resizeLevel = ResizeLevel::X1;
48 | 	SpritesheetLayout layout = SpritesheetLayout::HRECTANGLE;
49 | 	nctl::String directory = nctl::String(ui::MaxStringLength);
50 | 	nctl::String filename = nctl::String(ui::MaxStringLength);
51 | 
52 | 	RenderGuiWindow(UserInterface &ui);
53 | 
54 | 	inline const SaveAnim &saveAnimStatus() const { return saveAnimStatus_; }
55 | 	inline SaveAnim &saveAnimStatus() { return saveAnimStatus_; }
56 | 	inline bool shouldSaveFrames() const { return shouldSaveFrames_; }
57 | 	inline bool shouldSaveSpritesheet() const { return shouldSaveSpritesheet_; }
58 | 
59 | 	static float resizeAmount(ResizeLevel rl);
60 | 	float resizeAmount() const;
61 | 	void setResize(float resizeAmount);
62 | 
63 | 	void create();
64 | 	void signalFrameSaved();
65 | 	void cancelRender();
66 | 
67 |   private:
68 | 	UserInterface &ui_;
69 | 	SaveAnim saveAnimStatus_;
70 | 	bool shouldSaveFrames_ = false;
71 | 	bool shouldSaveSpritesheet_ = false;
72 | };
73 | 
74 | #endif
75 | 


--------------------------------------------------------------------------------
/src/GridFunction.cpp:
--------------------------------------------------------------------------------
 1 | #include "GridFunction.h"
 2 | 
 3 | ///////////////////////////////////////////////////////////
 4 | // CONSTRUCTORS and DESTRUCTOR
 5 | ///////////////////////////////////////////////////////////
 6 | 
 7 | GridFunction::GridFunction()
 8 |     : name_(MaxNameLength), parametersInfo_(4), callback_(nullptr)
 9 | {
10 | }
11 | 
12 | ///////////////////////////////////////////////////////////
13 | // PUBLIC FUNCTIONS
14 | ///////////////////////////////////////////////////////////
15 | 
16 | const GridFunction::ParameterInfo &GridFunction::parameterInfo(unsigned int index) const
17 | {
18 | 	FATAL_ASSERT(index < parametersInfo_.size());
19 | 	return parametersInfo_[index];
20 | }
21 | 
22 | const char *GridFunction::parameterName(unsigned int index) const
23 | {
24 | 	FATAL_ASSERT(index < parametersInfo_.size());
25 | 	return parametersInfo_[index].name.data();
26 | }
27 | 
28 | GridFunction::ParameterType GridFunction::parameterType(unsigned int index) const
29 | {
30 | 	FATAL_ASSERT(index < parametersInfo_.size());
31 | 	return parametersInfo_[index].type;
32 | }
33 | 
34 | GridFunctionParameter &GridFunction::parameterInitialValue(unsigned int index)
35 | {
36 | 	FATAL_ASSERT(index < parametersInfo_.size());
37 | 	return parametersInfo_[index].initialValue;
38 | }
39 | 
40 | GridFunction::ParameterInfo &GridFunction::addParameter(const char *name, ParameterType type, float initialValue0)
41 | {
42 | 	parametersInfo_.pushBack(ParameterInfo(name, type, initialValue0));
43 | 	return parametersInfo_.back();
44 | }
45 | 
46 | GridFunction::ParameterInfo &GridFunction::addParameter(const char *name, ParameterType type, float initialValue0, float initialValue1)
47 | {
48 | 	parametersInfo_.pushBack(ParameterInfo(name, type, initialValue0, initialValue1));
49 | 	return parametersInfo_.back();
50 | }
51 | 
52 | void GridFunction::execute(GridAnimation &animation) const
53 | {
54 | 	if (callback_ != nullptr)
55 | 		callback_(animation);
56 | }
57 | 


--------------------------------------------------------------------------------
/include/LoopComponent.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_LOOPCOMPONENT
 2 | #define CLASS_LOOPCOMPONENT
 3 | 
 4 | namespace Loop {
 5 | 
 6 | enum class Direction
 7 | {
 8 | 	FORWARD,
 9 | 	BACKWARD
10 | };
11 | 
12 | enum class Mode
13 | {
14 | 	DISABLED,
15 | 	REWIND,
16 | 	PING_PONG
17 | };
18 | 
19 | }
20 | 
21 | /// The composition class to add looping functionality
22 | class LoopComponent
23 | {
24 |   public:
25 | 	LoopComponent(Loop::Mode mode, Loop::Direction direction);
26 | 	LoopComponent(Loop::Mode mode);
27 | 	LoopComponent();
28 | 
29 | 	inline Loop::Direction direction() const { return direction_; }
30 | 	inline void setDirection(Loop::Direction direction) { direction_ = direction; }
31 | 	void reverseDirection();
32 | 
33 | 	inline Loop::Mode mode() const { return mode_; }
34 | 	inline void setMode(Loop::Mode mode) { mode_ = mode; }
35 | 
36 | 	inline bool isGoingForward() const { return forward_; }
37 | 	inline void goForward(bool forward) { forward_ = forward; }
38 | 	inline void toggleForward() { forward_ = !forward_; }
39 | 
40 | 	/// Returns true if the loop is starting again this frame
41 | 	inline bool hasJustReset() const { return hasJustReset_; };
42 | 	inline void justResetNow() { hasJustReset_ = true; };
43 | 
44 | 	inline float delay() const { return delay_; }
45 | 	inline void setDelay(float loopDelay) { delay_ = loopDelay; }
46 | 	inline float currentDelay() const { return currentDelay_; }
47 | 
48 | 	void resetDelay();
49 | 	bool shouldWaitDelay(float deltaTime);
50 | 
51 |   private:
52 | 	Loop::Mode mode_;
53 | 	Loop::Direction direction_;
54 | 	bool forward_;
55 | 	/// A flag to indicate that a loop has just reset this frame
56 | 	bool hasJustReset_;
57 | 
58 | 	/// Delay amount in seconds before an animation loops again
59 | 	float delay_;
60 | 	/// The amount of time in seconds waited until now for the loop delay
61 | 	float currentDelay_;
62 | 	/// A flag indicating if an animation should wait for the loop delay
63 | 	bool waitDelay_;
64 | };
65 | 
66 | #endif
67 | 


--------------------------------------------------------------------------------
/src/IAnimation.cpp:
--------------------------------------------------------------------------------
 1 | #include "IAnimation.h"
 2 | #include "AnimationGroup.h"
 3 | 
 4 | ///////////////////////////////////////////////////////////
 5 | // CONSTRUCTORS and DESTRUCTOR
 6 | ///////////////////////////////////////////////////////////
 7 | 
 8 | IAnimation::IAnimation()
 9 |     : state_(State::STOPPED), parent_(nullptr),
10 |       delay_(0.0f), currentDelay_(0.0f)
11 | {}
12 | 
13 | ///////////////////////////////////////////////////////////
14 | // PUBLIC FUNCTIONS
15 | ///////////////////////////////////////////////////////////
16 | 
17 | void IAnimation::stop()
18 | {
19 | 	state_ = State::STOPPED;
20 | 	currentDelay_ = 0.0f;
21 | }
22 | 
23 | bool IAnimation::shouldWaitDelay(float deltaTime)
24 | {
25 | 	currentDelay_ += deltaTime;
26 | 	if (currentDelay_ < delay_)
27 | 		return true;
28 | 	else
29 | 	{
30 | 		currentDelay_ = delay_;
31 | 		return false;
32 | 	}
33 | }
34 | 
35 | int IAnimation::indexInParent() const
36 | {
37 | 	if (parent_ == nullptr)
38 | 		return -1;
39 | 
40 | 	int index = -1;
41 | 	const nctl::Array<nctl::UniquePtr<IAnimation>> &anims = parent_->anims();
42 | 	for (unsigned int i = 0; i < anims.size(); i++)
43 | 	{
44 | 		if (anims[i].get() == this)
45 | 		{
46 | 			index = static_cast<int>(i);
47 | 			break;
48 | 		}
49 | 	}
50 | 
51 | 	return index;
52 | }
53 | 
54 | ///////////////////////////////////////////////////////////
55 | // PROTECTED FUNCTIONS
56 | ///////////////////////////////////////////////////////////
57 | 
58 | void IAnimation::cloneTo(IAnimation &other) const
59 | {
60 | 	other.name = name;
61 | 	other.enabled = enabled;
62 | 	// Animation state is not cloned
63 | 	other.state_ = State::STOPPED;
64 | 	other.parent_ = parent_;
65 | 	other.delay_ = delay_;
66 | 	other.currentDelay_ = 0.0f;
67 | }
68 | 
69 | bool IAnimation::insideSequential() const
70 | {
71 | 	IAnimation *parent = parent_;
72 | 	while (parent != nullptr)
73 | 	{
74 | 		if (parent->type() == Type::SEQUENTIAL_GROUP)
75 | 			return true;
76 | 		parent = parent->parent_;
77 | 	}
78 | 
79 | 	return false;
80 | }
81 | 


--------------------------------------------------------------------------------
/include/EasingCurve.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_EASINGCURVE
 2 | #define CLASS_EASINGCURVE
 3 | 
 4 | #include "LoopComponent.h"
 5 | 
 6 | /// The easing curve class
 7 | class EasingCurve
 8 | {
 9 |   public:
10 | 	enum class Type
11 | 	{
12 | 		LINEAR,
13 | 		QUAD,
14 | 		CUBIC,
15 | 		QUART,
16 | 		QUINT,
17 | 		SINE,
18 | 		EXPO,
19 | 		CIRC,
20 | 	};
21 | 
22 | 	EasingCurve(Type type, Loop::Mode loopMode);
23 | 
24 | 	inline Type type() const { return type_; }
25 | 	inline void setType(Type type) { type_ = type; }
26 | 
27 | 	inline const LoopComponent &loop() const { return loop_; }
28 | 	inline LoopComponent &loop() { return loop_; }
29 | 
30 | 	inline bool hasInitialValue() const { return withInitialValue_; }
31 | 	inline bool &hasInitialValue() { return withInitialValue_; }
32 | 	inline void enableInitialValue(bool withInitialValue) { withInitialValue_ = withInitialValue; }
33 | 
34 | 	inline float time() const { return time_; }
35 | 	inline float &time() { return time_; }
36 | 	void setTime(float time);
37 | 
38 | 	inline float initialValue() const { return initialValue_; }
39 | 	inline float &initialValue() { return initialValue_; }
40 | 	void setInitialValue(float initialValue);
41 | 
42 | 	inline float start() const { return start_; }
43 | 	inline float &start() { return start_; }
44 | 	inline void setStart(float start) { start_ = start; }
45 | 
46 | 	inline float end() const { return end_; }
47 | 	inline float &end() { return end_; }
48 | 	inline void setEnd(float end) { end_ = end; }
49 | 
50 | 	inline float scale() const { return scale_; }
51 | 	inline float &scale() { return scale_; }
52 | 	void setScale(float scale) { scale_ = scale; }
53 | 
54 | 	inline float shift() const { return shift_; }
55 | 	inline float &shift() { return shift_; }
56 | 	void setShift(float shift) { shift_ = shift; }
57 | 
58 | 	void reset();
59 | 	float value();
60 | 	void next(float deltaTime);
61 | 
62 |   private:
63 | 	Type type_;
64 | 	LoopComponent loop_;
65 | 	bool withInitialValue_;
66 | 
67 | 	float time_;
68 | 	float initialValue_;
69 | 	float start_;
70 | 	float end_;
71 | 
72 | 	float scale_;
73 | 	float shift_;
74 | };
75 | 
76 | #endif
77 | 


--------------------------------------------------------------------------------
/src/Script.cpp:
--------------------------------------------------------------------------------
 1 | #include <ncine/LuaUtils.h>
 2 | #include <ncine/FileSystem.h>
 3 | #include "singletons.h"
 4 | #include "Script.h"
 5 | #include "ScriptManager.h"
 6 | 
 7 | ///////////////////////////////////////////////////////////
 8 | // CONSTRUCTORS and DESTRUCTOR
 9 | ///////////////////////////////////////////////////////////
10 | 
11 | Script::Script()
12 |     : canRun_(false), name_(256), errorMessage_(256),
13 |       luaState_(nc::LuaStateManager::ApiType::NONE,
14 |                 nc::LuaStateManager::StatisticsTracking::DISABLED,
15 |                 nc::LuaStateManager::StandardLibraries::LOADED)
16 | {
17 | }
18 | 
19 | Script::Script(const char *filename)
20 |     : Script()
21 | {
22 | 	load(filename);
23 | }
24 | 
25 | ///////////////////////////////////////////////////////////
26 | // PUBLIC FUNCTIONS
27 | ///////////////////////////////////////////////////////////
28 | 
29 | bool Script::load(const char *filename)
30 | {
31 | 	const bool hasLoaded = nc::fs::isReadableFile(filename);
32 | 	if (hasLoaded)
33 | 	{
34 | 		name_ = filename;
35 | 		run(filename, nc::fs::baseName(filename).data());
36 | 	}
37 | 
38 | 	return hasLoaded;
39 | }
40 | 
41 | bool Script::reload()
42 | {
43 | 	nctl::String filename = name_;
44 | 	// Resolve relative path made to allow for relocatable project files
45 | 	if (nc::fs::isReadableFile(nc::fs::joinPath(theCfg.scriptsPath, name_.data()).data()))
46 | 		filename = nc::fs::joinPath(theCfg.scriptsPath, name_.data());
47 | 
48 | 	const bool hasLoaded = nc::fs::isReadableFile(filename.data());
49 | 	if (hasLoaded)
50 | 	{
51 | 		luaState_.reopen();
52 | 		run(filename.data(), name_.data());
53 | 	}
54 | 
55 | 	return hasLoaded;
56 | }
57 | 
58 | ///////////////////////////////////////////////////////////
59 | // PRIVATE FUNCTIONS
60 | ///////////////////////////////////////////////////////////
61 | 
62 | bool Script::run(const char *filename, const char *chunkName)
63 | {
64 | 	ScriptManager::exposeConstants(luaState_.state());
65 | 	ScriptManager::exposeFunctions(luaState_.state());
66 | 	canRun_ = luaState_.runFromFile(filename, chunkName, &errorMessage_);
67 | 
68 | 	return canRun_;
69 | }
70 | 


--------------------------------------------------------------------------------
/src/GridAnimation.cpp:
--------------------------------------------------------------------------------
 1 | #include "GridAnimation.h"
 2 | #include "Sprite.h"
 3 | #include "GridFunction.h"
 4 | #include "GridFunctionLibrary.h"
 5 | #include "AnimationGroup.h"
 6 | 
 7 | ///////////////////////////////////////////////////////////
 8 | // CONSTRUCTORS and DESTRUCTOR
 9 | ///////////////////////////////////////////////////////////
10 | 
11 | GridAnimation::GridAnimation()
12 |     : GridAnimation(nullptr)
13 | {
14 | }
15 | 
16 | GridAnimation::GridAnimation(Sprite *sprite)
17 |     : CurveAnimation(EasingCurve::Type::LINEAR, Loop::Mode::DISABLED),
18 |       sprite_(nullptr), gridFunction_(nullptr), params_(4)
19 | {
20 | 	setSprite(sprite);
21 | }
22 | 
23 | ///////////////////////////////////////////////////////////
24 | // PUBLIC FUNCTIONS
25 | ///////////////////////////////////////////////////////////
26 | 
27 | nctl::UniquePtr<IAnimation> GridAnimation::clone() const
28 | {
29 | 	nctl::UniquePtr<GridAnimation> anim = nctl::makeUnique<GridAnimation>(sprite_);
30 | 	CurveAnimation::cloneTo(*anim);
31 | 
32 | 	anim->setSprite(sprite_);
33 | 	anim->gridFunction_ = gridFunction_;
34 | 	anim->params_ = params_;
35 | 
36 | 	return nctl::move(anim);
37 | }
38 | 
39 | void GridAnimation::perform()
40 | {
41 | 	if (sprite_ && sprite_->visible && gridFunction_)
42 | 		gridFunction_->execute(*this);
43 | }
44 | 
45 | void GridAnimation::setSprite(Sprite *sprite)
46 | {
47 | 	if (sprite_ != sprite)
48 | 	{
49 | 		if (sprite_)
50 | 			sprite_->decrementGridAnimCounter();
51 | 		if (sprite)
52 | 			sprite->incrementGridAnimCounter();
53 | 
54 | 		sprite_ = sprite;
55 | 	}
56 | }
57 | 
58 | void GridAnimation::setFunction(const GridFunction *function)
59 | {
60 | 	if (function)
61 | 	{
62 | 		if (function->numParameters() != params_.size())
63 | 			params_.setSize(function->numParameters());
64 | 
65 | 		for (unsigned int i = 0; i < function->numParameters(); i++)
66 | 		{
67 | 			const GridFunction::ParameterInfo &paramInfo = function->parameterInfo(i);
68 | 			params_[i].value0 = paramInfo.initialValue.value0;
69 | 			params_[i].value1 = paramInfo.initialValue.value1;
70 | 		}
71 | 	}
72 | 	else
73 | 		params_.clear();
74 | 
75 | 	gridFunction_ = function;
76 | }
77 | 


--------------------------------------------------------------------------------
/include/IAnimation.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_IANIMATION
 2 | #define CLASS_IANIMATION
 3 | 
 4 | #include <nctl/String.h>
 5 | 
 6 | class AnimationGroup;
 7 | 
 8 | /// The animation interface class
 9 | class IAnimation
10 | {
11 |   public:
12 | 	enum class Type
13 | 	{
14 | 		PROPERTY,
15 | 		GRID,
16 | 		SCRIPT,
17 | 		SEQUENTIAL_GROUP,
18 | 		PARALLEL_GROUP
19 | 	};
20 | 
21 | 	enum class State
22 | 	{
23 | 		STOPPED,
24 | 		PAUSED,
25 | 		PLAYING
26 | 	};
27 | 
28 | 	IAnimation();
29 | 	virtual ~IAnimation() {}
30 | 
31 | 	virtual nctl::UniquePtr<IAnimation> clone() const = 0;
32 | 
33 | 	static const unsigned int MaxNameLength = 64;
34 | 	nctl::String name;
35 | 	bool enabled = true;
36 | 
37 | 	virtual Type type() const = 0;
38 | 	inline State state() const { return state_; }
39 | 	inline bool isGroup() const { return type() == Type::SEQUENTIAL_GROUP || type() == Type::PARALLEL_GROUP; }
40 | 	inline bool isStopped() const { return state_ == State::STOPPED; }
41 | 	inline bool isPaused() const { return state_ == State::PAUSED; }
42 | 	inline bool isPlaying() const { return state_ == State::PLAYING; }
43 | 
44 | 	virtual void stop();
45 | 	inline virtual void pause() { state_ = State::PAUSED; }
46 | 	inline virtual void play() { state_ = State::PLAYING; }
47 | 
48 | 	virtual void update(float deltaTime) = 0;
49 | 
50 | 	inline AnimationGroup *parent() { return parent_; }
51 | 	inline const AnimationGroup *parent() const { return parent_; }
52 | 	inline void setParent(AnimationGroup *parent) { parent_ = parent; }
53 | 
54 | 	inline float delay() const { return delay_; }
55 | 	inline void setDelay(float delay) { delay_ = delay; }
56 | 	inline float currentDelay() const { return currentDelay_; }
57 | 
58 | 	inline void resetDelay() { currentDelay_ = 0.0f; }
59 | 	bool shouldWaitDelay(float deltaTime);
60 | 
61 | 	int indexInParent() const;
62 | 
63 |   protected:
64 | 	State state_;
65 | 	AnimationGroup *parent_;
66 | 
67 | 	/// Delay amount in seconds before an animation begins to update
68 | 	float delay_;
69 | 	/// The amount of time in seconds waited until now for the delay
70 | 	float currentDelay_;
71 | 
72 | 	void cloneTo(IAnimation &other) const;
73 | 
74 | 	bool insideSequential() const;
75 | };
76 | 
77 | #endif
78 | 


--------------------------------------------------------------------------------
/include/SpriteEntry.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_SPRITEENTRY
 2 | #define CLASS_SPRITEENTRY
 3 | 
 4 | #include <nctl/Array.h>
 5 | #include <nctl/String.h>
 6 | #include <ncine/Colorf.h>
 7 | 
 8 | namespace nc = ncine;
 9 | 
10 | class Sprite;
11 | class SpriteGroup;
12 | 
13 | /// The class that contains information about an entry in the Sprites window
14 | class SpriteEntry
15 | {
16 |   public:
17 | 	enum class Type
18 | 	{
19 | 		GROUP,
20 | 		SPRITE
21 | 	};
22 | 
23 | 	SpriteEntry(Type type);
24 | 	SpriteEntry(Type type, nc::Colorf entryColor);
25 | 
26 | 	inline Type type() const { return type_; }
27 | 
28 | 	inline bool isGroup() const { return type_ == Type::GROUP; }
29 | 	inline bool isSprite() const { return type_ == Type::SPRITE; }
30 | 
31 | 	const SpriteGroup *toGroup() const;
32 | 	SpriteGroup *toGroup();
33 | 	const Sprite *toSprite() const;
34 | 	Sprite *toSprite();
35 | 
36 | 	unsigned int spriteId() const;
37 | 	void setSpriteId(unsigned int spriteId);
38 | 
39 | 	inline const SpriteGroup *parentGroup() const { return parentGroup_; }
40 | 	inline SpriteGroup *parentGroup() { return parentGroup_; }
41 | 	inline void setParentGroup(SpriteGroup *parentGroup) { parentGroup_ = parentGroup; }
42 | 
43 | 	inline const nc::Colorf &entryColor() const { return entyrColor_; }
44 | 	inline nc::Colorf &entryColor() { return entyrColor_; }
45 | 
46 | 	int indexInParent() const;
47 | 
48 |   protected:
49 | 	const Type type_;
50 | 	/// Not used if the entry is a group
51 | 	unsigned int spriteId_;
52 | 	SpriteGroup *parentGroup_ = nullptr;
53 | 	nc::Colorf entyrColor_;
54 | };
55 | 
56 | class SpriteGroup : public SpriteEntry
57 | {
58 |   public:
59 | 	SpriteGroup();
60 | 	SpriteGroup(const char *name);
61 | 	SpriteGroup(nc::Colorf entryColor, const char *name);
62 | 
63 | 	nctl::UniquePtr<SpriteGroup> clone() const;
64 | 
65 | 	inline const nctl::String &name() const { return name_; }
66 | 	inline nctl::String &name() { return name_; }
67 | 
68 | 	inline nctl::Array<nctl::UniquePtr<SpriteEntry>> &children() { return children_; }
69 | 	inline const nctl::Array<nctl::UniquePtr<SpriteEntry>> &children() const { return children_; }
70 | 
71 |   private:
72 | 	nctl::String name_;
73 | 	nctl::Array<nctl::UniquePtr<SpriteEntry>> children_;
74 | };
75 | 
76 | #endif
77 | 


--------------------------------------------------------------------------------
/include/Serializers.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_SERIALIZERS
 2 | #define CLASS_SERIALIZERS
 3 | 
 4 | #include <nctl/UniquePtr.h>
 5 | 
 6 | class LuaSerializer;
 7 | class Canvas;
 8 | class Texture;
 9 | class SpriteEntry;
10 | class SpriteGroup;
11 | class Sprite;
12 | class Script;
13 | 
14 | class LoopComponent;
15 | class IAnimation;
16 | class AnimationGroup;
17 | class PropertyAnimation;
18 | class GridAnimation;
19 | class ScriptAnimation;
20 | 
21 | class SaveAnim;
22 | 
23 | class Configuration;
24 | 
25 | namespace Serializers {
26 | 
27 | void serialize(LuaSerializer &ls, const char *name, const Canvas &canvas);
28 | void serialize(LuaSerializer &ls, const Texture &texture);
29 | void serialize(LuaSerializer &ls, const SpriteEntry *spriteEntry);
30 | void serialize(LuaSerializer &ls, const SpriteGroup &spriteGroup);
31 | void serialize(LuaSerializer &ls, const Sprite &sprite);
32 | void serialize(LuaSerializer &ls, const Script &script);
33 | 
34 | void serialize(LuaSerializer &ls, const IAnimation *anim);
35 | void serialize(LuaSerializer &ls, const AnimationGroup &anim);
36 | void serialize(LuaSerializer &ls, const PropertyAnimation &anim);
37 | void serialize(LuaSerializer &ls, const GridAnimation &anim);
38 | void serialize(LuaSerializer &ls, const ScriptAnimation &anim);
39 | 
40 | void serialize(LuaSerializer &ls, const char *name, const SaveAnim &saveAnim);
41 | 
42 | void serialize(LuaSerializer &ls, const Configuration &cf);
43 | 
44 | }
45 | 
46 | namespace Deserializers {
47 | 
48 | bool deserialize(LuaSerializer &ls, const char *name, Canvas &canvas);
49 | void deserialize(LuaSerializer &ls, nctl::UniquePtr<Texture> &texture);
50 | void deserialize(LuaSerializer &ls, nctl::UniquePtr<SpriteEntry> &spriteEntry);
51 | void deserialize(LuaSerializer &ls, nctl::UniquePtr<SpriteGroup> &spriteGroup);
52 | void deserialize(LuaSerializer &ls, nctl::UniquePtr<Sprite> &sprite);
53 | void deserialize(LuaSerializer &ls, nctl::UniquePtr<Script> &script);
54 | void deserialize(LuaSerializer &ls, nctl::UniquePtr<IAnimation> &anim);
55 | void deserialize(LuaSerializer &ls, LoopComponent &loop);
56 | bool deserialize(LuaSerializer &ls, const char *name, SaveAnim &saveAnim);
57 | void deserialize(LuaSerializer &ls, Configuration &cfg);
58 | 
59 | }
60 | 
61 | #endif
62 | 


--------------------------------------------------------------------------------
/src/AnimationGroup.cpp:
--------------------------------------------------------------------------------
 1 | #include "AnimationGroup.h"
 2 | #include "CurveAnimation.h"
 3 | 
 4 | ///////////////////////////////////////////////////////////
 5 | // CONSTRUCTORS and DESTRUCTOR
 6 | ///////////////////////////////////////////////////////////
 7 | 
 8 | AnimationGroup::AnimationGroup()
 9 |     : anims_(4)
10 | {
11 | }
12 | 
13 | ///////////////////////////////////////////////////////////
14 | // PUBLIC FUNCTIONS
15 | ///////////////////////////////////////////////////////////
16 | 
17 | void AnimationGroup::stop()
18 | {
19 | 	resetDelay();
20 | 	loop_.resetDelay();
21 | 
22 | 	if (shouldReverseAnimDirection())
23 | 	{
24 | 		for (auto &&anim : anims_)
25 | 		{
26 | 			if (anim->state() != State::STOPPED)
27 | 				reverseAnimDirection(*anim);
28 | 		}
29 | 	}
30 | 
31 | 	stopAnimations();
32 | 	state_ = State::STOPPED;
33 | }
34 | 
35 | ///////////////////////////////////////////////////////////
36 | // PROTECTED FUNCTIONS
37 | ///////////////////////////////////////////////////////////
38 | 
39 | void AnimationGroup::cloneTo(AnimationGroup &other) const
40 | {
41 | 	IAnimation::cloneTo(other);
42 | 
43 | 	other.loop_ = loop_;
44 | 	other.loop_.resetDelay();
45 | 
46 | 	for (auto &&anim : anims_)
47 | 	{
48 | 		other.anims_.pushBack(nctl::move(anim->clone()));
49 | 		other.anims_.back()->setParent(&other);
50 | 	}
51 | }
52 | 
53 | void AnimationGroup::stopAnimations()
54 | {
55 | 	if (loop_.direction() == Loop::Direction::FORWARD)
56 | 	{
57 | 		// Reverse stop to reset animations in the correct order
58 | 		for (int i = anims_.size() - 1; i >= 0; i--)
59 | 			anims_[i]->stop();
60 | 	}
61 | 	else
62 | 	{
63 | 		for (auto &&anim : anims_)
64 | 		{
65 | 			reverseAnimDirection(*anim);
66 | 			anim->stop();
67 | 			reverseAnimDirection(*anim);
68 | 		}
69 | 	}
70 | }
71 | 
72 | bool AnimationGroup::shouldReverseAnimDirection()
73 | {
74 | 	return ((loop_.mode() != Loop::Mode::PING_PONG && loop_.direction() == Loop::Direction::BACKWARD) ||
75 | 	        (loop_.mode() == Loop::Mode::PING_PONG && loop_.isGoingForward() == false));
76 | }
77 | 
78 | void AnimationGroup::reverseAnimDirection(IAnimation &anim)
79 | {
80 | 	if (anim.isGroup())
81 | 		static_cast<AnimationGroup &>(anim).loop().reverseDirection();
82 | 	else
83 | 		static_cast<CurveAnimation &>(anim).curve().loop().reverseDirection();
84 | }
85 | 


--------------------------------------------------------------------------------
/include/gui/FileDialog.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_FILEDIALOG
 2 | #define CLASS_FILEDIALOG
 3 | 
 4 | #include <nctl/Array.h>
 5 | #include <nctl/String.h>
 6 | #include <ncine/FileSystem.h>
 7 | 
 8 | namespace nc = ncine;
 9 | 
10 | class FileDialog
11 | {
12 |   public:
13 | 	enum class Sorting
14 | 	{
15 | 		NAME_ASC,
16 | 		NAME_DESC,
17 | 		SIZE_ASC,
18 | 		SIZE_DESC,
19 | 		DATE_ASC,
20 | 		DATE_DESC
21 | 	};
22 | 
23 | 	enum class SelectionType
24 | 	{
25 | 		DIRECTORY,
26 | 		FILE,
27 | 		NEW_FILE
28 | 	};
29 | 
30 | 	enum class Action
31 | 	{
32 | 		OPEN_PROJECT,
33 | 		SAVE_PROJECT,
34 | 		LOAD_TEXTURE,
35 | 		RELOAD_TEXTURE,
36 | 		LOAD_SCRIPT,
37 | 		RENDER_DIR
38 | 	};
39 | 
40 | 	struct Config
41 | 	{
42 | 		nctl::String directory = nctl::String(nc::fs::MaxPathLength);
43 | 		bool windowOpen = false;
44 | 		bool modalPopup = true;
45 | 		const char *windowIcon = "";
46 | 		const char *windowTitle = "File Browser";
47 | 		const char *okButton = "OK";
48 | 
49 | 		bool showNavigation = true;
50 | 		bool showControls = true;
51 | 		bool showExtraControls = false;
52 | 		bool showPinnedDirectories = true;
53 | #ifdef _WIN32
54 | 		bool showPermissions = false;
55 | #else
56 | 		bool showPermissions = true;
57 | #endif
58 | 		bool showSize = true;
59 | 		bool showDate = true;
60 | 		bool showHidden = false;
61 | 
62 | 		Sorting sorting = Sorting::NAME_ASC;
63 | 
64 | 		nctl::Array<nctl::String> *pinnedDirectories = nullptr;
65 | 		nctl::Array<nctl::String> directoryHistory = nctl::Array<nctl::String>(8);
66 | 		int historyIndex = -1;
67 | 
68 | 		bool sortDirectoriesfirst = true;
69 | 		SelectionType selectionType = SelectionType::FILE;
70 | 		const char *extensions = nullptr;
71 | 
72 | 		bool colors = true;
73 | 		unsigned int fileColor = IM_COL32(212, 213, 213, 255);
74 | 		unsigned int dirColor = IM_COL32(61, 174, 233, 255);
75 | 		unsigned int exeColor = IM_COL32(28, 215, 151, 255);
76 | 
77 | 		Action action = Action::OPEN_PROJECT;
78 | 		bool allowOverwrite = false;
79 | 	};
80 | 
81 | 	static Config config;
82 | 	static bool create(Config &config, nctl::String &selection);
83 | 
84 |   private:
85 | 	struct DirEntry
86 | 	{
87 | 		nctl::String name = nctl::String(nc::fs::MaxPathLength);
88 | 		bool isHidden = false;
89 | 		long int size = 0;
90 | 		nc::fs::FileDate date = {};
91 | 		int permissions = 0;
92 | 		bool isDirectory = false;
93 | 	};
94 | };
95 | 
96 | #endif
97 | 


--------------------------------------------------------------------------------
/src/shader_strings.cpp:
--------------------------------------------------------------------------------
 1 | #include "shader_strings.h"
 2 | 
 3 | char const *const ShaderStrings::sprite_vs = R"glsl(
 4 | uniform mat4 projection;
 5 | uniform mat4 modelView;
 6 | uniform vec4 color;
 7 | uniform vec4 texRect;
 8 | uniform vec2 spriteSize;
 9 | out vec2 vTexCoords;
10 | out vec4 vColor;
11 | 
12 | void main()
13 | {
14 | 	vec2 aPosition = vec2(0.5 - float(gl_VertexID >> 1), -0.5 + float(gl_VertexID % 2));
15 | 	vec2 aTexCoords = vec2(1.0 - float(gl_VertexID >> 1), float(gl_VertexID % 2));
16 | 	vec4 position = vec4(aPosition.x * spriteSize.x, aPosition.y * spriteSize.y, 0.0, 1.0);
17 | 
18 | 	gl_Position = projection * modelView * position;
19 | 	vTexCoords = vec2(aTexCoords.x * texRect.x + texRect.y, aTexCoords.y * texRect.z + texRect.w);
20 | 	vColor = color;
21 | }
22 | )glsl";
23 | 
24 | char const *const ShaderStrings::sprite_fs = R"glsl(
25 | #ifdef GL_ES
26 | precision mediump float;
27 | #endif
28 | 
29 | uniform sampler2D uTexture;
30 | in vec2 vTexCoords;
31 | in vec4 vColor;
32 | out vec4 fragColor;
33 | 
34 | void main()
35 | {
36 | 	fragColor = texture(uTexture, vTexCoords) * vColor;
37 | }
38 | )glsl";
39 | 
40 | char const *const ShaderStrings::meshsprite_vs = R"glsl(
41 | uniform mat4 projection;
42 | uniform mat4 modelView;
43 | uniform vec4 color;
44 | uniform vec4 texRect;
45 | uniform vec2 spriteSize;
46 | in vec2 aPosition;
47 | in vec2 aTexCoords;
48 | out vec2 vTexCoords;
49 | out vec4 vColor;
50 | 
51 | void main()
52 | {
53 | 	vec4 position = vec4(aPosition.x * spriteSize.x, aPosition.y * spriteSize.y, 0.0, 1.0);
54 | 	gl_Position = projection * modelView * position;
55 | 	vTexCoords = vec2(aTexCoords.x * texRect.x + texRect.y, aTexCoords.y * texRect.z + texRect.w);
56 | 	vColor = color;
57 | }
58 | )glsl";
59 | 
60 | char const *const ShaderStrings::meshsprite_snap_vs = R"glsl(
61 | uniform mat4 projection;
62 | uniform mat4 modelView;
63 | uniform vec4 color;
64 | uniform vec4 texRect;
65 | uniform vec2 spriteSize;
66 | in vec2 aPosition;
67 | in vec2 aTexCoords;
68 | out vec2 vTexCoords;
69 | out vec4 vColor;
70 | 
71 | void main()
72 | {
73 | 	vec4 position = vec4(aPosition.x * spriteSize.x, aPosition.y * spriteSize.y, 0.0, 1.0);
74 | 
75 | 	gl_Position = modelView * position;
76 | 	gl_Position.x = round(gl_Position.x);
77 | 	gl_Position.y = round(gl_Position.y);
78 | 	gl_Position = projection * gl_Position;
79 | 
80 | 	vTexCoords = vec2(aTexCoords.x * texRect.x + texRect.y, aTexCoords.y * texRect.z + texRect.w);
81 | 	vColor = color;
82 | }
83 | )glsl";
84 | 


--------------------------------------------------------------------------------
/include/GridFunction.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_GRIDFUNCTION
 2 | #define CLASS_GRIDFUNCTION
 3 | 
 4 | #include <nctl/Array.h>
 5 | #include <nctl/String.h>
 6 | #include "GridFunctionParameter.h"
 7 | 
 8 | class GridAnimation;
 9 | 
10 | namespace nc = ncine;
11 | 
12 | /// The class that applies function to the grid
13 | class GridFunction
14 | {
15 |   public:
16 | 	static const unsigned int MaxNameLength = 64;
17 | 	using CallbackType = void (*)(GridAnimation &gridAnimation);
18 | 
19 | 	enum class ParameterType
20 | 	{
21 | 		FLOAT,
22 | 		VECTOR2F
23 | 	};
24 | 
25 | 	enum class ValueMultiply
26 | 	{
27 | 		IDENTITY,
28 | 		SPRITE_WIDTH,
29 | 		SPRITE_HEIGHT
30 | 	};
31 | 
32 | 	enum class AnchorType
33 | 	{
34 | 		NONE,
35 | 		X,
36 | 		Y,
37 | 		XY
38 | 	};
39 | 
40 | 	struct ParameterInfo
41 | 	{
42 | 		ParameterInfo()
43 | 		    : name(MaxNameLength), type(ParameterType::FLOAT) {}
44 | 		ParameterInfo(const char *paramName, ParameterType paramType)
45 | 		    : name(paramName), type(paramType), initialValue(0.0f, 0.0f) {}
46 | 		ParameterInfo(const char *paramName, ParameterType paramType, float initialValue0)
47 | 		    : name(paramName), type(paramType), initialValue(initialValue0, initialValue0) {}
48 | 		ParameterInfo(const char *paramName, ParameterType paramType, float initialValue0, float initialValue1)
49 | 		    : name(paramName), type(paramType), initialValue(initialValue0, initialValue1) {}
50 | 		ParameterInfo(const ParameterInfo &) = default;
51 | 		ParameterInfo &operator=(const ParameterInfo &) = default;
52 | 
53 | 		nctl::String name;
54 | 		ParameterType type;
55 | 		GridFunctionParameter initialValue;
56 | 		GridFunctionParameter minValue;
57 | 		GridFunctionParameter maxValue;
58 | 		ValueMultiply initialMultiply = ValueMultiply::IDENTITY;
59 | 		ValueMultiply minMultiply = ValueMultiply::IDENTITY;
60 | 		ValueMultiply maxMultiply = ValueMultiply::IDENTITY;
61 | 		AnchorType anchorType = AnchorType::NONE;
62 | 	};
63 | 
64 | 	GridFunction();
65 | 
66 | 	inline const nctl::String &name() const { return name_; };
67 | 	inline void setName(const char *name) { name_ = name; }
68 | 
69 | 	inline unsigned int numParameters() const { return parametersInfo_.size(); };
70 | 
71 | 	const ParameterInfo &parameterInfo(unsigned int index) const;
72 | 	const char *parameterName(unsigned int index) const;
73 | 	ParameterType parameterType(unsigned int index) const;
74 | 	GridFunctionParameter &parameterInitialValue(unsigned int index);
75 | 
76 | 	ParameterInfo &addParameter(const char *name, ParameterType type, float initialValue0);
77 | 	ParameterInfo &addParameter(const char *name, ParameterType type, float initialValue0, float initialvalue1);
78 | 
79 | 	inline void setCallback(CallbackType callback) { callback_ = callback; }
80 | 
81 | 	void execute(GridAnimation &animation) const;
82 | 
83 |   private:
84 | 	nctl::String name_;
85 | 	nctl::Array<ParameterInfo> parametersInfo_;
86 | 	CallbackType callback_;
87 | };
88 | 
89 | #endif
90 | 


--------------------------------------------------------------------------------
/src/RenderingResources.cpp:
--------------------------------------------------------------------------------
 1 | #include "RenderingResources.h"
 2 | #include <ncine/GLShaderProgram.h>
 3 | #include <ncine/Application.h>
 4 | #include <ncine/AppConfiguration.h>
 5 | 
 6 | #include "shader_strings.h"
 7 | 
 8 | ///////////////////////////////////////////////////////////
 9 | // STATIC DEFINITIONS
10 | ///////////////////////////////////////////////////////////
11 | 
12 | nctl::UniquePtr<nc::GLShaderProgram> RenderingResources::spriteShaderProgram_;
13 | nctl::UniquePtr<nc::GLShaderProgram> RenderingResources::meshSpriteShaderProgram_;
14 | 
15 | nc::Vector2f RenderingResources::canvasSize_(0.0f, 0.0f);
16 | nc::Matrix4x4f RenderingResources::projectionMatrix_ = nc::Matrix4x4f::Identity;
17 | 
18 | ///////////////////////////////////////////////////////////
19 | // PUBLIC FUNCTIONS
20 | ///////////////////////////////////////////////////////////
21 | 
22 | namespace {
23 | 
24 | struct ShaderLoad
25 | {
26 | 	nctl::UniquePtr<nc::GLShaderProgram> &shaderProgram;
27 | 	const char *vertexShader;
28 | 	const char *fragmentShader;
29 | 	nc::GLShaderProgram::Introspection introspection;
30 | };
31 | 
32 | }
33 | 
34 | void RenderingResources::setCanvasSize(int width, int height)
35 | {
36 | 	canvasSize_.set(width, height);
37 | 	projectionMatrix_ = nc::Matrix4x4f::ortho(0.0f, width, 0.0f, height, 0.0f, 1.0f);
38 | }
39 | 
40 | void RenderingResources::create()
41 | {
42 | 	LOGI("Creating rendering resources...");
43 | 
44 | 	const nc::AppConfiguration &appCfg = nc::theApplication().appConfiguration();
45 | 
46 | 	ShaderLoad shadersToLoad[] = {
47 | 		{ RenderingResources::spriteShaderProgram_, ShaderStrings::sprite_vs, ShaderStrings::sprite_fs, nc::GLShaderProgram::Introspection::ENABLED },
48 | 		{ RenderingResources::meshSpriteShaderProgram_, ShaderStrings::meshsprite_vs, ShaderStrings::sprite_fs, nc::GLShaderProgram::Introspection::ENABLED },
49 | 	};
50 | 
51 | 	const nc::GLShaderProgram::QueryPhase queryPhase = appCfg.deferShaderQueries ? nc::GLShaderProgram::QueryPhase::DEFERRED : nc::GLShaderProgram::QueryPhase::IMMEDIATE;
52 | 	const unsigned int numShaderToLoad = (sizeof(shadersToLoad) / sizeof(*shadersToLoad));
53 | 	for (unsigned int i = 0; i < numShaderToLoad; i++)
54 | 	{
55 | 		const ShaderLoad &shaderToLoad = shadersToLoad[i];
56 | 
57 | 		shaderToLoad.shaderProgram = nctl::makeUnique<nc::GLShaderProgram>(queryPhase);
58 | 		shaderToLoad.shaderProgram->attachShaderFromString(GL_VERTEX_SHADER, shaderToLoad.vertexShader);
59 | 		shaderToLoad.shaderProgram->attachShaderFromString(GL_FRAGMENT_SHADER, shaderToLoad.fragmentShader);
60 | 		shaderToLoad.shaderProgram->link(shaderToLoad.introspection);
61 | 		FATAL_ASSERT(shaderToLoad.shaderProgram->status() != nc::GLShaderProgram::Status::LINKING_FAILED);
62 | 	}
63 | 
64 | 	LOGI("Rendering resources created");
65 | }
66 | 
67 | void RenderingResources::dispose()
68 | {
69 | 	meshSpriteShaderProgram_.reset(nullptr);
70 | 	spriteShaderProgram_.reset(nullptr);
71 | 
72 | 	LOGI("Rendering resources disposed");
73 | }
74 | 


--------------------------------------------------------------------------------
/src/CurveAnimation.cpp:
--------------------------------------------------------------------------------
  1 | #include "CurveAnimation.h"
  2 | #include "AnimationGroup.h"
  3 | 
  4 | ///////////////////////////////////////////////////////////
  5 | // CONSTRUCTORS and DESTRUCTOR
  6 | ///////////////////////////////////////////////////////////
  7 | 
  8 | CurveAnimation::CurveAnimation()
  9 |     : CurveAnimation(EasingCurve::Type::LINEAR, Loop::Mode::DISABLED)
 10 | {
 11 | }
 12 | 
 13 | CurveAnimation::CurveAnimation(EasingCurve::Type type, Loop::Mode loopMode)
 14 |     : isLocked_(true), curve_(type, loopMode), speed_(1.0f)
 15 | {
 16 | }
 17 | 
 18 | ///////////////////////////////////////////////////////////
 19 | // PUBLIC FUNCTIONS
 20 | ///////////////////////////////////////////////////////////
 21 | 
 22 | void CurveAnimation::stop()
 23 | {
 24 | 	resetDelay();
 25 | 	curve_.loop().resetDelay();
 26 | 
 27 | 	curve_.reset();
 28 | 	state_ = State::STOPPED;
 29 | }
 30 | 
 31 | void CurveAnimation::play()
 32 | {
 33 | 	if (enabled)
 34 | 	{
 35 | 		if (state_ == State::STOPPED)
 36 | 			curve_.reset();
 37 | 		state_ = State::PLAYING;
 38 | 	}
 39 | }
 40 | 
 41 | void CurveAnimation::update(float deltaTime)
 42 | {
 43 | 	switch (state_)
 44 | 	{
 45 | 		case State::STOPPED:
 46 | 			if (curve().hasInitialValue())
 47 | 				curve().setTime(curve().initialValue());
 48 | 
 49 | 			if (parent_->state() != State::PLAYING && isLocked_)
 50 | 				perform();
 51 | 			break;
 52 | 		case State::PAUSED:
 53 | 			if (parent_->state() != State::PLAYING && isLocked_)
 54 | 				perform();
 55 | 			break;
 56 | 		case State::PLAYING:
 57 | 			if (shouldWaitDelay(deltaTime))
 58 | 				return;
 59 | 
 60 | 			if (insideSequential() && curve_.loop().mode() != Loop::Mode::DISABLED)
 61 | 			{
 62 | 				// Disable looping if the animation is inside a sequential group
 63 | 				const Loop::Mode loopMode = curve_.loop().mode();
 64 | 				curve_.loop().setMode(Loop::Mode::DISABLED);
 65 | 				curve_.next(speed_ * deltaTime);
 66 | 				curve_.loop().setMode(loopMode);
 67 | 			}
 68 | 			else
 69 | 			{
 70 | 				if (curve_.loop().shouldWaitDelay(deltaTime) == false)
 71 | 					curve_.next(speed_ * deltaTime);
 72 | 			}
 73 | 
 74 | 			perform();
 75 | 
 76 | 			if (curve_.loop().mode() == Loop::Mode::DISABLED)
 77 | 			{
 78 | 				if ((curve_.loop().direction() == Loop::Direction::FORWARD && curve().time() >= curve().end()) ||
 79 | 				    (curve_.loop().direction() == Loop::Direction::BACKWARD && curve().time() <= curve().start()))
 80 | 				{
 81 | 					resetDelay();
 82 | 					curve_.loop().resetDelay();
 83 | 					state_ = State::STOPPED;
 84 | 				}
 85 | 			}
 86 | 			break;
 87 | 	}
 88 | }
 89 | 
 90 | ///////////////////////////////////////////////////////////
 91 | // PROTECTED FUNCTIONS
 92 | ///////////////////////////////////////////////////////////
 93 | 
 94 | void CurveAnimation::cloneTo(CurveAnimation &other) const
 95 | {
 96 | 	IAnimation::cloneTo(other);
 97 | 
 98 | 	// Always disable locking for cloned animations
 99 | 	other.isLocked_ = false;
100 | 	other.curve_ = curve_;
101 | 	other.curve_.loop().resetDelay();
102 | 	other.speed_ = speed_;
103 | }
104 | 


--------------------------------------------------------------------------------
/src/ScriptAnimation.cpp:
--------------------------------------------------------------------------------
  1 | #include <ncine/LuaUtils.h>
  2 | #include <ncine/LuaDebug.h>
  3 | #include "ScriptAnimation.h"
  4 | #include "Script.h"
  5 | #include "ScriptManager.h"
  6 | #include "Sprite.h"
  7 | #include "AnimationGroup.h"
  8 | 
  9 | ///////////////////////////////////////////////////////////
 10 | // CONSTRUCTORS and DESTRUCTOR
 11 | ///////////////////////////////////////////////////////////
 12 | 
 13 | ScriptAnimation::ScriptAnimation()
 14 |     : ScriptAnimation(nullptr, nullptr)
 15 | {
 16 | }
 17 | 
 18 | ScriptAnimation::ScriptAnimation(Sprite *sprite, Script *script)
 19 |     : CurveAnimation(EasingCurve::Type::LINEAR, Loop::Mode::DISABLED),
 20 |       sprite_(nullptr), script_(nullptr)
 21 | {
 22 | 	setSprite(sprite);
 23 | 	setScript(script);
 24 | 
 25 | 	// Locking is disabled to limit the number of script calls
 26 | 	isLocked_ = false;
 27 | }
 28 | 
 29 | ///////////////////////////////////////////////////////////
 30 | // PUBLIC FUNCTIONS
 31 | ///////////////////////////////////////////////////////////
 32 | 
 33 | nctl::UniquePtr<IAnimation> ScriptAnimation::clone() const
 34 | {
 35 | 	nctl::UniquePtr<ScriptAnimation> anim = nctl::makeUnique<ScriptAnimation>(sprite_, script_);
 36 | 	CurveAnimation::cloneTo(*anim);
 37 | 
 38 | 	anim->setSprite(sprite_);
 39 | 	anim->setScript(script_);
 40 | 
 41 | 	return nctl::move(anim);
 42 | }
 43 | 
 44 | void ScriptAnimation::play()
 45 | {
 46 | 	CurveAnimation::play();
 47 | 	if (sprite_)
 48 | 		runScript("init", curve_.value());
 49 | }
 50 | 
 51 | void ScriptAnimation::perform()
 52 | {
 53 | 	if (sprite_ && sprite_->visible)
 54 | 		runScript("update", curve_.value());
 55 | }
 56 | 
 57 | void ScriptAnimation::setSprite(Sprite *sprite)
 58 | {
 59 | 	if (sprite_ != sprite)
 60 | 	{
 61 | 		if (sprite_)
 62 | 			sprite_->decrementGridAnimCounter();
 63 | 		if (sprite)
 64 | 			sprite->incrementGridAnimCounter();
 65 | 
 66 | 		sprite_ = sprite;
 67 | 	}
 68 | }
 69 | 
 70 | void ScriptAnimation::setScript(Script *script)
 71 | {
 72 | 	script_ = script;
 73 | }
 74 | 
 75 | ///////////////////////////////////////////////////////////
 76 | // PRIVATE FUNCTIONS
 77 | ///////////////////////////////////////////////////////////
 78 | 
 79 | bool ScriptAnimation::runScript(const char *functionName, float value)
 80 | {
 81 | 	if (sprite_ == nullptr || script_ == nullptr)
 82 | 		return false;
 83 | 
 84 | 	lua_State *L = script_->luaState_.state();
 85 | 	const int type = nc::LuaUtils::getGlobal(L, functionName);
 86 | 
 87 | 	if (nc::LuaUtils::isFunction(type))
 88 | 	{
 89 | 		ScriptManager::pushSprite(L, sprite_);
 90 | 		nc::LuaUtils::push(L, value);
 91 | 		const int status = nc::LuaUtils::pcall(L, 1, 0);
 92 | 		if (nc::LuaUtils::isStatusOk(status) == false)
 93 | 		{
 94 | 			LOGE_X("Error running \"%s\" function for script \"%s\" (%s):\n%s", functionName, script_->name().data(),
 95 | 			       nc::LuaDebug::statusToString(status), nc::LuaUtils::retrieve<const char *>(L, -1));
 96 | 			nc::LuaUtils::pop(L);
 97 | 		}
 98 | 	}
 99 | 	else
100 | 		nc::LuaUtils::pop(L);
101 | 
102 | 	return true;
103 | }
104 | 


--------------------------------------------------------------------------------
/.github/workflows/codeql-analysis.yml:
--------------------------------------------------------------------------------
 1 | name: 'CodeQL'
 2 | 
 3 | env:
 4 |   LIBRARIES_BRANCH: libraries-OS-COMPILER
 5 |   NCINE_SOURCE_BRANCH: BRANCH_NAME
 6 |   IMGUI_VERSION_TAG: v1.92.5-docking
 7 | 
 8 | on: [push, workflow_dispatch]
 9 | 
10 | jobs:
11 |   analyze:
12 |     name: 'Analyze'
13 |     runs-on: 'ubuntu-24.04'
14 | 
15 |     strategy:
16 |       fail-fast: false
17 | 
18 |     steps:
19 |     - name: 'Checkout Repository'
20 |       uses: actions/checkout@v4
21 | 
22 |     - name: 'Initialize CodeQL'
23 |       uses: github/codeql-action/init@v1
24 |       with:
25 |         languages: 'cpp'
26 | 
27 |     - run: |
28 |         # Install nCine Build Dependencies
29 |         sudo apt-get update
30 |         sudo apt-get install -y libgl-dev libxext-dev libxrandr-dev libwayland-dev
31 | 
32 |         # Download nCine-libraries and project data
33 |         export OS=linux
34 |         export CC=gcc
35 |         export BRANCH_NAME=$(git describe --tags --exact-match 2> /dev/null || git symbolic-ref -q --short HEAD || git rev-parse --short HEAD)
36 | 
37 |         export LIBRARIES_BRANCH=`echo $LIBRARIES_BRANCH | sed 's/OS/'"$OS"'/'`
38 |         export LIBRARIES_BRANCH=`echo $LIBRARIES_BRANCH | sed 's/COMPILER/'"$CC"'/'`
39 | 
40 |         cd ..
41 |         git clone https://github.com/nCine/nCine-libraries-artifacts.git
42 |         cd nCine-libraries-artifacts
43 |         git checkout $LIBRARIES_BRANCH
44 |         LIBRARIES_FILE=$(ls -t | head -n 1) && tar xpzf $LIBRARIES_FILE
45 |         mv nCine-external ..
46 |         cd ..
47 |         rm -rf nCine-libraries-artifacts
48 | 
49 |         git clone https://github.com/$GITHUB_REPOSITORY-data.git
50 | 
51 |         # Download nCine source and data
52 |         export BuildType=Debug
53 |         export NCINE_SOURCE_BRANCH=`echo $NCINE_SOURCE_BRANCH | sed 's/BRANCH_NAME/'"$BRANCH_NAME"'/'`
54 | 
55 |         git clone https://github.com/nCine/nCine-data.git
56 |         git clone https://github.com/nCine/nCine.git --branch $NCINE_SOURCE_BRANCH
57 | 
58 |         # CMake Configuration and Make of nCine as a static library
59 |         cd nCine
60 |         export CMAKE_ARGS="-B ../nCine-build-$BuildType -D CMAKE_BUILD_TYPE=$BuildType -D NCINE_DYNAMIC_LIBRARY=OFF -D IMGUI_VERSION_TAG=$IMGUI_VERSION_TAG -D NCINE_PREFERRED_BACKEND=SDL2 -D NCINE_WITH_SCENEGRAPH=OFF -D NCINE_WITH_THREADS=OFF -D NCINE_WITH_WEBP=OFF -D NCINE_WITH_AUDIO=OFF -D NCINE_WITH_SCRIPTING_API=OFF -D NCINE_BUILD_TESTS=OFF"
61 | 
62 |         export CMAKE_ARGS="$CMAKE_ARGS -D CMAKE_PREFIX_PATH=$(pwd)/../nCine-external"
63 | 
64 |         cmake $CMAKE_ARGS
65 |         cd ..
66 |         make -j $(getconf _NPROCESSORS_ONLN) -C nCine-build-Debug
67 | 
68 |         # CMake Configuration and Make
69 |         export PROJECT_NAME=${GITHUB_REPOSITORY##*/}
70 | 
71 |         cd $PROJECT_NAME
72 |         cmake -B ../$PROJECT_NAME-build-$BuildType -D CMAKE_PREFIX_PATH=$(pwd)/../nCine-external -D CMAKE_BUILD_TYPE=$BuildType -D nCine_DIR=$(pwd)/../nCine-build-$BuildType
73 | 
74 |         export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$(pwd)/../nCine-external/lib
75 |         make -j $(getconf _NPROCESSORS_ONLN) -C ../$PROJECT_NAME-build-$BuildType
76 | 
77 |     - name: 'Perform CodeQL Analysis'
78 |       uses: github/codeql-action/analyze@v1
79 | 


--------------------------------------------------------------------------------
/include/ScriptManager.h:
--------------------------------------------------------------------------------
 1 | #ifndef CLASS_SCRIPTMANAGER
 2 | #define CLASS_SCRIPTMANAGER
 3 | 
 4 | #include <nctl/Array.h>
 5 | 
 6 | struct lua_State;
 7 | 
 8 | class Sprite;
 9 | class Script;
10 | 
11 | namespace nc = ncine;
12 | 
13 | /// The class that handles Lua scripts
14 | class ScriptManager
15 | {
16 |   public:
17 | 	ScriptManager() {}
18 | 
19 | 	inline nctl::Array<nctl::UniquePtr<Script>> &scripts() { return scripts_; }
20 | 	inline const nctl::Array<nctl::UniquePtr<Script>> &scripts() const { return scripts_; }
21 | 
22 | 	void clear();
23 | 
24 | 	int scriptIndex(const Script *script) const;
25 | 
26 | 	static void pushSprite(lua_State *L, Sprite *sprite);
27 | 
28 |   private:
29 | 	nctl::Array<nctl::UniquePtr<Script>> scripts_;
30 | 
31 | 	static Sprite *retrieveSprite(lua_State *L);
32 | 
33 | 	static void exposeConstants(lua_State *L);
34 | 	static void exposeFunctions(lua_State *L);
35 | 
36 | 	static int canvasWidth(lua_State *L);
37 | 	static int canvasHeight(lua_State *L);
38 | 	static int textureWidth(lua_State *L);
39 | 	static int textureHeight(lua_State *L);
40 | 	static int width(lua_State *L);
41 | 	static int height(lua_State *L);
42 | 
43 | 	static int position(lua_State *L);
44 | 	static int positionX(lua_State *L);
45 | 	static int positionY(lua_State *L);
46 | 	static int rotation(lua_State *L);
47 | 	static int scale(lua_State *L);
48 | 	static int scaleX(lua_State *L);
49 | 	static int scaleY(lua_State *L);
50 | 	static int anchorPoint(lua_State *L);
51 | 	static int anchorPointX(lua_State *L);
52 | 	static int anchorPointY(lua_State *L);
53 | 	static int color(lua_State *L);
54 | 	static int texRect(lua_State *L);
55 | 	static int isFlippedX(lua_State *L);
56 | 	static int isFlippedY(lua_State *L);
57 | 	static int rgbBlendingPreset(lua_State *L);
58 | 	static int alphaBlendingPreset(lua_State *L);
59 | 	static int numVertices(lua_State *L);
60 | 
61 | 	static int vertices(lua_State *L);
62 | 	static int verticesXY(lua_State *L);
63 | 	static int verticesUV(lua_State *L);
64 | 	static int verticesX(lua_State *L);
65 | 	static int verticesY(lua_State *L);
66 | 	static int verticesU(lua_State *L);
67 | 	static int verticesV(lua_State *L);
68 | 
69 | 	static int setPosition(lua_State *L);
70 | 	static int setPositionX(lua_State *L);
71 | 	static int setPositionY(lua_State *L);
72 | 	static int setRotation(lua_State *L);
73 | 	static int setScale(lua_State *L);
74 | 	static int setScaleX(lua_State *L);
75 | 	static int setScaleY(lua_State *L);
76 | 	static int setAnchorPoint(lua_State *L);
77 | 	static int setAnchorPointX(lua_State *L);
78 | 	static int setAnchorPointY(lua_State *L);
79 | 	static int setColor(lua_State *L);
80 | 	static int setTexRect(lua_State *L);
81 | 	static int setFlippedX(lua_State *L);
82 | 	static int setFlippedY(lua_State *L);
83 | 	static int setRgbBlendingPreset(lua_State *L);
84 | 	static int setAlphaBlendingPreset(lua_State *L);
85 | 
86 | 	static int setVertices(lua_State *L);
87 | 	static int setVerticesXY(lua_State *L);
88 | 	static int setVerticesUV(lua_State *L);
89 | 	static int setVerticesX(lua_State *L);
90 | 	static int setVerticesY(lua_State *L);
91 | 	static int setVerticesU(lua_State *L);
92 | 	static int setVerticesV(lua_State *L);
93 | 
94 | 	friend class Script;
95 | };
96 | 
97 | #endif
98 | 


--------------------------------------------------------------------------------
/src/SpriteEntry.cpp:
--------------------------------------------------------------------------------
  1 | #include "SpriteEntry.h"
  2 | #include "Sprite.h" // for `SpriteGroup::clone()`
  3 | #include <ncine/Random.h>
  4 | 
  5 | ///////////////////////////////////////////////////////////
  6 | // CONSTRUCTORS and DESTRUCTOR
  7 | ///////////////////////////////////////////////////////////
  8 | 
  9 | SpriteEntry::SpriteEntry(Type type)
 10 |     : type_(type), parentGroup_(nullptr), entyrColor_(nc::Colorf::White)
 11 | {
 12 | 	entyrColor_.set(nc::random().fastReal(0.0f, 1.0f), nc::random().fastReal(0.0f, 1.0f), nc::random().fastReal(0.0f, 1.0f), 1.0f);
 13 | }
 14 | 
 15 | SpriteEntry::SpriteEntry(Type type, nc::Colorf entryColor)
 16 |     : type_(type), parentGroup_(nullptr), entyrColor_(entryColor)
 17 | {
 18 | }
 19 | 
 20 | SpriteGroup::SpriteGroup()
 21 |     : SpriteEntry(Type::GROUP)
 22 | {
 23 | }
 24 | 
 25 | SpriteGroup::SpriteGroup(const char *name)
 26 |     : SpriteEntry(Type::GROUP), name_(name)
 27 | {
 28 | }
 29 | 
 30 | SpriteGroup::SpriteGroup(nc::Colorf entryColor, const char *name)
 31 |     : SpriteEntry(Type::GROUP, entryColor), name_(name)
 32 | {
 33 | }
 34 | 
 35 | ///////////////////////////////////////////////////////////
 36 | // PUBLIC FUNCTIONS
 37 | ///////////////////////////////////////////////////////////
 38 | 
 39 | const SpriteGroup *SpriteEntry::toGroup() const
 40 | {
 41 | 	return (type_ == Type::GROUP) ? reinterpret_cast<const SpriteGroup *>(this) : nullptr;
 42 | }
 43 | 
 44 | SpriteGroup *SpriteEntry::toGroup()
 45 | {
 46 | 	return (type_ == Type::GROUP) ? reinterpret_cast<SpriteGroup *>(this) : nullptr;
 47 | }
 48 | 
 49 | const Sprite *SpriteEntry::toSprite() const
 50 | {
 51 | 	return (type_ == Type::SPRITE) ? reinterpret_cast<const Sprite *>(this) : nullptr;
 52 | }
 53 | 
 54 | Sprite *SpriteEntry::toSprite()
 55 | {
 56 | 	return (type_ == Type::SPRITE) ? reinterpret_cast<Sprite *>(this) : nullptr;
 57 | }
 58 | 
 59 | unsigned int SpriteEntry::spriteId() const
 60 | {
 61 | 	ASSERT(type_ == Type::SPRITE);
 62 | 	return spriteId_;
 63 | }
 64 | 
 65 | void SpriteEntry::setSpriteId(unsigned int spriteId)
 66 | {
 67 | 	ASSERT(type_ == Type::SPRITE);
 68 | 	spriteId_ = spriteId;
 69 | }
 70 | 
 71 | int SpriteEntry::indexInParent() const
 72 | {
 73 | 	if (parentGroup_ == nullptr)
 74 | 		return -1;
 75 | 
 76 | 	int index = -1;
 77 | 	const nctl::Array<nctl::UniquePtr<SpriteEntry>> &children = parentGroup_->children();
 78 | 	for (unsigned int i = 0; i < children.size(); i++)
 79 | 	{
 80 | 		if (children[i].get() == this)
 81 | 		{
 82 | 			index = static_cast<int>(i);
 83 | 			break;
 84 | 		}
 85 | 	}
 86 | 
 87 | 	return index;
 88 | }
 89 | 
 90 | nctl::UniquePtr<SpriteGroup> SpriteGroup::clone() const
 91 | {
 92 | 	// Cloned groups have random colors like cloned sprites
 93 | 	nctl::UniquePtr<SpriteGroup> spriteGroup = nctl::makeUnique<SpriteGroup>(name_.data());
 94 | 	spriteGroup->setParentGroup(parentGroup_);
 95 | 
 96 | 	for (unsigned int i = 0; i < children_.size(); i++)
 97 | 	{
 98 | 		const SpriteEntry *child = children_[i].get();
 99 | 		if (child->isGroup())
100 | 			spriteGroup->children().pushBack(nctl::move(child->toGroup()->clone()));
101 | 		else if (child->isSprite())
102 | 			spriteGroup->children().pushBack(nctl::move(child->toSprite()->clone()));
103 | 		spriteGroup->children().back()->setParentGroup(spriteGroup.get());
104 | 	}
105 | 
106 | 	return spriteGroup;
107 | }
108 | 


--------------------------------------------------------------------------------
/cmake/custom_fontawesome.cmake:
--------------------------------------------------------------------------------
 1 | if(CUSTOM_WITH_FONTAWESOME)
 2 | 	set(FONTAWESOME_VERSION_TAG "master")
 3 | 	# Download release archive (TRUE) or Git repository (FALSE)
 4 | 	set(FONTAWESOME_DOWNLOAD_ARCHIVE TRUE)
 5 | 
 6 | 	if(FONTAWESOME_DOWNLOAD_ARCHIVE AND ${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.18.0")
 7 | 		# Strip the initial "v" character from the version tag
 8 | 		string(REGEX MATCH "^v[0-9]" FONTAWESOME_STRIP_VERSION ${FONTAWESOME_VERSION_TAG})
 9 | 		if(FONTAWESOME_STRIP_VERSION STREQUAL "")
10 | 			set(FONTAWESOME_VERSION_TAG_DIR ${FONTAWESOME_VERSION_TAG})
11 | 		else()
12 | 			string(SUBSTRING ${FONTAWESOME_VERSION_TAG} 1 -1 FONTAWESOME_VERSION_TAG_DIR)
13 | 		endif()
14 | 
15 | 		if (IS_DIRECTORY ${CMAKE_BINARY_DIR}/Font-Awesome-${FONTAWESOME_VERSION_TAG_DIR})
16 | 			message(STATUS "Font-Awesome release file \"${FONTAWESOME_VERSION_TAG}\" has been already downloaded")
17 | 		else()
18 | 			file(DOWNLOAD https://github.com/FortAwesome/Font-Awesome/archive/${FONTAWESOME_VERSION_TAG}.tar.gz
19 | 				${CMAKE_BINARY_DIR}/${FONTAWESOME_VERSION_TAG}.tar.gz STATUS result)
20 | 
21 | 			list(GET result 0 result_code)
22 | 			if(result_code)
23 | 				message(WARNING "Cannot download Font-Awesome release file ${FONTAWESOME_VERSION_TAG}")
24 | 			else()
25 | 				message(STATUS "Downloaded Font-Awesome release file \"${FONTAWESOME_VERSION_TAG}\"")
26 | 				file(ARCHIVE_EXTRACT INPUT ${CMAKE_BINARY_DIR}/${FONTAWESOME_VERSION_TAG}.tar.gz DESTINATION ${CMAKE_BINARY_DIR})
27 | 				file(REMOVE ${CMAKE_BINARY_DIR}/${FONTAWESOME_VERSION_TAG}.tar.gz)
28 | 			endif()
29 | 		endif()
30 | 
31 | 		if (IS_DIRECTORY ${CMAKE_BINARY_DIR}/Font-Awesome-${FONTAWESOME_VERSION_TAG_DIR})
32 | 			file(COPY ${CMAKE_BINARY_DIR}/Font-Awesome-${FONTAWESOME_VERSION_TAG_DIR}/webfonts/fa-brands-400.ttf
33 | 				${CMAKE_BINARY_DIR}/Font-Awesome-${FONTAWESOME_VERSION_TAG_DIR}/webfonts/fa-regular-400.ttf
34 | 				${CMAKE_BINARY_DIR}/Font-Awesome-${FONTAWESOME_VERSION_TAG_DIR}/webfonts/fa-solid-900.ttf
35 | 				DESTINATION ${NCPROJECT_DATA_DIR}/data/fonts)
36 | 		else()
37 | 			set(CUSTOM_WITH_FONTAWESOME FALSE)
38 | 		endif()
39 | 	else()
40 | 		# Download Font-Awesome repository at configure time
41 | 		configure_file(cmake/custom_fontawesome_download.in fontawesome-download/CMakeLists.txt)
42 | 
43 | 		execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
44 | 			RESULT_VARIABLE result
45 | 			WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/fontawesome-download
46 | 		)
47 | 		if(result)
48 | 			message(STATUS "CMake step for Font-Awesome failed: ${result}")
49 | 			set(FONTAWESOME_ERROR TRUE)
50 | 		endif()
51 | 
52 | 		execute_process(COMMAND ${CMAKE_COMMAND} --build .
53 | 			RESULT_VARIABLE result
54 | 			WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/fontawesome-download
55 | 		)
56 | 		if(result)
57 | 			message(STATUS "Build step for Font-Awesome failed: ${result}")
58 | 			set(FONTAWESOME_ERROR TRUE)
59 | 		endif()
60 | 
61 | 		if(FONTAWESOME_ERROR)
62 | 			set(CUSTOM_WITH_FONTAWESOME FALSE)
63 | 		else()
64 | 			execute_process(COMMAND ${CMAKE_COMMAND} -E make_directory ${NCPROJECT_DATA_DIR}/data/fonts
65 | 				COMMAND ${CMAKE_COMMAND} -E copy_if_different
66 | 					${CMAKE_BINARY_DIR}/fontawesome-src/webfonts/fa-brands-400.ttf
67 | 					${CMAKE_BINARY_DIR}/fontawesome-src/webfonts/fa-regular-400.ttf
68 | 					${CMAKE_BINARY_DIR}/fontawesome-src/webfonts/fa-solid-900.ttf
69 | 					${NCPROJECT_DATA_DIR}/data/fonts)
70 | 		endif()
71 | 	endif()
72 | endif()
73 | 


--------------------------------------------------------------------------------
/src/PropertyAnimation.cpp:
--------------------------------------------------------------------------------
  1 | #include "PropertyAnimation.h"
  2 | #include "Sprite.h"
  3 | #include "AnimationGroup.h"
  4 | 
  5 | ///////////////////////////////////////////////////////////
  6 | // CONSTRUCTORS and DESTRUCTOR
  7 | ///////////////////////////////////////////////////////////
  8 | 
  9 | PropertyAnimation::PropertyAnimation()
 10 |     : PropertyAnimation(nullptr)
 11 | {
 12 | }
 13 | 
 14 | PropertyAnimation::PropertyAnimation(Sprite *sprite)
 15 |     : CurveAnimation(EasingCurve::Type::LINEAR, Loop::Mode::DISABLED),
 16 |       propertyType_(Properties::Types::NONE), property_(nullptr), sprite_(sprite)
 17 | {
 18 | }
 19 | 
 20 | ///////////////////////////////////////////////////////////
 21 | // PUBLIC FUNCTIONS
 22 | ///////////////////////////////////////////////////////////
 23 | 
 24 | nctl::UniquePtr<IAnimation> PropertyAnimation::clone() const
 25 | {
 26 | 	nctl::UniquePtr<PropertyAnimation> anim = nctl::makeUnique<PropertyAnimation>(sprite_);
 27 | 	CurveAnimation::cloneTo(*anim);
 28 | 
 29 | 	anim->setSprite(sprite_);
 30 | 	anim->setProperty(propertyType_);
 31 | 
 32 | 	return nctl::move(anim);
 33 | }
 34 | 
 35 | void PropertyAnimation::perform()
 36 | {
 37 | 	if (property_)
 38 | 		*property_ = curve_.value();
 39 | }
 40 | 
 41 | const char *PropertyAnimation::propertyName() const
 42 | {
 43 | 	const int index = static_cast<int>(propertyType_);
 44 | 	return Properties::Strings[index];
 45 | }
 46 | 
 47 | void PropertyAnimation::setProperty(Properties::Types propertyType)
 48 | {
 49 | 	if (sprite_ == nullptr)
 50 | 	{
 51 | 		propertyType_ = Properties::Types::NONE;
 52 | 		property_ = nullptr;
 53 | 		return;
 54 | 	}
 55 | 
 56 | 	propertyType_ = propertyType;
 57 | 	switch (propertyType)
 58 | 	{
 59 | 		case Properties::Types::NONE:
 60 | 			property_ = nullptr;
 61 | 			break;
 62 | 		case Properties::Types::POSITION_X:
 63 | 			property_ = &sprite_->x;
 64 | 			break;
 65 | 		case Properties::Types::POSITION_Y:
 66 | 			property_ = &sprite_->y;
 67 | 			break;
 68 | 		case Properties::Types::ROTATION:
 69 | 			property_ = &sprite_->rotation;
 70 | 			break;
 71 | 		case Properties::Types::SCALE_X:
 72 | 			property_ = &sprite_->scaleFactor.x;
 73 | 			break;
 74 | 		case Properties::Types::SCALE_Y:
 75 | 			property_ = &sprite_->scaleFactor.y;
 76 | 			break;
 77 | 		case Properties::Types::ANCHOR_X:
 78 | 			property_ = &sprite_->anchorPoint.x;
 79 | 			break;
 80 | 		case Properties::Types::ANCHOR_Y:
 81 | 			property_ = &sprite_->anchorPoint.y;
 82 | 			break;
 83 | 		case Properties::Types::OPACITY:
 84 | 			property_ = &sprite_->color.data()[3];
 85 | 			break;
 86 | 		case Properties::Types::COLOR_R:
 87 | 			property_ = &sprite_->color.data()[0];
 88 | 			break;
 89 | 		case Properties::Types::COLOR_G:
 90 | 			property_ = &sprite_->color.data()[1];
 91 | 			break;
 92 | 		case Properties::Types::COLOR_B:
 93 | 			property_ = &sprite_->color.data()[2];
 94 | 			break;
 95 | 	}
 96 | }
 97 | 
 98 | void PropertyAnimation::setProperty(const char *name)
 99 | {
100 | 	if (name == nullptr)
101 | 		setProperty(Properties::Types::NONE);
102 | 	else
103 | 	{
104 | 		nctl::String string(name);
105 | 		for (unsigned int i = 0; i < Properties::Count; i++)
106 | 		{
107 | 			if (string == Properties::Strings[i])
108 | 			{
109 | 				setProperty(static_cast<Properties::Types>(i));
110 | 				break;
111 | 			}
112 | 		}
113 | 	}
114 | }
115 | 
116 | void PropertyAnimation::setSprite(Sprite *sprite)
117 | {
118 | 	if (sprite_ != sprite)
119 | 	{
120 | 		sprite_ = sprite;
121 | 		setProperty(propertyType_);
122 | 	}
123 | }
124 | 


--------------------------------------------------------------------------------
/cmake/custom_iconfontcppheaders.cmake:
--------------------------------------------------------------------------------
 1 | if(CUSTOM_WITH_FONTAWESOME)
 2 | 	set(ICONFONTCPPHEADERS_VERSION_TAG "main")
 3 | 	# Download release archive (TRUE) or Git repository (FALSE)
 4 | 	set(ICONFONTCPPHEADERS_DOWNLOAD_ARCHIVE TRUE)
 5 | 
 6 | 	if(ICONFONTCPPHEADERS_DOWNLOAD_ARCHIVE AND ${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.18.0")
 7 | 		# Strip the initial "v" character from the version tag
 8 | 		string(REGEX MATCH "^v[0-9]" ICONFONTCPPHEADERS_STRIP_VERSION ${ICONFONTCPPHEADERS_VERSION_TAG})
 9 | 		if(ICONFONTCPPHEADERS_STRIP_VERSION STREQUAL "")
10 | 			set(ICONFONTCPPHEADERS_VERSION_TAG_DIR ${ICONFONTCPPHEADERS_VERSION_TAG})
11 | 		else()
12 | 			string(SUBSTRING ${ICONFONTCPPHEADERS_VERSION_TAG} 1 -1 ICONFONTCPPHEADERS_VERSION_TAG_DIR)
13 | 		endif()
14 | 
15 | 		set(ICONFONTCPPHEADERS_SOURCE_DIR_NAME IconFontCppHeaders-${ICONFONTCPPHEADERS_VERSION_TAG_DIR})
16 | 	else()
17 | 		set(ICONFONTCPPHEADERS_SOURCE_DIR_NAME iconfontcppheaders-src)
18 | 	endif()
19 | 
20 | 	if(ANDROID)
21 | 		return()
22 | 	endif()
23 | 
24 | 	if(ICONFONTCPPHEADERS_DOWNLOAD_ARCHIVE AND ${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.18.0")
25 | 		if (IS_DIRECTORY ${CMAKE_BINARY_DIR}/${ICONFONTCPPHEADERS_SOURCE_DIR_NAME})
26 | 			message(STATUS "IconFontCppHeaders release file \"${ICONFONTCPPHEADERS_VERSION_TAG}\" has been already downloaded")
27 | 		else()
28 | 			file(DOWNLOAD https://github.com/juliettef/IconFontCppHeaders/archive/${ICONFONTCPPHEADERS_VERSION_TAG}.tar.gz
29 | 				${CMAKE_BINARY_DIR}/${ICONFONTCPPHEADERS_VERSION_TAG}.tar.gz STATUS result)
30 | 
31 | 			list(GET result 0 result_code)
32 | 			if(result_code)
33 | 				message(WARNING "Cannot download IconFontCppHeaders release file ${ICONFONTCPPHEADERS_VERSION_TAG}")
34 | 			else()
35 | 				message(STATUS "Downloaded IconFontCppHeaders release file \"${ICONFONTCPPHEADERS_VERSION_TAG}\"")
36 | 				file(ARCHIVE_EXTRACT INPUT ${CMAKE_BINARY_DIR}/${ICONFONTCPPHEADERS_VERSION_TAG}.tar.gz DESTINATION ${CMAKE_BINARY_DIR})
37 | 				file(REMOVE ${CMAKE_BINARY_DIR}/${ICONFONTCPPHEADERS_VERSION_TAG}.tar.gz)
38 | 			endif()
39 | 		endif()
40 | 
41 | 		if (IS_DIRECTORY ${CMAKE_BINARY_DIR}/${ICONFONTCPPHEADERS_SOURCE_DIR_NAME})
42 | 			target_compile_definitions(${NCPROJECT_EXE_NAME} PRIVATE "WITH_FONTAWESOME")
43 | 			target_include_directories(${NCPROJECT_EXE_NAME} PRIVATE ${CMAKE_BINARY_DIR}/${ICONFONTCPPHEADERS_SOURCE_DIR_NAME})
44 | 		else()
45 | 			set(CUSTOM_WITH_FONTAWESOME FALSE)
46 | 		endif()
47 | 	else()
48 | 		# Download IconFontCppHeaders repository at configure time
49 | 		configure_file(cmake/custom_iconfontcppheaders_download.in iconfontcppheaders-download/CMakeLists.txt)
50 | 
51 | 		execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
52 | 			RESULT_VARIABLE result
53 | 			WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/iconfontcppheaders-download
54 | 		)
55 | 		if(result)
56 | 			message(STATUS "CMake step for IconFontCppHeaders failed: ${result}")
57 | 			set(ICONFONTCPPHEADERS_ERROR TRUE)
58 | 		endif()
59 | 
60 | 		execute_process(COMMAND ${CMAKE_COMMAND} --build .
61 | 			RESULT_VARIABLE result
62 | 			WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/iconfontcppheaders-download
63 | 		)
64 | 		if(result)
65 | 			message(STATUS "Build step for IconFontCppHeaders failed: ${result}")
66 | 			set(ICONFONTCPPHEADERS_ERROR TRUE)
67 | 		endif()
68 | 
69 | 		if(ICONFONTCPPHEADERS_ERROR)
70 | 			set(CUSTOM_WITH_FONTAWESOME FALSE)
71 | 		else()
72 | 			target_compile_definitions(${NCPROJECT_EXE_NAME} PRIVATE "WITH_FONTAWESOME")
73 | 			target_include_directories(${NCPROJECT_EXE_NAME} PRIVATE ${CMAKE_BINARY_DIR}/${ICONFONTCPPHEADERS_SOURCE_DIR_NAME})
74 | 		endif()
75 | 	endif()
76 | endif()
77 | 


--------------------------------------------------------------------------------
/src/EasingCurve.cpp:
--------------------------------------------------------------------------------
  1 | #include <cmath>
  2 | #include <ncine/common_constants.h>
  3 | #include "EasingCurve.h"
  4 | 
  5 | ///////////////////////////////////////////////////////////
  6 | // CONSTRUCTORS and DESTRUCTOR
  7 | ///////////////////////////////////////////////////////////
  8 | 
  9 | EasingCurve::EasingCurve(Type type, Loop::Mode loopMode)
 10 |     : type_(type), loop_(loopMode), withInitialValue_(false), time_(0.0f),
 11 |       initialValue_(0.0f), start_(0.0f), end_(1.0f), scale_(1.0f), shift_(0.0f)
 12 | {
 13 | }
 14 | 
 15 | ///////////////////////////////////////////////////////////
 16 | // PUBLIC FUNCTIONS
 17 | ///////////////////////////////////////////////////////////
 18 | 
 19 | void EasingCurve::setTime(float time)
 20 | {
 21 | 	time_ = time;
 22 | 
 23 | 	if (time_ < start_)
 24 | 		time_ = start_;
 25 | 	else if (time_ > end_)
 26 | 		time_ = end_;
 27 | }
 28 | 
 29 | void EasingCurve::setInitialValue(float initialValue)
 30 | {
 31 | 	initialValue_ = initialValue;
 32 | 
 33 | 	if (initialValue_ < start_)
 34 | 		initialValue_ = start_;
 35 | 	else if (initialValue_ > end_)
 36 | 		initialValue_ = end_;
 37 | }
 38 | 
 39 | void EasingCurve::reset()
 40 | {
 41 | 	if (withInitialValue_ == false)
 42 | 	{
 43 | 		if (loop_.direction() == Loop::Direction::FORWARD)
 44 | 		{
 45 | 			time_ = start_;
 46 | 			loop_.goForward(true);
 47 | 		}
 48 | 		else if (loop_.direction() == Loop::Direction::BACKWARD)
 49 | 		{
 50 | 			time_ = end_;
 51 | 			loop_.goForward(false);
 52 | 		}
 53 | 	}
 54 | 	else
 55 | 		time_ = initialValue_;
 56 | }
 57 | 
 58 | float EasingCurve::value()
 59 | {
 60 | 	switch (type_)
 61 | 	{
 62 | 		case Type::LINEAR:
 63 | 			return time_ * scale_ + shift_;
 64 | 		case Type::QUAD:
 65 | 			return time_ * time_ * scale_ + shift_;
 66 | 		case Type::CUBIC:
 67 | 			return time_ * time_ * time_ * scale_ + shift_;
 68 | 		case Type::QUART:
 69 | 			return time_ * time_ * time_ * time_ * scale_ + shift_;
 70 | 		case Type::QUINT:
 71 | 			return time_ * time_ * time_ * time_ * time_ * scale_ + shift_;
 72 | 		case Type::SINE:
 73 | 			return sinf(time_ * ncine::fPi) * scale_ + shift_;
 74 | 		case Type::EXPO:
 75 | 			return (1.0f - powf(2, time_)) * scale_ + shift_;
 76 | 		case Type::CIRC:
 77 | 			return sqrtf(1.0f - time_ * time_) * scale_ + shift_;
 78 | 	}
 79 | 
 80 | 	return 1.0f;
 81 | }
 82 | 
 83 | void EasingCurve::next(float deltaTime)
 84 | {
 85 | 	if ((loop_.isGoingForward() && loop_.direction() == Loop::Direction::FORWARD) ||
 86 | 	    (!loop_.isGoingForward() && loop_.direction() == Loop::Direction::BACKWARD))
 87 | 		time_ += deltaTime;
 88 | 	else
 89 | 		time_ -= deltaTime;
 90 | 
 91 | 	if (time_ < start_)
 92 | 	{
 93 | 		if (loop_.direction() == Loop::Direction::BACKWARD)
 94 | 		{
 95 | 			if (loop_.mode() == Loop::Mode::DISABLED)
 96 | 				time_ = start_;
 97 | 			else if (loop_.mode() == Loop::Mode::REWIND)
 98 | 			{
 99 | 				time_ = end_ + time_;
100 | 				loop_.justResetNow();
101 | 			}
102 | 			else if (loop_.mode() == Loop::Mode::PING_PONG)
103 | 			{
104 | 				time_ = 2.0f * start_ - time_;
105 | 				loop_.justResetNow();
106 | 				loop_.goForward(false);
107 | 			}
108 | 		}
109 | 		else
110 | 		{
111 | 			time_ = 2.0f * start_ - time_;
112 | 			loop_.justResetNow();
113 | 			loop_.goForward(true);
114 | 		}
115 | 	}
116 | 	else if (time_ > end_)
117 | 	{
118 | 		if (loop_.direction() == Loop::Direction::FORWARD)
119 | 		{
120 | 			if (loop_.mode() == Loop::Mode::DISABLED)
121 | 				time_ = end_;
122 | 			else if (loop_.mode() == Loop::Mode::REWIND)
123 | 			{
124 | 				time_ = time_ - end_;
125 | 				loop_.justResetNow();
126 | 			}
127 | 			else if (loop_.mode() == Loop::Mode::PING_PONG)
128 | 			{
129 | 				time_ = 2.0f * end_ - time_;
130 | 				loop_.justResetNow();
131 | 				loop_.goForward(false);
132 | 			}
133 | 		}
134 | 		else
135 | 		{
136 | 			time_ = 2.0f * end_ - time_;
137 | 			loop_.justResetNow();
138 | 			loop_.goForward(true);
139 | 		}
140 | 	}
141 | }
142 | 


--------------------------------------------------------------------------------
/src/ParallelAnimationGroup.cpp:
--------------------------------------------------------------------------------
  1 | #include "ParallelAnimationGroup.h"
  2 | 
  3 | ///////////////////////////////////////////////////////////
  4 | // PUBLIC FUNCTIONS
  5 | ///////////////////////////////////////////////////////////
  6 | 
  7 | nctl::UniquePtr<IAnimation> ParallelAnimationGroup::clone() const
  8 | {
  9 | 	nctl::UniquePtr<ParallelAnimationGroup> animGroup = nctl::makeUnique<ParallelAnimationGroup>();
 10 | 	AnimationGroup::cloneTo(*animGroup);
 11 | 
 12 | 	return nctl::move(animGroup);
 13 | }
 14 | 
 15 | void ParallelAnimationGroup::pause()
 16 | {
 17 | 	if (state_ != State::PLAYING)
 18 | 		return;
 19 | 
 20 | 	for (auto &&anim : anims_)
 21 | 	{
 22 | 		// The parallel group pauses all playing animations
 23 | 		if (anim->state() == State::PLAYING)
 24 | 			anim->pause();
 25 | 	}
 26 | 
 27 | 	state_ = State::PAUSED;
 28 | }
 29 | 
 30 | void ParallelAnimationGroup::play()
 31 | {
 32 | 	if (enabled == false)
 33 | 		return;
 34 | 
 35 | 	switch (state_)
 36 | 	{
 37 | 		case State::STOPPED:
 38 | 			if (anims_.isEmpty() == false)
 39 | 			{
 40 | 				// Stop all animations to get the initial state
 41 | 				stopAnimations();
 42 | 
 43 | 				if (loop_.direction() == Loop::Direction::FORWARD)
 44 | 					loop_.goForward(true);
 45 | 				else
 46 | 				{
 47 | 					loop_.goForward(false);
 48 | 					if (shouldReverseAnimDirection())
 49 | 					{
 50 | 						for (auto &&anim : anims_)
 51 | 							reverseAnimDirection(*anim);
 52 | 					}
 53 | 				}
 54 | 
 55 | 				for (auto &&anim : anims_)
 56 | 				{
 57 | 					if (anim->enabled)
 58 | 						anim->play();
 59 | 				}
 60 | 			}
 61 | 			break;
 62 | 		case State::PAUSED:
 63 | 			for (auto &&anim : anims_)
 64 | 			{
 65 | 				if (anim->state() == State::PAUSED)
 66 | 					anim->play();
 67 | 			}
 68 | 			break;
 69 | 		case State::PLAYING:
 70 | 			break;
 71 | 	}
 72 | 
 73 | 	state_ = State::PLAYING;
 74 | }
 75 | 
 76 | void ParallelAnimationGroup::update(float deltaTime)
 77 | {
 78 | 	if (state_ == IAnimation::State::PLAYING)
 79 | 	{
 80 | 		if (shouldWaitDelay(deltaTime) ||
 81 | 		    (insideSequential() == false && loop_.shouldWaitDelay(deltaTime)))
 82 | 		{
 83 | 			return;
 84 | 		}
 85 | 	}
 86 | 
 87 | 	bool allStopped = true;
 88 | 	bool allDisabled = true;
 89 | 	// Update all enabled animations anyway
 90 | 	for (auto &&anim : anims_)
 91 | 	{
 92 | 		if (anim->enabled)
 93 | 		{
 94 | 			anim->update(deltaTime);
 95 | 			allDisabled = false;
 96 | 			if (anim->state() != State::STOPPED)
 97 | 				allStopped = false;
 98 | 		}
 99 | 	}
100 | 
101 | 	if (state_ == IAnimation::State::PLAYING && allStopped)
102 | 	{
103 | 		const Loop::Mode loopMode = loop_.mode();
104 | 		// Disable looping if the animation is inside a sequential group
105 | 		if (insideSequential())
106 | 			loop_.setMode(Loop::Mode::DISABLED);
107 | 
108 | 		switch (loop_.mode())
109 | 		{
110 | 			case Loop::Mode::DISABLED:
111 | 				break;
112 | 			case Loop::Mode::REWIND:
113 | 				// Stop all animations to get the initial state
114 | 				stopAnimations();
115 | 				loop_.justResetNow();
116 | 				break;
117 | 			case Loop::Mode::PING_PONG:
118 | 				loop_.justResetNow();
119 | 				loop_.toggleForward();
120 | 				break;
121 | 		}
122 | 
123 | 		if (loop_.mode() != Loop::Mode::DISABLED)
124 | 		{
125 | 			for (auto &&anim : anims_)
126 | 			{
127 | 				if (loop_.mode() == Loop::Mode::PING_PONG)
128 | 					reverseAnimDirection(*anim);
129 | 				if (anim->enabled)
130 | 					anim->play();
131 | 			}
132 | 		}
133 | 		else
134 | 		{
135 | 			if (shouldReverseAnimDirection())
136 | 			{
137 | 				for (auto &&anim : anims_)
138 | 					reverseAnimDirection(*anim);
139 | 			}
140 | 
141 | 			resetDelay();
142 | 			state_ = State::STOPPED;
143 | 		}
144 | 
145 | 		loop_.setMode(loopMode);
146 | 	}
147 | 
148 | 	// Stopping a parallel group that only contains disabled animations (like a sequential group will do)
149 | 	if (allDisabled)
150 | 	{
151 | 		resetDelay();
152 | 		state_ = State::STOPPED;
153 | 	}
154 | }
155 | 


--------------------------------------------------------------------------------
/src/Canvas.cpp:
--------------------------------------------------------------------------------
  1 | #include <ncine/config.h>
  2 | 
  3 | #include "Canvas.h"
  4 | #include "RenderingResources.h"
  5 | #include <ncine/Application.h>
  6 | #include <ncine/GLTexture.h>
  7 | #include <ncine/GLFramebufferObject.h>
  8 | #include <ncine/TextureSaverPng.h>
  9 | 
 10 | #include "shader_strings.h"
 11 | 
 12 | #ifdef __MINGW32__
 13 | 	#undef ERROR
 14 | #endif
 15 | 
 16 | ///////////////////////////////////////////////////////////
 17 | // CONSTRUCTORS and DESTRUCTOR
 18 | ///////////////////////////////////////////////////////////
 19 | 
 20 | Canvas::Canvas()
 21 |     : backgroundColor(0.0f, 0.0f, 0.0f, 0.0f),
 22 |       texWidth_(0), texHeight_(0), texSizeInBytes_(0)
 23 | {
 24 | 	const nc::IGfxCapabilities &gfxCaps = nc::theServiceLocator().gfxCapabilities();
 25 | 	maxTextureSize_ = gfxCaps.value(nc::IGfxCapabilities::GLIntValues::MAX_TEXTURE_SIZE);
 26 | }
 27 | 
 28 | Canvas::Canvas(int texWidth, int texHeight)
 29 |     : backgroundColor(0.0f, 0.0f, 0.0f, 0.0f),
 30 |       texWidth_(texWidth), texHeight_(texHeight), texSizeInBytes_(0)
 31 | {
 32 | 	const nc::IGfxCapabilities &gfxCaps = nc::theServiceLocator().gfxCapabilities();
 33 | 	maxTextureSize_ = gfxCaps.value(nc::IGfxCapabilities::GLIntValues::MAX_TEXTURE_SIZE);
 34 | 
 35 | 	resizeTexture(texWidth, texHeight);
 36 | }
 37 | 
 38 | ///////////////////////////////////////////////////////////
 39 | // PUBLIC FUNCTIONS
 40 | ///////////////////////////////////////////////////////////
 41 | 
 42 | void Canvas::resizeTexture(int width, int height)
 43 | {
 44 | 	FATAL_ASSERT(width > 0);
 45 | 	FATAL_ASSERT(height > 0);
 46 | 	if (pixels_ == nullptr || width != texWidth_ || height != texHeight_)
 47 | 	{
 48 | 		texWidth_ = (width <= maxTextureSize_) ? width : maxTextureSize_;
 49 | 		texHeight_ = (height <= maxTextureSize_) ? height : maxTextureSize_;
 50 | 		texSizeInBytes_ = static_cast<unsigned int>(texWidth_ * texHeight_ * 4);
 51 | 
 52 | 		pixels_ = nctl::makeUnique<unsigned char[]>(texSizeInBytes_);
 53 | 
 54 | 		texture_ = nctl::makeUnique<nc::GLTexture>(GL_TEXTURE_2D);
 55 | 		texture_->texStorage2D(1, GL_RGBA8, width, height);
 56 | 		texture_->texParameteri(GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 57 | 		texture_->texParameteri(GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 58 | 
 59 | 		fbo_ = nctl::makeUnique<nc::GLFramebufferObject>();
 60 | 		fbo_->attachTexture(*texture_, GL_COLOR_ATTACHMENT0);
 61 | 		if (fbo_->isStatusComplete() == false)
 62 | 			LOGE("Framebuffer object status is not complete\n");
 63 | 	}
 64 | }
 65 | 
 66 | void Canvas::bindTexture()
 67 | {
 68 | 	texture_->bind();
 69 | }
 70 | 
 71 | void Canvas::unbindTexture()
 72 | {
 73 | 	texture_->unbind();
 74 | }
 75 | 
 76 | void Canvas::bindRead()
 77 | {
 78 | 	fbo_->bind(GL_READ_FRAMEBUFFER);
 79 | }
 80 | 
 81 | void Canvas::bindDraw()
 82 | {
 83 | 	fbo_->bind(GL_DRAW_FRAMEBUFFER);
 84 | }
 85 | 
 86 | void Canvas::bind()
 87 | {
 88 | 	RenderingResources::setCanvasSize(texWidth_, texHeight_);
 89 | 	glViewport(0, 0, texWidth_, texHeight_);
 90 | 	fbo_->bind(GL_FRAMEBUFFER);
 91 | 	glClearColor(backgroundColor.r(), backgroundColor.g(), backgroundColor.b(), backgroundColor.a());
 92 | 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 93 | }
 94 | 
 95 | void Canvas::unbind()
 96 | {
 97 | 	fbo_->unbind();
 98 | 	glViewport(0, 0, nc::theApplication().widthInt(), nc::theApplication().heightInt());
 99 | }
100 | 
101 | void Canvas::save(const char *filename)
102 | {
103 | #if !defined(NCINE_WITH_OPENGLES) && !defined(__EMSCRIPTEN__)
104 | 	fbo_->unbind();
105 | 	texture_->getTexImage(0, GL_RGBA, GL_UNSIGNED_BYTE, pixels_.get());
106 | #else
107 | 	fbo_->bind(GL_READ_FRAMEBUFFER);
108 | 	glReadBuffer(GL_COLOR_ATTACHMENT0);
109 | 	glReadPixels(0, 0, texWidth_, texHeight_, GL_RGBA, GL_UNSIGNED_BYTE, pixels_.get());
110 | 	fbo_->unbind();
111 | #endif
112 | 
113 | 	nc::TextureSaverPng saver;
114 | 	nc::ITextureSaver::Properties props;
115 | 	props.width = texWidth_;
116 | 	props.height = texHeight_;
117 | 	props.pixels = pixels_.get();
118 | 	props.format = nc::ITextureSaver::Format::RGBA8;
119 | 	saver.saveToFile(props, filename);
120 | }
121 | 
122 | void *Canvas::imguiTexId()
123 | {
124 | 	return reinterpret_cast<void *>(texture_.get());
125 | }
126 | 


--------------------------------------------------------------------------------
/src/Texture.cpp:
--------------------------------------------------------------------------------
  1 | #include "Texture.h"
  2 | #include <ncine/GLTexture.h>
  3 | #include <ncine/ITextureLoader.h>
  4 | 
  5 | ///////////////////////////////////////////////////////////
  6 | // CONSTRUCTORS and DESTRUCTOR
  7 | ///////////////////////////////////////////////////////////
  8 | 
  9 | Texture::Texture(const char *filename)
 10 |     : glTexture_(nctl::makeUnique<nc::GLTexture>(GL_TEXTURE_2D)),
 11 |       name_(MaxNameLength), width_(0), height_(0), numChannels_(0), dataSize_(0)
 12 | {
 13 | 	loadFromFile(filename);
 14 | }
 15 | 
 16 | Texture::Texture(const char *bufferName, const unsigned char *bufferPtr, unsigned long int bufferSize)
 17 |     : glTexture_(nctl::makeUnique<nc::GLTexture>(GL_TEXTURE_2D)),
 18 |       name_(MaxNameLength), width_(0), height_(0), numChannels_(0), dataSize_(0)
 19 | {
 20 | 	loadFromMemory(bufferName, bufferPtr, bufferSize);
 21 | }
 22 | 
 23 | ///////////////////////////////////////////////////////////
 24 | // PUBLIC FUNCTIONS
 25 | ///////////////////////////////////////////////////////////
 26 | 
 27 | bool Texture::loadFromFile(const char *filename)
 28 | {
 29 | 	glTexture_->bind();
 30 | 	nctl::UniquePtr<nc::ITextureLoader> texLoader = nc::ITextureLoader::createFromFile(filename);
 31 | 	if (texLoader->hasLoaded() == false)
 32 | 		return false;
 33 | 
 34 | 	initialize(*texLoader);
 35 | 	load(*texLoader);
 36 | 	name_ = filename;
 37 | 	return true;
 38 | }
 39 | 
 40 | bool Texture::loadFromMemory(const char *bufferName, const unsigned char *bufferPtr, unsigned long int bufferSize)
 41 | {
 42 | 	glTexture_->bind();
 43 | 	nctl::UniquePtr<nc::ITextureLoader> texLoader = nc::ITextureLoader::createFromMemory(bufferName, bufferPtr, bufferSize);
 44 | 	if (texLoader->hasLoaded() == false)
 45 | 		return false;
 46 | 
 47 | 	initialize(*texLoader);
 48 | 	load(*texLoader);
 49 | 	name_ = bufferName;
 50 | 	return true;
 51 | }
 52 | 
 53 | void Texture::bind()
 54 | {
 55 | 	glTexture_->bind();
 56 | }
 57 | 
 58 | void *Texture::imguiTexId()
 59 | {
 60 | 	return reinterpret_cast<void *>(glTexture_.get());
 61 | }
 62 | 
 63 | ///////////////////////////////////////////////////////////
 64 | // PRIVATE FUNCTIONS
 65 | ///////////////////////////////////////////////////////////
 66 | 
 67 | void Texture::initialize(const nc::ITextureLoader &texLoader)
 68 | {
 69 | 	const nc::IGfxCapabilities &gfxCaps = nc::theServiceLocator().gfxCapabilities();
 70 | 	const int maxTextureSize = gfxCaps.value(nc::IGfxCapabilities::GLIntValues::MAX_TEXTURE_SIZE);
 71 | 	FATAL_ASSERT_MSG_X(texLoader.width() <= maxTextureSize, "Texture width %d is bigger than device maximum %d", texLoader.width(), maxTextureSize);
 72 | 	FATAL_ASSERT_MSG_X(texLoader.height() <= maxTextureSize, "Texture height %d is bigger than device maximum %d", texLoader.height(), maxTextureSize);
 73 | 
 74 | 	glTexture_->texParameteri(GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 75 | 	glTexture_->texParameteri(GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 76 | 	glTexture_->texParameteri(GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 77 | 	glTexture_->texParameteri(GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 78 | 
 79 | 	const nc::TextureFormat &texFormat = texLoader.texFormat();
 80 | 
 81 | #if (defined(__ANDROID__) && GL_ES_VERSION_3_0) || defined(WITH_ANGLE) || defined(__EMSCRIPTEN__)
 82 | 	const bool withTexStorage = true;
 83 | #else
 84 | 	const bool withTexStorage = gfxCaps.hasExtension(nc::IGfxCapabilities::GLExtensions::ARB_TEXTURE_STORAGE);
 85 | #endif
 86 | 
 87 | 	if (withTexStorage && dataSize_ > 0 &&
 88 | 	    (width_ != texLoader.width() || height_ != texLoader.height() || numChannels_ != texFormat.numChannels()))
 89 | 	{
 90 | 		// The OpenGL texture needs to be recreated as its storage is immutable
 91 | 		glTexture_ = nctl::makeUnique<nc::GLTexture>(GL_TEXTURE_2D);
 92 | 	}
 93 | 
 94 | 	if (withTexStorage)
 95 | 		glTexture_->texStorage2D(texLoader.mipMapCount(), texFormat.internalFormat(), texLoader.width(), texLoader.height());
 96 | 	else
 97 | 		glTexture_->texImage2D(0, texFormat.internalFormat(), texLoader.width(), texLoader.height(), texFormat.format(), texFormat.type(), nullptr);
 98 | 
 99 | 	width_ = texLoader.width();
100 | 	height_ = texLoader.height();
101 | 	numChannels_ = texFormat.numChannels();
102 | 	dataSize_ = texLoader.dataSize();
103 | }
104 | 
105 | void Texture::load(const nc::ITextureLoader &texLoader)
106 | {
107 | #if (defined(__ANDROID__) && GL_ES_VERSION_3_0) || defined(WITH_ANGLE) || defined(__EMSCRIPTEN__)
108 | 	const bool withTexStorage = true;
109 | #else
110 | 	const nc::IGfxCapabilities &gfxCaps = nc::theServiceLocator().gfxCapabilities();
111 | 	const bool withTexStorage = gfxCaps.hasExtension(nc::IGfxCapabilities::GLExtensions::ARB_TEXTURE_STORAGE);
112 | #endif
113 | 
114 | 	const nc::TextureFormat &texFormat = texLoader.texFormat();
115 | 
116 | 	if (withTexStorage)
117 | 		glTexture_->texSubImage2D(0, 0, 0, texLoader.width(), texLoader.height(), texFormat.format(), texFormat.type(), texLoader.pixels());
118 | 	else
119 | 		glTexture_->texImage2D(0, texFormat.internalFormat(), texLoader.width(), texLoader.height(), texFormat.format(), texFormat.type(), texLoader.pixels());
120 | }
121 | 


--------------------------------------------------------------------------------
/src/gui/style.cpp:
--------------------------------------------------------------------------------
 1 | #include "gui/UserInterface.h"
 2 | 
 3 | void UserInterface::applyDarkStyle()
 4 | {
 5 | 	ImGuiStyle &style = ImGui::GetStyle();
 6 | 	ImVec4 *colors = style.Colors;
 7 | 
 8 | 	/// 0 = FLAT APPEARENCE
 9 | 	/// 1 = MORE "3D" LOOK
10 | 	const float is3D = 1.0f;
11 | 
12 | 	// clang-format off
13 | 	colors[ImGuiCol_Text]                   = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
14 | 	colors[ImGuiCol_TextDisabled]           = ImVec4(0.40f, 0.40f, 0.40f, 1.00f);
15 | 	colors[ImGuiCol_ChildBg]                = ImVec4(0.25f, 0.25f, 0.25f, 1.00f);
16 | 	colors[ImGuiCol_WindowBg]               = ImVec4(0.25f, 0.25f, 0.25f, 1.00f);
17 | 	colors[ImGuiCol_PopupBg]                = ImVec4(0.25f, 0.25f, 0.25f, 1.00f);
18 | 	colors[ImGuiCol_Border]                 = ImVec4(0.12f, 0.12f, 0.12f, 0.71f);
19 | 	colors[ImGuiCol_BorderShadow]           = ImVec4(1.00f, 1.00f, 1.00f, 0.06f);
20 | 	colors[ImGuiCol_FrameBg]                = ImVec4(0.42f, 0.42f, 0.42f, 0.54f);
21 | 	colors[ImGuiCol_FrameBgHovered]         = ImVec4(0.42f, 0.42f, 0.42f, 0.40f);
22 | 	colors[ImGuiCol_FrameBgActive]          = ImVec4(0.56f, 0.56f, 0.56f, 0.67f);
23 | 	colors[ImGuiCol_TitleBg]                = ImVec4(0.19f, 0.19f, 0.19f, 1.00f);
24 | 	colors[ImGuiCol_TitleBgActive]          = ImVec4(0.22f, 0.22f, 0.22f, 1.00f);
25 | 	colors[ImGuiCol_TitleBgCollapsed]       = ImVec4(0.17f, 0.17f, 0.17f, 0.90f);
26 | 	colors[ImGuiCol_MenuBarBg]              = ImVec4(0.335f, 0.335f, 0.335f, 1.000f);
27 | 	colors[ImGuiCol_ScrollbarBg]            = ImVec4(0.24f, 0.24f, 0.24f, 0.53f);
28 | 	colors[ImGuiCol_ScrollbarGrab]          = ImVec4(0.41f, 0.41f, 0.41f, 1.00f);
29 | 	colors[ImGuiCol_ScrollbarGrabHovered]   = ImVec4(0.52f, 0.52f, 0.52f, 1.00f);
30 | 	colors[ImGuiCol_ScrollbarGrabActive]    = ImVec4(0.76f, 0.76f, 0.76f, 1.00f);
31 | 	colors[ImGuiCol_CheckMark]              = ImVec4(0.65f, 0.65f, 0.65f, 1.00f);
32 | 	colors[ImGuiCol_SliderGrab]             = ImVec4(0.52f, 0.52f, 0.52f, 1.00f);
33 | 	colors[ImGuiCol_SliderGrabActive]       = ImVec4(0.64f, 0.64f, 0.64f, 1.00f);
34 | 	colors[ImGuiCol_Button]                 = ImVec4(0.54f, 0.54f, 0.54f, 0.35f);
35 | 	colors[ImGuiCol_ButtonHovered]          = ImVec4(0.52f, 0.52f, 0.52f, 0.59f);
36 | 	colors[ImGuiCol_ButtonActive]           = ImVec4(0.76f, 0.76f, 0.76f, 1.00f);
37 | 	colors[ImGuiCol_Header]                 = ImVec4(0.38f, 0.38f, 0.38f, 1.00f);
38 | 	colors[ImGuiCol_HeaderHovered]          = ImVec4(0.47f, 0.47f, 0.47f, 1.00f);
39 | 	colors[ImGuiCol_HeaderActive]           = ImVec4(0.76f, 0.76f, 0.76f, 0.77f);
40 | 	colors[ImGuiCol_Separator]              = ImVec4(0.000f, 0.000f, 0.000f, 0.137f);
41 | 	colors[ImGuiCol_SeparatorHovered]       = ImVec4(0.700f, 0.671f, 0.600f, 0.290f);
42 | 	colors[ImGuiCol_SeparatorActive]        = ImVec4(0.702f, 0.671f, 0.600f, 0.674f);
43 | 	colors[ImGuiCol_ResizeGrip]             = ImVec4(0.26f, 0.59f, 0.98f, 0.25f);
44 | 	colors[ImGuiCol_ResizeGripHovered]      = ImVec4(0.26f, 0.59f, 0.98f, 0.67f);
45 | 	colors[ImGuiCol_ResizeGripActive]       = ImVec4(0.26f, 0.59f, 0.98f, 0.95f);
46 | 	colors[ImGuiCol_PlotLines]              = ImVec4(0.61f, 0.61f, 0.61f, 1.00f);
47 | 	colors[ImGuiCol_PlotLinesHovered]       = ImVec4(1.00f, 0.43f, 0.35f, 1.00f);
48 | 	colors[ImGuiCol_PlotHistogram]          = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
49 | 	colors[ImGuiCol_PlotHistogramHovered]   = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
50 | 	colors[ImGuiCol_TextSelectedBg]         = ImVec4(0.73f, 0.73f, 0.73f, 0.35f);
51 | 	colors[ImGuiCol_ModalWindowDimBg]       = ImVec4(0.80f, 0.80f, 0.80f, 0.35f);
52 | 	colors[ImGuiCol_DragDropTarget]         = ImVec4(1.00f, 1.00f, 0.00f, 0.90f);
53 | 	colors[ImGuiCol_NavCursor]              = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
54 | 	colors[ImGuiCol_NavWindowingHighlight]  = ImVec4(1.00f, 1.00f, 1.00f, 0.70f);
55 | 	colors[ImGuiCol_NavWindowingDimBg]      = ImVec4(0.80f, 0.80f, 0.80f, 0.20f);
56 | 
57 | 	style.PopupRounding = 3;
58 | 
59 | 	style.WindowPadding = ImVec2(4, 4);
60 | 	style.FramePadding  = ImVec2(6, 4);
61 | 	style.ItemSpacing   = ImVec2(6, 2);
62 | 
63 | 	style.ScrollbarSize = 18;
64 | 
65 | 	style.WindowBorderSize = 1;
66 | 	style.ChildBorderSize  = 1;
67 | 	style.PopupBorderSize  = 1;
68 | 	style.FrameBorderSize  = is3D;
69 | 
70 | 	style.WindowRounding    = 3;
71 | 	style.ChildRounding     = 3;
72 | 	style.FrameRounding     = 3;
73 | 	style.ScrollbarRounding = 2;
74 | 	style.GrabRounding      = 3;
75 | 
76 | #ifdef IMGUI_HAS_DOCK
77 | 	style.TabBorderSize = is3D;
78 | 	style.TabRounding   = 3;
79 | 
80 | 	colors[ImGuiCol_DockingEmptyBg]     = ImVec4(0.38f, 0.38f, 0.38f, 1.00f);
81 | 	colors[ImGuiCol_Tab]                = ImVec4(0.25f, 0.25f, 0.25f, 1.00f);
82 | 	colors[ImGuiCol_TabHovered]         = ImVec4(0.40f, 0.40f, 0.40f, 1.00f);
83 | 	colors[ImGuiCol_TabSelected]        = ImVec4(0.33f, 0.33f, 0.33f, 1.00f);
84 | 	colors[ImGuiCol_TabDimmed]          = ImVec4(0.25f, 0.25f, 0.25f, 1.00f);
85 | 	colors[ImGuiCol_TabDimmedSelected]  = ImVec4(0.33f, 0.33f, 0.33f, 1.00f);
86 | 	colors[ImGuiCol_DockingPreview]     = ImVec4(0.85f, 0.85f, 0.85f, 0.28f);
87 | 	// clang-format on
88 | 
89 | 	if (ImGui::GetIO().ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
90 | 	{
91 | 		style.WindowRounding = 0.0f;
92 | 		style.Colors[ImGuiCol_WindowBg].w = 1.0f;
93 | 	}
94 | #endif
95 | }
96 | 


--------------------------------------------------------------------------------
/include/Sprite.h:
--------------------------------------------------------------------------------
  1 | #ifndef CLASS_SPRITE
  2 | #define CLASS_SPRITE
  3 | 
  4 | #include <nctl/Array.h>
  5 | #include <nctl/String.h>
  6 | #include <ncine/Rect.h>
  7 | #include <ncine/Matrix4x4.h>
  8 | #include <ncine/Colorf.h>
  9 | #include "SpriteEntry.h"
 10 | 
 11 | namespace ncine {
 12 | 
 13 | class GLShaderProgram;
 14 | class GLShaderUniforms;
 15 | class GLBufferObject;
 16 | 
 17 | }
 18 | 
 19 | namespace nc = ncine;
 20 | 
 21 | class Texture;
 22 | 
 23 | /// The sprite to animate
 24 | class Sprite : public SpriteEntry
 25 | {
 26 |   public:
 27 | 	struct Vertex
 28 | 	{
 29 | 		float x, y;
 30 | 		float u, v;
 31 | 	};
 32 | 
 33 | 	enum class BlendingPreset
 34 | 	{
 35 | 		DISABLED, ///< uses `GL_ONE` and `GL_ZERO`
 36 | 		ALPHA, ///< uses `GL_SRC_ALPHA` and `GL_ONE_MINUS_SRC_ALPHA`
 37 | 		PREMULTIPLIED_ALPHA, ///< uses `GL_ONE` and `GL_ONE_MINUS_SRC_ALPHA`
 38 | 		ADDITIVE, ///< uses `GL_SRC_ALPHA` and `GL_ONE`
 39 | 		MULTIPLY ///< uses `GL_DST_COLOR` and `GL_ZERO`
 40 | 	};
 41 | 
 42 | 	static const unsigned int MaxNameLength = 64;
 43 | 	nctl::String name;
 44 | 
 45 | 	bool visible;
 46 | 	float x, y;
 47 | 	float rotation;
 48 | 	nc::Vector2f scaleFactor;
 49 | 	nc::Vector2f anchorPoint;
 50 | 	nc::Colorf color;
 51 | 	/// Used by the GUI to exclude children from becoming parents of their parents
 52 | 	bool visited;
 53 | 	/// Anchor point used by some grid animation functions
 54 | 	nc::Vector2f gridAnchorPoint;
 55 | 
 56 | 	Sprite(Texture *texture);
 57 | 
 58 | 	nctl::UniquePtr<Sprite> clone() const;
 59 | 
 60 | 	void transform();
 61 | 	void updateRender();
 62 | 	void render();
 63 | 	void resetGrid();
 64 | 
 65 | 	inline int width() const { return width_; }
 66 | 	inline int height() const { return height_; }
 67 | 
 68 | 	inline nc::Recti texRect() const { return texRect_; }
 69 | 	void setTexRect(const nc::Recti &texRect);
 70 | 	inline nc::Recti flippingTexRect() const { return flippingTexRect_; }
 71 | 
 72 | 	inline const Texture &texture() const { return *texture_; }
 73 | 	inline Texture &texture() { return *texture_; }
 74 | 	void setTexture(Texture *texture);
 75 | 
 76 | 	void loadTexture(const char *filename);
 77 | 
 78 | 	inline bool isFlippedX() const { return flippedX_; }
 79 | 	void setFlippedX(bool flippedX);
 80 | 
 81 | 	inline bool isFlippedY() const { return flippedY_; }
 82 | 	void setFlippedY(bool flippedY);
 83 | 
 84 | 	inline BlendingPreset rgbBlendingPreset() const { return rgbBlendingPreset_; }
 85 | 	inline void setRgbBlendingPreset(BlendingPreset rgbBlendingPreset) { rgbBlendingPreset_ = rgbBlendingPreset; }
 86 | 	inline BlendingPreset alphaBlendingPreset() const { return alphaBlendingPreset_; }
 87 | 	inline void setAlphaBlendingPreset(BlendingPreset alphaBlendingPreset) { alphaBlendingPreset_ = alphaBlendingPreset; }
 88 | 
 89 | 	inline const nctl::Array<Vertex> &vertexRestPositions() const { return restPositions_; }
 90 | 	inline const nctl::Array<Vertex> &interleavedVertices() const { return interleavedVertices_; }
 91 | 	inline nctl::Array<Vertex> &interleavedVertices() { return interleavedVertices_; }
 92 | 
 93 | 	void *imguiTexId();
 94 | 
 95 | 	void incrementGridAnimCounter();
 96 | 	void decrementGridAnimCounter();
 97 | 
 98 | 	inline const nctl::Array<Sprite *> children() const { return children_; }
 99 | 	inline const Sprite *parent() const { return parent_; }
100 | 	inline Sprite *parent() { return parent_; }
101 | 	void setParent(Sprite *parent);
102 | 
103 | 	inline int absWidth() const { return static_cast<int>(width_ * absScaleFactor_.x); }
104 | 	inline int absHeight() const { return static_cast<int>(height_ * absScaleFactor_.y); }
105 | 
106 | 	inline const nc::Vector2f absPosition() const { return absPosition_; }
107 | 	inline void setAbsPosition(const nc::Vector2f position) { setAbsPosition(position.x, position.y); }
108 | 	void setAbsPosition(float xx, float yy);
109 | 
110 | 	inline const nc::Vector2f &absScaleFactor() const { return absScaleFactor_; }
111 | 	inline float absRotation() const { return absRotation_; }
112 | 	inline const nc::Colorf &absColor() const { return absColor_; }
113 | 
114 |   private:
115 | 	int width_;
116 | 	int height_;
117 | 
118 | 	nc::Matrix4x4f localMatrix_;
119 | 	nc::Matrix4x4f worldMatrix_;
120 | 
121 | 	nc::Vector2f absPosition_;
122 | 	nc::Vector2f absScaleFactor_;
123 | 	float absRotation_;
124 | 	nc::Colorf absColor_;
125 | 
126 | 	Texture *texture_;
127 | 	nc::Recti texRect_;
128 | 	/// Texture rectangle that takes flipping into account
129 | 	nc::Recti flippingTexRect_;
130 | 
131 | 	bool flippedX_;
132 | 	bool flippedY_;
133 | 
134 | 	BlendingPreset rgbBlendingPreset_;
135 | 	BlendingPreset alphaBlendingPreset_;
136 | 
137 | 	int gridAnimationsCounter_;
138 | 
139 | 	nctl::Array<Vertex> interleavedVertices_;
140 | 	nctl::Array<Vertex> restPositions_;
141 | 	nctl::Array<unsigned int> indices_;
142 | 	nctl::Array<unsigned short> shortIndices_;
143 | 
144 | 	Sprite *parent_;
145 | 	nctl::Array<Sprite *> children_;
146 | 
147 | 	static const int UniformsBufferSize = 256;
148 | 	unsigned char uniformsBuffer_[UniformsBufferSize];
149 | 
150 | 	nc::GLShaderProgram *spriteShaderProgram_;
151 | 	nctl::UniquePtr<nc::GLShaderUniforms> spriteShaderUniforms_;
152 | 
153 | 	nc::GLShaderProgram *meshSpriteShaderProgram_;
154 | 	nctl::UniquePtr<nc::GLShaderUniforms> meshSpriteShaderUniforms_;
155 | 
156 | 	nctl::UniquePtr<nc::GLBufferObject> vbo_;
157 | 	nctl::UniquePtr<nc::GLBufferObject> ibo_;
158 | 
159 | 	void setSize(int width, int height);
160 | 	void initGrid(int width, int height);
161 | 	void resetVertices();
162 | 	void resetIndices();
163 | 
164 | 	bool addChild(Sprite *sprite);
165 | 	bool removeChild(Sprite *sprite);
166 | };
167 | 
168 | #endif
169 | 


--------------------------------------------------------------------------------
/src/SpriteManager.cpp:
--------------------------------------------------------------------------------
  1 | #include "SpriteManager.h"
  2 | #include "Texture.h"
  3 | #include "Sprite.h"
  4 | #include <ncine/GLBlending.h>
  5 | 
  6 | namespace {
  7 | 
  8 | void setBlendingFactors(Sprite::BlendingPreset blendingPreset, GLenum &sfactor, GLenum &dfactor)
  9 | {
 10 | 	switch (blendingPreset)
 11 | 	{
 12 | 		case Sprite::BlendingPreset::DISABLED:
 13 | 			sfactor = GL_ONE;
 14 | 			dfactor = GL_ZERO;
 15 | 			break;
 16 | 		case Sprite::BlendingPreset::ALPHA:
 17 | 			sfactor = GL_SRC_ALPHA;
 18 | 			dfactor = GL_ONE_MINUS_SRC_ALPHA;
 19 | 			break;
 20 | 		case Sprite::BlendingPreset::PREMULTIPLIED_ALPHA:
 21 | 			sfactor = GL_ONE;
 22 | 			dfactor = GL_ONE_MINUS_SRC_ALPHA;
 23 | 			break;
 24 | 		case Sprite::BlendingPreset::ADDITIVE:
 25 | 			sfactor = GL_SRC_ALPHA;
 26 | 			dfactor = GL_ONE;
 27 | 			break;
 28 | 		case Sprite::BlendingPreset::MULTIPLY:
 29 | 			sfactor = GL_DST_COLOR;
 30 | 			dfactor = GL_ZERO;
 31 | 			break;
 32 | 	}
 33 | }
 34 | 
 35 | void setBlendingFactors(Sprite::BlendingPreset rgbBlendingPreset, Sprite::BlendingPreset alphaBlendingPreset)
 36 | {
 37 | 	GLenum rgbSourceFactor = GL_ONE;
 38 | 	GLenum rgbDestFactor = GL_ZERO;
 39 | 	GLenum alphaSourceFactor = GL_ONE;
 40 | 	GLenum alphaDestFactor = GL_ZERO;
 41 | 
 42 | 	setBlendingFactors(rgbBlendingPreset, rgbSourceFactor, rgbDestFactor);
 43 | 	setBlendingFactors(alphaBlendingPreset, alphaSourceFactor, alphaDestFactor);
 44 | 
 45 | 	nc::GLBlending::setBlendFunc(rgbSourceFactor, rgbDestFactor, alphaSourceFactor, alphaDestFactor);
 46 | }
 47 | 
 48 | void recursiveLinearizeSprites(SpriteGroup &group, nctl::Array<Sprite *> &sprites, unsigned int &spriteId)
 49 | {
 50 | 	for (unsigned int i = 0; i < group.children().size(); i++)
 51 | 	{
 52 | 		SpriteEntry &child = *group.children()[i];
 53 | 		if (child.isSprite())
 54 | 		{
 55 | 			sprites.pushBack(child.toSprite());
 56 | 			child.setSpriteId(spriteId++);
 57 | 		}
 58 | 		else if (child.isGroup())
 59 | 			recursiveLinearizeSprites(*child.toGroup(), sprites, spriteId);
 60 | 	}
 61 | }
 62 | 
 63 | }
 64 | 
 65 | ///////////////////////////////////////////////////////////
 66 | // CONSTRUCTORS and DESTRUCTOR
 67 | ///////////////////////////////////////////////////////////
 68 | 
 69 | SpriteManager::SpriteManager()
 70 |     : textures_(4), root_(nctl::makeUnique<SpriteGroup>("Root")), spritesWithoutParent_(4), spritesArray_(4)
 71 | {
 72 | 	nc::GLBlending::enable();
 73 | }
 74 | 
 75 | ///////////////////////////////////////////////////////////
 76 | // PUBLIC FUNCTIONS
 77 | ///////////////////////////////////////////////////////////
 78 | 
 79 | nctl::Array<nctl::UniquePtr<SpriteEntry>> &SpriteManager::children()
 80 | {
 81 | 	return root_->children();
 82 | }
 83 | 
 84 | const nctl::Array<nctl::UniquePtr<SpriteEntry>> &SpriteManager::children() const
 85 | {
 86 | 	return root_->children();
 87 | }
 88 | 
 89 | void SpriteManager::updateSpritesArray()
 90 | {
 91 | 	spritesArray_.clear();
 92 | 	unsigned int spriteId = 0;
 93 | 	recursiveLinearizeSprites(*root_, spritesArray_, spriteId);
 94 | }
 95 | 
 96 | void SpriteManager::update()
 97 | {
 98 | 	spritesWithoutParent_.clear();
 99 | 	for (unsigned int i = 0; i < spritesArray_.size(); i++)
100 | 	{
101 | 		if (spritesArray_[i]->parent() == nullptr)
102 | 			spritesWithoutParent_.pushBack(spritesArray_[i]);
103 | 	}
104 | 
105 | 	for (unsigned int i = 0; i < spritesWithoutParent_.size(); i++)
106 | 		transform(spritesWithoutParent_[i]);
107 | 
108 | 	for (unsigned int i = 0; i < spritesArray_.size(); i++)
109 | 		draw(spritesArray_[i]);
110 | }
111 | 
112 | int SpriteManager::textureIndex(const Texture *texture) const
113 | {
114 | 	if (texture == nullptr)
115 | 		return -1;
116 | 
117 | 	int index = -1;
118 | 	for (unsigned int i = 0; i < textures_.size(); i++)
119 | 	{
120 | 		if (textures_[i].get() == texture)
121 | 		{
122 | 			index = static_cast<int>(i);
123 | 			break;
124 | 		}
125 | 	}
126 | 
127 | 	return index;
128 | }
129 | 
130 | SpriteGroup *SpriteManager::addGroup(SpriteEntry *selected)
131 | {
132 | 	SpriteGroup *parent = root_.get();
133 | 	if (selected && selected->isGroup())
134 | 		parent = selected->toGroup();
135 | 	else if (selected && selected->isSprite())
136 | 		parent = selected->parentGroup();
137 | 
138 | 	nctl::UniquePtr<SpriteGroup> spriteGroup = nctl::makeUnique<SpriteGroup>();
139 | 	spriteGroup->setParentGroup(parent);
140 | 	parent->children().pushBack(nctl::move(spriteGroup));
141 | 
142 | 	return parent->children().back()->toGroup();
143 | }
144 | 
145 | Sprite *SpriteManager::addSprite(SpriteEntry *selected, Texture *texture)
146 | {
147 | 	SpriteGroup *parent = root_.get();
148 | 	if (selected && selected->isGroup())
149 | 		parent = selected->toGroup();
150 | 	else if (selected && selected->isSprite())
151 | 		parent = selected->parentGroup();
152 | 
153 | 	nctl::UniquePtr<Sprite> sprite = nctl::makeUnique<Sprite>(texture);
154 | 	sprite->setParentGroup(parent);
155 | 	parent->children().pushBack(nctl::move(sprite));
156 | 
157 | 	return parent->children().back()->toSprite();
158 | }
159 | 
160 | void SpriteManager::clear()
161 | {
162 | 	root_->children().clear();
163 | 	spritesArray_.clear();
164 | 	textures_.clear();
165 | }
166 | 
167 | ///////////////////////////////////////////////////////////
168 | // PRIVATE FUNCTIONS
169 | ///////////////////////////////////////////////////////////
170 | 
171 | void SpriteManager::transform(Sprite *sprite)
172 | {
173 | 	sprite->transform();
174 | 
175 | 	for (unsigned int i = 0; i < sprite->children().size(); i++)
176 | 		transform(sprite->children()[i]);
177 | }
178 | 
179 | void SpriteManager::draw(Sprite *sprite)
180 | {
181 | 	if (sprite->visible == false)
182 | 		return;
183 | 
184 | 	sprite->updateRender();
185 | 	setBlendingFactors(sprite->rgbBlendingPreset(), sprite->alphaBlendingPreset());
186 | 	sprite->render();
187 | 	sprite->resetGrid();
188 | }
189 | 


--------------------------------------------------------------------------------
/.github/workflows/android.yml:
--------------------------------------------------------------------------------
  1 | name: 'Android'
  2 | 
  3 | env:
  4 |   LIBRARIES_BRANCH: libraries-OS-COMPILER
  5 |   NCINE_SOURCE_BRANCH: BRANCH_NAME
  6 |   DEPLOY_MESSAGE:
  7 |     "Push artifact from GitHub Actions build ${{ github.run_number }} with id ${{ github.run_id }}
  8 | 
  9 |      - PROJECT_NAME artifact from branch 'BRANCH_NAME' with commit id ${{ github.sha }}"
 10 |   IMGUI_VERSION_TAG: v1.92.5-docking
 11 | 
 12 | on: [push, workflow_dispatch]
 13 | 
 14 | jobs:
 15 |   Android:
 16 |     strategy:
 17 |       fail-fast: false
 18 |       matrix:
 19 |         ARCH: [armeabi-v7a, arm64-v8a, x86_64]
 20 |         BuildType: [Debug, Release]
 21 | 
 22 |     runs-on: 'ubuntu-24.04'
 23 | 
 24 |     steps:
 25 |     - name: 'Checkout Code'
 26 |       uses: actions/checkout@v4
 27 | 
 28 |     - name: 'Install nCine Build Dependencies'
 29 |       run: |
 30 |         sudo apt-get update
 31 |         sudo apt-get install -y libgl-dev libxext-dev libxrandr-dev libwayland-dev
 32 | 
 33 |     - name: 'Unshallow Git Repository for Versioning'
 34 |       run: |
 35 |         git fetch --unshallow || true
 36 | 
 37 |     - name: 'Download nCine-libraries and project data'
 38 |       run: |
 39 |         export OS=linux
 40 |         export CC=gcc
 41 |         export BRANCH_NAME=$(git describe --tags --exact-match 2> /dev/null || git symbolic-ref -q --short HEAD || git rev-parse --short HEAD)
 42 | 
 43 |         export LIBRARIES_BRANCH=`echo $LIBRARIES_BRANCH | sed 's/OS/'"$OS"'/'`
 44 |         export LIBRARIES_BRANCH=`echo $LIBRARIES_BRANCH | sed 's/COMPILER/'"$CC"'/'`
 45 | 
 46 |         cd ..
 47 |         git clone https://github.com/nCine/nCine-libraries-artifacts.git
 48 |         cd nCine-libraries-artifacts
 49 |         git checkout $LIBRARIES_BRANCH
 50 |         LIBRARIES_FILE=$(ls -t | head -n 1) && tar xpzf $LIBRARIES_FILE
 51 |         mv nCine-external ..
 52 |         git checkout android-libraries-armeabi-v7a
 53 |         LIBRARIES_FILE=$(ls -t | head -n 1) && tar xpzf $LIBRARIES_FILE
 54 |         git checkout android-libraries-arm64-v8a
 55 |         LIBRARIES_FILE=$(ls -t | head -n 1) && tar xpzf $LIBRARIES_FILE
 56 |         git checkout android-libraries-x86_64
 57 |         LIBRARIES_FILE=$(ls -t | head -n 1) && tar xpzf $LIBRARIES_FILE
 58 |         mv nCine-android-external ..
 59 |         cd ..
 60 |         rm -rf nCine-libraries-artifacts
 61 | 
 62 |         git clone https://github.com/$GITHUB_REPOSITORY-data.git
 63 | 
 64 |     - name: 'Download nCine source and data'
 65 |       run: |
 66 |         export BRANCH_NAME=$(git describe --tags --exact-match 2> /dev/null || git symbolic-ref -q --short HEAD || git rev-parse --short HEAD)
 67 |         export NCINE_SOURCE_BRANCH=`echo $NCINE_SOURCE_BRANCH | sed 's/BRANCH_NAME/'"$BRANCH_NAME"'/'`
 68 | 
 69 |         cd ..
 70 |         git clone https://github.com/nCine/nCine-data.git
 71 |         git clone https://github.com/nCine/nCine.git --branch $NCINE_SOURCE_BRANCH
 72 | 
 73 |     - name: 'CMake Configuration and Make of nCine as a static library'
 74 |       run: |
 75 |         cd ../nCine
 76 |         export CMAKE_ARGS=" -B ../nCine-build-${{ matrix.BuildType }} -D CMAKE_BUILD_TYPE=${{ matrix.BuildType }} -D NCINE_DYNAMIC_LIBRARY=OFF -D IMGUI_VERSION_TAG=$IMGUI_VERSION_TAG -D NCINE_WITH_SCENEGRAPH=OFF -D NCINE_WITH_THREADS=OFF -D NCINE_WITH_WEBP=OFF -D NCINE_WITH_AUDIO=OFF -D NCINE_WITH_SCRIPTING_API=OFF -D NCINE_BUILD_TESTS=OFF -D NCINE_BUILD_ANDROID=ON -D NCINE_NDK_ARCHITECTURES=${{ matrix.ARCH }} -D CMAKE_PREFIX_PATH=$(pwd)/../nCine-external"
 77 | 
 78 |         cmake $CMAKE_ARGS
 79 |         cd ..
 80 |         make -j $(getconf _NPROCESSORS_ONLN) -C nCine-build-${{ matrix.BuildType }}
 81 | 
 82 |     - name: 'CMake Configuration'
 83 |       run: |
 84 |         export PROJECT_NAME=${GITHUB_REPOSITORY##*/}
 85 | 
 86 |         cmake -B ../$PROJECT_NAME-build-${{ matrix.BuildType }} -D CMAKE_BUILD_TYPE=${{ matrix.BuildType }} -D NCPROJECT_NDK_ARCHITECTURES=${{ matrix.ARCH }} -D NCPROJECT_BUILD_ANDROID=ON -D NCPROJECT_ASSEMBLE_APK=ON -D nCine_DIR=$(pwd)/../nCine-build-${{ matrix.BuildType }} -D CMAKE_PREFIX_PATH=$(pwd)/../nCine-external
 87 | 
 88 |     - name: 'Gradle Assemble'
 89 |       run: |
 90 |         export JAVA_HOME=$JAVA_HOME_17_X64
 91 |         export PROJECT_NAME=${GITHUB_REPOSITORY##*/}
 92 |         export MAKEFLAGS="-j $(getconf _NPROCESSORS_ONLN)"
 93 | 
 94 |         cd ../$PROJECT_NAME-build-${{ matrix.BuildType }}/android
 95 |         gradle assemble${{ matrix.BuildType }} --parallel
 96 | 
 97 |     - name: 'Push Artifacts'
 98 |       env:
 99 |         PUBLIC_REPO_TOKEN: ${{ secrets.PUBLIC_REPO_TOKEN }}
100 |       run: |
101 |         git config --global user.email "actions@github.com"
102 |         git config --global user.name "GitHub Actions"
103 | 
104 |         export PROJECT_NAME=${GITHUB_REPOSITORY##*/}
105 |         export BRANCH_NAME=$(git describe --tags --exact-match 2> /dev/null || git symbolic-ref -q --short HEAD || git rev-parse --short HEAD)
106 |         export DEPLOY_MESSAGE=`sed 's/PROJECT_NAME/'"$PROJECT_NAME"'/' <<< "$DEPLOY_MESSAGE"`
107 |         export DEPLOY_MESSAGE=`sed 's/BRANCH_NAME/'"$BRANCH_NAME"'/' <<< "$DEPLOY_MESSAGE"`
108 | 
109 |         cd ..
110 |         export DEPLOY_BRANCH=$PROJECT_NAME-$BRANCH_NAME-android-${{ matrix.ARCH }}-${{ matrix.BuildType }}
111 |         git clone https://$PUBLIC_REPO_TOKEN@github.com/$GITHUB_REPOSITORY-artifacts.git >/dev/null 2>&1
112 |         cd $PROJECT_NAME-artifacts
113 | 
114 |         git checkout $DEPLOY_BRANCH || git checkout --orphan $DEPLOY_BRANCH
115 |         git reset
116 |         git clean -f
117 |         git rm * || true
118 |         mv -f ../$PROJECT_NAME-build-${{ matrix.BuildType }}/android/app/build/outputs/apk/*/*.apk .
119 |         git add *.apk
120 |         git commit --amend -m "$DEPLOY_MESSAGE" || git commit -m "$DEPLOY_MESSAGE"
121 |         git push --force || git push --set-upstream origin $DEPLOY_BRANCH
122 | 


--------------------------------------------------------------------------------
/include/gui/gui_tips.h:
--------------------------------------------------------------------------------
 1 | #ifndef GUI_TIPS
 2 | #define GUI_TIPS
 3 | 
 4 | #include "gui_labels.h"
 5 | #include <nctl/StaticArray.h>
 6 | #include <nctl/String.h>
 7 | 
 8 | namespace Tips {
 9 | 
10 | /// The longest tip string will be wrapped to the following number of lines by the ImGui::Text widget
11 | const unsigned int MaxNumberLines = 5;
12 | 
13 | const unsigned int Count = 31;
14 | nctl::StaticArray<nctl::String, Count> Strings;
15 | 
16 | void initStrings()
17 | {
18 | 	nctl::String temp(512);
19 | 	Strings.pushBack(temp.format("Pressing [F1] will open the browser and load the documentation.\nYou can do the same by accessing the \"%s\" item in the [Help] menu.", Labels::Documentation));
20 | 	Strings.pushBack("You can drag windows around and anchor them into any corner, change the split space between them or tab them one next to another.");
21 | 	Strings.pushBack("If you press [Ctrl] while clicking on a slider or a drag box you can input the value with the keyboard.");
22 | 	Strings.pushBack("You can modify the speed of change of drag boxes by pressing [Shift] (faster) or [Alt] (slower)");
23 | 	Strings.pushBack(temp.format("You can drag and drop colors around. For example, the background color of the \"%s\" window onto the sprite color in the \"%s\" window.", Labels::Canvas, Labels::Sprite));
24 | 	Strings.pushBack("Pressing [F5] will save your work using a name based on date and time, so you can quick save multiple versions without ever overwriting any. Pressing [F9] will load the latest one.");
25 | 	Strings.pushBack("You can delete the selected texture, sprite, script, or animation with the [Delete] key when the mouse is over the relative window.");
26 | 	Strings.pushBack("You can reorder sprites or animations with drag and drop.");
27 | 	Strings.pushBack(temp.format("The texture icon (%s) at the end of a sprite entry indicates that the sprite is using the currently selected texture.", Labels::SelectedTextureIcon));
28 | 	Strings.pushBack(temp.format("The checkmark (%s) or cross (%s) icon at the end of a script entry indicates that the script can be run or not.\nHovering with the mouse on a script that cannot run will show additional information about the error.", Labels::CheckIcon, Labels::TimesIcon));
29 | 	Strings.pushBack("You can reload a script by pressing [CTRL + R].");
30 | 	Strings.pushBack(temp.format("Pressing [Space] when hovering on the \"%s\" window will toggle the animation state between playing and paused.", Labels::Canvas));
31 | 	Strings.pushBack(temp.format("The sprite icon (%s) at the end of an animation entry indicates that the animation is assigned to the currently selected sprite.\nWhen you select a different animation its assigned sprite will be automatically selected.", Labels::SelectedSpriteIcon));
32 | 	Strings.pushBack(temp.format("You can use the \"%s\" window to help you set up the texture rectangle of a sprite using the mouse.", Labels::TexRect));
33 | 	Strings.pushBack(temp.format("The lock icon (%s) at the end of an animation entry indicates that the animation curve is locked.\nThe property, grid, or script will affect the sprite even if the animation is stopped or paused.", Labels::LockedAnimIcon));
34 | 	Strings.pushBack(temp.format("You can change the canvas zoom level by hovering on the \"%s\" window pressing the [Ctrl] key and scrolling the mouse wheel.", Labels::Canvas));
35 | 	Strings.pushBack(temp.format("Pressing [Alt] while clicking on the \"%s\" window will drag the selected sprite around.", Labels::Canvas));
36 | 	Strings.pushBack(temp.format("Pressing the arrow keys while the cursor is on the \"%s\" window will move the selected sprite in one-pixel increments for precise positioning.", Labels::Canvas));
37 | 	Strings.pushBack("Right-clicking on a texture, a sprite, a script, or an animation will show a contextual menu with a series of actions that you can perform.");
38 | 	Strings.pushBack("Animation groups have an option to override the sprite used by every contained animations. It comes in handy when you clone a group to apply the same animations to a different sprite.");
39 | 	Strings.pushBack(temp.format("Press [CTRL] while selecting a sprite or a sprite group (%s) in the \"%s\" window or an animation in the \"%s\" window to change its name.", Labels::GroupIcon, Labels::Sprite, Labels::Animations));
40 | 	Strings.pushBack(temp.format("Pressing the up or down arrow key when hovering on the \"%s\" or the \"%s\" windows will move sprites and animations up or down.", Labels::Sprites, Labels::Animations));
41 | 	Strings.pushBack(temp.format("Pressing the left or right arrow key when hovering on the \"%s\" window will show either the previous or the next tip.", Labels::Tips));
42 | 	Strings.pushBack(temp.format("In the \"%s\" window, press [ALT] to drag the texture rectangle around, and [SHIFT] to resize it from one corner.", Labels::TexRect));
43 | 	Strings.pushBack(temp.format("In a file dialog window, press the \"%s\" button to save the current directory to the list on the left.\nYou can then click it to navigate there with the browser.", Labels::FileDialog_Pin));
44 | 	Strings.pushBack(temp.format("Drag directories onto the list of pinned ones on the left side of a file dialog window to add them to the list."));
45 | 	Strings.pushBack(temp.format("Drag a file or a directory onto the browser on the right side of a file dialog window to navigate to that file or directory."));
46 | 	Strings.pushBack(temp.format("Drag files to the \"%s\" or \"%s\" windows to load them.", Labels::Textures, Labels::Scripts));
47 | 	Strings.pushBack(temp.format("Drag a file or a directory to the \"%s\" window to use it as a save directory for rendering.", Labels::Render));
48 | 	Strings.pushBack(temp.format("You can revert a video mode change before the \"%s\" popup times out by pressing [Escape].", Labels::VideoModeChanged));
49 | 	Strings.pushBack(temp.format("You can navigate through the file browser directory history with your extra mouse buttons, use the fourth button for \"%s\" (Previous) and the fifth for \"%s\" (Next)", Labels::FileDialog_PrevHistoryNav, Labels::FileDialog_NextHistoryNav));
50 | 
51 | 	ASSERT(Strings.size() == Count);
52 | }
53 | 
54 | }
55 | 
56 | #endif
57 | 


--------------------------------------------------------------------------------
/.github/workflows/macos.yml:
--------------------------------------------------------------------------------
  1 | name: 'macOS'
  2 | 
  3 | env:
  4 |   LIBRARIES_BRANCH: libraries-OS-COMPILER
  5 |   NCINE_SOURCE_BRANCH: BRANCH_NAME
  6 |   DEPLOY_MESSAGE:
  7 |     "Push artifact from GitHub Actions build ${{ github.run_number }} with id ${{ github.run_id }}
  8 | 
  9 |      - PROJECT_NAME artifact from branch 'BRANCH_NAME' with commit id ${{ github.sha }}"
 10 |   DEPLOY_BRANCH: PROJECT_NAME-BRANCH_NAME-OS-COMPILER
 11 |   IMGUI_VERSION_TAG: v1.92.5-docking
 12 | 
 13 | on: [push, workflow_dispatch]
 14 | 
 15 | jobs:
 16 |   macOS:
 17 |     strategy:
 18 |       fail-fast: false
 19 |       matrix:
 20 |         BuildType: [Debug, Release, BinDist]
 21 |         os: [macOS-15, macOS-15-intel]
 22 | 
 23 |     runs-on: ${{ matrix.os }}
 24 | 
 25 |     steps:
 26 |     - name: 'Checkout Code'
 27 |       uses: actions/checkout@v4
 28 | 
 29 |     - name: 'Unshallow Git Repository for Versioning'
 30 |       if: matrix.BuildType == 'BinDist'
 31 |       run: |
 32 |         git fetch --unshallow || true
 33 | 
 34 |     - name: 'Download nCine-libraries and project data'
 35 |       run: |
 36 |         if [[ "${{ matrix.os }}" == "macOS-15" ]]; then
 37 |           export OS=macos15
 38 |         else
 39 |           export OS=macos15-intel
 40 |         fi
 41 |         export CC=appleclang
 42 | 
 43 |         export LIBRARIES_BRANCH=`echo $LIBRARIES_BRANCH | sed 's/OS/'"$OS"'/'`
 44 |         export LIBRARIES_BRANCH=`echo $LIBRARIES_BRANCH | sed 's/COMPILER/'"$CC"'/'`
 45 | 
 46 |         cd ..
 47 |         git clone https://github.com/nCine/nCine-libraries-artifacts.git
 48 |         cd nCine-libraries-artifacts
 49 |         git checkout $LIBRARIES_BRANCH
 50 |         LIBRARIES_FILE=$(ls -t | head -n 1) && tar xpzf $LIBRARIES_FILE
 51 |         mv nCine-external ..
 52 |         cd ..
 53 |         rm -rf nCine-libraries-artifacts
 54 | 
 55 |         git clone https://github.com/$GITHUB_REPOSITORY-data.git
 56 | 
 57 |     - name: 'Download nCine source and data'
 58 |       run: |
 59 |         export BRANCH_NAME=$(git describe --tags --exact-match 2> /dev/null || git symbolic-ref -q --short HEAD || git rev-parse --short HEAD)
 60 |         export NCINE_SOURCE_BRANCH=`echo $NCINE_SOURCE_BRANCH | sed 's/BRANCH_NAME/'"$BRANCH_NAME"'/'`
 61 | 
 62 |         cd ..
 63 |         git clone https://github.com/nCine/nCine-data.git
 64 |         git clone https://github.com/nCine/nCine.git --branch $NCINE_SOURCE_BRANCH
 65 | 
 66 |     - name: 'CMake Configuration and Make of nCine as a static library'
 67 |       run: |
 68 |         cd ../nCine
 69 |         if [[ "${{ matrix.BuildType }}" == "BinDist" ]]; then
 70 |           export NCINE_BUILD_TYPE=Release
 71 |         else
 72 |           export NCINE_BUILD_TYPE=${{ matrix.BuildType }}
 73 |         fi
 74 |         export CMAKE_ARGS="-B ../nCine-build-$NCINE_BUILD_TYPE -D CMAKE_BUILD_TYPE=$NCINE_BUILD_TYPE -D NCINE_DYNAMIC_LIBRARY=OFF -D IMGUI_VERSION_TAG=$IMGUI_VERSION_TAG -D NCINE_PREFERRED_BACKEND=SDL2 -D NCINE_WITH_SCENEGRAPH=OFF -D NCINE_WITH_THREADS=OFF -D NCINE_WITH_WEBP=OFF -D NCINE_WITH_AUDIO=OFF -D NCINE_WITH_SCRIPTING_API=OFF -D NCINE_BUILD_TESTS=OFF"
 75 | 
 76 |         cmake $CMAKE_ARGS
 77 |         cd ..
 78 |         make -j $(getconf _NPROCESSORS_ONLN) -C nCine-build-$NCINE_BUILD_TYPE
 79 | 
 80 |     - name: 'CMake Configuration'
 81 |       run: |
 82 |         export PROJECT_NAME=${GITHUB_REPOSITORY##*/}
 83 | 
 84 |         export CMAKE_ARGS="-B ../$PROJECT_NAME-build-${{ matrix.BuildType }}"
 85 | 
 86 |         if [[ "${{ matrix.BuildType }}" == "BinDist" ]]; then
 87 |           cmake $CMAKE_ARGS -D NCPROJECT_OPTIONS_PRESETS=${{ matrix.BuildType }} -D nCine_DIR=$(pwd)/../nCine-build-Release
 88 |         else
 89 |           cmake $CMAKE_ARGS -D CMAKE_BUILD_TYPE=${{ matrix.BuildType }} -D nCine_DIR=$(pwd)/../nCine-build-${{ matrix.BuildType }}
 90 |         fi
 91 | 
 92 |     - name: 'Make'
 93 |       run: |
 94 |         export PROJECT_NAME=${GITHUB_REPOSITORY##*/}
 95 |         make -j $(getconf _NPROCESSORS_ONLN) -C ../$PROJECT_NAME-build-${{ matrix.BuildType }}
 96 | 
 97 |     - name: 'Package'
 98 |       if: matrix.BuildType == 'BinDist'
 99 |       run: |
100 |         export PROJECT_NAME=${GITHUB_REPOSITORY##*/}
101 |         make package -C ../$PROJECT_NAME-build-${{ matrix.BuildType }}
102 | 
103 |     - name: 'Push Artifacts'
104 |       if: matrix.BuildType == 'BinDist'
105 |       env:
106 |         PUBLIC_REPO_TOKEN: ${{ secrets.PUBLIC_REPO_TOKEN }}
107 |       run: |
108 |         git config --global user.email "actions@github.com"
109 |         git config --global user.name "GitHub Actions"
110 | 
111 |         export PROJECT_NAME=${GITHUB_REPOSITORY##*/}
112 |         export BRANCH_NAME=$(git describe --tags --exact-match 2> /dev/null || git symbolic-ref -q --short HEAD || git rev-parse --short HEAD)
113 |         export DEPLOY_MESSAGE=`sed 's/PROJECT_NAME/'"$PROJECT_NAME"'/' <<< "$DEPLOY_MESSAGE"`
114 |         export DEPLOY_MESSAGE=`sed 's/BRANCH_NAME/'"$BRANCH_NAME"'/' <<< "$DEPLOY_MESSAGE"`
115 | 
116 |         if [[ "${{ matrix.os }}" == "macOS-15" ]]; then
117 |           export OS=macos15
118 |         else
119 |           export OS=macos15-intel
120 |         fi
121 |         export CC=appleclang
122 |         export PROJECT_EXT=dmg
123 | 
124 |         cd ..
125 |         export DEPLOY_BRANCH=`echo $DEPLOY_BRANCH | sed 's/PROJECT_NAME/'"$PROJECT_NAME"'/'`
126 |         export DEPLOY_BRANCH=`echo $DEPLOY_BRANCH | sed 's/BRANCH_NAME/'"$BRANCH_NAME"'/'`
127 |         export DEPLOY_BRANCH=`echo $DEPLOY_BRANCH | sed 's/OS/'"$OS"'/'`
128 |         export DEPLOY_BRANCH=`echo $DEPLOY_BRANCH | sed 's/COMPILER/'"$CC"'/'`
129 |         git clone https://$PUBLIC_REPO_TOKEN@github.com/$GITHUB_REPOSITORY-artifacts.git >/dev/null 2>&1
130 |         cd $PROJECT_NAME-artifacts
131 | 
132 |         git checkout $DEPLOY_BRANCH || git checkout --orphan $DEPLOY_BRANCH
133 |         git reset
134 |         git clean -f
135 |         git rm * || true
136 |         mv -f ../$PROJECT_NAME-build-${{ matrix.BuildType }}/*.$PROJECT_EXT .
137 |         git add *.$PROJECT_EXT
138 |         git commit --amend -m "$DEPLOY_MESSAGE" || git commit -m "$DEPLOY_MESSAGE"
139 |         git push --force || git push --set-upstream origin $DEPLOY_BRANCH
140 | 


--------------------------------------------------------------------------------
/.github/workflows/emscripten.yml:
--------------------------------------------------------------------------------
  1 | name: 'Emscripten'
  2 | 
  3 | env:
  4 |   LIBRARIES_BRANCH: libraries-OS-COMPILER
  5 |   NCINE_SOURCE_BRANCH: BRANCH_NAME
  6 |   DEPLOY_MESSAGE:
  7 |     "Push artifact from GitHub Actions build ${{ github.run_number }} with id ${{ github.run_id }}
  8 | 
  9 |      - PROJECT_NAME artifact from branch 'BRANCH_NAME' with commit id ${{ github.sha }}"
 10 |   DEPLOY_BRANCH: PROJECT_NAME-BRANCH_NAME-OS-COMPILER
 11 |   IMGUI_VERSION_TAG: v1.92.5-docking
 12 | 
 13 | on: [push, workflow_dispatch]
 14 | 
 15 | jobs:
 16 |   Emscripten:
 17 |     strategy:
 18 |       fail-fast: false
 19 |       matrix:
 20 |         BuildType: [Debug, Release, BinDist]
 21 | 
 22 |     runs-on: 'ubuntu-24.04'
 23 | 
 24 |     steps:
 25 |     - name: 'Checkout Code'
 26 |       uses: actions/checkout@v4
 27 | 
 28 |     - name: 'Install Emscripten SDK'
 29 |       run: |
 30 |         sudo update-alternatives --install /usr/bin/python python /usr/bin/python3 10
 31 | 
 32 |         cd ..
 33 |         git clone https://github.com/emscripten-core/emsdk.git
 34 |         cd emsdk
 35 |         ./emsdk install latest
 36 |         ./emsdk activate latest
 37 | 
 38 |     - name: 'Unshallow Git Repository for Versioning'
 39 |       if: matrix.BuildType == 'BinDist'
 40 |       run: |
 41 |         git fetch --unshallow || true
 42 | 
 43 |     - name: 'Download nCine-libraries and project data'
 44 |       run: |
 45 |         export OS=emscripten
 46 |         export CC=emcc
 47 | 
 48 |         export LIBRARIES_BRANCH=`echo $LIBRARIES_BRANCH | sed 's/OS/'"$OS"'/'`
 49 |         export LIBRARIES_BRANCH=`echo $LIBRARIES_BRANCH | sed 's/COMPILER/'"$CC"'/'`
 50 | 
 51 |         cd ..
 52 |         git clone https://github.com/nCine/nCine-libraries-artifacts.git
 53 |         cd nCine-libraries-artifacts
 54 |         git checkout $LIBRARIES_BRANCH
 55 |         LIBRARIES_FILE=$(ls -t | head -n 1) && tar xpzf $LIBRARIES_FILE
 56 |         mv nCine-external-emscripten ..
 57 | 
 58 |         cd ..
 59 |         rm -rf nCine-libraries-artifacts
 60 | 
 61 |         git clone https://github.com/$GITHUB_REPOSITORY-data.git
 62 | 
 63 |     - name: 'Download nCine source and data'
 64 |       run: |
 65 |         export BRANCH_NAME=$(git describe --tags --exact-match 2> /dev/null || git symbolic-ref -q --short HEAD || git rev-parse --short HEAD)
 66 |         export NCINE_SOURCE_BRANCH=`echo $NCINE_SOURCE_BRANCH | sed 's/BRANCH_NAME/'"$BRANCH_NAME"'/'`
 67 | 
 68 |         cd ..
 69 |         git clone https://github.com/nCine/nCine-data.git
 70 |         git clone https://github.com/nCine/nCine.git --branch $NCINE_SOURCE_BRANCH
 71 | 
 72 |     - name: 'CMake Configuration and Make of nCine as a static library'
 73 |       run: |
 74 |         source ../emsdk/emsdk_env.sh
 75 | 
 76 |         cd ../nCine
 77 |         if [[ "${{ matrix.BuildType }}" == "BinDist" ]]; then
 78 |           export NCINE_BUILD_TYPE=Release
 79 |         else
 80 |           export NCINE_BUILD_TYPE=${{ matrix.BuildType }}
 81 |         fi
 82 |         export CMAKE_ARGS="-B ../nCine-build-$NCINE_BUILD_TYPE -D CMAKE_BUILD_TYPE=$NCINE_BUILD_TYPE -D NCINE_DYNAMIC_LIBRARY=OFF -D IMGUI_VERSION_TAG=$IMGUI_VERSION_TAG -D NCINE_PREFERRED_BACKEND=SDL2 -D NCINE_WITH_SCENEGRAPH=OFF -D NCINE_WITH_THREADS=OFF -D NCINE_WITH_WEBP=OFF -D NCINE_WITH_AUDIO=OFF -D NCINE_WITH_SCRIPTING_API=OFF -D NCINE_BUILD_TESTS=OFF"
 83 | 
 84 |         emcmake cmake $CMAKE_ARGS
 85 |         cd ..
 86 |         make -j $(getconf _NPROCESSORS_ONLN) -C nCine-build-$NCINE_BUILD_TYPE
 87 | 
 88 |     - name: 'CMake Configuration'
 89 |       run: |
 90 |         export PROJECT_NAME=${GITHUB_REPOSITORY##*/}
 91 | 
 92 |         source ../emsdk/emsdk_env.sh
 93 |         export CMAKE_ARGS="-B ../$PROJECT_NAME-build-${{ matrix.BuildType }}"
 94 | 
 95 |         if [[ "${{ matrix.BuildType }}" == "BinDist" ]]; then
 96 |           emcmake cmake $CMAKE_ARGS -D NCPROJECT_OPTIONS_PRESETS=${{ matrix.BuildType }} -D nCine_DIR=$(pwd)/../nCine-build-Release
 97 |         else
 98 |           emcmake cmake $CMAKE_ARGS -D CMAKE_BUILD_TYPE=${{ matrix.BuildType }} -D nCine_DIR=$(pwd)/../nCine-build-${{ matrix.BuildType }}
 99 |         fi
100 | 
101 |     - name: 'Make'
102 |       run: |
103 |         export PROJECT_NAME=${GITHUB_REPOSITORY##*/}
104 |         make -j $(getconf _NPROCESSORS_ONLN) -C ../$PROJECT_NAME-build-${{ matrix.BuildType }}
105 | 
106 |     - name: 'Package'
107 |       if: matrix.BuildType == 'BinDist'
108 |       run: |
109 |         export PROJECT_NAME=${GITHUB_REPOSITORY##*/}
110 |         make package -C ../$PROJECT_NAME-build-${{ matrix.BuildType }}
111 | 
112 |     - name: 'Push Artifacts'
113 |       if: matrix.BuildType == 'BinDist'
114 |       env:
115 |         PUBLIC_REPO_TOKEN: ${{ secrets.PUBLIC_REPO_TOKEN }}
116 |       run: |
117 |         git config --global user.email "actions@github.com"
118 |         git config --global user.name "GitHub Actions"
119 | 
120 |         export PROJECT_NAME=${GITHUB_REPOSITORY##*/}
121 |         export BRANCH_NAME=$(git describe --tags --exact-match 2> /dev/null || git symbolic-ref -q --short HEAD || git rev-parse --short HEAD)
122 |         export DEPLOY_MESSAGE=`sed 's/PROJECT_NAME/'"$PROJECT_NAME"'/' <<< "$DEPLOY_MESSAGE"`
123 |         export DEPLOY_MESSAGE=`sed 's/BRANCH_NAME/'"$BRANCH_NAME"'/' <<< "$DEPLOY_MESSAGE"`
124 | 
125 |         export OS=emscripten
126 |         export CC=emcc
127 | 
128 |         cd ..
129 |         export DEPLOY_BRANCH=`echo $DEPLOY_BRANCH | sed 's/PROJECT_NAME/'"$PROJECT_NAME"'/'`
130 |         export DEPLOY_BRANCH=`echo $DEPLOY_BRANCH | sed 's/BRANCH_NAME/'"$BRANCH_NAME"'/'`
131 |         export DEPLOY_BRANCH=`echo $DEPLOY_BRANCH | sed 's/OS/'"$OS"'/'`
132 |         export DEPLOY_BRANCH=`echo $DEPLOY_BRANCH | sed 's/COMPILER/'"$CC"'/'`
133 |         git clone https://$PUBLIC_REPO_TOKEN@github.com/$GITHUB_REPOSITORY-artifacts.git >/dev/null 2>&1
134 |         cd $PROJECT_NAME-artifacts
135 | 
136 |         git checkout $DEPLOY_BRANCH || git checkout --orphan $DEPLOY_BRANCH
137 |         git reset
138 |         git clean -f
139 |         git rm * || true
140 |         mv -f ../$PROJECT_NAME-build-${{ matrix.BuildType }}/*.tar.gz .
141 |         git add *.tar.gz
142 |         git commit --amend -m "$DEPLOY_MESSAGE" || git commit -m "$DEPLOY_MESSAGE"
143 |         git push --force || git push --set-upstream origin $DEPLOY_BRANCH
144 | 


--------------------------------------------------------------------------------
/src/gui/CanvasGuiSection.cpp:
--------------------------------------------------------------------------------
  1 | #include <ncine/imgui.h>
  2 | #include "gui/gui_labels.h"
  3 | #include "gui/gui_common.h"
  4 | #include "gui/CanvasGuiSection.h"
  5 | #include "Canvas.h"
  6 | 
  7 | namespace {
  8 | 
  9 | const char *ResizeStrings[7] = { "16x16", "32x32", "64x64", "128x128", "256x256", "512x512", "Custom" };
 10 | 
 11 | }
 12 | 
 13 | ///////////////////////////////////////////////////////////
 14 | // PUBLIC FUNCTIONS
 15 | ///////////////////////////////////////////////////////////
 16 | 
 17 | void CanvasGuiSection::create(Canvas &canvas)
 18 | {
 19 | 	ui::auxString.format("Zoom: %.2f", zoomAmount());
 20 | 	const ImVec2 closeItemSpacing(ImGui::GetStyle().ItemSpacing.x * 0.5f, ImGui::GetStyle().ItemSpacing.y * 0.5f);
 21 | 	ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, closeItemSpacing);
 22 | 	if (ImGui::Button(Labels::PlusIcon))
 23 | 		increaseZoom();
 24 | 	ImGui::SameLine();
 25 | 	if (ImGui::Button(Labels::MinusIcon))
 26 | 		decreaseZoom();
 27 | 	ImGui::PopStyleVar();
 28 | 
 29 | 	ImGui::SameLine();
 30 | 	if (ImGui::Button(ui::auxString.data()))
 31 | 		resetZoom();
 32 | 
 33 | 	ImGui::SameLine();
 34 | 	ImGui::ColorEdit4("Background", canvas.backgroundColor.data(), ImGuiColorEditFlags_AlphaBar | ImGuiColorEditFlags_NoInputs);
 35 | 	ImGui::SameLine();
 36 | 
 37 | 	int currentResizeCombo = static_cast<int>(resizePreset_);
 38 | 	ui::comboString.clear();
 39 | 	for (unsigned int i = 0; i < IM_ARRAYSIZE(ResizeStrings); i++)
 40 | 	{
 41 | 		ui::comboString.formatAppend("%s", ResizeStrings[i]);
 42 | 		if (ResizePreset(i) != ResizePreset::CUSTOM &&
 43 | 		    canvas.size().x == resizeVector(ResizePreset(i)).x &&
 44 | 		    canvas.size().y == resizeVector(ResizePreset(i)).y)
 45 | 		{
 46 | 			ui::comboString.formatAppend(" %s", Labels::SelectedIcon);
 47 | 		}
 48 | 		ui::comboString.setLength(ui::comboString.length() + 1);
 49 | 	}
 50 | 	ui::comboString.setLength(ui::comboString.length() + 1);
 51 | 	// Append a second '\0' to signal the end of the combo item list
 52 | 	ui::comboString[ui::comboString.length() - 1] = '\0';
 53 | 
 54 | 	ui::auxString.clear();
 55 | 	if (currentResizeCombo != static_cast<int>(ResizePreset::CUSTOM))
 56 | 		ui::auxString.append("Resize");
 57 | 	ui::auxString.append("##ResizeCombo");
 58 | 
 59 | 	ImGui::PushItemWidth(ImGui::GetFontSize() * 8.0f);
 60 | 	ImGui::Combo(ui::auxString.data(), &currentResizeCombo, ui::comboString.data());
 61 | 	ImGui::PopItemWidth();
 62 | 	resizePreset_ = static_cast<CanvasGuiSection::ResizePreset>(currentResizeCombo);
 63 | 	bool valueChanged = false;
 64 | 	if (currentResizeCombo == CanvasGuiSection::ResizePreset::CUSTOM)
 65 | 	{
 66 | 		ImGui::SameLine();
 67 | 		ImGui::PushItemWidth(ImGui::GetFontSize() * 6.5f);
 68 | 		ImGui::InputInt2("Resize", customCanvasSize_.data());
 69 | 		valueChanged = ImGui::IsItemDeactivatedAfterEdit();
 70 | 		ImGui::PopItemWidth();
 71 | 	}
 72 | 	else
 73 | 		customCanvasSize_ = canvas.size();
 74 | 
 75 | 	nc::Vector2i desiredCanvasSize = resizeVector();
 76 | 
 77 | 	if (desiredCanvasSize.x < 4)
 78 | 		desiredCanvasSize.x = 4;
 79 | 	else if (desiredCanvasSize.x > canvas.maxTextureSize())
 80 | 		desiredCanvasSize.x = canvas.maxTextureSize();
 81 | 	if (desiredCanvasSize.y < 4)
 82 | 		desiredCanvasSize.y = 4;
 83 | 	else if (desiredCanvasSize.y > canvas.maxTextureSize())
 84 | 		desiredCanvasSize.y = canvas.maxTextureSize();
 85 | 
 86 | 	if (valueChanged && (canvas.size().x != desiredCanvasSize.x || canvas.size().y != desiredCanvasSize.y))
 87 | 		canvas.resizeTexture(desiredCanvasSize);
 88 | 
 89 | 	ImGui::SameLine();
 90 | 	ImGui::Checkbox("Borders", &showBorders_);
 91 | 
 92 | 	ImGui::Separator();
 93 | }
 94 | 
 95 | void CanvasGuiSection::setResize(const nc::Vector2i &size)
 96 | {
 97 | 	setResize(size.x, size.y);
 98 | }
 99 | 
100 | void CanvasGuiSection::setResize(int width, int height)
101 | {
102 | 	customCanvasSize_.set(width, height);
103 | 	if (width == 16 && height == 16)
104 | 		resizePreset_ = ResizePreset::SIZE16;
105 | 	else if (width == 32 && height == 32)
106 | 		resizePreset_ = ResizePreset::SIZE32;
107 | 	else if (width == 64 && height == 64)
108 | 		resizePreset_ = ResizePreset::SIZE64;
109 | 	else if (width == 128 && height == 128)
110 | 		resizePreset_ = ResizePreset::SIZE128;
111 | 	else if (width == 256 && height == 256)
112 | 		resizePreset_ = ResizePreset::SIZE256;
113 | 	else if (width == 512 && height == 512)
114 | 		resizePreset_ = ResizePreset::SIZE512;
115 | 	else
116 | 		resizePreset_ = ResizePreset::CUSTOM;
117 | }
118 | 
119 | float CanvasGuiSection::zoomAmount() const
120 | {
121 | 	switch (zoomLevel_)
122 | 	{
123 | 		case ZoomLevel::X1_8:
124 | 			return 0.125f;
125 | 		case ZoomLevel::X1_4:
126 | 			return 0.25f;
127 | 		case ZoomLevel::X1_2:
128 | 			return 0.5f;
129 | 		case ZoomLevel::X1:
130 | 			return 1.0f;
131 | 		case ZoomLevel::X2:
132 | 			return 2.0f;
133 | 		case ZoomLevel::X4:
134 | 			return 4.0f;
135 | 		case ZoomLevel::X8:
136 | 			return 8.0f;
137 | 	}
138 | 	return 1.0f;
139 | }
140 | 
141 | void CanvasGuiSection::resetZoom()
142 | {
143 | 	zoomLevel_ = ZoomLevel::X1;
144 | }
145 | 
146 | void CanvasGuiSection::increaseZoom()
147 | {
148 | 	const unsigned int zoomIndex = static_cast<unsigned int>(zoomLevel_);
149 | 	if (zoomIndex < ZoomLevel::X8)
150 | 		zoomLevel_ = static_cast<ZoomLevel>(zoomIndex + 1);
151 | }
152 | 
153 | void CanvasGuiSection::decreaseZoom()
154 | {
155 | 	const unsigned int zoomIndex = static_cast<unsigned int>(zoomLevel_);
156 | 	if (zoomIndex > 0)
157 | 		zoomLevel_ = static_cast<ZoomLevel>(zoomIndex - 1);
158 | }
159 | 
160 | ///////////////////////////////////////////////////////////
161 | // PRIVATE FUNCTIONS
162 | ///////////////////////////////////////////////////////////
163 | 
164 | nc::Vector2i CanvasGuiSection::resizeVector(ResizePreset resizePreset)
165 | {
166 | 	switch (resizePreset)
167 | 	{
168 | 		case ResizePreset::SIZE16:
169 | 			return nc::Vector2i(16, 16);
170 | 		case ResizePreset::SIZE32:
171 | 			return nc::Vector2i(32, 32);
172 | 		case ResizePreset::SIZE64:
173 | 			return nc::Vector2i(64, 64);
174 | 		case ResizePreset::SIZE128:
175 | 			return nc::Vector2i(128, 128);
176 | 		case ResizePreset::SIZE256:
177 | 			return nc::Vector2i(256, 256);
178 | 		case ResizePreset::SIZE512:
179 | 			return nc::Vector2i(512, 512);
180 | 		case ResizePreset::CUSTOM:
181 | 			return customCanvasSize_;
182 | 	}
183 | 
184 | 	return customCanvasSize_;
185 | }
186 | 
187 | nc::Vector2i CanvasGuiSection::resizeVector()
188 | {
189 | 	return resizeVector(resizePreset_);
190 | }
191 | 


--------------------------------------------------------------------------------
/.github/workflows/windows.yml:
--------------------------------------------------------------------------------
  1 | name: 'Windows'
  2 | 
  3 | env:
  4 |   LIBRARIES_BRANCH: libraries-OS-COMPILER
  5 |   NCINE_SOURCE_BRANCH: BRANCH_NAME
  6 |   DEPLOY_MESSAGE:
  7 |     "Push artifact from GitHub Actions build ${{ github.run_number }} with id ${{ github.run_id }}
  8 | 
  9 |      - PROJECT_NAME artifact from branch 'BRANCH_NAME' with commit id ${{ github.sha }}"
 10 |   DEPLOY_BRANCH: PROJECT_NAME-BRANCH_NAME-OS-COMPILER
 11 |   IMGUI_VERSION_TAG: v1.92.5-docking
 12 | 
 13 | on: [push, workflow_dispatch]
 14 | 
 15 | jobs:
 16 |   Windows:
 17 |     strategy:
 18 |       fail-fast: false
 19 |       matrix:
 20 |         BuildType: [Debug, Release, BinDist]
 21 | 
 22 |     runs-on: 'windows-2022'
 23 | 
 24 |     steps:
 25 |     - name: 'Checkout Code'
 26 |       uses: actions/checkout@v4
 27 | 
 28 |     - name: 'Unshallow Git Repository for Versioning'
 29 |       if: matrix.BuildType == 'BinDist'
 30 |       run: |
 31 |         $env:GIT_REDIRECT_STDERR = '2>&1'
 32 |         git fetch --unshallow; if (-not $?) { return }
 33 | 
 34 |     - name: 'Download nCine-libraries and project data'
 35 |       run: |
 36 |         $env:GIT_REDIRECT_STDERR = '2>&1'
 37 | 
 38 |         cd ..
 39 |         git clone https://github.com/nCine/nCine-libraries-artifacts.git
 40 |         cd nCine-libraries-artifacts
 41 | 
 42 |         $env:LIBRARIES_BRANCH = $env:LIBRARIES_BRANCH -creplace "OS","windows" -creplace "COMPILER","vs2022"
 43 |         git checkout $env:LIBRARIES_BRANCH
 44 |         $env:LIBRARIES_FILE = Get-ChildItem -Path $(pwd) -Name -File | Select-Object -First 1
 45 |         7z x $env:LIBRARIES_FILE
 46 | 
 47 |         Move-Item -Path nCine-external -Destination ..
 48 | 
 49 |         cd ..
 50 |         Remove-Item nCine-libraries-artifacts -Recurse -Force
 51 | 
 52 |         git clone https://github.com/$env:GITHUB_REPOSITORY-data.git
 53 | 
 54 |     - name: 'Download nCine source and data'
 55 |       run: |
 56 |         $env:branch_name = git describe --tags --exact-match; if (-not $?) { $env:branch_name = git symbolic-ref -q --short HEAD }; if (-not $?) { $env:branch_name = git rev-parse --short HEAD }
 57 |         $env:NCINE_SOURCE_BRANCH = $env:NCINE_SOURCE_BRANCH -creplace "BRANCH_NAME","$env:branch_name"
 58 | 
 59 |         cd ..
 60 |         git clone https://github.com/nCine/nCine-data.git
 61 |         git clone https://github.com/nCine/nCine.git --branch $env:NCINE_SOURCE_BRANCH
 62 | 
 63 |     - name: 'CMake Configuration and Make of nCine as a static library'
 64 |       run: |
 65 |         cd ../nCine
 66 |         if ("${{ matrix.BuildType }}" -eq "BinDist")
 67 |           { $nCineBuildType = "Release" }
 68 |         else
 69 |           { $nCineBuildType = "${{ matrix.BuildType }}" }
 70 | 
 71 |         cmake -G "Visual Studio 17 2022" -A x64 -B ../nCine-build-$nCineBuildType -D CMAKE_BUILD_TYPE=$nCineBuildType -D NCINE_DYNAMIC_LIBRARY=OFF -D IMGUI_VERSION_TAG=$env:IMGUI_VERSION_TAG -D NCINE_PREFERRED_BACKEND=SDL2 -D NCINE_WITH_SCENEGRAPH=OFF -D NCINE_WITH_THREADS=OFF -D NCINE_WITH_WEBP=OFF -D NCINE_WITH_AUDIO=OFF -D NCINE_WITH_SCRIPTING_API=OFF -D NCINE_BUILD_TESTS=OFF
 72 | 
 73 |         cd ..
 74 |         cmake --build nCine-build-$nCineBuildType --config $nCineBuildType -j $env:NUMBER_OF_PROCESSORS
 75 | 
 76 |     - name: 'CMake Configuration'
 77 |       run: |
 78 |         $env:project_name = Split-Path -Path "$env:GITHUB_REPOSITORY" -leaf
 79 | 
 80 |         if ("${{ matrix.BuildType }}" -eq "BinDist")
 81 |           { cmake -G "Visual Studio 17 2022" -A x64 -B ../$env:project_name-build-${{ matrix.BuildType }} -D NCPROJECT_OPTIONS_PRESETS=${{ matrix.BuildType }} -D nCine_DIR=$(pwd)/../nCine-build-Release }
 82 |         else
 83 |           { cmake -G "Visual Studio 17 2022" -A x64 -B ../$env:project_name-build-${{ matrix.BuildType }} -D nCine_DIR=$(pwd)/../nCine-build-${{ matrix.BuildType }} }
 84 | 
 85 |     - name: 'CMake Build'
 86 |       run: |
 87 |         $env:project_name = Split-Path -Path "$env:GITHUB_REPOSITORY" -leaf
 88 | 
 89 |         if ("${{ matrix.BuildType }}" -eq "BinDist")
 90 |           { cmake --build ../$env:project_name-build-${{ matrix.BuildType }} --config Release -j $env:NUMBER_OF_PROCESSORS }
 91 |         else
 92 |           { cmake --build ../$env:project_name-build-${{ matrix.BuildType }} --config ${{ matrix.BuildType }} -j $env:NUMBER_OF_PROCESSORS }
 93 | 
 94 |     - name: 'Package'
 95 |       if: matrix.BuildType == 'BinDist'
 96 |       run: |
 97 |         $env:project_name = Split-Path -Path "$env:GITHUB_REPOSITORY" -leaf
 98 |         cmake --build ../$env:project_name-build-${{ matrix.BuildType }} --config Release --target package
 99 | 
100 |     - name: 'Push Artifacts'
101 |       if: matrix.BuildType == 'BinDist'
102 |       env:
103 |         PUBLIC_REPO_TOKEN: ${{ secrets.PUBLIC_REPO_TOKEN }}
104 |       run: |
105 |         git config --global user.email "actions@github.com"
106 |         git config --global user.name "GitHub Actions"
107 |         $env:GIT_REDIRECT_STDERR = '2>&1'
108 | 
109 |         $env:project_name = Split-Path -Path "$env:GITHUB_REPOSITORY" -leaf
110 |         $env:branch_name = git describe --tags --exact-match; if (-not $?) { $env:branch_name = git symbolic-ref -q --short HEAD }; if (-not $?) { $env:branch_name = git rev-parse --short HEAD }
111 |         $env:DEPLOY_MESSAGE = $env:DEPLOY_MESSAGE -creplace "PROJECT_NAME",$env:project_name
112 |         $env:DEPLOY_MESSAGE = $env:DEPLOY_MESSAGE -creplace "BRANCH_NAME",$env:branch_name
113 | 
114 |         $env:DEPLOY_BRANCH = $env:DEPLOY_BRANCH -creplace "PROJECT_NAME",$env:project_name
115 |         $env:DEPLOY_BRANCH = $env:DEPLOY_BRANCH -creplace "BRANCH_NAME",$env:branch_name
116 |         $env:DEPLOY_BRANCH = $env:DEPLOY_BRANCH -creplace "OS","windows" -creplace "COMPILER","vs2022"
117 | 
118 |         Write-Output $env:project_name
119 |         Write-Output $env:branch_name
120 |         Write-Output $env:DEPLOY_MESSAGE
121 |         Write-Output $env:DEPLOY_BRANCH
122 | 
123 |         cd ..
124 |         git clone https://$env:PUBLIC_REPO_TOKEN@github.com/$env:GITHUB_REPOSITORY-artifacts.git 2>&1>$null
125 |         cd $env:project_name-artifacts
126 |         git checkout $env:DEPLOY_BRANCH; if (-not $?) { git checkout --orphan $env:DEPLOY_BRANCH }
127 |         git reset
128 |         git clean -f
129 |         git rm *
130 | 
131 |         Move-Item -Path ..\$env:project_name-build-${{ matrix.BuildType }}\*.exe -Destination .
132 |         Move-Item -Path ..\$env:project_name-build-${{ matrix.BuildType }}\*.zip -Destination .
133 |         git add *.exe *.zip
134 | 
135 |         git commit --amend -m "$env:DEPLOY_MESSAGE"; if (-not $?) { git commit -m "$env:DEPLOY_MESSAGE" }
136 |         git push --force; if (-not $?) { git push --set-upstream origin $env:DEPLOY_BRANCH }
137 | 


--------------------------------------------------------------------------------
/include/gui/UserInterface.h:
--------------------------------------------------------------------------------
  1 | #ifndef CLASS_USERINTERFACE
  2 | #define CLASS_USERINTERFACE
  3 | 
  4 | #include <nctl/String.h>
  5 | #include <nctl/Array.h>
  6 | #include <ncine/Vector2.h>
  7 | #include <ncine/Colorf.h>
  8 | #include <ncine/TimeStamp.h>
  9 | 
 10 | #include "LuaSaver.h"
 11 | #include "gui/CanvasGuiSection.h"
 12 | #include "gui/RenderGuiWindow.h"
 13 | 
 14 | #ifdef __EMSCRIPTEN__
 15 | 	#include <ncine/EmscriptenLocalFile.h>
 16 | #endif
 17 | 
 18 | class Canvas;
 19 | class SpriteManager;
 20 | class AnimationManager;
 21 | class IAnimation;
 22 | class AnimationGroup;
 23 | class LoopComponent;
 24 | class CurveAnimation;
 25 | class PropertyAnimation;
 26 | class GridAnimation;
 27 | class ScriptAnimation;
 28 | class Texture;
 29 | class SpriteEntry;
 30 | class SpriteGroup;
 31 | class Sprite;
 32 | 
 33 | namespace nc = ncine;
 34 | 
 35 | /// The ImGui user interface class
 36 | class UserInterface
 37 | {
 38 |   public:
 39 | 	UserInterface();
 40 | 
 41 | 	void pushStatusInfoMessage(const char *message);
 42 | 	void pushStatusErrorMessage(const char *message);
 43 | 
 44 | 	const SaveAnim &saveAnimStatus() const;
 45 | 	bool shouldSaveFrames() const;
 46 | 	bool shouldSaveSpritesheet() const;
 47 | 	void signalFrameSaved();
 48 | 	void cancelRender();
 49 | 	void changeScalingFactor(float factor);
 50 | 	void openVideoModePopup();
 51 | 
 52 | 	void closeModalsAndUndockables();
 53 | 	void pressDeleteKey();
 54 | 	void moveSprite(int xDiff, int yDiff);
 55 | 	bool menuNewEnabled();
 56 | 	bool menuSaveEnabled();
 57 | 	bool menuSaveAsEnabled();
 58 | 	bool menuQuickOpenEnabled();
 59 | 	bool menuQuickSaveEnabled();
 60 | 	void menuNew();
 61 | 	void menuOpen();
 62 | 	void menuSave();
 63 | 	void menuSaveAs();
 64 | 	void menuQuickOpen();
 65 | 	void menuQuickSave();
 66 | 	void quit();
 67 | 	bool openDocumentationEnabled();
 68 | 	void openDocumentation();
 69 | 	void toggleAnimation();
 70 | 	void reloadScript();
 71 | 
 72 | 	void createGui();
 73 | 
 74 |   private:
 75 | 	static bool showConfigWindow;
 76 | 
 77 | 	enum class MouseStatus
 78 | 	{
 79 | 		IDLE,
 80 | 		CLICKED,
 81 | 		RELEASED,
 82 | 		DRAGGING
 83 | 	};
 84 | 
 85 | 	/// Used to keep track of which node can be parent of another node
 86 | 	struct SpriteStruct
 87 | 	{
 88 | 		SpriteStruct()
 89 | 		    : index(-1), sprite(nullptr) {}
 90 | 		SpriteStruct(int i, Sprite *sp)
 91 | 		    : index(i), sprite(sp) {}
 92 | 
 93 | 		int index;
 94 | 		Sprite *sprite;
 95 | 	};
 96 | 
 97 | 	struct CurveAnimationGuiLimits
 98 | 	{
 99 | 		float minScale = -1.0;
100 | 		float maxScale = 1.0f;
101 | 		float minShift = -1.0f;
102 | 		float maxShift = 1.0f;
103 | 	};
104 | 
105 | 	class SpriteProperties
106 | 	{
107 | 	  public:
108 | 		void save(Sprite &sprite);
109 | 		void restore(Sprite &sprite);
110 | 
111 | 	  private:
112 | 		bool saved_ = false;
113 | 		Sprite *parent_ = nullptr;
114 | 		nc::Vector2f position_ = nc::Vector2f(0.0f, 0.0f);
115 | 		float rotation_ = 0.0f;
116 | 		nc::Vector2f scaleFactor_ = nc::Vector2f(1.0f, 1.0f);
117 | 		nc::Vector2f anchorPoint_ = nc::Vector2f(1.0f, 1.0f);
118 | 		nc::Colorf color_ = nc::Colorf::White;
119 | 	};
120 | 	SpriteProperties spriteProps_;
121 | 	SpriteEntry *selectedSpriteEntry_;
122 | 	int selectedTextureIndex_;
123 | 	int selectedScriptIndex_;
124 | 	IAnimation *selectedAnimation_;
125 | 
126 | #ifdef WITH_FONTAWESOME
127 | 	/// Memory buffer for the FontAwesome icons font
128 | 	nctl::UniquePtr<uint8_t[]> fontFileBuffer_;
129 | #endif
130 | 
131 | 	/// Used to keep track of which node can be the parent of the selected one
132 | 	nctl::Array<SpriteStruct> spriteGraph_;
133 | 
134 | 	CanvasGuiSection canvasGuiSection_;
135 | 	RenderGuiWindow renderGuiWindow_;
136 | 	LuaSaver::Data saverData_;
137 | 
138 | #ifdef __EMSCRIPTEN__
139 | 	nc::EmscriptenLocalFile loadTextureLocalFile_;
140 | 	nc::EmscriptenLocalFile reloadTextureLocalFile_;
141 | #endif
142 | 
143 | 	nctl::String lastLoadedProject_ = nctl::String(ui::MaxStringLength);
144 | 	nctl::String lastQuickSavedProject_ = nctl::String(ui::MaxStringLength);
145 | 
146 | 	nctl::String statusMessage_ = nctl::String(ui::MaxStringLength);
147 | 	nc::TimeStamp lastStatus_;
148 | 
149 | 	nctl::UniquePtr<Texture> spookyLogo_;
150 | 	nctl::UniquePtr<Texture> ncineLogo_;
151 | 
152 | 	bool openProject(const char *filename);
153 | 	bool loadTexture(const char *filename);
154 | 	bool reloadTexture(const char *filename);
155 | 	bool loadScript(const char *filename);
156 | 
157 | #ifdef __EMSCRIPTEN__
158 | 	bool loadTexture(const char *bufferName, const char *bufferPtr, unsigned long int bufferSize);
159 | 	bool reloadTexture(const char *bufferName, const char *bufferPtr, unsigned long int bufferSize);
160 | #endif
161 | 	bool postLoadTexture(nctl::UniquePtr<Texture> &texture, const char *name);
162 | 
163 | 	void createDockingSpace();
164 | 	void createInitialDocking();
165 | 	void createMenuBar();
166 | 
167 | 	void createToolbarWindow();
168 | 	void recursiveRemoveSpriteWithTexture(SpriteGroup &group, Texture &tex);
169 | 	void removeTexture();
170 | 	void createTexturesWindow();
171 | 	void cloneSprite();
172 | 	void cloneSpriteGroup();
173 | 	void removeSprite();
174 | 	void recursiveRemoveSpriteGroup(SpriteGroup &group);
175 | 	void removeSpriteGroup();
176 | 	void createSpriteListEntry(SpriteEntry &entry, unsigned int index);
177 | 	void createSpritesWindow();
178 | 	void removeScript();
179 | 	void createScriptsWindow();
180 | 	void cloneAnimation(unsigned int &selectedIndex);
181 | 	void removeAnimation();
182 | 	void createAnimationListEntry(IAnimation &anim, unsigned int index, unsigned int &animId);
183 | 	void createAnimationsWindow();
184 | 
185 | 	void createSpriteWindow();
186 | 	void createAnimationWindow();
187 | 
188 | 	void createDelayAnimationGui(IAnimation &anim);
189 | 	void createLoopAnimationGui(LoopComponent &loop);
190 | 	void createOverrideSpriteGui(AnimationGroup &animGroup);
191 | 	void createCurveAnimationGui(CurveAnimation &anim, const CurveAnimationGuiLimits &limits);
192 | 	void createPropertyAnimationGui(PropertyAnimation &anim);
193 | 	void createGridAnimationGui(GridAnimation &anim);
194 | 	void createScriptAnimationGui(ScriptAnimation &anim);
195 | 
196 | 	void createFileDialog();
197 | 	void createCanvasWindow();
198 | 	void createTexRectWindow();
199 | 	void createConfigWindow();
200 | 	void createTipsWindow();
201 | 	void createAboutWindow();
202 | 	void createQuitPopup();
203 | 	void createVideoModePopup();
204 | 
205 | 	void applyDarkStyle();
206 | 	void mouseWheelCanvasZoom();
207 | 	void visitSprite(Sprite &sprite);
208 | 	void sanitizeConfigValues();
209 | 	void openFile(const char *filename);
210 | 
211 | 	void updateParentOnSpriteRemoval(Sprite *sprite);
212 | 	void updateSelectedAnimOnSpriteRemoval(Sprite *sprite);
213 | 
214 | 	friend class RenderGuiWindow;
215 | };
216 | 
217 | #endif
218 | 


--------------------------------------------------------------------------------
/src/SequentialAnimationGroup.cpp:
--------------------------------------------------------------------------------
  1 | #include "SequentialAnimationGroup.h"
  2 | 
  3 | ///////////////////////////////////////////////////////////
  4 | // PUBLIC FUNCTIONS
  5 | ///////////////////////////////////////////////////////////
  6 | 
  7 | nctl::UniquePtr<IAnimation> SequentialAnimationGroup::clone() const
  8 | {
  9 | 	nctl::UniquePtr<SequentialAnimationGroup> animGroup = nctl::makeUnique<SequentialAnimationGroup>();
 10 | 	AnimationGroup::cloneTo(*animGroup);
 11 | 
 12 | 	return nctl::move(animGroup);
 13 | }
 14 | 
 15 | void SequentialAnimationGroup::pause()
 16 | {
 17 | 	if (state_ != State::PLAYING)
 18 | 		return;
 19 | 
 20 | 	for (auto &&anim : anims_)
 21 | 	{
 22 | 		// The sequential group pauses the first and only playing animation
 23 | 		if (anim->state() == State::PLAYING)
 24 | 		{
 25 | 			anim->pause();
 26 | 			break;
 27 | 		}
 28 | 	}
 29 | 
 30 | 	state_ = State::PAUSED;
 31 | }
 32 | 
 33 | void SequentialAnimationGroup::play()
 34 | {
 35 | 	if (enabled == false)
 36 | 		return;
 37 | 
 38 | 	switch (state_)
 39 | 	{
 40 | 		case State::STOPPED:
 41 | 			if (anims_.isEmpty() == false)
 42 | 			{
 43 | 				// Stop all animations to get the initial state
 44 | 				stopAnimations();
 45 | 
 46 | 				if (loop_.direction() == Loop::Direction::FORWARD)
 47 | 				{
 48 | 					loop_.goForward(true);
 49 | 
 50 | 					// Find first enabled animation
 51 | 					unsigned int firstEnabled = 0;
 52 | 					while (firstEnabled < anims_.size() && anims_[firstEnabled]->enabled == false)
 53 | 						firstEnabled++;
 54 | 
 55 | 					if (firstEnabled < anims_.size())
 56 | 						anims_[firstEnabled]->play();
 57 | 				}
 58 | 				else
 59 | 				{
 60 | 					loop_.goForward(false);
 61 | 					if (shouldReverseAnimDirection())
 62 | 						reverseAnimDirection(*anims_.back());
 63 | 
 64 | 					// Find last enabled animation
 65 | 					int lastEnabled = anims_.size() - 1;
 66 | 					while (lastEnabled >= 0 && anims_[lastEnabled]->enabled == false)
 67 | 						lastEnabled--;
 68 | 
 69 | 					if (lastEnabled >= 0)
 70 | 						anims_[lastEnabled]->play();
 71 | 				}
 72 | 			}
 73 | 			break;
 74 | 		case State::PAUSED:
 75 | 			for (auto &&anim : anims_)
 76 | 			{
 77 | 				if (anim->state() == State::PAUSED)
 78 | 				{
 79 | 					anim->play();
 80 | 					break;
 81 | 				}
 82 | 			}
 83 | 			break;
 84 | 		case State::PLAYING:
 85 | 			break;
 86 | 	}
 87 | 
 88 | 	state_ = State::PLAYING;
 89 | }
 90 | 
 91 | void SequentialAnimationGroup::update(float deltaTime)
 92 | {
 93 | 	int playingIndex = -1;
 94 | 
 95 | 	if (state_ == IAnimation::State::PLAYING)
 96 | 	{
 97 | 		if (shouldWaitDelay(deltaTime) ||
 98 | 		    (insideSequential() == false && loop_.shouldWaitDelay(deltaTime)))
 99 | 		{
100 | 			return;
101 | 		}
102 | 		else
103 | 		{
104 | 			// Check if there is an animation currently in playing state
105 | 			for (unsigned int i = 0; i < anims_.size(); i++)
106 | 			{
107 | 				if (anims_[i]->state() == State::PLAYING)
108 | 				{
109 | 					playingIndex = i;
110 | 					break;
111 | 				}
112 | 			}
113 | 		}
114 | 	}
115 | 
116 | 	// Update all enabled animations anyway (always after checking if one is playing)
117 | 	for (unsigned int i = 0; i < anims_.size(); i++)
118 | 	{
119 | 		if (anims_[i]->enabled)
120 | 			anims_[i]->update(deltaTime);
121 | 		else if (anims_[i]->state() == IAnimation::State::PLAYING)
122 | 			anims_[i]->stop();
123 | 	}
124 | 
125 | 	if (playingIndex > -1 && state_ == IAnimation::State::PLAYING)
126 | 	{
127 | 		// Decide the next animation to play if the last playing one has just finished
128 | 		if (anims_[playingIndex]->state() == State::STOPPED)
129 | 		{
130 | 			const Loop::Mode loopMode = loop_.mode();
131 | 			// Disable looping if the animation is inside a sequential group
132 | 			if (insideSequential())
133 | 				loop_.setMode(Loop::Mode::DISABLED);
134 | 
135 | 			if (shouldReverseAnimDirection())
136 | 				reverseAnimDirection(*anims_[playingIndex]);
137 | 
138 | 			playingIndex = nextPlayingIndex(playingIndex);
139 | 
140 | 			loop_.setMode(loopMode);
141 | 
142 | 			// The last animation finished and looping is disabled
143 | 			if (playingIndex < 0 || playingIndex > anims_.size() - 1)
144 | 			{
145 | 				resetDelay();
146 | 				loop_.resetDelay();
147 | 				state_ = State::STOPPED;
148 | 			}
149 | 			else if (anims_[playingIndex]->state() != State::PLAYING)
150 | 			{
151 | 				if (shouldReverseAnimDirection())
152 | 					reverseAnimDirection(*anims_[playingIndex]);
153 | 
154 | 				anims_[playingIndex]->play();
155 | 			}
156 | 		}
157 | 	}
158 | }
159 | 
160 | ///////////////////////////////////////////////////////////
161 | // PRIVATE FUNCTIONS
162 | ///////////////////////////////////////////////////////////
163 | 
164 | int SequentialAnimationGroup::nextPlayingIndex(int playingIndex)
165 | {
166 | 	// Search the index of the first animation that is enabled
167 | 	int firstEnabled = -1;
168 | 	for (unsigned int i = 0; i < anims_.size(); i++)
169 | 	{
170 | 		if (anims_[i]->enabled)
171 | 		{
172 | 			firstEnabled = i;
173 | 			break;
174 | 		}
175 | 	}
176 | 
177 | 	// Return an invalid index if there are no enabled animations in the group
178 | 	if (firstEnabled < 0)
179 | 		return -1;
180 | 
181 | 	// Search the index of the last animation that is enabled
182 | 	int lastEnabled = anims_.size() - 1;
183 | 	for (int i = anims_.size() - 1; i >= 0; i--)
184 | 	{
185 | 		if (anims_[i]->enabled)
186 | 		{
187 | 			lastEnabled = i;
188 | 			break;
189 | 		}
190 | 	}
191 | 
192 | 	do
193 | 	{
194 | 		switch (loop_.mode())
195 | 		{
196 | 			case Loop::Mode::DISABLED:
197 | 				playingIndex += (loop_.direction() == Loop::Direction::FORWARD) ? 1 : -1;
198 | 				break;
199 | 			case Loop::Mode::REWIND:
200 | 				playingIndex += (loop_.direction() == Loop::Direction::FORWARD) ? 1 : -1;
201 | 				if (playingIndex > lastEnabled)
202 | 				{
203 | 					playingIndex = firstEnabled;
204 | 					// Stop all animations to get the initial state
205 | 					stopAnimations();
206 | 					loop_.justResetNow();
207 | 				}
208 | 				else if (playingIndex < firstEnabled)
209 | 				{
210 | 					playingIndex = lastEnabled;
211 | 					// Stop all animations to get the initial state
212 | 					stopAnimations();
213 | 					loop_.justResetNow();
214 | 				}
215 | 				break;
216 | 			case Loop::Mode::PING_PONG:
217 | 				if (loop_.isGoingForward())
218 | 				{
219 | 					playingIndex++;
220 | 					if (playingIndex > lastEnabled)
221 | 					{
222 | 						// Playing again the last animation but reverted
223 | 						playingIndex = lastEnabled;
224 | 						loop_.justResetNow();
225 | 						loop_.toggleForward();
226 | 					}
227 | 				}
228 | 				else
229 | 				{
230 | 					playingIndex--;
231 | 					if (playingIndex < firstEnabled)
232 | 					{
233 | 						// Playing again the first animation but reverted
234 | 						playingIndex = firstEnabled;
235 | 						loop_.justResetNow();
236 | 						loop_.toggleForward();
237 | 					}
238 | 				}
239 | 				break;
240 | 		}
241 | 	} while (playingIndex >=0 && playingIndex < anims_.size() && anims_[playingIndex]->enabled == false);
242 | 
243 | 	return playingIndex;
244 | }
245 | 


--------------------------------------------------------------------------------
/src/LuaSaver.cpp:
--------------------------------------------------------------------------------
  1 | #include <ncine/FileSystem.h>
  2 | 
  3 | #include "LuaSaver.h"
  4 | #include "SpriteEntry.h"
  5 | #include "SpriteManager.h"
  6 | #include "Texture.h"
  7 | #include "ScriptManager.h"
  8 | #include "AnimationManager.h"
  9 | #include "GridFunctionLibrary.h"
 10 | #include "Configuration.h"
 11 | 
 12 | #include "Serializers.h"
 13 | #include "LuaSerializer.h"
 14 | #include "SerializerContext.h"
 15 | 
 16 | namespace {
 17 | 
 18 | const int ProjectVersion = 7;
 19 | 
 20 | }
 21 | 
 22 | ///////////////////////////////////////////////////////////
 23 | // STATIC DEFINITIONS
 24 | ///////////////////////////////////////////////////////////
 25 | 
 26 | nctl::String LuaSaver::defaultCfgFile_(256);
 27 | 
 28 | ///////////////////////////////////////////////////////////
 29 | // CONSTRUCTORS and DESTRUCTOR
 30 | ///////////////////////////////////////////////////////////
 31 | 
 32 | LuaSaver::LuaSaver(unsigned int bufferSize)
 33 | {
 34 | 	serializer_ = nctl::makeUnique<LuaSerializer>(bufferSize);
 35 | }
 36 | 
 37 | ///////////////////////////////////////////////////////////
 38 | // PUBLIC FUNCTIONS
 39 | ///////////////////////////////////////////////////////////
 40 | 
 41 | bool LuaSaver::load(const char *filename, Data &data)
 42 | {
 43 | 	DeserializerContext context;
 44 | 	serializer_->setContext(&context);
 45 | 	context.textures = &data.spriteMgr.textures();
 46 | 	nctl::Array<nctl::UniquePtr<SpriteEntry>> spriteEntries;
 47 | 	context.spriteEntries = &spriteEntries;
 48 | 	context.scripts = &data.scriptMgr.scripts();
 49 | 	nctl::Array<nctl::UniquePtr<IAnimation>> anims;
 50 | 	context.animations = &anims;
 51 | 
 52 | 	const unsigned int numFunctions = GridFunctionLibrary::gridFunctions().size();
 53 | 	nctl::HashMap<const char *, const GridFunction *> functionHash(numFunctions * 2);
 54 | 	context.functionHash = &functionHash;
 55 | 	for (unsigned int i = 0; i < numFunctions; i++)
 56 | 	{
 57 | 		const GridFunction &function = GridFunctionLibrary::gridFunctions()[i];
 58 | 		functionHash.insert(function.name().data(), &function);
 59 | 	}
 60 | 
 61 | 	if (serializer_->load(filename) == false)
 62 | 		return false;
 63 | 
 64 | 	data.spriteMgr.clear();
 65 | 	data.scriptMgr.clear();
 66 | 	data.animMgr.clear();
 67 | 
 68 | 	Deserializers::deserializeGlobal(*serializer_, "version", context.version);
 69 | 	ASSERT(context.version >= 1);
 70 | 	Deserializers::deserialize(*serializer_, "canvas", data.canvas);
 71 | 	Deserializers::deserialize(*serializer_, "textures", *context.textures);
 72 | 
 73 | 	nctl::String spriteTableName = "sprites";
 74 | 	if (context.version >= 7)
 75 | 		spriteTableName = "sprite_entries";
 76 | 
 77 | 	// Deserialize all sprites in an array that can be used by the animations
 78 | 	Deserializers::deserialize(*serializer_, spriteTableName.data(), *context.spriteEntries);
 79 | 
 80 | 	if (context.version >= 2)
 81 | 		Deserializers::deserialize(*serializer_, "scripts", *context.scripts);
 82 | 
 83 | 	Deserializers::deserialize(*serializer_, "animations", *context.animations);
 84 | 	if (data.animMgr.anims().capacity() < anims.size())
 85 | 		data.animMgr.anims().setCapacity(anims.size());
 86 | 	for (unsigned int i = 0; i < anims.size(); i++)
 87 | 		anims[i]->parent()->anims().pushBack(nctl::move(anims[i]));
 88 | 
 89 | 	// Stop all animations to get the initial state
 90 | 	data.animMgr.animGroup().stop();
 91 | 
 92 | 	// After the animations have been deserialized, the array of sprite entries can be moved to the sprite manager
 93 | 	if (data.spriteMgr.children().capacity() < spriteEntries.size())
 94 | 		data.spriteMgr.children().setCapacity(spriteEntries.size());
 95 | 	for (unsigned int i = 0; i < spriteEntries.size(); i++)
 96 | 		spriteEntries[i]->parentGroup()->children().pushBack(nctl::move(spriteEntries[i]));
 97 | 	data.spriteMgr.updateSpritesArray();
 98 | 
 99 | 	return true;
100 | }
101 | 
102 | void visitSpriteEntries(const SpriteEntry *spriteEntry, nctl::Array<const SpriteEntry *> &spriteEntries)
103 | {
104 | 	spriteEntries.pushBack(spriteEntry);
105 | 
106 | 	if (spriteEntry->isGroup())
107 | 	{
108 | 		const SpriteGroup *spriteGroup = spriteEntry->toGroup();
109 | 		for (unsigned int i = 0; i < spriteGroup->children().size(); i++)
110 | 			visitSpriteEntries(spriteGroup->children()[i].get(), spriteEntries);
111 | 	}
112 | }
113 | 
114 | void visitAnimations(const IAnimation *anim, nctl::Array<const IAnimation *> &anims)
115 | {
116 | 	anims.pushBack(anim);
117 | 
118 | 	if (anim->type() == IAnimation::Type::PARALLEL_GROUP ||
119 | 	    anim->type() == IAnimation::Type::SEQUENTIAL_GROUP)
120 | 	{
121 | 		const AnimationGroup *animGroup = static_cast<const AnimationGroup *>(anim);
122 | 		for (unsigned int i = 0; i < animGroup->anims().size(); i++)
123 | 			visitAnimations(animGroup->anims()[i].get(), anims);
124 | 	}
125 | }
126 | 
127 | void LuaSaver::save(const char *filename, const Data &data)
128 | {
129 | 	SerializerContext context;
130 | 	serializer_->setContext(&context);
131 | 
132 | 	serializer_->reset();
133 | 
134 | 	Serializers::serializeGlobal(*serializer_, "version", ProjectVersion);
135 | 	serializer_->buffer().append("\n");
136 | 	Serializers::serialize(*serializer_, "canvas", data.canvas);
137 | 
138 | 	const unsigned int numTextures = data.spriteMgr.textures().size();
139 | 	if (numTextures > 0)
140 | 	{
141 | 		serializer_->buffer().append("\n");
142 | 		context.textureHash = nctl::makeUnique<nctl::HashMap<const Texture *, unsigned int>>(numTextures * 2);
143 | 
144 | 		for (unsigned int i = 0; i < numTextures; i++)
145 | 			context.textureHash->insert(data.spriteMgr.textures()[i].get(), i);
146 | 
147 | 		Serializers::serialize(*serializer_, "textures", data.spriteMgr.textures());
148 | 
149 | 		nctl::Array<const SpriteEntry *> spriteEntries;
150 | 		for (unsigned int i = 0; i < data.spriteMgr.children().size(); i++)
151 | 			visitSpriteEntries(data.spriteMgr.children()[i].get(), spriteEntries);
152 | 
153 | 		const unsigned int numSpriteEntries = spriteEntries.size();
154 | 		if (numSpriteEntries > 0)
155 | 		{
156 | 			serializer_->buffer().append("\n");
157 | 			context.spriteEntryHash = nctl::makeUnique<nctl::HashMap<const SpriteEntry *, unsigned int>>(numSpriteEntries * 2);
158 | 			for (unsigned int i = 0; i < numSpriteEntries; i++)
159 | 				context.spriteEntryHash->insert(spriteEntries[i], i);
160 | 
161 | 			Serializers::serialize(*serializer_, "sprite_entries", spriteEntries);
162 | 		}
163 | 	}
164 | 
165 | 	const unsigned int numScripts = data.scriptMgr.scripts().size();
166 | 	if (numScripts > 0)
167 | 	{
168 | 		serializer_->buffer().append("\n");
169 | 		context.scriptHash = nctl::makeUnique<nctl::HashMap<const Script *, unsigned int>>(numScripts * 2);
170 | 
171 | 		for (unsigned int i = 0; i < numScripts; i++)
172 | 			context.scriptHash->insert(data.scriptMgr.scripts()[i].get(), i);
173 | 
174 | 		Serializers::serialize(*serializer_, "scripts", data.scriptMgr.scripts());
175 | 	}
176 | 
177 | 	nctl::Array<const IAnimation *> anims;
178 | 	for (unsigned int i = 0; i < data.animMgr.anims().size(); i++)
179 | 		visitAnimations(data.animMgr.anims()[i].get(), anims);
180 | 
181 | 	const unsigned int numAnims = anims.size();
182 | 	if (numAnims > 0)
183 | 	{
184 | 		serializer_->buffer().append("\n");
185 | 		context.animationHash = nctl::makeUnique<nctl::HashMap<const IAnimation *, unsigned int>>(numAnims * 2);
186 | 		for (unsigned int i = 0; i < numAnims; i++)
187 | 			context.animationHash->insert(anims[i], i);
188 | 
189 | 		Serializers::serialize(*serializer_, "animations", anims);
190 | 	}
191 | 
192 | 	serializer_->save(filename);
193 | }
194 | 
195 | bool LuaSaver::loadCfg(const char *filename, Configuration &cfg)
196 | {
197 | 	if (serializer_->load(filename) == false)
198 | 		return false;
199 | 
200 | 	Deserializers::deserialize(*serializer_, cfg);
201 | 
202 | 	return true;
203 | }
204 | 
205 | void LuaSaver::saveCfg(const char *filename, const Configuration &cfg)
206 | {
207 | 	serializer_->reset();
208 | 	Serializers::serialize(*serializer_, cfg);
209 | 	serializer_->save(filename);
210 | }
211 | 


--------------------------------------------------------------------------------
/.github/workflows/linux.yml:
--------------------------------------------------------------------------------
  1 | name: 'Linux'
  2 | 
  3 | env:
  4 |   LIBRARIES_BRANCH: libraries-OS-COMPILER
  5 |   NCINE_SOURCE_BRANCH: BRANCH_NAME
  6 |   DEPLOY_MESSAGE:
  7 |     "Push artifact from GitHub Actions build ${{ github.run_number }} with id ${{ github.run_id }}
  8 | 
  9 |      - PROJECT_NAME artifact from branch 'BRANCH_NAME' with commit id ${{ github.sha }}"
 10 |   DEPLOY_BRANCH: PROJECT_NAME-BRANCH_NAME-OS-COMPILER
 11 |   IMGUI_VERSION_TAG: v1.92.5-docking
 12 | 
 13 | on: [push, workflow_dispatch]
 14 | 
 15 | jobs:
 16 |   Linux:
 17 |     strategy:
 18 |       fail-fast: false
 19 |       matrix:
 20 |         include:
 21 |         - BuildType: Debug
 22 |           CC: gcc
 23 |           CXX: g++
 24 | 
 25 |         - BuildType: Release
 26 |           CC: gcc
 27 |           CXX: g++
 28 | 
 29 |         - BuildType: BinDist
 30 |           CC: gcc
 31 |           CXX: g++
 32 | 
 33 |         - BuildType: Debug
 34 |           CC: clang
 35 |           CXX: clang++
 36 | 
 37 |         - BuildType: Release
 38 |           CC: clang
 39 |           CXX: clang++
 40 | 
 41 |         - BuildType: BinDist
 42 |           CC: clang
 43 |           CXX: clang++
 44 | 
 45 |     runs-on: 'ubuntu-24.04'
 46 | 
 47 |     steps:
 48 |     - name: 'Checkout Code'
 49 |       uses: actions/checkout@v4
 50 | 
 51 |     - name: 'Install nCine Build Dependencies'
 52 |       run: |
 53 |         sudo apt-get update
 54 |         sudo apt-get install -y libgl-dev libxext-dev libxrandr-dev libwayland-dev
 55 | 
 56 |     - name: 'Unshallow Git Repository for Versioning'
 57 |       if: matrix.BuildType == 'BinDist'
 58 |       run: |
 59 |         git fetch --unshallow || true
 60 | 
 61 |     - name: 'Download nCine-libraries and project data'
 62 |       run: |
 63 |         export OS=linux
 64 |         export CC=${{ matrix.CC }}
 65 | 
 66 |         export LIBRARIES_BRANCH=`echo $LIBRARIES_BRANCH | sed 's/OS/'"$OS"'/'`
 67 |         export LIBRARIES_BRANCH=`echo $LIBRARIES_BRANCH | sed 's/COMPILER/'"$CC"'/'`
 68 | 
 69 |         cd ..
 70 |         git clone https://github.com/nCine/nCine-libraries-artifacts.git
 71 |         cd nCine-libraries-artifacts
 72 |         git checkout $LIBRARIES_BRANCH
 73 |         LIBRARIES_FILE=$(ls -t | head -n 1) && tar xpzf $LIBRARIES_FILE
 74 |         mv nCine-external ..
 75 |         cd ..
 76 |         rm -rf nCine-libraries-artifacts
 77 | 
 78 |         git clone https://github.com/$GITHUB_REPOSITORY-data.git
 79 | 
 80 |     - name: 'Download nCine source and data'
 81 |       run: |
 82 |         export BRANCH_NAME=$(git describe --tags --exact-match 2> /dev/null || git symbolic-ref -q --short HEAD || git rev-parse --short HEAD)
 83 |         export NCINE_SOURCE_BRANCH=`echo $NCINE_SOURCE_BRANCH | sed 's/BRANCH_NAME/'"$BRANCH_NAME"'/'`
 84 | 
 85 |         cd ..
 86 |         git clone https://github.com/nCine/nCine-data.git
 87 |         git clone https://github.com/nCine/nCine.git --branch $NCINE_SOURCE_BRANCH
 88 | 
 89 |     - name: 'CMake Configuration and Make of nCine as a static library'
 90 |       run: |
 91 |         cd ../nCine
 92 |         if [[ "${{ matrix.BuildType }}" == "BinDist" ]]; then
 93 |           export NCINE_BUILD_TYPE=Release
 94 |         else
 95 |           export NCINE_BUILD_TYPE=${{ matrix.BuildType }}
 96 |         fi
 97 |         export CMAKE_ARGS="-B ../nCine-build-$NCINE_BUILD_TYPE -D CMAKE_BUILD_TYPE=$NCINE_BUILD_TYPE -D NCINE_DYNAMIC_LIBRARY=OFF -D IMGUI_VERSION_TAG=$IMGUI_VERSION_TAG -D NCINE_PREFERRED_BACKEND=SDL2 -D NCINE_WITH_SCENEGRAPH=OFF -D NCINE_WITH_THREADS=OFF -D NCINE_WITH_WEBP=OFF -D NCINE_WITH_AUDIO=OFF -D NCINE_WITH_SCRIPTING_API=OFF -D NCINE_BUILD_TESTS=OFF"
 98 | 
 99 |         export CC= ${{ matrix.CC }}
100 |         export CXX=${{ matrix.CXX }}
101 |         export CMAKE_ARGS="$CMAKE_ARGS -D CMAKE_PREFIX_PATH=$(pwd)/../nCine-external"
102 | 
103 |         cmake $CMAKE_ARGS
104 |         cd ..
105 |         make -j $(getconf _NPROCESSORS_ONLN) -C nCine-build-$NCINE_BUILD_TYPE
106 | 
107 |     - name: 'CMake Configuration'
108 |       run: |
109 |         export PROJECT_NAME=${GITHUB_REPOSITORY##*/}
110 | 
111 |         export CMAKE_ARGS="-B ../$PROJECT_NAME-build-${{ matrix.BuildType }}"
112 | 
113 |         export CC= ${{ matrix.CC }}
114 |         export CXX=${{ matrix.CXX }}
115 |         export CMAKE_ARGS="$CMAKE_ARGS -D CMAKE_PREFIX_PATH=$(pwd)/../nCine-external"
116 | 
117 |         if [[ "${{ matrix.BuildType }}" == "BinDist" ]]; then
118 |           cmake $CMAKE_ARGS -D NCPROJECT_OPTIONS_PRESETS=${{ matrix.BuildType }} -D CMAKE_INSTALL_PREFIX="" -D nCine_DIR=$(pwd)/../nCine-build-Release
119 |         else
120 |           cmake $CMAKE_ARGS -D CMAKE_BUILD_TYPE=${{ matrix.BuildType }} -D nCine_DIR=$(pwd)/../nCine-build-${{ matrix.BuildType }}
121 |         fi
122 | 
123 |     - name: 'Make'
124 |       run: |
125 |         export PROJECT_NAME=${GITHUB_REPOSITORY##*/}
126 | 
127 |         export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$(pwd)/../nCine-external/lib
128 |         make -j $(getconf _NPROCESSORS_ONLN) -C ../$PROJECT_NAME-build-${{ matrix.BuildType }}
129 | 
130 |     - name: 'Package'
131 |       if: matrix.BuildType == 'BinDist'
132 |       run: |
133 |         export PROJECT_NAME=${GITHUB_REPOSITORY##*/}
134 |         make package -C ../$PROJECT_NAME-build-${{ matrix.BuildType }}
135 | 
136 |     - name: 'Generate and Push Documentation'
137 |       if: matrix.BuildType == 'BinDist' && matrix.CC == 'gcc'
138 |       env:
139 |         PUBLIC_REPO_TOKEN: ${{ secrets.PUBLIC_REPO_TOKEN }}
140 |       run: |
141 |         git config --global user.email "actions@github.com"
142 |         git config --global user.name "GitHub Actions"
143 | 
144 |         cd ../SpookyGhost-data/docs
145 |         export GEM_HOME=~/.gem
146 |         export GEM_PATH=~/.gem
147 |         gem install asciidoctor
148 |         export PATH=$GEM_HOME/bin:$PATH
149 |         asciidoctor documentation.adoc
150 | 
151 |         cd ../..
152 |         git clone https://$PUBLIC_REPO_TOKEN@github.com/SpookyGhost2D/docs.git >/dev/null 2>&1
153 |         cd docs
154 |         git rm -r . >/dev/null 2>&1
155 |         cp -p ../SpookyGhost-data/docs/* .
156 |         rm documentation.adoc
157 |         mv documentation.html index.html
158 |         git add .
159 | 
160 |         git commit --amend -m "Initial commit" || git commit -m "Initial commit"
161 |         git push --force || git push --set-upstream origin master
162 | 
163 |     - name: 'Push Artifacts'
164 |       if: matrix.BuildType == 'BinDist'
165 |       env:
166 |         PUBLIC_REPO_TOKEN: ${{ secrets.PUBLIC_REPO_TOKEN }}
167 |       run: |
168 |         git config --global user.email "actions@github.com"
169 |         git config --global user.name "GitHub Actions"
170 | 
171 |         export PROJECT_NAME=${GITHUB_REPOSITORY##*/}
172 |         export BRANCH_NAME=$(git describe --tags --exact-match 2> /dev/null || git symbolic-ref -q --short HEAD || git rev-parse --short HEAD)
173 |         export DEPLOY_MESSAGE=`sed 's/PROJECT_NAME/'"$PROJECT_NAME"'/' <<< "$DEPLOY_MESSAGE"`
174 |         export DEPLOY_MESSAGE=`sed 's/BRANCH_NAME/'"$BRANCH_NAME"'/' <<< "$DEPLOY_MESSAGE"`
175 | 
176 |         export OS=linux
177 |         export CC=${{ matrix.CC }}
178 |         export PROJECT_EXT=tar.gz
179 | 
180 |         cd ..
181 |         export DEPLOY_BRANCH=`echo $DEPLOY_BRANCH | sed 's/PROJECT_NAME/'"$PROJECT_NAME"'/'`
182 |         export DEPLOY_BRANCH=`echo $DEPLOY_BRANCH | sed 's/BRANCH_NAME/'"$BRANCH_NAME"'/'`
183 |         export DEPLOY_BRANCH=`echo $DEPLOY_BRANCH | sed 's/OS/'"$OS"'/'`
184 |         export DEPLOY_BRANCH=`echo $DEPLOY_BRANCH | sed 's/COMPILER/'"$CC"'/'`
185 |         git clone https://$PUBLIC_REPO_TOKEN@github.com/$GITHUB_REPOSITORY-artifacts.git >/dev/null 2>&1
186 |         cd $PROJECT_NAME-artifacts
187 | 
188 |         git checkout $DEPLOY_BRANCH || git checkout --orphan $DEPLOY_BRANCH
189 |         git reset
190 |         git clean -f
191 |         git rm * || true
192 |         mv -f ../$PROJECT_NAME-build-${{ matrix.BuildType }}/*.$PROJECT_EXT .
193 |         git add *.$PROJECT_EXT
194 |         git commit --amend -m "$DEPLOY_MESSAGE" || git commit -m "$DEPLOY_MESSAGE"
195 |         git push --force || git push --set-upstream origin $DEPLOY_BRANCH
196 | 


--------------------------------------------------------------------------------
/.github/workflows/mingw.yml:
--------------------------------------------------------------------------------
  1 | name: 'MinGW'
  2 | 
  3 | env:
  4 |   LIBRARIES_BRANCH: libraries-OS-COMPILER
  5 |   NCINE_SOURCE_BRANCH: BRANCH_NAME
  6 |   DEPLOY_MESSAGE:
  7 |     "Push artifact from GitHub Actions build ${{ github.run_number }} with id ${{ github.run_id }}
  8 | 
  9 |      - PROJECT_NAME artifact from branch 'BRANCH_NAME' with commit id ${{ github.sha }}"
 10 |   DEPLOY_BRANCH: PROJECT_NAME-BRANCH_NAME-OS-COMPILER
 11 |   IMGUI_VERSION_TAG: v1.92.5-docking
 12 | 
 13 | on: [push, workflow_dispatch]
 14 | 
 15 | jobs:
 16 |   MinGW:
 17 |     strategy:
 18 |       fail-fast: false
 19 |       matrix:
 20 |         include:
 21 |         - BuildType: Debug
 22 |           CC: gcc
 23 |           CXX: g++
 24 | 
 25 |         - BuildType: Release
 26 |           CC: gcc
 27 |           CXX: g++
 28 | 
 29 |         - BuildType: BinDist
 30 |           CC: gcc
 31 |           CXX: g++
 32 | 
 33 |         - BuildType: Debug
 34 |           CC: clang
 35 |           CXX: clang++
 36 | 
 37 |         - BuildType: Release
 38 |           CC: clang
 39 |           CXX: clang++
 40 | 
 41 |         - BuildType: BinDist
 42 |           CC: clang
 43 |           CXX: clang++
 44 | 
 45 |     runs-on: 'windows-2022'
 46 | 
 47 |     steps:
 48 |     - name: 'Checkout Code'
 49 |       uses: actions/checkout@v4
 50 | 
 51 |     - name: 'Update MSYS2'
 52 |       run: |
 53 |         $env:MSYSTEM = "MINGW64"
 54 | 
 55 |         C:\msys64\usr\bin\bash -lc 'pacman --noconfirm -Syyuu'
 56 |         C:\msys64\usr\bin\bash -lc 'pacman --noconfirm -Syyuu'
 57 | 
 58 |     - name: 'Install Build Dependencies'
 59 |       run: |
 60 |         $env:MSYSTEM = "MINGW64"
 61 | 
 62 |         C:\msys64\usr\bin\bash -lc 'pacman --needed --noconfirm -S mingw-w64-x86_64-glew mingw-w64-x86_64-glfw mingw-w64-x86_64-SDL2 mingw-w64-x86_64-openal mingw-w64-x86_64-libvorbis mingw-w64-x86_64-libwebp mingw-w64-x86_64-lua mingw-w64-x86_64-cmake make patch'
 63 | 
 64 |         if ("${{ matrix.CC }}" -eq "gcc") { C:\msys64\usr\bin\bash -lc 'pacman --needed --noconfirm -S mingw-w64-x86_64-gcc' }
 65 |         else { C:\msys64\usr\bin\bash -lc 'pacman --needed --noconfirm -S mingw-w64-x86_64-clang' }
 66 | 
 67 |         C:\msys64\usr\bin\bash -lc 'pacman --noconfirm -Scc'
 68 | 
 69 |     - name: 'Unshallow Git Repository for Versioning'
 70 |       if: matrix.BuildType == 'BinDist'
 71 |       run: |
 72 |         $env:GIT_REDIRECT_STDERR = '2>&1'
 73 |         git fetch --unshallow; if (-not $?) { return }
 74 | 
 75 |     - name: 'Download nCine-libraries and project data'
 76 |       run: |
 77 |         $env:GIT_REDIRECT_STDERR = '2>&1'
 78 | 
 79 |         $env:CC = "${{ matrix.CC }}"
 80 | 
 81 |         cd ..
 82 |         git clone https://github.com/nCine/nCine-libraries-artifacts.git
 83 |         cd nCine-libraries-artifacts
 84 | 
 85 |         cd ..
 86 |         Remove-Item nCine-libraries-artifacts -Recurse -Force
 87 | 
 88 |         git clone https://github.com/$env:GITHUB_REPOSITORY-data.git
 89 | 
 90 |     - name: 'Download nCine source and data'
 91 |       run: |
 92 |         $env:branch_name = git describe --tags --exact-match; if (-not $?) { $env:branch_name = git symbolic-ref -q --short HEAD }; if (-not $?) { $env:branch_name = git rev-parse --short HEAD }
 93 |         $env:NCINE_SOURCE_BRANCH = $env:NCINE_SOURCE_BRANCH -creplace "BRANCH_NAME","$env:branch_name"
 94 | 
 95 |         cd ..
 96 |         git clone https://github.com/nCine/nCine-data.git
 97 |         git clone https://github.com/nCine/nCine.git --branch $env:NCINE_SOURCE_BRANCH
 98 | 
 99 |     - name: 'CMake Configuration and Make of nCine as a static library'
100 |       env:
101 |         CHERE_INVOKING: on
102 |       run: |
103 |         $env:CC= "${{ matrix.CC }}"
104 |         $env:CXX = "${{ matrix.CXX }}"
105 |         $env:MSYSTEM = "MINGW64"
106 | 
107 |         cd ../nCine
108 |         if ("${{ matrix.BuildType }}" -eq "BinDist")
109 |         {
110 |           C:\msys64\usr\bin\bash.exe -lc "cmake -G 'MSYS Makefiles' -B ../nCine-build-Release -D CMAKE_BUILD_TYPE=Release -D NCINE_DYNAMIC_LIBRARY=OFF -D IMGUI_VERSION_TAG=$env:IMGUI_VERSION_TAG -D NCINE_PREFERRED_BACKEND=SDL2 -D NCINE_WITH_SCENEGRAPH=OFF -D NCINE_WITH_THREADS=OFF -D NCINE_WITH_WEBP=OFF -D NCINE_WITH_AUDIO=OFF -D NCINE_WITH_SCRIPTING_API=OFF -D NCINE_BUILD_TESTS=OFF"
111 |           C:\msys64\usr\bin\bash.exe -lc 'make -j $NUMBER_OF_PROCESSORS -C ../nCine-build-Release'
112 |         }
113 |         else
114 |         {
115 |           C:\msys64\usr\bin\bash.exe -lc "cmake -G 'MSYS Makefiles' -B ../nCine-build-${{ matrix.BuildType }} -D CMAKE_BUILD_TYPE=${{ matrix.BuildType }} -D NCINE_DYNAMIC_LIBRARY=OFF -D IMGUI_VERSION_TAG=$env:IMGUI_VERSION_TAG -D NCINE_PREFERRED_BACKEND=SDL2 -D NCINE_WITH_SCENEGRAPH=OFF -D NCINE_WITH_THREADS=OFF -D NCINE_WITH_WEBP=OFF -D NCINE_WITH_AUDIO=OFF -D NCINE_WITH_SCRIPTING_API=OFF -D NCINE_BUILD_TESTS=OFF"
116 |           C:\msys64\usr\bin\bash.exe -lc 'make -j $NUMBER_OF_PROCESSORS -C ../nCine-build-${{ matrix.BuildType }}'
117 |         }
118 | 
119 |     - name: 'CMake Configuration'
120 |       env:
121 |         CHERE_INVOKING: on
122 |       run: |
123 |         $env:CC= "${{ matrix.CC }}"
124 |         $env:CXX = "${{ matrix.CXX }}"
125 | 
126 |         $env:PROJECT_NAME = Split-Path -Path "$env:GITHUB_REPOSITORY" -leaf
127 |         $env:MSYSTEM = "MINGW64"
128 | 
129 |         if ("${{ matrix.BuildType }}" -eq "BinDist")
130 |           { C:\msys64\usr\bin\bash.exe -lc "cmake -G 'MSYS Makefiles' -B ../$env:PROJECT_NAME-build-${{ matrix.BuildType }} -D NCPROJECT_OPTIONS_PRESETS=${{ matrix.BuildType }} -D nCine_DIR=$(cygpath -m $PWD/../nCine-build-Release)" }
131 |         else
132 |           { C:\msys64\usr\bin\bash.exe -lc "cmake -G 'MSYS Makefiles' -B ../$env:PROJECT_NAME-build-${{ matrix.BuildType }} -D CMAKE_BUILD_TYPE=${{ matrix.BuildType }} -D nCine_DIR=$(cygpath -m $PWD/../nCine-build-${{ matrix.BuildType }})" }
133 | 
134 |     - name: 'Make'
135 |       env:
136 |         CHERE_INVOKING: on
137 |       run: |
138 |         $env:PROJECT_NAME = Split-Path -Path "$env:GITHUB_REPOSITORY" -leaf
139 |         $env:MSYSTEM = "MINGW64"
140 | 
141 |         C:\msys64\usr\bin\bash.exe -lc 'make -j $NUMBER_OF_PROCESSORS -C ../$PROJECT_NAME-build-${{ matrix.BuildType }}'
142 | 
143 |     - name: 'Package'
144 |       if: matrix.BuildType == 'BinDist'
145 |       env:
146 |         CHERE_INVOKING: on
147 |       run: |
148 |         $env:PROJECT_NAME = Split-Path -Path "$env:GITHUB_REPOSITORY" -leaf
149 |         $env:MSYSTEM = "MINGW64"
150 | 
151 |         C:\msys64\usr\bin\bash.exe -lc 'make package -C ../$PROJECT_NAME-build-${{ matrix.BuildType }}'
152 | 
153 |     - name: 'Push Artifacts'
154 |       if: matrix.BuildType == 'BinDist'
155 |       env:
156 |         PUBLIC_REPO_TOKEN: ${{ secrets.PUBLIC_REPO_TOKEN }}
157 |       run: |
158 |         git config --global user.email "pipelines@azure.com"
159 |         git config --global user.name "Azure Pipelines"
160 |         $env:GIT_REDIRECT_STDERR = '2>&1'
161 | 
162 |         $env:CC = "${{ matrix.CC }}"
163 | 
164 |         $env:project_name = Split-Path -Path "$env:GITHUB_REPOSITORY" -leaf
165 |         $env:branch_name = git describe --tags --exact-match; if (-not $?) { $env:branch_name = git symbolic-ref -q --short HEAD }; if (-not $?) { $env:branch_name = git rev-parse --short HEAD }
166 |         $env:DEPLOY_MESSAGE = $env:DEPLOY_MESSAGE -creplace "PROJECT_NAME",$env:project_name
167 |         $env:DEPLOY_MESSAGE = $env:DEPLOY_MESSAGE -creplace "BRANCH_NAME",$env:branch_name
168 | 
169 |         $env:DEPLOY_BRANCH = $env:DEPLOY_BRANCH -creplace "PROJECT_NAME",$env:project_name
170 |         $env:DEPLOY_BRANCH = $env:DEPLOY_BRANCH -creplace "BRANCH_NAME",$env:branch_name
171 |         $env:DEPLOY_BRANCH = $env:DEPLOY_BRANCH -creplace "OS","mingw64" -creplace "COMPILER",$env:CC
172 | 
173 |         cd ..
174 |         git clone https://$env:PUBLIC_REPO_TOKEN@github.com/$env:GITHUB_REPOSITORY-artifacts.git 2>&1>$null
175 |         cd $env:project_name-artifacts
176 |         git checkout $env:DEPLOY_BRANCH; if (-not $?) { git checkout --orphan $env:DEPLOY_BRANCH }
177 |         git reset
178 |         git clean -f
179 |         git rm *
180 | 
181 |         Move-Item -Path ..\$env:project_name-build-${{ matrix.BuildType }}\*.tar.gz -Destination .
182 |         git add *.tar.gz
183 | 
184 |         git commit --amend -m "$env:DEPLOY_MESSAGE"; if (-not $?) { git commit -m "$env:DEPLOY_MESSAGE" }
185 |         git push --force; if (-not $?) { git push --set-upstream origin $env:DEPLOY_BRANCH }
186 | 


--------------------------------------------------------------------------------
/src/GridFunctionLibrary.cpp:
--------------------------------------------------------------------------------
  1 | #include "GridFunctionLibrary.h"
  2 | #include "GridAnimation.h"
  3 | #include "Sprite.h"
  4 | 
  5 | nctl::Array<GridFunction> GridFunctionLibrary::gridFunctions_(4);
  6 | 
  7 | ///////////////////////////////////////////////////////////
  8 | // PUBLIC FUNCTIONS
  9 | ///////////////////////////////////////////////////////////
 10 | 
 11 | namespace {
 12 | 
 13 | void waveX(GridAnimation &gridAnimation)
 14 | {
 15 | 	const float value = gridAnimation.curve().value();
 16 | 	const nctl::Array<GridFunctionParameter> &parameters = gridAnimation.parameters();
 17 | 
 18 | 	const float amplitude = parameters[0].value0;
 19 | 	const float frequency = parameters[1].value0;
 20 | 	const float py = parameters[2].value0;
 21 | 	Sprite *sprite = gridAnimation.sprite();
 22 | 
 23 | 	const int width = sprite->width();
 24 | 	const int height = sprite->height();
 25 | 	const int halfHeight = height / 2;
 26 | 	nctl::Array<Sprite::Vertex> &interleavedVertices = sprite->interleavedVertices();
 27 | 
 28 | 	for (int y = 0; y < height + 1; y++)
 29 | 	{
 30 | 		const float distPyNorm = (halfHeight + py - y) / halfHeight;
 31 | 		const float diff = distPyNorm * amplitude * sinf(value * 2.0f * nc::fPi + (frequency * distPyNorm));
 32 | 		for (int x = 0; x < width + 1; x++)
 33 | 		{
 34 | 			const unsigned int index = static_cast<unsigned int>(x + y * (width + 1));
 35 | 			Sprite::Vertex &v = interleavedVertices[index];
 36 | 			v.x += diff;
 37 | 		}
 38 | 	}
 39 | }
 40 | 
 41 | void waveY(GridAnimation &gridAnimation)
 42 | {
 43 | 	const float value = gridAnimation.curve().value();
 44 | 	const nctl::Array<GridFunctionParameter> &parameters = gridAnimation.parameters();
 45 | 
 46 | 	const float amplitude = parameters[0].value0;
 47 | 	const float frequency = parameters[1].value0;
 48 | 	const float px = parameters[2].value0;
 49 | 	Sprite *sprite = gridAnimation.sprite();
 50 | 
 51 | 	const int width = sprite->width();
 52 | 	const int height = sprite->height();
 53 | 	const int halfWidth = width / 2;
 54 | 	nctl::Array<Sprite::Vertex> &interleavedVertices = sprite->interleavedVertices();
 55 | 
 56 | 	for (int x = 0; x < width + 1; x++)
 57 | 	{
 58 | 		const float distPxNorm = (halfWidth + px - x) / halfWidth;
 59 | 		const float diff = distPxNorm * amplitude * sinf(value * 2.0f * nc::fPi + (frequency * distPxNorm));
 60 | 		for (int y = 0; y < height + 1; y++)
 61 | 		{
 62 | 			const unsigned int index = static_cast<unsigned int>(x + y * (width + 1));
 63 | 			Sprite::Vertex &v = interleavedVertices[index];
 64 | 			v.y += diff;
 65 | 		}
 66 | 	}
 67 | }
 68 | 
 69 | void skewX(GridAnimation &gridAnimation)
 70 | {
 71 | 	const float value = gridAnimation.curve().value();
 72 | 	const nctl::Array<GridFunctionParameter> &parameters = gridAnimation.parameters();
 73 | 
 74 | 	const float py = parameters[0].value0;
 75 | 	Sprite *sprite = gridAnimation.sprite();
 76 | 
 77 | 	const int width = sprite->width();
 78 | 	const int height = sprite->height();
 79 | 	const int halfHeight = height / 2;
 80 | 	const float invWidth = 1.0f / float(width);
 81 | 	nctl::Array<Sprite::Vertex> &interleavedVertices = sprite->interleavedVertices();
 82 | 
 83 | 	for (int y = 0; y < height + 1; y++)
 84 | 	{
 85 | 		const float distPy = halfHeight + py - y;
 86 | 		const float diff = -distPy * value * invWidth;
 87 | 		for (int x = 0; x < width + 1; x++)
 88 | 		{
 89 | 			const unsigned int index = static_cast<unsigned int>(x + y * (width + 1));
 90 | 			Sprite::Vertex &v = interleavedVertices[index];
 91 | 			v.x += diff;
 92 | 		}
 93 | 	}
 94 | }
 95 | 
 96 | void skewY(GridAnimation &gridAnimation)
 97 | {
 98 | 	const float value = gridAnimation.curve().value();
 99 | 	const nctl::Array<GridFunctionParameter> &parameters = gridAnimation.parameters();
100 | 
101 | 	const float px = parameters[0].value0;
102 | 	Sprite *sprite = gridAnimation.sprite();
103 | 
104 | 	const int width = sprite->width();
105 | 	const int height = sprite->height();
106 | 	const int halfWidth = width / 2;
107 | 	const float invHeight = 1.0f / float(height);
108 | 	nctl::Array<Sprite::Vertex> &interleavedVertices = sprite->interleavedVertices();
109 | 
110 | 	for (int x = 0; x < width + 1; x++)
111 | 	{
112 | 		const float distPx = halfWidth + px - x;
113 | 		const float diff = -distPx * value * invHeight;
114 | 		for (int y = 0; y < height + 1; y++)
115 | 		{
116 | 			const unsigned int index = static_cast<unsigned int>(x + y * (width + 1));
117 | 			Sprite::Vertex &v = interleavedVertices[index];
118 | 			v.y += diff;
119 | 		}
120 | 	}
121 | }
122 | 
123 | void zoom(GridAnimation &gridAnimation)
124 | {
125 | 	const float value = gridAnimation.curve().value();
126 | 	const nctl::Array<GridFunctionParameter> &parameters = gridAnimation.parameters();
127 | 
128 | 	const float px = parameters[0].value0;
129 | 	const float py = parameters[1].value0;
130 | 	Sprite *sprite = gridAnimation.sprite();
131 | 
132 | 	const int width = sprite->width();
133 | 	const int height = sprite->height();
134 | 	const int halfWidth = width / 2;
135 | 	const int halfHeight = height / 2;
136 | 	const float invWidth = 1.0f / float(width);
137 | 	const float invHeight = 1.0f / float(height);
138 | 	nctl::Array<Sprite::Vertex> &interleavedVertices = sprite->interleavedVertices();
139 | 
140 | 	for (int y = 0; y < height + 1; y++)
141 | 	{
142 | 		const float distPy = halfHeight + py - y;
143 | 		const float diffY = -distPy * value * invHeight;
144 | 		for (int x = 0; x < width + 1; x++)
145 | 		{
146 | 			const float distPx = halfWidth + px - x;
147 | 			const float diffX = -distPx * value * invWidth;
148 | 			const unsigned int index = static_cast<unsigned int>(x + y * (width + 1));
149 | 			Sprite::Vertex &v = interleavedVertices[index];
150 | 			v.x += diffX;
151 | 			v.y += diffY;
152 | 		}
153 | 	}
154 | }
155 | 
156 | }
157 | 
158 | void GridFunctionLibrary::init()
159 | {
160 | 	{
161 | 		GridFunction waveXFunction;
162 | 		waveXFunction.setName("Wave X");
163 | 		GridFunction::ParameterInfo &amplitude = waveXFunction.addParameter("Amplitude", GridFunction::ParameterType::FLOAT, 0.25f);
164 | 		amplitude.minValue.value0 = 0.0f;
165 | 		amplitude.maxValue.value0 = 1.0f;
166 | 		GridFunction::ParameterInfo &frequency = waveXFunction.addParameter("Frequency", GridFunction::ParameterType::FLOAT, 1.0f);
167 | 		frequency.minValue.value0 = 0.0f;
168 | 		frequency.maxValue.value0 = 8.0f;
169 | 		GridFunction::ParameterInfo &anchor = waveXFunction.addParameter("Anchor Y", GridFunction::ParameterType::FLOAT, 0.0f);
170 | 		anchor.minValue.value0 = -0.5f;
171 | 		anchor.maxValue.value0 = 0.5f;
172 | 		anchor.minMultiply = GridFunction::ValueMultiply::SPRITE_HEIGHT;
173 | 		anchor.maxMultiply = GridFunction::ValueMultiply::SPRITE_HEIGHT;
174 | 		anchor.anchorType = GridFunction::AnchorType::Y;
175 | 		waveXFunction.setCallback(waveX);
176 | 		gridFunctions_.pushBack(waveXFunction);
177 | 	}
178 | 
179 | 	{
180 | 		GridFunction waveYFunction;
181 | 		waveYFunction.setName("Wave Y");
182 | 		GridFunction::ParameterInfo &amplitude = waveYFunction.addParameter("Amplitude", GridFunction::ParameterType::FLOAT, 0.25f);
183 | 		amplitude.minValue.value0 = 0.0f;
184 | 		amplitude.maxValue.value0 = 1.0f;
185 | 		GridFunction::ParameterInfo &frequency = waveYFunction.addParameter("Frequency", GridFunction::ParameterType::FLOAT, 1.0f);
186 | 		frequency.minValue.value0 = 0.0f;
187 | 		frequency.maxValue.value0 = 8.0f;
188 | 		GridFunction::ParameterInfo &anchor = waveYFunction.addParameter("Anchor X", GridFunction::ParameterType::FLOAT, 0.0f, 0.0f);
189 | 		anchor.minValue.value0 = -0.5f;
190 | 		anchor.maxValue.value0 = 0.5f;
191 | 		anchor.minMultiply = GridFunction::ValueMultiply::SPRITE_WIDTH;
192 | 		anchor.maxMultiply = GridFunction::ValueMultiply::SPRITE_WIDTH;
193 | 		anchor.anchorType = GridFunction::AnchorType::X;
194 | 		waveYFunction.setCallback(waveY);
195 | 		gridFunctions_.pushBack(waveYFunction);
196 | 	}
197 | 
198 | 	{
199 | 		GridFunction skewXFunction;
200 | 		skewXFunction.setName("Skew X");
201 | 		GridFunction::ParameterInfo &anchor = skewXFunction.addParameter("Anchor Y", GridFunction::ParameterType::FLOAT, 0.0f);
202 | 		anchor.minValue.value0 = -0.5f;
203 | 		anchor.maxValue.value0 = 0.5f;
204 | 		anchor.minMultiply = GridFunction::ValueMultiply::SPRITE_HEIGHT;
205 | 		anchor.maxMultiply = GridFunction::ValueMultiply::SPRITE_HEIGHT;
206 | 		anchor.anchorType = GridFunction::AnchorType::Y;
207 | 		skewXFunction.setCallback(skewX);
208 | 		gridFunctions_.pushBack(skewXFunction);
209 | 	}
210 | 
211 | 	{
212 | 		GridFunction skewYFunction;
213 | 		skewYFunction.setName("Skew Y");
214 | 		GridFunction::ParameterInfo &anchor = skewYFunction.addParameter("Anchor X", GridFunction::ParameterType::FLOAT, 0.0f, 0.0f);
215 | 		anchor.minValue.value0 = -0.5f;
216 | 		anchor.maxValue.value0 = 0.5f;
217 | 		anchor.minMultiply = GridFunction::ValueMultiply::SPRITE_WIDTH;
218 | 		anchor.maxMultiply = GridFunction::ValueMultiply::SPRITE_WIDTH;
219 | 		anchor.anchorType = GridFunction::AnchorType::X;
220 | 		skewYFunction.setCallback(skewY);
221 | 		gridFunctions_.pushBack(skewYFunction);
222 | 	}
223 | 
224 | 	{
225 | 		GridFunction zoomFunction;
226 | 		zoomFunction.setName("Zoom");
227 | 		GridFunction::ParameterInfo &anchorx = zoomFunction.addParameter("Anchor X", GridFunction::ParameterType::FLOAT, 0.0f, 0.0f);
228 | 		anchorx.minValue.value0 = -0.5f;
229 | 		anchorx.maxValue.value0 = 0.5f;
230 | 		anchorx.minMultiply = GridFunction::ValueMultiply::SPRITE_WIDTH;
231 | 		anchorx.maxMultiply = GridFunction::ValueMultiply::SPRITE_WIDTH;
232 | 		anchorx.anchorType = GridFunction::AnchorType::X;
233 | 		GridFunction::ParameterInfo &anchory = zoomFunction.addParameter("Anchor Y", GridFunction::ParameterType::FLOAT, 0.0f, 0.0f);
234 | 		anchory.minValue.value0 = -0.5f;
235 | 		anchory.maxValue.value0 = 0.5f;
236 | 		anchory.minMultiply = GridFunction::ValueMultiply::SPRITE_WIDTH;
237 | 		anchory.maxMultiply = GridFunction::ValueMultiply::SPRITE_WIDTH;
238 | 		anchory.anchorType = GridFunction::AnchorType::Y;
239 | 		zoomFunction.setCallback(zoom);
240 | 		gridFunctions_.pushBack(zoomFunction);
241 | 	}
242 | }
243 | 


--------------------------------------------------------------------------------
/src/gui/config_window.cpp:
--------------------------------------------------------------------------------
  1 | #include <ncine/IGfxDevice.h>
  2 | #include <ncine/Application.h>
  3 | #include <ncine/IFile.h>
  4 | 
  5 | #include "singletons.h"
  6 | #include "gui/UserInterface.h"
  7 | #include "gui/gui_labels.h"
  8 | #include "Configuration.h"
  9 | #include "LuaSaver.h"
 10 | 
 11 | bool UserInterface::showConfigWindow = false;
 12 | 
 13 | ///////////////////////////////////////////////////////////
 14 | // PRIVATE FUNCTIONS
 15 | ///////////////////////////////////////////////////////////
 16 | 
 17 | void UserInterface::createConfigWindow()
 18 | {
 19 | 	if (showConfigWindow == false)
 20 | 		return;
 21 | 
 22 | 	nc::IGfxDevice &gfxDevice = nc::theApplication().gfxDevice();
 23 | 	const float scalingFactor = theCfg.autoGuiScaling ? gfxDevice.windowScalingFactor() : theCfg.guiScaling;
 24 | 	const ImVec2 guiWindowSize = ImVec2(500.0f * scalingFactor, 475.0f * scalingFactor);
 25 | 	ImGui::SetNextWindowSize(guiWindowSize, ImGuiCond_Once);
 26 | 	const ImVec2 guiWindowPos = ImVec2(ImGui::GetWindowViewport()->Size.x * 0.5f, ImGui::GetWindowViewport()->Size.y * 0.5f);
 27 | 	ImGui::SetNextWindowPos(guiWindowPos, ImGuiCond_Once, ImVec2(0.5f, 0.5f));
 28 | 	ImGui::Begin(Labels::Configuration, &showConfigWindow, ImGuiWindowFlags_NoDocking);
 29 | 
 30 | #ifdef __ANDROID__
 31 | 	ImGui::Text("Screen Resolution: %d x %d", gfxDevice.width(), gfxDevice.height());
 32 | 	ImGui::TextUnformatted("Resizable: false");
 33 | 	ImGui::TextUnformatted("Fullscreen: true");
 34 | #else
 35 | 	static bool fullScreen = theCfg.fullScreen;
 36 | 	static int selectedVideoMode[nc::IGfxDevice::MaxMonitors] = {};
 37 | 	const unsigned int monitorIndex = gfxDevice.windowMonitorIndex();
 38 | 	const nc::IGfxDevice::VideoMode &currentVideoMode = gfxDevice.currentVideoMode(monitorIndex);
 39 | 	const nc::IGfxDevice::Monitor &monitor = gfxDevice.monitor(monitorIndex);
 40 | 
 41 | 	ImGui::BeginDisabled(gfxDevice.isFullScreen());
 42 | 	ImGui::AlignTextToFramePadding();
 43 | 	ImGui::Text("Window Position: %d, %d", gfxDevice.windowPositionX(), gfxDevice.windowPositionY());
 44 | 	ImGui::SameLine();
 45 | 	if (ImGui::Button(Labels::CenterWindow))
 46 | 	{
 47 | 		const nc::Vector2i windowSize(gfxDevice.width(), gfxDevice.height());
 48 | 		const nc::Vector2i screenResolution(currentVideoMode.width, currentVideoMode.height);
 49 | 		gfxDevice.setWindowPosition(monitor.position + (screenResolution - windowSize) / 2);
 50 | 	}
 51 | 	ImGui::EndDisabled();
 52 | 	theCfg.windowPositionX = gfxDevice.windowPositionX();
 53 | 	theCfg.windowPositionY = gfxDevice.windowPositionY();
 54 | 
 55 | 	ImGui::BeginDisabled(fullScreen);
 56 | 	ImGui::SliderInt("Window Width", &theCfg.width, 0, currentVideoMode.width / scalingFactor);
 57 | 	ImGui::SliderInt("Window Height", &theCfg.height, 0, currentVideoMode.height / scalingFactor);
 58 | 	const nc::Vector2i scaledWindowSize(theCfg.width * scalingFactor, theCfg.height * scalingFactor);
 59 | 	if (scalingFactor != 1.0f)
 60 | 		ImGui::Text("Scaled Size: %d x %d (factor: %.2f)", scaledWindowSize.x, scaledWindowSize.y, scalingFactor);
 61 | 	ImGui::EndDisabled();
 62 | 
 63 | 	ui::auxString.format("Monitor #%u: \"%s\"", monitorIndex, monitor.name);
 64 | 	if (monitorIndex == gfxDevice.primaryMonitorIndex())
 65 | 		ui::auxString.append(" [Primary]");
 66 | 	ImGui::TextUnformatted(ui::auxString.data());
 67 | 
 68 | 	const unsigned int numVideoModes = monitor.numVideoModes;
 69 | 	ui::comboString.clear();
 70 | 	for (unsigned int modeIndex = 0; modeIndex < numVideoModes; modeIndex++)
 71 | 	{
 72 | 		const nc::IGfxDevice::VideoMode &mode = monitor.videoModes[modeIndex];
 73 | 		ui::comboString.formatAppend("#%u: %u x %u, %.2f Hz", modeIndex, mode.width, mode.height, mode.refreshRate);
 74 | 		ui::comboString.setLength(ui::comboString.length() + 1);
 75 | 	}
 76 | 	ui::comboString.setLength(ui::comboString.length() + 1);
 77 | 	// Append a second '\0' to signal the end of the combo item list
 78 | 	ui::comboString[ui::comboString.length() - 1] = '\0';
 79 | 
 80 | 	if (selectedVideoMode[monitorIndex] < 0)
 81 | 		selectedVideoMode[monitorIndex] = 0;
 82 | 	if (selectedVideoMode[monitorIndex] > monitor.numVideoModes - 1)
 83 | 		selectedVideoMode[monitorIndex] = monitor.numVideoModes - 1;
 84 | 
 85 | 	ImGui::Combo("Video Mode", &selectedVideoMode[monitorIndex], ui::comboString.data());
 86 | 	ImGui::Checkbox("Full Screen", &fullScreen);
 87 | 
 88 | 	ImGui::BeginDisabled(fullScreen);
 89 | 	ImGui::SameLine();
 90 | 	if (ImGui::Checkbox("Resizable", &theCfg.resizable) && theCfg.resizable != gfxDevice.isResizable())
 91 | 		pushStatusInfoMessage("Restart the application to see the changes");
 92 | 	ImGui::EndDisabled();
 93 | 
 94 | 	const bool shouldChangeVideoMode = (monitor.videoModes[selectedVideoMode[monitorIndex]] != currentVideoMode);
 95 | 	const bool shouldChangeWindowSize = (gfxDevice.resolution().x != scaledWindowSize.x || gfxDevice.resolution().y != scaledWindowSize.y);
 96 | 	const bool canApply = (gfxDevice.isFullScreen() != fullScreen) || (fullScreen && shouldChangeVideoMode) || shouldChangeWindowSize;
 97 | 	ImGui::BeginDisabled(canApply == false);
 98 | 	ImGui::SameLine();
 99 | 	if (ImGui::Button(Labels::Apply))
100 | 	{
101 | 		if (fullScreen)
102 | 		{
103 | 			gfxDevice.setVideoMode(selectedVideoMode[monitorIndex]);
104 | 			gfxDevice.setFullScreen(fullScreen);
105 | 
106 | 			if (shouldChangeVideoMode)
107 | 				openVideoModePopup(); // The popup saves the configuration
108 | 			else
109 | 			{
110 | 				theCfg.width = currentVideoMode.width;
111 | 				theCfg.height = currentVideoMode.height;
112 | 				theCfg.refreshRate = 0.0f;
113 | 				theCfg.fullScreen = fullScreen;
114 | 			}
115 | 		}
116 | 		else
117 | 		{
118 | 			gfxDevice.setFullScreen(fullScreen);
119 | 			theCfg.refreshRate = 0.0f;
120 | 			const nc::Vector2i halfScreenResolution(currentVideoMode.width / 2, currentVideoMode.height / 2);
121 | 			gfxDevice.setWindowPosition(monitor.position + halfScreenResolution - scaledWindowSize / 2);
122 | 			gfxDevice.setWindowSize(scaledWindowSize);
123 | 			theCfg.fullScreen = fullScreen;
124 | 		}
125 | 	}
126 | 	ImGui::EndDisabled();
127 | 
128 | 	ImGui::SameLine();
129 | 	const bool currentEnabled = (shouldChangeVideoMode || gfxDevice.isFullScreen() != fullScreen ||
130 | 	                             shouldChangeWindowSize || gfxDevice.isResizable() != theCfg.resizable);
131 | 	ImGui::BeginDisabled(currentEnabled == false);
132 | 	if (ImGui::Button(Labels::Current))
133 | 	{
134 | 		for (unsigned int i = 0; i < monitor.numVideoModes; i++)
135 | 		{
136 | 			if (monitor.videoModes[i] == currentVideoMode)
137 | 			{
138 | 				selectedVideoMode[monitorIndex] = i;
139 | 				break;
140 | 			}
141 | 		}
142 | 		theCfg.width = gfxDevice.width() / scalingFactor;
143 | 		theCfg.height = gfxDevice.height() / scalingFactor;
144 | 		fullScreen = gfxDevice.isFullScreen();
145 | 		theCfg.resizable = gfxDevice.isResizable();
146 | 	}
147 | 	ImGui::EndDisabled();
148 | #endif
149 | 
150 | 	ImGui::NewLine();
151 | #ifdef __ANDROID__
152 | 	ImGui::Text("Vertical Sync: true");
153 | #else
154 | 	ImGui::Checkbox("Vertical Sync", &theCfg.withVSync);
155 | 	nc::theApplication().gfxDevice().setSwapInterval(theCfg.withVSync ? 1 : 0);
156 | #endif
157 | 	int frameLimit = theCfg.frameLimit;
158 | 	ImGui::SliderInt("Frame Limit", &frameLimit, 0, 240);
159 | 	theCfg.frameLimit = frameLimit < 0 ? 0 : frameLimit;
160 | 
161 | 	ImGui::NewLine();
162 | 	ImGui::SliderInt("Canvas Width", &theCfg.canvasWidth, 0, 1024);
163 | 	ImGui::SliderInt("Canvas Height", &theCfg.canvasHeight, 0, 1024);
164 | 
165 | 	ImGui::NewLine();
166 | 	if (ImGui::Checkbox("Automatic GUI Scaling", &theCfg.autoGuiScaling))
167 | 		theCfg.guiScaling = gfxDevice.windowScalingFactor();
168 | 	ImGui::BeginDisabled(theCfg.autoGuiScaling);
169 | 	ImGui::SameLine();
170 | 	if (ImGui::Button(Labels::Reset))
171 | 		theCfg.guiScaling = 1.0f;
172 | 	ImGui::SliderFloat("GUI Scaling", &theCfg.guiScaling, 0.5f, 2.0f, "%.2f");
173 | 	ImGui::EndDisabled();
174 | 
175 | 	if (ImGui::GetStyle().FontScaleMain != theCfg.guiScaling)
176 | 		changeScalingFactor(theCfg.guiScaling);
177 | 
178 | 	ImGui::InputText("Start-up Project", theCfg.startupProjectName.data(), ui::MaxStringLength,
179 | 	                 ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_CallbackResize, ui::inputTextCallback, &theCfg.startupProjectName);
180 | 	ImGui::Checkbox("Auto Play On Start", &theCfg.autoPlayOnStart);
181 | 
182 | 	ImGui::NewLine();
183 | 	ImGui::InputText("Projects Path", theCfg.projectsPath.data(), ui::MaxStringLength,
184 | 	                 ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_CallbackResize, ui::inputTextCallback, &theCfg.projectsPath);
185 | 	ImGui::InputText("Textures Path", theCfg.texturesPath.data(), ui::MaxStringLength,
186 | 	                 ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_CallbackResize, ui::inputTextCallback, &theCfg.texturesPath);
187 | 	ImGui::InputText("Scripts Path", theCfg.scriptsPath.data(), ui::MaxStringLength,
188 | 	                 ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_CallbackResize, ui::inputTextCallback, &theCfg.scriptsPath);
189 | 
190 | 	ImGui::Checkbox("Show Tips On Start", &theCfg.showTipsOnStart);
191 | 
192 | 	sanitizeConfigValues();
193 | 
194 | 	ImGui::NewLine();
195 | 	if (ImGui::Button(Labels::Close))
196 | 		showConfigWindow = false;
197 | 
198 | 	// Auto-save on window close
199 | 	if (showConfigWindow == false)
200 | 		theSaver->saveCfg(theCfg);
201 | 
202 | 	ImGui::End();
203 | }
204 | 
205 | void UserInterface::sanitizeConfigValues()
206 | {
207 | 	if (theCfg.width < 640)
208 | 		theCfg.width = 640;
209 | 	if (theCfg.height < 480)
210 | 		theCfg.height = 480;
211 | 	if (theCfg.refreshRate < 0.0f)
212 | 		theCfg.refreshRate = 0.0f;
213 | 
214 | 	if (theCfg.frameLimit > 240)
215 | 		theCfg.frameLimit = 240;
216 | 
217 | 	if (theCfg.canvasWidth < 16)
218 | 		theCfg.canvasWidth = 16;
219 | 	if (theCfg.canvasHeight < 16)
220 | 		theCfg.canvasHeight = 16;
221 | 
222 | 	if (theCfg.autoGuiScaling == false)
223 | 	{
224 | 		if (theCfg.guiScaling < 0.5f)
225 | 			theCfg.guiScaling = 0.5f;
226 | 		else if (theCfg.guiScaling > 2.0f)
227 | 			theCfg.guiScaling = 2.0f;
228 | 	}
229 | }
230 | 


--------------------------------------------------------------------------------