Lenheart
/
Magic_Game
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Format codes

This commit is contained in:
Nomango 2020-01-21 10:09:55 +08:00
parent 1e12296181
commit 4aa8a549aa
211 changed files with 28880 additions and 28843 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
.clang-format Normal file
View File

@ -0,0 +1,108 @@
# Clang-format version v9.0.0
---
Language: Cpp
BasedOnStyle: Google
ColumnLimit: 120
##
## Indent Style
##
IndentWidth: 4
AccessModifierOffset: -4
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
TabWidth: 4
UseTab: Never
IndentCaseLabels: false
NamespaceIndentation: None
##
## Align Style
##
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: true
AlignConsecutiveDeclarations: true
AlignEscapedNewlinesLeft: true
AlignOperands: true
AlignTrailingComments: true
PointerAlignment: Left
##
## SingleLine Style
##
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: Empty
AllowShortIfStatementsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: true
BinPackArguments: true
BinPackParameters: true
BreakBeforeBraces: Allman
BraceWrapping:
AfterClass: true
AfterControlStatement: true
AfterEnum: true
AfterFunction: true
AfterNamespace: true
AfterObjCDeclaration: true
AfterStruct: true
AfterUnion: true
BeforeCatch: true
BeforeElse: true
IndentBraces: true
BreakBeforeBinaryOperators: NonAssignment
BreakBeforeTernaryOperators: true
CommentPragmas: "^ IWYU pragma:"
ConstructorInitializerAllOnOneLineOrOnePerLine: false
##
## Others
##
BreakConstructorInitializers: BeforeComma
BreakInheritanceList: BeforeComma
ReflowComments: true
SortIncludes: true
Cpp11BracedListStyle: false
DerivePointerAlignment: false
DisableFormat: false
ExperimentalAutoDetectBinPacking: false
ForEachMacros: [foreach, Q_FOREACH, BOOST_FOREACH]
IncludeCategories:
- Regex: '^"(llvm|llvm-c|clang|clang-c)/'
Priority: 2
- Regex: '^(<|"(gtest|isl|json)/)'
Priority: 3
- Regex: ".*"
Priority: 1
IndentWrappedFunctionNames: false
KeepEmptyLinesAtTheStartOfBlocks: true
MacroBlockBegin: ""
MacroBlockEnd: ""
MaxEmptyLinesToKeep: 1
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
SpaceAfterCStyleCast: false
SpaceBeforeAssignmentOperators: true
SpaceBeforeParens: ControlStatements
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 2
SpacesInAngles: false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Cpp11

2
.editorconfig
View File

@ -14,7 +14,7 @@ insert_final_newline = true
charset = gb2312
# 4 space indentation
indent_style = tab
indent_style = space
indent_size = 4
# Matches the exact files

24
projects/kiwano/kiwano.vcxproj
View File

@ -65,13 +65,13 @@
<ClInclude Include="..\..\src\kiwano\platform\Window.h" />
<ClInclude Include="..\..\src\kiwano\render\Brush.h" />
<ClInclude Include="..\..\src\kiwano\render\Color.h" />
<ClInclude Include="..\..\src\kiwano\render\dx\D2DDeviceResources.h" />
<ClInclude Include="..\..\src\kiwano\render\dx\D3D10DeviceResources.h" />
<ClInclude Include="..\..\src\kiwano\render\dx\D3D11DeviceResources.h" />
<ClInclude Include="..\..\src\kiwano\render\dx\D3DDeviceResourcesBase.h" />
<ClInclude Include="..\..\src\kiwano\render\dx\FontCollectionLoader.h" />
<ClInclude Include="..\..\src\kiwano\render\dx\helper.h" />
<ClInclude Include="..\..\src\kiwano\render\dx\TextRenderer.h" />
<ClInclude Include="..\..\src\kiwano\render\DirectX\D2DDeviceResources.h" />
<ClInclude Include="..\..\src\kiwano\render\DirectX\D3D10DeviceResources.h" />
<ClInclude Include="..\..\src\kiwano\render\DirectX\D3D11DeviceResources.h" />
<ClInclude Include="..\..\src\kiwano\render\DirectX\D3DDeviceResourcesBase.h" />
<ClInclude Include="..\..\src\kiwano\render\DirectX\FontCollectionLoader.h" />
<ClInclude Include="..\..\src\kiwano\render\DirectX\helper.h" />
<ClInclude Include="..\..\src\kiwano\render\DirectX\TextRenderer.h" />
<ClInclude Include="..\..\src\kiwano\render\Font.h" />
<ClInclude Include="..\..\src\kiwano\render\Geometry.h" />
<ClInclude Include="..\..\src\kiwano\render\GeometrySink.h" />
@ -136,11 +136,11 @@
<ClCompile Include="..\..\src\kiwano\platform\Window.cpp" />
<ClCompile Include="..\..\src\kiwano\render\Brush.cpp" />
<ClCompile Include="..\..\src\kiwano\render\Color.cpp" />
<ClCompile Include="..\..\src\kiwano\render\dx\D2DDeviceResources.cpp" />
<ClCompile Include="..\..\src\kiwano\render\dx\D3D10DeviceResources.cpp" />
<ClCompile Include="..\..\src\kiwano\render\dx\D3D11DeviceResources.cpp" />
<ClCompile Include="..\..\src\kiwano\render\dx\FontCollectionLoader.cpp" />
<ClCompile Include="..\..\src\kiwano\render\dx\TextRenderer.cpp" />
<ClCompile Include="..\..\src\kiwano\render\DirectX\D2DDeviceResources.cpp" />
<ClCompile Include="..\..\src\kiwano\render\DirectX\D3D10DeviceResources.cpp" />
<ClCompile Include="..\..\src\kiwano\render\DirectX\D3D11DeviceResources.cpp" />
<ClCompile Include="..\..\src\kiwano\render\DirectX\FontCollectionLoader.cpp" />
<ClCompile Include="..\..\src\kiwano\render\DirectX\TextRenderer.cpp" />
<ClCompile Include="..\..\src\kiwano\render\Font.cpp" />
<ClCompile Include="..\..\src\kiwano\render\Geometry.cpp" />
<ClCompile Include="..\..\src\kiwano\render\GeometrySink.cpp" />

74
projects/kiwano/kiwano.vcxproj.filters
View File

@ -28,7 +28,7 @@
<Filter Include="render">
<UniqueIdentifier>{adb44ca9-674a-4b77-993f-d65193d8ab06}</UniqueIdentifier>
</Filter>
<Filter Include="render\dx">
<Filter Include="render\DirectX">
<UniqueIdentifier>{fd281702-0006-46d2-8fd1-28c502464164}</UniqueIdentifier>
</Filter>
</ItemGroup>
@ -222,27 +222,6 @@
<ClInclude Include="..\..\src\kiwano\core\Time.h">
<Filter>core</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\render\dx\D2DDeviceResources.h">
<Filter>render\dx</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\render\dx\D3D10DeviceResources.h">
<Filter>render\dx</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\render\dx\D3D11DeviceResources.h">
<Filter>render\dx</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\render\dx\D3DDeviceResourcesBase.h">
<Filter>render\dx</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\render\dx\FontCollectionLoader.h">
<Filter>render\dx</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\render\dx\helper.h">
<Filter>render\dx</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\render\dx\TextRenderer.h">
<Filter>render\dx</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\render\Brush.h">
<Filter>render</Filter>
</ClInclude>
@ -285,6 +264,27 @@
<ClInclude Include="..\..\src\kiwano\render\TextureCache.h">
<Filter>render</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\render\DirectX\D2DDeviceResources.h">
<Filter>render\DirectX</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\render\DirectX\D3D10DeviceResources.h">
<Filter>render\DirectX</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\render\DirectX\D3D11DeviceResources.h">
<Filter>render\DirectX</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\render\DirectX\D3DDeviceResourcesBase.h">
<Filter>render\DirectX</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\render\DirectX\FontCollectionLoader.h">
<Filter>render\DirectX</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\render\DirectX\helper.h">
<Filter>render\DirectX</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\render\DirectX\TextRenderer.h">
<Filter>render\DirectX</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\..\src\kiwano\2d\Canvas.cpp">
@ -431,21 +431,6 @@
<ClCompile Include="..\..\src\kiwano\core\Time.cpp">
<Filter>core</Filter>
</ClCompile>
<ClCompile Include="..\..\src\kiwano\render\dx\D2DDeviceResources.cpp">
<Filter>render\dx</Filter>
</ClCompile>
<ClCompile Include="..\..\src\kiwano\render\dx\D3D10DeviceResources.cpp">
<Filter>render\dx</Filter>
</ClCompile>
<ClCompile Include="..\..\src\kiwano\render\dx\D3D11DeviceResources.cpp">
<Filter>render\dx</Filter>
</ClCompile>
<ClCompile Include="..\..\src\kiwano\render\dx\FontCollectionLoader.cpp">
<Filter>render\dx</Filter>
</ClCompile>
<ClCompile Include="..\..\src\kiwano\render\dx\TextRenderer.cpp">
<Filter>render\dx</Filter>
</ClCompile>
<ClCompile Include="..\..\src\kiwano\render\Brush.cpp">
<Filter>render</Filter>
</ClCompile>
@ -485,5 +470,20 @@
<ClCompile Include="..\..\src\kiwano\render\TextureCache.cpp">
<Filter>render</Filter>
</ClCompile>
<ClCompile Include="..\..\src\kiwano\render\DirectX\D2DDeviceResources.cpp">
<Filter>render\DirectX</Filter>
</ClCompile>
<ClCompile Include="..\..\src\kiwano\render\DirectX\D3D10DeviceResources.cpp">
<Filter>render\DirectX</Filter>
</ClCompile>
<ClCompile Include="..\..\src\kiwano\render\DirectX\D3D11DeviceResources.cpp">
<Filter>render\DirectX</Filter>
</ClCompile>
<ClCompile Include="..\..\src\kiwano\render\DirectX\FontCollectionLoader.cpp">
<Filter>render\DirectX</Filter>
</ClCompile>
<ClCompile Include="..\..\src\kiwano\render\DirectX\TextRenderer.cpp">
<Filter>render\DirectX</Filter>
</ClCompile>
</ItemGroup>
</Project>

84
scripts/clang-format-all Normal file
View File

@ -0,0 +1,84 @@
#!/bin/bash
#
# clang-format-all: a tool to run clang-format on an entire project
# Copyright (C) 2016 Evan Klitzke <evan@eklitzke.org>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
function usage {
echo "Usage: $0 DIR..."
exit 1
}
if [ $# -eq 0 ]; then
usage
fi
# Variable that will hold the name of the clang-format command
FMT=""
# Some distros just call it clang-format. Others (e.g. Ubuntu) are insistent
# that the version number be part of the command. We prefer clang-format if
# that's present, otherwise we work backwards from highest version to lowest
# version.
for clangfmt in clang-format{,-{4,3}.{9,8,7,6,5,4,3,2,1,0}}; do
if which "$clangfmt" &>/dev/null; then
FMT="$clangfmt"
break
fi
done
# Check if we found a working clang-format
if [ -z "$FMT" ]; then
echo "failed to find clang-format"
exit 1
fi
# Check all of the arguments first to make sure they're all directories
for dir in "$@"; do
if [ ! -d "${dir}" ]; then
echo "${dir} is not a directory"
usage
fi
done
# Find a dominating file, starting from a given directory and going up.
find-dominating-file() {
if [ -r "$1"/"$2" ]; then
return 0
fi
if [ "$1" = "/" ]; then
return 1
fi
find-dominating-file "$(realpath "$1"/..)" "$2"
return $?
}
# Run clang-format -i on all of the things
for dir in "$@"; do
pushd "${dir}" &>/dev/null
if ! find-dominating-file . .clang-format; then
echo "Failed to find dominating .clang-format starting at $PWD"
continue
fi
find . \
\( -name '*.c' \
-o -name '*.cc' \
-o -name '*.cpp' \
-o -name '*.h' \
-o -name '*.hh' \
-o -name '*.hpp' \) \
-exec "${FMT}" -i '{}' \;
popd &>/dev/null
done

52
src/kiwano-audio/AudioEngine.cpp
View File

@ -18,27 +18,25 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include <kiwano/platform/win32/helper.h> // win32::ThrowIfFailed
#include <kiwano/core/Logger.h>
#include <kiwano-audio/libraries.h>
#include <kiwano-audio/AudioEngine.h>
#include <kiwano-audio/libraries.h>
#include <kiwano/core/Logger.h>
#include <kiwano/platform/win32/helper.h> // win32::ThrowIfFailed
namespace kiwano
{
namespace audio
{
AudioEngine::AudioEngine()
namespace audio
{
AudioEngine::AudioEngine()
: x_audio2_(nullptr)
, mastering_voice_(nullptr)
{
}
{
}
AudioEngine::~AudioEngine()
{
}
AudioEngine::~AudioEngine() {}
void AudioEngine::SetupComponent()
{
void AudioEngine::SetupComponent()
{
KGE_SYS_LOG(L"Creating audio resources");
HRESULT hr = dlls::MediaFoundation::Get().MFStartup(MF_VERSION, MFSTARTUP_FULL);
@ -54,10 +52,10 @@ namespace kiwano
}
win32::ThrowIfFailed(hr);
}
}
void AudioEngine::DestroyComponent()
{
void AudioEngine::DestroyComponent()
{
KGE_SYS_LOG(L"Destroying audio resources");
if (mastering_voice_)
@ -73,10 +71,10 @@ namespace kiwano
}
dlls::MediaFoundation::Get().MFShutdown();
}
}
bool AudioEngine::CreateSound(Sound& sound, const Transcoder::Buffer& buffer)
{
bool AudioEngine::CreateSound(Sound& sound, const Transcoder::Buffer& buffer)
{
KGE_ASSERT(x_audio2_ && "AudioEngine hasn't been initialized!");
HRESULT hr = S_OK;
@ -104,22 +102,22 @@ namespace kiwano
win32::WarnIfFailed(hr);
return SUCCEEDED(hr);
}
}
void AudioEngine::Open()
{
void AudioEngine::Open()
{
KGE_ASSERT(x_audio2_ && "AudioEngine hasn't been initialized!");
if (x_audio2_)
x_audio2_->StartEngine();
}
}
void AudioEngine::Close()
{
void AudioEngine::Close()
{
KGE_ASSERT(x_audio2_ && "AudioEngine hasn't been initialized!");
if (x_audio2_)
x_audio2_->StopEngine();
}
}
}
} // namespace audio
} // namespace kiwano

36
src/kiwano-audio/AudioEngine.h
View File

@ -19,37 +19,38 @@
// THE SOFTWARE.
#pragma once
#include <kiwano-audio/Sound.h>
#include <kiwano-audio/Transcoder.h>
#include <kiwano/core/Common.h>
#include <kiwano/core/Component.h>
#include <kiwano-audio/Transcoder.h>
#include <kiwano-audio/Sound.h>
#include <xaudio2.h>
namespace kiwano
{
namespace audio
{
/**
namespace audio
{
/**
* \~chinese
* \defgroup Audio 音频引擎
*/
/**
/**
* \addtogroup Audio
* @{
*/
/**
/**
* \~chinese
* @brief 音频引擎
*/
class KGE_API AudioEngine
class KGE_API AudioEngine
: public Singleton<AudioEngine>
, public ComponentBase
{
{
friend Singleton<AudioEngine>;
public:
public:
/// \~chinese
/// @brief 开启音频设备
void Open();
@ -62,21 +63,22 @@ namespace kiwano
/// @brief 从解码器数据缓冲中创建音频对象
bool CreateSound(Sound& sound, const Transcoder::Buffer& buffer);
public:
public:
void SetupComponent() override;
void DestroyComponent() override;
private:
private:
AudioEngine();
~AudioEngine();
private:
private:
IXAudio2* x_audio2_;
IXAudio2MasteringVoice* mastering_voice_;
};
};
/** @} */
}
}
/** @} */
} // namespace audio
} // namespace kiwano

88
src/kiwano-audio/Sound.cpp
View File

@ -18,30 +18,30 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include <kiwano-audio/AudioEngine.h>
#include <kiwano-audio/Sound.h>
#include <kiwano/core/Logger.h>
#include <kiwano/platform/FileSystem.h>
#include <kiwano-audio/Sound.h>
#include <kiwano-audio/AudioEngine.h>
namespace kiwano
{
namespace audio
{
namespace audio
{
Sound::Sound()
Sound::Sound()
: opened_(false)
, playing_(false)
, voice_(nullptr)
{
}
{
}
Sound::~Sound()
{
Sound::~Sound()
{
Close();
}
}
bool Sound::Load(String const& file_path)
{
bool Sound::Load(String const& file_path)
{
if (!FileSystem::Instance().IsFileExists(file_path))
{
KGE_WARN(L"Media file '%s' not found", file_path.c_str());
@ -70,10 +70,10 @@ namespace kiwano
opened_ = true;
return true;
}
}
bool Sound::Load(Resource const& res)
{
bool Sound::Load(Resource const& res)
{
if (opened_)
{
Close();
@ -94,15 +94,15 @@ namespace kiwano
opened_ = true;
return true;
}
}
bool Sound::IsValid() const
{
bool Sound::IsValid() const
{
return voice_ != nullptr;
}
}
void Sound::Play(int loop_count)
{
void Sound::Play(int loop_count)
{
if (!opened_)
{
KGE_ERROR(L"Sound must be opened first!");
@ -140,26 +140,26 @@ namespace kiwano
}
playing_ = SUCCEEDED(hr);
}
}
void Sound::Pause()
{
void Sound::Pause()
{
KGE_ASSERT(voice_ != nullptr && "IXAudio2SourceVoice* is NULL");
if (SUCCEEDED(voice_->Stop()))
playing_ = false;
}
}
void Sound::Resume()
{
void Sound::Resume()
{
KGE_ASSERT(voice_ != nullptr && "IXAudio2SourceVoice* is NULL");
if (SUCCEEDED(voice_->Start()))
playing_ = true;
}
}
void Sound::Stop()
{
void Sound::Stop()
{
KGE_ASSERT(voice_ != nullptr && "IXAudio2SourceVoice* is NULL");
HRESULT hr = voice_->Stop();
@ -172,10 +172,10 @@ namespace kiwano
if (SUCCEEDED(hr))
playing_ = false;
}
}
void Sound::Close()
{
void Sound::Close()
{
if (voice_)
{
voice_->Stop();
@ -188,10 +188,10 @@ namespace kiwano
opened_ = false;
playing_ = false;
}
}
bool Sound::IsPlaying() const
{
bool Sound::IsPlaying() const
{
if (opened_)
{
if (!voice_)
@ -205,23 +205,23 @@ namespace kiwano
return true;
}
return false;
}
}
float Sound::GetVolume() const
{
float Sound::GetVolume() const
{
KGE_ASSERT(voice_ != nullptr && "IXAudio2SourceVoice* is NULL");
float volume = 0.0f;
voice_->GetVolume(&volume);
return volume;
}
}
void Sound::SetVolume(float volume)
{
void Sound::SetVolume(float volume)
{
KGE_ASSERT(voice_ != nullptr && "IXAudio2SourceVoice* is NULL");
volume = std::min(std::max(volume, -224.f), 224.f);
voice_->SetVolume(volume);
}
}
}
} // namespace audio
} // namespace kiwano

48
src/kiwano-audio/Sound.h
View File

@ -19,35 +19,34 @@
// THE SOFTWARE.
#pragma once
#include <kiwano-audio/Transcoder.h>
#include <kiwano/core/ObjectBase.h>
#include <kiwano/core/Resource.h>
#include <kiwano/platform/win32/ComPtr.hpp>
#include <kiwano-audio/Transcoder.h>
#include <xaudio2.h>
namespace kiwano
{
namespace audio
{
class AudioEngine;
namespace audio
{
class AudioEngine;
KGE_DECLARE_SMART_PTR(Sound);
KGE_DECLARE_SMART_PTR(Sound);
/**
/**
* \addtogroup Audio
* @{
*/
/**
/**
* \~chinese
* @brief 音频
*/
class KGE_API Sound
: public virtual ObjectBase
{
class KGE_API Sound : public virtual ObjectBase
{
friend class AudioEngine;
public:
public:
Sound();
virtual ~Sound();
@ -100,29 +99,28 @@ namespace kiwano
/// @param volume 音量大小，1.0 为原始音量, 大于 1 为放大音量, 0 为最小音量
void SetVolume(float volume);
private:
private:
IXAudio2SourceVoice* GetXAudio2Voice() const;
void SetXAudio2Voice(IXAudio2SourceVoice* voice);
private:
private:
bool opened_;
bool playing_;
Transcoder transcoder_;
IXAudio2SourceVoice* voice_;
};
};
/** @} */
/** @} */
inline IXAudio2SourceVoice* Sound::GetXAudio2Voice() const
{
inline IXAudio2SourceVoice* Sound::GetXAudio2Voice() const
{
return voice_;
}
inline void Sound::SetXAudio2Voice(IXAudio2SourceVoice* voice)
{
voice_ = voice;
}
}
}
inline void Sound::SetXAudio2Voice(IXAudio2SourceVoice* voice)
{
voice_ = voice;
}
} // namespace audio
} // namespace kiwano

100
src/kiwano-audio/SoundPlayer.cpp
View File

@ -22,20 +22,20 @@
namespace kiwano
{
namespace audio
{
SoundPlayer::SoundPlayer()
namespace audio
{
SoundPlayer::SoundPlayer()
: volume_(1.f)
{
}
{
}
SoundPlayer::~SoundPlayer()
{
SoundPlayer::~SoundPlayer()
{
ClearCache();
}
}
size_t SoundPlayer::Load(String const& file_path)
{
size_t SoundPlayer::Load(String const& file_path)
{
int hash_code = static_cast<int>(file_path.hash());
if (sound_cache_.end() != sound_cache_.find(hash_code))
return hash_code;
@ -52,10 +52,10 @@ namespace kiwano
}
}
return 0;
}
}
size_t SoundPlayer::Load(Resource const& res)
{
size_t SoundPlayer::Load(Resource const& res)
{
size_t hash_code = static_cast<size_t>(res.GetId());
if (sound_cache_.end() != sound_cache_.find(hash_code))
return hash_code;
@ -72,85 +72,85 @@ namespace kiwano
}
}
return 0;
}
}
void SoundPlayer::Play(size_t id, int loop_count)
{
void SoundPlayer::Play(size_t id, int loop_count)
{
auto iter = sound_cache_.find(id);
if (sound_cache_.end() != iter)
iter->second->Play(loop_count);
}
}
void SoundPlayer::Pause(size_t id)
{
void SoundPlayer::Pause(size_t id)
{
auto iter = sound_cache_.find(id);
if (sound_cache_.end() != iter)
iter->second->Pause();
}
}
void SoundPlayer::Resume(size_t id)
{
void SoundPlayer::Resume(size_t id)
{
auto iter = sound_cache_.find(id);
if (sound_cache_.end() != iter)
iter->second->Resume();
}
}
void SoundPlayer::Stop(size_t id)
{
void SoundPlayer::Stop(size_t id)
{
auto iter = sound_cache_.find(id);
if (sound_cache_.end() != iter)
iter->second->Stop();
}
}
bool SoundPlayer::IsPlaying(size_t id)
{
bool SoundPlayer::IsPlaying(size_t id)
{
auto iter = sound_cache_.find(id);
if (sound_cache_.end() != iter)
return iter->second->IsPlaying();
return false;
}
}
float SoundPlayer::GetVolume() const
{
float SoundPlayer::GetVolume() const
{
return volume_;
}
}
void SoundPlayer::SetVolume(float volume)
{
void SoundPlayer::SetVolume(float volume)
{
volume_ = std::min(std::max(volume, -224.f), 224.f);
for (auto& pair : sound_cache_)
{
pair.second->SetVolume(volume_);
}
}
}
void SoundPlayer::PauseAll()
{
void SoundPlayer::PauseAll()
{
for (auto& pair : sound_cache_)
{
pair.second->Pause();
}
}
}
void SoundPlayer::ResumeAll()
{
void SoundPlayer::ResumeAll()
{
for (auto& pair : sound_cache_)
{
pair.second->Resume();
}
}
}
void SoundPlayer::StopAll()
{
void SoundPlayer::StopAll()
{
for (auto& pair : sound_cache_)
{
pair.second->Stop();
}
}
void SoundPlayer::ClearCache()
{
sound_cache_.clear();
}
}
}
void SoundPlayer::ClearCache()
{
sound_cache_.clear();
}
} // namespace audio
} // namespace kiwano

29
src/kiwano-audio/SoundPlayer.h
View File

@ -19,28 +19,27 @@
// THE SOFTWARE.
#pragma once
#include <kiwano/core/ObjectBase.h>
#include <kiwano-audio/Sound.h>
#include <kiwano/core/ObjectBase.h>
namespace kiwano
{
namespace audio
{
KGE_DECLARE_SMART_PTR(SoundPlayer);
namespace audio
{
KGE_DECLARE_SMART_PTR(SoundPlayer);
/**
/**
* \addtogroup Audio
* @{
*/
/**
/**
* \~chinese
* @brief 音频播放器
*/
class KGE_API SoundPlayer
: public virtual ObjectBase
{
public:
class KGE_API SoundPlayer : public virtual ObjectBase
{
public:
SoundPlayer();
~SoundPlayer();
@ -108,13 +107,13 @@ namespace kiwano
/// @brief 清除缓存
void ClearCache();
private:
private:
float volume_;
using SoundMap = Map<size_t, SoundPtr>;
SoundMap sound_cache_;
};
};
/** @} */
}
}
/** @} */
} // namespace audio
} // namespace kiwano

144
src/kiwano-audio/Transcoder.cpp
View File

@ -19,42 +19,42 @@
// THE SOFTWARE.
#ifndef INITGUID
# define INITGUID // MFAudioFormat_PCM, MF_MT_MAJOR_TYPE, MF_MT_SUBTYPE, MFMediaType_Audio
#define INITGUID // MFAudioFormat_PCM, MF_MT_MAJOR_TYPE, MF_MT_SUBTYPE, MFMediaType_Audio
#endif
#include <kiwano/macros.h>
#include <kiwano-audio/Transcoder.h>
#include <kiwano-audio/libraries.h>
#include <kiwano/core/Common.h>
#include <kiwano/core/Resource.h>
#include <kiwano/core/Logger.h>
#include <kiwano/core/Resource.h>
#include <kiwano/macros.h>
#include <kiwano/platform/win32/ComPtr.hpp>
#include <kiwano/platform/win32/libraries.h>
#include <kiwano-audio/libraries.h>
#include <kiwano-audio/Transcoder.h>
namespace kiwano
{
namespace audio
{
namespace audio
{
Transcoder::Transcoder()
Transcoder::Transcoder()
: wave_format_(nullptr)
, wave_data_(nullptr)
, wave_size_(0)
{
}
{
}
Transcoder::~Transcoder()
{
Transcoder::~Transcoder()
{
ClearBuffer();
}
}
Transcoder::Buffer Transcoder::GetBuffer() const
{
Transcoder::Buffer Transcoder::GetBuffer() const
{
return Buffer{ wave_data_, wave_size_, wave_format_ };
}
}
void Transcoder::ClearBuffer()
{
void Transcoder::ClearBuffer()
{
if (wave_format_)
{
::CoTaskMemFree(wave_format_);
@ -68,19 +68,15 @@ namespace kiwano
}
wave_size_ = 0;
}
}
HRESULT Transcoder::LoadMediaFile(String const& file_path)
{
HRESULT Transcoder::LoadMediaFile(String const& file_path)
{
HRESULT hr = S_OK;
ComPtr<IMFSourceReader> reader;
hr = dlls::MediaFoundation::Get().MFCreateSourceReaderFromURL(
file_path.c_str(),
nullptr,
&reader
);
hr = dlls::MediaFoundation::Get().MFCreateSourceReaderFromURL(file_path.c_str(), nullptr, &reader);
if (SUCCEEDED(hr))
{
@ -88,10 +84,10 @@ namespace kiwano
}
return hr;
}
}
HRESULT Transcoder::LoadMediaResource(Resource const& res)
{
HRESULT Transcoder::LoadMediaResource(Resource const& res)
{
HRESULT hr = S_OK;
ComPtr<IStream> stream;
@ -99,12 +95,13 @@ namespace kiwano
ComPtr<IMFSourceReader> reader;
Resource::Data data = res.GetData();
if (!data) { return E_FAIL; }
if (!data)
{
return E_FAIL;
}
stream = win32::dlls::Shlwapi::Get().SHCreateMemStream(
static_cast<const BYTE*>(data.buffer),
static_cast<uint32_t>(data.size)
);
stream = win32::dlls::Shlwapi::Get().SHCreateMemStream(static_cast<const BYTE*>(data.buffer),
static_cast<uint32_t>(data.size));
if (stream == nullptr)
{
@ -119,11 +116,7 @@ namespace kiwano
if (SUCCEEDED(hr))
{
hr = dlls::MediaFoundation::Get().MFCreateSourceReaderFromByteStream(
byte_stream.get(),
nullptr,
&reader
);
hr = dlls::MediaFoundation::Get().MFCreateSourceReaderFromByteStream(byte_stream.get(), nullptr, &reader);
}
if (SUCCEEDED(hr))
@ -132,10 +125,10 @@ namespace kiwano
}
return hr;
}
}
HRESULT Transcoder::ReadSource(IMFSourceReader* reader)
{
HRESULT Transcoder::ReadSource(IMFSourceReader* reader)
{
HRESULT hr = S_OK;
DWORD max_stream_size = 0;
@ -157,29 +150,19 @@ namespace kiwano
// 设置 source reader 的媒体类型，它将使用合适的解码器去解码这个音频
if (SUCCEEDED(hr))
{
hr = reader->SetCurrentMediaType(
(DWORD)MF_SOURCE_READER_FIRST_AUDIO_STREAM,
0,
partial_type.get()
);
hr = reader->SetCurrentMediaType((DWORD)MF_SOURCE_READER_FIRST_AUDIO_STREAM, 0, partial_type.get());
}
// 从 IMFMediaType 中获取 WAVEFORMAT 结构
if (SUCCEEDED(hr))
{
hr = reader->GetCurrentMediaType(
(DWORD)MF_SOURCE_READER_FIRST_AUDIO_STREAM,
&uncompressed_type
);
hr = reader->GetCurrentMediaType((DWORD)MF_SOURCE_READER_FIRST_AUDIO_STREAM, &uncompressed_type);
}
// 指定音频流
if (SUCCEEDED(hr))
{
hr = reader->SetStreamSelection(
(DWORD)MF_SOURCE_READER_FIRST_AUDIO_STREAM,
true
);
hr = reader->SetStreamSelection((DWORD)MF_SOURCE_READER_FIRST_AUDIO_STREAM, true);
}
// 获取 WAVEFORMAT 数据
@ -187,11 +170,7 @@ namespace kiwano
{
uint32_t size = 0;
hr = dlls::MediaFoundation::Get().MFCreateWaveFormatExFromMFMediaType(
uncompressed_type.get(),
&wave_format_,
&size,
(DWORD)MFWaveFormatExConvertFlag_Normal
);
uncompressed_type.get(), &wave_format_, &size, (DWORD)MFWaveFormatExConvertFlag_Normal);
}
// 估算音频流大小
@ -200,16 +179,10 @@ namespace kiwano
PROPVARIANT prop;
PropVariantInit(&prop);
hr = reader->GetPresentationAttribute(
(DWORD)MF_SOURCE_READER_MEDIASOURCE,
MF_PD_DURATION,
&prop
);
hr = reader->GetPresentationAttribute((DWORD)MF_SOURCE_READER_MEDIASOURCE, MF_PD_DURATION, &prop);
LONGLONG duration = prop.uhVal.QuadPart;
max_stream_size = static_cast<DWORD>(
(duration * wave_format_->nAvgBytesPerSec) / 10000000 + 1
);
max_stream_size = static_cast<DWORD>((duration * wave_format_->nAvgBytesPerSec) / 10000000 + 1);
PropVariantClear(&prop);
}
@ -232,18 +205,18 @@ namespace kiwano
{
while (true)
{
hr = reader->ReadSample(
(DWORD)MF_SOURCE_READER_FIRST_AUDIO_STREAM,
0,
nullptr,
&flags,
nullptr,
&sample
);
hr = reader->ReadSample((DWORD)MF_SOURCE_READER_FIRST_AUDIO_STREAM, 0, nullptr, &flags, nullptr,
&sample);
if (flags & MF_SOURCE_READERF_ENDOFSTREAM) { break; }
if (flags & MF_SOURCE_READERF_ENDOFSTREAM)
{
break;
}
if (sample == nullptr) { continue; }
if (sample == nullptr)
{
continue;
}
if (SUCCEEDED(hr))
{
@ -254,11 +227,7 @@ namespace kiwano
BYTE* audio_data = nullptr;
DWORD sample_buffer_length = 0;
hr = buffer->Lock(
&audio_data,
nullptr,
&sample_buffer_length
);
hr = buffer->Lock(&audio_data, nullptr, &sample_buffer_length);
if (position + sample_buffer_length >= max_stream_size)
{
@ -276,7 +245,10 @@ namespace kiwano
}
sample = nullptr;
if (FAILED(hr)) { break; }
if (FAILED(hr))
{
break;
}
}
if (SUCCEEDED(hr))
@ -293,6 +265,6 @@ namespace kiwano
}
return hr;
}
}
}
} // namespace audio
} // namespace kiwano

28
src/kiwano-audio/Transcoder.h
View File

@ -26,24 +26,24 @@
namespace kiwano
{
namespace audio
{
class Sound;
namespace audio
{
class Sound;
/**
/**
* \addtogroup Audio
* @{
*/
/**
/**
* \~chinese
* @brief 音频解码器
*/
class KGE_API Transcoder
{
class KGE_API Transcoder
{
friend class Sound;
public:
public:
/**
* \~chinese
* @brief 音频数据缓冲
@ -67,7 +67,7 @@ namespace kiwano
/// @brief 清空数据缓冲
void ClearBuffer();
private:
private:
/// \~chinese
/// @brief 解码本地音频文件
HRESULT LoadMediaFile(String const& file_path);
@ -80,12 +80,12 @@ namespace kiwano
/// @brief 读取音频源数据
HRESULT ReadSource(IMFSourceReader* reader);
private:
private:
BYTE* wave_data_;
uint32_t wave_size_;
WAVEFORMATEX* wave_format_;
};
};
/** @} */
}
}
/** @} */
} // namespace audio
} // namespace kiwano

41
src/kiwano-audio/libraries.cpp
View File

@ -18,21 +18,20 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include <kiwano/core/Logger.h>
#include <kiwano-audio/libraries.h>
#include <kiwano/core/Logger.h>
namespace kiwano
{
namespace audio
{
namespace dlls
{
XAudio2::XAudio2()
namespace audio
{
namespace dlls
{
XAudio2::XAudio2()
: xaudio2()
, XAudio2Create(nullptr)
{
const auto xaudio2_dll_names =
{
{
const auto xaudio2_dll_names = {
"xaudio2_9.dll", // for Windows 10
"xaudio2_8.dll", // for Windows 8
"xaudio2_7.dll" // for DirectX SDK
@ -55,9 +54,9 @@ namespace kiwano
KGE_ERROR(L"Load xaudio2.dll failed");
throw std::runtime_error("Load xaudio2.dll failed");
}
}
}
MediaFoundation::MediaFoundation()
MediaFoundation::MediaFoundation()
: mfplat()
, mfreadwrite()
, MFStartup(nullptr)
@ -67,14 +66,16 @@ namespace kiwano
, MFCreateSourceReaderFromURL(nullptr)
, MFCreateSourceReaderFromByteStream(nullptr)
, MFCreateMFByteStreamOnStream(nullptr)
{
{
if (mfplat.Load("Mfplat.dll"))
{
MFStartup = mfplat.GetProcess<PFN_MFStartup>("MFStartup");
MFShutdown = mfplat.GetProcess<PFN_MFShutdown>("MFShutdown");
MFCreateMediaType = mfplat.GetProcess<PFN_MFCreateMediaType>("MFCreateMediaType");
MFCreateWaveFormatExFromMFMediaType = mfplat.GetProcess<PFN_MFCreateWaveFormatExFromMFMediaType>("MFCreateWaveFormatExFromMFMediaType");
MFCreateMFByteStreamOnStream = mfplat.GetProcess<PFN_MFCreateMFByteStreamOnStream>("MFCreateMFByteStreamOnStream");
MFCreateWaveFormatExFromMFMediaType =
mfplat.GetProcess<PFN_MFCreateWaveFormatExFromMFMediaType>("MFCreateWaveFormatExFromMFMediaType");
MFCreateMFByteStreamOnStream =
mfplat.GetProcess<PFN_MFCreateMFByteStreamOnStream>("MFCreateMFByteStreamOnStream");
}
else
{
@ -84,15 +85,17 @@ namespace kiwano
if (mfreadwrite.Load("Mfreadwrite.dll"))
{
MFCreateSourceReaderFromURL = mfreadwrite.GetProcess<PFN_MFCreateSourceReaderFromURL>("MFCreateSourceReaderFromURL");
MFCreateSourceReaderFromByteStream = mfreadwrite.GetProcess<PFN_MFCreateSourceReaderFromByteStream>("MFCreateSourceReaderFromByteStream");
MFCreateSourceReaderFromURL =
mfreadwrite.GetProcess<PFN_MFCreateSourceReaderFromURL>("MFCreateSourceReaderFromURL");
MFCreateSourceReaderFromByteStream =
mfreadwrite.GetProcess<PFN_MFCreateSourceReaderFromByteStream>("MFCreateSourceReaderFromByteStream");
}
else
{
KGE_ERROR(L"Load Mfreadwrite.dll failed");
throw std::runtime_error("Load Mfreadwrite.dll failed");
}
}
}
}
}
} // namespace dlls
} // namespace audio
} // namespace kiwano

37
src/kiwano-audio/libraries.h
View File

@ -20,22 +20,22 @@
#pragma once
#include <kiwano/core/Library.h>
#include <xaudio2.h>
#include <mfapi.h>
#include <mfidl.h>
#include <mfreadwrite.h>
#include <xaudio2.h>
#ifndef KGE_DOXYGEN_DO_NOT_INCLUDE
namespace kiwano
{
namespace audio
{
namespace dlls
{
class KGE_API XAudio2
{
public:
namespace audio
{
namespace dlls
{
class KGE_API XAudio2
{
public:
static inline XAudio2& Get()
{
static XAudio2 instance;
@ -47,19 +47,18 @@ namespace kiwano
PFN_XAudio2Create XAudio2Create;
private:
private:
XAudio2();
XAudio2(const XAudio2&) = delete;
XAudio2& operator=(const XAudio2&) = delete;
Library xaudio2;
};
};
class KGE_API MediaFoundation
{
public:
class KGE_API MediaFoundation
{
public:
static inline MediaFoundation& Get()
{
static MediaFoundation instance;
@ -83,7 +82,7 @@ namespace kiwano
PFN_MFCreateSourceReaderFromByteStream MFCreateSourceReaderFromByteStream;
PFN_MFCreateMFByteStreamOnStream MFCreateMFByteStreamOnStream;
private:
private:
MediaFoundation();
MediaFoundation(const MediaFoundation&) = delete;
@ -91,9 +90,9 @@ namespace kiwano
Library mfplat;
Library mfreadwrite;
};
}
}
}
};
} // namespace dlls
} // namespace audio
} // namespace kiwano
#endif

50
src/kiwano-imgui/ImGuiLayer.cpp
View File

@ -22,47 +22,45 @@
namespace kiwano
{
namespace imgui
{
ImGuiLayer::ImGuiLayer()
{
namespace imgui
{
ImGuiLayer::ImGuiLayer()
{
SetSwallowEvents(true);
}
}
ImGuiLayer::~ImGuiLayer()
{
}
ImGuiLayer::~ImGuiLayer() {}
void ImGuiLayer::OnRender(RenderContext& ctx)
{
void ImGuiLayer::OnRender(RenderContext& ctx)
{
for (const auto& pipeline : pipelines_)
{
pipeline.second();
}
}
}
bool ImGuiLayer::CheckVisibility(RenderContext& ctx) const
{
bool ImGuiLayer::CheckVisibility(RenderContext& ctx) const
{
return true;
}
}
void ImGuiLayer::AddItem(String const& name, ImGuiPipeline const& item)
{
void ImGuiLayer::AddItem(String const& name, ImGuiPipeline const& item)
{
pipelines_.insert(std::make_pair(name, item));
}
}
void ImGuiLayer::RemoveItem(String const& name)
{
void ImGuiLayer::RemoveItem(String const& name)
{
auto iter = pipelines_.find(name);
if (iter != pipelines_.end())
{
pipelines_.erase(iter);
}
}
void ImGuiLayer::RemoveAllItems()
{
pipelines_.clear();
}
}
}
void ImGuiLayer::RemoveAllItems()
{
pipelines_.clear();
}
} // namespace imgui
} // namespace kiwano

31
src/kiwano-imgui/ImGuiLayer.h
View File

@ -23,22 +23,21 @@
namespace kiwano
{
namespace imgui
{
KGE_DECLARE_SMART_PTR(ImGuiLayer);
namespace imgui
{
KGE_DECLARE_SMART_PTR(ImGuiLayer);
/// \~chinese
/// @brief ImGui¹ÜµÀ
using ImGuiPipeline = Function<void()>;
/// \~chinese
/// @brief ImGui¹ÜµÀ
using ImGuiPipeline = Function<void()>;
/**
/**
* \~chinese
* @brief ImGui图层
*/
class ImGuiLayer
: public Layer
{
public:
class ImGuiLayer : public Layer
{
public:
ImGuiLayer();
virtual ~ImGuiLayer();
@ -59,13 +58,13 @@ namespace kiwano
/// @brief 移除所有元素
void RemoveAllItems();
public:
public:
void OnRender(RenderContext& ctx) override;
bool CheckVisibility(RenderContext& ctx) const override;
private:
private:
Map<String, ImGuiPipeline> pipelines_;
};
}
}
};
} // namespace imgui
} // namespace kiwano

142
src/kiwano-imgui/ImGuiModule.cpp
View File

@ -1,29 +1,30 @@
// Copyright (C) 2019 Nomango
#include <kiwano-imgui/ImGuiModule.h>
#include <kiwano-imgui/imgui_impl.h>
#include <kiwano/core/Common.h>
#include <kiwano/core/event/KeyEvent.h>
#include <kiwano/core/event/MouseEvent.h>
#include <kiwano/platform/Window.h>
#include <kiwano/platform/Input.h>
#include <kiwano/platform/Window.h>
#include <kiwano/render/Renderer.h>
#include <kiwano-imgui/ImGuiModule.h>
#include <kiwano-imgui/imgui_impl.h>
namespace kiwano
{
namespace imgui
{
ImGuiModule::ImGuiModule()
namespace imgui
{
ImGuiModule::ImGuiModule()
: target_window_(nullptr)
{
}
{
}
void ImGuiModule::SetupComponent()
{
void ImGuiModule::SetupComponent()
{
// Setup Dear ImGui context
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO(); (void)io;
ImGuiIO& io = ImGui::GetIO();
(void)io;
// Setup Dear ImGui style
ImGui::StyleColorsDark();
@ -32,11 +33,13 @@ namespace kiwano
target_window_ = Renderer::Instance().GetTargetWindow();
io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors; // We can honor GetMouseCursor() values (optional)
io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos; // We can honor io.WantSetMousePos requests (optional, rarely used)
io.BackendFlags |=
ImGuiBackendFlags_HasSetMousePos; // We can honor io.WantSetMousePos requests (optional, rarely used)
io.BackendPlatformName = "imgui_impl_win32";
io.ImeWindowHandle = target_window_;
// Keyboard mapping. ImGui will use those indices to peek into the io.KeysDown[] array that we will update during the application lifetime.
// Keyboard mapping. ImGui will use those indices to peek into the io.KeysDown[] array that we will update during
// the application lifetime.
io.KeyMap[ImGuiKey_Tab] = (int)KeyCode::Tab;
io.KeyMap[ImGuiKey_LeftArrow] = (int)KeyCode::Left;
io.KeyMap[ImGuiKey_RightArrow] = (int)KeyCode::Right;
@ -55,16 +58,16 @@ namespace kiwano
io.KeyMap[ImGuiKey_Z] = (int)KeyCode::Z;
ImGui_Impl_Init(Renderer::Instance());
}
}
void ImGuiModule::DestroyComponent()
{
void ImGuiModule::DestroyComponent()
{
ImGui_Impl_Shutdown();
ImGui::DestroyContext();
}
}
void ImGuiModule::OnUpdate(Duration dt)
{
void ImGuiModule::OnUpdate(Duration dt)
{
ImGuiIO& io = ImGui::GetIO();
// Setup time step
@ -82,20 +85,20 @@ namespace kiwano
// Update OS mouse cursor with the cursor requested by imgui
UpdateMouseCursor();
}
}
void ImGuiModule::BeforeRender()
{
void ImGuiModule::BeforeRender()
{
NewFrame();
}
}
void ImGuiModule::AfterRender()
{
void ImGuiModule::AfterRender()
{
Render();
}
}
void ImGuiModule::HandleEvent(Event* evt)
{
void ImGuiModule::HandleEvent(Event* evt)
{
if (ImGui::GetCurrentContext() == NULL)
return;
@ -106,18 +109,24 @@ namespace kiwano
{
MouseButton button = dynamic_cast<MouseDownEvent*>(evt)->button;
int index = 0;
if (button == MouseButton::Left) index = 0;
else if (button == MouseButton::Right) index = 1;
else if (button == MouseButton::Middle) index = 2;
if (button == MouseButton::Left)
index = 0;
else if (button == MouseButton::Right)
index = 1;
else if (button == MouseButton::Middle)
index = 2;
io.MouseDown[index] = true;
}
else if (evt->IsType<MouseUpEvent>())
{
MouseButton button = dynamic_cast<MouseUpEvent*>(evt)->button;
int index = 0;
if (button == MouseButton::Left) index = 0;
else if (button == MouseButton::Right) index = 1;
else if (button == MouseButton::Middle) index = 2;
if (button == MouseButton::Left)
index = 0;
else if (button == MouseButton::Right)
index = 1;
else if (button == MouseButton::Middle)
index = 2;
io.MouseDown[index] = false;
}
else if (evt->IsType<MouseWheelEvent>())
@ -145,10 +154,10 @@ namespace kiwano
io.AddInputCharacter(static_cast<ImWchar>(ch));
}
}
}
}
void ImGuiModule::NewFrame()
{
void ImGuiModule::NewFrame()
{
ImGui_Impl_NewFrame();
ImGuiIO& io = ImGui::GetIO();
@ -159,20 +168,21 @@ namespace kiwano
io.DisplaySize = ImVec2(display_size.x, display_size.y);
ImGui::NewFrame();
}
}
void ImGuiModule::Render()
{
void ImGuiModule::Render()
{
ImGui::Render();
ImGui_Impl_RenderDrawData(ImGui::GetDrawData());
}
}
void ImGuiModule::UpdateMousePos()
{
void ImGuiModule::UpdateMousePos()
{
ImGuiIO& io = ImGui::GetIO();
// Set OS mouse position if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
// Set OS mouse position if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by
// user)
if (io.WantSetMousePos)
{
POINT pos = { (int)io.MousePos.x, (int)io.MousePos.y };
@ -182,28 +192,44 @@ namespace kiwano
Point pos = Input::Instance().GetMousePos();
io.MousePos = ImVec2(pos.x, pos.y);
}
}
void ImGuiModule::UpdateMouseCursor()
{
void ImGuiModule::UpdateMouseCursor()
{
if (ImGui::GetIO().ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange)
return;
CursorType cursor = CursorType::Arrow;
switch (ImGui::GetMouseCursor())
{
case ImGuiMouseCursor_Arrow: cursor = CursorType::Arrow; break;
case ImGuiMouseCursor_TextInput: cursor = CursorType::TextInput; break;
case ImGuiMouseCursor_ResizeAll: cursor = CursorType::SizeAll; break;
case ImGuiMouseCursor_ResizeEW: cursor = CursorType::SizeWE; break;
case ImGuiMouseCursor_ResizeNS: cursor = CursorType::SizeNS; break;
case ImGuiMouseCursor_ResizeNESW: cursor = CursorType::SizeNESW; break;
case ImGuiMouseCursor_ResizeNWSE: cursor = CursorType::SizeNWSE; break;
case ImGuiMouseCursor_Hand: cursor = CursorType::Hand; break;
case ImGuiMouseCursor_Arrow:
cursor = CursorType::Arrow;
break;
case ImGuiMouseCursor_TextInput:
cursor = CursorType::TextInput;
break;
case ImGuiMouseCursor_ResizeAll:
cursor = CursorType::SizeAll;
break;
case ImGuiMouseCursor_ResizeEW:
cursor = CursorType::SizeWE;
break;
case ImGuiMouseCursor_ResizeNS:
cursor = CursorType::SizeNS;
break;
case ImGuiMouseCursor_ResizeNESW:
cursor = CursorType::SizeNESW;
break;
case ImGuiMouseCursor_ResizeNWSE:
cursor = CursorType::SizeNWSE;
break;
case ImGuiMouseCursor_Hand:
cursor = CursorType::Hand;
break;
}
Window::Instance().SetCursor(cursor);
}
}
}
} // namespace imgui
} // namespace kiwano

22
src/kiwano-imgui/ImGuiModule.h
View File

@ -24,21 +24,21 @@
namespace kiwano
{
namespace imgui
{
/**
namespace imgui
{
/**
* \~chinese
* @brief ImGuiÄ£¿é
*/
class ImGuiModule
class ImGuiModule
: public Singleton<ImGuiModule>
, public RenderComponent
, public UpdateComponent
, public EventComponent
{
{
friend Singleton<ImGuiModule>;
public:
public:
ImGuiModule();
void SetupComponent() override;
@ -53,7 +53,7 @@ namespace kiwano
void OnUpdate(Duration dt) override;
private:
private:
void NewFrame();
void Render();
@ -62,8 +62,8 @@ namespace kiwano
void UpdateMouseCursor();
private:
private:
WindowHandle target_window_;
};
}
}
};
} // namespace imgui
} // namespace kiwano

61
src/kiwano-imgui/imgui_impl.h
View File

@ -8,25 +8,62 @@
#include <kiwano-imgui/imgui_impl_dx11.h>
inline bool ImGui_Impl_Init(::kiwano::Renderer& renderer) { return ImGui_ImplDX11_Init(renderer.GetD3DDeviceResources()->GetDevice(), renderer.GetD3DDeviceResources()->GetDeviceContext()); }
inline void ImGui_Impl_Shutdown() { ImGui_ImplDX11_Shutdown(); }
inline void ImGui_Impl_NewFrame() { ImGui_ImplDX11_NewFrame(); }
inline void ImGui_Impl_RenderDrawData(ImDrawData* draw_data) { ImGui_ImplDX11_RenderDrawData(draw_data); }
inline bool ImGui_Impl_Init(::kiwano::Renderer& renderer)
{
return ImGui_ImplDX11_Init(renderer.GetD3DDeviceResources()->GetDevice(),
renderer.GetD3DDeviceResources()->GetDeviceContext());
}
inline void ImGui_Impl_Shutdown()
{
ImGui_ImplDX11_Shutdown();
}
inline void ImGui_Impl_NewFrame()
{
ImGui_ImplDX11_NewFrame();
}
inline void ImGui_Impl_RenderDrawData(ImDrawData* draw_data)
{
ImGui_ImplDX11_RenderDrawData(draw_data);
}
inline void ImGui_Impl_InvalidateDeviceObjects() { ImGui_ImplDX11_InvalidateDeviceObjects(); }
inline bool ImGui_Impl_CreateDeviceObjects() { return ImGui_ImplDX11_CreateDeviceObjects(); }
inline void ImGui_Impl_InvalidateDeviceObjects()
{
ImGui_ImplDX11_InvalidateDeviceObjects();
}
inline bool ImGui_Impl_CreateDeviceObjects()
{
return ImGui_ImplDX11_CreateDeviceObjects();
}
#else
#include <kiwano-imgui/imgui_impl_dx10.h>
inline bool ImGui_Impl_Init(::kiwano::Renderer& renderer) { return ImGui_ImplDX10_Init(renderer.GetD3DDeviceResources()->GetDevice()); }
inline void ImGui_Impl_Shutdown() { ImGui_ImplDX10_Shutdown(); }
inline void ImGui_Impl_NewFrame() { ImGui_ImplDX10_NewFrame(); }
inline void ImGui_Impl_RenderDrawData(ImDrawData* draw_data) { ImGui_ImplDX10_RenderDrawData(draw_data); }
inline bool ImGui_Impl_Init(::kiwano::Renderer& renderer)
{
return ImGui_ImplDX10_Init(renderer.GetD3DDeviceResources()->GetDevice());
}
inline void ImGui_Impl_Shutdown()
{
ImGui_ImplDX10_Shutdown();
}
inline void ImGui_Impl_NewFrame()
{
ImGui_ImplDX10_NewFrame();
}
inline void ImGui_Impl_RenderDrawData(ImDrawData* draw_data)
{
ImGui_ImplDX10_RenderDrawData(draw_data);
}
inline void ImGui_Impl_InvalidateDeviceObjects() { ImGui_ImplDX10_InvalidateDeviceObjects(); }
inline bool ImGui_Impl_CreateDeviceObjects() { return ImGui_ImplDX10_CreateDeviceObjects(); }
inline void ImGui_Impl_InvalidateDeviceObjects()
{
ImGui_ImplDX10_InvalidateDeviceObjects();
}
inline bool ImGui_Impl_CreateDeviceObjects()
{
return ImGui_ImplDX10_CreateDeviceObjects();
}
#endif

235
src/kiwano-imgui/imgui_impl_dx10.cpp
View File

@ -3,10 +3,10 @@
#include <kiwano-imgui/imgui_impl_dx10.h>
// DirectX
#include <stdio.h>
#include <d3d10_1.h>
#include <d3d10.h>
#include <d3d10_1.h>
#include <d3dcompiler.h>
#include <stdio.h>
#ifdef _MSC_VER
#pragma comment(lib, "d3dcompiler") // Automatically link with d3dcompiler.lib as we are using D3DCompile() below.
@ -24,7 +24,7 @@ static ID3D10Buffer* g_pVertexConstantBuffer = NULL;
static ID3D10Blob* g_pPixelShaderBlob = NULL;
static ID3D10PixelShader* g_pPixelShader = NULL;
static ID3D10SamplerState* g_pFontSampler = NULL;
static ID3D10ShaderResourceView*g_pFontTextureView = NULL;
static ID3D10ShaderResourceView* g_pFontTextureView = NULL;
static ID3D10RasterizerState* g_pRasterizerState = NULL;
static ID3D10BlendState* g_pBlendState = NULL;
static ID3D10DepthStencilState* g_pDepthStencilState = NULL;
@ -36,7 +36,8 @@ struct VERTEX_CONSTANT_BUFFER
};
// Render Function
// (this used to be set in io.RenderDrawListsFn and called by ImGui::Render(), but you can now call this directly from your main loop)
// (this used to be set in io.RenderDrawListsFn and called by ImGui::Render(), but you can now call this directly from
// your main loop)
void ImGui_ImplDX10_RenderDrawData(ImDrawData* draw_data)
{
ID3D10Device* ctx = g_pd3dDevice;
@ -44,7 +45,11 @@ void ImGui_ImplDX10_RenderDrawData(ImDrawData* draw_data)
// Create and grow vertex/index buffers if needed
if (!g_pVB || g_VertexBufferSize < draw_data->TotalVtxCount)
{
if (g_pVB) { g_pVB->Release(); g_pVB = NULL; }
if (g_pVB)
{
g_pVB->Release();
g_pVB = NULL;
}
g_VertexBufferSize = draw_data->TotalVtxCount + 5000;
D3D10_BUFFER_DESC desc;
memset(&desc, 0, sizeof(D3D10_BUFFER_DESC));
@ -59,7 +64,11 @@ void ImGui_ImplDX10_RenderDrawData(ImDrawData* draw_data)
if (!g_pIB || g_IndexBufferSize < draw_data->TotalIdxCount)
{
if (g_pIB) { g_pIB->Release(); g_pIB = NULL; }
if (g_pIB)
{
g_pIB->Release();
g_pIB = NULL;
}
g_IndexBufferSize = draw_data->TotalIdxCount + 10000;
D3D10_BUFFER_DESC desc;
memset(&desc, 0, sizeof(D3D10_BUFFER_DESC));
@ -88,7 +97,8 @@ void ImGui_ImplDX10_RenderDrawData(ImDrawData* draw_data)
g_pIB->Unmap();
// Setup orthographic projection matrix into our constant buffer
// Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right).
// Our visible imgui space lies from draw_data->DisplayPos (top left) to
// draw_data->DisplayPos+data_data->DisplaySize (bottom right).
{
void* mapped_resource;
if (g_pVertexConstantBuffer->Map(D3D10_MAP_WRITE_DISCARD, 0, &mapped_resource) != S_OK)
@ -98,18 +108,18 @@ void ImGui_ImplDX10_RenderDrawData(ImDrawData* draw_data)
float R = draw_data->DisplayPos.x + draw_data->DisplaySize.x;
float T = draw_data->DisplayPos.y;
float B = draw_data->DisplayPos.y + draw_data->DisplaySize.y;
float mvp[4][4] =
{
{ 2.0f/(R-L), 0.0f, 0.0f, 0.0f },
{ 0.0f, 2.0f/(T-B), 0.0f, 0.0f },
float mvp[4][4] = {
{ 2.0f / (R - L), 0.0f, 0.0f, 0.0f },
{ 0.0f, 2.0f / (T - B), 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.5f, 0.0f },
{ (R+L)/(L-R), (T+B)/(B-T), 0.5f, 1.0f },
{ (R + L) / (L - R), (T + B) / (B - T), 0.5f, 1.0f },
};
memcpy(&constant_buffer->mvp, mvp, sizeof(mvp));
g_pVertexConstantBuffer->Unmap();
}
// Backup DX state that will be modified to restore it afterwards (unfortunately this is very ugly looking and verbose. Close your eyes!)
// Backup DX state that will be modified to restore it afterwards (unfortunately this is very ugly looking and
// verbose. Close your eyes!)
struct BACKUP_DX10_STATE
{
UINT ScissorRectsCount, ViewportsCount;
@ -126,7 +136,7 @@ void ImGui_ImplDX10_RenderDrawData(ImDrawData* draw_data)
ID3D10PixelShader* PS;
ID3D10VertexShader* VS;
D3D10_PRIMITIVE_TOPOLOGY PrimitiveTopology;
ID3D10Buffer* IndexBuffer, *VertexBuffer, *VSConstantBuffer;
ID3D10Buffer * IndexBuffer, *VertexBuffer, *VSConstantBuffer;
UINT IndexBufferOffset, VertexBufferStride, VertexBufferOffset;
DXGI_FORMAT IndexBufferFormat;
ID3D10InputLayout* InputLayout;
@ -194,7 +204,8 @@ void ImGui_ImplDX10_RenderDrawData(ImDrawData* draw_data)
else
{
// Apply scissor/clipping rectangle
const D3D10_RECT r = { (LONG)(pcmd->ClipRect.x - pos.x), (LONG)(pcmd->ClipRect.y - pos.y), (LONG)(pcmd->ClipRect.z - pos.x), (LONG)(pcmd->ClipRect.w - pos.y)};
const D3D10_RECT r = { (LONG)(pcmd->ClipRect.x - pos.x), (LONG)(pcmd->ClipRect.y - pos.y),
(LONG)(pcmd->ClipRect.z - pos.x), (LONG)(pcmd->ClipRect.w - pos.y) };
ctx->RSSetScissorRects(1, &r);
// Bind texture, Draw
@ -210,18 +221,40 @@ void ImGui_ImplDX10_RenderDrawData(ImDrawData* draw_data)
// Restore modified DX state
ctx->RSSetScissorRects(old.ScissorRectsCount, old.ScissorRects);
ctx->RSSetViewports(old.ViewportsCount, old.Viewports);
ctx->RSSetState(old.RS); if (old.RS) old.RS->Release();
ctx->OMSetBlendState(old.BlendState, old.BlendFactor, old.SampleMask); if (old.BlendState) old.BlendState->Release();
ctx->OMSetDepthStencilState(old.DepthStencilState, old.StencilRef); if (old.DepthStencilState) old.DepthStencilState->Release();
ctx->PSSetShaderResources(0, 1, &old.PSShaderResource); if (old.PSShaderResource) old.PSShaderResource->Release();
ctx->PSSetSamplers(0, 1, &old.PSSampler); if (old.PSSampler) old.PSSampler->Release();
ctx->PSSetShader(old.PS); if (old.PS) old.PS->Release();
ctx->VSSetShader(old.VS); if (old.VS) old.VS->Release();
ctx->VSSetConstantBuffers(0, 1, &old.VSConstantBuffer); if (old.VSConstantBuffer) old.VSConstantBuffer->Release();
ctx->RSSetState(old.RS);
if (old.RS)
old.RS->Release();
ctx->OMSetBlendState(old.BlendState, old.BlendFactor, old.SampleMask);
if (old.BlendState)
old.BlendState->Release();
ctx->OMSetDepthStencilState(old.DepthStencilState, old.StencilRef);
if (old.DepthStencilState)
old.DepthStencilState->Release();
ctx->PSSetShaderResources(0, 1, &old.PSShaderResource);
if (old.PSShaderResource)
old.PSShaderResource->Release();
ctx->PSSetSamplers(0, 1, &old.PSSampler);
if (old.PSSampler)
old.PSSampler->Release();
ctx->PSSetShader(old.PS);
if (old.PS)
old.PS->Release();
ctx->VSSetShader(old.VS);
if (old.VS)
old.VS->Release();
ctx->VSSetConstantBuffers(0, 1, &old.VSConstantBuffer);
if (old.VSConstantBuffer)
old.VSConstantBuffer->Release();
ctx->IASetPrimitiveTopology(old.PrimitiveTopology);
ctx->IASetIndexBuffer(old.IndexBuffer, old.IndexBufferFormat, old.IndexBufferOffset); if (old.IndexBuffer) old.IndexBuffer->Release();
ctx->IASetVertexBuffers(0, 1, &old.VertexBuffer, &old.VertexBufferStride, &old.VertexBufferOffset); if (old.VertexBuffer) old.VertexBuffer->Release();
ctx->IASetInputLayout(old.InputLayout); if (old.InputLayout) old.InputLayout->Release();
ctx->IASetIndexBuffer(old.IndexBuffer, old.IndexBufferFormat, old.IndexBufferOffset);
if (old.IndexBuffer)
old.IndexBuffer->Release();
ctx->IASetVertexBuffers(0, 1, &old.VertexBuffer, &old.VertexBufferStride, &old.VertexBufferOffset);
if (old.VertexBuffer)
old.VertexBuffer->Release();
ctx->IASetInputLayout(old.InputLayout);
if (old.InputLayout)
old.InputLayout->Release();
}
static void ImGui_ImplDX10_CreateFontsTexture()
@ -246,7 +279,7 @@ static void ImGui_ImplDX10_CreateFontsTexture()
desc.BindFlags = D3D10_BIND_SHADER_RESOURCE;
desc.CPUAccessFlags = 0;
ID3D10Texture2D *pTexture = NULL;
ID3D10Texture2D* pTexture = NULL;
D3D10_SUBRESOURCE_DATA subResource;
subResource.pSysMem = pixels;
subResource.SysMemPitch = desc.Width * 4;
@ -290,16 +323,17 @@ bool ImGui_ImplDX10_CreateDeviceObjects()
if (g_pFontSampler)
ImGui_ImplDX10_InvalidateDeviceObjects();
// By using D3DCompile() from <d3dcompiler.h> / d3dcompiler.lib, we introduce a dependency to a given version of d3dcompiler_XX.dll (see D3DCOMPILER_DLL_A)
// If you would like to use this DX10 sample code but remove this dependency you can:
// 1) compile once, save the compiled shader blobs into a file or source code and pass them to CreateVertexShader()/CreatePixelShader() [preferred solution]
// 2) use code to detect any version of the DLL and grab a pointer to D3DCompile from the DLL.
// By using D3DCompile() from <d3dcompiler.h> / d3dcompiler.lib, we introduce a dependency to a given version of
// d3dcompiler_XX.dll (see D3DCOMPILER_DLL_A) If you would like to use this DX10 sample code but remove this
// dependency you can:
// 1) compile once, save the compiled shader blobs into a file or source code and pass them to
// CreateVertexShader()/CreatePixelShader() [preferred solution] 2) use code to detect any version of the DLL and
// grab a pointer to D3DCompile from the DLL.
// See https://github.com/ocornut/imgui/pull/638 for sources and details.
// Create the vertex shader
{
static const char* vertexShader =
"cbuffer vertexBuffer : register(b0) \
static const char* vertexShader = "cbuffer vertexBuffer : register(b0) \
{\
float4x4 ProjectionMatrix; \
};\
@ -326,20 +360,29 @@ bool ImGui_ImplDX10_CreateDeviceObjects()
return output;\
}";
D3DCompile(vertexShader, strlen(vertexShader), NULL, NULL, NULL, "main", "vs_4_0", 0, 0, &g_pVertexShaderBlob, NULL);
if (g_pVertexShaderBlob == NULL) // NB: Pass ID3D10Blob* pErrorBlob to D3DCompile() to get error showing in (const char*)pErrorBlob->GetBufferPointer(). Make sure to Release() the blob!
D3DCompile(vertexShader, strlen(vertexShader), NULL, NULL, NULL, "main", "vs_4_0", 0, 0, &g_pVertexShaderBlob,
NULL);
if (g_pVertexShaderBlob
== NULL) // NB: Pass ID3D10Blob* pErrorBlob to D3DCompile() to get error showing in (const
// char*)pErrorBlob->GetBufferPointer(). Make sure to Release() the blob!
return false;
if (g_pd3dDevice->CreateVertexShader((DWORD*)g_pVertexShaderBlob->GetBufferPointer(), g_pVertexShaderBlob->GetBufferSize(), &g_pVertexShader) != S_OK)
if (g_pd3dDevice->CreateVertexShader((DWORD*)g_pVertexShaderBlob->GetBufferPointer(),
g_pVertexShaderBlob->GetBufferSize(), &g_pVertexShader)
!= S_OK)
return false;
// Create the input layout
D3D10_INPUT_ELEMENT_DESC local_layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, (size_t)(&((ImDrawVert*)0)->pos), D3D10_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, (size_t)(&((ImDrawVert*)0)->uv), D3D10_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, (size_t)(&((ImDrawVert*)0)->col), D3D10_INPUT_PER_VERTEX_DATA, 0 },
D3D10_INPUT_ELEMENT_DESC local_layout[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, (size_t)(&((ImDrawVert*)0)->pos), D3D10_INPUT_PER_VERTEX_DATA,
0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, (size_t)(&((ImDrawVert*)0)->uv), D3D10_INPUT_PER_VERTEX_DATA,
0 },
{ "COLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, (size_t)(&((ImDrawVert*)0)->col), D3D10_INPUT_PER_VERTEX_DATA,
0 },
};
if (g_pd3dDevice->CreateInputLayout(local_layout, 3, g_pVertexShaderBlob->GetBufferPointer(), g_pVertexShaderBlob->GetBufferSize(), &g_pInputLayout) != S_OK)
if (g_pd3dDevice->CreateInputLayout(local_layout, 3, g_pVertexShaderBlob->GetBufferPointer(),
g_pVertexShaderBlob->GetBufferSize(), &g_pInputLayout)
!= S_OK)
return false;
// Create the constant buffer
@ -356,8 +399,7 @@ bool ImGui_ImplDX10_CreateDeviceObjects()
// Create the pixel shader
{
static const char* pixelShader =
"struct PS_INPUT\
static const char* pixelShader = "struct PS_INPUT\
{\
float4 pos : SV_POSITION;\
float4 col : COLOR0;\
@ -372,10 +414,15 @@ bool ImGui_ImplDX10_CreateDeviceObjects()
return out_col; \
}";
D3DCompile(pixelShader, strlen(pixelShader), NULL, NULL, NULL, "main", "ps_4_0", 0, 0, &g_pPixelShaderBlob, NULL);
if (g_pPixelShaderBlob == NULL) // NB: Pass ID3D10Blob* pErrorBlob to D3DCompile() to get error showing in (const char*)pErrorBlob->GetBufferPointer(). Make sure to Release() the blob!
D3DCompile(pixelShader, strlen(pixelShader), NULL, NULL, NULL, "main", "ps_4_0", 0, 0, &g_pPixelShaderBlob,
NULL);
if (g_pPixelShaderBlob
== NULL) // NB: Pass ID3D10Blob* pErrorBlob to D3DCompile() to get error showing in (const
// char*)pErrorBlob->GetBufferPointer(). Make sure to Release() the blob!
return false;
if (g_pd3dDevice->CreatePixelShader((DWORD*)g_pPixelShaderBlob->GetBufferPointer(), g_pPixelShaderBlob->GetBufferSize(), &g_pPixelShader) != S_OK)
if (g_pd3dDevice->CreatePixelShader((DWORD*)g_pPixelShaderBlob->GetBufferPointer(),
g_pPixelShaderBlob->GetBufferSize(), &g_pPixelShader)
!= S_OK)
return false;
}
@ -414,7 +461,8 @@ bool ImGui_ImplDX10_CreateDeviceObjects()
desc.DepthWriteMask = D3D10_DEPTH_WRITE_MASK_ALL;
desc.DepthFunc = D3D10_COMPARISON_ALWAYS;
desc.StencilEnable = false;
desc.FrontFace.StencilFailOp = desc.FrontFace.StencilDepthFailOp = desc.FrontFace.StencilPassOp = D3D10_STENCIL_OP_KEEP;
desc.FrontFace.StencilFailOp = desc.FrontFace.StencilDepthFailOp = desc.FrontFace.StencilPassOp =
D3D10_STENCIL_OP_KEEP;
desc.FrontFace.StencilFunc = D3D10_COMPARISON_ALWAYS;
desc.BackFace = desc.FrontFace;
g_pd3dDevice->CreateDepthStencilState(&desc, &g_pDepthStencilState);
@ -430,20 +478,73 @@ void ImGui_ImplDX10_InvalidateDeviceObjects()
if (!g_pd3dDevice)
return;
if (g_pFontSampler) { g_pFontSampler->Release(); g_pFontSampler = NULL; }
if (g_pFontTextureView) { g_pFontTextureView->Release(); g_pFontTextureView = NULL; ImGui::GetIO().Fonts->TexID = NULL; } // We copied g_pFontTextureView to io.Fonts->TexID so let's clear that as well.
if (g_pIB) { g_pIB->Release(); g_pIB = NULL; }
if (g_pVB) { g_pVB->Release(); g_pVB = NULL; }
if (g_pFontSampler)
{
g_pFontSampler->Release();
g_pFontSampler = NULL;
}
if (g_pFontTextureView)
{
g_pFontTextureView->Release();
g_pFontTextureView = NULL;
ImGui::GetIO().Fonts->TexID = NULL;
} // We copied g_pFontTextureView to io.Fonts->TexID so let's clear that as well.
if (g_pIB)
{
g_pIB->Release();
g_pIB = NULL;
}
if (g_pVB)
{
g_pVB->Release();
g_pVB = NULL;
}
if (g_pBlendState) { g_pBlendState->Release(); g_pBlendState = NULL; }
if (g_pDepthStencilState) { g_pDepthStencilState->Release(); g_pDepthStencilState = NULL; }
if (g_pRasterizerState) { g_pRasterizerState->Release(); g_pRasterizerState = NULL; }
if (g_pPixelShader) { g_pPixelShader->Release(); g_pPixelShader = NULL; }
if (g_pPixelShaderBlob) { g_pPixelShaderBlob->Release(); g_pPixelShaderBlob = NULL; }
if (g_pVertexConstantBuffer) { g_pVertexConstantBuffer->Release(); g_pVertexConstantBuffer = NULL; }
if (g_pInputLayout) { g_pInputLayout->Release(); g_pInputLayout = NULL; }
if (g_pVertexShader) { g_pVertexShader->Release(); g_pVertexShader = NULL; }
if (g_pVertexShaderBlob) { g_pVertexShaderBlob->Release(); g_pVertexShaderBlob = NULL; }
if (g_pBlendState)
{
g_pBlendState->Release();
g_pBlendState = NULL;
}
if (g_pDepthStencilState)
{
g_pDepthStencilState->Release();
g_pDepthStencilState = NULL;
}
if (g_pRasterizerState)
{
g_pRasterizerState->Release();
g_pRasterizerState = NULL;
}
if (g_pPixelShader)
{
g_pPixelShader->Release();
g_pPixelShader = NULL;
}
if (g_pPixelShaderBlob)
{
g_pPixelShaderBlob->Release();
g_pPixelShaderBlob = NULL;
}
if (g_pVertexConstantBuffer)
{
g_pVertexConstantBuffer->Release();
g_pVertexConstantBuffer = NULL;
}
if (g_pInputLayout)
{
g_pInputLayout->Release();
g_pInputLayout = NULL;
}
if (g_pVertexShader)
{
g_pVertexShader->Release();
g_pVertexShader = NULL;
}
if (g_pVertexShaderBlob)
{
g_pVertexShaderBlob->Release();
g_pVertexShaderBlob = NULL;
}
}
bool ImGui_ImplDX10_Init(ID3D10Device* device)
@ -463,8 +564,10 @@ bool ImGui_ImplDX10_Init(ID3D10Device* device)
g_pd3dDevice = device;
g_pFactory = pFactory;
}
if (pDXGIDevice) pDXGIDevice->Release();
if (pDXGIAdapter) pDXGIAdapter->Release();
if (pDXGIDevice)
pDXGIDevice->Release();
if (pDXGIAdapter)
pDXGIAdapter->Release();
return true;
}
@ -472,7 +575,11 @@ bool ImGui_ImplDX10_Init(ID3D10Device* device)
void ImGui_ImplDX10_Shutdown()
{
ImGui_ImplDX10_InvalidateDeviceObjects();
if (g_pFactory) { g_pFactory->Release(); g_pFactory = NULL; }
if (g_pFactory)
{
g_pFactory->Release();
g_pFactory = NULL;
}
g_pd3dDevice = NULL;
}

243
src/kiwano-imgui/imgui_impl_dx11.cpp
View File

@ -3,9 +3,9 @@
#include <kiwano-imgui/imgui_impl_dx11.h>
// DirectX
#include <stdio.h>
#include <d3d11.h>
#include <d3dcompiler.h>
#include <stdio.h>
#ifdef _MSC_VER
#pragma comment(lib, "d3dcompiler") // Automatically link with d3dcompiler.lib as we are using D3DCompile() below.
@ -24,7 +24,7 @@ static ID3D11Buffer* g_pVertexConstantBuffer = NULL;
static ID3D10Blob* g_pPixelShaderBlob = NULL;
static ID3D11PixelShader* g_pPixelShader = NULL;
static ID3D11SamplerState* g_pFontSampler = NULL;
static ID3D11ShaderResourceView*g_pFontTextureView = NULL;
static ID3D11ShaderResourceView* g_pFontTextureView = NULL;
static ID3D11RasterizerState* g_pRasterizerState = NULL;
static ID3D11BlendState* g_pBlendState = NULL;
static ID3D11DepthStencilState* g_pDepthStencilState = NULL;
@ -36,7 +36,8 @@ struct VERTEX_CONSTANT_BUFFER
};
// Render Function
// (this used to be set in io.RenderDrawListsFn and called by ImGui::Render(), but you can now call this directly from your main loop)
// (this used to be set in io.RenderDrawListsFn and called by ImGui::Render(), but you can now call this directly from
// your main loop)
void ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data)
{
ID3D11DeviceContext* ctx = g_pd3dDeviceContext;
@ -44,7 +45,11 @@ void ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data)
// Create and grow vertex/index buffers if needed
if (!g_pVB || g_VertexBufferSize < draw_data->TotalVtxCount)
{
if (g_pVB) { g_pVB->Release(); g_pVB = NULL; }
if (g_pVB)
{
g_pVB->Release();
g_pVB = NULL;
}
g_VertexBufferSize = draw_data->TotalVtxCount + 5000;
D3D11_BUFFER_DESC desc;
memset(&desc, 0, sizeof(D3D11_BUFFER_DESC));
@ -58,7 +63,11 @@ void ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data)
}
if (!g_pIB || g_IndexBufferSize < draw_data->TotalIdxCount)
{
if (g_pIB) { g_pIB->Release(); g_pIB = NULL; }
if (g_pIB)
{
g_pIB->Release();
g_pIB = NULL;
}
g_IndexBufferSize = draw_data->TotalIdxCount + 10000;
D3D11_BUFFER_DESC desc;
memset(&desc, 0, sizeof(D3D11_BUFFER_DESC));
@ -90,7 +99,8 @@ void ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data)
ctx->Unmap(g_pIB, 0);
// Setup orthographic projection matrix into our constant buffer
// Our visible imgui space lies from draw_data->DisplayPos (top left) to draw_data->DisplayPos+data_data->DisplaySize (bottom right).
// Our visible imgui space lies from draw_data->DisplayPos (top left) to
// draw_data->DisplayPos+data_data->DisplaySize (bottom right).
{
D3D11_MAPPED_SUBRESOURCE mapped_resource;
if (ctx->Map(g_pVertexConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_resource) != S_OK)
@ -100,18 +110,18 @@ void ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data)
float R = draw_data->DisplayPos.x + draw_data->DisplaySize.x;
float T = draw_data->DisplayPos.y;
float B = draw_data->DisplayPos.y + draw_data->DisplaySize.y;
float mvp[4][4] =
{
{ 2.0f/(R-L), 0.0f, 0.0f, 0.0f },
{ 0.0f, 2.0f/(T-B), 0.0f, 0.0f },
float mvp[4][4] = {
{ 2.0f / (R - L), 0.0f, 0.0f, 0.0f },
{ 0.0f, 2.0f / (T - B), 0.0f, 0.0f },
{ 0.0f, 0.0f, 0.5f, 0.0f },
{ (R+L)/(L-R), (T+B)/(B-T), 0.5f, 1.0f },
{ (R + L) / (L - R), (T + B) / (B - T), 0.5f, 1.0f },
};
memcpy(&constant_buffer->mvp, mvp, sizeof(mvp));
ctx->Unmap(g_pVertexConstantBuffer, 0);
}
// Backup DX state that will be modified to restore it afterwards (unfortunately this is very ugly looking and verbose. Close your eyes!)
// Backup DX state that will be modified to restore it afterwards (unfortunately this is very ugly looking and
// verbose. Close your eyes!)
struct BACKUP_DX11_STATE
{
UINT ScissorRectsCount, ViewportsCount;
@ -128,9 +138,9 @@ void ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data)
ID3D11PixelShader* PS;
ID3D11VertexShader* VS;
UINT PSInstancesCount, VSInstancesCount;
ID3D11ClassInstance* PSInstances[256], *VSInstances[256]; // 256 is max according to PSSetShader documentation
ID3D11ClassInstance *PSInstances[256], *VSInstances[256]; // 256 is max according to PSSetShader documentation
D3D11_PRIMITIVE_TOPOLOGY PrimitiveTopology;
ID3D11Buffer* IndexBuffer, *VertexBuffer, *VSConstantBuffer;
ID3D11Buffer * IndexBuffer, *VertexBuffer, *VSConstantBuffer;
UINT IndexBufferOffset, VertexBufferStride, VertexBufferOffset;
DXGI_FORMAT IndexBufferFormat;
ID3D11InputLayout* InputLayout;
@ -199,7 +209,8 @@ void ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data)
else
{
// Apply scissor/clipping rectangle
const D3D11_RECT r = { (LONG)(pcmd->ClipRect.x - pos.x), (LONG)(pcmd->ClipRect.y - pos.y), (LONG)(pcmd->ClipRect.z - pos.x), (LONG)(pcmd->ClipRect.w - pos.y) };
const D3D11_RECT r = { (LONG)(pcmd->ClipRect.x - pos.x), (LONG)(pcmd->ClipRect.y - pos.y),
(LONG)(pcmd->ClipRect.z - pos.x), (LONG)(pcmd->ClipRect.w - pos.y) };
ctx->RSSetScissorRects(1, &r);
// Bind texture, Draw
@ -215,20 +226,46 @@ void ImGui_ImplDX11_RenderDrawData(ImDrawData* draw_data)
// Restore modified DX state
ctx->RSSetScissorRects(old.ScissorRectsCount, old.ScissorRects);
ctx->RSSetViewports(old.ViewportsCount, old.Viewports);
ctx->RSSetState(old.RS); if (old.RS) old.RS->Release();
ctx->OMSetBlendState(old.BlendState, old.BlendFactor, old.SampleMask); if (old.BlendState) old.BlendState->Release();
ctx->OMSetDepthStencilState(old.DepthStencilState, old.StencilRef); if (old.DepthStencilState) old.DepthStencilState->Release();
ctx->PSSetShaderResources(0, 1, &old.PSShaderResource); if (old.PSShaderResource) old.PSShaderResource->Release();
ctx->PSSetSamplers(0, 1, &old.PSSampler); if (old.PSSampler) old.PSSampler->Release();
ctx->PSSetShader(old.PS, old.PSInstances, old.PSInstancesCount); if (old.PS) old.PS->Release();
for (UINT i = 0; i < old.PSInstancesCount; i++) if (old.PSInstances[i]) old.PSInstances[i]->Release();
ctx->VSSetShader(old.VS, old.VSInstances, old.VSInstancesCount); if (old.VS) old.VS->Release();
ctx->VSSetConstantBuffers(0, 1, &old.VSConstantBuffer); if (old.VSConstantBuffer) old.VSConstantBuffer->Release();
for (UINT i = 0; i < old.VSInstancesCount; i++) if (old.VSInstances[i]) old.VSInstances[i]->Release();
ctx->RSSetState(old.RS);
if (old.RS)
old.RS->Release();
ctx->OMSetBlendState(old.BlendState, old.BlendFactor, old.SampleMask);
if (old.BlendState)
old.BlendState->Release();
ctx->OMSetDepthStencilState(old.DepthStencilState, old.StencilRef);
if (old.DepthStencilState)
old.DepthStencilState->Release();
ctx->PSSetShaderResources(0, 1, &old.PSShaderResource);
if (old.PSShaderResource)
old.PSShaderResource->Release();
ctx->PSSetSamplers(0, 1, &old.PSSampler);
if (old.PSSampler)
old.PSSampler->Release();
ctx->PSSetShader(old.PS, old.PSInstances, old.PSInstancesCount);
if (old.PS)
old.PS->Release();
for (UINT i = 0; i < old.PSInstancesCount; i++)
if (old.PSInstances[i])
old.PSInstances[i]->Release();
ctx->VSSetShader(old.VS, old.VSInstances, old.VSInstancesCount);
if (old.VS)
old.VS->Release();
ctx->VSSetConstantBuffers(0, 1, &old.VSConstantBuffer);
if (old.VSConstantBuffer)
old.VSConstantBuffer->Release();
for (UINT i = 0; i < old.VSInstancesCount; i++)
if (old.VSInstances[i])
old.VSInstances[i]->Release();
ctx->IASetPrimitiveTopology(old.PrimitiveTopology);
ctx->IASetIndexBuffer(old.IndexBuffer, old.IndexBufferFormat, old.IndexBufferOffset); if (old.IndexBuffer) old.IndexBuffer->Release();
ctx->IASetVertexBuffers(0, 1, &old.VertexBuffer, &old.VertexBufferStride, &old.VertexBufferOffset); if (old.VertexBuffer) old.VertexBuffer->Release();
ctx->IASetInputLayout(old.InputLayout); if (old.InputLayout) old.InputLayout->Release();
ctx->IASetIndexBuffer(old.IndexBuffer, old.IndexBufferFormat, old.IndexBufferOffset);
if (old.IndexBuffer)
old.IndexBuffer->Release();
ctx->IASetVertexBuffers(0, 1, &old.VertexBuffer, &old.VertexBufferStride, &old.VertexBufferOffset);
if (old.VertexBuffer)
old.VertexBuffer->Release();
ctx->IASetInputLayout(old.InputLayout);
if (old.InputLayout)
old.InputLayout->Release();
}
static void ImGui_ImplDX11_CreateFontsTexture()
@ -253,7 +290,7 @@ static void ImGui_ImplDX11_CreateFontsTexture()
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
desc.CPUAccessFlags = 0;
ID3D11Texture2D *pTexture = NULL;
ID3D11Texture2D* pTexture = NULL;
D3D11_SUBRESOURCE_DATA subResource;
subResource.pSysMem = pixels;
subResource.SysMemPitch = desc.Width * 4;
@ -301,16 +338,17 @@ bool ImGui_ImplDX11_CreateDeviceObjects()
if (g_pFontSampler)
ImGui_ImplDX11_InvalidateDeviceObjects();
// By using D3DCompile() from <d3dcompiler.h> / d3dcompiler.lib, we introduce a dependency to a given version of d3dcompiler_XX.dll (see D3DCOMPILER_DLL_A)
// If you would like to use this DX11 sample code but remove this dependency you can:
// 1) compile once, save the compiled shader blobs into a file or source code and pass them to CreateVertexShader()/CreatePixelShader() [preferred solution]
// 2) use code to detect any version of the DLL and grab a pointer to D3DCompile from the DLL.
// By using D3DCompile() from <d3dcompiler.h> / d3dcompiler.lib, we introduce a dependency to a given version of
// d3dcompiler_XX.dll (see D3DCOMPILER_DLL_A) If you would like to use this DX11 sample code but remove this
// dependency you can:
// 1) compile once, save the compiled shader blobs into a file or source code and pass them to
// CreateVertexShader()/CreatePixelShader() [preferred solution] 2) use code to detect any version of the DLL and
// grab a pointer to D3DCompile from the DLL.
// See https://github.com/ocornut/imgui/pull/638 for sources and details.
// Create the vertex shader
{
static const char* vertexShader =
"cbuffer vertexBuffer : register(b0) \
static const char* vertexShader = "cbuffer vertexBuffer : register(b0) \
{\
float4x4 ProjectionMatrix; \
};\
@ -337,20 +375,29 @@ bool ImGui_ImplDX11_CreateDeviceObjects()
return output;\
}";
D3DCompile(vertexShader, strlen(vertexShader), NULL, NULL, NULL, "main", "vs_4_0", 0, 0, &g_pVertexShaderBlob, NULL);
if (g_pVertexShaderBlob == NULL) // NB: Pass ID3D10Blob* pErrorBlob to D3DCompile() to get error showing in (const char*)pErrorBlob->GetBufferPointer(). Make sure to Release() the blob!
D3DCompile(vertexShader, strlen(vertexShader), NULL, NULL, NULL, "main", "vs_4_0", 0, 0, &g_pVertexShaderBlob,
NULL);
if (g_pVertexShaderBlob
== NULL) // NB: Pass ID3D10Blob* pErrorBlob to D3DCompile() to get error showing in (const
// char*)pErrorBlob->GetBufferPointer(). Make sure to Release() the blob!
return false;
if (g_pd3dDevice->CreateVertexShader((DWORD*)g_pVertexShaderBlob->GetBufferPointer(), g_pVertexShaderBlob->GetBufferSize(), NULL, &g_pVertexShader) != S_OK)
if (g_pd3dDevice->CreateVertexShader((DWORD*)g_pVertexShaderBlob->GetBufferPointer(),
g_pVertexShaderBlob->GetBufferSize(), NULL, &g_pVertexShader)
!= S_OK)
return false;
// Create the input layout
D3D11_INPUT_ELEMENT_DESC local_layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, (size_t)(&((ImDrawVert*)0)->pos), D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, (size_t)(&((ImDrawVert*)0)->uv), D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, (size_t)(&((ImDrawVert*)0)->col), D3D11_INPUT_PER_VERTEX_DATA, 0 },
D3D11_INPUT_ELEMENT_DESC local_layout[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, (size_t)(&((ImDrawVert*)0)->pos), D3D11_INPUT_PER_VERTEX_DATA,
0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, (size_t)(&((ImDrawVert*)0)->uv), D3D11_INPUT_PER_VERTEX_DATA,
0 },
{ "COLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, (size_t)(&((ImDrawVert*)0)->col), D3D11_INPUT_PER_VERTEX_DATA,
0 },
};
if (g_pd3dDevice->CreateInputLayout(local_layout, 3, g_pVertexShaderBlob->GetBufferPointer(), g_pVertexShaderBlob->GetBufferSize(), &g_pInputLayout) != S_OK)
if (g_pd3dDevice->CreateInputLayout(local_layout, 3, g_pVertexShaderBlob->GetBufferPointer(),
g_pVertexShaderBlob->GetBufferSize(), &g_pInputLayout)
!= S_OK)
return false;
// Create the constant buffer
@ -367,8 +414,7 @@ bool ImGui_ImplDX11_CreateDeviceObjects()
// Create the pixel shader
{
static const char* pixelShader =
"struct PS_INPUT\
static const char* pixelShader = "struct PS_INPUT\
{\
float4 pos : SV_POSITION;\
float4 col : COLOR0;\
@ -383,10 +429,15 @@ bool ImGui_ImplDX11_CreateDeviceObjects()
return out_col; \
}";
D3DCompile(pixelShader, strlen(pixelShader), NULL, NULL, NULL, "main", "ps_4_0", 0, 0, &g_pPixelShaderBlob, NULL);
if (g_pPixelShaderBlob == NULL) // NB: Pass ID3D10Blob* pErrorBlob to D3DCompile() to get error showing in (const char*)pErrorBlob->GetBufferPointer(). Make sure to Release() the blob!
D3DCompile(pixelShader, strlen(pixelShader), NULL, NULL, NULL, "main", "ps_4_0", 0, 0, &g_pPixelShaderBlob,
NULL);
if (g_pPixelShaderBlob
== NULL) // NB: Pass ID3D10Blob* pErrorBlob to D3DCompile() to get error showing in (const
// char*)pErrorBlob->GetBufferPointer(). Make sure to Release() the blob!
return false;
if (g_pd3dDevice->CreatePixelShader((DWORD*)g_pPixelShaderBlob->GetBufferPointer(), g_pPixelShaderBlob->GetBufferSize(), NULL, &g_pPixelShader) != S_OK)
if (g_pd3dDevice->CreatePixelShader((DWORD*)g_pPixelShaderBlob->GetBufferPointer(),
g_pPixelShaderBlob->GetBufferSize(), NULL, &g_pPixelShader)
!= S_OK)
return false;
}
@ -425,7 +476,8 @@ bool ImGui_ImplDX11_CreateDeviceObjects()
desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
desc.DepthFunc = D3D11_COMPARISON_ALWAYS;
desc.StencilEnable = false;
desc.FrontFace.StencilFailOp = desc.FrontFace.StencilDepthFailOp = desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
desc.FrontFace.StencilFailOp = desc.FrontFace.StencilDepthFailOp = desc.FrontFace.StencilPassOp =
D3D11_STENCIL_OP_KEEP;
desc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
desc.BackFace = desc.FrontFace;
g_pd3dDevice->CreateDepthStencilState(&desc, &g_pDepthStencilState);
@ -441,20 +493,73 @@ void ImGui_ImplDX11_InvalidateDeviceObjects()
if (!g_pd3dDevice)
return;
if (g_pFontSampler) { g_pFontSampler->Release(); g_pFontSampler = NULL; }
if (g_pFontTextureView) { g_pFontTextureView->Release(); g_pFontTextureView = NULL; ImGui::GetIO().Fonts->TexID = NULL; } // We copied g_pFontTextureView to io.Fonts->TexID so let's clear that as well.
if (g_pIB) { g_pIB->Release(); g_pIB = NULL; }
if (g_pVB) { g_pVB->Release(); g_pVB = NULL; }
if (g_pFontSampler)
{
g_pFontSampler->Release();
g_pFontSampler = NULL;
}
if (g_pFontTextureView)
{
g_pFontTextureView->Release();
g_pFontTextureView = NULL;
ImGui::GetIO().Fonts->TexID = NULL;
} // We copied g_pFontTextureView to io.Fonts->TexID so let's clear that as well.
if (g_pIB)
{
g_pIB->Release();
g_pIB = NULL;
}
if (g_pVB)
{
g_pVB->Release();
g_pVB = NULL;
}
if (g_pBlendState) { g_pBlendState->Release(); g_pBlendState = NULL; }
if (g_pDepthStencilState) { g_pDepthStencilState->Release(); g_pDepthStencilState = NULL; }
if (g_pRasterizerState) { g_pRasterizerState->Release(); g_pRasterizerState = NULL; }
if (g_pPixelShader) { g_pPixelShader->Release(); g_pPixelShader = NULL; }
if (g_pPixelShaderBlob) { g_pPixelShaderBlob->Release(); g_pPixelShaderBlob = NULL; }
if (g_pVertexConstantBuffer) { g_pVertexConstantBuffer->Release(); g_pVertexConstantBuffer = NULL; }
if (g_pInputLayout) { g_pInputLayout->Release(); g_pInputLayout = NULL; }
if (g_pVertexShader) { g_pVertexShader->Release(); g_pVertexShader = NULL; }
if (g_pVertexShaderBlob) { g_pVertexShaderBlob->Release(); g_pVertexShaderBlob = NULL; }
if (g_pBlendState)
{
g_pBlendState->Release();
g_pBlendState = NULL;
}
if (g_pDepthStencilState)
{
g_pDepthStencilState->Release();
g_pDepthStencilState = NULL;
}
if (g_pRasterizerState)
{
g_pRasterizerState->Release();
g_pRasterizerState = NULL;
}
if (g_pPixelShader)
{
g_pPixelShader->Release();
g_pPixelShader = NULL;
}
if (g_pPixelShaderBlob)
{
g_pPixelShaderBlob->Release();
g_pPixelShaderBlob = NULL;
}
if (g_pVertexConstantBuffer)
{
g_pVertexConstantBuffer->Release();
g_pVertexConstantBuffer = NULL;
}
if (g_pInputLayout)
{
g_pInputLayout->Release();
g_pInputLayout = NULL;
}
if (g_pVertexShader)
{
g_pVertexShader->Release();
g_pVertexShader = NULL;
}
if (g_pVertexShaderBlob)
{
g_pVertexShaderBlob->Release();
g_pVertexShaderBlob = NULL;
}
}
bool ImGui_ImplDX11_Init(ID3D11Device* device, ID3D11DeviceContext* device_context)
@ -475,8 +580,10 @@ bool ImGui_ImplDX11_Init(ID3D11Device* device, ID3D11DeviceContext* device_co
g_pd3dDeviceContext = device_context;
g_pFactory = pFactory;
}
if (pDXGIDevice) pDXGIDevice->Release();
if (pDXGIAdapter) pDXGIAdapter->Release();
if (pDXGIDevice)
pDXGIDevice->Release();
if (pDXGIAdapter)
pDXGIAdapter->Release();
return true;
}
@ -484,7 +591,11 @@ bool ImGui_ImplDX11_Init(ID3D11Device* device, ID3D11DeviceContext* device_co
void ImGui_ImplDX11_Shutdown()
{
ImGui_ImplDX11_InvalidateDeviceObjects();
if (g_pFactory) { g_pFactory->Release(); g_pFactory = NULL; }
if (g_pFactory)
{
g_pFactory->Release();
g_pFactory = NULL;
}
g_pd3dDevice = NULL;
g_pd3dDeviceContext = NULL;
}

174
src/kiwano-network/HttpClient.cpp
View File

@ -18,24 +18,22 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include <thread>
#include <3rd-party/curl/curl.h> // CURL
#include <codecvt>
#include <kiwano-network/HttpClient.h>
#include <kiwano-network/HttpRequest.h>
#include <kiwano-network/HttpResponse.hpp>
#include <kiwano-network/HttpClient.h>
#include <kiwano/core/Logger.h>
#include <kiwano/platform/Application.h>
#include <3rd-party/curl/curl.h> // CURL
#include <thread>
namespace
{
using namespace kiwano;
using namespace kiwano::network;
using namespace kiwano;
using namespace kiwano::network;
uint32_t write_data(void* buffer, uint32_t size, uint32_t nmemb, void* userp)
{
uint32_t write_data(void* buffer, uint32_t size, uint32_t nmemb, void* userp)
{
ByteString* recv_buffer = (ByteString*)userp;
uint32_t total = size * nmemb;
@ -44,10 +42,10 @@ namespace
recv_buffer->append((char*)buffer, total);
return total;
}
}
ByteString convert_to_utf8(String const& str)
{
ByteString convert_to_utf8(String const& str)
{
std::wstring_convert<std::codecvt_utf8<wchar_t>> utf8_conv;
ByteString result;
@ -61,10 +59,10 @@ namespace
result = WideToMultiByte(str);
}
return result;
}
}
String convert_from_utf8(ByteString const& str)
{
String convert_from_utf8(ByteString const& str)
{
oc::string_convert<std::codecvt_utf8<wchar_t>> utf8_conv;
String result;
@ -78,11 +76,11 @@ namespace
result = MultiByteToWide(str);
}
return result;
}
}
class Curl
{
public:
class Curl
{
public:
Curl()
: curl_(curl_easy_init())
, curl_headers_(nullptr)
@ -104,7 +102,8 @@ namespace
}
}
bool Init(HttpClient* client, Vector<ByteString> const& headers, ByteString const& url, ByteString* response_data, ByteString* response_header, char* error_buffer)
bool Init(HttpClient* client, Vector<ByteString> const& headers, ByteString const& url, ByteString* response_data,
ByteString* response_header, char* error_buffer)
{
if (!SetOption(CURLOPT_ERRORBUFFER, error_buffer))
return false;
@ -114,13 +113,15 @@ namespace
return false;
const auto ssl_ca_file = wide_to_string(client->GetSSLVerification());
if (ssl_ca_file.empty()) {
if (ssl_ca_file.empty())
{
if (!SetOption(CURLOPT_SSL_VERIFYPEER, 0L))
return false;
if (!SetOption(CURLOPT_SSL_VERIFYHOST, 0L))
return false;
}
else {
else
{
if (!SetOption(CURLOPT_SSL_VERIFYPEER, 1L))
return false;
if (!SetOption(CURLOPT_SSL_VERIFYHOST, 2L))
@ -145,10 +146,8 @@ namespace
return false;
}
return SetOption(CURLOPT_URL, url.c_str())
&& SetOption(CURLOPT_WRITEFUNCTION, write_data)
&& SetOption(CURLOPT_WRITEDATA, response_data)
&& SetOption(CURLOPT_HEADERFUNCTION, write_data)
return SetOption(CURLOPT_URL, url.c_str()) && SetOption(CURLOPT_WRITEFUNCTION, write_data)
&& SetOption(CURLOPT_WRITEDATA, response_data) && SetOption(CURLOPT_HEADERFUNCTION, write_data)
&& SetOption(CURLOPT_HEADERDATA, response_header);
}
@ -161,111 +160,84 @@ namespace
return code == CURLE_OK && (*response_code >= 200 && *response_code < 300);
}
template <typename ..._Args>
template <typename... _Args>
bool SetOption(CURLoption option, _Args&&... args)
{
return CURLE_OK == curl_easy_setopt(curl_, option, std::forward<_Args>(args)...);
}
public:
static inline bool GetRequest(
HttpClient* client,
Vector<ByteString> const& headers,
ByteString const& url,
long* response_code,
ByteString* response_data,
ByteString* response_header,
public:
static inline bool GetRequest(HttpClient* client, Vector<ByteString> const& headers, ByteString const& url,
long* response_code, ByteString* response_data, ByteString* response_header,
char* error_buffer)
{
Curl curl;
return curl.Init(client, headers, url, response_data, response_header, error_buffer)
&& curl.SetOption(CURLOPT_FOLLOWLOCATION, true)
&& curl.Perform(response_code);
&& curl.SetOption(CURLOPT_FOLLOWLOCATION, true) && curl.Perform(response_code);
}
static inline bool PostRequest(
HttpClient* client,
Vector<ByteString> const& headers,
ByteString const& url,
ByteString const& request_data,
long* response_code,
ByteString* response_data,
ByteString* response_header,
char* error_buffer)
static inline bool PostRequest(HttpClient* client, Vector<ByteString> const& headers, ByteString const& url,
ByteString const& request_data, long* response_code, ByteString* response_data,
ByteString* response_header, char* error_buffer)
{
Curl curl;
return curl.Init(client, headers, url, response_data, response_header, error_buffer)
&& curl.SetOption(CURLOPT_POST, 1)
&& curl.SetOption(CURLOPT_POSTFIELDS, request_data.c_str())
&& curl.SetOption(CURLOPT_POSTFIELDSIZE, request_data.size())
&& curl.Perform(response_code);
&& curl.SetOption(CURLOPT_POST, 1) && curl.SetOption(CURLOPT_POSTFIELDS, request_data.c_str())
&& curl.SetOption(CURLOPT_POSTFIELDSIZE, request_data.size()) && curl.Perform(response_code);
}
static inline bool PutRequest(
HttpClient* client,
Vector<ByteString> const& headers,
ByteString const& url,
ByteString const& request_data,
long* response_code,
ByteString* response_data,
ByteString* response_header,
char* error_buffer)
static inline bool PutRequest(HttpClient* client, Vector<ByteString> const& headers, ByteString const& url,
ByteString const& request_data, long* response_code, ByteString* response_data,
ByteString* response_header, char* error_buffer)
{
Curl curl;
return curl.Init(client, headers, url, response_data, response_header, error_buffer)
&& curl.SetOption(CURLOPT_CUSTOMREQUEST, "PUT")
&& curl.SetOption(CURLOPT_POSTFIELDS, request_data.c_str())
&& curl.SetOption(CURLOPT_POSTFIELDSIZE, request_data.size())
&& curl.Perform(response_code);
&& curl.SetOption(CURLOPT_POSTFIELDSIZE, request_data.size()) && curl.Perform(response_code);
}
static inline bool DeleteRequest(
HttpClient* client,
Vector<ByteString> const& headers,
ByteString const& url,
long* response_code,
ByteString* response_data,
ByteString* response_header,
static inline bool DeleteRequest(HttpClient* client, Vector<ByteString> const& headers, ByteString const& url,
long* response_code, ByteString* response_data, ByteString* response_header,
char* error_buffer)
{
Curl curl;
return curl.Init(client, headers, url, response_data, response_header, error_buffer)
&& curl.SetOption(CURLOPT_CUSTOMREQUEST, "DELETE")
&& curl.SetOption(CURLOPT_FOLLOWLOCATION, true)
&& curl.SetOption(CURLOPT_CUSTOMREQUEST, "DELETE") && curl.SetOption(CURLOPT_FOLLOWLOCATION, true)
&& curl.Perform(response_code);
}
private:
private:
CURL* curl_;
curl_slist* curl_headers_;
};
}
};
} // namespace
namespace kiwano
{
namespace network
{
HttpClient::HttpClient()
namespace network
{
HttpClient::HttpClient()
: timeout_for_connect_(30000 /* 30 seconds */)
, timeout_for_read_(60000 /* 60 seconds */)
{
}
{
}
void HttpClient::SetupComponent()
{
void HttpClient::SetupComponent()
{
::curl_global_init(CURL_GLOBAL_ALL);
std::thread thread(Closure(this, &HttpClient::NetworkThread));
thread.detach();
}
}
void HttpClient::DestroyComponent()
{
void HttpClient::DestroyComponent()
{
::curl_global_cleanup();
}
}
void HttpClient::Send(HttpRequestPtr request)
{
void HttpClient::Send(HttpRequestPtr request)
{
if (!request)
return;
@ -274,10 +246,10 @@ namespace kiwano
request_mutex_.unlock();
sleep_condition_.notify_one();
}
}
void HttpClient::NetworkThread()
{
void HttpClient::NetworkThread()
{
while (true)
{
HttpRequestPtr request;
@ -300,10 +272,10 @@ namespace kiwano
Application::PreformInMainThread(Closure(this, &HttpClient::DispatchResponseCallback));
}
}
}
void HttpClient::Perform(HttpRequestPtr request, HttpResponsePtr response)
{
void HttpClient::Perform(HttpRequestPtr request, HttpResponsePtr response)
{
bool ok = false;
long response_code = 0;
char error_message[256] = { 0 };
@ -326,10 +298,12 @@ namespace kiwano
ok = Curl::GetRequest(this, headers, url, &response_code, &response_data, &response_header, error_message);
break;
case HttpRequest::Type::Post:
ok = Curl::PostRequest(this, headers, url, data, &response_code, &response_data, &response_header, error_message);
ok = Curl::PostRequest(this, headers, url, data, &response_code, &response_data, &response_header,
error_message);
break;
case HttpRequest::Type::Put:
ok = Curl::PutRequest(this, headers, url, data, &response_code, &response_data, &response_header, error_message);
ok =
Curl::PutRequest(this, headers, url, data, &response_code, &response_data, &response_header, error_message);
break;
case HttpRequest::Type::Delete:
ok = Curl::DeleteRequest(this, headers, url, &response_code, &response_data, &response_header, error_message);
@ -351,10 +325,10 @@ namespace kiwano
{
response->SetSucceed(true);
}
}
}
void HttpClient::DispatchResponseCallback()
{
void HttpClient::DispatchResponseCallback()
{
HttpResponsePtr response;
response_mutex_.lock();
@ -375,7 +349,7 @@ namespace kiwano
callback(request.get(), response.get());
}
}
}
}
}
} // namespace network
} // namespace kiwano

89
src/kiwano-network/HttpClient.h
View File

@ -19,36 +19,36 @@
// THE SOFTWARE.
#pragma once
#include <condition_variable>
#include <kiwano/core/Common.h>
#include <kiwano/core/Component.h>
#include <mutex>
#include <condition_variable>
namespace kiwano
{
namespace network
{
/**
namespace network
{
/**
* \~chinese
* \defgroup Network 网络通信
*/
/**
/**
* \addtogroup Network
* @{
*/
/**
/**
* \~chinese
* @brief HTTP客户端
*/
class KGE_API HttpClient
class KGE_API HttpClient
: public Singleton<HttpClient>
, public ComponentBase
{
{
friend Singleton<HttpClient>;
public:
public:
/// \~chinese
/// @brief 发送HTTP请求
/// @param[in] request HTTP请求
@ -79,12 +79,12 @@ namespace kiwano
/// @brief 获取SSL证书地址
String const& GetSSLVerification() const;
public:
public:
virtual void SetupComponent() override;
virtual void DestroyComponent() override;
private:
private:
HttpClient();
void NetworkThread();
@ -93,7 +93,7 @@ namespace kiwano
void DispatchResponseCallback();
private:
private:
Duration timeout_for_connect_;
Duration timeout_for_read_;
@ -106,40 +106,39 @@ namespace kiwano
Queue<HttpResponsePtr> response_queue_;
std::condition_variable_any sleep_condition_;
};
};
/** @} */
/** @} */
inline void HttpClient::SetTimeoutForConnect(Duration timeout)
{
inline void HttpClient::SetTimeoutForConnect(Duration timeout)
{
timeout_for_connect_ = timeout;
}
inline Duration HttpClient::GetTimeoutForConnect() const
{
return timeout_for_connect_;
}
inline void HttpClient::SetTimeoutForRead(Duration timeout)
{
timeout_for_read_ = timeout;
}
inline Duration HttpClient::GetTimeoutForRead() const
{
return timeout_for_read_;
}
inline void HttpClient::SetSSLVerification(String const& root_certificate_path)
{
ssl_verification_ = root_certificate_path;
}
inline String const& HttpClient::GetSSLVerification() const
{
return ssl_verification_;
}
}
}
inline Duration HttpClient::GetTimeoutForConnect() const
{
return timeout_for_connect_;
}
inline void HttpClient::SetTimeoutForRead(Duration timeout)
{
timeout_for_read_ = timeout;
}
inline Duration HttpClient::GetTimeoutForRead() const
{
return timeout_for_read_;
}
inline void HttpClient::SetSSLVerification(String const& root_certificate_path)
{
ssl_verification_ = root_certificate_path;
}
inline String const& HttpClient::GetSSLVerification() const
{
return ssl_verification_;
}
} // namespace network
} // namespace kiwano

12
src/kiwano-network/HttpRequest.cpp
View File

@ -23,12 +23,12 @@
namespace kiwano
{
namespace network
{
void HttpRequest::SetJsonData(Json const& json)
{
namespace network
{
void HttpRequest::SetJsonData(Json const& json)
{
SetHeader(L"Content-Type", L"application/json;charset=UTF-8");
data_ = json.dump();
}
}
}
} // namespace network
} // namespace kiwano

123
src/kiwano-network/HttpRequest.h
View File

@ -25,25 +25,24 @@
namespace kiwano
{
namespace network
{
class HttpResponse;
namespace network
{
class HttpResponse;
KGE_DECLARE_SMART_PTR(HttpRequest);
KGE_DECLARE_SMART_PTR(HttpRequest);
/**
/**
* \addtogroup Network
* @{
*/
/**
/**
* \~chinese
* @brief HTTP请求
*/
class KGE_API HttpRequest
: public virtual ObjectBase
{
public:
class KGE_API HttpRequest : public virtual ObjectBase
{
public:
/// \~chinese
/// @brief 响应回调函数
using ResponseCallback = Function<void(HttpRequest* /* request */, HttpResponse* /* response */)>;
@ -115,42 +114,84 @@ namespace kiwano
/// @brief 获取响应回调函数
ResponseCallback const& GetResponseCallback() const;
private:
private:
Type type_;
String url_;
String data_;
Map<String, String> headers_;
ResponseCallback response_cb_;
};
};
/** @} */
/** @} */
inline HttpRequest::HttpRequest() : type_(Type::Unknown) {}
inline HttpRequest::HttpRequest(Type type) : type_(type) {}
inline void HttpRequest::SetUrl(String const& url) { url_ = url; }
inline String const& HttpRequest::GetUrl() const { return url_; }
inline void HttpRequest::SetType(Type type) { type_ = type; }
inline HttpRequest::Type HttpRequest::GetType() const { return type_; }
inline void HttpRequest::SetData(String const& data) { data_ = data; }
inline String const& HttpRequest::GetData() const { return data_; }
inline void HttpRequest::SetHeaders(Map<String, String> const& headers) { headers_ = headers; }
inline void HttpRequest::SetHeader(String const& field, String const& content) { headers_[field] = content; }
inline Map<String, String>& HttpRequest::GetHeaders() { return headers_; }
inline String const& HttpRequest::GetHeader(String const& header) const { return headers_.at(header); }
inline void HttpRequest::SetResponseCallback(ResponseCallback const& callback) { response_cb_ = callback; }
inline HttpRequest::ResponseCallback const& HttpRequest::GetResponseCallback() const { return response_cb_; }
}
inline HttpRequest::HttpRequest()
: type_(Type::Unknown)
{
}
inline HttpRequest::HttpRequest(Type type)
: type_(type)
{
}
inline void HttpRequest::SetUrl(String const& url)
{
url_ = url;
}
inline String const& HttpRequest::GetUrl() const
{
return url_;
}
inline void HttpRequest::SetType(Type type)
{
type_ = type;
}
inline HttpRequest::Type HttpRequest::GetType() const
{
return type_;
}
inline void HttpRequest::SetData(String const& data)
{
data_ = data;
}
inline String const& HttpRequest::GetData() const
{
return data_;
}
inline void HttpRequest::SetHeaders(Map<String, String> const& headers)
{
headers_ = headers;
}
inline void HttpRequest::SetHeader(String const& field, String const& content)
{
headers_[field] = content;
}
inline Map<String, String>& HttpRequest::GetHeaders()
{
return headers_;
}
inline String const& HttpRequest::GetHeader(String const& header) const
{
return headers_.at(header);
}
inline void HttpRequest::SetResponseCallback(ResponseCallback const& callback)
{
response_cb_ = callback;
}
inline HttpRequest::ResponseCallback const& HttpRequest::GetResponseCallback() const
{
return response_cb_;
}
} // namespace network
} // namespace kiwano

109
src/kiwano-network/HttpResponse.hpp
View File

@ -23,23 +23,22 @@
namespace kiwano
{
namespace network
{
KGE_DECLARE_SMART_PTR(HttpResponse);
namespace network
{
KGE_DECLARE_SMART_PTR(HttpResponse);
/**
/**
* \addtogroup Network
* @{
*/
/**
/**
* \~chinese
* @brief HTTP响应
*/
class KGE_API HttpResponse
: public virtual ObjectBase
{
public:
class KGE_API HttpResponse : public virtual ObjectBase
{
public:
HttpResponse(HttpRequestPtr request);
/// \~chinese
@ -86,7 +85,7 @@ namespace kiwano
/// @brief 设置错误信息
void SetError(String const& error_buffer);
private:
private:
bool succeed_;
long response_code_;
HttpRequestPtr request_;
@ -94,32 +93,70 @@ namespace kiwano
String response_header_;
String response_data_;
String error_buffer_;
};
};
/** @} */
/** @} */
inline HttpResponse::HttpResponse(HttpRequestPtr request) : request_(request), succeed_(false), response_code_(0) {}
inline HttpRequestPtr HttpResponse::GetRequest() const { return request_; }
inline void HttpResponse::SetSucceed(bool succeed) { succeed_ = succeed; }
inline bool HttpResponse::IsSucceed() const { return succeed_; }
inline void HttpResponse::SetResponseCode(long response_code) { response_code_ = response_code; }
inline long HttpResponse::GetResponseCode() const { return response_code_; }
inline void HttpResponse::SetHeader(String const& response_header) { response_header_ = response_header; }
inline String HttpResponse::GetHeader() const { return response_header_; }
inline void HttpResponse::SetData(String const& response_data) { response_data_ = response_data; }
inline String const& HttpResponse::GetData() const { return response_data_; }
inline void HttpResponse::SetError(String const& error_buffer) { error_buffer_ = error_buffer; }
inline String const& HttpResponse::GetError() const { return error_buffer_; }
}
inline HttpResponse::HttpResponse(HttpRequestPtr request)
: request_(request)
, succeed_(false)
, response_code_(0)
{
}
inline HttpRequestPtr HttpResponse::GetRequest() const
{
return request_;
}
inline void HttpResponse::SetSucceed(bool succeed)
{
succeed_ = succeed;
}
inline bool HttpResponse::IsSucceed() const
{
return succeed_;
}
inline void HttpResponse::SetResponseCode(long response_code)
{
response_code_ = response_code;
}
inline long HttpResponse::GetResponseCode() const
{
return response_code_;
}
inline void HttpResponse::SetHeader(String const& response_header)
{
response_header_ = response_header;
}
inline String HttpResponse::GetHeader() const
{
return response_header_;
}
inline void HttpResponse::SetData(String const& response_data)
{
response_data_ = response_data;
}
inline String const& HttpResponse::GetData() const
{
return response_data_;
}
inline void HttpResponse::SetError(String const& error_buffer)
{
error_buffer_ = error_buffer;
}
inline String const& HttpResponse::GetError() const
{
return error_buffer_;
}
} // namespace network
} // namespace kiwano

2
src/kiwano-network/kiwano-network.h
View File

@ -20,6 +20,6 @@
#pragma once
#include <kiwano-network/HttpClient.h>
#include <kiwano-network/HttpRequest.h>
#include <kiwano-network/HttpResponse.hpp>
#include <kiwano-network/HttpClient.h>

207
src/kiwano-physics/Body.cpp
View File

@ -23,26 +23,26 @@
namespace kiwano
{
namespace physics
{
namespace physics
{
Body::Body()
Body::Body()
: body_(nullptr)
, actor_(nullptr)
, world_(nullptr)
, category_bits_(0x0001)
, mask_bits_(0xFFFF)
, group_index_(0)
{
}
{
}
Body::~Body()
{
Body::~Body()
{
Destroy();
}
}
bool Body::InitBody(World* world, Actor* actor)
{
bool Body::InitBody(World* world, Actor* actor)
{
KGE_ASSERT(world);
Destroy();
@ -59,49 +59,49 @@ namespace kiwano
return true;
}
return false;
}
}
Fixture Body::AddFixture(Shape* shape, const Fixture::Param& param)
{
Fixture Body::AddFixture(Shape* shape, const Fixture::Param& param)
{
KGE_ASSERT(body_ && world_);
return Fixture(this, shape, param);
}
}
Fixture Body::AddCircleShape(float radius, float density)
{
Fixture Body::AddCircleShape(float radius, float density)
{
return AddFixture(&CircleShape(radius), Fixture::Param(density));
}
}
Fixture Body::AddBoxShape(Vec2 const& size, float density)
{
Fixture Body::AddBoxShape(Vec2 const& size, float density)
{
return AddFixture(&BoxShape(size), Fixture::Param(density));
}
}
Fixture Body::AddPolygonShape(Vector<Point> const& vertexs, float density)
{
Fixture Body::AddPolygonShape(Vector<Point> const& vertexs, float density)
{
return AddFixture(&PolygonShape(vertexs), Fixture::Param(density));
}
}
Fixture Body::AddEdgeShape(Point const& p1, Point const& p2, float density)
{
Fixture Body::AddEdgeShape(Point const& p1, Point const& p2, float density)
{
return AddFixture(&EdgeShape(p1, p2), Fixture::Param(density));
}
}
Fixture Body::AddChainShape(Vector<Point> const& vertexs, bool loop, float density)
{
Fixture Body::AddChainShape(Vector<Point> const& vertexs, bool loop, float density)
{
return AddFixture(&ChainShape(vertexs, loop), Fixture::Param(density));
}
}
void Body::RemoveFixture(Fixture const& fixture)
{
void Body::RemoveFixture(Fixture const& fixture)
{
if (fixture.GetB2Fixture())
{
body_->DestroyFixture(fixture.GetB2Fixture());
}
}
}
void Body::SetCategoryBits(uint16_t category_bits)
{
void Body::SetCategoryBits(uint16_t category_bits)
{
KGE_ASSERT(body_);
if (category_bits != category_bits_)
@ -115,10 +115,10 @@ namespace kiwano
fixture = fixture->GetNext();
}
}
}
}
void Body::SetMaskBits(uint16_t mask_bits)
{
void Body::SetMaskBits(uint16_t mask_bits)
{
KGE_ASSERT(body_);
if (mask_bits != mask_bits_)
@ -132,10 +132,10 @@ namespace kiwano
fixture = fixture->GetNext();
}
}
}
}
void Body::SetGroupIndex(int16_t index)
{
void Body::SetGroupIndex(int16_t index)
{
KGE_ASSERT(body_);
if (index != group_index_)
@ -149,22 +149,25 @@ namespace kiwano
fixture = fixture->GetNext();
}
}
}
}
void Body::GetMassData(float* mass, Point* center, float* inertia) const
{
void Body::GetMassData(float* mass, Point* center, float* inertia) const
{
KGE_ASSERT(body_ && world_);
b2MassData data;
body_->GetMassData(&data);
if (mass) *mass = data.mass;
if (center) *center = world_->World2Stage(data.center);
if (inertia) *inertia = data.I;
}
if (mass)
*mass = data.mass;
if (center)
*center = world_->World2Stage(data.center);
if (inertia)
*inertia = data.I;
}
void Body::SetMassData(float mass, Point const& center, float inertia)
{
void Body::SetMassData(float mass, Point const& center, float inertia)
{
KGE_ASSERT(body_ && world_);
b2MassData data;
@ -172,79 +175,79 @@ namespace kiwano
data.center = world_->Stage2World(center);
data.I = inertia;
body_->SetMassData(&data);
}
}
void Body::ResetMassData()
{
void Body::ResetMassData()
{
KGE_ASSERT(body_);
body_->ResetMassData();
}
}
Point Body::GetBodyPosition() const
{
Point Body::GetBodyPosition() const
{
KGE_ASSERT(body_ && world_);
return world_->World2Stage(body_->GetPosition());
}
}
void Body::SetBodyTransform(Point const& pos, float angle)
{
void Body::SetBodyTransform(Point const& pos, float angle)
{
KGE_ASSERT(body_ && world_);
body_->SetTransform(world_->Stage2World(pos), math::Degree2Radian(angle));
}
}
Point Body::GetLocalPoint(Point const& world) const
{
Point Body::GetLocalPoint(Point const& world) const
{
KGE_ASSERT(body_ && world_);
return world_->World2Stage(body_->GetLocalPoint(world_->Stage2World(world)));
}
}
Point Body::GetWorldPoint(Point const& local) const
{
Point Body::GetWorldPoint(Point const& local) const
{
KGE_ASSERT(body_ && world_);
return world_->World2Stage(body_->GetWorldPoint(world_->Stage2World(local)));
}
}
Point Body::GetLocalCenter() const
{
Point Body::GetLocalCenter() const
{
KGE_ASSERT(body_ && world_);
return world_->World2Stage(body_->GetLocalCenter());
}
}
Point Body::GetWorldCenter() const
{
Point Body::GetWorldCenter() const
{
KGE_ASSERT(body_ && world_);
return world_->World2Stage(body_->GetWorldCenter());
}
}
void Body::ApplyForce(Vec2 const& force, Point const& point, bool wake)
{
void Body::ApplyForce(Vec2 const& force, Point const& point, bool wake)
{
KGE_ASSERT(body_ && world_);
body_->ApplyForce(b2Vec2(force.x, force.y), world_->Stage2World(point), wake);
}
}
void Body::ApplyForceToCenter(Vec2 const& force, bool wake)
{
void Body::ApplyForceToCenter(Vec2 const& force, bool wake)
{
KGE_ASSERT(body_ && world_);
body_->ApplyForceToCenter(b2Vec2(force.x, force.y), wake);
}
}
void Body::ApplyTorque(float torque, bool wake)
{
void Body::ApplyTorque(float torque, bool wake)
{
KGE_ASSERT(body_ && world_);
body_->ApplyTorque(torque, wake);
}
}
void Body::SetB2Body(b2Body* body)
{
void Body::SetB2Body(b2Body* body)
{
body_ = body;
if (body_)
{
body_->SetUserData(this);
}
}
}
void Body::Destroy()
{
void Body::Destroy()
{
if (world_)
{
world_->RemoveBody(this);
@ -253,10 +256,10 @@ namespace kiwano
body_ = nullptr;
world_ = nullptr;
actor_ = nullptr;
}
}
void Body::UpdateActor()
{
void Body::UpdateActor()
{
if (actor_ && body_)
{
if (world_)
@ -269,37 +272,31 @@ namespace kiwano
}
actor_->SetRotation(math::Radian2Degree(body_->GetAngle()));
}
}
}
void Body::UpdateFromActor()
{
void Body::UpdateFromActor()
{
if (actor_ && body_)
{
if (world_)
{
body_->SetTransform(
world_->Stage2World(actor_->GetPosition()),
math::Degree2Radian(actor_->GetRotation())
);
body_->SetTransform(world_->Stage2World(actor_->GetPosition()), math::Degree2Radian(actor_->GetRotation()));
}
else
{
body_->SetTransform(
Stage2World(actor_->GetPosition()),
math::Degree2Radian(actor_->GetRotation())
);
}
body_->SetTransform(Stage2World(actor_->GetPosition()), math::Degree2Radian(actor_->GetRotation()));
}
}
}
void Body::UpdateFixtureFilter(b2Fixture* fixture)
{
void Body::UpdateFixtureFilter(b2Fixture* fixture)
{
b2Filter filter;
filter.categoryBits = category_bits_;
filter.maskBits = mask_bits_;
filter.groupIndex = group_index_;
fixture->SetFilterData(filter);
}
}
}
}
} // namespace physics
} // namespace kiwano

257
src/kiwano-physics/Body.h
View File

@ -19,30 +19,29 @@
// THE SOFTWARE.
#pragma once
#include <kiwano-physics/helper.h>
#include <kiwano-physics/Shape.h>
#include <kiwano-physics/Fixture.h>
#include <kiwano-physics/ContactEdge.h>
#include <kiwano-physics/Fixture.h>
#include <kiwano-physics/Shape.h>
#include <kiwano-physics/helper.h>
namespace kiwano
{
namespace physics
{
class World;
namespace physics
{
class World;
KGE_DECLARE_SMART_PTR(Body);
KGE_DECLARE_SMART_PTR(Body);
/**
/**
* \addtogroup Physics
* @{
*/
/// \~chinese
/// @brief ÎïÌå
class KGE_API Body
: public virtual ObjectBase
{
public:
/// \~chinese
/// @brief ÎïÌå
class KGE_API Body : public virtual ObjectBase
{
public:
/// \~chinese
/// @brief ÎïÌåÀàÐÍ
enum class Type
@ -302,7 +301,7 @@ namespace kiwano
b2Body* GetB2Body() const;
void SetB2Body(b2Body* body);
private:
private:
/// \~chinese
/// @brief Ïú»ÙÎïÌå
void UpdateFixtureFilter(b2Fixture* fixture);
@ -311,7 +310,7 @@ namespace kiwano
/// @brief Ïú»ÙÎïÌå
void Destroy();
private:
private:
Actor* actor_;
World* world_;
b2Body* body_;
@ -319,66 +318,172 @@ namespace kiwano
uint16_t category_bits_;
uint16_t mask_bits_;
int16_t group_index_;
};
};
/** @} */
/** @} */
inline bool Body::InitBody(World* world, ActorPtr actor) { return InitBody(world, actor.get()); }
inline FixtureList Body::GetFixtureList() const { KGE_ASSERT(body_); return FixtureList(Fixture(body_->GetFixtureList())); }
inline ContactEdgeList Body::GetContactList() const { KGE_ASSERT(body_); return ContactEdgeList(ContactEdge(body_->GetContactList())); }
inline uint16_t Body::GetCategoryBits() const { return category_bits_; }
inline uint16_t Body::GetMaskBits() const { return mask_bits_; }
inline int16_t Body::GetGroupIndex() const { return group_index_; }
inline float Body::GetBodyRotation() const { KGE_ASSERT(body_); return math::Radian2Degree(body_->GetAngle()); }
inline void Body::SetBodyRotation(float angle) { SetBodyTransform(GetBodyPosition(), angle); }
inline void Body::SetBodyPosition(Point const& pos) { SetBodyTransform(pos, GetBodyRotation()); }
inline float Body::GetMass() const { KGE_ASSERT(body_); return body_->GetMass(); }
inline float Body::GetInertia() const { KGE_ASSERT(body_); return body_->GetInertia(); }
inline Body::Type Body::GetType() const { KGE_ASSERT(body_); return Type(body_->GetType()); }
inline void Body::SetType(Type type) { KGE_ASSERT(body_); body_->SetType(static_cast<b2BodyType>(type)); }
inline float Body::GetGravityScale() const { KGE_ASSERT(body_); return body_->GetGravityScale(); }
inline void Body::SetGravityScale(float scale) { KGE_ASSERT(body_); body_->SetGravityScale(scale); }
inline bool Body::IsIgnoreRotation() const { KGE_ASSERT(body_); return body_->IsFixedRotation(); }
inline void Body::SetIgnoreRotation(bool flag) { KGE_ASSERT(body_); body_->SetFixedRotation(flag); }
inline bool Body::IsBullet() const { KGE_ASSERT(body_); return body_->IsBullet(); }
inline void Body::SetBullet(bool flag) { KGE_ASSERT(body_); body_->SetBullet(flag); }
inline bool Body::IsAwake() const { KGE_ASSERT(body_); return body_->IsAwake(); }
inline void Body::SetAwake(bool flag) { KGE_ASSERT(body_); body_->SetAwake(flag); }
inline bool Body::IsSleepingAllowed() const { KGE_ASSERT(body_); return body_->IsSleepingAllowed(); }
inline void Body::SetSleepingAllowed(bool flag) { KGE_ASSERT(body_); body_->SetSleepingAllowed(flag); }
inline bool Body::IsActive() const { KGE_ASSERT(body_); return body_->IsActive(); }
inline void Body::SetActive(bool flag) { KGE_ASSERT(body_); body_->SetActive(flag); }
inline Actor* Body::GetActor() const { return actor_; }
inline void Body::SetActor(Actor* actor) { actor_ = actor; }
inline b2Body* Body::GetB2Body() const { return body_; }
inline World* Body::GetWorld() const { return world_; }
}
inline bool Body::InitBody(World* world, ActorPtr actor)
{
return InitBody(world, actor.get());
}
inline FixtureList Body::GetFixtureList() const
{
KGE_ASSERT(body_);
return FixtureList(Fixture(body_->GetFixtureList()));
}
inline ContactEdgeList Body::GetContactList() const
{
KGE_ASSERT(body_);
return ContactEdgeList(ContactEdge(body_->GetContactList()));
}
inline uint16_t Body::GetCategoryBits() const
{
return category_bits_;
}
inline uint16_t Body::GetMaskBits() const
{
return mask_bits_;
}
inline int16_t Body::GetGroupIndex() const
{
return group_index_;
}
inline float Body::GetBodyRotation() const
{
KGE_ASSERT(body_);
return math::Radian2Degree(body_->GetAngle());
}
inline void Body::SetBodyRotation(float angle)
{
SetBodyTransform(GetBodyPosition(), angle);
}
inline void Body::SetBodyPosition(Point const& pos)
{
SetBodyTransform(pos, GetBodyRotation());
}
inline float Body::GetMass() const
{
KGE_ASSERT(body_);
return body_->GetMass();
}
inline float Body::GetInertia() const
{
KGE_ASSERT(body_);
return body_->GetInertia();
}
inline Body::Type Body::GetType() const
{
KGE_ASSERT(body_);
return Type(body_->GetType());
}
inline void Body::SetType(Type type)
{
KGE_ASSERT(body_);
body_->SetType(static_cast<b2BodyType>(type));
}
inline float Body::GetGravityScale() const
{
KGE_ASSERT(body_);
return body_->GetGravityScale();
}
inline void Body::SetGravityScale(float scale)
{
KGE_ASSERT(body_);
body_->SetGravityScale(scale);
}
inline bool Body::IsIgnoreRotation() const
{
KGE_ASSERT(body_);
return body_->IsFixedRotation();
}
inline void Body::SetIgnoreRotation(bool flag)
{
KGE_ASSERT(body_);
body_->SetFixedRotation(flag);
}
inline bool Body::IsBullet() const
{
KGE_ASSERT(body_);
return body_->IsBullet();
}
inline void Body::SetBullet(bool flag)
{
KGE_ASSERT(body_);
body_->SetBullet(flag);
}
inline bool Body::IsAwake() const
{
KGE_ASSERT(body_);
return body_->IsAwake();
}
inline void Body::SetAwake(bool flag)
{
KGE_ASSERT(body_);
body_->SetAwake(flag);
}
inline bool Body::IsSleepingAllowed() const
{
KGE_ASSERT(body_);
return body_->IsSleepingAllowed();
}
inline void Body::SetSleepingAllowed(bool flag)
{
KGE_ASSERT(body_);
body_->SetSleepingAllowed(flag);
}
inline bool Body::IsActive() const
{
KGE_ASSERT(body_);
return body_->IsActive();
}
inline void Body::SetActive(bool flag)
{
KGE_ASSERT(body_);
body_->SetActive(flag);
}
inline Actor* Body::GetActor() const
{
return actor_;
}
inline void Body::SetActor(Actor* actor)
{
actor_ = actor;
}
inline b2Body* Body::GetB2Body() const
{
return body_;
}
inline World* Body::GetWorld() const
{
return world_;
}
} // namespace physics
} // namespace kiwano

58
src/kiwano-physics/Contact.cpp
View File

@ -18,50 +18,50 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include <kiwano-physics/Contact.h>
#include <kiwano-physics/Body.h>
#include <kiwano-physics/Contact.h>
#include <kiwano-physics/World.h>
namespace kiwano
{
namespace physics
{
namespace physics
{
Contact::Contact()
Contact::Contact()
: contact_(nullptr)
{
}
{
}
Contact::Contact(b2Contact* contact)
Contact::Contact(b2Contact* contact)
: Contact()
{
{
SetB2Contact(contact);
}
}
Fixture Contact::GetFixtureA() const
{
Fixture Contact::GetFixtureA() const
{
KGE_ASSERT(contact_);
return Fixture(contact_->GetFixtureA());
}
}
Fixture Contact::GetFixtureB() const
{
Fixture Contact::GetFixtureB() const
{
KGE_ASSERT(contact_);
return Fixture(contact_->GetFixtureB());
}
}
Body* Contact::GetBodyA() const
{
Body* Contact::GetBodyA() const
{
return GetFixtureA().GetBody();
}
}
Body* Contact::GetBodyB() const
{
Body* Contact::GetBodyB() const
{
return GetFixtureB().GetBody();
}
}
void Contact::SetTangentSpeed(float speed)
{
void Contact::SetTangentSpeed(float speed)
{
KGE_ASSERT(contact_);
Body* body = GetFixtureA().GetBody();
@ -71,10 +71,10 @@ namespace kiwano
KGE_ASSERT(world);
contact_->SetTangentSpeed(world->Stage2World(speed));
}
}
float Contact::GetTangentSpeed() const
{
float Contact::GetTangentSpeed() const
{
KGE_ASSERT(contact_);
const Body* body = GetFixtureA().GetBody();
@ -84,7 +84,7 @@ namespace kiwano
KGE_ASSERT(world);
return world->World2Stage(contact_->GetTangentSpeed());
}
}
}
} // namespace physics
} // namespace kiwano

141
src/kiwano-physics/Contact.h
View File

@ -19,25 +19,25 @@
// THE SOFTWARE.
#pragma once
#include <kiwano-physics/helper.h>
#include <kiwano-physics/Fixture.h>
#include <kiwano-physics/helper.h>
namespace kiwano
{
namespace physics
{
class Body;
namespace physics
{
class Body;
/**
/**
* \addtogroup Physics
* @{
*/
/// \~chinese
/// @brief ÎïÀí½Ó´¥
class KGE_API Contact
{
public:
/// \~chinese
/// @brief ÎïÀí½Ó´¥
class KGE_API Contact
{
public:
Contact();
Contact(b2Contact* contact);
@ -108,22 +108,19 @@ namespace kiwano
b2Contact* GetB2Contact() const;
void SetB2Contact(b2Contact* contact);
bool operator== (const Contact& rhs) const;
bool operator!= (const Contact& rhs) const;
bool operator==(const Contact& rhs) const;
bool operator!=(const Contact& rhs) const;
private:
private:
b2Contact* contact_;
};
};
/// \~chinese
/// @brief ÎïÀí½Ó´¥Áбí
class ContactList
: public List<Contact>
{
/// \~chinese
/// @brief ÎïÀí½Ó´¥Áбí
class ContactList : public List<Contact>
{
template <typename _Ty>
class IteratorImpl
: public std::iterator<std::forward_iterator_tag, _Ty>
class IteratorImpl : public std::iterator<std::forward_iterator_tag, _Ty>
{
using herit = std::iterator<std::forward_iterator_tag, _Ty>;
@ -156,12 +153,12 @@ namespace kiwano
return old;
}
inline bool operator== (const IteratorImpl& rhs) const
inline bool operator==(const IteratorImpl& rhs) const
{
return elem_ == rhs.elem_;
}
inline bool operator!= (const IteratorImpl& rhs) const
inline bool operator!=(const IteratorImpl& rhs) const
{
return !operator==(rhs);
}
@ -170,14 +167,12 @@ namespace kiwano
_Ty elem_;
};
public:
public:
using value_type = Contact;
using iterator = IteratorImpl<value_type>;
using const_iterator = IteratorImpl<const value_type>;
inline ContactList()
{
}
inline ContactList() {}
inline ContactList(const value_type& first)
: first_(first)
@ -224,27 +219,77 @@ namespace kiwano
return const_iterator(nullptr);
}
private:
private:
value_type first_;
};
};
/** @} */
/** @} */
inline bool Contact::IsValid() const { return contact_ != nullptr;}
inline bool Contact::IsTouching() const { KGE_ASSERT(contact_); return contact_->IsTouching(); }
inline void Contact::SetEnabled(bool flag) { KGE_ASSERT(contact_); contact_->SetEnabled(flag); }
inline bool Contact::IsEnabled() const { KGE_ASSERT(contact_); return contact_->IsEnabled(); }
inline void Contact::SetFriction(float friction) { KGE_ASSERT(contact_); contact_->SetFriction(friction); }
inline float Contact::GetFriction() const { KGE_ASSERT(contact_); return contact_->GetFriction(); }
inline void Contact::ResetFriction() { KGE_ASSERT(contact_); contact_->ResetFriction(); }
inline void Contact::SetRestitution(float restitution) { KGE_ASSERT(contact_); contact_->SetRestitution(restitution); }
inline float Contact::GetRestitution() const { KGE_ASSERT(contact_); return contact_->GetRestitution(); }
inline void Contact::ResetRestitution() { KGE_ASSERT(contact_); contact_->ResetRestitution(); }
inline b2Contact* Contact::GetB2Contact() const { return contact_; }
inline void Contact::SetB2Contact(b2Contact* contact) { contact_ = contact; }
inline bool Contact::operator==(const Contact& rhs) const { return contact_ == rhs.contact_; }
inline bool Contact::operator!=(const Contact& rhs) const { return contact_ != rhs.contact_; }
}
inline bool Contact::IsValid() const
{
return contact_ != nullptr;
}
inline bool Contact::IsTouching() const
{
KGE_ASSERT(contact_);
return contact_->IsTouching();
}
inline void Contact::SetEnabled(bool flag)
{
KGE_ASSERT(contact_);
contact_->SetEnabled(flag);
}
inline bool Contact::IsEnabled() const
{
KGE_ASSERT(contact_);
return contact_->IsEnabled();
}
inline void Contact::SetFriction(float friction)
{
KGE_ASSERT(contact_);
contact_->SetFriction(friction);
}
inline float Contact::GetFriction() const
{
KGE_ASSERT(contact_);
return contact_->GetFriction();
}
inline void Contact::ResetFriction()
{
KGE_ASSERT(contact_);
contact_->ResetFriction();
}
inline void Contact::SetRestitution(float restitution)
{
KGE_ASSERT(contact_);
contact_->SetRestitution(restitution);
}
inline float Contact::GetRestitution() const
{
KGE_ASSERT(contact_);
return contact_->GetRestitution();
}
inline void Contact::ResetRestitution()
{
KGE_ASSERT(contact_);
contact_->ResetRestitution();
}
inline b2Contact* Contact::GetB2Contact() const
{
return contact_;
}
inline void Contact::SetB2Contact(b2Contact* contact)
{
contact_ = contact;
}
inline bool Contact::operator==(const Contact& rhs) const
{
return contact_ == rhs.contact_;
}
inline bool Contact::operator!=(const Contact& rhs) const
{
return contact_ != rhs.contact_;
}
} // namespace physics
} // namespace kiwano

26
src/kiwano-physics/ContactEdge.cpp
View File

@ -22,19 +22,19 @@
namespace kiwano
{
namespace physics
{
namespace physics
{
ContactEdge::ContactEdge()
ContactEdge::ContactEdge()
: edge_(nullptr)
{
}
ContactEdge::ContactEdge(b2ContactEdge* edge)
: ContactEdge()
{
SetB2ContactEdge(edge);
}
}
{
}
ContactEdge::ContactEdge(b2ContactEdge* edge)
: ContactEdge()
{
SetB2ContactEdge(edge);
}
} // namespace physics
} // namespace kiwano

93
src/kiwano-physics/ContactEdge.h
View File

@ -23,18 +23,18 @@
namespace kiwano
{
namespace physics
{
/**
namespace physics
{
/**
* \addtogroup Physics
* @{
*/
/// \~chinese
/// @brief ½Ó´¥±ß
class KGE_API ContactEdge
{
public:
/// \~chinese
/// @brief ½Ó´¥±ß
class KGE_API ContactEdge
{
public:
ContactEdge();
ContactEdge(b2ContactEdge* edge);
@ -53,21 +53,19 @@ namespace kiwano
b2ContactEdge* GetB2ContactEdge() const;
void SetB2ContactEdge(b2ContactEdge* edge);
bool operator== (const ContactEdge& rhs) const;
bool operator!= (const ContactEdge& rhs) const;
bool operator==(const ContactEdge& rhs) const;
bool operator!=(const ContactEdge& rhs) const;
private:
private:
b2ContactEdge* edge_;
};
};
/// \~chinese
/// @brief ÎïÀí½Ó´¥±ßÁбí
class ContactEdgeList
{
/// \~chinese
/// @brief ÎïÀí½Ó´¥±ßÁбí
class ContactEdgeList
{
template <typename _Ty>
class IteratorImpl
: public std::iterator<std::forward_iterator_tag, _Ty>
class IteratorImpl : public std::iterator<std::forward_iterator_tag, _Ty>
{
using herit = std::iterator<std::forward_iterator_tag, _Ty>;
@ -100,12 +98,12 @@ namespace kiwano
return old;
}
inline bool operator== (const IteratorImpl& rhs) const
inline bool operator==(const IteratorImpl& rhs) const
{
return elem_ == rhs.elem_;
}
inline bool operator!= (const IteratorImpl& rhs) const
inline bool operator!=(const IteratorImpl& rhs) const
{
return !operator==(rhs);
}
@ -114,14 +112,12 @@ namespace kiwano
_Ty elem_;
};
public:
public:
using value_type = ContactEdge;
using iterator = IteratorImpl<value_type>;
using const_iterator = IteratorImpl<const value_type>;
inline ContactEdgeList()
{
}
inline ContactEdgeList() {}
inline ContactEdgeList(const value_type& first)
: first_(first)
@ -168,19 +164,42 @@ namespace kiwano
return const_iterator(nullptr);
}
private:
private:
value_type first_;
};
};
/** @} */
/** @} */
inline bool ContactEdge::IsValid() const { return edge_ != nullptr; }
inline Body* ContactEdge::GetOtherBody() const { KGE_ASSERT(edge_); return static_cast<Body*>(edge_->other->GetUserData()); }
inline Contact ContactEdge::GetContact() const { KGE_ASSERT(edge_); return Contact(edge_->contact); }
inline b2ContactEdge* ContactEdge::GetB2ContactEdge() const { return edge_; }
inline void ContactEdge::SetB2ContactEdge(b2ContactEdge* edge) { edge_ = edge; }
inline bool ContactEdge::operator==(const ContactEdge& rhs) const { return edge_ == rhs.edge_; }
inline bool ContactEdge::operator!=(const ContactEdge& rhs) const { return edge_ != rhs.edge_; }
}
inline bool ContactEdge::IsValid() const
{
return edge_ != nullptr;
}
inline Body* ContactEdge::GetOtherBody() const
{
KGE_ASSERT(edge_);
return static_cast<Body*>(edge_->other->GetUserData());
}
inline Contact ContactEdge::GetContact() const
{
KGE_ASSERT(edge_);
return Contact(edge_->contact);
}
inline b2ContactEdge* ContactEdge::GetB2ContactEdge() const
{
return edge_;
}
inline void ContactEdge::SetB2ContactEdge(b2ContactEdge* edge)
{
edge_ = edge;
}
inline bool ContactEdge::operator==(const ContactEdge& rhs) const
{
return edge_ == rhs.edge_;
}
inline bool ContactEdge::operator!=(const ContactEdge& rhs) const
{
return edge_ != rhs.edge_;
}
} // namespace physics
} // namespace kiwano

32
src/kiwano-physics/ContactEvent.cpp
View File

@ -22,29 +22,29 @@
namespace kiwano
{
namespace physics
{
ContactBeginEvent::ContactBeginEvent()
namespace physics
{
ContactBeginEvent::ContactBeginEvent()
: Event(KGE_EVENT(ContactBeginEvent))
{
}
{
}
ContactBeginEvent::ContactBeginEvent(Contact const& contact)
ContactBeginEvent::ContactBeginEvent(Contact const& contact)
: ContactBeginEvent()
{
{
this->contact = contact;
}
}
ContactEndEvent::ContactEndEvent()
ContactEndEvent::ContactEndEvent()
: Event(KGE_EVENT(ContactEndEvent))
{
}
{
}
ContactEndEvent::ContactEndEvent(Contact const& contact)
ContactEndEvent::ContactEndEvent(Contact const& contact)
: ContactEndEvent()
{
{
this->contact = contact;
}
}
}
}
} // namespace physics
} // namespace kiwano

44
src/kiwano-physics/ContactEvent.h
View File

@ -19,47 +19,45 @@
// THE SOFTWARE.
#pragma once
#include <kiwano-physics/Contact.h>
#include <kiwano-physics/Body.h>
#include <kiwano-physics/Contact.h>
namespace kiwano
{
namespace physics
{
KGE_DECLARE_SMART_PTR(ContactBeginEvent);
KGE_DECLARE_SMART_PTR(ContactEndEvent);
namespace physics
{
KGE_DECLARE_SMART_PTR(ContactBeginEvent);
KGE_DECLARE_SMART_PTR(ContactEndEvent);
/**
/**
* \addtogroup Events
* @{
*/
/// \~chinese
/// @brief 物理接触开始事件
class KGE_API ContactBeginEvent
: public Event
{
public:
/// \~chinese
/// @brief 物理接触开始事件
class KGE_API ContactBeginEvent : public Event
{
public:
Contact contact; ///< 产生的接触
ContactBeginEvent();
ContactBeginEvent(Contact const& contact);
};
};
/// \~chinese
/// @brief 物理接触结束事件
class KGE_API ContactEndEvent
: public Event
{
public:
/// \~chinese
/// @brief 物理接触结束事件
class KGE_API ContactEndEvent : public Event
{
public:
Contact contact; ///< 产生的接触
ContactEndEvent();
ContactEndEvent(Contact const& contact);
};
};
/** @} */
}
}
/** @} */
} // namespace physics
} // namespace kiwano

61
src/kiwano-physics/Fixture.cpp
View File

@ -18,29 +18,29 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include <kiwano-physics/Fixture.h>
#include <kiwano-physics/Body.h>
#include <kiwano-physics/Fixture.h>
#include <kiwano-physics/World.h>
namespace kiwano
{
namespace physics
{
namespace physics
{
Fixture::Fixture()
Fixture::Fixture()
: fixture_(nullptr)
{
}
{
}
Fixture::Fixture(b2Fixture* fixture)
Fixture::Fixture(b2Fixture* fixture)
: Fixture()
{
{
SetB2Fixture(fixture);
}
}
Fixture::Fixture(Body* body, Shape* shape, const Param& param)
Fixture::Fixture(Body* body, Shape* shape, const Param& param)
: Fixture()
{
{
KGE_ASSERT(body);
if (shape)
@ -56,22 +56,22 @@ namespace kiwano
auto fixture = b2body->CreateFixture(&fd);
SetB2Fixture(fixture);
}
}
}
Body* Fixture::GetBody() const
{
Body* Fixture::GetBody() const
{
KGE_ASSERT(fixture_);
return static_cast<Body*>(fixture_->GetBody()->GetUserData());
}
}
Shape Fixture::GetShape() const
{
Shape Fixture::GetShape() const
{
KGE_ASSERT(fixture_);
return Shape(fixture_->GetShape());
}
}
void Fixture::GetMassData(float* mass, Point* center, float* inertia) const
{
void Fixture::GetMassData(float* mass, Point* center, float* inertia) const
{
KGE_ASSERT(fixture_);
const Body* body = GetBody();
@ -83,13 +83,16 @@ namespace kiwano
b2MassData data;
fixture_->GetMassData(&data);
if (mass) *mass = data.mass;
if (center) *center = world->World2Stage(data.center);
if (inertia) *inertia = data.I;
}
if (mass)
*mass = data.mass;
if (center)
*center = world->World2Stage(data.center);
if (inertia)
*inertia = data.I;
}
bool Fixture::TestPoint(const Point& p) const
{
bool Fixture::TestPoint(const Point& p) const
{
KGE_ASSERT(fixture_);
const Body* body = GetBody();
@ -99,7 +102,7 @@ namespace kiwano
KGE_ASSERT(world);
return fixture_->TestPoint(world->Stage2World(p));
}
}
}
} // namespace physics
} // namespace kiwano

134
src/kiwano-physics/Fixture.h
View File

@ -19,25 +19,25 @@
// THE SOFTWARE.
#pragma once
#include <kiwano-physics/helper.h>
#include <kiwano-physics/Shape.h>
#include <kiwano-physics/helper.h>
namespace kiwano
{
namespace physics
{
class Body;
namespace physics
{
class Body;
/**
/**
* \addtogroup Physics
* @{
*/
/// \~chinese
/// @brief ÎïÀí¼Ð¾ß
class Fixture
{
public:
/// \~chinese
/// @brief ÎïÀí¼Ð¾ß
class Fixture
{
public:
/// \~chinese
/// @brief ¼Ð¾ß²ÎÊý
struct Param
@ -54,7 +54,8 @@ namespace kiwano
, friction(friction)
, restitution(restitution)
, is_sensor(is_sensor)
{}
{
}
};
Fixture();
@ -117,21 +118,19 @@ namespace kiwano
b2Fixture* GetB2Fixture() const;
void SetB2Fixture(b2Fixture* fixture);
bool operator== (const Fixture& rhs) const;
bool operator!= (const Fixture& rhs) const;
bool operator==(const Fixture& rhs) const;
bool operator!=(const Fixture& rhs) const;
private:
private:
b2Fixture* fixture_;
};
};
/// \~chinese
/// @brief ÎïÀí¼Ð¾ßÁбí
class FixtureList
: public List<Fixture>
{
/// \~chinese
/// @brief ÎïÀí¼Ð¾ßÁбí
class FixtureList : public List<Fixture>
{
template <typename _Ty>
class IteratorImpl
: public std::iterator<std::forward_iterator_tag, _Ty>
class IteratorImpl : public std::iterator<std::forward_iterator_tag, _Ty>
{
using herit = std::iterator<std::forward_iterator_tag, _Ty>;
@ -164,12 +163,12 @@ namespace kiwano
return old;
}
inline bool operator== (const IteratorImpl& rhs) const
inline bool operator==(const IteratorImpl& rhs) const
{
return elem_ == rhs.elem_;
}
inline bool operator!= (const IteratorImpl& rhs) const
inline bool operator!=(const IteratorImpl& rhs) const
{
return !operator==(rhs);
}
@ -178,14 +177,12 @@ namespace kiwano
_Ty elem_;
};
public:
public:
using value_type = Fixture;
using iterator = IteratorImpl<value_type>;
using const_iterator = IteratorImpl<const value_type>;
inline FixtureList()
{
}
inline FixtureList() {}
inline FixtureList(const value_type& first)
: first_(first)
@ -232,24 +229,71 @@ namespace kiwano
return const_iterator(nullptr);
}
private:
private:
value_type first_;
};
};
/** @} */
/** @} */
inline bool Fixture::IsSensor() const { KGE_ASSERT(fixture_); return fixture_->IsSensor(); }
inline void Fixture::SetSensor(bool sensor) { KGE_ASSERT(fixture_); fixture_->SetSensor(sensor); }
inline float Fixture::GetDensity() const { KGE_ASSERT(fixture_); return fixture_->GetDensity(); }
inline void Fixture::SetDensity(float density) { KGE_ASSERT(fixture_); fixture_->SetDensity(density); }
inline float Fixture::GetFriction() const { KGE_ASSERT(fixture_); return fixture_->GetFriction(); }
inline void Fixture::SetFriction(float friction) { KGE_ASSERT(fixture_); fixture_->SetFriction(friction); }
inline float Fixture::GetRestitution() const { KGE_ASSERT(fixture_); return fixture_->GetRestitution(); }
inline void Fixture::SetRestitution(float restitution) { KGE_ASSERT(fixture_); fixture_->SetRestitution(restitution); }
inline bool Fixture::IsValid() const { return fixture_ != nullptr; }
inline b2Fixture* Fixture::GetB2Fixture() const { return fixture_; }
inline void Fixture::SetB2Fixture(b2Fixture* fixture) { fixture_ = fixture; }
inline bool Fixture::operator==(const Fixture& rhs) const { return fixture_ == rhs.fixture_; }
inline bool Fixture::operator!=(const Fixture& rhs) const { return fixture_ != rhs.fixture_; }
}
inline bool Fixture::IsSensor() const
{
KGE_ASSERT(fixture_);
return fixture_->IsSensor();
}
inline void Fixture::SetSensor(bool sensor)
{
KGE_ASSERT(fixture_);
fixture_->SetSensor(sensor);
}
inline float Fixture::GetDensity() const
{
KGE_ASSERT(fixture_);
return fixture_->GetDensity();
}
inline void Fixture::SetDensity(float density)
{
KGE_ASSERT(fixture_);
fixture_->SetDensity(density);
}
inline float Fixture::GetFriction() const
{
KGE_ASSERT(fixture_);
return fixture_->GetFriction();
}
inline void Fixture::SetFriction(float friction)
{
KGE_ASSERT(fixture_);
fixture_->SetFriction(friction);
}
inline float Fixture::GetRestitution() const
{
KGE_ASSERT(fixture_);
return fixture_->GetRestitution();
}
inline void Fixture::SetRestitution(float restitution)
{
KGE_ASSERT(fixture_);
fixture_->SetRestitution(restitution);
}
inline bool Fixture::IsValid() const
{
return fixture_ != nullptr;
}
inline b2Fixture* Fixture::GetB2Fixture() const
{
return fixture_;
}
inline void Fixture::SetB2Fixture(b2Fixture* fixture)
{
fixture_ = fixture;
}
inline bool Fixture::operator==(const Fixture& rhs) const
{
return fixture_ == rhs.fixture_;
}
inline bool Fixture::operator!=(const Fixture& rhs) const
{
return fixture_ != rhs.fixture_;
}
} // namespace physics
} // namespace kiwano

503
src/kiwano-physics/Joint.cpp
View File

@ -23,26 +23,26 @@
namespace kiwano
{
namespace physics
{
//
// Joint
//
namespace physics
{
//
// Joint
//
Joint::Joint()
Joint::Joint()
: joint_(nullptr)
, world_(nullptr)
, type_(Type::Unknown)
{
}
{
}
Joint::~Joint()
{
Joint::~Joint()
{
Destroy();
}
}
bool Joint::InitJoint(World* world, b2JointDef* joint_def)
{
bool Joint::InitJoint(World* world, b2JointDef* joint_def)
{
KGE_ASSERT(world);
Destroy();
@ -58,89 +58,90 @@ namespace kiwano
return joint != nullptr;
}
return false;
}
}
BodyPtr Joint::GetBodyA() const
{
BodyPtr Joint::GetBodyA() const
{
KGE_ASSERT(joint_);
b2Body* body = joint_->GetBodyA();
return BodyPtr(static_cast<Body*>(body->GetUserData()));
}
}
BodyPtr Joint::GetBodyB() const
{
BodyPtr Joint::GetBodyB() const
{
KGE_ASSERT(joint_);
b2Body* body = joint_->GetBodyB();
return BodyPtr(static_cast<Body*>(body->GetUserData()));
}
}
void Joint::SetB2Joint(b2Joint* joint)
{
void Joint::SetB2Joint(b2Joint* joint)
{
joint_ = joint;
if (joint_)
{
type_ = Joint::Type(joint_->GetType());
}
}
}
void Joint::Destroy()
{
void Joint::Destroy()
{
if (world_)
{
world_->RemoveJoint(this);
}
}
}
//
// DistanceJoint
//
//
// DistanceJoint
//
DistanceJoint::DistanceJoint()
DistanceJoint::DistanceJoint()
: Joint()
, raw_joint_(nullptr)
{
}
{
}
bool DistanceJoint::InitJoint(World* world, DistanceJoint::Param const& param)
{
bool DistanceJoint::InitJoint(World* world, DistanceJoint::Param const& param)
{
KGE_ASSERT(param.body_a && param.body_b);
b2DistanceJointDef def;
def.Initialize(param.body_a->GetB2Body(), param.body_b->GetB2Body(), world->Stage2World(param.anchor_a), world->Stage2World(param.anchor_b));
def.Initialize(param.body_a->GetB2Body(), param.body_b->GetB2Body(), world->Stage2World(param.anchor_a),
world->Stage2World(param.anchor_b));
def.frequencyHz = param.frequency_hz;
def.dampingRatio = param.damping_ratio;
Joint::InitJoint(world, &def);
raw_joint_ = static_cast<b2DistanceJoint*>(GetB2Joint());
return raw_joint_ != nullptr;
}
}
void DistanceJoint::SetLength(float length)
{
void DistanceJoint::SetLength(float length)
{
KGE_ASSERT(raw_joint_ && GetWorld());
raw_joint_->SetLength(GetWorld()->Stage2World(length));
}
}
float DistanceJoint::GetLength() const
{
float DistanceJoint::GetLength() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetLength());
}
}
//
// FrictionJoint
//
//
// FrictionJoint
//
FrictionJoint::FrictionJoint()
FrictionJoint::FrictionJoint()
: Joint()
, raw_joint_(nullptr)
{
}
{
}
bool FrictionJoint::InitJoint(World* world, FrictionJoint::Param const& param)
{
bool FrictionJoint::InitJoint(World* world, FrictionJoint::Param const& param)
{
KGE_ASSERT(param.body_a && param.body_b);
b2FrictionJointDef def;
@ -151,44 +152,44 @@ namespace kiwano
Joint::InitJoint(world, &def);
raw_joint_ = static_cast<b2FrictionJoint*>(GetB2Joint());
return raw_joint_ != nullptr;
}
}
void FrictionJoint::SetMaxForce(float length)
{
void FrictionJoint::SetMaxForce(float length)
{
KGE_ASSERT(raw_joint_);
raw_joint_->SetMaxForce(length);
}
}
float FrictionJoint::GetMaxForce() const
{
float FrictionJoint::GetMaxForce() const
{
KGE_ASSERT(raw_joint_);
return raw_joint_->GetMaxForce();
}
}
void FrictionJoint::SetMaxTorque(float length)
{
void FrictionJoint::SetMaxTorque(float length)
{
KGE_ASSERT(raw_joint_ && GetWorld());
raw_joint_->SetMaxTorque(GetWorld()->Stage2World(length));
}
}
float FrictionJoint::GetMaxTorque() const
{
float FrictionJoint::GetMaxTorque() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetMaxTorque());
}
}
//
// GearJoint
//
//
// GearJoint
//
GearJoint::GearJoint()
GearJoint::GearJoint()
: Joint()
, raw_joint_(nullptr)
{
}
{
}
bool GearJoint::InitJoint(World* world, GearJoint::Param const& param)
{
bool GearJoint::InitJoint(World* world, GearJoint::Param const& param)
{
KGE_ASSERT(param.joint_a && param.joint_b);
b2GearJointDef def;
@ -199,32 +200,32 @@ namespace kiwano
Joint::InitJoint(world, &def);
raw_joint_ = static_cast<b2GearJoint*>(GetB2Joint());
return raw_joint_ != nullptr;
}
}
void GearJoint::SetRatio(float ratio)
{
void GearJoint::SetRatio(float ratio)
{
KGE_ASSERT(raw_joint_);
raw_joint_->SetRatio(ratio);
}
}
float GearJoint::GetRatio() const
{
float GearJoint::GetRatio() const
{
KGE_ASSERT(raw_joint_);
return raw_joint_->GetRatio();
}
}
//
// MotorJoint
//
//
// MotorJoint
//
MotorJoint::MotorJoint()
MotorJoint::MotorJoint()
: Joint()
, raw_joint_(nullptr)
{
}
{
}
bool MotorJoint::InitJoint(World* world, MotorJoint::Param const& param)
{
bool MotorJoint::InitJoint(World* world, MotorJoint::Param const& param)
{
KGE_ASSERT(param.body_a && param.body_b);
b2MotorJointDef def;
@ -236,48 +237,49 @@ namespace kiwano
Joint::InitJoint(world, &def);
raw_joint_ = static_cast<b2MotorJoint*>(GetB2Joint());
return raw_joint_ != nullptr;
}
}
void MotorJoint::SetMaxForce(float length)
{
void MotorJoint::SetMaxForce(float length)
{
KGE_ASSERT(raw_joint_);
raw_joint_->SetMaxForce(length);
}
}
float MotorJoint::GetMaxForce() const
{
float MotorJoint::GetMaxForce() const
{
KGE_ASSERT(raw_joint_);
return raw_joint_->GetMaxForce();
}
}
void MotorJoint::SetMaxTorque(float length)
{
void MotorJoint::SetMaxTorque(float length)
{
KGE_ASSERT(raw_joint_ && GetWorld());
raw_joint_->SetMaxTorque(GetWorld()->Stage2World(length));
}
}
float MotorJoint::GetMaxTorque() const
{
float MotorJoint::GetMaxTorque() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetMaxTorque());
}
}
//
// PrismaticJoint
//
//
// PrismaticJoint
//
PrismaticJoint::PrismaticJoint()
PrismaticJoint::PrismaticJoint()
: Joint()
, raw_joint_(nullptr)
{
}
{
}
bool PrismaticJoint::InitJoint(World* world, PrismaticJoint::Param const& param)
{
bool PrismaticJoint::InitJoint(World* world, PrismaticJoint::Param const& param)
{
KGE_ASSERT(param.body_a && param.body_b);
b2PrismaticJointDef def;
def.Initialize(param.body_a->GetB2Body(), param.body_b->GetB2Body(), world->Stage2World(param.anchor), Stage2World(param.axis));
def.Initialize(param.body_a->GetB2Body(), param.body_b->GetB2Body(), world->Stage2World(param.anchor),
Stage2World(param.axis));
def.enableLimit = param.enable_limit;
def.lowerTranslation = world->Stage2World(param.lower_translation);
def.upperTranslation = world->Stage2World(param.upper_translation);
@ -288,115 +290,116 @@ namespace kiwano
Joint::InitJoint(world, &def);
raw_joint_ = static_cast<b2PrismaticJoint*>(GetB2Joint());
return raw_joint_ != nullptr;
}
}
float PrismaticJoint::GetJointTranslation() const
{
float PrismaticJoint::GetJointTranslation() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetJointTranslation());
}
}
float PrismaticJoint::GetJointSpeed() const
{
float PrismaticJoint::GetJointSpeed() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetJointSpeed());
}
}
float PrismaticJoint::GetLowerLimit() const
{
float PrismaticJoint::GetLowerLimit() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetLowerLimit());
}
}
float PrismaticJoint::GetUpperLimit() const
{
float PrismaticJoint::GetUpperLimit() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetUpperLimit());
}
}
void PrismaticJoint::SetLimits(float lower, float upper)
{
void PrismaticJoint::SetLimits(float lower, float upper)
{
KGE_ASSERT(raw_joint_ && GetWorld());
raw_joint_->SetLimits(GetWorld()->Stage2World(lower), GetWorld()->Stage2World(upper));
}
}
//
// PulleyJoint
//
//
// PulleyJoint
//
PulleyJoint::PulleyJoint()
PulleyJoint::PulleyJoint()
: Joint()
, raw_joint_(nullptr)
{
}
{
}
bool PulleyJoint::InitJoint(World* world, PulleyJoint::Param const& param)
{
bool PulleyJoint::InitJoint(World* world, PulleyJoint::Param const& param)
{
KGE_ASSERT(param.body_a && param.body_b);
b2PulleyJointDef def;
def.Initialize(param.body_a->GetB2Body(), param.body_b->GetB2Body(), world->Stage2World(param.ground_anchor_a), world->Stage2World(param.ground_anchor_b),
world->Stage2World(param.anchor_a), world->Stage2World(param.anchor_b), param.ratio);
def.Initialize(param.body_a->GetB2Body(), param.body_b->GetB2Body(), world->Stage2World(param.ground_anchor_a),
world->Stage2World(param.ground_anchor_b), world->Stage2World(param.anchor_a),
world->Stage2World(param.anchor_b), param.ratio);
Joint::InitJoint(world, &def);
raw_joint_ = static_cast<b2PulleyJoint*>(GetB2Joint());
return raw_joint_ != nullptr;
}
}
Point PulleyJoint::GetGroundAnchorA() const
{
Point PulleyJoint::GetGroundAnchorA() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetGroundAnchorA());
}
}
Point PulleyJoint::GetGroundAnchorB() const
{
Point PulleyJoint::GetGroundAnchorB() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetGroundAnchorB());
}
}
float PulleyJoint::GetRatio() const
{
float PulleyJoint::GetRatio() const
{
KGE_ASSERT(raw_joint_);
return raw_joint_->GetRatio();
}
}
float PulleyJoint::GetLengthA() const
{
float PulleyJoint::GetLengthA() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetLengthA());
}
}
float PulleyJoint::GetLengthB() const
{
float PulleyJoint::GetLengthB() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetLengthB());
}
}
float PulleyJoint::GetCurrentLengthA() const
{
float PulleyJoint::GetCurrentLengthA() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetCurrentLengthA());
}
}
float PulleyJoint::GetCurrentLengthB() const
{
float PulleyJoint::GetCurrentLengthB() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetCurrentLengthB());
}
}
//
// RevoluteJoint
//
//
// RevoluteJoint
//
RevoluteJoint::RevoluteJoint()
RevoluteJoint::RevoluteJoint()
: Joint()
, raw_joint_(nullptr)
{
}
{
}
bool RevoluteJoint::InitJoint(World* world, RevoluteJoint::Param const& param)
{
bool RevoluteJoint::InitJoint(World* world, RevoluteJoint::Param const& param)
{
KGE_ASSERT(param.body_a && param.body_b);
b2RevoluteJointDef def;
@ -411,62 +414,62 @@ namespace kiwano
Joint::InitJoint(world, &def);
raw_joint_ = static_cast<b2RevoluteJoint*>(GetB2Joint());
return raw_joint_ != nullptr;
}
}
float RevoluteJoint::GetJointAngle() const
{
float RevoluteJoint::GetJointAngle() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return math::Radian2Degree(raw_joint_->GetJointAngle());
}
}
float RevoluteJoint::GetJointSpeed() const
{
float RevoluteJoint::GetJointSpeed() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return math::Radian2Degree(raw_joint_->GetJointSpeed());
}
}
float RevoluteJoint::GetLowerLimit() const
{
float RevoluteJoint::GetLowerLimit() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return math::Radian2Degree(raw_joint_->GetLowerLimit());
}
}
float RevoluteJoint::GetUpperLimit() const
{
float RevoluteJoint::GetUpperLimit() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return math::Radian2Degree(raw_joint_->GetUpperLimit());
}
}
void RevoluteJoint::SetLimits(float lower, float upper)
{
void RevoluteJoint::SetLimits(float lower, float upper)
{
KGE_ASSERT(raw_joint_ && GetWorld());
raw_joint_->SetLimits(math::Degree2Radian(lower), math::Degree2Radian(upper));
}
}
void RevoluteJoint::SetMaxMotorTorque(float torque)
{
void RevoluteJoint::SetMaxMotorTorque(float torque)
{
KGE_ASSERT(raw_joint_ && GetWorld());
raw_joint_->SetMaxMotorTorque(GetWorld()->Stage2World(torque));
}
}
float RevoluteJoint::GetMaxMotorTorque() const
{
float RevoluteJoint::GetMaxMotorTorque() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetMaxMotorTorque());
}
}
//
// RopeJoint
//
//
// RopeJoint
//
RopeJoint::RopeJoint()
RopeJoint::RopeJoint()
: Joint()
, raw_joint_(nullptr)
{
}
{
}
bool RopeJoint::InitJoint(World* world, RopeJoint::Param const& param)
{
bool RopeJoint::InitJoint(World* world, RopeJoint::Param const& param)
{
KGE_ASSERT(param.body_a && param.body_b);
b2RopeJointDef def;
@ -479,32 +482,32 @@ namespace kiwano
Joint::InitJoint(world, &def);
raw_joint_ = static_cast<b2RopeJoint*>(GetB2Joint());
return raw_joint_ != nullptr;
}
}
void RopeJoint::SetMaxLength(float length)
{
void RopeJoint::SetMaxLength(float length)
{
KGE_ASSERT(raw_joint_ && GetWorld());
raw_joint_->SetMaxLength(GetWorld()->Stage2World(length));
}
}
float RopeJoint::GetMaxLength() const
{
float RopeJoint::GetMaxLength() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetMaxLength());
}
}
//
// WeldJoint
//
//
// WeldJoint
//
WeldJoint::WeldJoint()
WeldJoint::WeldJoint()
: Joint()
, raw_joint_(nullptr)
{
}
{
}
bool WeldJoint::InitJoint(World* world, WeldJoint::Param const& param)
{
bool WeldJoint::InitJoint(World* world, WeldJoint::Param const& param)
{
KGE_ASSERT(param.body_a && param.body_b);
b2WeldJointDef def;
@ -515,25 +518,25 @@ namespace kiwano
Joint::InitJoint(world, &def);
raw_joint_ = static_cast<b2WeldJoint*>(GetB2Joint());
return raw_joint_ != nullptr;
}
}
//
// WheelJoint
//
//
// WheelJoint
//
WheelJoint::WheelJoint()
WheelJoint::WheelJoint()
: Joint()
, raw_joint_(nullptr)
{
}
{
}
bool WheelJoint::InitJoint(World* world, WheelJoint::Param const& param)
{
bool WheelJoint::InitJoint(World* world, WheelJoint::Param const& param)
{
KGE_ASSERT(param.body_a && param.body_b);
b2WheelJointDef def;
def.Initialize(param.body_a->GetB2Body(), param.body_b->GetB2Body(), world->Stage2World(param.anchor), Stage2World(param.axis));
def.Initialize(param.body_a->GetB2Body(), param.body_b->GetB2Body(), world->Stage2World(param.anchor),
Stage2World(param.axis));
def.enableMotor = param.enable_motor;
def.maxMotorTorque = world->Stage2World(param.max_motor_torque);
def.motorSpeed = world->Stage2World(param.motor_speed);
@ -543,44 +546,44 @@ namespace kiwano
Joint::InitJoint(world, &def);
raw_joint_ = static_cast<b2WheelJoint*>(GetB2Joint());
return raw_joint_ != nullptr;
}
}
float WheelJoint::GetJointTranslation() const
{
float WheelJoint::GetJointTranslation() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetJointTranslation());
}
}
float WheelJoint::GetJointLinearSpeed() const
{
float WheelJoint::GetJointLinearSpeed() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetJointLinearSpeed());
}
}
void WheelJoint::SetMaxMotorTorque(float torque)
{
void WheelJoint::SetMaxMotorTorque(float torque)
{
KGE_ASSERT(raw_joint_ && GetWorld());
raw_joint_->SetMaxMotorTorque(GetWorld()->Stage2World(torque));
}
}
float WheelJoint::GetMaxMotorTorque() const
{
float WheelJoint::GetMaxMotorTorque() const
{
KGE_ASSERT(raw_joint_ && GetWorld());
return GetWorld()->World2Stage(raw_joint_->GetMaxMotorTorque());
}
}
//
// MouseJoint
//
//
// MouseJoint
//
MouseJoint::MouseJoint()
MouseJoint::MouseJoint()
: Joint()
, raw_joint_(nullptr)
{
}
{
}
bool MouseJoint::InitJoint(World* world, MouseJoint::Param const& param)
{
bool MouseJoint::InitJoint(World* world, MouseJoint::Param const& param)
{
KGE_ASSERT(param.body_a && param.body_b);
b2MouseJointDef def;
@ -594,19 +597,19 @@ namespace kiwano
Joint::InitJoint(world, &def);
raw_joint_ = static_cast<b2MouseJoint*>(GetB2Joint());
return raw_joint_ != nullptr;
}
}
void MouseJoint::SetMaxForce(float length)
{
void MouseJoint::SetMaxForce(float length)
{
KGE_ASSERT(raw_joint_);
raw_joint_->SetMaxForce(length);
}
}
float MouseJoint::GetMaxForce() const
{
float MouseJoint::GetMaxForce() const
{
KGE_ASSERT(raw_joint_);
return raw_joint_->GetMaxForce();
}
}
}
}
} // namespace physics
} // namespace kiwano

788
src/kiwano-physics/Joint.h
View File

File diff suppressed because it is too large Load Diff

182
src/kiwano-physics/Shape.cpp
View File

@ -23,114 +23,114 @@
namespace kiwano
{
namespace physics
{
Shape::Shape()
namespace physics
{
Shape::Shape()
: shape_(nullptr)
{
}
{
}
Shape::Shape(b2Shape* shape)
Shape::Shape(b2Shape* shape)
: shape_(shape)
{
}
{
}
b2Shape* Shape::GetB2Shape() const
{
b2Shape* Shape::GetB2Shape() const
{
return shape_;
}
}
void Shape::SetB2Shape(b2Shape* shape)
{
void Shape::SetB2Shape(b2Shape* shape)
{
shape_ = shape;
}
}
//
// CircleShape
//
//
// CircleShape
//
CircleShape::CircleShape()
CircleShape::CircleShape()
: Shape(&circle_)
, circle_()
, radius_(0.f)
{
}
{
}
CircleShape::CircleShape(float radius, Point const& offset)
CircleShape::CircleShape(float radius, Point const& offset)
: CircleShape()
{
{
Set(radius, offset);
}
}
void CircleShape::Set(float radius, Point const& offset)
{
void CircleShape::Set(float radius, Point const& offset)
{
radius_ = radius;
offset_ = offset;
}
}
void CircleShape::FitWorld(World* world)
{
void CircleShape::FitWorld(World* world)
{
KGE_ASSERT(world);
circle_.m_radius = world->Stage2World(radius_);
circle_.m_p = world->Stage2World(offset_);
}
}
//
// BoxShape
//
//
// BoxShape
//
BoxShape::BoxShape()
BoxShape::BoxShape()
: Shape(&polygon_)
, polygon_()
, rotation_(0.f)
{
}
{
}
BoxShape::BoxShape(Vec2 const& size, Point const& offset, float rotation)
BoxShape::BoxShape(Vec2 const& size, Point const& offset, float rotation)
: BoxShape()
{
{
Set(size, offset, rotation);
}
}
void BoxShape::Set(Vec2 const& size, Point const& offset, float rotation)
{
void BoxShape::Set(Vec2 const& size, Point const& offset, float rotation)
{
box_size_ = size;
offset_ = offset;
rotation_ = rotation;
}
}
void BoxShape::FitWorld(World* world)
{
void BoxShape::FitWorld(World* world)
{
KGE_ASSERT(world);
b2Vec2 box = world->Stage2World(box_size_);
b2Vec2 offset = world->Stage2World(offset_);
polygon_.SetAsBox(box.x / 2, box.y / 2, offset, rotation_);
}
}
//
// PolygonShape
//
//
// PolygonShape
//
PolygonShape::PolygonShape()
PolygonShape::PolygonShape()
: Shape(&polygon_)
, polygon_()
{
}
{
}
PolygonShape::PolygonShape(Vector<Point> const& vertexs)
PolygonShape::PolygonShape(Vector<Point> const& vertexs)
: PolygonShape()
{
{
Set(vertexs);
}
}
void PolygonShape::Set(Vector<Point> const& vertexs)
{
void PolygonShape::Set(Vector<Point> const& vertexs)
{
vertexs_ = vertexs;
}
}
void PolygonShape::FitWorld(World* world)
{
void PolygonShape::FitWorld(World* world)
{
KGE_ASSERT(world);
Vector<b2Vec2> b2vertexs;
@ -141,64 +141,64 @@ namespace kiwano
}
polygon_.Set(&b2vertexs[0], static_cast<int32>(b2vertexs.size()));
}
}
//
// EdgeShape
//
//
// EdgeShape
//
EdgeShape::EdgeShape()
EdgeShape::EdgeShape()
: Shape(&edge_)
, edge_()
{
}
{
}
EdgeShape::EdgeShape(Point const& p1, Point const& p2)
EdgeShape::EdgeShape(Point const& p1, Point const& p2)
: EdgeShape()
{
{
Set(p1, p2);
}
}
void EdgeShape::Set(Point const& p1, Point const& p2)
{
void EdgeShape::Set(Point const& p1, Point const& p2)
{
p_[0] = p1;
p_[1] = p2;
}
}
void EdgeShape::FitWorld(World* world)
{
void EdgeShape::FitWorld(World* world)
{
KGE_ASSERT(world);
b2Vec2 p1 = world->Stage2World(p_[0]);
b2Vec2 p2 = world->Stage2World(p_[1]);
edge_.Set(p1, p2);
}
}
//
// ChainShape
//
//
// ChainShape
//
ChainShape::ChainShape()
ChainShape::ChainShape()
: Shape(&chain_)
, chain_()
, loop_(false)
{
}
{
}
ChainShape::ChainShape(Vector<Point> const& vertexs, bool loop)
ChainShape::ChainShape(Vector<Point> const& vertexs, bool loop)
: ChainShape()
{
{
Set(vertexs, loop);
}
}
void ChainShape::Set(Vector<Point> const& vertexs, bool loop)
{
void ChainShape::Set(Vector<Point> const& vertexs, bool loop)
{
vertexs_ = vertexs;
loop_ = loop;
}
}
void ChainShape::FitWorld(World* world)
{
void ChainShape::FitWorld(World* world)
{
KGE_ASSERT(world);
Vector<b2Vec2> b2vertexs;
@ -216,7 +216,7 @@ namespace kiwano
{
chain_.CreateChain(&b2vertexs[0], static_cast<int32>(b2vertexs.size()));
}
}
}
}
}
} // namespace physics
} // namespace kiwano

117
src/kiwano-physics/Shape.h
View File

@ -23,140 +23,135 @@
namespace kiwano
{
namespace physics
{
class World;
class Fixture;
namespace physics
{
class World;
class Fixture;
/**
/**
* \addtogroup Physics
* @{
*/
/// \~chinese
/// @brief 形状基类
class KGE_API Shape
{
/// \~chinese
/// @brief 形状基类
class KGE_API Shape
{
friend class Fixture;
public:
public:
Shape();
Shape(b2Shape* shape);
b2Shape* GetB2Shape() const;
void SetB2Shape(b2Shape* shape);
private:
private:
virtual void FitWorld(World* world) {}
private:
private:
b2Shape* shape_;
};
};
/// \~chinese
/// @brief 圆形形状
class KGE_API CircleShape
: public Shape
{
public:
/// \~chinese
/// @brief 圆形形状
class KGE_API CircleShape : public Shape
{
public:
CircleShape();
CircleShape(float radius, Point const& offset = Point());
void Set(float radius, Point const& offset = Point());
private:
private:
void FitWorld(World* world) override;
private:
private:
float radius_;
Point offset_;
b2CircleShape circle_;
};
};
/// \~chinese
/// @brief 盒子形状
class KGE_API BoxShape
: public Shape
{
public:
/// \~chinese
/// @brief 盒子形状
class KGE_API BoxShape : public Shape
{
public:
BoxShape();
BoxShape(Vec2 const& size, Point const& offset = Point(), float rotation = 0.f);
void Set(Vec2 const& size, Point const& offset = Point(), float rotation = 0.f);
private:
private:
void FitWorld(World* world) override;
private:
private:
float rotation_;
Vec2 box_size_;
Point offset_;
b2PolygonShape polygon_;
};
};
/// \~chinese
/// @brief 多边形形状
class KGE_API PolygonShape
: public Shape
{
public:
/// \~chinese
/// @brief 多边形形状
class KGE_API PolygonShape : public Shape
{
public:
PolygonShape();
PolygonShape(Vector<Point> const& vertexs);
void Set(Vector<Point> const& vertexs);
private:
private:
void FitWorld(World* world) override;
private:
private:
Vector<Point> vertexs_;
b2PolygonShape polygon_;
};
};
/// \~chinese
/// @brief 线段形状, 用于表示一条边
class KGE_API EdgeShape
: public Shape
{
public:
/// \~chinese
/// @brief 线段形状, 用于表示一条边
class KGE_API EdgeShape : public Shape
{
public:
EdgeShape();
EdgeShape(Point const& p1, Point const& p2);
void Set(Point const& p1, Point const& p2);
private:
private:
void FitWorld(World* world) override;
private:
private:
Point p_[2];
b2EdgeShape edge_;
};
};
/// \~chinese
/// @brief 链式形状
class KGE_API ChainShape
: public Shape
{
public:
/// \~chinese
/// @brief 链式形状
class KGE_API ChainShape : public Shape
{
public:
ChainShape();
ChainShape(Vector<Point> const& vertexs, bool loop = false);
void Set(Vector<Point> const& vertexs, bool loop = false);
private:
private:
void FitWorld(World* world) override;
private:
private:
bool loop_;
Vector<Point> vertexs_;
b2ChainShape chain_;
};
};
/** @} */
}
}
/** @} */
} // namespace physics
} // namespace kiwano

142
src/kiwano-physics/World.cpp
View File

@ -19,22 +19,23 @@
// THE SOFTWARE.
#include "World.h"
#include <kiwano-physics/ContactEvent.h>
namespace kiwano
{
namespace physics
{
namespace
{
const float default_global_scale = 100.f; // 100 pixels per meters
}
namespace physics
{
namespace
{
const float default_global_scale = 100.f; // 100 pixels per meters
}
class World::DestructionListener : public b2DestructionListener
{
class World::DestructionListener : public b2DestructionListener
{
World* world_;
public:
public:
DestructionListener(World* world)
: world_(world)
{
@ -48,18 +49,14 @@ namespace kiwano
}
}
void SayGoodbye(b2Fixture* fixture) override
{
void SayGoodbye(b2Fixture* fixture) override {}
};
}
};
class World::ContactListener
: public b2ContactListener
{
class World::ContactListener : public b2ContactListener
{
World* world_;
public:
public:
ContactListener(World* world)
: world_(world)
{
@ -77,11 +74,19 @@ namespace kiwano
world_->DispatchEvent(evt.get());
}
void PreSolve(b2Contact* contact, const b2Manifold* oldManifold) override { KGE_NOT_USED(contact); KGE_NOT_USED(oldManifold); }
void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse) override { KGE_NOT_USED(contact); KGE_NOT_USED(impulse); }
};
void PreSolve(b2Contact* contact, const b2Manifold* oldManifold) override
{
KGE_NOT_USED(contact);
KGE_NOT_USED(oldManifold);
}
void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse) override
{
KGE_NOT_USED(contact);
KGE_NOT_USED(impulse);
}
};
World::World()
World::World()
: world_(b2Vec2(0, 10.0f))
, vel_iter_(6)
, pos_iter_(2)
@ -89,16 +94,16 @@ namespace kiwano
, destruction_listener_(nullptr)
, contact_listener_(nullptr)
, removing_joint_(false)
{
{
destruction_listener_ = new DestructionListener(this);
world_.SetDestructionListener(destruction_listener_);
contact_listener_ = new ContactListener(this);
world_.SetContactListener(contact_listener_);
}
}
World::~World()
{
World::~World()
{
world_.SetDestructionListener(nullptr);
if (destruction_listener_)
{
@ -117,18 +122,18 @@ namespace kiwano
RemoveAllChildren();
RemoveAllBodies();
RemoveAllJoints();
}
}
void World::RemoveBody(Body* body)
{
void World::RemoveBody(Body* body)
{
if (body && body->GetB2Body())
{
world_.DestroyBody(body->GetB2Body());
}
}
}
void World::RemoveAllBodies()
{
void World::RemoveAllBodies()
{
if (world_.GetBodyCount())
{
b2Body* body = world_.GetBodyList();
@ -139,18 +144,18 @@ namespace kiwano
body = next;
}
}
}
}
void World::AddJoint(Joint* joint)
{
void World::AddJoint(Joint* joint)
{
if (joint)
{
joints_.push_back(joint);
}
}
}
void World::RemoveJoint(Joint* joint)
{
void World::RemoveJoint(Joint* joint)
{
if (joint)
{
auto iter = std::find(joints_.begin(), joints_.end(), joint);
@ -166,10 +171,10 @@ namespace kiwano
}
}
}
}
}
void World::RemoveAllJoints()
{
void World::RemoveAllJoints()
{
if (world_.GetJointCount())
{
removing_joint_ = true;
@ -185,53 +190,50 @@ namespace kiwano
removing_joint_ = false;
}
joints_.clear();
}
}
void World::JointRemoved(b2Joint* joint)
{
void World::JointRemoved(b2Joint* joint)
{
if (!removing_joint_ && joint)
{
auto iter = std::find_if(
joints_.begin(),
joints_.end(),
[joint](Joint* j) -> bool { return j->GetB2Joint() == joint; }
);
auto iter = std::find_if(joints_.begin(), joints_.end(),
[joint](Joint* j) -> bool { return j->GetB2Joint() == joint; });
if (iter != joints_.end())
{
joints_.erase(iter);
}
}
}
}
b2World* World::GetB2World()
{
b2World* World::GetB2World()
{
return &world_;
}
}
const b2World* World::GetB2World() const
{
const b2World* World::GetB2World() const
{
return &world_;
}
}
Vec2 World::GetGravity() const
{
Vec2 World::GetGravity() const
{
b2Vec2 g = world_.GetGravity();
return Vec2(g.x, g.y);
}
}
void World::SetGravity(Vec2 gravity)
{
void World::SetGravity(Vec2 gravity)
{
world_.SetGravity(b2Vec2(gravity.x, gravity.y));
}
}
ContactList World::GetContactList()
{
ContactList World::GetContactList()
{
return ContactList(Contact(world_.GetContactList()));
}
}
void World::Update(Duration dt)
{
void World::Update(Duration dt)
{
world_.Step(dt.Seconds(), vel_iter_, pos_iter_);
b2Body* b2body = world_.GetBodyList();
@ -247,7 +249,7 @@ namespace kiwano
}
Stage::Update(dt);
}
}
}
} // namespace physics
} // namespace kiwano

108
src/kiwano-physics/World.h
View File

@ -24,31 +24,30 @@
namespace kiwano
{
namespace physics
{
KGE_DECLARE_SMART_PTR(World);
namespace physics
{
KGE_DECLARE_SMART_PTR(World);
/**
/**
* \~chinese
* \defgroup Physics 物理引擎
*/
/**
/**
* \addtogroup Physics
* @{
*/
/**
/**
* \~chinese
* @brief 物理世界
*/
class KGE_API World
: public Stage
{
class KGE_API World : public Stage
{
friend class Body;
friend class Joint;
public:
public:
World();
virtual ~World();
@ -107,7 +106,7 @@ namespace kiwano
const b2World* GetB2World() const;
private:
private:
/// \~chinese
/// @brief 移除物体
void RemoveBody(Body* body);
@ -132,10 +131,10 @@ namespace kiwano
/// @brief 关节被移除
void JointRemoved(b2Joint* joint);
protected:
protected:
void Update(Duration dt) override;
private:
private:
b2World world_;
int vel_iter_;
int pos_iter_;
@ -151,49 +150,48 @@ namespace kiwano
bool removing_joint_;
Vector<Joint*> joints_;
};
};
/** @} */
/** @} */
inline float World::GetGlobalScale() const
{
inline float World::GetGlobalScale() const
{
return global_scale_;
}
inline void World::SetGlobalScale(float scale)
{
global_scale_ = scale;
}
inline float World::World2Stage(float value) const
{
return value * GetGlobalScale();
}
inline Vec2 World::World2Stage(const b2Vec2& pos) const
{
return Point(World2Stage(pos.x), World2Stage(pos.y));
}
inline float World::Stage2World(float value) const
{
return value / GetGlobalScale();
}
inline b2Vec2 World::Stage2World(const Vec2& pos) const
{
return b2Vec2(Stage2World(pos.x), Stage2World(pos.y));
}
inline void World::SetVelocityIterations(int vel_iter)
{
vel_iter_ = vel_iter;
}
inline void World::SetPositionIterations(int pos_iter)
{
pos_iter_ = pos_iter;
}
}
}
inline void World::SetGlobalScale(float scale)
{
global_scale_ = scale;
}
inline float World::World2Stage(float value) const
{
return value * GetGlobalScale();
}
inline Vec2 World::World2Stage(const b2Vec2& pos) const
{
return Point(World2Stage(pos.x), World2Stage(pos.y));
}
inline float World::Stage2World(float value) const
{
return value / GetGlobalScale();
}
inline b2Vec2 World::Stage2World(const Vec2& pos) const
{
return b2Vec2(Stage2World(pos.x), Stage2World(pos.y));
}
inline void World::SetVelocityIterations(int vel_iter)
{
vel_iter_ = vel_iter;
}
inline void World::SetPositionIterations(int pos_iter)
{
pos_iter_ = pos_iter;
}
} // namespace physics
} // namespace kiwano

16
src/kiwano-physics/helper.h
View File

@ -26,9 +26,15 @@
namespace kiwano
{
namespace physics
{
inline b2Vec2 Stage2World(const Vec2& pos) { return b2Vec2(pos.x, pos.y); }
inline Vec2 World2Stage(const b2Vec2& pos) { return Vec2(pos.x, pos.y); }
}
namespace physics
{
inline b2Vec2 Stage2World(const Vec2& pos)
{
return b2Vec2(pos.x, pos.y);
}
inline Vec2 World2Stage(const b2Vec2& pos)
{
return Vec2(pos.x, pos.y);
}
} // namespace physics
} // namespace kiwano

6
src/kiwano-physics/kiwano-physics.h
View File

@ -20,10 +20,10 @@
#pragma once
#include <kiwano-physics/Shape.h>
#include <kiwano-physics/Fixture.h>
#include <kiwano-physics/Body.h>
#include <kiwano-physics/Contact.h>
#include <kiwano-physics/ContactEvent.h>
#include <kiwano-physics/Body.h>
#include <kiwano-physics/Fixture.h>
#include <kiwano-physics/Joint.h>
#include <kiwano-physics/Shape.h>
#include <kiwano-physics/World.h>

307
src/kiwano/2d/Actor.cpp
View File

@ -25,19 +25,19 @@
namespace kiwano
{
namespace
{
float default_anchor_x = 0.f;
float default_anchor_y = 0.f;
}
namespace
{
float default_anchor_x = 0.f;
float default_anchor_y = 0.f;
} // namespace
void Actor::SetDefaultAnchor(float anchor_x, float anchor_y)
{
void Actor::SetDefaultAnchor(float anchor_x, float anchor_y)
{
default_anchor_x = anchor_x;
default_anchor_y = anchor_y;
}
}
Actor::Actor()
Actor::Actor()
: visible_(true)
, visible_in_rt_(true)
, update_pausing_(false)
@ -57,15 +57,13 @@ namespace kiwano
, opacity_(1.f)
, displayed_opacity_(1.f)
, anchor_(default_anchor_x, default_anchor_y)
{
}
{
}
Actor::~Actor()
{
}
Actor::~Actor() {}
void Actor::Update(Duration dt)
{
void Actor::Update(Duration dt)
{
UpdateActions(this, dt);
UpdateTimers(dt);
@ -86,10 +84,10 @@ namespace kiwano
child->Update(dt);
}
}
}
}
void Actor::Render(RenderContext& ctx)
{
void Actor::Render(RenderContext& ctx)
{
if (!visible_)
return;
@ -128,16 +126,16 @@ namespace kiwano
child = child->next_item().get();
}
}
}
}
void Actor::PrepareToRender(RenderContext& ctx)
{
void Actor::PrepareToRender(RenderContext& ctx)
{
ctx.SetTransform(transform_matrix_);
ctx.SetBrushOpacity(GetDisplayedOpacity());
}
}
void Actor::RenderBorder(RenderContext& ctx)
{
void Actor::RenderBorder(RenderContext& ctx)
{
if (show_border_ && !size_.IsOrigin())
{
Rect bounds = GetBounds();
@ -155,10 +153,10 @@ namespace kiwano
{
child->RenderBorder(ctx);
}
}
}
bool Actor::CheckVisibility(RenderContext& ctx) const
{
bool Actor::CheckVisibility(RenderContext& ctx) const
{
if (dirty_visibility_)
{
dirty_visibility_ = false;
@ -173,10 +171,10 @@ namespace kiwano
}
}
return visible_in_rt_;
}
}
bool Actor::DispatchEvent(Event* evt)
{
bool Actor::DispatchEvent(Event* evt)
{
if (!visible_)
return true;
@ -206,10 +204,10 @@ namespace kiwano
child = child->prev_item().get();
}
return true;
}
}
void Actor::HandleEvent(Event* evt)
{
void Actor::HandleEvent(Event* evt)
{
if (responsible_)
{
if (evt->IsType<MouseMoveEvent>())
@ -252,16 +250,16 @@ namespace kiwano
EventDispatcher::DispatchEvent(click.get());
}
}
}
}
Matrix3x2 const & Actor::GetTransformMatrix() const
{
Matrix3x2 const& Actor::GetTransformMatrix() const
{
UpdateTransform();
return transform_matrix_;
}
}
Matrix3x2 const & Actor::GetTransformInverseMatrix() const
{
Matrix3x2 const& Actor::GetTransformInverseMatrix() const
{
UpdateTransform();
if (dirty_transform_inverse_)
{
@ -269,10 +267,10 @@ namespace kiwano
dirty_transform_inverse_ = false;
}
return transform_matrix_inverse_;
}
}
void Actor::UpdateTransform() const
{
void Actor::UpdateTransform() const
{
if (!dirty_transform_)
return;
@ -300,10 +298,10 @@ namespace kiwano
// update children's transform
for (auto child = children_.first_item().get(); child; child = child->next_item().get())
child->dirty_transform_ = true;
}
}
void Actor::UpdateOpacity()
{
void Actor::UpdateOpacity()
{
if (parent_ && parent_->IsCascadeOpacityEnabled())
{
displayed_opacity_ = opacity_ * parent_->displayed_opacity_;
@ -317,10 +315,10 @@ namespace kiwano
{
child->UpdateOpacity();
}
}
}
void Actor::SetStage(Stage* stage)
{
void Actor::SetStage(Stage* stage)
{
if (stage_ != stage)
{
stage_ = stage;
@ -329,10 +327,10 @@ namespace kiwano
child->stage_ = stage;
}
}
}
}
void Actor::Reorder()
{
void Actor::Reorder()
{
if (parent_)
{
ActorPtr me = this;
@ -361,140 +359,140 @@ namespace kiwano
parent_->children_.push_front(me);
}
}
}
}
void Actor::SetZOrder(int zorder)
{
void Actor::SetZOrder(int zorder)
{
if (z_order_ != zorder)
{
z_order_ = zorder;
Reorder();
}
}
}
void Actor::SetOpacity(float opacity)
{
void Actor::SetOpacity(float opacity)
{
if (opacity_ == opacity)
return;
displayed_opacity_ = opacity_ = std::min(std::max(opacity, 0.f), 1.f);
UpdateOpacity();
}
}
void Actor::SetCascadeOpacityEnabled(bool enabled)
{
void Actor::SetCascadeOpacityEnabled(bool enabled)
{
if (cascade_opacity_ == enabled)
return;
cascade_opacity_ = enabled;
UpdateOpacity();
}
}
void Actor::SetAnchor(Vec2 const& anchor)
{
void Actor::SetAnchor(Vec2 const& anchor)
{
if (anchor_ == anchor)
return;
anchor_ = anchor;
dirty_transform_ = true;
}
}
void Actor::SetWidth(float width)
{
void Actor::SetWidth(float width)
{
SetSize(Size{ width, size_.y });
}
}
void Actor::SetHeight(float height)
{
void Actor::SetHeight(float height)
{
SetSize(Size{ size_.x, height });
}
}
void Actor::SetSize(Size const& size)
{
void Actor::SetSize(Size const& size)
{
if (size_ == size)
return;
size_ = size;
dirty_transform_ = true;
}
}
void Actor::SetTransform(Transform const& transform)
{
void Actor::SetTransform(Transform const& transform)
{
transform_ = transform;
dirty_transform_ = true;
is_fast_transform_ = false;
}
}
void Actor::SetVisible(bool val)
{
void Actor::SetVisible(bool val)
{
visible_ = val;
}
}
void Actor::SetName(String const& name)
{
void Actor::SetName(String const& name)
{
if (!IsName(name))
{
ObjectBase::SetName(name);
hash_name_ = std::hash<String>{}(name);
}
}
}
void Actor::SetPosition(const Point & pos)
{
void Actor::SetPosition(const Point& pos)
{
if (transform_.position == pos)
return;
transform_.position = pos;
dirty_transform_ = true;
}
}
void Actor::SetPositionX(float x)
{
void Actor::SetPositionX(float x)
{
SetPosition(Point{ x, transform_.position.y });
}
}
void Actor::SetPositionY(float y)
{
void Actor::SetPositionY(float y)
{
SetPosition(Point{ transform_.position.x, y });
}
}
void Actor::Move(Vec2 const& v)
{
void Actor::Move(Vec2 const& v)
{
this->SetPosition(Point{ transform_.position.x + v.x, transform_.position.y + v.y });
}
}
void Actor::SetScale(Vec2 const& scale)
{
void Actor::SetScale(Vec2 const& scale)
{
if (transform_.scale == scale)
return;
transform_.scale = scale;
dirty_transform_ = true;
is_fast_transform_ = false;
}
}
void Actor::SetSkew(Vec2 const& skew)
{
void Actor::SetSkew(Vec2 const& skew)
{
if (transform_.skew == skew)
return;
transform_.skew = skew;
dirty_transform_ = true;
is_fast_transform_ = false;
}
}
void Actor::SetRotation(float angle)
{
void Actor::SetRotation(float angle)
{
if (transform_.rotation == angle)
return;
transform_.rotation = angle;
dirty_transform_ = true;
is_fast_transform_ = false;
}
}
void Actor::AddChild(Actor* child, int zorder)
{
void Actor::AddChild(Actor* child, int zorder)
{
KGE_ASSERT(child && "Actor::AddChild failed, NULL pointer exception");
if (child)
@ -523,33 +521,33 @@ namespace kiwano
child->Reorder();
child->UpdateOpacity();
}
}
}
void Actor::AddChild(ActorPtr child, int zorder)
{
void Actor::AddChild(ActorPtr child, int zorder)
{
AddChild(child.get());
}
}
void Actor::AddChildren(Vector<ActorPtr> const& children)
{
void Actor::AddChildren(Vector<ActorPtr> const& children)
{
for (const auto& actor : children)
{
this->AddChild(actor);
}
}
}
Rect Actor::GetBounds() const
{
Rect Actor::GetBounds() const
{
return Rect{ Point{}, size_ };
}
}
Rect Actor::GetBoundingBox() const
{
Rect Actor::GetBoundingBox() const
{
return GetTransformMatrix().Transform(GetBounds());
}
}
Vector<ActorPtr> Actor::GetChildren(String const& name) const
{
Vector<ActorPtr> Actor::GetChildren(String const& name) const
{
Vector<ActorPtr> children;
size_t hash_code = std::hash<String>{}(name);
@ -561,10 +559,10 @@ namespace kiwano
}
}
return children;
}
}
Actor* Actor::GetChild(String const& name) const
{
Actor* Actor::GetChild(String const& name) const
{
size_t hash_code = std::hash<String>{}(name);
for (auto child = children_.first_item().get(); child; child = child->next_item().get())
@ -575,33 +573,33 @@ namespace kiwano
}
}
return nullptr;
}
}
Actor::Children& Actor::GetAllChildren()
{
Actor::Children& Actor::GetAllChildren()
{
return children_;
}
}
Actor::Children const & Actor::GetAllChildren() const
{
Actor::Children const& Actor::GetAllChildren() const
{
return children_;
}
}
void Actor::RemoveFromParent()
{
void Actor::RemoveFromParent()
{
if (parent_)
{
parent_->RemoveChild(this);
}
}
}
void Actor::RemoveChild(ActorPtr child)
{
void Actor::RemoveChild(ActorPtr child)
{
RemoveChild(child.get());
}
}
void Actor::RemoveChild(Actor * child)
{
void Actor::RemoveChild(Actor* child)
{
KGE_ASSERT(child && "Actor::RemoveChild failed, NULL pointer exception");
if (children_.empty())
@ -610,13 +608,14 @@ namespace kiwano
if (child)
{
child->parent_ = nullptr;
if (child->stage_) child->SetStage(nullptr);
if (child->stage_)
child->SetStage(nullptr);
children_.remove(ActorPtr(child));
}
}
}
void Actor::RemoveChildren(String const& child_name)
{
void Actor::RemoveChildren(String const& child_name)
{
if (children_.empty())
{
return;
@ -634,25 +633,25 @@ namespace kiwano
RemoveChild(child);
}
}
}
}
void Actor::RemoveAllChildren()
{
void Actor::RemoveAllChildren()
{
children_.clear();
}
}
void Actor::SetResponsible(bool enable)
{
void Actor::SetResponsible(bool enable)
{
responsible_ = enable;
}
}
bool Actor::ContainsPoint(const Point& point) const
{
bool Actor::ContainsPoint(const Point& point) const
{
if (size_.x == 0.f || size_.y == 0.f)
return false;
Point local = GetTransformInverseMatrix().Transform(point);
return GetBounds().ContainsPoint(local);
}
}
} // namespace kiwano

472
src/kiwano/2d/Actor.h
View File

@ -19,49 +19,50 @@
// THE SOFTWARE.
#pragma once
#include <kiwano/math/math.h>
#include <kiwano/core/Time.h>
#include <kiwano/core/ObjectBase.h>
#include <kiwano/core/TimerManager.h>
#include <kiwano/core/EventDispatcher.h>
#include <kiwano/2d/Transform.h>
#include <kiwano/2d/action/ActionManager.h>
#include <kiwano/core/EventDispatcher.h>
#include <kiwano/core/ObjectBase.h>
#include <kiwano/core/Time.h>
#include <kiwano/core/TimerManager.h>
#include <kiwano/math/math.h>
namespace kiwano
{
class Stage;
class Director;
class RenderContext;
class Stage;
class Director;
class RenderContext;
KGE_DECLARE_SMART_PTR(Actor);
KGE_DECLARE_SMART_PTR(Actor);
/**
/**
* \~chinese
* \defgroup Actors 基础角色
*/
/**
/**
* \addtogroup Actors
* @{
*/
/**
/**
* \~chinese
* @brief 角色
* @details 角色是舞台上最基本的元素，是完成渲染、更新、事件分发等功能的最小单位，也是动画、定时器、事件监听等功能的载体
* @details
* 角色是舞台上最基本的元素，是完成渲染、更新、事件分发等功能的最小单位，也是动画、定时器、事件监听等功能的载体
*/
class KGE_API Actor
class KGE_API Actor
: public virtual ObjectBase
, public TimerManager
, public ActionManager
, public EventDispatcher
, protected IntrusiveListItem<ActorPtr>
{
{
friend class Director;
friend class Transition;
friend IntrusiveList<ActorPtr>;
public:
public:
/// \~chinese
/// @brief 子成员列表
using Children = IntrusiveList<ActorPtr>;
@ -82,7 +83,8 @@ namespace kiwano
/// \~chinese
/// @brief 渲染角色
/// @details 每帧画面刷新时调用该函数，默认不进行渲染，重载该函数以实现具体渲染过程
/// @details
/// 每帧画面刷新时调用该函数，默认不进行渲染，重载该函数以实现具体渲染过程
/// @param ctx 渲染上下文
virtual void OnRender(RenderContext& ctx);
@ -401,7 +403,7 @@ namespace kiwano
/// @brief 设置默认锚点
static void SetDefaultAnchor(float anchor_x, float anchor_y);
protected:
protected:
/// \~chinese
/// @brief 更新自身和所有子角色
virtual void Update(Duration dt);
@ -442,7 +444,7 @@ namespace kiwano
/// @brief 处理事件
void HandleEvent(Event* evt);
private:
private:
bool visible_;
bool update_pausing_;
bool cascade_opacity_;
@ -469,224 +471,222 @@ namespace kiwano
mutable bool dirty_transform_inverse_;
mutable Matrix3x2 transform_matrix_;
mutable Matrix3x2 transform_matrix_inverse_;
};
};
/** @} */
/** @} */
inline void Actor::OnUpdate(Duration dt)
{
inline void Actor::OnUpdate(Duration dt)
{
KGE_NOT_USED(dt);
}
inline void Actor::OnRender(RenderContext& ctx)
{
KGE_NOT_USED(ctx);
}
inline bool Actor::IsVisible() const
{
return visible_;
}
inline bool Actor::IsResponsible() const
{
return responsible_;
}
inline bool Actor::IsCascadeOpacityEnabled() const
{
return cascade_opacity_;
}
inline size_t Actor::GetHashName() const
{
return hash_name_;
}
inline int Actor::GetZOrder() const
{
return z_order_;
}
inline Point const& Actor::GetPosition() const
{
return transform_.position;
}
inline float Actor::GetPositionX() const
{
return GetPosition().x;
}
inline float Actor::GetPositionY() const
{
return GetPosition().y;
}
inline Point const& Actor::GetScale() const
{
return transform_.scale;
}
inline float Actor::GetScaleX() const
{
return GetScale().x;
}
inline float Actor::GetScaleY() const
{
return GetScale().y;
}
inline Point const& Actor::GetSkew() const
{
return transform_.skew;
}
inline float Actor::GetSkewX() const
{
return GetSkew().x;
}
inline float Actor::GetSkewY() const
{
return GetSkew().y;
}
inline float Actor::GetRotation() const
{
return transform_.rotation;
}
inline float Actor::GetWidth() const
{
return GetSize().x;
}
inline float Actor::GetHeight() const
{
return GetSize().y;
}
inline Size const& Actor::GetSize() const
{
return size_;
}
inline float Actor::GetScaledWidth() const
{
return GetWidth() * GetScaleX();
}
inline float Actor::GetScaledHeight() const
{
return GetHeight() * GetScaleY();
}
inline Size Actor::GetScaledSize() const
{
return Size{ GetScaledWidth(), GetScaledHeight() };
}
inline Point const& Actor::GetAnchor() const
{
return anchor_;
}
inline float Actor::GetAnchorX() const
{
return GetAnchor().x;
}
inline float Actor::GetAnchorY() const
{
return GetAnchor().y;
}
inline float Actor::GetOpacity() const
{
return opacity_;
}
inline float Actor::GetDisplayedOpacity() const
{
return displayed_opacity_;
}
inline Transform Actor::GetTransform() const
{
return transform_;
}
inline Actor* Actor::GetParent() const
{
return parent_;
}
inline Stage* Actor::GetStage() const
{
return stage_;
}
inline void Actor::PauseUpdating()
{
update_pausing_ = true;
}
inline void Actor::ResumeUpdating()
{
update_pausing_ = false;
}
inline bool Actor::IsUpdatePausing() const
{
return update_pausing_;
}
inline void Actor::SetCallbackOnUpdate(UpdateCallback const& cb)
{
cb_update_ = cb;
}
inline Actor::UpdateCallback Actor::GetCallbackOnUpdate() const
{
return cb_update_;
}
inline void Actor::ShowBorder(bool show)
{
show_border_ = show;
}
inline void Actor::SetPosition(float x, float y)
{
SetPosition(Point{ x, y });
}
inline void Actor::Move(float vx, float vy)
{
Move(Vec2{ vx, vy });
}
inline void Actor::SetScale(float scalex, float scaley)
{
SetScale(Vec2{ scalex, scaley });
}
inline void Actor::SetAnchor(float anchorx, float anchory)
{
SetAnchor(Vec2{ anchorx, anchory });
}
inline void Actor::SetSize(float width, float height)
{
SetSize(Size{ width, height });
}
inline void Actor::SetSkew(float skewx, float skewy)
{
SetSkew(Vec2{ skewx, skewy });
}
}
inline void Actor::OnRender(RenderContext& ctx)
{
KGE_NOT_USED(ctx);
}
inline bool Actor::IsVisible() const
{
return visible_;
}
inline bool Actor::IsResponsible() const
{
return responsible_;
}
inline bool Actor::IsCascadeOpacityEnabled() const
{
return cascade_opacity_;
}
inline size_t Actor::GetHashName() const
{
return hash_name_;
}
inline int Actor::GetZOrder() const
{
return z_order_;
}
inline Point const& Actor::GetPosition() const
{
return transform_.position;
}
inline float Actor::GetPositionX() const
{
return GetPosition().x;
}
inline float Actor::GetPositionY() const
{
return GetPosition().y;
}
inline Point const& Actor::GetScale() const
{
return transform_.scale;
}
inline float Actor::GetScaleX() const
{
return GetScale().x;
}
inline float Actor::GetScaleY() const
{
return GetScale().y;
}
inline Point const& Actor::GetSkew() const
{
return transform_.skew;
}
inline float Actor::GetSkewX() const
{
return GetSkew().x;
}
inline float Actor::GetSkewY() const
{
return GetSkew().y;
}
inline float Actor::GetRotation() const
{
return transform_.rotation;
}
inline float Actor::GetWidth() const
{
return GetSize().x;
}
inline float Actor::GetHeight() const
{
return GetSize().y;
}
inline Size const& Actor::GetSize() const
{
return size_;
}
inline float Actor::GetScaledWidth() const
{
return GetWidth() * GetScaleX();
}
inline float Actor::GetScaledHeight() const
{
return GetHeight() * GetScaleY();
}
inline Size Actor::GetScaledSize() const
{
return Size{ GetScaledWidth(), GetScaledHeight() };
}
inline Point const& Actor::GetAnchor() const
{
return anchor_;
}
inline float Actor::GetAnchorX() const
{
return GetAnchor().x;
}
inline float Actor::GetAnchorY() const
{
return GetAnchor().y;
}
inline float Actor::GetOpacity() const
{
return opacity_;
}
inline float Actor::GetDisplayedOpacity() const
{
return displayed_opacity_;
}
inline Transform Actor::GetTransform() const
{
return transform_;
}
inline Actor* Actor::GetParent() const
{
return parent_;
}
inline Stage* Actor::GetStage() const
{
return stage_;
}
inline void Actor::PauseUpdating()
{
update_pausing_ = true;
}
inline void Actor::ResumeUpdating()
{
update_pausing_ = false;
}
inline bool Actor::IsUpdatePausing() const
{
return update_pausing_;
}
inline void Actor::SetCallbackOnUpdate(UpdateCallback const& cb)
{
cb_update_ = cb;
}
inline Actor::UpdateCallback Actor::GetCallbackOnUpdate() const
{
return cb_update_;
}
inline void Actor::ShowBorder(bool show)
{
show_border_ = show;
}
inline void Actor::SetPosition(float x, float y)
{
SetPosition(Point{ x, y });
}
inline void Actor::Move(float vx, float vy)
{
Move(Vec2{ vx, vy });
}
inline void Actor::SetScale(float scalex, float scaley)
{
SetScale(Vec2{ scalex, scaley });
}
inline void Actor::SetAnchor(float anchorx, float anchory)
{
SetAnchor(Vec2{ anchorx, anchory });
}
inline void Actor::SetSize(float width, float height)
{
SetSize(Size{ width, height });
}
inline void Actor::SetSkew(float skewx, float skewy)
{
SetSkew(Vec2{ skewx, skewy });
}
} // namespace kiwano

124
src/kiwano/2d/Button.cpp
View File

@ -24,71 +24,69 @@
namespace kiwano
{
Button::Button()
Button::Button()
: enabled_(true)
, status_(Status::Normal)
{
}
{
}
Button::Button(const Callback& click)
Button::Button(const Callback& click)
: Button()
{
{
this->SetClickCallback(click);
}
}
Button::Button(Callback const & click, Callback const & pressed, Callback const & mouse_over, Callback const & mouse_out)
Button::Button(Callback const& click, Callback const& pressed, Callback const& mouse_over, Callback const& mouse_out)
: Button()
{
{
this->SetClickCallback(click);
this->SetPressedCallback(pressed);
this->SetMouseOverCallback(mouse_over);
this->SetMouseOutCallback(mouse_out);
}
}
Button::~Button()
{
}
Button::~Button() {}
bool Button::IsEnable() const
{
bool Button::IsEnable() const
{
return enabled_;
}
}
void Button::SetEnabled(bool enabled)
{
void Button::SetEnabled(bool enabled)
{
if (enabled_ != enabled)
{
enabled_ = enabled;
}
}
}
void Button::SetClickCallback(const Callback& func)
{
void Button::SetClickCallback(const Callback& func)
{
click_callback_ = func;
}
}
void Button::SetPressedCallback(const Callback & func)
{
void Button::SetPressedCallback(const Callback& func)
{
pressed_callback_ = func;
}
}
void Button::SetReleasedCallback(const Callback& func)
{
void Button::SetReleasedCallback(const Callback& func)
{
released_callback_ = func;
}
}
void Button::SetMouseOverCallback(const Callback & func)
{
void Button::SetMouseOverCallback(const Callback& func)
{
mouse_over_callback_ = func;
}
}
void Button::SetMouseOutCallback(const Callback & func)
{
void Button::SetMouseOutCallback(const Callback& func)
{
mouse_out_callback_ = func;
}
}
void Button::SetStatus(Status status)
{
void Button::SetStatus(Status status)
{
if (status_ != status)
{
Status old_status = status_;
@ -123,15 +121,15 @@ namespace kiwano
status_ = status;
}
}
}
Button::Status Button::GetStatus() const
{
Button::Status Button::GetStatus() const
{
return status_;
}
}
void Button::UpdateStatus(Event* evt)
{
void Button::UpdateStatus(Event* evt)
{
if (!enabled_)
return;
@ -156,22 +154,22 @@ namespace kiwano
if (click_callback_)
click_callback_(this);
}
}
}
SpriteButton::SpriteButton()
SpriteButton::SpriteButton()
: SpriteButton(nullptr, nullptr, nullptr, nullptr)
{
}
{
}
SpriteButton::SpriteButton(Callback const& click)
SpriteButton::SpriteButton(Callback const& click)
: SpriteButton(click, nullptr, nullptr, nullptr)
{
}
{
}
SpriteButton::SpriteButton(Callback const& click, Callback const& pressed, Callback const& mouse_over, Callback const& mouse_out)
SpriteButton::SpriteButton(Callback const& click, Callback const& pressed, Callback const& mouse_over,
Callback const& mouse_out)
: Button(click, pressed, mouse_over, mouse_out)
{
{
SetResponsible(true);
EventListener::Callback handler = Closure(this, &SpriteButton::UpdateStatus);
@ -180,22 +178,22 @@ namespace kiwano
AddListener<MouseDownEvent>(handler);
AddListener<MouseUpEvent>(handler);
AddListener<MouseClickEvent>(handler);
}
}
TextButton::TextButton()
TextButton::TextButton()
: TextButton(nullptr, nullptr, nullptr, nullptr)
{
}
{
}
TextButton::TextButton(Callback const& click)
TextButton::TextButton(Callback const& click)
: TextButton(click, nullptr, nullptr, nullptr)
{
}
{
}
TextButton::TextButton(Callback const& click, Callback const& pressed, Callback const& mouse_over, Callback const& mouse_out)
TextButton::TextButton(Callback const& click, Callback const& pressed, Callback const& mouse_over,
Callback const& mouse_out)
: Button(click, pressed, mouse_over, mouse_out)
{
{
SetResponsible(true);
EventListener::Callback handler = Closure(this, &TextButton::UpdateStatus);
@ -204,6 +202,6 @@ namespace kiwano
AddListener<MouseDownEvent>(handler);
AddListener<MouseUpEvent>(handler);
AddListener<MouseClickEvent>(handler);
}
}
} // namespace kiwano

49
src/kiwano/2d/Button.h
View File

@ -24,18 +24,17 @@
namespace kiwano
{
KGE_DECLARE_SMART_PTR(Button);
KGE_DECLARE_SMART_PTR(SpriteButton);
KGE_DECLARE_SMART_PTR(TextButton);
KGE_DECLARE_SMART_PTR(Button);
KGE_DECLARE_SMART_PTR(SpriteButton);
KGE_DECLARE_SMART_PTR(TextButton);
/**
/**
* \~chinese
* @brief 按钮
*/
class KGE_API Button
: public virtual ObjectBase
{
public:
class KGE_API Button : public virtual ObjectBase
{
public:
/// \~chinese
/// @brief 按钮回调函数
using Callback = Function<void(Button* /* self */)>;
@ -102,12 +101,12 @@ namespace kiwano
/// @brief 获取按钮状态
Status GetStatus() const;
protected:
protected:
/// \~chinese
/// @brief 更新按钮状态
void UpdateStatus(Event* evt);
private:
private:
bool enabled_;
Status status_;
Callback click_callback_;
@ -115,16 +114,15 @@ namespace kiwano
Callback released_callback_;
Callback mouse_over_callback_;
Callback mouse_out_callback_;
};
};
/// \~chinese
/// @brief 精灵按钮
class SpriteButton
/// \~chinese
/// @brief 精灵按钮
class SpriteButton
: public Sprite
, public Button
{
public:
{
public:
SpriteButton();
/// \~chinese
@ -139,16 +137,15 @@ namespace kiwano
/// @param mouse_over 按钮移入回调函数
/// @param mouse_out 按钮移出回调函数
SpriteButton(Callback const& click, Callback const& pressed, Callback const& mouse_over, Callback const& mouse_out);
};
};
/// \~chinese
/// @brief 文字按钮
class TextButton
/// \~chinese
/// @brief 文字按钮
class TextButton
: public TextActor
, public Button
{
public:
{
public:
TextButton();
/// \~chinese
@ -163,5 +160,5 @@ namespace kiwano
/// @param mouse_over 按钮移入回调函数
/// @param mouse_out 按钮移出回调函数
TextButton(Callback const& click, Callback const& pressed, Callback const& mouse_over, Callback const& mouse_out);
};
}
};
} // namespace kiwano

291
src/kiwano/2d/Canvas.cpp
View File

@ -24,32 +24,30 @@
namespace kiwano
{
Canvas::Canvas()
Canvas::Canvas()
: cache_expired_(false)
, stroke_width_(1.0f)
, stroke_style_()
{
}
{
}
Canvas::~Canvas()
{
}
Canvas::~Canvas() {}
void Canvas::BeginDraw()
{
void Canvas::BeginDraw()
{
InitRenderTargetAndBrushs();
ctx_->BeginDraw();
}
}
void Canvas::EndDraw()
{
void Canvas::EndDraw()
{
InitRenderTargetAndBrushs();
ctx_->EndDraw();
cache_expired_ = true;
}
}
void Canvas::OnRender(RenderContext& ctx)
{
void Canvas::OnRender(RenderContext& ctx)
{
UpdateCache();
if (texture_cached_ && texture_cached_->IsValid())
@ -59,174 +57,139 @@ namespace kiwano
Rect bitmap_rect(0.f, 0.f, texture_cached_->GetWidth(), texture_cached_->GetHeight());
ctx.DrawTexture(*texture_cached_, bitmap_rect, bitmap_rect);
}
}
}
void Canvas::SetBrush(BrushPtr brush)
{
void Canvas::SetBrush(BrushPtr brush)
{
InitRenderTargetAndBrushs();
ctx_->SetCurrentBrush(brush);
}
}
float Canvas::GetStrokeWidth() const
{
float Canvas::GetStrokeWidth() const
{
return stroke_width_;
}
}
void Canvas::SetBrushTransform(Transform const& transform)
{
void Canvas::SetBrushTransform(Transform const& transform)
{
InitRenderTargetAndBrushs();
ctx_->SetTransform(transform.ToMatrix());
}
}
void Canvas::SetBrushTransform(Matrix3x2 const & transform)
{
void Canvas::SetBrushTransform(Matrix3x2 const& transform)
{
InitRenderTargetAndBrushs();
ctx_->SetTransform(transform);
}
}
void Canvas::PushLayerArea(LayerArea& area)
{
void Canvas::PushLayerArea(LayerArea& area)
{
InitRenderTargetAndBrushs();
ctx_->PushLayer(area);
}
}
void Canvas::PopLayerArea()
{
void Canvas::PopLayerArea()
{
InitRenderTargetAndBrushs();
ctx_->PopLayer();
}
}
void Canvas::PushClipRect(Rect const& clip_rect)
{
void Canvas::PushClipRect(Rect const& clip_rect)
{
InitRenderTargetAndBrushs();
ctx_->PushClipRect(clip_rect);
}
}
void Canvas::PopClipRect()
{
void Canvas::PopClipRect()
{
InitRenderTargetAndBrushs();
ctx_->PopClipRect();
}
}
void Canvas::DrawLine(Point const& begin, Point const& end)
{
void Canvas::DrawLine(Point const& begin, Point const& end)
{
InitRenderTargetAndBrushs();
ctx_->SetCurrentBrush(stroke_brush_);
ctx_->DrawLine(
begin,
end,
stroke_width_,
stroke_style_
);
ctx_->DrawLine(begin, end, stroke_width_, stroke_style_);
cache_expired_ = true;
}
}
void Canvas::DrawCircle(Point const& center, float radius)
{
void Canvas::DrawCircle(Point const& center, float radius)
{
InitRenderTargetAndBrushs();
ctx_->SetCurrentBrush(stroke_brush_);
ctx_->DrawEllipse(
center,
Vec2(radius, radius),
stroke_width_,
stroke_style_
);
ctx_->DrawEllipse(center, Vec2(radius, radius), stroke_width_, stroke_style_);
cache_expired_ = true;
}
}
void Canvas::DrawEllipse(Point const& center, Vec2 const& radius)
{
void Canvas::DrawEllipse(Point const& center, Vec2 const& radius)
{
InitRenderTargetAndBrushs();
ctx_->SetCurrentBrush(stroke_brush_);
ctx_->DrawEllipse(
center,
radius,
stroke_width_,
stroke_style_
);
ctx_->DrawEllipse(center, radius, stroke_width_, stroke_style_);
cache_expired_ = true;
}
}
void Canvas::DrawRect(Rect const& rect)
{
void Canvas::DrawRect(Rect const& rect)
{
InitRenderTargetAndBrushs();
ctx_->SetCurrentBrush(stroke_brush_);
ctx_->DrawRectangle(
rect,
stroke_width_,
stroke_style_
);
ctx_->DrawRectangle(rect, stroke_width_, stroke_style_);
cache_expired_ = true;
}
}
void Canvas::DrawRoundedRect(Rect const& rect, Vec2 const& radius)
{
void Canvas::DrawRoundedRect(Rect const& rect, Vec2 const& radius)
{
InitRenderTargetAndBrushs();
ctx_->SetCurrentBrush(stroke_brush_);
ctx_->DrawRoundedRectangle(
rect,
radius,
stroke_width_,
stroke_style_
);
ctx_->DrawRoundedRectangle(rect, radius, stroke_width_, stroke_style_);
cache_expired_ = true;
}
}
void Canvas::FillCircle(Point const& center, float radius)
{
void Canvas::FillCircle(Point const& center, float radius)
{
InitRenderTargetAndBrushs();
ctx_->SetCurrentBrush(fill_brush_);
ctx_->FillEllipse(
center,
Vec2(radius, radius)
);
ctx_->FillEllipse(center, Vec2(radius, radius));
cache_expired_ = true;
}
}
void Canvas::FillEllipse(Point const& center, Vec2 const& radius)
{
void Canvas::FillEllipse(Point const& center, Vec2 const& radius)
{
InitRenderTargetAndBrushs();
ctx_->SetCurrentBrush(fill_brush_);
ctx_->FillEllipse(
center,
radius
);
ctx_->FillEllipse(center, radius);
cache_expired_ = true;
}
}
void Canvas::FillRect(Rect const& rect)
{
void Canvas::FillRect(Rect const& rect)
{
InitRenderTargetAndBrushs();
ctx_->SetCurrentBrush(fill_brush_);
ctx_->FillRectangle(
rect
);
ctx_->FillRectangle(rect);
cache_expired_ = true;
}
}
void Canvas::FillRoundedRect(Rect const& rect, Vec2 const& radius)
{
void Canvas::FillRoundedRect(Rect const& rect, Vec2 const& radius)
{
InitRenderTargetAndBrushs();
ctx_->SetCurrentBrush(fill_brush_);
ctx_->FillRoundedRectangle(
rect,
radius
);
ctx_->FillRoundedRectangle(rect, radius);
cache_expired_ = true;
}
}
void Canvas::DrawTexture(TexturePtr texture, const Rect* src_rect, const Rect* dest_rect)
{
void Canvas::DrawTexture(TexturePtr texture, const Rect* src_rect, const Rect* dest_rect)
{
if (texture)
{
InitRenderTargetAndBrushs();
ctx_->DrawTexture(*texture, src_rect, dest_rect);
cache_expired_ = true;
}
}
}
void Canvas::DrawTextLayout(String const& text, Point const& point)
{
void Canvas::DrawTextLayout(String const& text, Point const& point)
{
if (text.empty())
return;
@ -234,88 +197,82 @@ namespace kiwano
layout.SetStyle(text_style_);
layout.SetText(text);
DrawTextLayout(layout, point);
}
}
void Canvas::DrawTextLayout(TextLayout const& layout, Point const& point)
{
void Canvas::DrawTextLayout(TextLayout const& layout, Point const& point)
{
InitRenderTargetAndBrushs();
ctx_->DrawTextLayout(layout, point);
}
}
void Canvas::BeginPath(Point const& begin_pos)
{
void Canvas::BeginPath(Point const& begin_pos)
{
geo_sink_.BeginPath(begin_pos);
}
}
void Canvas::EndPath(bool closed)
{
void Canvas::EndPath(bool closed)
{
geo_sink_.EndPath(closed);
}
}
void Canvas::AddLine(Point const & point)
{
void Canvas::AddLine(Point const& point)
{
geo_sink_.AddLine(point);
}
}
void Canvas::AddLines(Vector<Point> const& points)
{
void Canvas::AddLines(Vector<Point> const& points)
{
geo_sink_.AddLines(points);
}
}
void Canvas::AddBezier(Point const & point1, Point const & point2, Point const & point3)
{
void Canvas::AddBezier(Point const& point1, Point const& point2, Point const& point3)
{
geo_sink_.AddBezier(point1, point2, point3);
}
}
void Canvas::AddArc(Point const & point, Size const & radius, float rotation, bool clockwise, bool is_small)
{
void Canvas::AddArc(Point const& point, Size const& radius, float rotation, bool clockwise, bool is_small)
{
geo_sink_.AddArc(point, radius, rotation, clockwise, is_small);
}
}
void Canvas::StrokePath()
{
void Canvas::StrokePath()
{
InitRenderTargetAndBrushs();
ctx_->SetCurrentBrush(stroke_brush_);
ctx_->DrawGeometry(
geo_sink_.GetGeometry(),
stroke_width_,
stroke_style_
);
ctx_->DrawGeometry(geo_sink_.GetGeometry(), stroke_width_, stroke_style_);
cache_expired_ = true;
}
}
void Canvas::FillPath()
{
void Canvas::FillPath()
{
InitRenderTargetAndBrushs();
ctx_->SetCurrentBrush(fill_brush_);
ctx_->FillGeometry(
geo_sink_.GetGeometry()
);
ctx_->FillGeometry(geo_sink_.GetGeometry());
cache_expired_ = true;
}
}
void Canvas::Clear()
{
void Canvas::Clear()
{
InitRenderTargetAndBrushs();
ctx_->Clear();
cache_expired_ = true;
}
}
void Canvas::Clear(Color const& clear_color)
{
void Canvas::Clear(Color const& clear_color)
{
InitRenderTargetAndBrushs();
ctx_->Clear(clear_color);
cache_expired_ = true;
}
}
TexturePtr Canvas::ExportToTexture() const
{
TexturePtr Canvas::ExportToTexture() const
{
UpdateCache();
return texture_cached_;
}
}
void Canvas::InitRenderTargetAndBrushs()
{
void Canvas::InitRenderTargetAndBrushs()
{
if (!ctx_)
{
Renderer::Instance().CreateTextureRenderTarget(ctx_);
@ -332,10 +289,10 @@ namespace kiwano
fill_brush_ = new Brush;
fill_brush_->SetColor(Color::White);
}
}
}
void Canvas::UpdateCache() const
{
void Canvas::UpdateCache() const
{
if (cache_expired_ && ctx_)
{
if (!texture_cached_)
@ -348,6 +305,6 @@ namespace kiwano
cache_expired_ = false;
}
}
}
}
} // namespace kiwano

94
src/kiwano/2d/Canvas.h
View File

@ -20,26 +20,25 @@
#pragma once
#include <kiwano/2d/Actor.h>
#include <kiwano/render/RenderContext.h>
#include <kiwano/render/GeometrySink.h>
#include <kiwano/render/RenderContext.h>
namespace kiwano
{
KGE_DECLARE_SMART_PTR(Canvas);
KGE_DECLARE_SMART_PTR(Canvas);
/**
/**
* \addtogroup Actors
* @{
*/
/**
/**
* \~chinese
* @brief 画布，用于绘制图元
*/
class KGE_API Canvas
: public Actor
{
public:
class KGE_API Canvas : public Actor
{
public:
/// \~chinese
/// @brief 构建空画布
Canvas();
@ -264,12 +263,12 @@ namespace kiwano
void OnRender(RenderContext& ctx) override;
private:
private:
void InitRenderTargetAndBrushs();
void UpdateCache() const;
private:
private:
float stroke_width_;
TextStyle text_style_;
StrokeStyle stroke_style_;
@ -280,55 +279,54 @@ namespace kiwano
mutable bool cache_expired_;
mutable TexturePtr texture_cached_;
mutable TextureRenderContextPtr ctx_;
};
};
/** @} */
/** @} */
inline void Canvas::SetStrokeWidth(float width)
{
inline void Canvas::SetStrokeWidth(float width)
{
stroke_width_ = std::max(width, 0.f);
}
}
inline void Canvas::SetStrokeStyle(const StrokeStyle& stroke_style)
{
inline void Canvas::SetStrokeStyle(const StrokeStyle& stroke_style)
{
stroke_style_ = stroke_style;
}
}
inline void Canvas::SetTextStyle(TextStyle const& text_style)
{
inline void Canvas::SetTextStyle(TextStyle const& text_style)
{
text_style_ = text_style;
}
}
inline void Canvas::SetStrokeColor(Color const& color)
{
inline void Canvas::SetStrokeColor(Color const& color)
{
InitRenderTargetAndBrushs();
stroke_brush_->SetColor(color);
}
}
inline void Canvas::SetFillColor(Color const& color)
{
inline void Canvas::SetFillColor(Color const& color)
{
InitRenderTargetAndBrushs();
fill_brush_->SetColor(color);
}
inline void Canvas::SetFillBrush(BrushPtr brush)
{
fill_brush_ = brush;
}
inline void Canvas::SetStrokeBrush(BrushPtr brush)
{
stroke_brush_ = brush;
}
inline BrushPtr Canvas::GetFillBrush() const
{
return fill_brush_;
}
inline BrushPtr Canvas::GetStrokeBrush() const
{
return stroke_brush_;
}
}
inline void Canvas::SetFillBrush(BrushPtr brush)
{
fill_brush_ = brush;
}
inline void Canvas::SetStrokeBrush(BrushPtr brush)
{
stroke_brush_ = brush;
}
inline BrushPtr Canvas::GetFillBrush() const
{
return fill_brush_;
}
inline BrushPtr Canvas::GetStrokeBrush() const
{
return stroke_brush_;
}
} // namespace kiwano

53
src/kiwano/2d/DebugActor.cpp
View File

@ -19,19 +19,19 @@
// THE SOFTWARE.
#include <kiwano/2d/DebugActor.h>
#include <kiwano/render/Renderer.h>
#include <kiwano/core/Logger.h>
#include <kiwano/render/Renderer.h>
#include <psapi.h>
#pragma comment(lib, "psapi.lib")
namespace kiwano
{
namespace
{
class comma_numpunct : public std::numpunct<wchar_t>
{
private:
namespace
{
class comma_numpunct : public std::numpunct<wchar_t>
{
private:
virtual wchar_t do_thousands_sep() const override
{
return L',';
@ -41,11 +41,11 @@ namespace kiwano
{
return "\03";
}
};
}
};
} // namespace
DebugActor::DebugActor()
{
DebugActor::DebugActor()
{
SetName(L"kiwano-debug-actor");
SetPosition(Point{ 10, 10 });
SetResponsible(true);
@ -69,21 +69,19 @@ namespace kiwano
AddListener<MouseHoverEvent>([=](Event*) { SetOpacity(0.4f); });
AddListener<MouseOutEvent>([=](Event*) { SetOpacity(1.f); });
}
}
DebugActor::~DebugActor()
{
}
DebugActor::~DebugActor() {}
void DebugActor::OnRender(RenderContext& ctx)
{
void DebugActor::OnRender(RenderContext& ctx)
{
ctx.SetCurrentBrush(background_brush_);
ctx.FillRoundedRectangle(GetBounds(), Vec2{ 5.f, 5.f });
ctx.DrawTextLayout(debug_text_, Point(10, 10));
}
}
void DebugActor::OnUpdate(Duration dt)
{
void DebugActor::OnUpdate(Duration dt)
{
KGE_NOT_USED(dt);
frame_time_.push_back(Time::Now());
@ -108,7 +106,8 @@ namespace kiwano
ss << "Render: " << Renderer::Instance().GetStatus().duration.Milliseconds() << "ms" << std::endl;
ss << "Primitives / sec: " << std::fixed << Renderer::Instance().GetStatus().primitives * frame_time_.size() << std::endl;
ss << "Primitives / sec: " << std::fixed << Renderer::Instance().GetStatus().primitives * frame_time_.size()
<< std::endl;
ss << "Memory: ";
{
@ -137,11 +136,11 @@ namespace kiwano
{
SetHeight(20 + layout_size.y);
}
}
bool DebugActor::CheckVisibility(RenderContext& ctx) const
{
return true;
}
}
bool DebugActor::CheckVisibility(RenderContext& ctx) const
{
return true;
}
} // namespace kiwano

22
src/kiwano/2d/DebugActor.h
View File

@ -24,19 +24,18 @@
namespace kiwano
{
/**
/**
* \addtogroup Actors
* @{
*/
/**
/**
* \~chinese
* @brief µ÷ÊÔ½Úµã
*/
class KGE_API DebugActor
: public Actor
{
public:
class KGE_API DebugActor : public Actor
{
public:
DebugActor();
virtual ~DebugActor();
@ -45,16 +44,15 @@ namespace kiwano
void OnUpdate(Duration dt) override;
protected:
protected:
bool CheckVisibility(RenderContext& ctx) const override;
private:
private:
std::locale comma_locale_;
BrushPtr background_brush_;
TextLayout debug_text_;
Vector<Time> frame_time_;
};
};
/** @} */
}
/** @} */
} // namespace kiwano

28
src/kiwano/2d/Frame.cpp
View File

@ -23,12 +23,10 @@
namespace kiwano
{
Frame::Frame()
{
}
Frame::Frame() {}
bool Frame::Load(String const& file_path)
{
bool Frame::Load(String const& file_path)
{
TexturePtr texture = TextureCache::Instance().AddOrGetTexture(file_path);
if (texture->IsValid())
{
@ -36,10 +34,10 @@ namespace kiwano
return true;
}
return false;
}
}
bool Frame::Load(Resource const& res)
{
bool Frame::Load(Resource const& res)
{
TexturePtr texture = TextureCache::Instance().AddOrGetTexture(res);
if (texture->IsValid())
{
@ -47,10 +45,10 @@ namespace kiwano
return true;
}
return false;
}
}
void Frame::SetCropRect(Rect const& crop_rect)
{
void Frame::SetCropRect(Rect const& crop_rect)
{
if (texture_->IsValid())
{
auto bitmap_size = texture_->GetSize();
@ -59,10 +57,10 @@ namespace kiwano
crop_rect_.right_bottom.x = std::min(std::max(crop_rect.right_bottom.x, 0.f), bitmap_size.x);
crop_rect_.right_bottom.y = std::min(std::max(crop_rect.right_bottom.y, 0.f), bitmap_size.y);
}
}
}
void Frame::SetTexture(TexturePtr texture)
{
void Frame::SetTexture(TexturePtr texture)
{
texture_ = texture;
if (texture_->IsValid())
{
@ -70,5 +68,5 @@ namespace kiwano
crop_rect_.right_bottom.x = texture_->GetWidth();
crop_rect_.right_bottom.y = texture_->GetHeight();
}
}
}
} // namespace kiwano

50
src/kiwano/2d/Frame.h
View File

@ -24,16 +24,15 @@
namespace kiwano
{
KGE_DECLARE_SMART_PTR(Frame);
KGE_DECLARE_SMART_PTR(Frame);
/**
/**
* \~chinese
* @brief 图像帧
*/
class KGE_API Frame
: public virtual ObjectBase
{
public:
class KGE_API Frame : public virtual ObjectBase
{
public:
/// \~chinese
/// @brief 构建空图像帧
Frame();
@ -86,16 +85,37 @@ namespace kiwano
/// @brief 获取纹理
TexturePtr GetTexture() const;
private:
private:
TexturePtr texture_;
Rect crop_rect_;
};
};
inline bool Frame::IsValid() const { return texture_ && texture_->IsValid(); }
inline float Frame::GetWidth() const { return crop_rect_.GetWidth(); }
inline float Frame::GetHeight() const { return crop_rect_.GetHeight(); }
inline Size Frame::GetSize() const { return crop_rect_.GetSize(); }
inline Point Frame::GetCropPoint() const { return crop_rect_.GetLeftTop(); }
inline Rect const& Frame::GetCropRect() const { return crop_rect_; }
inline TexturePtr Frame::GetTexture() const { return texture_; }
inline bool Frame::IsValid() const
{
return texture_ && texture_->IsValid();
}
inline float Frame::GetWidth() const
{
return crop_rect_.GetWidth();
}
inline float Frame::GetHeight() const
{
return crop_rect_.GetHeight();
}
inline Size Frame::GetSize() const
{
return crop_rect_.GetSize();
}
inline Point Frame::GetCropPoint() const
{
return crop_rect_.GetLeftTop();
}
inline Rect const& Frame::GetCropRect() const
{
return crop_rect_;
}
inline TexturePtr Frame::GetTexture() const
{
return texture_;
}
} // namespace kiwano

58
src/kiwano/2d/FrameSequence.cpp
View File

@ -23,31 +23,27 @@
namespace kiwano
{
FrameSequence::FrameSequence()
{
}
FrameSequence::FrameSequence() {}
FrameSequence::FrameSequence(Vector<FramePtr> const& frames)
{
FrameSequence::FrameSequence(Vector<FramePtr> const& frames)
{
this->AddFrames(frames);
}
}
FrameSequence::~FrameSequence()
{
}
FrameSequence::~FrameSequence() {}
void FrameSequence::AddFrame(FramePtr frame)
{
void FrameSequence::AddFrame(FramePtr frame)
{
KGE_ASSERT(frame && "FrameSequence::Add failed, NULL pointer exception");
if (frame)
{
frames_.push_back(frame);
}
}
}
void FrameSequence::AddFrames(Vector<FramePtr> const& frames)
{
void FrameSequence::AddFrames(Vector<FramePtr> const& frames)
{
if (frames_.empty())
frames_ = frames;
else
@ -56,36 +52,36 @@ namespace kiwano
for (const auto& texture : frames)
AddFrame(texture);
}
}
}
FramePtr FrameSequence::GetFrame(size_t index) const
{
FramePtr FrameSequence::GetFrame(size_t index) const
{
KGE_ASSERT(index < frames_.size());
return frames_[index];
}
}
Vector<FramePtr> const& FrameSequence::GetFrames() const
{
Vector<FramePtr> const& FrameSequence::GetFrames() const
{
return frames_;
}
}
size_t FrameSequence::GetFramesCount() const
{
size_t FrameSequence::GetFramesCount() const
{
return frames_.size();
}
}
FrameSequencePtr FrameSequence::Clone() const
{
FrameSequencePtr FrameSequence::Clone() const
{
auto frame_seq = new (std::nothrow) FrameSequence;
if (frame_seq)
{
frame_seq->AddFrames(frames_);
}
return frame_seq;
}
}
FrameSequencePtr FrameSequence::Reverse() const
{
FrameSequencePtr FrameSequence::Reverse() const
{
auto frame_seq = new (std::nothrow) FrameSequence;
if (!frames_.empty())
{
@ -96,6 +92,6 @@ namespace kiwano
}
}
return frame_seq;
}
}
} // namespace kiwano

19
src/kiwano/2d/FrameSequence.h
View File

@ -19,22 +19,21 @@
// THE SOFTWARE.
#pragma once
#include <kiwano/2d/Frame.h>
#include <kiwano/core/Common.h>
#include <kiwano/core/Time.h>
#include <kiwano/2d/Frame.h>
namespace kiwano
{
KGE_DECLARE_SMART_PTR(FrameSequence);
KGE_DECLARE_SMART_PTR(FrameSequence);
/**
/**
* \~chinese
* @brief 序列帧
*/
class KGE_API FrameSequence
: public virtual ObjectBase
{
public:
class KGE_API FrameSequence : public virtual ObjectBase
{
public:
/// \~chinese
/// @brief 构建空序列帧
FrameSequence();
@ -77,7 +76,7 @@ namespace kiwano
/// @brief 获取序列帧的倒转
FrameSequencePtr Reverse() const;
private:
private:
Vector<FramePtr> frames_;
};
}
};
} // namespace kiwano

91
src/kiwano/2d/GifSprite.cpp
View File

@ -19,33 +19,33 @@
// THE SOFTWARE.
#include <kiwano/2d/GifSprite.h>
#include <kiwano/render/TextureCache.h>
#include <kiwano/render/Renderer.h>
#include <kiwano/render/TextureCache.h>
namespace kiwano
{
GifSprite::GifSprite()
GifSprite::GifSprite()
: animating_(false)
, next_index_(0)
, total_loop_count_(1)
, loop_count_(0)
{
}
{
}
bool GifSprite::Load(String const& file_path)
{
bool GifSprite::Load(String const& file_path)
{
GifImagePtr image = TextureCache::Instance().AddOrGetGifImage(file_path);
return Load(image);
}
}
bool GifSprite::Load(Resource const& res)
{
bool GifSprite::Load(Resource const& res)
{
GifImagePtr image = TextureCache::Instance().AddOrGetGifImage(res);
return Load(image);
}
}
bool GifSprite::Load(GifImagePtr gif)
{
bool GifSprite::Load(GifImagePtr gif)
{
if (gif && gif->IsValid())
{
gif_ = gif;
@ -68,20 +68,20 @@ namespace kiwano
return true;
}
return false;
}
}
void GifSprite::OnRender(RenderContext& ctx)
{
void GifSprite::OnRender(RenderContext& ctx)
{
if (frame_to_render_ && CheckVisibility(ctx))
{
PrepareToRender(ctx);
ctx.DrawTexture(*frame_to_render_, &frame_.rect, nullptr);
}
}
}
void GifSprite::Update(Duration dt)
{
void GifSprite::Update(Duration dt)
{
Actor::Update(dt);
if (gif_ && gif_->IsValid() && animating_)
@ -94,24 +94,24 @@ namespace kiwano
ComposeNextFrame();
}
}
}
}
void GifSprite::SetGifImage(GifImagePtr gif)
{
void GifSprite::SetGifImage(GifImagePtr gif)
{
gif_ = gif;
RestartAnimation();
}
}
void GifSprite::RestartAnimation()
{
void GifSprite::RestartAnimation()
{
animating_ = true;
next_index_ = 0;
loop_count_ = 0;
frame_.disposal_type = GifImage::DisposalType::None;
}
}
void GifSprite::ComposeNextFrame()
{
void GifSprite::ComposeNextFrame()
{
KGE_ASSERT(frame_rt_);
KGE_ASSERT(gif_);
@ -125,10 +125,10 @@ namespace kiwano
animating_ = (!EndOfAnimation() && gif_->GetFramesCount() > 1);
}
}
}
void GifSprite::DisposeCurrentFrame()
{
void GifSprite::DisposeCurrentFrame()
{
switch (frame_.disposal_type)
{
case GifImage::DisposalType::Unknown:
@ -143,10 +143,10 @@ namespace kiwano
RestoreSavedFrame();
break;
}
}
}
void GifSprite::OverlayNextFrame()
{
void GifSprite::OverlayNextFrame()
{
KGE_ASSERT(frame_rt_);
KGE_ASSERT(gif_ && gif_->IsValid());
@ -193,10 +193,10 @@ namespace kiwano
{
done_cb_();
}
}
}
void GifSprite::SaveComposedFrame()
{
void GifSprite::SaveComposedFrame()
{
KGE_ASSERT(frame_rt_);
TexturePtr frame_to_be_saved = new Texture;
@ -206,15 +206,16 @@ namespace kiwano
if (!saved_frame_)
{
saved_frame_ = new Texture;
frame_rt_->CreateTexture(*saved_frame_, frame_to_be_saved->GetSizeInPixels(), frame_to_be_saved->GetPixelFormat());
frame_rt_->CreateTexture(*saved_frame_, frame_to_be_saved->GetSizeInPixels(),
frame_to_be_saved->GetPixelFormat());
}
saved_frame_->CopyFrom(frame_to_be_saved);
}
}
}
void GifSprite::RestoreSavedFrame()
{
void GifSprite::RestoreSavedFrame()
{
KGE_ASSERT(frame_rt_);
if (saved_frame_)
@ -226,10 +227,10 @@ namespace kiwano
frame_to_copy_to->CopyFrom(saved_frame_);
}
}
}
}
void GifSprite::ClearCurrentFrameArea()
{
void GifSprite::ClearCurrentFrameArea()
{
KGE_ASSERT(frame_rt_);
frame_rt_->BeginDraw();
@ -238,6 +239,6 @@ namespace kiwano
frame_rt_->PopClipRect();
return frame_rt_->EndDraw();
}
}
} // namespace kiwano

77
src/kiwano/2d/GifSprite.h
View File

@ -21,26 +21,25 @@
#pragma once
#include <kiwano/2d/Actor.h>
#include <kiwano/core/Resource.h>
#include <kiwano/render/RenderContext.h>
#include <kiwano/render/GifImage.h>
#include <kiwano/render/RenderContext.h>
namespace kiwano
{
KGE_DECLARE_SMART_PTR(GifSprite);
KGE_DECLARE_SMART_PTR(GifSprite);
/**
/**
* \addtogroup Actors
* @{
*/
/**
/**
* \~chinese
* @brief GIF 精灵
*/
class KGE_API GifSprite
: public Actor
{
public:
class KGE_API GifSprite : public Actor
{
public:
/// \~chinese
/// @brief GIF播放循环结束回调
using LoopDoneCallback = Function<void(int /* times */)>;
@ -100,7 +99,7 @@ namespace kiwano
void OnRender(RenderContext& ctx) override;
private:
private:
void Update(Duration dt) override;
/// \~chinese
@ -135,7 +134,7 @@ namespace kiwano
/// @brief 清空当前图像区域
void ClearCurrentFrameArea();
private:
private:
bool animating_;
int total_loop_count_;
int loop_count_;
@ -148,23 +147,47 @@ namespace kiwano
TexturePtr saved_frame_;
TexturePtr frame_to_render_;
TextureRenderContextPtr frame_rt_;
};
};
/** @} */
/** @} */
inline void GifSprite::SetLoopCount(int loops) { total_loop_count_ = loops; }
inline void GifSprite::SetLoopDoneCallback(LoopDoneCallback const& cb) { loop_cb_ = cb; }
inline void GifSprite::SetDoneCallback(DoneCallback const& cb) { done_cb_ = cb; }
inline GifSprite::LoopDoneCallback GifSprite::GetLoopDoneCallback() const { return loop_cb_; }
inline GifSprite::DoneCallback GifSprite::GetDoneCallback() const { return done_cb_; }
inline GifImagePtr GifSprite::GetGifImage() const { return gif_; }
inline bool GifSprite::IsLastFrame() const { return (next_index_ == 0); }
inline bool GifSprite::EndOfAnimation() const { return IsLastFrame() && loop_count_ == total_loop_count_ + 1; }
inline void GifSprite::SetLoopCount(int loops)
{
total_loop_count_ = loops;
}
inline void GifSprite::SetLoopDoneCallback(LoopDoneCallback const& cb)
{
loop_cb_ = cb;
}
inline void GifSprite::SetDoneCallback(DoneCallback const& cb)
{
done_cb_ = cb;
}
inline GifSprite::LoopDoneCallback GifSprite::GetLoopDoneCallback() const
{
return loop_cb_;
}
inline GifSprite::DoneCallback GifSprite::GetDoneCallback() const
{
return done_cb_;
}
inline GifImagePtr GifSprite::GetGifImage() const
{
return gif_;
}
inline bool GifSprite::IsLastFrame() const
{
return (next_index_ == 0);
}
inline bool GifSprite::EndOfAnimation() const
{
return IsLastFrame() && loop_count_ == total_loop_count_ + 1;
}
} // namespace kiwano

54
src/kiwano/2d/Layer.cpp
View File

@ -24,38 +24,36 @@
namespace kiwano
{
Layer::Layer()
Layer::Layer()
: swallow_(false)
{
}
{
}
Layer::~Layer()
{
}
Layer::~Layer() {}
void Layer::SetClipRect(Rect const& clip_rect)
{
void Layer::SetClipRect(Rect const& clip_rect)
{
area_.SetAreaRect(clip_rect);
}
}
void Layer::SetOpacity(float opacity)
{
void Layer::SetOpacity(float opacity)
{
// Actor::SetOpacity(opacity);
area_.SetOpacity(opacity);
}
}
void Layer::SetMaskGeometry(Geometry const& mask)
{
void Layer::SetMaskGeometry(Geometry const& mask)
{
area_.SetMaskGeometry(mask);
}
}
void Layer::SetMaskTransform(Matrix3x2 const& transform)
{
void Layer::SetMaskTransform(Matrix3x2 const& transform)
{
area_.SetMaskTransform(transform);
}
}
bool Layer::DispatchEvent(Event* evt)
{
bool Layer::DispatchEvent(Event* evt)
{
if (!IsVisible())
return true;
@ -64,21 +62,21 @@ namespace kiwano
return EventDispatcher::DispatchEvent(evt);
}
return Actor::DispatchEvent(evt);
}
}
void Layer::Render(RenderContext& ctx)
{
void Layer::Render(RenderContext& ctx)
{
ctx.PushLayer(area_);
Actor::Render(ctx);
ctx.PopLayer();
}
}
bool Layer::CheckVisibility(RenderContext& ctx) const
{
bool Layer::CheckVisibility(RenderContext& ctx) const
{
// Do not need to render Layer
return false;
}
}
} // namespace kiwano

48
src/kiwano/2d/Layer.h
View File

@ -25,21 +25,20 @@
namespace kiwano
{
KGE_DECLARE_SMART_PTR(Layer);
KGE_DECLARE_SMART_PTR(Layer);
/**
/**
* \addtogroup Actors
* @{
*/
/**
/**
* \~chinese
* @brief ͼ²ã
*/
class KGE_API Layer
: public Actor
{
public:
class KGE_API Layer : public Actor
{
public:
Layer();
virtual ~Layer();
@ -84,24 +83,35 @@ namespace kiwano
bool DispatchEvent(Event* evt) override;
protected:
protected:
void Render(RenderContext& ctx) override;
bool CheckVisibility(RenderContext& ctx) const override;
private:
private:
bool swallow_;
LayerArea area_;
};
};
/** @} */
inline bool Layer::IsSwallowEventsEnabled() const { return swallow_; }
inline void Layer::SetSwallowEvents(bool enabled) { swallow_ = enabled; }
inline void Layer::SetArea(LayerArea const& area) { area_ = area; }
inline LayerArea const& Layer::GetArea() const { return area_; }
/** @} */
inline bool Layer::IsSwallowEventsEnabled() const
{
return swallow_;
}
inline void Layer::SetSwallowEvents(bool enabled)
{
swallow_ = enabled;
}
inline void Layer::SetArea(LayerArea const& area)
{
area_ = area;
}
inline LayerArea const& Layer::GetArea() const
{
return area_;
}
} // namespace kiwano

283
src/kiwano/2d/ShapeActor.cpp
View File

@ -24,46 +24,44 @@
namespace kiwano
{
ShapeActor::ShapeActor()
ShapeActor::ShapeActor()
: stroke_width_(1.f)
, stroke_style_()
{
}
{
}
ShapeActor::~ShapeActor()
{
}
ShapeActor::~ShapeActor() {}
Rect ShapeActor::GetBounds() const
{
Rect ShapeActor::GetBounds() const
{
return bounds_;
}
}
Rect ShapeActor::GetBoundingBox() const
{
Rect ShapeActor::GetBoundingBox() const
{
if (!geo_.IsValid())
return Rect{};
return geo_.GetBoundingBox(GetTransformMatrix());
}
}
bool ShapeActor::ContainsPoint(const Point& point) const
{
bool ShapeActor::ContainsPoint(const Point& point) const
{
return geo_.ContainsPoint(point, &GetTransformMatrix());
}
}
void ShapeActor::SetStrokeWidth(float width)
{
void ShapeActor::SetStrokeWidth(float width)
{
stroke_width_ = std::max(width, 0.f);
}
}
void ShapeActor::SetStrokeStyle(const StrokeStyle& stroke_style)
{
void ShapeActor::SetStrokeStyle(const StrokeStyle& stroke_style)
{
stroke_style_ = stroke_style;
}
}
void ShapeActor::SetGeometry(Geometry const& geometry)
{
void ShapeActor::SetGeometry(Geometry const& geometry)
{
geo_ = geometry;
if (geo_.IsValid())
{
@ -75,10 +73,10 @@ namespace kiwano
bounds_ = Rect{};
SetSize(0.f, 0.f);
}
}
}
void ShapeActor::OnRender(RenderContext& ctx)
{
void ShapeActor::OnRender(RenderContext& ctx)
{
// Create default brush
if (!fill_brush_)
{
@ -97,182 +95,145 @@ namespace kiwano
ctx.SetCurrentBrush(fill_brush_);
ctx.FillGeometry(geo_);
}
}
bool ShapeActor::CheckVisibility(RenderContext& ctx) const
{
bool ShapeActor::CheckVisibility(RenderContext& ctx) const
{
return geo_.IsValid() && Actor::CheckVisibility(ctx);
}
}
//-------------------------------------------------------
// LineActor
//-------------------------------------------------------
//-------------------------------------------------------
// LineActor
//-------------------------------------------------------
LineActor::LineActor()
{
}
LineActor::LineActor() {}
LineActor::~LineActor()
{
}
LineActor::~LineActor() {}
void LineActor::SetLine(Point const& begin, Point const& end)
{
void LineActor::SetLine(Point const& begin, Point const& end)
{
if (begin_ != begin || end_ != end)
{
begin_ = begin;
end_ = end;
SetGeometry(Geometry::CreateLine(begin, end));
}
}
}
//-------------------------------------------------------
// RectActor
//-------------------------------------------------------
//-------------------------------------------------------
// RectActor
//-------------------------------------------------------
RectActor::RectActor() {}
RectActor::RectActor()
{
}
RectActor::~RectActor() {}
RectActor::~RectActor()
{
}
void RectActor::SetRectSize(Size const& size)
{
void RectActor::SetRectSize(Size const& size)
{
if (size != rect_size_)
{
rect_size_ = size;
SetGeometry(Geometry::CreateRect(Rect{ Point{}, size }));
}
}
}
//-------------------------------------------------------
// RoundRectActor
//-------------------------------------------------------
//-------------------------------------------------------
// RoundRectActor
//-------------------------------------------------------
RoundRectActor::RoundRectActor() {}
RoundRectActor::RoundRectActor()
{
}
RoundRectActor::~RoundRectActor() {}
RoundRectActor::~RoundRectActor()
{
}
void RoundRectActor::SetRadius(Vec2 const& radius)
{
void RoundRectActor::SetRadius(Vec2 const& radius)
{
SetRoundedRect(GetSize(), radius);
}
}
void RoundRectActor::SetRectSize(Size const& size)
{
void RoundRectActor::SetRectSize(Size const& size)
{
SetRoundedRect(size, radius_);
}
}
void RoundRectActor::SetRoundedRect(Size const& size, Vec2 const& radius)
{
void RoundRectActor::SetRoundedRect(Size const& size, Vec2 const& radius)
{
if (rect_size_ != size || radius_ != radius)
{
rect_size_ = size;
radius_ = radius;
SetGeometry(Geometry::CreateRoundedRect(Rect{ Point{}, size }, radius));
}
}
}
//-------------------------------------------------------
// CircleActor
//-------------------------------------------------------
//-------------------------------------------------------
// CircleActor
//-------------------------------------------------------
CircleActor::CircleActor()
CircleActor::CircleActor()
: radius_(0.f)
{
}
{
}
CircleActor::~CircleActor()
{
}
CircleActor::~CircleActor() {}
void CircleActor::SetRadius(float radius)
{
void CircleActor::SetRadius(float radius)
{
if (radius_ != radius)
{
radius_ = radius;
SetGeometry(Geometry::CreateCircle(Point{ radius, radius }, radius));
}
}
}
//-------------------------------------------------------
// EllipseActor
//-------------------------------------------------------
//-------------------------------------------------------
// EllipseActor
//-------------------------------------------------------
EllipseActor::EllipseActor() {}
EllipseActor::EllipseActor()
{
}
EllipseActor::~EllipseActor() {}
EllipseActor::~EllipseActor()
{
}
void EllipseActor::SetRadius(Vec2 const& radius)
{
void EllipseActor::SetRadius(Vec2 const& radius)
{
if (radius_ != radius)
{
radius_ = radius;
SetGeometry(Geometry::CreateEllipse(radius, radius));
}
}
}
//-------------------------------------------------------
// PolygonActor
//-------------------------------------------------------
//-------------------------------------------------------
// PolygonActor
//-------------------------------------------------------
PolygonActor::PolygonActor() {}
PolygonActor::PolygonActor()
{
}
PolygonActor::~PolygonActor() {}
PolygonActor::~PolygonActor()
{
}
void PolygonActor::SetVertices(Vector<Point> const& points)
{
void PolygonActor::SetVertices(Vector<Point> const& points)
{
if (points.size() > 1)
{
SetGeometry(
GeometrySink()
.BeginPath(points[0])
.AddLines(&points[1], points.size() - 1)
.EndPath(true)
.GetGeometry()
);
}
GeometrySink().BeginPath(points[0]).AddLines(&points[1], points.size() - 1).EndPath(true).GetGeometry());
}
}
//-------------------------------------------------------
// PathShapeActor
//-------------------------------------------------------
//-------------------------------------------------------
// PathShapeActor
//-------------------------------------------------------
PathShapeActor::PathShapeActor() {}
PathShapeActor::PathShapeActor()
{
}
PathShapeActor::~PathShapeActor() {}
PathShapeActor::~PathShapeActor()
{
}
void PathShapeActor::BeginPath(Point const& begin_pos)
{
void PathShapeActor::BeginPath(Point const& begin_pos)
{
sink_.BeginPath(begin_pos);
}
}
void PathShapeActor::EndPath(bool closed)
{
void PathShapeActor::EndPath(bool closed)
{
sink_.EndPath(closed);
Geometry geo = sink_.GetGeometry();
@ -280,31 +241,31 @@ namespace kiwano
{
SetGeometry(geo);
}
}
void PathShapeActor::AddLine(Point const& point)
{
sink_.AddLine(point);
}
void PathShapeActor::AddLines(Vector<Point> const& points)
{
sink_.AddLines(points);
}
void PathShapeActor::AddBezier(Point const& point1, Point const& point2, Point const& point3)
{
sink_.AddBezier(point1, point2, point3);
}
void PathShapeActor::AddArc(Point const& point, Size const& radius, float rotation, bool clockwise, bool is_small)
{
sink_.AddArc(point, radius, rotation, clockwise, is_small);
}
void PathShapeActor::ClearPath()
{
SetGeometry(Geometry());
}
}
void PathShapeActor::AddLine(Point const& point)
{
sink_.AddLine(point);
}
void PathShapeActor::AddLines(Vector<Point> const& points)
{
sink_.AddLines(points);
}
void PathShapeActor::AddBezier(Point const& point1, Point const& point2, Point const& point3)
{
sink_.AddBezier(point1, point2, point3);
}
void PathShapeActor::AddArc(Point const& point, Size const& radius, float rotation, bool clockwise, bool is_small)
{
sink_.AddArc(point, radius, rotation, clockwise, is_small);
}
void PathShapeActor::ClearPath()
{
SetGeometry(Geometry());
}
} // namespace kiwano

250
src/kiwano/2d/ShapeActor.h
View File

@ -27,28 +27,27 @@
namespace kiwano
{
KGE_DECLARE_SMART_PTR(ShapeActor);
KGE_DECLARE_SMART_PTR(LineActor);
KGE_DECLARE_SMART_PTR(RectActor);
KGE_DECLARE_SMART_PTR(RoundRectActor);
KGE_DECLARE_SMART_PTR(CircleActor);
KGE_DECLARE_SMART_PTR(EllipseActor);
KGE_DECLARE_SMART_PTR(PolygonActor);
KGE_DECLARE_SMART_PTR(PathShapeActor);
KGE_DECLARE_SMART_PTR(ShapeActor);
KGE_DECLARE_SMART_PTR(LineActor);
KGE_DECLARE_SMART_PTR(RectActor);
KGE_DECLARE_SMART_PTR(RoundRectActor);
KGE_DECLARE_SMART_PTR(CircleActor);
KGE_DECLARE_SMART_PTR(EllipseActor);
KGE_DECLARE_SMART_PTR(PolygonActor);
KGE_DECLARE_SMART_PTR(PathShapeActor);
/**
/**
* \addtogroup Actors
* @{
*/
/**
/**
* \~chinese
* @brief 二维形状角色
*/
class KGE_API ShapeActor
: public Actor
{
public:
class KGE_API ShapeActor : public Actor
{
public:
/// \~chinese
/// @brief 构造二维形状角色
ShapeActor();
@ -121,25 +120,23 @@ namespace kiwano
void OnRender(RenderContext& ctx) override;
protected:
protected:
bool CheckVisibility(RenderContext& ctx) const override;
private:
private:
BrushPtr fill_brush_;
BrushPtr stroke_brush_;
float stroke_width_;
StrokeStyle stroke_style_;
Rect bounds_;
Geometry geo_;
};
};
/// \~chinese
/// @brief 线段图形角色
class KGE_API LineActor
: public ShapeActor
{
public:
/// \~chinese
/// @brief 线段图形角色
class KGE_API LineActor : public ShapeActor
{
public:
LineActor();
virtual ~LineActor();
@ -168,18 +165,16 @@ namespace kiwano
/// @param end 线段终点
void SetLine(Point const& begin, Point const& end);
private:
private:
Point begin_;
Point end_;
};
};
/// \~chinese
/// @brief 矩形角色
class KGE_API RectActor
: public ShapeActor
{
public:
/// \~chinese
/// @brief 矩形角色
class KGE_API RectActor : public ShapeActor
{
public:
RectActor();
virtual ~RectActor();
@ -193,18 +188,15 @@ namespace kiwano
/// @param size 矩形大小
void SetRectSize(Size const& size);
private:
private:
Size rect_size_;
};
};
/// \~chinese
/// @brief 圆角矩形角色
class KGE_API RoundRectActor
: public ShapeActor
{
public:
/// \~chinese
/// @brief 圆角矩形角色
class KGE_API RoundRectActor : public ShapeActor
{
public:
RoundRectActor();
virtual ~RoundRectActor();
@ -233,18 +225,16 @@ namespace kiwano
/// @param radius 圆角半径
void SetRoundedRect(Size const& size, Vec2 const& radius);
private:
private:
Size rect_size_;
Vec2 radius_;
};
};
/// \~chinese
/// @brief 圆形角色
class KGE_API CircleActor
: public ShapeActor
{
public:
/// \~chinese
/// @brief 圆形角色
class KGE_API CircleActor : public ShapeActor
{
public:
CircleActor();
virtual ~CircleActor();
@ -258,17 +248,15 @@ namespace kiwano
/// @param radius 圆形半径
void SetRadius(float radius);
private:
private:
float radius_;
};
};
/// \~chinese
/// @brief 椭圆角色
class KGE_API EllipseActor
: public ShapeActor
{
public:
/// \~chinese
/// @brief 椭圆角色
class KGE_API EllipseActor : public ShapeActor
{
public:
EllipseActor();
virtual ~EllipseActor();
@ -282,17 +270,15 @@ namespace kiwano
/// @param radius 椭圆半径
void SetRadius(Vec2 const& radius);
private:
private:
Vec2 radius_;
};
};
/// \~chinese
/// @brief 多边形角色
class KGE_API PolygonActor
: public ShapeActor
{
public:
/// \~chinese
/// @brief 多边形角色
class KGE_API PolygonActor : public ShapeActor
{
public:
PolygonActor();
virtual ~PolygonActor();
@ -301,15 +287,13 @@ namespace kiwano
/// @brief 设置多边形端点
/// @param points 多边形端点集合
void SetVertices(Vector<Point> const& points);
};
};
/// \~chinese
/// @brief 路径图形角色
class KGE_API PathShapeActor
: public ShapeActor
{
public:
/// \~chinese
/// @brief 路径图形角色
class KGE_API PathShapeActor : public ShapeActor
{
public:
PathShapeActor();
virtual ~PathShapeActor();
@ -354,49 +338,97 @@ namespace kiwano
/// @brief 清除路径
void ClearPath();
private:
private:
GeometrySink sink_;
};
};
/** @} */
/** @} */
inline void ShapeActor::SetStrokeColor(Color const& color)
{
inline void ShapeActor::SetStrokeColor(Color const& color)
{
if (!stroke_brush_)
{
stroke_brush_ = new Brush;
}
stroke_brush_->SetColor(color);
}
}
inline void ShapeActor::SetFillColor(Color const& color)
{
inline void ShapeActor::SetFillColor(Color const& color)
{
if (!fill_brush_)
{
fill_brush_ = new Brush;
}
fill_brush_->SetColor(color);
}
inline void ShapeActor::SetFillBrush(BrushPtr brush) { fill_brush_ = brush; }
inline void ShapeActor::SetStrokeBrush(BrushPtr brush) { stroke_brush_ = brush; }
inline BrushPtr ShapeActor::GetFillBrush() const { return fill_brush_; }
inline BrushPtr ShapeActor::GetStrokeBrush() const { return stroke_brush_; }
inline float ShapeActor::GetStrokeWidth() const { return stroke_width_; }
inline const StrokeStyle& ShapeActor::GetStrokeStyle() const { return stroke_style_; }
inline Geometry ShapeActor::GetGeometry() const { return geo_; }
inline Point const& LineActor::GetBeginPoint() const { return begin_; }
inline Point const& LineActor::GetEndPoint() const { return end_; }
inline void LineActor::SetBeginPoint(Point const& begin) { SetLine(begin, end_); }
inline void LineActor::SetEndPoint(Point const& end) { SetLine(begin_, end); }
inline Size const& RectActor::GetRectSize() const { return rect_size_; }
inline Vec2 RoundRectActor::GetRadius() const { return radius_; }
inline Size RoundRectActor::GetRectSize() const { return GetSize(); }
inline float CircleActor::GetRadius() const { return radius_; }
inline Vec2 EllipseActor::GetRadius() const { return radius_; }
}
inline void ShapeActor::SetFillBrush(BrushPtr brush)
{
fill_brush_ = brush;
}
inline void ShapeActor::SetStrokeBrush(BrushPtr brush)
{
stroke_brush_ = brush;
}
inline BrushPtr ShapeActor::GetFillBrush() const
{
return fill_brush_;
}
inline BrushPtr ShapeActor::GetStrokeBrush() const
{
return stroke_brush_;
}
inline float ShapeActor::GetStrokeWidth() const
{
return stroke_width_;
}
inline const StrokeStyle& ShapeActor::GetStrokeStyle() const
{
return stroke_style_;
}
inline Geometry ShapeActor::GetGeometry() const
{
return geo_;
}
inline Point const& LineActor::GetBeginPoint() const
{
return begin_;
}
inline Point const& LineActor::GetEndPoint() const
{
return end_;
}
inline void LineActor::SetBeginPoint(Point const& begin)
{
SetLine(begin, end_);
}
inline void LineActor::SetEndPoint(Point const& end)
{
SetLine(begin_, end);
}
inline Size const& RectActor::GetRectSize() const
{
return rect_size_;
}
inline Vec2 RoundRectActor::GetRadius() const
{
return radius_;
}
inline Size RoundRectActor::GetRectSize() const
{
return GetSize();
}
inline float CircleActor::GetRadius() const
{
return radius_;
}
inline Vec2 EllipseActor::GetRadius() const
{
return radius_;
}
} // namespace kiwano

52
src/kiwano/2d/Sprite.cpp
View File

@ -23,16 +23,12 @@
namespace kiwano
{
Sprite::Sprite()
{
}
Sprite::Sprite() {}
Sprite::~Sprite()
{
}
Sprite::~Sprite() {}
bool Sprite::Load(String const& file_path)
{
bool Sprite::Load(String const& file_path)
{
FramePtr frame = new (std::nothrow) Frame;
if (frame->Load(file_path))
{
@ -40,10 +36,10 @@ namespace kiwano
return true;
}
return false;
}
}
bool Sprite::Load(Resource const& res)
{
bool Sprite::Load(Resource const& res)
{
FramePtr frame = new (std::nothrow) Frame;
if (frame->Load(res))
{
@ -51,19 +47,19 @@ namespace kiwano
return true;
}
return false;
}
}
void Sprite::SetCropRect(const Rect& crop_rect)
{
void Sprite::SetCropRect(const Rect& crop_rect)
{
if (frame_)
{
frame_->SetCropRect(crop_rect);
SetSize(Size{ frame_->GetWidth(), frame_->GetHeight() });
}
}
}
void Sprite::SetFrame(FramePtr frame)
{
void Sprite::SetFrame(FramePtr frame)
{
if (frame_ != frame)
{
frame_ = frame;
@ -72,15 +68,15 @@ namespace kiwano
SetSize(Size{ frame_->GetWidth(), frame_->GetHeight() });
}
}
}
void Sprite::OnRender(RenderContext& ctx)
{
ctx.DrawTexture(*frame_->GetTexture(), &frame_->GetCropRect(), &GetBounds());
}
bool Sprite::CheckVisibility(RenderContext& ctx) const
{
return frame_ && frame_->IsValid() && Actor::CheckVisibility(ctx);
}
}
void Sprite::OnRender(RenderContext& ctx)
{
ctx.DrawTexture(*frame_->GetTexture(), &frame_->GetCropRect(), &GetBounds());
}
bool Sprite::CheckVisibility(RenderContext& ctx) const
{
return frame_ && frame_->IsValid() && Actor::CheckVisibility(ctx);
}
} // namespace kiwano

27
src/kiwano/2d/Sprite.h
View File

@ -24,21 +24,20 @@
namespace kiwano
{
KGE_DECLARE_SMART_PTR(Sprite);
KGE_DECLARE_SMART_PTR(Sprite);
/**
/**
* \addtogroup Actors
* @{
*/
/**
/**
* \~chinese
* @brief ¾«Áé
*/
class KGE_API Sprite
: public Actor
{
public:
class KGE_API Sprite : public Actor
{
public:
Sprite();
virtual ~Sprite();
@ -69,15 +68,17 @@ namespace kiwano
void OnRender(RenderContext& ctx) override;
protected:
protected:
bool CheckVisibility(RenderContext& ctx) const override;
private:
private:
FramePtr frame_;
};
};
/** @} */
inline FramePtr Sprite::GetFrame() const { return frame_; }
/** @} */
inline FramePtr Sprite::GetFrame() const
{
return frame_;
}
} // namespace kiwano

30
src/kiwano/2d/Stage.cpp
View File

@ -24,30 +24,28 @@
namespace kiwano
{
Stage::Stage()
{
Stage::Stage()
{
SetStage(this);
SetAnchor(Vec2{ 0, 0 });
SetSize(Renderer::Instance().GetOutputSize());
}
}
Stage::~Stage()
{
}
Stage::~Stage() {}
void Stage::OnEnter()
{
void Stage::OnEnter()
{
KGE_SYS_LOG(L"Stage entered");
}
}
void Stage::OnExit()
{
void Stage::OnExit()
{
KGE_SYS_LOG(L"Stage exited");
}
}
void Stage::RenderBorder(RenderContext& ctx)
{
void Stage::RenderBorder(RenderContext& ctx)
{
ctx.SetBrushOpacity(GetDisplayedOpacity());
if (!border_fill_brush_)
@ -63,6 +61,6 @@ namespace kiwano
}
Actor::RenderBorder(ctx);
}
}
} // namespace kiwano

58
src/kiwano/2d/Stage.h
View File

@ -24,26 +24,25 @@
namespace kiwano
{
KGE_DECLARE_SMART_PTR(Stage);
KGE_DECLARE_SMART_PTR(Stage);
/**
/**
* \addtogroup Actors
* @{
*/
/**
/**
* \~chinese
* @brief 舞台
* @details 舞台是所有角色的载体，是导演直接控制的对象
* @see kiwano::Actor kiwano::Director
*/
class KGE_API Stage
: public Actor
{
class KGE_API Stage : public Actor
{
friend class Transition;
friend class Director;
public:
public:
Stage();
virtual ~Stage();
@ -74,36 +73,35 @@ namespace kiwano
/// @brief 设置角色边界轮廓画刷
void SetBorderStrokeBrush(BrushPtr brush);
protected:
protected:
/// \~chinese
/// @brief 绘制所有子角色的边界
void RenderBorder(RenderContext& ctx) override;
private:
private:
BrushPtr border_fill_brush_;
BrushPtr border_stroke_brush_;
};
};
/** @} */
/** @} */
inline BrushPtr Stage::GetBorderFillBrush() const
{
inline BrushPtr Stage::GetBorderFillBrush() const
{
return border_fill_brush_;
}
inline BrushPtr Stage::GetBorderStrokeBrush() const
{
return border_stroke_brush_;
}
inline void Stage::SetBorderFillBrush(BrushPtr brush)
{
border_fill_brush_ = brush;
}
inline void Stage::SetBorderStrokeBrush(BrushPtr brush)
{
border_stroke_brush_ = brush;
}
}
inline BrushPtr Stage::GetBorderStrokeBrush() const
{
return border_stroke_brush_;
}
inline void Stage::SetBorderFillBrush(BrushPtr brush)
{
border_fill_brush_ = brush;
}
inline void Stage::SetBorderStrokeBrush(BrushPtr brush)
{
border_stroke_brush_ = brush;
}
} // namespace kiwano

86
src/kiwano/2d/TextActor.cpp
View File

@ -24,12 +24,12 @@
namespace kiwano
{
namespace
{
TextStyle text_default_style;
namespace
{
TextStyle text_default_style;
void InitDefaultTextStyle()
{
void InitDefaultTextStyle()
{
static bool inited = false;
if (!inited)
{
@ -39,54 +39,52 @@ namespace kiwano
text_default_style.fill_brush = new Brush;
text_default_style.fill_brush->SetColor(Color::White);
}
}
}
}
} // namespace
void TextActor::SetDefaultStyle(TextStyle const & style)
{
void TextActor::SetDefaultStyle(TextStyle const& style)
{
text_default_style = style;
}
}
const TextStyle& TextActor::GetDefaultStyle()
{
const TextStyle& TextActor::GetDefaultStyle()
{
InitDefaultTextStyle();
return text_default_style;
}
}
TextActor::TextActor()
TextActor::TextActor()
: TextActor(String())
{
}
{
}
TextActor::TextActor(String const& text)
TextActor::TextActor(String const& text)
: TextActor(text, GetDefaultStyle())
{
}
{
}
TextActor::TextActor(String const& text, const TextStyle& style)
TextActor::TextActor(String const& text, const TextStyle& style)
: show_underline_(false)
, show_strikethrough_(false)
{
{
SetText(text);
SetStyle(style);
}
}
TextActor::~TextActor()
{
}
TextActor::~TextActor() {}
void TextActor::OnRender(RenderContext& ctx)
{
void TextActor::OnRender(RenderContext& ctx)
{
ctx.DrawTextLayout(text_layout_);
}
}
void TextActor::OnUpdate(Duration dt)
{
void TextActor::OnUpdate(Duration dt)
{
UpdateLayout();
}
}
void TextActor::UpdateLayout()
{
void TextActor::UpdateLayout()
{
if (text_layout_.IsDirty())
{
text_layout_.Update();
@ -104,31 +102,31 @@ namespace kiwano
SetSize(text_layout_.GetLayoutSize());
}
}
}
bool TextActor::CheckVisibility(RenderContext& ctx) const
{
bool TextActor::CheckVisibility(RenderContext& ctx) const
{
return text_layout_.IsValid() && Actor::CheckVisibility(ctx);
}
}
void TextActor::SetFillColor(Color const& color)
{
void TextActor::SetFillColor(Color const& color)
{
if (!text_layout_.GetFillBrush() || text_layout_.GetFillBrush() == GetDefaultStyle().fill_brush)
{
BrushPtr brush = new Brush;
text_layout_.SetFillBrush(brush);
}
text_layout_.GetFillBrush()->SetColor(color);
}
}
void TextActor::SetOutlineColor(Color const& outline_color)
{
void TextActor::SetOutlineColor(Color const& outline_color)
{
if (!text_layout_.GetOutlineBrush() || text_layout_.GetOutlineBrush() == GetDefaultStyle().outline_brush)
{
BrushPtr brush = new Brush;
text_layout_.SetOutlineBrush(brush);
}
text_layout_.GetOutlineBrush()->SetColor(outline_color);
}
}
} // namespace kiwano

248
src/kiwano/2d/TextActor.h
View File

@ -25,21 +25,20 @@
namespace kiwano
{
KGE_DECLARE_SMART_PTR(TextActor);
KGE_DECLARE_SMART_PTR(TextActor);
/**
/**
* \addtogroup Actors
* @{
*/
/**
/**
* \~chinese
* @brief 文本角色
*/
class KGE_API TextActor
: public Actor
{
public:
class KGE_API TextActor : public Actor
{
public:
/// \~chinese
/// @brief 构建空的文本角色
TextActor();
@ -174,130 +173,129 @@ namespace kiwano
void OnUpdate(Duration dt) override;
protected:
protected:
bool CheckVisibility(RenderContext& ctx) const override;
private:
private:
bool show_underline_;
bool show_strikethrough_;
TextLayout text_layout_;
};
};
/** @} */
/** @} */
inline const String& TextActor::GetText() const
{
inline const String& TextActor::GetText() const
{
return text_layout_.GetText();
}
inline FontPtr TextActor::GetFont() const
{
return text_layout_.GetStyle().font;
}
inline const TextStyle& TextActor::GetStyle() const
{
return text_layout_.GetStyle();
}
inline const TextLayout& TextActor::GetLayout() const
{
return text_layout_;
}
inline Size TextActor::GetLayoutSize() const
{
return text_layout_.GetLayoutSize();
}
inline BrushPtr TextActor::GetFillBrush() const
{
return text_layout_.GetFillBrush();
}
inline BrushPtr TextActor::GetOutlineBrush() const
{
return text_layout_.GetOutlineBrush();
}
inline void TextActor::SetText(String const& text)
{
text_layout_.SetText(text);
}
inline void TextActor::SetStyle(const TextStyle& style)
{
text_layout_.SetStyle(style);
}
inline void TextActor::SetFont(FontPtr font)
{
text_layout_.SetFont(font);
}
inline void TextActor::SetFontFamily(String const& family)
{
text_layout_.SetFontFamily(family);
}
inline void TextActor::SetFontSize(float size)
{
text_layout_.SetFontSize(size);
}
inline void TextActor::SetFontWeight(uint32_t weight)
{
text_layout_.SetFontWeight(weight);
}
inline void TextActor::SetItalic(bool italic)
{
text_layout_.SetItalic(italic);
}
inline void TextActor::SetWrapWidth(float wrap_width)
{
text_layout_.SetWrapWidth(wrap_width);
}
inline void TextActor::SetLineSpacing(float line_spacing)
{
text_layout_.SetLineSpacing(line_spacing);
}
inline void TextActor::SetAlignment(TextAlign align)
{
text_layout_.SetAlignment(align);
}
inline void TextActor::SetUnderline(bool enable)
{
show_underline_ = enable;
}
inline void TextActor::SetStrikethrough(bool enable)
{
show_strikethrough_ = enable;
}
inline void TextActor::SetFillBrush(BrushPtr brush)
{
text_layout_.SetFillBrush(brush);
}
inline void TextActor::SetOutlineBrush(BrushPtr brush)
{
text_layout_.SetOutlineBrush(brush);
}
inline void TextActor::SetOutlineWidth(float outline_width)
{
text_layout_.SetOutlineWidth(outline_width);
}
inline void TextActor::SetOutlineStroke(const StrokeStyle& outline_stroke)
{
text_layout_.SetOutlineStroke(outline_stroke);
}
}
inline FontPtr TextActor::GetFont() const
{
return text_layout_.GetStyle().font;
}
inline const TextStyle& TextActor::GetStyle() const
{
return text_layout_.GetStyle();
}
inline const TextLayout& TextActor::GetLayout() const
{
return text_layout_;
}
inline Size TextActor::GetLayoutSize() const
{
return text_layout_.GetLayoutSize();
}
inline BrushPtr TextActor::GetFillBrush() const
{
return text_layout_.GetFillBrush();
}
inline BrushPtr TextActor::GetOutlineBrush() const
{
return text_layout_.GetOutlineBrush();
}
inline void TextActor::SetText(String const& text)
{
text_layout_.SetText(text);
}
inline void TextActor::SetStyle(const TextStyle& style)
{
text_layout_.SetStyle(style);
}
inline void TextActor::SetFont(FontPtr font)
{
text_layout_.SetFont(font);
}
inline void TextActor::SetFontFamily(String const& family)
{
text_layout_.SetFontFamily(family);
}
inline void TextActor::SetFontSize(float size)
{
text_layout_.SetFontSize(size);
}
inline void TextActor::SetFontWeight(uint32_t weight)
{
text_layout_.SetFontWeight(weight);
}
inline void TextActor::SetItalic(bool italic)
{
text_layout_.SetItalic(italic);
}
inline void TextActor::SetWrapWidth(float wrap_width)
{
text_layout_.SetWrapWidth(wrap_width);
}
inline void TextActor::SetLineSpacing(float line_spacing)
{
text_layout_.SetLineSpacing(line_spacing);
}
inline void TextActor::SetAlignment(TextAlign align)
{
text_layout_.SetAlignment(align);
}
inline void TextActor::SetUnderline(bool enable)
{
show_underline_ = enable;
}
inline void TextActor::SetStrikethrough(bool enable)
{
show_strikethrough_ = enable;
}
inline void TextActor::SetFillBrush(BrushPtr brush)
{
text_layout_.SetFillBrush(brush);
}
inline void TextActor::SetOutlineBrush(BrushPtr brush)
{
text_layout_.SetOutlineBrush(brush);
}
inline void TextActor::SetOutlineWidth(float outline_width)
{
text_layout_.SetOutlineWidth(outline_width);
}
inline void TextActor::SetOutlineStroke(const StrokeStyle& outline_stroke)
{
text_layout_.SetOutlineStroke(outline_stroke);
}
} // namespace kiwano

25
src/kiwano/2d/Transform.cpp
View File

@ -22,28 +22,25 @@
namespace kiwano
{
Transform::Transform()
Transform::Transform()
: position()
, rotation(0.f)
, scale(1.f, 1.f)
, skew(0.f, 0.f)
{
}
{
}
Matrix3x2 Transform::ToMatrix() const
{
Matrix3x2 Transform::ToMatrix() const
{
if (!skew.IsOrigin())
{
return Matrix3x2::Skewing(skew) * Matrix3x2::SRT(position, scale, rotation);
}
return Matrix3x2::SRT(position, scale, rotation);
}
bool Transform::operator== (Transform const& rhs) const
{
return position == rhs.position &&
rotation == rhs.rotation &&
scale == rhs.scale &&
skew == rhs.skew;
}
}
bool Transform::operator==(Transform const& rhs) const
{
return position == rhs.position && rotation == rhs.rotation && scale == rhs.scale && skew == rhs.skew;
}
} // namespace kiwano

16
src/kiwano/2d/Transform.h
View File

@ -23,25 +23,25 @@
namespace kiwano
{
/**
/**
* \~chinese
* @brief 二维放射变换
*/
class Transform
{
public:
class Transform
{
public:
float rotation; ///< 旋转
Point position; ///< 坐标
Point scale; ///< 缩放
Point skew; ///< 错切角度
public:
public:
Transform();
/// \~chinese
/// @brief 将二维放射变换转换为矩阵
Matrix3x2 ToMatrix() const;
bool operator== (const Transform& rhs) const;
};
}
bool operator==(const Transform& rhs) const;
};
} // namespace kiwano

202
src/kiwano/2d/Transition.cpp
View File

@ -18,20 +18,20 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include <kiwano/2d/Transition.h>
#include <kiwano/2d/Actor.h>
#include <kiwano/2d/Stage.h>
#include <kiwano/platform/Window.h>
#include <kiwano/2d/Transition.h>
#include <kiwano/core/Logger.h>
#include <kiwano/platform/Window.h>
#include <kiwano/render/Renderer.h>
namespace kiwano
{
//-------------------------------------------------------
// Transition
//-------------------------------------------------------
//-------------------------------------------------------
// Transition
//-------------------------------------------------------
Transition::Transition(Duration duration)
Transition::Transition(Duration duration)
: done_(false)
, duration_(duration)
, delta_()
@ -41,20 +41,18 @@ namespace kiwano
, in_stage_(nullptr)
, out_layer_()
, in_layer_()
{
}
{
}
Transition::~Transition()
{
}
Transition::~Transition() {}
bool Transition::IsDone()
{
bool Transition::IsDone()
{
return done_;
}
}
void Transition::Init(StagePtr prev, StagePtr next)
{
void Transition::Init(StagePtr prev, StagePtr next)
{
process_ = 0;
delta_ = Duration{};
@ -71,10 +69,10 @@ namespace kiwano
{
out_layer_.SetAreaRect(Rect{ Point(), window_size_ });
}
}
}
void Transition::Update(Duration dt)
{
void Transition::Update(Duration dt)
{
if (duration_.IsZero())
{
process_ = 1;
@ -89,10 +87,10 @@ namespace kiwano
{
this->Stop();
}
}
}
void Transition::Render(RenderContext& ctx)
{
void Transition::Render(RenderContext& ctx)
{
if (out_stage_)
{
out_stage_->PrepareToRender(ctx);
@ -116,104 +114,92 @@ namespace kiwano
ctx.PopLayer();
ctx.PopClipRect();
}
}
}
void Transition::Stop()
{
void Transition::Stop()
{
done_ = true;
Reset();
}
}
//-------------------------------------------------------
// BoxTransition
//-------------------------------------------------------
//-------------------------------------------------------
// BoxTransition
//-------------------------------------------------------
BoxTransition::BoxTransition(Duration duration)
BoxTransition::BoxTransition(Duration duration)
: Transition(duration)
{
}
{
}
void BoxTransition::Init(StagePtr prev, StagePtr next)
{
void BoxTransition::Init(StagePtr prev, StagePtr next)
{
Transition::Init(prev, next);
in_layer_.SetOpacity(0.f);
}
}
void BoxTransition::Update(Duration dt)
{
void BoxTransition::Update(Duration dt)
{
Transition::Update(dt);
if (process_ < .5f)
{
out_layer_.SetAreaRect(
Rect(
window_size_.x * process_,
window_size_.y * process_,
window_size_.x * (1 - process_),
window_size_.y * (1 - process_)
)
);
out_layer_.SetAreaRect(Rect(window_size_.x * process_, window_size_.y * process_,
window_size_.x * (1 - process_), window_size_.y * (1 - process_)));
}
else
{
out_layer_.SetOpacity(0.f);
in_layer_.SetOpacity(1.f);
in_layer_.SetAreaRect(
Rect(
window_size_.x * (1 - process_),
window_size_.y * (1 - process_),
window_size_.x * process_,
window_size_.y * process_
)
);
}
in_layer_.SetAreaRect(Rect(window_size_.x * (1 - process_), window_size_.y * (1 - process_),
window_size_.x * process_, window_size_.y * process_));
}
}
//-------------------------------------------------------
// EmergeTransition
//-------------------------------------------------------
//-------------------------------------------------------
// EmergeTransition
//-------------------------------------------------------
EmergeTransition::EmergeTransition(Duration duration)
EmergeTransition::EmergeTransition(Duration duration)
: Transition(duration)
{
}
{
}
void EmergeTransition::Init(StagePtr prev, StagePtr next)
{
void EmergeTransition::Init(StagePtr prev, StagePtr next)
{
Transition::Init(prev, next);
out_layer_.SetOpacity(1.f);
in_layer_.SetOpacity(0.f);
}
}
void EmergeTransition::Update(Duration dt)
{
void EmergeTransition::Update(Duration dt)
{
Transition::Update(dt);
out_layer_.SetOpacity(1 - process_);
in_layer_.SetOpacity(process_);
}
}
//-------------------------------------------------------
// FadeTransition
//-------------------------------------------------------
//-------------------------------------------------------
// FadeTransition
//-------------------------------------------------------
FadeTransition::FadeTransition(Duration duration)
FadeTransition::FadeTransition(Duration duration)
: Transition(duration)
{
}
{
}
void FadeTransition::Init(StagePtr prev, StagePtr next)
{
void FadeTransition::Init(StagePtr prev, StagePtr next)
{
Transition::Init(prev, next);
out_layer_.SetOpacity(1.f);
in_layer_.SetOpacity(0.f);
}
}
void FadeTransition::Update(Duration dt)
{
void FadeTransition::Update(Duration dt)
{
Transition::Update(dt);
if (process_ < 0.5)
@ -226,20 +212,20 @@ namespace kiwano
out_layer_.SetOpacity(0.f);
in_layer_.SetOpacity((process_ - 0.5f) * 2);
}
}
}
//-------------------------------------------------------
// MoveTransition
//-------------------------------------------------------
//-------------------------------------------------------
// MoveTransition
//-------------------------------------------------------
MoveTransition::MoveTransition(Duration duration, Type type)
MoveTransition::MoveTransition(Duration duration, Type type)
: Transition(duration)
, type_(type)
{
}
{
}
void MoveTransition::Init(StagePtr prev, StagePtr next)
{
void MoveTransition::Init(StagePtr prev, StagePtr next)
{
Transition::Init(prev, next);
switch (type_)
@ -273,10 +259,10 @@ namespace kiwano
transform.position = start_pos_;
in_stage_->SetTransform(transform);
}
}
}
void MoveTransition::Update(Duration dt)
{
void MoveTransition::Update(Duration dt)
{
Transition::Update(dt);
if (out_stage_)
@ -292,10 +278,10 @@ namespace kiwano
transform.position = start_pos_ + pos_delta_ * process_;
in_stage_->SetTransform(transform);
}
}
}
void MoveTransition::Reset()
{
void MoveTransition::Reset()
{
if (out_stage_)
{
out_stage_->SetTransform(Transform{});
@ -305,20 +291,20 @@ namespace kiwano
{
in_stage_->SetTransform(Transform{});
}
}
}
//-------------------------------------------------------
// RotationTransition
//-------------------------------------------------------
//-------------------------------------------------------
// RotationTransition
//-------------------------------------------------------
RotationTransition::RotationTransition(Duration duration, float rotation)
RotationTransition::RotationTransition(Duration duration, float rotation)
: Transition(duration)
, rotation_(rotation)
{
}
{
}
void RotationTransition::Init(StagePtr prev, StagePtr next)
{
void RotationTransition::Init(StagePtr prev, StagePtr next)
{
Transition::Init(prev, next);
auto transform = Transform{};
@ -337,10 +323,10 @@ namespace kiwano
}
in_layer_.SetOpacity(0.f);
}
}
void RotationTransition::Update(Duration dt)
{
void RotationTransition::Update(Duration dt)
{
Transition::Update(dt);
if (process_ < .5f)
@ -367,10 +353,10 @@ namespace kiwano
in_stage_->SetTransform(transform);
}
}
}
}
void RotationTransition::Reset()
{
void RotationTransition::Reset()
{
if (out_stage_)
{
out_stage_->SetTransform(Transform{});
@ -382,5 +368,5 @@ namespace kiwano
in_stage_->SetTransform(Transform{});
in_stage_->SetAnchor(Vec2{ 0.f, 0.f });
}
}
}
} // namespace kiwano

163
src/kiwano/2d/Transition.h
View File

@ -24,34 +24,31 @@
namespace kiwano
{
class Director;
class RenderContext;
class Director;
class RenderContext;
KGE_DECLARE_SMART_PTR(Transition);
KGE_DECLARE_SMART_PTR(FadeTransition);
KGE_DECLARE_SMART_PTR(EmergeTransition);
KGE_DECLARE_SMART_PTR(BoxTransition);
KGE_DECLARE_SMART_PTR(MoveTransition);
KGE_DECLARE_SMART_PTR(RotationTransition);
KGE_DECLARE_SMART_PTR(Transition);
KGE_DECLARE_SMART_PTR(FadeTransition);
KGE_DECLARE_SMART_PTR(EmergeTransition);
KGE_DECLARE_SMART_PTR(BoxTransition);
KGE_DECLARE_SMART_PTR(MoveTransition);
KGE_DECLARE_SMART_PTR(RotationTransition);
/**
/**
* \~chinese
* @brief 舞台过渡动画
*/
class KGE_API Transition
: public virtual ObjectBase
{
class KGE_API Transition : public virtual ObjectBase
{
friend class Director;
public:
public:
/**
* \~chinese
* @brief 构建空的场景过渡动画
* @param duration 动画时长
*/
explicit Transition(
Duration duration
);
explicit Transition(Duration duration);
virtual ~Transition();
@ -61,17 +58,14 @@ namespace kiwano
*/
bool IsDone();
protected:
protected:
/**
* \~chinese
* @brief 初始化场景过渡动画
* @param[in] prev 转出场景
* @param[in] next 转入场景
*/
virtual void Init(
StagePtr prev,
StagePtr next
);
virtual void Init(StagePtr prev, StagePtr next);
/**
* \~chinese
@ -99,7 +93,7 @@ namespace kiwano
*/
virtual void Reset() {}
protected:
protected:
bool done_;
float process_;
Duration duration_;
@ -109,102 +103,79 @@ namespace kiwano
StagePtr in_stage_;
LayerArea out_layer_;
LayerArea in_layer_;
};
};
/**
/**
* \~chinese
* @brief 淡入淡出过渡动画
* @details 前一场景淡出动画结束后，后一场景淡入
*/
class FadeTransition
: public Transition
{
public:
class FadeTransition : public Transition
{
public:
/**
* \~chinese
* @brief 构建淡入淡出过渡动画
* @param duration 动画时长
*/
explicit FadeTransition(
Duration duration
);
explicit FadeTransition(Duration duration);
protected:
protected:
void Update(Duration dt) override;
virtual void Init(
StagePtr prev,
StagePtr next
) override;
};
virtual void Init(StagePtr prev, StagePtr next) override;
};
/**
/**
* \~chinese
* @brief 渐变过渡动画
* @details 前一场景淡出动画的同时，后一场景淡入
*/
class EmergeTransition
: public Transition
{
public:
class EmergeTransition : public Transition
{
public:
/**
* \~chinese
* @brief 构建渐变过渡动画
* @param duration 动画时长
*/
explicit EmergeTransition(
Duration duration
);
explicit EmergeTransition(Duration duration);
protected:
protected:
void Update(Duration dt) override;
virtual void Init(
StagePtr prev,
StagePtr next
) override;
};
virtual void Init(StagePtr prev, StagePtr next) override;
};
/**
/**
* \~chinese
* @brief 盒状过渡动画
* @details 前一场景以盒状收缩至消失，后一场景以盒状扩大
*/
class BoxTransition
: public Transition
{
public:
class BoxTransition : public Transition
{
public:
/**
* \~chinese
* @brief 构建盒状过渡动画
* @param duration 动画时长
*/
explicit BoxTransition(
Duration duration
);
explicit BoxTransition(Duration duration);
protected:
protected:
void Update(Duration dt) override;
virtual void Init(
StagePtr prev,
StagePtr next
) override;
};
virtual void Init(StagePtr prev, StagePtr next) override;
};
/**
/**
* \~chinese
* @brief 位移过渡动画
* @details 两场景以位移的方式切换
*/
class MoveTransition
: public Transition
{
public:
class MoveTransition : public Transition
{
public:
/**
* \~chinese
* @brief 位移方式
@ -223,59 +194,45 @@ namespace kiwano
* @param duration 动画时长
* @param type 位移方式
*/
explicit MoveTransition(
Duration duration,
Type type
);
explicit MoveTransition(Duration duration, Type type);
protected:
protected:
void Update(Duration dt) override;
virtual void Init(
StagePtr prev,
StagePtr next
) override;
virtual void Init(StagePtr prev, StagePtr next) override;
void Reset() override;
private:
private:
Type type_;
Point pos_delta_;
Point start_pos_;
};
};
/**
/**
* \~chinese
* @brief 旋转过渡动画
* @details 前一场景以旋转方式收缩至消失，后一场景以旋转方式扩大
*/
class RotationTransition
: public Transition
{
public:
class RotationTransition : public Transition
{
public:
/**
* \~chinese
* @brief 构建旋转过渡动画
* @param duration 动画时长
* @param rotation 旋转度数
*/
explicit RotationTransition(
Duration duration,
float rotation = 360
);
explicit RotationTransition(Duration duration, float rotation = 360);
protected:
protected:
void Update(Duration dt) override;
virtual void Init(
StagePtr prev,
StagePtr next
) override;
virtual void Init(StagePtr prev, StagePtr next) override;
void Reset() override;
private:
private:
float rotation_;
};
}
};
} // namespace kiwano

45
src/kiwano/2d/action/Action.cpp
View File

@ -18,35 +18,31 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include <kiwano/2d/action/Action.h>
#include <kiwano/2d/Actor.h>
#include <kiwano/2d/action/Action.h>
namespace kiwano
{
Action::Action()
Action::Action()
: running_(true)
, detach_target_(false)
, loops_done_(0)
, loops_(0)
, status_(Status::NotStarted)
{
}
{
}
Action::~Action()
{
}
Action::~Action() {}
void Action::Init(Actor* target)
{
}
void Action::Init(Actor* target) {}
void Action::Update(Actor* target, Duration dt)
{
void Action::Update(Actor* target, Duration dt)
{
Complete(target);
}
}
void Action::UpdateStep(Actor* target, Duration dt)
{
void Action::UpdateStep(Actor* target, Duration dt)
{
KGE_ASSERT(target != nullptr && "Action target should NOT be nullptr!");
elapsed_ += dt;
@ -81,15 +77,14 @@ namespace kiwano
status_ = Status::Removeable;
}
}
}
void Action::Complete(Actor* target)
{
void Action::Complete(Actor* target)
{
if (cb_loop_done_)
cb_loop_done_(target);
if (loops_ >= 0
&& loops_done_ >= loops_)
if (loops_ >= 0 && loops_done_ >= loops_)
{
Done();
}
@ -99,15 +94,15 @@ namespace kiwano
}
++loops_done_;
}
}
void Action::Restart(Actor* target)
{
void Action::Restart(Actor* target)
{
status_ = Status::NotStarted;
elapsed_ = 0;
loops_done_ = 0;
Init(target);
}
}
} // namespace kiwano

219
src/kiwano/2d/action/Action.h
View File

@ -20,39 +20,39 @@
#pragma once
#include <kiwano/core/Common.h>
#include <kiwano/core/Time.h>
#include <kiwano/core/SmartPtr.hpp>
#include <kiwano/core/ObjectBase.h>
#include <kiwano/core/SmartPtr.hpp>
#include <kiwano/core/Time.h>
#include <kiwano/math/math.h>
namespace kiwano
{
class Actor;
class ActionManager;
class Actor;
class ActionManager;
KGE_DECLARE_SMART_PTR(Action);
KGE_DECLARE_SMART_PTR(Action);
/**
/**
* \~chinese
* \defgroup Actions 动画
*/
/**
/**
* \addtogroup Actions
* @{
*/
/// \~chinese
/// @brief ¶¯»­
class KGE_API Action
/// \~chinese
/// @brief ¶¯»­
class KGE_API Action
: public virtual ObjectBase
, protected IntrusiveListItem<ActionPtr>
{
{
friend class ActionManager;
friend class ActionGroup;
friend IntrusiveList<ActionPtr>;
public:
public:
/// \~chinese
/// @brief 动画结束时的回调函数
using DoneCallback = Function<void(Actor* /* target */)>;
@ -122,7 +122,7 @@ namespace kiwano
/// @brief 获取动画循环结束时的回调函数
DoneCallback GetLoopDoneCallback() const;
protected:
protected:
/// \~chinese
/// @brief 初始化动画
virtual void Init(Actor* target);
@ -178,7 +178,7 @@ namespace kiwano
/// @brief 是否可移除
bool IsRemoveable() const;
private:
private:
Status status_;
bool running_;
bool detach_target_;
@ -188,103 +188,102 @@ namespace kiwano
Duration elapsed_;
DoneCallback cb_done_;
DoneCallback cb_loop_done_;
};
};
/** @} */
/** @} */
inline void Action::Resume()
{
inline void Action::Resume()
{
running_ = true;
}
inline void Action::Pause()
{
running_ = false;
}
inline void Action::Stop()
{
Done();
}
inline void Action::SetDelay(Duration delay)
{
delay_ = delay;
}
inline void Action::SetLoops(int loops)
{
loops_ = loops;
}
inline void Action::RemoveTargetWhenDone()
{
detach_target_ = true;
}
inline void Action::SetDoneCallback(DoneCallback const& cb)
{
cb_done_ = cb;
}
inline void Action::SetLoopDoneCallback(DoneCallback const& cb)
{
cb_loop_done_ = cb;
}
inline void Action::Done()
{
status_ = Status::Done;
}
inline Action::Status Action::GetStatus() const
{
return status_;
}
inline bool Action::IsRunning() const
{
return running_;
}
inline bool Action::IsDone() const
{
return status_ == Status::Done || status_ == Status::Removeable;
}
inline bool Action::IsRemoveable() const
{
return status_ == Status::Removeable;
}
inline int Action::GetLoops() const
{
return loops_;
}
inline Duration Action::GetDelay() const
{
return delay_;
}
inline Duration Action::GetElapsed() const
{
return elapsed_;
}
inline int Action::GetLoopsDone() const
{
return loops_done_;
}
inline Action::DoneCallback Action::GetDoneCallback() const
{
return cb_done_;
}
inline Action::DoneCallback Action::GetLoopDoneCallback() const
{
return cb_loop_done_;
}
}
inline void Action::Pause()
{
running_ = false;
}
inline void Action::Stop()
{
Done();
}
inline void Action::SetDelay(Duration delay)
{
delay_ = delay;
}
inline void Action::SetLoops(int loops)
{
loops_ = loops;
}
inline void Action::RemoveTargetWhenDone()
{
detach_target_ = true;
}
inline void Action::SetDoneCallback(DoneCallback const& cb)
{
cb_done_ = cb;
}
inline void Action::SetLoopDoneCallback(DoneCallback const& cb)
{
cb_loop_done_ = cb;
}
inline void Action::Done()
{
status_ = Status::Done;
}
inline Action::Status Action::GetStatus() const
{
return status_;
}
inline bool Action::IsRunning() const
{
return running_;
}
inline bool Action::IsDone() const
{
return status_ == Status::Done || status_ == Status::Removeable;
}
inline bool Action::IsRemoveable() const
{
return status_ == Status::Removeable;
}
inline int Action::GetLoops() const
{
return loops_;
}
inline Duration Action::GetDelay() const
{
return delay_;
}
inline Duration Action::GetElapsed() const
{
return elapsed_;
}
inline int Action::GetLoopsDone() const
{
return loops_done_;
}
inline Action::DoneCallback Action::GetDoneCallback() const
{
return cb_done_;
}
inline Action::DoneCallback Action::GetLoopDoneCallback() const
{
return cb_loop_done_;
}
} // namespace kiwano

28
src/kiwano/2d/action/ActionDelay.cpp
View File

@ -22,19 +22,19 @@
namespace kiwano
{
ActionDelay::ActionDelay(Duration delay)
{
ActionDelay::ActionDelay(Duration delay)
{
SetDelay(delay);
}
ActionPtr ActionDelay::Clone() const
{
return new ActionDelay(GetDelay());
}
ActionPtr ActionDelay::Reverse() const
{
return new ActionDelay(GetDelay());
}
}
ActionPtr ActionDelay::Clone() const
{
return new ActionDelay(GetDelay());
}
ActionPtr ActionDelay::Reverse() const
{
return new ActionDelay(GetDelay());
}
} // namespace kiwano

23
src/kiwano/2d/action/ActionDelay.h
View File

@ -23,23 +23,20 @@
namespace kiwano
{
/**
/**
* \addtogroup Actions
* @{
*/
/// \~chinese
/// @brief 延时动画
class KGE_API ActionDelay
: public Action
{
public:
/// \~chinese
/// @brief 延时动画
class KGE_API ActionDelay : public Action
{
public:
/// \~chinese
/// @brief 构建延时动画
/// @param delay 延时时长
ActionDelay(
Duration delay
);
ActionDelay(Duration delay);
/// \~chinese
/// @brief 获取该动画的拷贝对象
@ -48,7 +45,7 @@ namespace kiwano
/// \~chinese
/// @brief 获取该动画的倒转
ActionPtr Reverse() const override;
};
};
/** @} */
}
/** @} */
} // namespace kiwano

62
src/kiwano/2d/action/ActionGroup.cpp
View File

@ -18,33 +18,31 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include <kiwano/2d/action/ActionGroup.h>
#include <kiwano/2d/Actor.h>
#include <kiwano/2d/action/ActionGroup.h>
#include <kiwano/core/Logger.h>
namespace kiwano
{
//-------------------------------------------------------
// ActionGroup
//-------------------------------------------------------
//-------------------------------------------------------
// ActionGroup
//-------------------------------------------------------
ActionGroup::ActionGroup()
ActionGroup::ActionGroup()
: sequence_(true)
{
}
{
}
ActionGroup::ActionGroup(Vector<ActionPtr> const& actions, bool sequence)
ActionGroup::ActionGroup(Vector<ActionPtr> const& actions, bool sequence)
: sequence_(sequence)
{
{
this->Add(actions);
}
}
ActionGroup::~ActionGroup()
{
}
ActionGroup::~ActionGroup() {}
void ActionGroup::Init(Actor* target)
{
void ActionGroup::Init(Actor* target)
{
if (actions_.empty())
{
Done();
@ -62,10 +60,10 @@ namespace kiwano
current_->Restart(target);
}
}
}
}
void ActionGroup::Update(Actor* target, Duration dt)
{
void ActionGroup::Update(Actor* target, Duration dt)
{
if (sequence_)
{
if (current_)
@ -100,24 +98,24 @@ namespace kiwano
Complete(target);
}
}
}
}
void ActionGroup::Add(ActionPtr action)
{
void ActionGroup::Add(ActionPtr action)
{
if (action)
{
actions_.push_back(action);
}
}
}
void ActionGroup::Add(Vector<ActionPtr> const& actions)
{
void ActionGroup::Add(Vector<ActionPtr> const& actions)
{
for (const auto& action : actions)
Add(action);
}
}
ActionPtr ActionGroup::Clone() const
{
ActionPtr ActionGroup::Clone() const
{
auto group = new (std::nothrow) ActionGroup();
if (group)
{
@ -130,10 +128,10 @@ namespace kiwano
}
}
return group;
}
}
ActionPtr ActionGroup::Reverse() const
{
ActionPtr ActionGroup::Reverse() const
{
auto group = new (std::nothrow) ActionGroup();
if (group && !actions_.empty())
{
@ -143,6 +141,6 @@ namespace kiwano
}
}
return group;
}
}
} // namespace kiwano

30
src/kiwano/2d/action/ActionGroup.h
View File

@ -23,19 +23,18 @@
namespace kiwano
{
KGE_DECLARE_SMART_PTR(ActionGroup);
KGE_DECLARE_SMART_PTR(ActionGroup);
/**
/**
* \addtogroup Actions
* @{
*/
/// \~chinese
/// @brief 动画组合
class KGE_API ActionGroup
: public Action
{
public:
/// \~chinese
/// @brief 动画组合
class KGE_API ActionGroup : public Action
{
public:
using ActionList = IntrusiveList<ActionPtr>;
ActionGroup();
@ -70,19 +69,22 @@ namespace kiwano
/// @brief 获取该动画的倒转
ActionPtr Reverse() const override;
protected:
protected:
void Init(Actor* target) override;
void Update(Actor* target, Duration dt) override;
private:
private:
bool sequence_;
ActionPtr current_;
ActionList actions_;
};
};
/** @} */
inline ActionGroup::ActionList const& ActionGroup::GetActions() const { return actions_; }
/** @} */
inline ActionGroup::ActionList const& ActionGroup::GetActions() const
{
return actions_;
}
} // namespace kiwano

235
src/kiwano/2d/action/ActionHelper.h
View File

@ -19,124 +19,200 @@
// THE SOFTWARE.
#pragma once
#include <kiwano/2d/action/ActionTween.h>
#include <kiwano/2d/action/ActionWalk.h>
#include <kiwano/2d/action/ActionDelay.h>
#include <kiwano/2d/action/ActionGroup.h>
#include <kiwano/2d/action/ActionTween.h>
#include <kiwano/2d/action/ActionWalk.h>
#include <kiwano/2d/action/Animation.h>
namespace kiwano
{
/**
/**
* \addtogroup Actions
* @{
*/
/// \~chinese
/// @brief 动画辅助类
struct ActionHelper
{
/// \~chinese
/// @brief 动画辅助类
struct ActionHelper
{
using DoneCallback = Action::DoneCallback;
/// \~chinese
/// @brief 设置循环次数
inline ActionHelper& SetLoops(int loops) { core->SetLoops(loops); return (*this); }
inline ActionHelper& SetLoops(int loops)
{
core->SetLoops(loops);
return (*this);
}
/// \~chinese
/// @brief 设置动画延迟
inline ActionHelper& SetDelay(Duration delay) { core->SetDelay(delay); return (*this); }
inline ActionHelper& SetDelay(Duration delay)
{
core->SetDelay(delay);
return (*this);
}
/// \~chinese
/// @brief 设置动画结束回调函数
inline ActionHelper& SetDoneCallback(DoneCallback const& cb) { core->SetDoneCallback(cb); return (*this); }
inline ActionHelper& SetDoneCallback(DoneCallback const& cb)
{
core->SetDoneCallback(cb);
return (*this);
}
/// \~chinese
/// @brief 设置动画循环结束时的回调函数
inline ActionHelper& SetLoopDoneCallback(DoneCallback const& cb) { core->SetLoopDoneCallback(cb); return (*this); }
inline ActionHelper& SetLoopDoneCallback(DoneCallback const& cb)
{
core->SetLoopDoneCallback(cb);
return (*this);
}
/// \~chinese
/// @brief 动画结束时移除目标角色
inline ActionHelper& RemoveTargetWhenDone() { core->RemoveTargetWhenDone(); return (*this); }
inline ActionHelper& RemoveTargetWhenDone()
{
core->RemoveTargetWhenDone();
return (*this);
}
/// \~chinese
/// @brief 设置名称
inline ActionHelper& SetName(String const& name) { core->SetName(name); return (*this); }
inline ActionHelper& SetName(String const& name)
{
core->SetName(name);
return (*this);
}
/// \~chinese
/// @brief 获取指针
inline ActionPtr Get() const { return core; }
inline ActionHelper(ActionPtr core) : core(core) {}
inline operator ActionPtr() const { return core; }
private:
ActionPtr core;
};
/// \~chinese
/// @brief 补间动画辅助类
struct TweenHelper
inline ActionPtr Get() const
{
return core;
}
inline ActionHelper(ActionPtr core)
: core(core)
{
}
inline operator ActionPtr() const
{
return core;
}
private:
ActionPtr core;
};
/// \~chinese
/// @brief 补间动画辅助类
struct TweenHelper
{
using DoneCallback = Action::DoneCallback;
/// \~chinese
/// @brief 设置动画持续时长
inline TweenHelper& SetDuration(Duration dur) { core->SetDuration(dur); return (*this); }
inline TweenHelper& SetDuration(Duration dur)
{
core->SetDuration(dur);
return (*this);
}
/// \~chinese
/// @brief 设置循环次数
inline TweenHelper& SetLoops(int loops) { core->SetLoops(loops); return (*this); }
inline TweenHelper& SetLoops(int loops)
{
core->SetLoops(loops);
return (*this);
}
/// \~chinese
/// @brief 设置缓动函数
inline TweenHelper& SetEaseFunc(EaseFunc ease) { core->SetEaseFunc(ease); return (*this); }
inline TweenHelper& SetEaseFunc(EaseFunc ease)
{
core->SetEaseFunc(ease);
return (*this);
}
/// \~chinese
/// @brief 设置动画延迟
inline TweenHelper& SetDelay(Duration delay) { core->SetDelay(delay); return (*this); }
inline TweenHelper& SetDelay(Duration delay)
{
core->SetDelay(delay);
return (*this);
}
/// \~chinese
/// @brief 设置动画结束回调函数
inline TweenHelper& SetDoneCallback(DoneCallback const& cb) { core->SetDoneCallback(cb); return (*this); }
inline TweenHelper& SetDoneCallback(DoneCallback const& cb)
{
core->SetDoneCallback(cb);
return (*this);
}
/// \~chinese
/// @brief 设置动画循环结束时的回调函数
inline TweenHelper& SetLoopDoneCallback(DoneCallback const& cb) { core->SetLoopDoneCallback(cb); return (*this); }
inline TweenHelper& SetLoopDoneCallback(DoneCallback const& cb)
{
core->SetLoopDoneCallback(cb);
return (*this);
}
/// \~chinese
/// @brief 动画结束时移除目标角色
inline TweenHelper& RemoveTargetWhenDone() { core->RemoveTargetWhenDone(); return (*this); }
inline TweenHelper& RemoveTargetWhenDone()
{
core->RemoveTargetWhenDone();
return (*this);
}
/// \~chinese
/// @brief 设置名称
inline TweenHelper& SetName(String const& name) { core->SetName(name); return (*this); }
inline TweenHelper& SetName(String const& name)
{
core->SetName(name);
return (*this);
}
/// \~chinese
/// @brief 获取指针
inline ActionTweenPtr Get() const { return core; }
inline TweenHelper(ActionTweenPtr core) : core(core) {}
inline operator ActionPtr() const { return core; }
inline operator ActionTweenPtr() const { return core; }
private:
ActionTweenPtr core;
};
/// \~chinese
/// @brief 动画构造器
struct Tween
inline ActionTweenPtr Get() const
{
public:
return core;
}
inline TweenHelper(ActionTweenPtr core)
: core(core)
{
}
inline operator ActionPtr() const
{
return core;
}
inline operator ActionTweenPtr() const
{
return core;
}
private:
ActionTweenPtr core;
};
/// \~chinese
/// @brief 动画构造器
struct Tween
{
public:
/// \~chinese
/// @brief 构造相对位移动画
/// @param duration 动画时长
/// @param vector 移动向量
static inline TweenHelper
MoveBy(Duration dur, Point const& vector)
static inline TweenHelper MoveBy(Duration dur, Point const& vector)
{
return TweenHelper(new kiwano::ActionMoveBy(dur, vector));
}
@ -145,8 +221,7 @@ namespace kiwano
/// @brief 构造位移动画
/// @param duration 动画时长
/// @param pos 目的坐标
static inline TweenHelper
MoveTo(Duration dur, Point const& pos)
static inline TweenHelper MoveTo(Duration dur, Point const& pos)
{
return TweenHelper(new kiwano::ActionMoveTo(dur, pos));
}
@ -157,8 +232,7 @@ namespace kiwano
/// @param vec 跳跃位移向量
/// @param height 跳跃高度
/// @param jumps 跳跃次数
static inline TweenHelper
JumpBy(Duration duration, Vec2 const& vec, float height, int jumps = 1)
static inline TweenHelper JumpBy(Duration duration, Vec2 const& vec, float height, int jumps = 1)
{
return TweenHelper(new kiwano::ActionJumpBy(duration, vec, height, jumps));
}
@ -169,8 +243,7 @@ namespace kiwano
/// @param pos 目的坐标
/// @param height 跳跃高度
/// @param jumps 跳跃次数
static inline TweenHelper
JumpTo(Duration duration, Point const& pos, float height, int jumps = 1)
static inline TweenHelper JumpTo(Duration duration, Point const& pos, float height, int jumps = 1)
{
return TweenHelper(new kiwano::ActionJumpTo(duration, pos, height, jumps));
}
@ -180,8 +253,7 @@ namespace kiwano
/// @param duration 动画时长
/// @param scale_x 横向缩放相对变化值
/// @param scale_y 纵向缩放相对变化值
static inline TweenHelper
ScaleBy(Duration dur, float scale_x, float scale_y)
static inline TweenHelper ScaleBy(Duration dur, float scale_x, float scale_y)
{
return TweenHelper(new kiwano::ActionScaleBy(dur, scale_x, scale_y));
}
@ -191,8 +263,7 @@ namespace kiwano
/// @param duration 动画时长
/// @param scale_x 横向缩放目标值
/// @param scale_y 纵向缩放目标值
static inline TweenHelper
ScaleTo(Duration dur, float scale_x, float scale_y)
static inline TweenHelper ScaleTo(Duration dur, float scale_x, float scale_y)
{
return TweenHelper(new kiwano::ActionScaleTo(dur, scale_x, scale_y));
}
@ -201,8 +272,7 @@ namespace kiwano
/// @brief 构造透明度渐变动画
/// @param duration 动画时长
/// @param opacity 目标透明度
static inline TweenHelper
FadeTo(Duration dur, float opacity)
static inline TweenHelper FadeTo(Duration dur, float opacity)
{
return TweenHelper(new kiwano::ActionFadeTo(dur, opacity));
}
@ -210,8 +280,7 @@ namespace kiwano
/// \~chinese
/// @brief 构造淡入动画
/// @param duration 动画时长
static inline TweenHelper
FadeIn(Duration dur)
static inline TweenHelper FadeIn(Duration dur)
{
return TweenHelper(new kiwano::ActionFadeIn(dur));
}
@ -219,8 +288,7 @@ namespace kiwano
/// \~chinese
/// @brief 构造淡出动画
/// @param duration 动画时长
static inline TweenHelper
FadeOut(Duration dur)
static inline TweenHelper FadeOut(Duration dur)
{
return TweenHelper(new kiwano::ActionFadeOut(dur));
}
@ -229,8 +297,7 @@ namespace kiwano
/// @brief 构造相对旋转动画
/// @param duration 动画时长
/// @param rotation 角度相对变化值
static inline TweenHelper
RotateBy(Duration dur, float rotation)
static inline TweenHelper RotateBy(Duration dur, float rotation)
{
return TweenHelper(new kiwano::ActionRotateBy(dur, rotation));
}
@ -239,8 +306,7 @@ namespace kiwano
/// @brief 构造旋转动画
/// @param duration 动画时长
/// @param rotation 目标角度
static inline TweenHelper
RotateTo(Duration dur, float rotation)
static inline TweenHelper RotateTo(Duration dur, float rotation)
{
return TweenHelper(new kiwano::ActionRotateTo(dur, rotation));
}
@ -252,8 +318,8 @@ namespace kiwano
/// @param rotating 是否沿路径切线方向旋转
/// @param start 路径起点（百分比）
/// @param end 路径终点（百分比）
static inline TweenHelper
Walk(Duration duration, Geometry const& path, bool rotating = false, float start = 0.f, float end = 1.f)
static inline TweenHelper Walk(Duration duration, Geometry const& path, bool rotating = false, float start = 0.f,
float end = 1.f)
{
return TweenHelper(new kiwano::ActionWalk(duration, path, rotating, start, end));
}
@ -262,8 +328,7 @@ namespace kiwano
/// @brief 构建帧动画
/// @param duration 动画时长
/// @param[in] frame_seq 序列帧
static inline TweenHelper
Animation(Duration dur, FrameSequencePtr frames)
static inline TweenHelper Animation(Duration dur, FrameSequencePtr frames)
{
return TweenHelper(new kiwano::Animation(dur, frames));
}
@ -272,8 +337,7 @@ namespace kiwano
/// @brief 构造自定义动画
/// @param duration 动画时长
/// @param tween_func 动画回调函数
static inline TweenHelper
Custom(Duration dur, ActionCustom::TweenFunc tween_func)
static inline TweenHelper Custom(Duration dur, ActionCustom::TweenFunc tween_func)
{
return TweenHelper(new kiwano::ActionCustom(dur, tween_func));
}
@ -281,8 +345,7 @@ namespace kiwano
/// \~chinese
/// @brief 构建延时动画
/// @param delay 延时时长
static inline ActionHelper
Delay(Duration delay)
static inline ActionHelper Delay(Duration delay)
{
return ActionHelper(new kiwano::ActionDelay(delay));
}
@ -291,8 +354,7 @@ namespace kiwano
/// @brief 动画组合
/// @param actions 动画集合
/// @param sequence 动画按顺序依次执行或同时执行
static inline ActionHelper
Group(Vector<ActionPtr> const& actions, bool sequence = true)
static inline ActionHelper Group(Vector<ActionPtr> const& actions, bool sequence = true)
{
return ActionHelper(new kiwano::ActionGroup(actions, sequence));
}
@ -300,12 +362,11 @@ namespace kiwano
/// \~chinese
/// @brief 同步动画组合
/// @param actions 动画集合
static inline ActionHelper
Multiple(Vector<ActionPtr> const& actions)
static inline ActionHelper Multiple(Vector<ActionPtr> const& actions)
{
return ActionHelper(new kiwano::ActionGroup(actions, false));
}
};
};
/** @} */
}
/** @} */
} // namespace kiwano

54
src/kiwano/2d/action/ActionManager.cpp
View File

@ -18,14 +18,14 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include <kiwano/2d/action/ActionManager.h>
#include <kiwano/2d/Actor.h>
#include <kiwano/2d/action/ActionManager.h>
#include <kiwano/core/Logger.h>
namespace kiwano
{
void ActionManager::UpdateActions(Actor* target, Duration dt)
{
void ActionManager::UpdateActions(Actor* target, Duration dt)
{
if (actions_.empty() || !target)
return;
@ -40,15 +40,15 @@ namespace kiwano
if (action->IsRemoveable())
actions_.remove(action);
}
}
}
Action* ActionManager::AddAction(ActionPtr action)
{
Action* ActionManager::AddAction(ActionPtr action)
{
return AddAction(action.get());
}
}
Action* ActionManager::AddAction(Action* action)
{
Action* ActionManager::AddAction(Action* action)
{
KGE_ASSERT(action && "AddAction failed, NULL pointer exception");
if (action)
@ -56,10 +56,10 @@ namespace kiwano
actions_.push_back(action);
}
return action;
}
}
void ActionManager::ResumeAllActions()
{
void ActionManager::ResumeAllActions()
{
if (actions_.empty())
return;
@ -67,10 +67,10 @@ namespace kiwano
{
action.Resume();
}
}
}
void ActionManager::PauseAllActions()
{
void ActionManager::PauseAllActions()
{
if (actions_.empty())
return;
@ -78,10 +78,10 @@ namespace kiwano
{
action.Pause();
}
}
}
void ActionManager::StopAllActions()
{
void ActionManager::StopAllActions()
{
if (actions_.empty())
return;
@ -89,10 +89,10 @@ namespace kiwano
{
action.Stop();
}
}
}
ActionPtr ActionManager::GetAction(String const& name)
{
ActionPtr ActionManager::GetAction(String const& name)
{
if (actions_.empty())
return nullptr;
@ -101,10 +101,10 @@ namespace kiwano
return &action;
return nullptr;
}
const ActionManager::Actions& ActionManager::GetAllActions() const
{
return actions_;
}
}
const ActionManager::Actions& ActionManager::GetAllActions() const
{
return actions_;
}
} // namespace kiwano

20
src/kiwano/2d/action/ActionManager.h
View File

@ -23,18 +23,18 @@
namespace kiwano
{
/**
/**
* \addtogroup Actions
* @{
*/
/**
/**
* \~chinese
* @brief 动画管理器
*/
class KGE_API ActionManager
{
public:
class KGE_API ActionManager
{
public:
/// \~chinese
/// @brief 动画列表
using Actions = IntrusiveList<ActionPtr>;
@ -68,14 +68,14 @@ namespace kiwano
/// @brief 获取所有动画
Actions const& GetAllActions() const;
protected:
protected:
/// \~chinese
/// @brief 更新动画
void UpdateActions(Actor* target, Duration dt);
private:
private:
Actions actions_;
};
};
/** @} */
}
/** @} */
} // namespace kiwano

444
src/kiwano/2d/action/ActionTween.cpp
View File

@ -19,87 +19,105 @@
// THE SOFTWARE.
#include <functional>
#include <kiwano/2d/action/ActionTween.h>
#include <kiwano/2d/Actor.h>
#include <kiwano/2d/action/ActionTween.h>
namespace kiwano
{
//-------------------------------------------------------
// Ease Functions
//-------------------------------------------------------
//-------------------------------------------------------
// Ease Functions
//-------------------------------------------------------
inline EaseFunc MakeEaseIn(float rate) { return std::bind(math::EaseIn, std::placeholders::_1, rate); }
inline EaseFunc MakeEaseOut(float rate) { return std::bind(math::EaseOut, std::placeholders::_1, rate); }
inline EaseFunc MakeEaseInOut(float rate) { return std::bind(math::EaseInOut, std::placeholders::_1, rate); }
inline EaseFunc MakeEaseElasticIn(float period) { return std::bind(math::EaseElasticIn, std::placeholders::_1, period); }
inline EaseFunc MakeEaseElasticOut(float period) { return std::bind(math::EaseElasticOut, std::placeholders::_1, period); }
inline EaseFunc MakeEaseElasticInOut(float period) { return std::bind(math::EaseElasticInOut, std::placeholders::_1, period); }
inline EaseFunc MakeEaseIn(float rate)
{
return std::bind(math::EaseIn, std::placeholders::_1, rate);
}
inline EaseFunc MakeEaseOut(float rate)
{
return std::bind(math::EaseOut, std::placeholders::_1, rate);
}
inline EaseFunc MakeEaseInOut(float rate)
{
return std::bind(math::EaseInOut, std::placeholders::_1, rate);
}
inline EaseFunc MakeEaseElasticIn(float period)
{
return std::bind(math::EaseElasticIn, std::placeholders::_1, period);
}
inline EaseFunc MakeEaseElasticOut(float period)
{
return std::bind(math::EaseElasticOut, std::placeholders::_1, period);
}
inline EaseFunc MakeEaseElasticInOut(float period)
{
return std::bind(math::EaseElasticInOut, std::placeholders::_1, period);
}
KGE_API EaseFunc Ease::Linear = math::Linear;
KGE_API EaseFunc Ease::EaseIn = MakeEaseIn(2.f);
KGE_API EaseFunc Ease::EaseOut = MakeEaseOut(2.f);
KGE_API EaseFunc Ease::EaseInOut = MakeEaseInOut(2.f);
KGE_API EaseFunc Ease::ExpoIn = math::EaseExponentialIn;
KGE_API EaseFunc Ease::ExpoOut = math::EaseExponentialOut;
KGE_API EaseFunc Ease::ExpoInOut = math::EaseExponentialInOut;
KGE_API EaseFunc Ease::BounceIn = math::EaseBounceIn;
KGE_API EaseFunc Ease::BounceOut = math::EaseBounceOut;
KGE_API EaseFunc Ease::BounceInOut = math::EaseBounceInOut;
KGE_API EaseFunc Ease::ElasticIn = MakeEaseElasticIn(0.3f);
KGE_API EaseFunc Ease::ElasticOut = MakeEaseElasticOut(0.3f);
KGE_API EaseFunc Ease::ElasticInOut = MakeEaseElasticInOut(0.3f);
KGE_API EaseFunc Ease::SineIn = math::EaseSineIn;
KGE_API EaseFunc Ease::SineOut = math::EaseSineOut;
KGE_API EaseFunc Ease::SineInOut = math::EaseSineInOut;
KGE_API EaseFunc Ease::BackIn = math::EaseBackIn;
KGE_API EaseFunc Ease::BackOut = math::EaseBackOut;
KGE_API EaseFunc Ease::BackInOut = math::EaseBackInOut;
KGE_API EaseFunc Ease::QuadIn = math::EaseQuadIn;
KGE_API EaseFunc Ease::QuadOut = math::EaseQuadOut;
KGE_API EaseFunc Ease::QuadInOut = math::EaseQuadInOut;
KGE_API EaseFunc Ease::CubicIn = math::EaseCubicIn;
KGE_API EaseFunc Ease::CubicOut = math::EaseCubicOut;
KGE_API EaseFunc Ease::CubicInOut = math::EaseCubicInOut;
KGE_API EaseFunc Ease::QuartIn = math::EaseQuartIn;
KGE_API EaseFunc Ease::QuartOut = math::EaseQuartOut;
KGE_API EaseFunc Ease::QuartInOut = math::EaseQuartInOut;
KGE_API EaseFunc Ease::QuintIn = math::EaseQuintIn;
KGE_API EaseFunc Ease::QuintOut = math::EaseQuintOut;
KGE_API EaseFunc Ease::QuintInOut = math::EaseQuintInOut;
KGE_API EaseFunc Ease::Linear = math::Linear;
KGE_API EaseFunc Ease::EaseIn = MakeEaseIn(2.f);
KGE_API EaseFunc Ease::EaseOut = MakeEaseOut(2.f);
KGE_API EaseFunc Ease::EaseInOut = MakeEaseInOut(2.f);
KGE_API EaseFunc Ease::ExpoIn = math::EaseExponentialIn;
KGE_API EaseFunc Ease::ExpoOut = math::EaseExponentialOut;
KGE_API EaseFunc Ease::ExpoInOut = math::EaseExponentialInOut;
KGE_API EaseFunc Ease::BounceIn = math::EaseBounceIn;
KGE_API EaseFunc Ease::BounceOut = math::EaseBounceOut;
KGE_API EaseFunc Ease::BounceInOut = math::EaseBounceInOut;
KGE_API EaseFunc Ease::ElasticIn = MakeEaseElasticIn(0.3f);
KGE_API EaseFunc Ease::ElasticOut = MakeEaseElasticOut(0.3f);
KGE_API EaseFunc Ease::ElasticInOut = MakeEaseElasticInOut(0.3f);
KGE_API EaseFunc Ease::SineIn = math::EaseSineIn;
KGE_API EaseFunc Ease::SineOut = math::EaseSineOut;
KGE_API EaseFunc Ease::SineInOut = math::EaseSineInOut;
KGE_API EaseFunc Ease::BackIn = math::EaseBackIn;
KGE_API EaseFunc Ease::BackOut = math::EaseBackOut;
KGE_API EaseFunc Ease::BackInOut = math::EaseBackInOut;
KGE_API EaseFunc Ease::QuadIn = math::EaseQuadIn;
KGE_API EaseFunc Ease::QuadOut = math::EaseQuadOut;
KGE_API EaseFunc Ease::QuadInOut = math::EaseQuadInOut;
KGE_API EaseFunc Ease::CubicIn = math::EaseCubicIn;
KGE_API EaseFunc Ease::CubicOut = math::EaseCubicOut;
KGE_API EaseFunc Ease::CubicInOut = math::EaseCubicInOut;
KGE_API EaseFunc Ease::QuartIn = math::EaseQuartIn;
KGE_API EaseFunc Ease::QuartOut = math::EaseQuartOut;
KGE_API EaseFunc Ease::QuartInOut = math::EaseQuartInOut;
KGE_API EaseFunc Ease::QuintIn = math::EaseQuintIn;
KGE_API EaseFunc Ease::QuintOut = math::EaseQuintOut;
KGE_API EaseFunc Ease::QuintInOut = math::EaseQuintInOut;
//-------------------------------------------------------
// ActionTween
//-------------------------------------------------------
//-------------------------------------------------------
// ActionTween
//-------------------------------------------------------
ActionTween::ActionTween()
ActionTween::ActionTween()
: dur_()
, ease_func_(nullptr)
{
}
{
}
ActionTween::ActionTween(Duration duration, EaseFunc func)
{
ActionTween::ActionTween(Duration duration, EaseFunc func)
{
SetDuration(duration);
SetEaseFunc(func);
}
}
void ActionTween::SetEaseFunc(EaseFunc const& func)
{
void ActionTween::SetEaseFunc(EaseFunc const& func)
{
ease_func_ = func;
}
}
EaseFunc const & ActionTween::GetEaseFunc() const
{
EaseFunc const& ActionTween::GetEaseFunc() const
{
return ease_func_;
}
}
Duration ActionTween::GetDuration() const
{
Duration ActionTween::GetDuration() const
{
return dur_;
}
}
void ActionTween::Update(Actor* target, Duration dt)
{
void ActionTween::Update(Actor* target, Duration dt)
{
float percent;
if (dur_.IsZero())
@ -124,34 +142,33 @@ namespace kiwano
percent = ease_func_(percent);
UpdateTween(target, percent);
}
}
void ActionTween::SetDuration(Duration duration)
{
void ActionTween::SetDuration(Duration duration)
{
dur_ = duration;
}
}
//-------------------------------------------------------
// Move Action
//-------------------------------------------------------
//-------------------------------------------------------
// Move Action
//-------------------------------------------------------
ActionMoveBy::ActionMoveBy(Duration duration, Vec2 const& vector, EaseFunc func)
ActionMoveBy::ActionMoveBy(Duration duration, Vec2 const& vector, EaseFunc func)
: ActionTween(duration, func)
{
{
delta_pos_ = vector;
}
}
void ActionMoveBy::Init(Actor* target)
{
void ActionMoveBy::Init(Actor* target)
{
if (target)
{
prev_pos_ = start_pos_ = target->GetPosition();
}
}
}
void ActionMoveBy::UpdateTween(Actor* target, float percent)
{
void ActionMoveBy::UpdateTween(Actor* target, float percent)
{
Point diff = target->GetPosition() - prev_pos_;
start_pos_ = start_pos_ + diff;
@ -159,68 +176,67 @@ namespace kiwano
target->SetPosition(new_pos);
prev_pos_ = new_pos;
}
}
ActionPtr ActionMoveBy::Clone() const
{
ActionPtr ActionMoveBy::Clone() const
{
return new (std::nothrow) ActionMoveBy(GetDuration(), delta_pos_, GetEaseFunc());
}
}
ActionPtr ActionMoveBy::Reverse() const
{
ActionPtr ActionMoveBy::Reverse() const
{
return new (std::nothrow) ActionMoveBy(GetDuration(), -delta_pos_, GetEaseFunc());
}
}
ActionMoveTo::ActionMoveTo(Duration duration, Point const& pos, EaseFunc func)
ActionMoveTo::ActionMoveTo(Duration duration, Point const& pos, EaseFunc func)
: ActionMoveBy(duration, Point(), func)
{
{
end_pos_ = pos;
}
}
ActionPtr ActionMoveTo::Clone() const
{
ActionPtr ActionMoveTo::Clone() const
{
return new (std::nothrow) ActionMoveTo(GetDuration(), end_pos_, GetEaseFunc());
}
}
void ActionMoveTo::Init(Actor* target)
{
void ActionMoveTo::Init(Actor* target)
{
ActionMoveBy::Init(target);
delta_pos_ = end_pos_ - start_pos_;
}
}
//-------------------------------------------------------
// Jump Action
//-------------------------------------------------------
//-------------------------------------------------------
// Jump Action
//-------------------------------------------------------
ActionJumpBy::ActionJumpBy(Duration duration, Vec2 const& vec, float height, int jumps, EaseFunc func)
ActionJumpBy::ActionJumpBy(Duration duration, Vec2 const& vec, float height, int jumps, EaseFunc func)
: ActionTween(duration, func)
, delta_pos_(vec)
, height_(height)
, jumps_(jumps)
{
}
{
}
ActionPtr ActionJumpBy::Clone() const
{
ActionPtr ActionJumpBy::Clone() const
{
return new (std::nothrow) ActionJumpBy(GetDuration(), delta_pos_, height_, jumps_, GetEaseFunc());
}
}
ActionPtr ActionJumpBy::Reverse() const
{
ActionPtr ActionJumpBy::Reverse() const
{
return new (std::nothrow) ActionJumpBy(GetDuration(), -delta_pos_, height_, jumps_, GetEaseFunc());
}
}
void ActionJumpBy::Init(Actor* target)
{
void ActionJumpBy::Init(Actor* target)
{
if (target)
{
prev_pos_ = start_pos_ = target->GetPosition();
}
}
}
void ActionJumpBy::UpdateTween(Actor* target, float percent)
{
void ActionJumpBy::UpdateTween(Actor* target, float percent)
{
float frac = fmod(percent * jumps_, 1.f);
float x = delta_pos_.x * percent;
float y = height_ * 4 * frac * (1 - frac);
@ -233,206 +249,202 @@ namespace kiwano
target->SetPosition(new_pos);
prev_pos_ = new_pos;
}
}
ActionJumpTo::ActionJumpTo(Duration duration, Point const& pos, float height, int jumps, EaseFunc func)
ActionJumpTo::ActionJumpTo(Duration duration, Point const& pos, float height, int jumps, EaseFunc func)
: ActionJumpBy(duration, Point(), height, jumps, func)
, end_pos_(pos)
{
}
{
}
ActionPtr ActionJumpTo::Clone() const
{
ActionPtr ActionJumpTo::Clone() const
{
return new (std::nothrow) ActionJumpTo(GetDuration(), end_pos_, height_, jumps_, GetEaseFunc());
}
}
void ActionJumpTo::Init(Actor* target)
{
void ActionJumpTo::Init(Actor* target)
{
ActionJumpBy::Init(target);
delta_pos_ = end_pos_ - start_pos_;
}
}
//-------------------------------------------------------
// Scale Action
//-------------------------------------------------------
//-------------------------------------------------------
// Scale Action
//-------------------------------------------------------
ActionScaleBy::ActionScaleBy(Duration duration, float scale_x, float scale_y, EaseFunc func)
ActionScaleBy::ActionScaleBy(Duration duration, float scale_x, float scale_y, EaseFunc func)
: ActionTween(duration, func)
, delta_x_(scale_x)
, delta_y_(scale_y)
, start_scale_x_(0.f)
, start_scale_y_(0.f)
{
}
{
}
void ActionScaleBy::Init(Actor* target)
{
void ActionScaleBy::Init(Actor* target)
{
if (target)
{
start_scale_x_ = target->GetScaleX();
start_scale_y_ = target->GetScaleY();
}
}
}
void ActionScaleBy::UpdateTween(Actor* target, float percent)
{
void ActionScaleBy::UpdateTween(Actor* target, float percent)
{
target->SetScale(Vec2{ start_scale_x_ + delta_x_ * percent, start_scale_y_ + delta_y_ * percent });
}
}
ActionPtr ActionScaleBy::Clone() const
{
ActionPtr ActionScaleBy::Clone() const
{
return new (std::nothrow) ActionScaleBy(GetDuration(), delta_x_, delta_y_, GetEaseFunc());
}
}
ActionPtr ActionScaleBy::Reverse() const
{
ActionPtr ActionScaleBy::Reverse() const
{
return new (std::nothrow) ActionScaleBy(GetDuration(), -delta_x_, -delta_y_, GetEaseFunc());
}
}
ActionScaleTo::ActionScaleTo(Duration duration, float scale_x, float scale_y, EaseFunc func)
ActionScaleTo::ActionScaleTo(Duration duration, float scale_x, float scale_y, EaseFunc func)
: ActionScaleBy(duration, 0, 0, func)
{
{
end_scale_x_ = scale_x;
end_scale_y_ = scale_y;
}
}
ActionPtr ActionScaleTo::Clone() const
{
ActionPtr ActionScaleTo::Clone() const
{
return new (std::nothrow) ActionScaleTo(GetDuration(), end_scale_x_, end_scale_y_, GetEaseFunc());
}
}
void ActionScaleTo::Init(Actor* target)
{
void ActionScaleTo::Init(Actor* target)
{
ActionScaleBy::Init(target);
delta_x_ = end_scale_x_ - start_scale_x_;
delta_y_ = end_scale_y_ - start_scale_y_;
}
}
//-------------------------------------------------------
// Opacity Action
//-------------------------------------------------------
//-------------------------------------------------------
// Opacity Action
//-------------------------------------------------------
ActionFadeTo::ActionFadeTo(Duration duration, float opacity, EaseFunc func)
ActionFadeTo::ActionFadeTo(Duration duration, float opacity, EaseFunc func)
: ActionTween(duration, func)
, delta_val_(0.f)
, start_val_(0.f)
, end_val_(opacity)
{
}
{
}
void ActionFadeTo::Init(Actor* target)
{
void ActionFadeTo::Init(Actor* target)
{
if (target)
{
start_val_ = target->GetOpacity();
delta_val_ = end_val_ - start_val_;
}
}
}
void ActionFadeTo::UpdateTween(Actor* target, float percent)
{
void ActionFadeTo::UpdateTween(Actor* target, float percent)
{
target->SetOpacity(start_val_ + delta_val_ * percent);
}
}
ActionPtr ActionFadeTo::Clone() const
{
ActionPtr ActionFadeTo::Clone() const
{
return new (std::nothrow) ActionFadeTo(GetDuration(), end_val_, GetEaseFunc());
}
}
ActionFadeIn::ActionFadeIn(Duration duration, EaseFunc func)
ActionFadeIn::ActionFadeIn(Duration duration, EaseFunc func)
: ActionFadeTo(duration, 1, func)
{
}
{
}
ActionFadeOut::ActionFadeOut(Duration duration, EaseFunc func)
ActionFadeOut::ActionFadeOut(Duration duration, EaseFunc func)
: ActionFadeTo(duration, 0, func)
{
}
{
}
//-------------------------------------------------------
// Rotate Action
//-------------------------------------------------------
//-------------------------------------------------------
// Rotate Action
//-------------------------------------------------------
ActionRotateBy::ActionRotateBy(Duration duration, float rotation, EaseFunc func)
ActionRotateBy::ActionRotateBy(Duration duration, float rotation, EaseFunc func)
: ActionTween(duration, func)
, start_val_()
, delta_val_(rotation)
{
}
{
}
void ActionRotateBy::Init(Actor* target)
{
void ActionRotateBy::Init(Actor* target)
{
if (target)
{
start_val_ = target->GetRotation();
}
}
}
void ActionRotateBy::UpdateTween(Actor* target, float percent)
{
void ActionRotateBy::UpdateTween(Actor* target, float percent)
{
float rotation = start_val_ + delta_val_ * percent;
if (rotation > 360.f)
rotation -= 360.f;
target->SetRotation(rotation);
}
}
ActionPtr ActionRotateBy::Clone() const
{
ActionPtr ActionRotateBy::Clone() const
{
return new (std::nothrow) ActionRotateBy(GetDuration(), delta_val_, GetEaseFunc());
}
}
ActionPtr ActionRotateBy::Reverse() const
{
ActionPtr ActionRotateBy::Reverse() const
{
return new (std::nothrow) ActionRotateBy(GetDuration(), -delta_val_, GetEaseFunc());
}
}
ActionRotateTo::ActionRotateTo(Duration duration, float rotation, EaseFunc func)
ActionRotateTo::ActionRotateTo(Duration duration, float rotation, EaseFunc func)
: ActionRotateBy(duration, 0, func)
{
{
end_val_ = rotation;
}
}
ActionPtr ActionRotateTo::Clone() const
{
ActionPtr ActionRotateTo::Clone() const
{
return new (std::nothrow) ActionRotateTo(GetDuration(), end_val_, GetEaseFunc());
}
}
void ActionRotateTo::Init(Actor* target)
{
void ActionRotateTo::Init(Actor* target)
{
ActionRotateBy::Init(target);
delta_val_ = end_val_ - start_val_;
}
}
//-------------------------------------------------------
// ActionCustom
//-------------------------------------------------------
//-------------------------------------------------------
// ActionCustom
//-------------------------------------------------------
ActionCustom::ActionCustom(Duration duration, TweenFunc tween_func, EaseFunc func)
ActionCustom::ActionCustom(Duration duration, TweenFunc tween_func, EaseFunc func)
: ActionTween(duration, func)
, tween_func_(tween_func)
{
}
{
}
ActionPtr ActionCustom::Clone() const
{
ActionPtr ActionCustom::Clone() const
{
return new ActionCustom(GetDuration(), tween_func_);
}
}
void ActionCustom::Init(Actor* target)
{
void ActionCustom::Init(Actor* target)
{
if (!tween_func_)
this->Done();
}
}
void ActionCustom::UpdateTween(Actor* target, float percent)
{
void ActionCustom::UpdateTween(Actor* target, float percent)
{
if (tween_func_)
tween_func_(target, percent);
}
}
} // namespace kiwano

277
src/kiwano/2d/action/ActionTween.h
View File

@ -24,15 +24,15 @@
namespace kiwano
{
/// \~chinese
/// @brief 缓动函数
using EaseFunc = Function<float(float)>;
/// \~chinese
/// @brief 缓动函数
using EaseFunc = Function<float(float)>;
/// \~chinese
/// @brief 缓动函数枚举
/// @details 查看 https://easings.net 获取更多信息
struct Ease
{
/// \~chinese
/// @brief 缓动函数枚举
/// @details 查看 https://easings.net 获取更多信息
struct Ease
{
static KGE_API EaseFunc Linear; ///< 线性
static KGE_API EaseFunc EaseIn; ///< 由慢变快
static KGE_API EaseFunc EaseOut; ///< 由快变慢
@ -64,35 +64,32 @@ namespace kiwano
static KGE_API EaseFunc SineIn;
static KGE_API EaseFunc SineOut;
static KGE_API EaseFunc SineInOut;
};
};
KGE_DECLARE_SMART_PTR(ActionTween);
KGE_DECLARE_SMART_PTR(ActionMoveBy);
KGE_DECLARE_SMART_PTR(ActionMoveTo);
KGE_DECLARE_SMART_PTR(ActionJumpBy);
KGE_DECLARE_SMART_PTR(ActionJumpTo);
KGE_DECLARE_SMART_PTR(ActionScaleBy);
KGE_DECLARE_SMART_PTR(ActionScaleTo);
KGE_DECLARE_SMART_PTR(ActionFadeTo);
KGE_DECLARE_SMART_PTR(ActionFadeIn);
KGE_DECLARE_SMART_PTR(ActionFadeOut);
KGE_DECLARE_SMART_PTR(ActionRotateBy);
KGE_DECLARE_SMART_PTR(ActionRotateTo);
KGE_DECLARE_SMART_PTR(ActionCustom);
KGE_DECLARE_SMART_PTR(ActionTween);
KGE_DECLARE_SMART_PTR(ActionMoveBy);
KGE_DECLARE_SMART_PTR(ActionMoveTo);
KGE_DECLARE_SMART_PTR(ActionJumpBy);
KGE_DECLARE_SMART_PTR(ActionJumpTo);
KGE_DECLARE_SMART_PTR(ActionScaleBy);
KGE_DECLARE_SMART_PTR(ActionScaleTo);
KGE_DECLARE_SMART_PTR(ActionFadeTo);
KGE_DECLARE_SMART_PTR(ActionFadeIn);
KGE_DECLARE_SMART_PTR(ActionFadeOut);
KGE_DECLARE_SMART_PTR(ActionRotateBy);
KGE_DECLARE_SMART_PTR(ActionRotateTo);
KGE_DECLARE_SMART_PTR(ActionCustom);
/**
/**
* \addtogroup Actions
* @{
*/
/// \~chinese
/// @brief 补间动画
class KGE_API ActionTween
: public Action
{
public:
/// \~chinese
/// @brief 补间动画
class KGE_API ActionTween : public Action
{
public:
ActionTween();
/// \~chinese
@ -117,23 +114,21 @@ namespace kiwano
/// @brief 设置动画速度缓动函数
void SetEaseFunc(EaseFunc const& func);
protected:
protected:
void Update(Actor* target, Duration dt) override;
virtual void UpdateTween(Actor* target, float percent) = 0;
private:
private:
Duration dur_;
EaseFunc ease_func_;
};
};
/// \~chinese
/// @brief 相对位移动画
class KGE_API ActionMoveBy
: public ActionTween
{
public:
/// \~chinese
/// @brief 相对位移动画
class KGE_API ActionMoveBy : public ActionTween
{
public:
/// \~chinese
/// @brief 构造相对位移动画
/// @param duration 动画时长
@ -149,24 +144,22 @@ namespace kiwano
/// @brief 获取该动画的倒转
ActionPtr Reverse() const override;
protected:
protected:
void Init(Actor* target) override;
void UpdateTween(Actor* target, float percent) override;
protected:
protected:
Point start_pos_;
Point prev_pos_;
Vec2 delta_pos_;
};
};
/// \~chinese
/// @brief 位移动画
class KGE_API ActionMoveTo
: public ActionMoveBy
{
public:
/// \~chinese
/// @brief 位移动画
class KGE_API ActionMoveTo : public ActionMoveBy
{
public:
/// \~chinese
/// @brief 构造位移动画
/// @param duration 动画时长
@ -186,20 +179,18 @@ namespace kiwano
return nullptr;
}
protected:
protected:
void Init(Actor* target) override;
private:
private:
Point end_pos_;
};
};
/// \~chinese
/// @brief 相对跳跃动画
class KGE_API ActionJumpBy
: public ActionTween
{
public:
/// \~chinese
/// @brief 相对跳跃动画
class KGE_API ActionJumpBy : public ActionTween
{
public:
/// \~chinese
/// @brief 构造相对跳跃动画
/// @param duration 动画时长
@ -217,26 +208,24 @@ namespace kiwano
/// @brief 获取该动画的倒转
ActionPtr Reverse() const override;
protected:
protected:
void Init(Actor* target) override;
void UpdateTween(Actor* target, float percent) override;
protected:
protected:
Point start_pos_;
Point delta_pos_;
float height_;
int jumps_;
Point prev_pos_;
};
};
/// \~chinese
/// @brief 跳跃动画
class KGE_API ActionJumpTo
: public ActionJumpBy
{
public:
/// \~chinese
/// @brief 跳跃动画
class KGE_API ActionJumpTo : public ActionJumpBy
{
public:
/// \~chinese
/// @brief 构造跳跃动画
/// @param duration 动画时长
@ -258,20 +247,18 @@ namespace kiwano
return nullptr;
}
protected:
protected:
void Init(Actor* target) override;
private:
private:
Point end_pos_;
};
};
/// \~chinese
/// @brief 相对缩放动画
class KGE_API ActionScaleBy
: public ActionTween
{
public:
/// \~chinese
/// @brief 相对缩放动画
class KGE_API ActionScaleBy : public ActionTween
{
public:
/// \~chinese
/// @brief 构造相对缩放动画
/// @param duration 动画时长
@ -288,25 +275,23 @@ namespace kiwano
/// @brief 获取该动画的倒转
ActionPtr Reverse() const override;
protected:
protected:
void Init(Actor* target) override;
void UpdateTween(Actor* target, float percent) override;
protected:
protected:
float start_scale_x_;
float start_scale_y_;
float delta_x_;
float delta_y_;
};
};
/// \~chinese
/// @brief 缩放动画
class KGE_API ActionScaleTo
: public ActionScaleBy
{
public:
/// \~chinese
/// @brief 缩放动画
class KGE_API ActionScaleTo : public ActionScaleBy
{
public:
/// \~chinese
/// @brief 构造缩放动画
/// @param duration 动画时长
@ -327,21 +312,19 @@ namespace kiwano
return nullptr;
}
protected:
protected:
void Init(Actor* target) override;
private:
private:
float end_scale_x_;
float end_scale_y_;
};
};
/// \~chinese
/// @brief 透明度渐变动画
class KGE_API ActionFadeTo
: public ActionTween
{
public:
/// \~chinese
/// @brief 透明度渐变动画
class KGE_API ActionFadeTo : public ActionTween
{
public:
/// \~chinese
/// @brief 构造透明度渐变动画
/// @param duration 动画时长
@ -361,52 +344,46 @@ namespace kiwano
return nullptr;
}
protected:
protected:
void Init(Actor* target) override;
void UpdateTween(Actor* target, float percent) override;
private:
private:
float start_val_;
float delta_val_;
float end_val_;
};
};
/// \~chinese
/// @brief 淡入动画
class KGE_API ActionFadeIn
: public ActionFadeTo
{
public:
/// \~chinese
/// @brief 淡入动画
class KGE_API ActionFadeIn : public ActionFadeTo
{
public:
/// \~chinese
/// @brief 构造淡入动画
/// @param duration 动画时长
/// @param func 动画速度缓动函数
explicit ActionFadeIn(Duration duration, EaseFunc func = nullptr);
};
};
/// \~chinese
/// @brief 淡出动画
class KGE_API ActionFadeOut
: public ActionFadeTo
{
public:
/// \~chinese
/// @brief 淡出动画
class KGE_API ActionFadeOut : public ActionFadeTo
{
public:
/// \~chinese
/// @brief 构造淡出动画
/// @param duration 动画时长
/// @param func 动画速度缓动函数
explicit ActionFadeOut(Duration duration, EaseFunc func = nullptr);
};
};
/// \~chinese
/// @brief 相对旋转动画
class KGE_API ActionRotateBy
: public ActionTween
{
public:
/// \~chinese
/// @brief 相对旋转动画
class KGE_API ActionRotateBy : public ActionTween
{
public:
/// \~chinese
/// @brief 构造相对旋转动画
/// @param duration 动画时长
@ -422,23 +399,21 @@ namespace kiwano
/// @brief 获取该动画的倒转
ActionPtr Reverse() const override;
protected:
protected:
void Init(Actor* target) override;
void UpdateTween(Actor* target, float percent) override;
protected:
protected:
float start_val_;
float delta_val_;
};
};
/// \~chinese
/// @brief 旋转动画
class KGE_API ActionRotateTo
: public ActionRotateBy
{
public:
/// \~chinese
/// @brief 旋转动画
class KGE_API ActionRotateTo : public ActionRotateBy
{
public:
/// \~chinese
/// @brief 构造旋转动画
/// @param duration 动画时长
@ -458,20 +433,18 @@ namespace kiwano
return nullptr;
}
protected:
protected:
void Init(Actor* target) override;
private:
private:
float end_val_;
};
};
/// \~chinese
/// @brief 自定义动画
class KGE_API ActionCustom
: public ActionTween
{
public:
/// \~chinese
/// @brief 自定义动画
class KGE_API ActionCustom : public ActionTween
{
public:
/// \~chinese
/// @brief 动画回调函数
/// @details 在动画更新时回调该函数，第一个参数是执行动画的目标，第二个参数是动画进度（0.0 - 1.0）
@ -496,15 +469,15 @@ namespace kiwano
return nullptr;
}
protected:
protected:
void Init(Actor* target) override;
void UpdateTween(Actor* target, float percent) override;
private:
private:
TweenFunc tween_func_;
};
};
/** @} */
/** @} */
}
} // namespace kiwano

102
src/kiwano/2d/action/ActionWalk.cpp
View File

@ -18,48 +18,48 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include <kiwano/2d/action/ActionWalk.h>
#include <kiwano/2d/Actor.h>
#include <kiwano/2d/action/ActionWalk.h>
namespace kiwano
{
ActionWalk::ActionWalk(Duration duration, bool rotating, float start, float end, EaseFunc func)
ActionWalk::ActionWalk(Duration duration, bool rotating, float start, float end, EaseFunc func)
: ActionTween(duration, func)
, start_(start)
, end_(end)
, rotating_(rotating)
, length_(0.f)
{
}
{
}
ActionWalk::ActionWalk(Duration duration, Geometry const& path, bool rotating, float start, float end, EaseFunc func)
ActionWalk::ActionWalk(Duration duration, Geometry const& path, bool rotating, float start, float end, EaseFunc func)
: ActionWalk(duration, rotating, start, end, func)
{
{
path_ = path;
}
}
ActionPtr ActionWalk::Clone() const
{
ActionPtr ActionWalk::Clone() const
{
ActionWalkPtr clone = new ActionWalk(GetDuration(), rotating_, start_, end_, GetEaseFunc());
if (clone)
{
clone->SetPath(path_);
}
return clone;
}
}
ActionPtr ActionWalk::Reverse() const
{
ActionPtr ActionWalk::Reverse() const
{
ActionWalkPtr reverse = new ActionWalk(GetDuration(), rotating_, end_, start_, GetEaseFunc());
if (reverse)
{
reverse->SetPath(path_);
}
return reverse;
}
}
void ActionWalk::Init(Actor* target)
{
void ActionWalk::Init(Actor* target)
{
if (!path_.IsValid())
{
Done();
@ -68,10 +68,10 @@ namespace kiwano
start_pos_ = target->GetPosition();
length_ = path_.GetLength();
}
}
void ActionWalk::UpdateTween(Actor* target, float percent)
{
void ActionWalk::UpdateTween(Actor* target, float percent)
{
float distance = length_ * std::min(std::max((end_ - start_) * percent + start_, 0.f), 1.f);
Point point, tangent;
@ -86,42 +86,42 @@ namespace kiwano
target->SetRotation(rotation);
}
}
}
}
void ActionWalk::BeginPath()
{
void ActionWalk::BeginPath()
{
sink_.BeginPath();
}
}
void ActionWalk::EndPath(bool closed)
{
void ActionWalk::EndPath(bool closed)
{
sink_.EndPath(closed);
path_ = sink_.GetGeometry();
}
void ActionWalk::AddLine(Point const& point)
{
sink_.AddLine(point);
}
void ActionWalk::AddLines(Vector<Point> const& points)
{
sink_.AddLines(points);
}
void ActionWalk::AddBezier(Point const& point1, Point const& point2, Point const& point3)
{
sink_.AddBezier(point1, point2, point3);
}
void ActionWalk::AddArc(Point const& point, Size const& radius, float rotation, bool clockwise, bool is_small)
{
sink_.AddArc(point, radius, rotation, clockwise, is_small);
}
void ActionWalk::ClearPath()
{
path_.Clear();
}
}
void ActionWalk::AddLine(Point const& point)
{
sink_.AddLine(point);
}
void ActionWalk::AddLines(Vector<Point> const& points)
{
sink_.AddLines(points);
}
void ActionWalk::AddBezier(Point const& point1, Point const& point2, Point const& point3)
{
sink_.AddBezier(point1, point2, point3);
}
void ActionWalk::AddArc(Point const& point, Size const& radius, float rotation, bool clockwise, bool is_small)
{
sink_.AddArc(point, radius, rotation, clockwise, is_small);
}
void ActionWalk::ClearPath()
{
path_.Clear();
}
} // namespace kiwano

38
src/kiwano/2d/action/ActionWalk.h
View File

@ -25,19 +25,18 @@
namespace kiwano
{
KGE_DECLARE_SMART_PTR(ActionWalk);
KGE_DECLARE_SMART_PTR(ActionWalk);
/**
/**
* \addtogroup Actions
* @{
*/
/// \~chinese
/// @brief 路径行走动画
class KGE_API ActionWalk
: public ActionTween
{
public:
/// \~chinese
/// @brief 路径行走动画
class KGE_API ActionWalk : public ActionTween
{
public:
/// \~chinese
/// @brief 构造路径行走动画
/// @param duration 持续时长
@ -55,7 +54,8 @@ namespace kiwano
/// @param start 路径起点（百分比）
/// @param end 路径终点（百分比）
/// @param func 动画速度缓动函数
ActionWalk(Duration duration, Geometry const& path, bool rotating = false, float start = 0.f, float end = 1.f, EaseFunc func = nullptr);
ActionWalk(Duration duration, Geometry const& path, bool rotating = false, float start = 0.f, float end = 1.f,
EaseFunc func = nullptr);
/// \~chinese
/// @brief 获取该动画的拷贝对象
@ -113,12 +113,12 @@ namespace kiwano
/// @brief 设置路径几何形状
void SetPath(Geometry const& path);
protected:
protected:
void Init(Actor* target) override;
void UpdateTween(Actor* target, float percent) override;
private:
private:
bool rotating_;
float start_;
float end_;
@ -126,11 +126,17 @@ namespace kiwano
Point start_pos_;
Geometry path_;
GeometrySink sink_;
};
};
/** @} */
/** @} */
inline Geometry const& ActionWalk::GetPath() const { return path_; }
inline void ActionWalk::SetPath(Geometry const& path) { path_ = path; }
inline Geometry const& ActionWalk::GetPath() const
{
return path_;
}
inline void ActionWalk::SetPath(Geometry const& path)
{
path_ = path;
}
} // namespace kiwano

56
src/kiwano/2d/action/Animation.cpp
View File

@ -18,40 +18,38 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include <kiwano/2d/action/Animation.h>
#include <kiwano/2d/FrameSequence.h>
#include <kiwano/2d/Sprite.h>
#include <kiwano/2d/action/Animation.h>
namespace kiwano
{
Animation::Animation()
Animation::Animation()
: frame_seq_(nullptr)
{
}
{
}
Animation::Animation(Duration duration, FrameSequencePtr frame_seq, EaseFunc func)
Animation::Animation(Duration duration, FrameSequencePtr frame_seq, EaseFunc func)
: ActionTween(duration, func)
, frame_seq_(nullptr)
{
{
this->SetFrameSequence(frame_seq);
}
}
Animation::~Animation()
{
}
Animation::~Animation() {}
FrameSequencePtr Animation::GetFrameSequence() const
{
FrameSequencePtr Animation::GetFrameSequence() const
{
return frame_seq_;
}
}
void Animation::SetFrameSequence(FrameSequencePtr frame_seq)
{
void Animation::SetFrameSequence(FrameSequencePtr frame_seq)
{
frame_seq_ = frame_seq;
}
}
void Animation::Init(Actor* target)
{
void Animation::Init(Actor* target)
{
KGE_ASSERT(frame_seq_ && "Animation::Init() failed: FrameSequence is NULL!");
if (!frame_seq_ || frame_seq_->GetFrames().empty())
{
@ -66,10 +64,10 @@ namespace kiwano
{
sprite_target->SetFrame(frame_seq_->GetFrames()[0]);
}
}
}
void Animation::UpdateTween(Actor* target, float percent)
{
void Animation::UpdateTween(Actor* target, float percent)
{
auto sprite_target = dynamic_cast<Sprite*>(target);
if (sprite_target && frame_seq_)
@ -80,19 +78,19 @@ namespace kiwano
sprite_target->SetFrame(frames[index]);
}
}
}
ActionPtr Animation::Clone() const
{
ActionPtr Animation::Clone() const
{
if (frame_seq_)
{
return new (std::nothrow) Animation(GetDuration(), frame_seq_, GetEaseFunc());
}
return nullptr;
}
}
ActionPtr Animation::Reverse() const
{
ActionPtr Animation::Reverse() const
{
if (frame_seq_)
{
FrameSequencePtr frames = frame_seq_->Reverse();
@ -102,6 +100,6 @@ namespace kiwano
}
}
return nullptr;
}
}
} // namespace kiwano

27
src/kiwano/2d/action/Animation.h
View File

@ -19,24 +19,23 @@
// THE SOFTWARE.
#pragma once
#include <kiwano/2d/action/ActionTween.h>
#include <kiwano/2d/FrameSequence.h>
#include <kiwano/2d/action/ActionTween.h>
namespace kiwano
{
KGE_DECLARE_SMART_PTR(Animation);
KGE_DECLARE_SMART_PTR(Animation);
/**
/**
* \addtogroup Actions
* @{
*/
/// \~chinese
/// @brief 帧动画
class KGE_API Animation
: public ActionTween
{
public:
/// \~chinese
/// @brief 帧动画
class KGE_API Animation : public ActionTween
{
public:
Animation();
/// \~chinese
@ -65,14 +64,14 @@ namespace kiwano
/// @brief 获取该动画的倒转
ActionPtr Reverse() const override;
protected:
protected:
void Init(Actor* target) override;
void UpdateTween(Actor* target, float percent) override;
private:
private:
FrameSequencePtr frame_seq_;
};
};
/** @} */
}
/** @} */
} // namespace kiwano

48
src/kiwano/core/AsyncTask.cpp
View File

@ -23,44 +23,42 @@
namespace kiwano
{
AsyncTask::AsyncTask()
AsyncTask::AsyncTask()
: thread_(Closure(this, &AsyncTask::TaskThread))
{
}
{
}
AsyncTask::AsyncTask(AsyncTaskFunc func)
AsyncTask::AsyncTask(AsyncTaskFunc func)
: AsyncTask()
{
{
Then(func);
}
}
AsyncTask::~AsyncTask()
{
}
AsyncTask::~AsyncTask() {}
void AsyncTask::Start()
{
void AsyncTask::Start()
{
thread_.detach();
// retain this object until finished
Retain();
}
}
AsyncTask& AsyncTask::Then(AsyncTaskFunc func)
{
AsyncTask& AsyncTask::Then(AsyncTaskFunc func)
{
std::lock_guard<std::mutex> lock(func_mutex_);
thread_func_queue_.push(func);
return (*this);
}
}
AsyncTask& AsyncTask::SetCallback(AsyncTaskCallback callback)
{
AsyncTask& AsyncTask::SetCallback(AsyncTaskCallback callback)
{
thread_cb_ = callback;
return (*this);
}
}
void AsyncTask::TaskThread()
{
void AsyncTask::TaskThread()
{
while (!thread_func_queue_.empty())
{
auto& func = thread_func_queue_.front();
@ -75,10 +73,10 @@ namespace kiwano
}
Application::PreformInMainThread(Closure(this, &AsyncTask::Complete));
}
}
void AsyncTask::Complete()
{
void AsyncTask::Complete()
{
if (thread_cb_)
{
thread_cb_();
@ -86,6 +84,6 @@ namespace kiwano
// Release this object
Release();
}
}
} // namespace kiwano

54
src/kiwano/core/AsyncTask.h
View File

@ -19,30 +19,28 @@
// THE SOFTWARE.
#pragma once
#include <thread>
#include <mutex>
#include <kiwano/core/ObjectBase.h>
#include <mutex>
#include <thread>
namespace kiwano
{
KGE_DECLARE_SMART_PTR(AsyncTask);
KGE_DECLARE_SMART_PTR(AsyncTask);
typedef Function<void()> AsyncTaskFunc;
typedef Function<void()> AsyncTaskCallback;
typedef Function<void()> AsyncTaskFunc;
typedef Function<void()> AsyncTaskCallback;
/// \~chinese
/// @brief 异步任务
/// @details 在多线程下执行任务并返回
/// @code
/// AsyncTaskPtr task = new AsyncTask;
/// task->Then(DoSomething);
/// task->Start();
/// @endcode
class AsyncTask
: public virtual ObjectBase
{
public:
/// \~chinese
/// @brief 异步任务
/// @details 在多线程下执行任务并返回
/// @code
/// AsyncTaskPtr task = new AsyncTask;
/// task->Then(DoSomething);
/// task->Start();
/// @endcode
class AsyncTask : public virtual ObjectBase
{
public:
/// \~chinese
/// @brief 构造异步任务
AsyncTask();
@ -50,38 +48,32 @@ namespace kiwano
/// \~chinese
/// @brief 构造异步任务
/// @param func 异步回调函数
AsyncTask(
AsyncTaskFunc func
);
AsyncTask(AsyncTaskFunc func);
virtual ~AsyncTask();
/// \~chinese
/// @brief 添加异步任务链
AsyncTask& Then(
AsyncTaskFunc func
);
AsyncTask& Then(AsyncTaskFunc func);
/// \~chinese
/// @brief 设置任务执行完成后的回调函数
/// @note 该函数在 Kiwano 主线程中执行
AsyncTask& SetCallback(
AsyncTaskCallback callback
);
AsyncTask& SetCallback(AsyncTaskCallback callback);
/// \~chinese
/// @brief 启动异步任务
void Start();
private:
private:
void TaskThread();
void Complete();
private:
private:
std::thread thread_;
std::mutex func_mutex_;
Queue<AsyncTaskFunc> thread_func_queue_;
AsyncTaskCallback thread_cb_;
};
}
};
} // namespace kiwano

232
src/kiwano/core/Common.h
View File

@ -19,144 +19,146 @@
// THE SOFTWARE.
#pragma once
#include <set>
#include <map>
#include <list>
#include <queue>
#include <stack>
#include <unordered_set>
#include <unordered_map>
#include <sstream>
#include <3rd-party/OuterC/oc/oc.h>
#include <kiwano/macros.h>
#include <kiwano/core/Singleton.h>
#include <kiwano/macros.h>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <unordered_map>
#include <unordered_set>
namespace kiwano
{
/// \~chinese
/// @brief 字符串容器
using String = oc::wstring;
/// \~chinese
/// @brief 字符串容器
using String = oc::wstring;
/// \~chinese
/// @brief 窄字符串容器
using ByteString = oc::string;
/// \~chinese
/// @brief 窄字符串容器
using ByteString = oc::string;
/// \~chinese
/// @brief 字符串流
using StringStream = std::wstringstream;
/// \~chinese
/// @brief 字符串流
using StringStream = std::wstringstream;
/// \~chinese
/// @brief 线性数组容器
template <typename _Ty, typename... _Args>
using Vector = oc::vector<_Ty, _Args...>;
/// \~chinese
/// @brief 线性数组容器
template <typename _Ty, typename... _Args>
using Vector = oc::vector<_Ty, _Args...>;
/// \~chinese
/// @brief 链表容器
template <typename _Ty, typename... _Args>
using List = std::list<_Ty, _Args...>;
/// \~chinese
/// @brief 链表容器
template <typename _Ty, typename... _Args>
using List = std::list<_Ty, _Args...>;
/// \~chinese
/// @brief 队列容器
template <typename _Ty, typename... _Args>
using Queue = std::queue<_Ty, _Args...>;
/// \~chinese
/// @brief 队列容器
template <typename _Ty, typename... _Args>
using Queue = std::queue<_Ty, _Args...>;
/// \~chinese
/// @brief 集合容器
template <typename _Ty, typename... _Args>
using Set = std::set<_Ty, _Args...>;
/// \~chinese
/// @brief 集合容器
template <typename _Ty, typename... _Args>
using Set = std::set<_Ty, _Args...>;
/// \~chinese
/// @brief 对容器
template <typename _Ty1, typename _Ty2>
using Pair = std::pair<_Ty1, _Ty2>;
/// \~chinese
/// @brief 对容器
template <typename _Ty1, typename _Ty2>
using Pair = std::pair<_Ty1, _Ty2>;
/// \~chinese
/// @brief 无序集合容器
template <typename _Ty, typename... _Args>
using UnorderedSet = std::unordered_set<_Ty, _Args...>;
/// \~chinese
/// @brief 无序集合容器
template <typename _Ty, typename... _Args>
using UnorderedSet = std::unordered_set<_Ty, _Args...>;
/// \~chinese
/// @brief 栈容器
template <typename _Ty, typename... _Args>
using Stack = std::stack<_Ty, _Args...>;
/// \~chinese
/// @brief 栈容器
template <typename _Ty, typename... _Args>
using Stack = std::stack<_Ty, _Args...>;
/// \~chinese
/// @brief 字符串容器
template <typename _Kty, typename _Ty, typename... _Args>
using Map = std::map<_Kty, _Ty, _Args...>;
/// \~chinese
/// @brief 字符串容器
template <typename _Kty, typename _Ty, typename... _Args>
using Map = std::map<_Kty, _Ty, _Args...>;
/// \~chinese
/// @brief 字符串容器
template <typename _Kty, typename _Ty, typename... _Args>
using UnorderedMap = std::unordered_map<_Kty, _Ty, _Args...>;
/// \~chinese
/// @brief 字符串容器
template <typename _Kty, typename _Ty, typename... _Args>
using UnorderedMap = std::unordered_map<_Kty, _Ty, _Args...>;
/// \~chinese
/// @brief 函数封装器
/// @par
/// 使用函数封装器可以储存、复制和调用任何可调用目标，示例代码如下：
/// @code
/// Function<bool(int)> func1 = StaticFunc; // bool StaticFunc(int x);
/// Function<bool(int)> func2 = Closure(&t, &T::Func); // bool T::Func(int x);
/// Function<bool(int)> func3 = T::StaticFunc; // static bool T::StaticFunc(int x);
/// Function<bool(int)> func4 = [](int x) -> bool {}; // Lambda function
/// Function<bool(int)> func5 = std::bind(&T::Func, &t); // std::bind
/// Function<bool(int)> func5 = Callable(); // Callable objects: struct Callable { bool operator()(int x) {} };
/// @endcode
template <typename _FuncTy>
using Function = oc::function<_FuncTy>;
/// \~chinese
/// @brief 函数封装器
/// @par
/// 使用函数封装器可以储存、复制和调用任何可调用目标，示例代码如下：
/// @code
/// Function<bool(int)> func1 = StaticFunc; // bool
/// StaticFunc(int x);
/// Function<bool(int)> func2 = Closure(&t, &T::Func); // bool
/// T::Func(int x);
/// Function<bool(int)> func3 = T::StaticFunc; // static bool
/// T::StaticFunc(int x);
/// Function<bool(int)> func4 = [](int x) -> bool {}; // Lambda function
/// Function<bool(int)> func5 = std::bind(&T::Func, &t); // std::bind
/// Function<bool(int)> func5 = Callable(); // Callable
/// objects: struct Callable { bool operator()(int x) {} };
/// @endcode
template <typename _FuncTy>
using Function = oc::function<_FuncTy>;
/// \~chinese
/// @brief 单值容器
using Any = oc::any;
/// \~chinese
/// @brief 单值容器
using Any = oc::any;
/// \~chinese
/// @brief JSON对象容器
using Json = oc::basic_json<Map, Vector, String, int, double, bool, std::allocator>;
/// \~chinese
/// @brief JSON对象容器
using Json = oc::basic_json<Map, Vector, String, int, double, bool, std::allocator>;
/// \~chinese
/// @brief 侵入式链表容器
template <typename _Ty>
using IntrusiveList = oc::intrusive_list<_Ty>;
/// \~chinese
/// @brief 侵入式链表容器
template <typename _Ty>
using IntrusiveList = oc::intrusive_list<_Ty>;
/// \~chinese
/// @brief 侵入式链表元素
template <typename _Ty>
using IntrusiveListItem = oc::intrusive_list_item<_Ty>;
/// \~chinese
/// @brief 侵入式链表元素
template <typename _Ty>
using IntrusiveListItem = oc::intrusive_list_item<_Ty>;
/// \~chinese
/// @brief 侵入式智能指针
template <typename _Ty, typename _RefProxyTy>
using IntrusivePtr = oc::intrusive_ptr<_Ty, _RefProxyTy>;
/// \~chinese
/// @brief 侵入式智能指针
template <typename _Ty, typename _RefProxyTy>
using IntrusivePtr = oc::intrusive_ptr<_Ty, _RefProxyTy>;
/// \~chinese
/// @brief 不可拷贝对象
using Noncopyable = oc::noncopyable;
/// \~chinese
/// @brief 不可拷贝对象
using Noncopyable = oc::noncopyable;
/// \~chinese
/// @brief 闭包函数
template<typename _Ty, typename _Uty, typename _Ret, typename... _Args>
inline Function<_Ret(_Args...)> Closure(_Uty* ptr, _Ret(_Ty::* func)(_Args...))
{
/// \~chinese
/// @brief 闭包函数
template <typename _Ty, typename _Uty, typename _Ret, typename... _Args>
inline Function<_Ret(_Args...)> Closure(_Uty* ptr, _Ret (_Ty::*func)(_Args...))
{
return oc::closure(ptr, func);
}
/// \~chinese
/// @brief 闭包函数
template<typename _Ty, typename _Uty, typename _Ret, typename... _Args>
inline Function<_Ret(_Args...)> Closure(_Uty* ptr, _Ret(_Ty::* func)(_Args...) const)
{
return oc::closure(ptr, func);
}
inline ByteString WideToMultiByte(const String& str)
{
return oc::wide_to_string(str);
}
inline String MultiByteToWide(const ByteString& str)
{
return oc::string_to_wide(str);
}
}
/// \~chinese
/// @brief 闭包函数
template <typename _Ty, typename _Uty, typename _Ret, typename... _Args>
inline Function<_Ret(_Args...)> Closure(_Uty* ptr, _Ret (_Ty::*func)(_Args...) const)
{
return oc::closure(ptr, func);
}
inline ByteString WideToMultiByte(const String& str)
{
return oc::wide_to_string(str);
}
inline String MultiByteToWide(const ByteString& str)
{
return oc::string_to_wide(str);
}
} // namespace kiwano

56
src/kiwano/core/Component.cpp
View File

@ -20,37 +20,37 @@
#include <kiwano/core/Component.h>
#define KGE_DEFINE_COMPONENT_FLAG(OFFSET) ( 0x01 << (OFFSET % 32) )
#define KGE_DEFINE_COMPONENT_FLAG(OFFSET) (0x01 << (OFFSET % 32))
namespace kiwano
{
const int RenderComponent::flag = KGE_DEFINE_COMPONENT_FLAG(0);
const int UpdateComponent::flag = KGE_DEFINE_COMPONENT_FLAG(1);
const int EventComponent::flag = KGE_DEFINE_COMPONENT_FLAG(2);
const int RenderComponent::flag = KGE_DEFINE_COMPONENT_FLAG(0);
const int UpdateComponent::flag = KGE_DEFINE_COMPONENT_FLAG(1);
const int EventComponent::flag = KGE_DEFINE_COMPONENT_FLAG(2);
ComponentBase::ComponentBase()
ComponentBase::ComponentBase()
: flag_(0)
{
}
bool ComponentBase::Check(const int flag)
{
return !!(flag_ & flag);
}
RenderComponent::RenderComponent()
{
flag_ |= flag;
}
UpdateComponent::UpdateComponent()
{
flag_ |= flag;
}
EventComponent::EventComponent()
{
flag_ |= flag;
}
{
}
bool ComponentBase::Check(const int flag)
{
return !!(flag_ & flag);
}
RenderComponent::RenderComponent()
{
flag_ |= flag;
}
UpdateComponent::UpdateComponent()
{
flag_ |= flag;
}
EventComponent::EventComponent()
{
flag_ |= flag;
}
} // namespace kiwano

65
src/kiwano/core/Component.h
View File

@ -19,21 +19,21 @@
// THE SOFTWARE.
#pragma once
#include <kiwano/macros.h>
#include <kiwano/core/Time.h>
#include <kiwano/macros.h>
namespace kiwano
{
class RenderContext;
class Event;
class RenderContext;
class Event;
/**
/**
* \~chinese
* @brief 基础功能组件
*/
class KGE_API ComponentBase
{
public:
class KGE_API ComponentBase
{
public:
/// \~chinese
/// @brief 启动组件
virtual void SetupComponent() = 0;
@ -44,22 +44,20 @@ namespace kiwano
bool Check(const int flag);
protected:
protected:
ComponentBase();
protected:
protected:
int flag_;
};
};
/**
/**
* \~chinese
* @brief 渲染支持组件
*/
class KGE_API RenderComponent
: public virtual ComponentBase
{
public:
class KGE_API RenderComponent : public virtual ComponentBase
{
public:
/// \~chinese
/// @brief 渲染前
virtual void BeforeRender() {}
@ -73,21 +71,19 @@ namespace kiwano
/// @brief 渲染后
virtual void AfterRender() {}
public:
public:
static const int flag;
RenderComponent();
};
};
/**
/**
* \~chinese
* @brief 更新支持组件
*/
class KGE_API UpdateComponent
: public virtual ComponentBase
{
public:
class KGE_API UpdateComponent : public virtual ComponentBase
{
public:
/// \~chinese
/// @brief 更新前
virtual void BeforeUpdate() {}
@ -101,30 +97,27 @@ namespace kiwano
/// @brief 更新后
virtual void AfterUpdate() {}
public:
public:
static const int flag;
UpdateComponent();
};
};
/**
/**
* \~chinese
* @brief 事件支持组件
*/
class KGE_API EventComponent
: public virtual ComponentBase
{
public:
class KGE_API EventComponent : public virtual ComponentBase
{
public:
/// \~chinese
/// @brief 事件处理
/// @param evt 事件
virtual void HandleEvent(Event* evt) {}
public:
public:
static const int flag;
EventComponent();
};
}
};
} // namespace kiwano

76
src/kiwano/core/Director.cpp
View File

@ -18,26 +18,24 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include <kiwano/core/Director.h>
#include <kiwano/2d/Actor.h>
#include <kiwano/2d/DebugActor.h>
#include <kiwano/2d/Stage.h>
#include <kiwano/2d/Transition.h>
#include <kiwano/2d/DebugActor.h>
#include <kiwano/core/Director.h>
#include <kiwano/render/RenderContext.h>
namespace kiwano
{
Director::Director()
Director::Director()
: render_border_enabled_(false)
{
}
{
}
Director::~Director()
{
}
Director::~Director() {}
void Director::EnterStage(StagePtr stage, TransitionPtr transition)
{
void Director::EnterStage(StagePtr stage, TransitionPtr transition)
{
KGE_ASSERT(stage && "Director::EnterStage failed, NULL pointer exception");
if (current_stage_ == stage || next_stage_ == stage)
@ -54,20 +52,20 @@ namespace kiwano
transition_ = transition;
transition_->Init(current_stage_, next_stage_);
}
}
}
void Director::PushStage(StagePtr stage, TransitionPtr transition)
{
void Director::PushStage(StagePtr stage, TransitionPtr transition)
{
EnterStage(stage, transition);
if (current_stage_)
{
stages_.push(current_stage_);
}
}
}
void Director::PopStage(TransitionPtr transition)
{
void Director::PopStage(TransitionPtr transition)
{
KGE_ASSERT(!stages_.empty() && "Director::PopStage failed, calling pop() on empty stage stack");
if (!stages_.empty())
@ -85,20 +83,20 @@ namespace kiwano
transition_ = transition;
transition_->Init(current_stage_, next_stage_);
}
}
}
StagePtr Director::GetCurrentStage()
{
StagePtr Director::GetCurrentStage()
{
return current_stage_;
}
}
void Director::SetRenderBorderEnabled(bool enabled)
{
void Director::SetRenderBorderEnabled(bool enabled)
{
render_border_enabled_ = enabled;
}
}
void Director::ShowDebugInfo(bool show)
{
void Director::ShowDebugInfo(bool show)
{
if (show)
{
if (!debug_actor_)
@ -108,10 +106,10 @@ namespace kiwano
{
debug_actor_.reset();
}
}
}
void Director::ClearStages()
{
void Director::ClearStages()
{
while (!stages_.empty())
stages_.pop();
@ -119,10 +117,10 @@ namespace kiwano
next_stage_.reset();
transition_.reset();
debug_actor_.reset();
}
}
void Director::OnUpdate(Duration dt)
{
void Director::OnUpdate(Duration dt)
{
if (transition_)
{
transition_->Update(dt);
@ -152,10 +150,10 @@ namespace kiwano
if (debug_actor_)
debug_actor_->Update(dt);
}
}
void Director::OnRender(RenderContext& ctx)
{
void Director::OnRender(RenderContext& ctx)
{
if (transition_)
{
transition_->Render(ctx);
@ -174,10 +172,10 @@ namespace kiwano
{
debug_actor_->Render(ctx);
}
}
}
void Director::HandleEvent(Event* evt)
{
void Director::HandleEvent(Event* evt)
{
if (current_stage_)
current_stage_->DispatchEvent(evt);
@ -186,6 +184,6 @@ namespace kiwano
if (debug_actor_)
debug_actor_->DispatchEvent(evt);
}
}
} // namespace kiwano

34
src/kiwano/core/Director.h
View File

@ -19,38 +19,35 @@
// THE SOFTWARE.
#pragma once
#include <kiwano/core/Component.h>
#include <kiwano/2d/Actor.h>
#include <kiwano/2d/Stage.h>
#include <kiwano/2d/Transition.h>
#include <kiwano/core/Component.h>
namespace kiwano
{
/**
/**
* \~chinese
* @brief 导演
* @details 导演完成舞台的渲染、更新、事件分发以及控制舞台间跳转
* @see kiwano::Stage
*/
class KGE_API Director
class KGE_API Director
: public Singleton<Director>
, public UpdateComponent
, public RenderComponent
, public EventComponent
{
{
friend Singleton<Director>;
public:
public:
/**
* \~chinese
* @brief 切换舞台
* @param[in] stage 舞台
* @param[in] transition 过渡动画
*/
void EnterStage(
StagePtr stage,
TransitionPtr transition = nullptr
);
void EnterStage(StagePtr stage, TransitionPtr transition = nullptr);
/**
* \~chinese
@ -58,19 +55,14 @@ namespace kiwano
* @param[in] stage 舞台
* @param[in] transition 过渡动画
*/
void PushStage(
StagePtr stage,
TransitionPtr transition = nullptr
);
void PushStage(StagePtr stage, TransitionPtr transition = nullptr);
/**
* \~chinese
* @brief 退出当前舞台，并切换到上一个舞台
* @param[in] transition 过渡动画
*/
void PopStage(
TransitionPtr transition = nullptr
);
void PopStage(TransitionPtr transition = nullptr);
/**
* \~chinese
@ -99,7 +91,7 @@ namespace kiwano
*/
void ClearStages();
public:
public:
void SetupComponent() override {}
void DestroyComponent() override {}
@ -110,17 +102,17 @@ namespace kiwano
void HandleEvent(Event* evt) override;
private:
private:
Director();
virtual ~Director();
private:
private:
bool render_border_enabled_;
Stack<StagePtr> stages_;
StagePtr current_stage_;
StagePtr next_stage_;
ActorPtr debug_actor_;
TransitionPtr transition_;
};
}
};
} // namespace kiwano

222
src/kiwano/core/EventDispatcher.cpp
View File

@ -23,8 +23,8 @@
namespace kiwano
{
bool EventDispatcher::DispatchEvent(Event* evt)
{
bool EventDispatcher::DispatchEvent(Event* evt)
{
if (listeners_.empty())
return true;
@ -43,15 +43,15 @@ namespace kiwano
return false;
}
return true;
}
}
EventListener* EventDispatcher::AddListener(EventListenerPtr listener)
{
EventListener* EventDispatcher::AddListener(EventListenerPtr listener)
{
return AddListener(listener.get());
}
}
EventListener* EventDispatcher::AddListener(EventListener* listener)
{
EventListener* EventDispatcher::AddListener(EventListener* listener)
{
KGE_ASSERT(listener && "AddListener failed, NULL pointer exception");
if (listener)
@ -59,113 +59,113 @@ namespace kiwano
listeners_.push_back(listener);
}
return listener;
}
}
EventListener* EventDispatcher::AddListener(String const& name, EventType type, EventListener::Callback callback)
{
EventListener* EventDispatcher::AddListener(String const& name, EventType type, EventListener::Callback callback)
{
EventListenerPtr listener = new EventListener(name, type, callback);
return AddListener(listener);
}
}
EventListener* EventDispatcher::AddListener(EventType type, EventListener::Callback callback)
{
EventListener* EventDispatcher::AddListener(EventType type, EventListener::Callback callback)
{
EventListenerPtr listener = new EventListener(type, callback);
return AddListener(listener);
}
void EventDispatcher::StartListeners(String const & listener_name)
{
for (auto& listener : listeners_)
{
if (listener.IsName(listener_name))
{
listener.Start();
}
}
}
void EventDispatcher::StopListeners(String const & listener_name)
{
for (auto& listener : listeners_)
{
if (listener.IsName(listener_name))
{
listener.Stop();
}
}
}
void EventDispatcher::RemoveListeners(String const & listener_name)
{
for (auto& listener : listeners_)
{
if (listener.IsName(listener_name))
{
listener.Remove();
}
}
}
void EventDispatcher::StartListeners(const EventType& type)
{
for (auto& listener : listeners_)
{
if (listener.GetEventType() == type)
{
listener.Start();
}
}
}
void EventDispatcher::StopListeners(const EventType& type)
{
for (auto& listener : listeners_)
{
if (listener.GetEventType() == type)
{
listener.Stop();
}
}
}
void EventDispatcher::RemoveListeners(const EventType& type)
{
for (auto& listener : listeners_)
{
if (listener.GetEventType() == type)
{
listener.Remove();
}
}
}
void EventDispatcher::StartAllListeners()
{
for (auto& listener : listeners_)
{
listener.Start();
}
}
void EventDispatcher::StopAllListeners()
{
for (auto& listener : listeners_)
{
listener.Stop();
}
}
void EventDispatcher::RemoveAllListeners()
{
for (auto& listener : listeners_)
{
listener.Remove();
}
}
const EventDispatcher::Listeners& EventDispatcher::GetAllListeners() const
{
return listeners_;
}
}
void EventDispatcher::StartListeners(String const& listener_name)
{
for (auto& listener : listeners_)
{
if (listener.IsName(listener_name))
{
listener.Start();
}
}
}
void EventDispatcher::StopListeners(String const& listener_name)
{
for (auto& listener : listeners_)
{
if (listener.IsName(listener_name))
{
listener.Stop();
}
}
}
void EventDispatcher::RemoveListeners(String const& listener_name)
{
for (auto& listener : listeners_)
{
if (listener.IsName(listener_name))
{
listener.Remove();
}
}
}
void EventDispatcher::StartListeners(const EventType& type)
{
for (auto& listener : listeners_)
{
if (listener.GetEventType() == type)
{
listener.Start();
}
}
}
void EventDispatcher::StopListeners(const EventType& type)
{
for (auto& listener : listeners_)
{
if (listener.GetEventType() == type)
{
listener.Stop();
}
}
}
void EventDispatcher::RemoveListeners(const EventType& type)
{
for (auto& listener : listeners_)
{
if (listener.GetEventType() == type)
{
listener.Remove();
}
}
}
void EventDispatcher::StartAllListeners()
{
for (auto& listener : listeners_)
{
listener.Start();
}
}
void EventDispatcher::StopAllListeners()
{
for (auto& listener : listeners_)
{
listener.Stop();
}
}
void EventDispatcher::RemoveAllListeners()
{
for (auto& listener : listeners_)
{
listener.Remove();
}
}
const EventDispatcher::Listeners& EventDispatcher::GetAllListeners() const
{
return listeners_;
}
} // namespace kiwano

24
src/kiwano/core/EventDispatcher.h
View File

@ -23,13 +23,13 @@
namespace kiwano
{
/**
/**
* \~chinese
* @brief 事件分发系统
*/
class KGE_API EventDispatcher
{
public:
class KGE_API EventDispatcher
{
public:
/// \~chinese
/// @brief 监听器列表
using Listeners = IntrusiveList<EventListenerPtr>;
@ -59,10 +59,7 @@ namespace kiwano
/// @brief 添加监听器
/// @tparam _EventTy 事件类型
/// @param callback 回调函数
template <
typename _EventTy,
typename = typename std::enable_if<IsEvent<_EventTy>::value, int>::type
>
template <typename _EventTy, typename = typename std::enable_if<IsEvent<_EventTy>::value, int>::type>
EventListener* AddListener(EventListener::Callback callback)
{
return AddListener(KGE_EVENT(_EventTy), callback);
@ -73,10 +70,7 @@ namespace kiwano
/// @tparam _EventTy 事件类型
/// @param name 监听器名称
/// @param callback 回调函数
template <
typename _EventTy,
typename = typename std::enable_if<IsEvent<_EventTy>::value, int>
>
template <typename _EventTy, typename = typename std::enable_if<IsEvent<_EventTy>::value, int>>
EventListener* AddListener(String const& name, EventListener::Callback callback)
{
return AddListener(name, KGE_EVENT(_EventTy), callback);
@ -134,7 +128,7 @@ namespace kiwano
/// @return 是否继续分发该事件
bool DispatchEvent(Event* evt);
private:
private:
Listeners listeners_;
};
}
};
} // namespace kiwano

26
src/kiwano/core/EventListener.cpp
View File

@ -23,30 +23,28 @@
namespace kiwano
{
EventListener::EventListener()
EventListener::EventListener()
: type_()
, callback_()
, running_(true)
, removeable_(false)
, swallow_(false)
{
}
{
}
EventListener::EventListener(EventType type, Callback const& callback)
EventListener::EventListener(EventType type, Callback const& callback)
: EventListener(String(), type, callback)
{
}
{
}
EventListener::EventListener(String const& name, EventType type, Callback const& callback)
EventListener::EventListener(String const& name, EventType type, Callback const& callback)
: EventListener()
{
{
SetName(name);
SetEventType(type);
SetCallback(callback);
}
EventListener::~EventListener()
{
}
}
EventListener::~EventListener() {}
} // namespace kiwano

109
src/kiwano/core/EventListener.h
View File

@ -20,31 +20,31 @@
#pragma once
#include <kiwano/core/Common.h>
#include <kiwano/core/SmartPtr.hpp>
#include <kiwano/core/ObjectBase.h>
#include <kiwano/core/SmartPtr.hpp>
#include <kiwano/core/event/Event.h>
#include <kiwano/core/event/MouseEvent.h>
#include <kiwano/core/event/KeyEvent.h>
#include <kiwano/core/event/MouseEvent.h>
#include <kiwano/core/event/WindowEvent.h>
namespace kiwano
{
class EventDispatcher;
class EventDispatcher;
KGE_DECLARE_SMART_PTR(EventListener);
KGE_DECLARE_SMART_PTR(EventListener);
/**
/**
* \~chinese
* @brief 事件监听器
*/
class KGE_API EventListener
class KGE_API EventListener
: public virtual ObjectBase
, protected IntrusiveListItem<EventListenerPtr>
{
{
friend class EventDispatcher;
friend IntrusiveList<EventListenerPtr>;
public:
public:
/// \~chinese
/// @brief 监听器回调函数
using Callback = Function<void(Event*)>;
@ -70,10 +70,7 @@ namespace kiwano
/// @brief 构造监听器
/// @tparam _EventTy 事件类型
/// @param callback 回调函数
template <
typename _EventTy,
typename = typename std::enable_if<IsEvent<_EventTy>::value, int>::type
>
template <typename _EventTy, typename = typename std::enable_if<IsEvent<_EventTy>::value, int>::type>
inline EventListener(Callback const& callback)
: EventListener(KGE_EVENT(_EventTy), callback)
{
@ -84,10 +81,7 @@ namespace kiwano
/// @tparam _EventTy 事件类型
/// @param name 监听器名称
/// @param callback 回调函数
template <
typename _EventTy,
typename = typename std::enable_if<IsEvent<_EventTy>::value, int>::type
>
template <typename _EventTy, typename = typename std::enable_if<IsEvent<_EventTy>::value, int>::type>
inline EventListener(String const& name, Callback const& callback)
: EventListener(name, KGE_EVENT(_EventTy), callback)
{
@ -143,10 +137,7 @@ namespace kiwano
/// \~chinese
/// @brief 设置监听的事件类型
/// @tparam _EventTy 事件类型
template <
typename _EventTy,
typename = typename std::enable_if<IsEvent<_EventTy>::value, int>::type
>
template <typename _EventTy, typename = typename std::enable_if<IsEvent<_EventTy>::value, int>::type>
inline void SetEventType()
{
SetEventType(KGE_EVENT(_EventTy));
@ -156,78 +147,76 @@ namespace kiwano
/// @brief 接收消息
void Receive(Event* evt);
private:
private:
bool running_;
bool removeable_;
bool swallow_;
EventType type_;
Callback callback_;
};
};
inline void EventListener::Start()
{
inline void EventListener::Start()
{
running_ = true;
}
}
inline void EventListener::Stop()
{
inline void EventListener::Stop()
{
running_ = false;
}
}
inline void EventListener::Remove()
{
inline void EventListener::Remove()
{
removeable_ = true;
}
}
inline bool EventListener::IsRunning() const
{
inline bool EventListener::IsRunning() const
{
return running_;
}
}
inline bool EventListener::IsRemoveable() const
{
inline bool EventListener::IsRemoveable() const
{
return removeable_;
}
}
inline bool EventListener::IsSwallowEnabled() const
{
inline bool EventListener::IsSwallowEnabled() const
{
return swallow_;
}
}
inline void EventListener::SetSwallowEnabled(bool enabled)
{
inline void EventListener::SetSwallowEnabled(bool enabled)
{
swallow_ = enabled;
}
}
inline const EventListener::Callback& EventListener::GetCallback() const
{
inline const EventListener::Callback& EventListener::GetCallback() const
{
return callback_;
}
}
inline void EventListener::SetCallback(Callback const& cb)
{
inline void EventListener::SetCallback(Callback const& cb)
{
callback_ = cb;
}
}
inline EventType EventListener::GetEventType() const
{
inline EventType EventListener::GetEventType() const
{
return type_;
}
}
inline void EventListener::SetEventType(EventType const& type)
{
inline void EventListener::SetEventType(EventType const& type)
{
type_ = type;
}
}
inline void EventListener::Receive(Event* evt)
{
inline void EventListener::Receive(Event* evt)
{
KGE_ASSERT(evt != nullptr);
if (type_ == evt->GetType() && callback_)
{
callback_(evt);
}
}
}
} // namespace kiwano

Some files were not shown because too many files have changed in this diff Show More