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

Rename RenderTarget to RenderContext

This commit is contained in:
Nomango 2020-01-10 15:22:12 +08:00
parent 8547397cc6
commit b102f85096
44 changed files with 399 additions and 398 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
projects/kiwano/kiwano.vcxproj
View File

@ -74,7 +74,7 @@
<ClInclude Include="..\..\src\kiwano\renderer\TextureCache.h" />
<ClInclude Include="..\..\src\kiwano\renderer\LayerArea.h" />
<ClInclude Include="..\..\src\kiwano\renderer\Renderer.h" />
<ClInclude Include="..\..\src\kiwano\renderer\RenderTarget.h" />
<ClInclude Include="..\..\src\kiwano\renderer\RenderContext.h" />
<ClInclude Include="..\..\src\kiwano\renderer\TextLayout.h" />
<ClInclude Include="..\..\src\kiwano\renderer\win32\D2DDeviceResources.h" />
<ClInclude Include="..\..\src\kiwano\renderer\win32\D3D10DeviceResources.h" />
@ -143,7 +143,7 @@
<ClCompile Include="..\..\src\kiwano\renderer\TextureCache.cpp" />
<ClCompile Include="..\..\src\kiwano\renderer\LayerArea.cpp" />
<ClCompile Include="..\..\src\kiwano\renderer\Renderer.cpp" />
<ClCompile Include="..\..\src\kiwano\renderer\RenderTarget.cpp" />
<ClCompile Include="..\..\src\kiwano\renderer\RenderContext.cpp" />
<ClCompile Include="..\..\src\kiwano\renderer\TextLayout.cpp" />
<ClCompile Include="..\..\src\kiwano\renderer\win32\D2DDeviceResources.cpp" />
<ClCompile Include="..\..\src\kiwano\renderer\win32\D3D10DeviceResources.cpp" />

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

@ -186,9 +186,6 @@
<ClInclude Include="..\..\src\kiwano\renderer\win32\TextRenderer.h">
<Filter>renderer\win32</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\renderer\RenderTarget.h">
<Filter>renderer</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\2d\Transform.h">
<Filter>2d</Filter>
</ClInclude>
@ -282,6 +279,9 @@
<ClInclude Include="..\..\src\kiwano\2d\Button.h">
<Filter>2d</Filter>
</ClInclude>
<ClInclude Include="..\..\src\kiwano\renderer\RenderContext.h">
<Filter>renderer</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\..\src\kiwano\2d\Canvas.cpp">
@ -407,9 +407,6 @@
<ClCompile Include="..\..\src\kiwano\renderer\win32\TextRenderer.cpp">
<Filter>renderer\win32</Filter>
</ClCompile>
<ClCompile Include="..\..\src\kiwano\renderer\RenderTarget.cpp">
<Filter>renderer</Filter>
</ClCompile>
<ClCompile Include="..\..\src\kiwano\2d\Transform.cpp">
<Filter>2d</Filter>
</ClCompile>
@ -479,5 +476,8 @@
<ClCompile Include="..\..\src\kiwano\renderer\StrokeStyle.cpp">
<Filter>renderer</Filter>
</ClCompile>
<ClCompile Include="..\..\src\kiwano\renderer\RenderContext.cpp">
<Filter>renderer</Filter>
</ClCompile>
</ItemGroup>
</Project>

88
src/3rd-party/OuterC/oc/intrusive_list.h vendored
View File

@ -16,20 +16,19 @@ template <typename _Ty, typename _PTy = typename std::pointer_traits<_Ty>::point
class intrusive_list_item
{
public:
using pointer_type = _PTy;
using const_pointer_type = const _PTy;
using pointer = _PTy;
intrusive_list_item() : prev_(nullptr), next_(nullptr) {}
intrusive_list_item(pointer_type rhs) : prev_(nullptr), next_(nullptr) { if (rhs) { prev_ = rhs->prev_; next_ = rhs->next_; } }
intrusive_list_item() : prev_(nullptr), next_(nullptr) {}
intrusive_list_item(pointer rhs) : prev_(nullptr), next_(nullptr) { if (rhs) { prev_ = rhs->prev_; next_ = rhs->next_; } }
const_pointer_type prev_item() const { return prev_; }
pointer_type prev_item() { return prev_; }
const_pointer_type next_item() const { return next_; }
pointer_type next_item() { return next_; }
const pointer prev_item() const { return prev_; }
pointer prev_item() { return prev_; }
const pointer next_item() const { return next_; }
pointer next_item() { return next_; }
private:
pointer_type prev_;
pointer_type next_;
pointer prev_;
pointer next_;
friend class intrusive_list<_Ty, _PTy>;
};
@ -39,23 +38,24 @@ template <typename _Ty, typename _PTy>
class intrusive_list
{
public:
using pointer_type = _PTy;
using const_pointer_type = const _PTy;
using value_type = typename std::pointer_traits<_PTy>::element_type;
using pointer = _PTy;
using reference = value_type&;
intrusive_list() : first_(), last_() {}
~intrusive_list() { clear(); }
intrusive_list() : first_(), last_() {}
~intrusive_list() { clear(); }
const_pointer_type first_item() const { return first_; }
pointer_type first_item() { return first_; }
const_pointer_type last_item() const { return last_; }
pointer_type last_item() { return last_; }
const pointer first_item() const { return first_; }
pointer first_item() { return first_; }
const pointer last_item() const { return last_; }
pointer last_item() { return last_; }
inline bool empty() const
{
return first_ == nullptr;
}
void push_back(pointer_type child)
void push_back(pointer child)
{
if (child->prev_)
child->prev_->next_ = child->next_;
@ -77,7 +77,7 @@ public:
last_ = child;
}
void push_front(pointer_type child)
void push_front(pointer child)
{
if (child->prev_)
child->prev_->next_ = child->next_;
@ -99,7 +99,7 @@ public:
first_ = child;
}
void insert_before(pointer_type child, pointer_type before)
void insert_before(pointer child, pointer before)
{
if (child->prev_)
child->prev_->next_ = child->next_;
@ -116,7 +116,7 @@ public:
before->prev_ = child;
}
void insert_after(pointer_type child, pointer_type after)
void insert_after(pointer child, pointer after)
{
if (child->prev_)
child->prev_->next_ = child->next_;
@ -133,7 +133,7 @@ public:
after->next_ = child;
}
void remove(pointer_type child)
void remove(pointer child)
{
if (child->next_)
{
@ -159,10 +159,10 @@ public:
void clear()
{
pointer_type p = first_;
pointer p = first_;
while (p)
{
pointer_type tmp = p;
pointer tmp = p;
p = p->next_;
if (tmp)
{
@ -180,8 +180,8 @@ public:
return;
int pos = 0;
pointer_type p = first_;
pointer_type tmp = p;
pointer p = first_;
pointer tmp = p;
do
{
tmp = p;
@ -205,15 +205,19 @@ public:
struct iterator_impl
{
using iterator_category = std::bidirectional_iterator_tag;
using pointer_type = _PTy;
using const_pointer_type = const _PTy;
using value_type = typename std::pointer_traits<_PTy>::element_type;
using difference_type = ptrdiff_t;
using pointer = _PTy;
using reference = value_type&;
inline iterator_impl(pointer_type ptr = nullptr, bool is_end = false) : base_(ptr), is_end_(is_end) {}
inline iterator_impl(pointer ptr = nullptr, bool is_end = false) : base_(ptr), is_end_(is_end) {}
inline pointer_type operator*() const { OC_ASSERT(base_ && !is_end_); return base_; }
inline iterator_impl& operator++() { OC_ASSERT(base_ && !is_end_); pointer_type next = base_->next_item(); if (next) base_ = next; else is_end_ = true; return (*this); }
inline pointer base() const { OC_ASSERT(!is_end_); return const_cast<pointer&>(base_); }
inline reference operator*() const { OC_ASSERT(base_ && !is_end_); return const_cast<reference>(*base_); }
inline pointer operator->() const { OC_ASSERT(base_ && !is_end_); return const_cast<pointer&>(base_); }
inline iterator_impl& operator++() { OC_ASSERT(base_ && !is_end_); pointer next = base_->next_item(); if (next) base_ = next; else is_end_ = true; return (*this); }
inline iterator_impl operator++(int) { iterator_impl old = (*this); ++(*this); return old; }
inline iterator_impl& operator--() { OC_ASSERT(base_); if (is_end_) is_end_ = false; else base_ = pointer_type(base_->prev_item()); return (*this); }
inline iterator_impl& operator--() { OC_ASSERT(base_); if (is_end_) is_end_ = false; else base_ = pointer(base_->prev_item()); return (*this); }
inline iterator_impl operator--(int) { iterator_impl old = (*this); --(*this); return old; }
inline bool operator==(iterator_impl const& other) const { return base_ == other.base_ && is_end_ == other.is_end_; }
inline bool operator!=(iterator_impl const& other) const { return !(*this == other); }
@ -221,11 +225,11 @@ public:
private:
bool is_end_;
pointer_type base_;
pointer base_;
};
using iterator = iterator_impl<pointer_type>;
using const_iterator = iterator_impl<const pointer_type>;
using iterator = iterator_impl<pointer>;
using const_iterator = iterator_impl<const pointer>;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
@ -241,14 +245,14 @@ public:
inline reverse_iterator rend() { return reverse_iterator(begin()); }
inline const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
inline const_reverse_iterator crend() const { return rend(); }
inline pointer_type front() { if (empty()) throw std::out_of_range("front() called on empty intrusive_list"); return first_item(); }
inline const_pointer_type front() const { if (empty()) throw std::out_of_range("front() called on empty intrusive_list"); return first_item(); }
inline pointer_type back() { if (empty()) throw std::out_of_range("back() called on empty intrusive_list"); return last_item(); }
inline const_pointer_type back() const { if (empty()) throw std::out_of_range("back() called on empty intrusive_list"); return last_item(); }
inline pointer front() { if (empty()) throw std::out_of_range("front() called on empty intrusive_list"); return first_item(); }
inline const pointer front() const { if (empty()) throw std::out_of_range("front() called on empty intrusive_list"); return first_item(); }
inline pointer back() { if (empty()) throw std::out_of_range("back() called on empty intrusive_list"); return last_item(); }
inline const pointer back() const { if (empty()) throw std::out_of_range("back() called on empty intrusive_list"); return last_item(); }
private:
pointer_type first_;
pointer_type last_;
pointer first_;
pointer last_;
};
} // namespace oc

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

@ -33,9 +33,9 @@ namespace kiwano
{
}
void ImGuiLayer::OnRender(RenderTarget* rt)
void ImGuiLayer::OnRender(RenderContext& ctx)
{
PrepareToRender(rt);
PrepareToRender(ctx);
for (const auto& pipeline : pipelines_)
{
pipeline.second();

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

@ -60,7 +60,7 @@ namespace kiwano
void RemoveAllItems();
public:
void OnRender(RenderTarget* rt) override;
void OnRender(RenderContext& ctx) override;
private:
Map<String, ImGuiPipeline> pipelines_;

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

@ -88,7 +88,7 @@ namespace kiwano
}
}
void Actor::Render(RenderTarget* rt)
void Actor::Render(RenderContext& ctx)
{
if (!visible_)
return;
@ -97,10 +97,10 @@ namespace kiwano
if (children_.empty())
{
if (CheckVisibilty(rt))
if (CheckVisibilty(ctx))
{
PrepareToRender(rt);
OnRender(rt);
PrepareToRender(ctx);
OnRender(ctx);
}
}
else
@ -112,52 +112,52 @@ namespace kiwano
if (child->GetZOrder() >= 0)
break;
child->Render(rt);
child->Render(ctx);
child = child->next_item().get();
}
if (CheckVisibilty(rt))
if (CheckVisibilty(ctx))
{
PrepareToRender(rt);
OnRender(rt);
PrepareToRender(ctx);
OnRender(ctx);
}
while (child)
{
child->Render(rt);
child->Render(ctx);
child = child->next_item().get();
}
}
}
void Actor::PrepareToRender(RenderTarget* rt)
void Actor::PrepareToRender(RenderContext& ctx)
{
rt->SetTransform(transform_matrix_);
rt->SetBrushOpacity(GetDisplayedOpacity());
ctx.SetTransform(transform_matrix_);
ctx.SetBrushOpacity(GetDisplayedOpacity());
}
void Actor::RenderBorder(RenderTarget* rt)
void Actor::RenderBorder(RenderContext& ctx)
{
if (show_border_ && !size_.IsOrigin())
{
Rect bounds = GetBounds();
rt->SetTransform(transform_matrix_);
ctx.SetTransform(transform_matrix_);
rt->SetCurrentBrush(GetStage()->GetBorderFillBrush());
rt->FillRectangle(bounds);
ctx.SetCurrentBrush(GetStage()->GetBorderFillBrush());
ctx.FillRectangle(bounds);
rt->SetCurrentBrush(GetStage()->GetBorderStrokeBrush());
rt->DrawRectangle(bounds, 2.f);
ctx.SetCurrentBrush(GetStage()->GetBorderStrokeBrush());
ctx.DrawRectangle(bounds, 2.f);
}
for (auto child = children_.first_item(); child; child = child->next_item())
{
child->RenderBorder(rt);
child->RenderBorder(ctx);
}
}
bool Actor::CheckVisibilty(RenderTarget* rt) const
bool Actor::CheckVisibilty(RenderContext& ctx) const
{
if (dirty_visibility_)
{
@ -169,7 +169,7 @@ namespace kiwano
}
else
{
visible_in_rt_ = rt->CheckVisibility(GetBounds(), GetTransformMatrix());
visible_in_rt_ = ctx.CheckVisibility(GetBounds(), GetTransformMatrix());
}
}
return visible_in_rt_;

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

@ -31,7 +31,7 @@ namespace kiwano
{
class Stage;
class Director;
class RenderTarget;
class RenderContext;
KGE_DECLARE_SMART_PTR(Actor);
@ -83,8 +83,8 @@ namespace kiwano
/// \~chinese
/// @brief 渲染角色
/// @details 每帧画面刷新时调用该函数，默认不进行渲染，重载该函数以实现具体渲染过程
/// @param rt 渲染目标
virtual void OnRender(RenderTarget* rt);
/// @param ctx 渲染上下文
virtual void OnRender(RenderContext& ctx);
/// \~chinese
/// @brief 获取显示状态
@ -406,19 +406,19 @@ namespace kiwano
/// \~chinese
/// @brief 渲染自身和所有子角色
virtual void Render(RenderTarget* rt);
virtual void Render(RenderContext& ctx);
/// \~chinese
/// @brief 绘制自身和所有子角色的边界
virtual void RenderBorder(RenderTarget* rt);
virtual void RenderBorder(RenderContext& ctx);
/// \~chinese
/// @brief 检查是否在渲染目标的视区内
virtual bool CheckVisibilty(RenderTarget* rt) const;
/// @brief 检查是否在渲染上下文的视区内
virtual bool CheckVisibilty(RenderContext& ctx) const;
/// \~chinese
/// @brief 渲染前初始化渲染目标状态，仅当 CheckVisibilty 返回真时调用该函数
virtual void PrepareToRender(RenderTarget* rt);
/// @brief 渲染前初始化渲染上下文状态，仅当 CheckVisibilty 返回真时调用该函数
virtual void PrepareToRender(RenderContext& ctx);
/// \~chinese
/// @brief 更新自己的二维变换，并通知所有子角色
@ -477,9 +477,9 @@ namespace kiwano
KGE_NOT_USED(dt);
}
inline void Actor::OnRender(RenderTarget* rt)
inline void Actor::OnRender(RenderContext& ctx)
{
KGE_NOT_USED(rt);
KGE_NOT_USED(ctx);
}
inline bool Actor::IsVisible() const

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

@ -38,33 +38,33 @@ namespace kiwano
void Canvas::BeginDraw()
{
InitRenderTargetAndBrushs();
rt_->BeginDraw();
ctx_->BeginDraw();
}
void Canvas::EndDraw()
{
InitRenderTargetAndBrushs();
rt_->EndDraw();
ctx_->EndDraw();
cache_expired_ = true;
}
void Canvas::OnRender(RenderTarget* rt)
void Canvas::OnRender(RenderContext& ctx)
{
UpdateCache();
if (texture_cached_ && texture_cached_->IsValid())
{
PrepareToRender(rt);
PrepareToRender(ctx);
Rect bitmap_rect(0.f, 0.f, texture_cached_->GetWidth(), texture_cached_->GetHeight());
rt->DrawTexture(*texture_cached_, bitmap_rect, bitmap_rect);
ctx.DrawTexture(*texture_cached_, bitmap_rect, bitmap_rect);
}
}
void Canvas::SetBrush(BrushPtr brush)
{
InitRenderTargetAndBrushs();
rt_->SetCurrentBrush(brush);
ctx_->SetCurrentBrush(brush);
}
float Canvas::GetStrokeWidth() const
@ -75,44 +75,44 @@ namespace kiwano
void Canvas::SetBrushTransform(Transform const& transform)
{
InitRenderTargetAndBrushs();
rt_->SetTransform(transform.ToMatrix());
ctx_->SetTransform(transform.ToMatrix());
}
void Canvas::SetBrushTransform(Matrix3x2 const & transform)
{
InitRenderTargetAndBrushs();
rt_->SetTransform(transform);
ctx_->SetTransform(transform);
}
void Canvas::PushLayerArea(LayerArea& area)
{
InitRenderTargetAndBrushs();
rt_->PushLayer(area);
ctx_->PushLayer(area);
}
void Canvas::PopLayerArea()
{
InitRenderTargetAndBrushs();
rt_->PopLayer();
ctx_->PopLayer();
}
void Canvas::PushClipRect(Rect const& clip_rect)
{
InitRenderTargetAndBrushs();
rt_->PushClipRect(clip_rect);
ctx_->PushClipRect(clip_rect);
}
void Canvas::PopClipRect()
{
InitRenderTargetAndBrushs();
rt_->PopClipRect();
ctx_->PopClipRect();
}
void Canvas::DrawLine(Point const& begin, Point const& end)
{
InitRenderTargetAndBrushs();
rt_->SetCurrentBrush(stroke_brush_);
rt_->DrawLine(
ctx_->SetCurrentBrush(stroke_brush_);
ctx_->DrawLine(
begin,
end,
stroke_width_,
@ -124,8 +124,8 @@ namespace kiwano
void Canvas::DrawCircle(Point const& center, float radius)
{
InitRenderTargetAndBrushs();
rt_->SetCurrentBrush(stroke_brush_);
rt_->DrawEllipse(
ctx_->SetCurrentBrush(stroke_brush_);
ctx_->DrawEllipse(
center,
Vec2(radius, radius),
stroke_width_,
@ -137,8 +137,8 @@ namespace kiwano
void Canvas::DrawEllipse(Point const& center, Vec2 const& radius)
{
InitRenderTargetAndBrushs();
rt_->SetCurrentBrush(stroke_brush_);
rt_->DrawEllipse(
ctx_->SetCurrentBrush(stroke_brush_);
ctx_->DrawEllipse(
center,
radius,
stroke_width_,
@ -150,8 +150,8 @@ namespace kiwano
void Canvas::DrawRect(Rect const& rect)
{
InitRenderTargetAndBrushs();
rt_->SetCurrentBrush(stroke_brush_);
rt_->DrawRectangle(
ctx_->SetCurrentBrush(stroke_brush_);
ctx_->DrawRectangle(
rect,
stroke_width_,
stroke_style_
@ -162,8 +162,8 @@ namespace kiwano
void Canvas::DrawRoundedRect(Rect const& rect, Vec2 const& radius)
{
InitRenderTargetAndBrushs();
rt_->SetCurrentBrush(stroke_brush_);
rt_->DrawRoundedRectangle(
ctx_->SetCurrentBrush(stroke_brush_);
ctx_->DrawRoundedRectangle(
rect,
radius,
stroke_width_,
@ -175,8 +175,8 @@ namespace kiwano
void Canvas::FillCircle(Point const& center, float radius)
{
InitRenderTargetAndBrushs();
rt_->SetCurrentBrush(fill_brush_);
rt_->FillEllipse(
ctx_->SetCurrentBrush(fill_brush_);
ctx_->FillEllipse(
center,
Vec2(radius, radius)
);
@ -186,8 +186,8 @@ namespace kiwano
void Canvas::FillEllipse(Point const& center, Vec2 const& radius)
{
InitRenderTargetAndBrushs();
rt_->SetCurrentBrush(fill_brush_);
rt_->FillEllipse(
ctx_->SetCurrentBrush(fill_brush_);
ctx_->FillEllipse(
center,
radius
);
@ -197,8 +197,8 @@ namespace kiwano
void Canvas::FillRect(Rect const& rect)
{
InitRenderTargetAndBrushs();
rt_->SetCurrentBrush(fill_brush_);
rt_->FillRectangle(
ctx_->SetCurrentBrush(fill_brush_);
ctx_->FillRectangle(
rect
);
cache_expired_ = true;
@ -207,8 +207,8 @@ namespace kiwano
void Canvas::FillRoundedRect(Rect const& rect, Vec2 const& radius)
{
InitRenderTargetAndBrushs();
rt_->SetCurrentBrush(fill_brush_);
rt_->FillRoundedRectangle(
ctx_->SetCurrentBrush(fill_brush_);
ctx_->FillRoundedRectangle(
rect,
radius
);
@ -220,7 +220,7 @@ namespace kiwano
if (texture)
{
InitRenderTargetAndBrushs();
rt_->DrawTexture(*texture, src_rect, dest_rect);
ctx_->DrawTexture(*texture, src_rect, dest_rect);
cache_expired_ = true;
}
}
@ -239,7 +239,7 @@ namespace kiwano
void Canvas::DrawTextLayout(TextLayout const& layout, Point const& point)
{
InitRenderTargetAndBrushs();
rt_->DrawTextLayout(layout, point);
ctx_->DrawTextLayout(layout, point);
}
void Canvas::BeginPath(Point const& begin_pos)
@ -275,8 +275,8 @@ namespace kiwano
void Canvas::StrokePath()
{
InitRenderTargetAndBrushs();
rt_->SetCurrentBrush(stroke_brush_);
rt_->DrawGeometry(
ctx_->SetCurrentBrush(stroke_brush_);
ctx_->DrawGeometry(
geo_sink_.GetGeometry(),
stroke_width_,
stroke_style_
@ -287,8 +287,8 @@ namespace kiwano
void Canvas::FillPath()
{
InitRenderTargetAndBrushs();
rt_->SetCurrentBrush(fill_brush_);
rt_->FillGeometry(
ctx_->SetCurrentBrush(fill_brush_);
ctx_->FillGeometry(
geo_sink_.GetGeometry()
);
cache_expired_ = true;
@ -297,14 +297,14 @@ namespace kiwano
void Canvas::Clear()
{
InitRenderTargetAndBrushs();
rt_->Clear();
ctx_->Clear();
cache_expired_ = true;
}
void Canvas::Clear(Color const& clear_color)
{
InitRenderTargetAndBrushs();
rt_->Clear(clear_color);
ctx_->Clear(clear_color);
cache_expired_ = true;
}
@ -316,9 +316,9 @@ namespace kiwano
void Canvas::InitRenderTargetAndBrushs()
{
if (!rt_)
if (!ctx_)
{
Renderer::instance().CreateTextureRenderTarget(rt_);
Renderer::instance().CreateTextureRenderTarget(ctx_);
}
if (!stroke_brush_)
@ -336,14 +336,14 @@ namespace kiwano
void Canvas::UpdateCache() const
{
if (cache_expired_ && rt_)
if (cache_expired_ && ctx_)
{
if (!texture_cached_)
{
texture_cached_ = new Texture;
}
if (rt_->GetOutput(*texture_cached_))
if (ctx_->GetOutput(*texture_cached_))
{
cache_expired_ = false;
}

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

@ -20,7 +20,7 @@
#pragma once
#include <kiwano/2d/Actor.h>
#include <kiwano/renderer/RenderTarget.h>
#include <kiwano/renderer/RenderContext.h>
#include <kiwano/renderer/GeometrySink.h>
namespace kiwano
@ -262,7 +262,7 @@ namespace kiwano
/// @brief 导出纹理
TexturePtr ExportToTexture() const;
void OnRender(RenderTarget* rt) override;
void OnRender(RenderContext& ctx) override;
private:
void InitRenderTargetAndBrushs();
@ -279,7 +279,7 @@ namespace kiwano
mutable bool cache_expired_;
mutable TexturePtr texture_cached_;
mutable TextureRenderTargetPtr rt_;
mutable TextureRenderContextPtr ctx_;
};
/** @} */

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

@ -75,12 +75,11 @@ namespace kiwano
{
}
void DebugActor::OnRender(RenderTarget* rt)
void DebugActor::OnRender(RenderContext& ctx)
{
rt->SetCurrentBrush(background_brush_);
rt->FillRoundedRectangle(GetBounds(), Vec2{ 5.f, 5.f });
rt->DrawTextLayout(debug_text_, Point(10, 10));
ctx.SetCurrentBrush(background_brush_);
ctx.FillRoundedRectangle(GetBounds(), Vec2{ 5.f, 5.f });
ctx.DrawTextLayout(debug_text_, Point(10, 10));
}
void DebugActor::OnUpdate(Duration dt)
@ -140,7 +139,7 @@ namespace kiwano
}
}
bool DebugActor::CheckVisibilty(RenderTarget* rt) const
bool DebugActor::CheckVisibilty(RenderContext& ctx) const
{
return true;
}

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

@ -41,12 +41,12 @@ namespace kiwano
virtual ~DebugActor();
void OnRender(RenderTarget* rt) override;
void OnRender(RenderContext& ctx) override;
void OnUpdate(Duration dt) override;
protected:
bool CheckVisibilty(RenderTarget* rt) const override;
bool CheckVisibilty(RenderContext& ctx) const override;
private:
std::locale comma_locale_;

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

@ -70,13 +70,13 @@ namespace kiwano
return false;
}
void GifSprite::OnRender(RenderTarget* rt)
void GifSprite::OnRender(RenderContext& ctx)
{
if (frame_to_render_ && CheckVisibilty(rt))
if (frame_to_render_ && CheckVisibilty(ctx))
{
PrepareToRender(rt);
PrepareToRender(ctx);
rt->DrawTexture(*frame_to_render_, &frame_.rect, nullptr);
ctx.DrawTexture(*frame_to_render_, &frame_.rect, nullptr);
}
}

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

@ -21,7 +21,7 @@
#pragma once
#include <kiwano/2d/Actor.h>
#include <kiwano/core/Resource.h>
#include <kiwano/renderer/RenderTarget.h>
#include <kiwano/renderer/RenderContext.h>
#include <kiwano/renderer/GifImage.h>
namespace kiwano
@ -98,7 +98,7 @@ namespace kiwano
/// @brief »ñÈ¡ GIF ͼƬ
GifImagePtr GetGifImage() const;
void OnRender(RenderTarget* rt) override;
void OnRender(RenderContext& ctx) override;
private:
void Update(Duration dt) override;
@ -147,7 +147,7 @@ namespace kiwano
GifImage::Frame frame_;
TexturePtr saved_frame_;
TexturePtr frame_to_render_;
TextureRenderTargetPtr frame_rt_;
TextureRenderContextPtr frame_rt_;
};
/** @} */

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

@ -61,10 +61,8 @@ namespace kiwano
if (!swallow_)
{
ActorPtr prev;
for (auto child = GetAllChildren().last_item(); child; child = prev)
for (auto child = GetAllChildren().rbegin(); child != GetAllChildren().rend(); ++child)
{
prev = child->prev_item();
child->Dispatch(evt);
}
}
@ -72,16 +70,16 @@ namespace kiwano
EventDispatcher::Dispatch(evt);
}
void Layer::Render(RenderTarget* rt)
void Layer::Render(RenderContext& ctx)
{
rt->PushLayer(area_);
ctx.PushLayer(area_);
Actor::Render(rt);
Actor::Render(ctx);
rt->PopLayer();
ctx.PopLayer();
}
bool Layer::CheckVisibilty(RenderTarget* rt) const
bool Layer::CheckVisibilty(RenderContext& ctx) const
{
// Do not need to render Layer
return false;

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

@ -21,7 +21,7 @@
#pragma once
#include <kiwano/2d/Actor.h>
#include <kiwano/renderer/LayerArea.h>
#include <kiwano/renderer/RenderTarget.h>
#include <kiwano/renderer/RenderContext.h>
namespace kiwano
{
@ -85,9 +85,9 @@ namespace kiwano
void Dispatch(Event& evt) override;
protected:
void Render(RenderTarget* rt) override;
void Render(RenderContext& ctx) override;
bool CheckVisibilty(RenderTarget* rt) const override;
bool CheckVisibilty(RenderContext& ctx) const override;
private:
bool swallow_;

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

@ -77,7 +77,7 @@ namespace kiwano
}
}
void ShapeActor::OnRender(RenderTarget* rt)
void ShapeActor::OnRender(RenderContext& ctx)
{
// Create default brush
if (!fill_brush_)
@ -92,16 +92,16 @@ namespace kiwano
stroke_brush_->SetColor(Color::Transparent);
}
rt->SetCurrentBrush(stroke_brush_);
rt->DrawGeometry(geo_, stroke_width_ * 2 /* twice width for widening */, stroke_style_);
ctx.SetCurrentBrush(stroke_brush_);
ctx.DrawGeometry(geo_, stroke_width_ * 2 /* twice width for widening */, stroke_style_);
rt->SetCurrentBrush(fill_brush_);
rt->FillGeometry(geo_);
ctx.SetCurrentBrush(fill_brush_);
ctx.FillGeometry(geo_);
}
bool ShapeActor::CheckVisibilty(RenderTarget* rt) const
bool ShapeActor::CheckVisibilty(RenderContext& ctx) const
{
return geo_.IsValid() && Actor::CheckVisibilty(rt);
return geo_.IsValid() && Actor::CheckVisibilty(ctx);
}
//-------------------------------------------------------

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

@ -119,10 +119,10 @@ namespace kiwano
/// @brief <20>零섯부近榴
void SetGeometry(Geometry const& geometry);
void OnRender(RenderTarget* rt) override;
void OnRender(RenderContext& ctx) override;
protected:
bool CheckVisibilty(RenderTarget* rt) const override;
bool CheckVisibilty(RenderContext& ctx) const override;
private:
BrushPtr fill_brush_;

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

@ -74,13 +74,13 @@ namespace kiwano
}
}
void Sprite::OnRender(RenderTarget* rt)
void Sprite::OnRender(RenderContext& ctx)
{
rt->DrawTexture(*frame_->GetTexture(), &frame_->GetCropRect(), &GetBounds());
ctx.DrawTexture(*frame_->GetTexture(), &frame_->GetCropRect(), &GetBounds());
}
bool Sprite::CheckVisibilty(RenderTarget* rt) const
bool Sprite::CheckVisibilty(RenderContext& ctx) const
{
return frame_ && frame_->IsValid() && Actor::CheckVisibilty(rt);
return frame_ && frame_->IsValid() && Actor::CheckVisibilty(ctx);
}
}

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

@ -67,10 +67,10 @@ namespace kiwano
/// @param[in] frame ÍźĎńÖĄ
void SetFrame(FramePtr frame);
void OnRender(RenderTarget* rt) override;
void OnRender(RenderContext& ctx) override;
protected:
bool CheckVisibilty(RenderTarget* rt) const override;
bool CheckVisibilty(RenderContext& ctx) const override;
private:
FramePtr frame_;

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

@ -46,9 +46,9 @@ namespace kiwano
KGE_SYS_LOG(L"Stage exited");
}
void Stage::RenderBorder(RenderTarget* rt)
void Stage::RenderBorder(RenderContext& ctx)
{
rt->SetBrushOpacity(1.0f);
ctx.SetBrushOpacity(1.0f);
if (!border_fill_brush_)
{
@ -62,7 +62,7 @@ namespace kiwano
border_stroke_brush_->SetColor(Color(Color::Red, .8f));
}
Actor::RenderBorder(rt);
Actor::RenderBorder(ctx);
}
}

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

@ -77,7 +77,7 @@ namespace kiwano
protected:
/// \~chinese
/// @brief 绘制所有子角色的边界
void RenderBorder(RenderTarget* rt) override;
void RenderBorder(RenderContext& ctx) override;
private:
BrushPtr border_fill_brush_;

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

@ -75,9 +75,9 @@ namespace kiwano
{
}
void TextActor::OnRender(RenderTarget* rt)
void TextActor::OnRender(RenderContext& ctx)
{
rt->DrawTextLayout(text_layout_);
ctx.DrawTextLayout(text_layout_);
}
void TextActor::OnUpdate(Duration dt)
@ -106,9 +106,9 @@ namespace kiwano
}
}
bool TextActor::CheckVisibilty(RenderTarget* rt) const
bool TextActor::CheckVisibilty(RenderContext& ctx) const
{
return text_layout_.IsValid() && Actor::CheckVisibilty(rt);
return text_layout_.IsValid() && Actor::CheckVisibilty(ctx);
}
void TextActor::SetFillColor(Color const& color)

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

@ -170,12 +170,12 @@ namespace kiwano
/// @brief 获取默认文字样式
static const TextStyle& GetDefaultStyle();
void OnRender(RenderTarget* rt) override;
void OnRender(RenderContext& ctx) override;
void OnUpdate(Duration dt) override;
protected:
bool CheckVisibilty(RenderTarget* rt) const override;
bool CheckVisibilty(RenderContext& ctx) const override;
private:
bool show_underline_;

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

@ -91,30 +91,30 @@ namespace kiwano
}
}
void Transition::Render(RenderTarget* rt)
void Transition::Render(RenderContext& ctx)
{
if (out_stage_)
{
out_stage_->PrepareToRender(rt);
rt->PushClipRect(Rect{ Point{}, window_size_ });
rt->PushLayer(out_layer_);
out_stage_->PrepareToRender(ctx);
ctx.PushClipRect(Rect{ Point{}, window_size_ });
ctx.PushLayer(out_layer_);
out_stage_->Render(rt);
out_stage_->Render(ctx);
rt->PopLayer();
rt->PopClipRect();
ctx.PopLayer();
ctx.PopClipRect();
}
if (in_stage_)
{
in_stage_->PrepareToRender(rt);
rt->PushClipRect(Rect{ Point{}, window_size_ });
rt->PushLayer(in_layer_);
in_stage_->PrepareToRender(ctx);
ctx.PushClipRect(Rect{ Point{}, window_size_ });
ctx.PushLayer(in_layer_);
in_stage_->Render(rt);
in_stage_->Render(ctx);
rt->PopLayer();
rt->PopClipRect();
ctx.PopLayer();
ctx.PopClipRect();
}
}

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

@ -25,7 +25,7 @@
namespace kiwano
{
class Director;
class RenderTarget;
class RenderContext;
KGE_DECLARE_SMART_PTR(Transition);
KGE_DECLARE_SMART_PTR(FadeTransition);
@ -83,9 +83,9 @@ namespace kiwano
/**
* \~chinese
* @brief 渲染过度动画
* @param[in] rt äÖȾĿ±ê
* @param[in] ctx 渲染上下文
*/
virtual void Render(RenderTarget* rt);
virtual void Render(RenderContext& ctx);
/**
* \~chinese

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

@ -58,18 +58,6 @@ namespace kiwano
return action;
}
ActionPtr ActionManager::GetAction(String const & name)
{
if (actions_.empty())
return nullptr;
for (auto& action : actions_)
if (action->IsName(name))
return action;
return nullptr;
}
void ActionManager::ResumeAllActions()
{
if (actions_.empty())
@ -77,7 +65,7 @@ namespace kiwano
for (auto& action : actions_)
{
action->Resume();
action.Resume();
}
}
@ -88,7 +76,7 @@ namespace kiwano
for (auto& action : actions_)
{
action->Pause();
action.Pause();
}
}
@ -99,10 +87,22 @@ namespace kiwano
for (auto& action : actions_)
{
action->Stop();
action.Stop();
}
}
ActionPtr ActionManager::GetAction(String const& name)
{
if (actions_.empty())
return nullptr;
for (auto& action : actions_)
if (action.IsName(name))
return &action;
return nullptr;
}
const ActionManager::Actions& ActionManager::GetAllActions() const
{
return actions_;

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

@ -47,11 +47,6 @@ namespace kiwano
/// @brief 添加动画
Action* AddAction(Action* action);
/// \~chinese
/// @brief 获取指定名称的动画
/// @param name 动画名称
ActionPtr GetAction(String const& name);
/// \~chinese
/// @brief 继续所有暂停动画
void ResumeAllActions();
@ -64,6 +59,11 @@ namespace kiwano
/// @brief 停止所有动画
void StopAllActions();
/// \~chinese
/// @brief 获取指定名称的动画
/// @param name 动画名称
ActionPtr GetAction(String const& name);
/// \~chinese
/// @brief 获取所有动画
Actions const& GetAllActions() const;

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

@ -24,7 +24,7 @@
namespace kiwano
{
class RenderTarget;
class RenderContext;
class Event;
/**
@ -66,8 +66,8 @@ namespace kiwano
/// \~chinese
/// @brief 渲染时
/// @param rt äÖȾĿ±ê
virtual void OnRender(RenderTarget* rt) {}
/// @param ctx 渲染上下文
virtual void OnRender(RenderContext& ctx) {}
/// \~chinese
/// @brief 渲染后

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

@ -77,9 +77,9 @@ namespace kiwano
{
for (auto& listener : listeners_)
{
if (listener->IsName(listener_name))
if (listener.IsName(listener_name))
{
listener->Start();
listener.Start();
}
}
}
@ -88,9 +88,9 @@ namespace kiwano
{
for (auto& listener : listeners_)
{
if (listener->IsName(listener_name))
if (listener.IsName(listener_name))
{
listener->Stop();
listener.Stop();
}
}
}
@ -99,9 +99,9 @@ namespace kiwano
{
for (auto& listener : listeners_)
{
if (listener->IsName(listener_name))
if (listener.IsName(listener_name))
{
listener->Remove();
listener.Remove();
}
}
}
@ -110,9 +110,9 @@ namespace kiwano
{
for (auto& listener : listeners_)
{
if (listener->type_ == type)
if (listener.GetEventType() == type)
{
listener->Start();
listener.Start();
}
}
}
@ -121,9 +121,9 @@ namespace kiwano
{
for (auto& listener : listeners_)
{
if (listener->type_ == type)
if (listener.GetEventType() == type)
{
listener->Stop();
listener.Stop();
}
}
}
@ -132,9 +132,9 @@ namespace kiwano
{
for (auto& listener : listeners_)
{
if (listener->type_ == type)
if (listener.GetEventType() == type)
{
listener->Remove();
listener.Remove();
}
}
}
@ -143,7 +143,7 @@ namespace kiwano
{
for (auto& listener : listeners_)
{
listener->Start();
listener.Start();
}
}
@ -151,7 +151,7 @@ namespace kiwano
{
for (auto& listener : listeners_)
{
listener->Stop();
listener.Stop();
}
}
@ -159,7 +159,7 @@ namespace kiwano
{
for (auto& listener : listeners_)
{
listener->Remove();
listener.Remove();
}
}

16
src/kiwano/core/TimerManager.cpp
View File

@ -71,9 +71,9 @@ namespace kiwano
for (auto& timer : timers_)
{
if (timer->IsName(name))
if (timer.IsName(name))
{
timer->Stop();
timer.Stop();
}
}
}
@ -85,9 +85,9 @@ namespace kiwano
for (auto& timer : timers_)
{
if (timer->IsName(name))
if (timer.IsName(name))
{
timer->Start();
timer.Start();
}
}
}
@ -99,9 +99,9 @@ namespace kiwano
for (auto& timer : timers_)
{
if (timer->IsName(name))
if (timer.IsName(name))
{
timer->Remove();
timer.Remove();
}
}
}
@ -113,7 +113,7 @@ namespace kiwano
for (auto& timer : timers_)
{
timer->Stop();
timer.Stop();
}
}
@ -124,7 +124,7 @@ namespace kiwano
for (auto& timer : timers_)
{
timer->Start();
timer.Start();
}
}

2
src/kiwano/platform/Application.cpp
View File

@ -238,7 +238,7 @@ namespace kiwano
}
// Rendering
Renderer* renderer = &Renderer::instance();
Renderer& renderer = Renderer::instance();
for (auto c : render_comps_)
{
c->OnRender(renderer);

12
src/kiwano/platform/Director.cpp
View File

@ -23,7 +23,7 @@
#include <kiwano/2d/Stage.h>
#include <kiwano/2d/Transition.h>
#include <kiwano/2d/DebugActor.h>
#include <kiwano/renderer/RenderTarget.h>
#include <kiwano/renderer/RenderContext.h>
namespace kiwano
{
@ -154,28 +154,28 @@ namespace kiwano
debug_actor_->Update(dt);
}
void Director::OnRender(RenderTarget* rt)
void Director::OnRender(RenderContext& ctx)
{
if (transition_)
{
transition_->Render(rt);
transition_->Render(ctx);
}
else if (current_stage_)
{
current_stage_->Render(rt);
current_stage_->Render(ctx);
}
if (render_border_enabled_)
{
if (current_stage_)
{
current_stage_->RenderBorder(rt);
current_stage_->RenderBorder(ctx);
}
}
if (debug_actor_)
{
debug_actor_->Render(rt);
debug_actor_->Render(ctx);
}
}

2
src/kiwano/platform/Director.h
View File

@ -106,7 +106,7 @@ namespace kiwano
void OnUpdate(Duration dt) override;
void OnRender(RenderTarget* rt) override;
void OnRender(RenderContext& ctx) override;
void HandleEvent(Event& evt) override;

4
src/kiwano/renderer/Brush.h
View File

@ -24,7 +24,7 @@
namespace kiwano
{
class RenderTarget;
class RenderContext;
class Renderer;
KGE_DECLARE_SMART_PTR(Brush);
@ -88,7 +88,7 @@ namespace kiwano
class KGE_API Brush
: public virtual ObjectBase
{
friend class RenderTarget;
friend class RenderContext;
friend class Renderer;
public:

4
src/kiwano/renderer/Geometry.h
View File

@ -23,7 +23,7 @@
namespace kiwano
{
class RenderTarget;
class RenderContext;
class Renderer;
class GeometrySink;
@ -38,7 +38,7 @@ namespace kiwano
*/
class KGE_API Geometry
{
friend class RenderTarget;
friend class RenderContext;
friend class Renderer;
friend class GeometrySink;

2
src/kiwano/renderer/GeometrySink.h
View File

@ -23,7 +23,7 @@
namespace kiwano
{
class RenderTarget;
class RenderContext;
class Renderer;
/**

4
src/kiwano/renderer/LayerArea.h
View File

@ -23,7 +23,7 @@
namespace kiwano
{
class RenderTarget;
class RenderContext;
/**
* \addtogroup Render
@ -36,7 +36,7 @@ namespace kiwano
*/
class KGE_API LayerArea
{
friend class RenderTarget;
friend class RenderContext;
public:
LayerArea();

178
src/kiwano/renderer/RenderTarget.cpp → src/kiwano/renderer/RenderContext.cpp
View File

@ -18,16 +18,16 @@
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
#include <kiwano/renderer/RenderTarget.h>
#include <kiwano/renderer/RenderContext.h>
#include <kiwano/core/Logger.h>
namespace kiwano
{
//
// RenderTarget
// RenderContext
//
RenderTarget::RenderTarget()
RenderContext::RenderContext()
: collecting_status_(false)
, fast_global_transform_(true)
, brush_opacity_(1.0f)
@ -37,18 +37,18 @@ namespace kiwano
status_.primitives = 0;
}
HRESULT RenderTarget::CreateDeviceResources(ComPtr<ID2D1Factory> factory, ComPtr<ID2D1RenderTarget> rt)
HRESULT RenderContext::CreateDeviceResources(ComPtr<ID2D1Factory> factory, ComPtr<ID2D1RenderTarget> ctx)
{
if (!factory || !rt)
if (!factory || !ctx)
return E_INVALIDARG;
render_target_ = rt;
render_ctx_ = ctx;
text_renderer_.reset();
current_brush_.reset();
HRESULT hr = ITextRenderer::Create(
&text_renderer_,
render_target_.get()
render_ctx_.get()
);
if (SUCCEEDED(hr))
@ -62,19 +62,19 @@ namespace kiwano
return hr;
}
void RenderTarget::DiscardDeviceResources()
void RenderContext::DiscardDeviceResources()
{
text_renderer_.reset();
render_target_.reset();
render_ctx_.reset();
current_brush_.reset();
}
bool RenderTarget::IsValid() const
bool RenderContext::IsValid() const
{
return render_target_ != nullptr;
return render_ctx_ != nullptr;
}
void RenderTarget::BeginDraw()
void RenderContext::BeginDraw()
{
if (collecting_status_)
{
@ -82,15 +82,15 @@ namespace kiwano
status_.primitives = 0;
}
if (render_target_)
if (render_ctx_)
{
render_target_->BeginDraw();
render_ctx_->BeginDraw();
}
}
void RenderTarget::EndDraw()
void RenderContext::EndDraw()
{
win32::ThrowIfFailed( render_target_->EndDraw() );
win32::ThrowIfFailed( render_ctx_->EndDraw() );
if (collecting_status_)
{
@ -98,14 +98,14 @@ namespace kiwano
}
}
void RenderTarget::DrawGeometry(Geometry const& geometry, float stroke_width, const StrokeStyle& stroke)
void RenderContext::DrawGeometry(Geometry const& geometry, float stroke_width, const StrokeStyle& stroke)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
KGE_ASSERT(current_brush_ && "The brush used for rendering has not been set!");
if (geometry.IsValid())
{
render_target_->DrawGeometry(
render_ctx_->DrawGeometry(
geometry.GetGeometry().get(),
current_brush_->GetBrush().get(),
stroke_width,
@ -116,14 +116,14 @@ namespace kiwano
}
}
void RenderTarget::FillGeometry(Geometry const& geometry)
void RenderContext::FillGeometry(Geometry const& geometry)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
KGE_ASSERT(current_brush_ && "The brush used for rendering has not been set!");
if (geometry.IsValid())
{
render_target_->FillGeometry(
render_ctx_->FillGeometry(
geometry.GetGeometry().get(),
current_brush_->GetBrush().get()
);
@ -132,12 +132,12 @@ namespace kiwano
}
}
void RenderTarget::DrawLine(Point const& point1, Point const& point2, float stroke_width, const StrokeStyle& stroke)
void RenderContext::DrawLine(Point const& point1, Point const& point2, float stroke_width, const StrokeStyle& stroke)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
KGE_ASSERT(current_brush_ && "The brush used for rendering has not been set!");
render_target_->DrawLine(
render_ctx_->DrawLine(
DX::ConvertToPoint2F(point1),
DX::ConvertToPoint2F(point2),
current_brush_->GetBrush().get(),
@ -148,12 +148,12 @@ namespace kiwano
IncreasePrimitivesCount();
}
void RenderTarget::DrawRectangle(Rect const& rect, float stroke_width, const StrokeStyle& stroke)
void RenderContext::DrawRectangle(Rect const& rect, float stroke_width, const StrokeStyle& stroke)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
KGE_ASSERT(current_brush_ && "The brush used for rendering has not been set!");
render_target_->DrawRectangle(
render_ctx_->DrawRectangle(
DX::ConvertToRectF(rect),
current_brush_->GetBrush().get(),
stroke_width,
@ -163,12 +163,12 @@ namespace kiwano
IncreasePrimitivesCount();
}
void RenderTarget::FillRectangle(Rect const& rect)
void RenderContext::FillRectangle(Rect const& rect)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
KGE_ASSERT(current_brush_ && "The brush used for rendering has not been set!");
render_target_->FillRectangle(
render_ctx_->FillRectangle(
DX::ConvertToRectF(rect),
current_brush_->GetBrush().get()
);
@ -176,12 +176,12 @@ namespace kiwano
IncreasePrimitivesCount();
}
void RenderTarget::DrawRoundedRectangle(Rect const& rect, Vec2 const& radius, float stroke_width, const StrokeStyle& stroke)
void RenderContext::DrawRoundedRectangle(Rect const& rect, Vec2 const& radius, float stroke_width, const StrokeStyle& stroke)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
KGE_ASSERT(current_brush_ && "The brush used for rendering has not been set!");
render_target_->DrawRoundedRectangle(
render_ctx_->DrawRoundedRectangle(
D2D1::RoundedRect(
DX::ConvertToRectF(rect),
radius.x,
@ -195,12 +195,12 @@ namespace kiwano
IncreasePrimitivesCount();
}
void RenderTarget::FillRoundedRectangle(Rect const& rect, Vec2 const& radius)
void RenderContext::FillRoundedRectangle(Rect const& rect, Vec2 const& radius)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
KGE_ASSERT(current_brush_ && "The brush used for rendering has not been set!");
render_target_->FillRoundedRectangle(
render_ctx_->FillRoundedRectangle(
D2D1::RoundedRect(
DX::ConvertToRectF(rect),
radius.x,
@ -212,12 +212,12 @@ namespace kiwano
IncreasePrimitivesCount();
}
void RenderTarget::DrawEllipse(Point const& center, Vec2 const& radius, float stroke_width, const StrokeStyle& stroke)
void RenderContext::DrawEllipse(Point const& center, Vec2 const& radius, float stroke_width, const StrokeStyle& stroke)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
KGE_ASSERT(current_brush_ && "The brush used for rendering has not been set!");
render_target_->DrawEllipse(
render_ctx_->DrawEllipse(
D2D1::Ellipse(
DX::ConvertToPoint2F(center),
radius.x,
@ -231,12 +231,12 @@ namespace kiwano
IncreasePrimitivesCount();
}
void RenderTarget::FillEllipse(Point const& center, Vec2 const& radius)
void RenderContext::FillEllipse(Point const& center, Vec2 const& radius)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
KGE_ASSERT(current_brush_ && "The brush used for rendering has not been set!");
render_target_->FillEllipse(
render_ctx_->FillEllipse(
D2D1::Ellipse(
DX::ConvertToPoint2F(center),
radius.x,
@ -248,14 +248,14 @@ namespace kiwano
IncreasePrimitivesCount();
}
void RenderTarget::DrawTexture(Texture const& texture, Rect const& src_rect, Rect const& dest_rect)
void RenderContext::DrawTexture(Texture const& texture, Rect const& src_rect, Rect const& dest_rect)
{
DrawTexture(texture, &src_rect, &dest_rect);
}
void RenderTarget::DrawTexture(Texture const& texture, const Rect* src_rect, const Rect* dest_rect)
void RenderContext::DrawTexture(Texture const& texture, const Rect* src_rect, const Rect* dest_rect)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
if (texture.IsValid())
{
@ -263,7 +263,7 @@ namespace kiwano
? D2D1_BITMAP_INTERPOLATION_MODE_LINEAR
: D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR;
render_target_->DrawBitmap(
render_ctx_->DrawBitmap(
texture.GetBitmap().get(),
dest_rect ? &DX::ConvertToRectF(*dest_rect) : nullptr,
brush_opacity_,
@ -275,7 +275,7 @@ namespace kiwano
}
}
void RenderTarget::DrawTextLayout(TextLayout const& layout, Point const& offset)
void RenderContext::DrawTextLayout(TextLayout const& layout, Point const& offset)
{
KGE_ASSERT(text_renderer_ && "Text renderer has not been initialized!");
@ -318,12 +318,12 @@ namespace kiwano
}
}
void RenderTarget::CreateTexture(Texture& texture, math::Vec2T<uint32_t> size, D2D1_PIXEL_FORMAT format)
void RenderContext::CreateTexture(Texture& texture, math::Vec2T<uint32_t> size, D2D1_PIXEL_FORMAT format)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
ComPtr<ID2D1Bitmap> saved_bitmap;
HRESULT hr = render_target_->CreateBitmap(
HRESULT hr = render_ctx_->CreateBitmap(
D2D1::SizeU(size.x, size.y),
D2D1::BitmapProperties(format),
&saved_bitmap
@ -339,28 +339,28 @@ namespace kiwano
}
}
void RenderTarget::PushClipRect(Rect const& clip_rect)
void RenderContext::PushClipRect(Rect const& clip_rect)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
render_target_->PushAxisAlignedClip(
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
render_ctx_->PushAxisAlignedClip(
DX::ConvertToRectF(clip_rect),
antialias_ ? D2D1_ANTIALIAS_MODE_PER_PRIMITIVE : D2D1_ANTIALIAS_MODE_ALIASED
);
}
void RenderTarget::PopClipRect()
void RenderContext::PopClipRect()
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
render_target_->PopAxisAlignedClip();
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
render_ctx_->PopAxisAlignedClip();
}
void RenderTarget::PushLayer(LayerArea& layer)
void RenderContext::PushLayer(LayerArea& layer)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
if (!layer.IsValid())
{
ComPtr<ID2D1Layer> output;
HRESULT hr = render_target_->CreateLayer(&output);
HRESULT hr = render_ctx_->CreateLayer(&output);
if (SUCCEEDED(hr))
{
@ -374,7 +374,7 @@ namespace kiwano
if (layer.IsValid())
{
render_target_->PushLayer(
render_ctx_->PushLayer(
D2D1::LayerParameters(
DX::ConvertToRectF(layer.GetAreaRect()),
layer.GetMaskGeometry().GetGeometry().get(),
@ -389,40 +389,40 @@ namespace kiwano
}
}
void RenderTarget::PopLayer()
void RenderContext::PopLayer()
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
render_target_->PopLayer();
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
render_ctx_->PopLayer();
}
void RenderTarget::Clear()
void RenderContext::Clear()
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
render_target_->Clear();
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
render_ctx_->Clear();
}
void RenderTarget::Clear(Color const& clear_color)
void RenderContext::Clear(Color const& clear_color)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
render_target_->Clear(DX::ConvertToColorF(clear_color));
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
render_ctx_->Clear(DX::ConvertToColorF(clear_color));
}
void RenderTarget::SetTransform(const Matrix3x2& matrix)
void RenderContext::SetTransform(const Matrix3x2& matrix)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
if (fast_global_transform_)
{
render_target_->SetTransform(DX::ConvertToMatrix3x2F(&matrix));
render_ctx_->SetTransform(DX::ConvertToMatrix3x2F(&matrix));
}
else
{
Matrix3x2 result = matrix * global_transform_;
render_target_->SetTransform(DX::ConvertToMatrix3x2F(&result));
render_ctx_->SetTransform(DX::ConvertToMatrix3x2F(&result));
}
}
void RenderTarget::SetGlobalTransform(const Matrix3x2* matrix)
void RenderContext::SetGlobalTransform(const Matrix3x2* matrix)
{
if (matrix)
{
@ -435,17 +435,17 @@ namespace kiwano
}
}
void RenderTarget::SetAntialiasMode(bool enabled)
void RenderContext::SetAntialiasMode(bool enabled)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
render_target_->SetAntialiasMode(enabled ? D2D1_ANTIALIAS_MODE_PER_PRIMITIVE : D2D1_ANTIALIAS_MODE_ALIASED);
render_ctx_->SetAntialiasMode(enabled ? D2D1_ANTIALIAS_MODE_PER_PRIMITIVE : D2D1_ANTIALIAS_MODE_ALIASED);
antialias_ = enabled;
}
void RenderTarget::SetTextAntialiasMode(TextAntialiasMode mode)
void RenderContext::SetTextAntialiasMode(TextAntialiasMode mode)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
D2D1_TEXT_ANTIALIAS_MODE antialias_mode = D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE;
switch (mode)
@ -467,12 +467,12 @@ namespace kiwano
}
text_antialias_ = mode;
render_target_->SetTextAntialiasMode(antialias_mode);
render_ctx_->SetTextAntialiasMode(antialias_mode);
}
bool RenderTarget::CheckVisibility(Rect const& bounds, Matrix3x2 const& transform)
bool RenderContext::CheckVisibility(Rect const& bounds, Matrix3x2 const& transform)
{
KGE_ASSERT(render_target_ && "Render target has not been initialized!");
KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
if (fast_global_transform_)
{
@ -481,17 +481,17 @@ namespace kiwano
return visible_size_.Intersects(Matrix3x2(transform * global_transform_).Transform(bounds));
}
void RenderTarget::Resize(Size const& size)
void RenderContext::Resize(Size const& size)
{
visible_size_ = Rect(Point(), size);
}
void RenderTarget::SetCollectingStatus(bool enable)
void RenderContext::SetCollectingStatus(bool enable)
{
collecting_status_ = enable;
}
void RenderTarget::IncreasePrimitivesCount(uint32_t increase) const
void RenderContext::IncreasePrimitivesCount(uint32_t increase) const
{
if (collecting_status_)
{
@ -501,14 +501,14 @@ namespace kiwano
//
// TextureRenderTarget
// TextureRenderContext
//
TextureRenderTarget::TextureRenderTarget()
TextureRenderContext::TextureRenderContext()
{
}
bool TextureRenderTarget::GetOutput(Texture& texture)
bool TextureRenderContext::GetOutput(Texture& texture)
{
HRESULT hr = E_FAIL;

66
src/kiwano/renderer/RenderTarget.h → src/kiwano/renderer/RenderContext.h
View File

@ -32,8 +32,8 @@ namespace kiwano
{
class Renderer;
KGE_DECLARE_SMART_PTR(RenderTarget);
KGE_DECLARE_SMART_PTR(TextureRenderTarget);
KGE_DECLARE_SMART_PTR(RenderContext);
KGE_DECLARE_SMART_PTR(TextureRenderContext);
/**
* \addtogroup Render
@ -52,9 +52,9 @@ namespace kiwano
/// \~chinese
/// @brief 渲染目标
/// @details 渲染目标将完成基础图元的绘制，并将绘制结果输出到特定的目标中（如窗口或纹理）
class KGE_API RenderTarget
/// @brief 渲染上下文
/// @details 渲染上下文将完成基础图元的绘制，并将绘制结果输出到特定的目标中（如窗口或纹理）
class KGE_API RenderContext
: public virtual ObjectBase
{
friend class Renderer;
@ -258,12 +258,12 @@ namespace kiwano
);
/// \~chinese
/// @brief 重设渲染目标大小
/// @brief 重设渲染上下文大小
void Resize(Size const& size);
public:
/// \~chinese
/// @brief 渲染目标状态
/// @brief 渲染上下文状态
struct Status
{
uint32_t primitives; ///< 渲染图元数量
@ -278,11 +278,11 @@ namespace kiwano
void SetCollectingStatus(bool enable);
/// \~chinese
/// @brief 获取渲染目标状态
/// @brief 获取渲染上下文状态
Status const& GetStatus() const;
protected:
RenderTarget();
RenderContext();
ComPtr<ID2D1RenderTarget> GetRenderTarget() const;
@ -291,7 +291,7 @@ namespace kiwano
private:
/// \~chinese
/// @brief 创建设备依赖资源
HRESULT CreateDeviceResources(ComPtr<ID2D1Factory> factory, ComPtr<ID2D1RenderTarget> rt);
HRESULT CreateDeviceResources(ComPtr<ID2D1Factory> factory, ComPtr<ID2D1RenderTarget> ctx);
/// \~chinese
/// @brief 销毁设备依赖资源
@ -307,7 +307,7 @@ namespace kiwano
float brush_opacity_;
TextAntialiasMode text_antialias_;
ComPtr<ITextRenderer> text_renderer_;
ComPtr<ID2D1RenderTarget> render_target_;
ComPtr<ID2D1RenderTarget> render_ctx_;
BrushPtr current_brush_;
Rect visible_size_;
Matrix3x2 global_transform_;
@ -318,10 +318,10 @@ namespace kiwano
/// \~chinese
/// @brief 纹理渲染目标
/// @details 纹理渲染目标将渲染输出到一个纹理对象中
class KGE_API TextureRenderTarget
: public RenderTarget
/// @brief 纹理渲染上下文
/// @details 纹理渲染上下文将渲染输出到一个纹理对象中
class KGE_API TextureRenderContext
: public RenderContext
{
friend class Renderer;
@ -337,11 +337,11 @@ namespace kiwano
bool GetOutput(Texture& texture);
private:
TextureRenderTarget();
TextureRenderContext();
ComPtr<ID2D1BitmapRenderTarget> GetBitmapRenderTarget() const;
void SetBitmapRenderTarget(ComPtr<ID2D1BitmapRenderTarget> rt);
void SetBitmapRenderTarget(ComPtr<ID2D1BitmapRenderTarget> ctx);
private:
ComPtr<ID2D1BitmapRenderTarget> bitmap_rt_;
@ -350,54 +350,54 @@ namespace kiwano
/** @} */
inline RenderTarget::Status::Status()
inline RenderContext::Status::Status()
: primitives(0)
{
}
inline RenderTarget::Status const& RenderTarget::GetStatus() const
inline RenderContext::Status const& RenderContext::GetStatus() const
{
return status_;
}
inline ComPtr<ID2D1RenderTarget> RenderTarget::GetRenderTarget() const
inline ComPtr<ID2D1RenderTarget> RenderContext::GetRenderTarget() const
{
KGE_ASSERT(render_target_);
return render_target_;
KGE_ASSERT(render_ctx_);
return render_ctx_;
}
inline ComPtr<ITextRenderer> RenderTarget::GetTextRenderer() const
inline ComPtr<ITextRenderer> RenderContext::GetTextRenderer() const
{
KGE_ASSERT(text_renderer_);
return text_renderer_;
}
inline float RenderTarget::GetBrushOpacity() const
inline float RenderContext::GetBrushOpacity() const
{
return brush_opacity_;
}
inline BrushPtr RenderTarget::GetCurrentBrush() const
inline BrushPtr RenderContext::GetCurrentBrush() const
{
return current_brush_;
}
inline Matrix3x2 RenderTarget::GetGlobalTransform() const
inline Matrix3x2 RenderContext::GetGlobalTransform() const
{
return global_transform_;
}
inline void RenderTarget::SetBrushOpacity(float opacity)
inline void RenderContext::SetBrushOpacity(float opacity)
{
brush_opacity_ = opacity;
}
inline void RenderTarget::SetGlobalTransform(const Matrix3x2& matrix)
inline void RenderContext::SetGlobalTransform(const Matrix3x2& matrix)
{
SetGlobalTransform(&matrix);
}
inline void RenderTarget::SetCurrentBrush(BrushPtr brush)
inline void RenderContext::SetCurrentBrush(BrushPtr brush)
{
current_brush_ = brush;
if (current_brush_)
@ -406,18 +406,18 @@ namespace kiwano
}
}
inline bool TextureRenderTarget::IsValid() const
inline bool TextureRenderContext::IsValid() const
{
return bitmap_rt_ != nullptr;
}
inline ComPtr<ID2D1BitmapRenderTarget> TextureRenderTarget::GetBitmapRenderTarget() const
inline ComPtr<ID2D1BitmapRenderTarget> TextureRenderContext::GetBitmapRenderTarget() const
{
return bitmap_rt_;
}
inline void TextureRenderTarget::SetBitmapRenderTarget(ComPtr<ID2D1BitmapRenderTarget> rt)
inline void TextureRenderContext::SetBitmapRenderTarget(ComPtr<ID2D1BitmapRenderTarget> ctx)
{
bitmap_rt_ = rt;
bitmap_rt_ = ctx;
}
}

10
src/kiwano/renderer/Renderer.cpp
View File

@ -188,7 +188,7 @@ namespace kiwano
HRESULT Renderer::HandleDeviceLost()
{
KGE_ASSERT(d3d_res_ && d2d_res_ && render_target_);
KGE_ASSERT(d3d_res_ && d2d_res_ && render_ctx_);
HRESULT hr = d3d_res_->HandleDeviceLost();
@ -828,7 +828,7 @@ namespace kiwano
win32::ThrowIfFailed(hr);
}
void Renderer::CreateTextureRenderTarget(TextureRenderTargetPtr& render_target)
void Renderer::CreateTextureRenderTarget(TextureRenderContextPtr& render_context)
{
HRESULT hr = S_OK;
if (!d2d_res_)
@ -836,7 +836,7 @@ namespace kiwano
hr = E_UNEXPECTED;
}
TextureRenderTargetPtr output;
TextureRenderContextPtr output;
if (SUCCEEDED(hr))
{
ComPtr<ID2D1BitmapRenderTarget> bitmap_rt;
@ -844,7 +844,7 @@ namespace kiwano
if (SUCCEEDED(hr))
{
output = new TextureRenderTarget;
output = new TextureRenderContext;
hr = output->CreateDeviceResources(d2d_res_->GetFactory(), bitmap_rt);
}
@ -856,7 +856,7 @@ namespace kiwano
if (SUCCEEDED(hr))
{
render_target = output;
render_context = output;
}
win32::ThrowIfFailed(hr);

10
src/kiwano/renderer/Renderer.h
View File

@ -21,7 +21,7 @@
#pragma once
#include <kiwano/core/Component.h>
#include <kiwano/renderer/win32/FontCollectionLoader.h>
#include <kiwano/renderer/RenderTarget.h>
#include <kiwano/renderer/RenderContext.h>
#include <kiwano/renderer/GifImage.h>
#include <kiwano/renderer/Font.h>
#include <kiwano/renderer/TextStyle.hpp>
@ -75,7 +75,7 @@ namespace kiwano
: public Singleton<Renderer>
, public RenderComponent
, public EventComponent
, public RenderTarget
, public RenderContext
{
friend Singleton<Renderer>;
@ -225,10 +225,10 @@ namespace kiwano
);
/// \~chinese
/// @brief 创建纹理渲染目标
/// @param[out] render_target 渲染目标
/// @brief 创建纹理渲染上下文
/// @param[out] render_context 渲染上下文
void CreateTextureRenderTarget(
TextureRenderTargetPtr& render_target
TextureRenderContextPtr& render_context
);
/// \~chinese

4
src/kiwano/renderer/StrokeStyle.h
View File

@ -23,7 +23,7 @@
namespace kiwano
{
class RenderTarget;
class RenderContext;
class Renderer;
/**
@ -68,7 +68,7 @@ namespace kiwano
/// @brief ÏßÌõÑùʽ
class StrokeStyle
{
friend class RenderTarget;
friend class RenderContext;
friend class Renderer;
public:

4
src/kiwano/renderer/TextLayout.h
View File

@ -24,7 +24,7 @@
namespace kiwano
{
class RenderTarget;
class RenderContext;
class Renderer;
/**
@ -36,7 +36,7 @@ namespace kiwano
/// @brief 文本布局
class KGE_API TextLayout
{
friend class RenderTarget;
friend class RenderContext;
friend class Renderer;
public:

8
src/kiwano/renderer/Texture.h
View File

@ -24,8 +24,8 @@
namespace kiwano
{
class RenderTarget;
class TextureRenderTarget;
class RenderContext;
class TextureRenderContext;
class Renderer;
KGE_DECLARE_SMART_PTR(Texture);
@ -53,8 +53,8 @@ namespace kiwano
class KGE_API Texture
: public virtual ObjectBase
{
friend class RenderTarget;
friend class TextureRenderTarget;
friend class RenderContext;
friend class TextureRenderContext;
friend class Renderer;
public: