Rename RenderTarget to RenderContext

projects/kiwano/kiwano.vcxproj

@@ -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" />

projects/kiwano/kiwano.vcxproj.filters

@@ -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>

src/3rd-party/OuterC/oc/intrusive_list.h

@@ -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 pointer = _PTy;
-	using const_pointer_type	= const _PTy;
 
-	intrusive_list_item()					: prev_(nullptr), next_(nullptr) {}
+	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(pointer rhs)	: prev_(nullptr), next_(nullptr) { if (rhs) { prev_ = rhs->prev_; next_ = rhs->next_; } }
 
-	const_pointer_type	prev_item() const	{ return prev_; }
+	const pointer	prev_item() const	{ return prev_; }
-	pointer_type		prev_item()			{ return prev_; }
+	pointer			prev_item()			{ return prev_; }
-	const_pointer_type	next_item() const	{ return next_; }
+	const pointer	next_item() const	{ return next_; }
-	pointer_type		next_item()			{ return next_; }
+	pointer			next_item()			{ return next_; }
 
 private:
-	pointer_type prev_;
+	pointer prev_;
-	pointer_type next_;
+	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 value_type	= typename std::pointer_traits<_PTy>::element_type;
-	using const_pointer_type	= const _PTy;
+	using pointer		= _PTy;
+	using reference		= value_type&;
 
-	intrusive_list()							: first_(), last_() {}
+	intrusive_list()						: first_(), last_() {}
-	~intrusive_list()							{ clear(); }
+	~intrusive_list()						{ clear(); }
 
-	const_pointer_type	first_item() const		{ return first_; }
+	const pointer	first_item() const		{ return first_; }
-	pointer_type		first_item()			{ return first_; }
+	pointer			first_item()			{ return first_; }
-	const_pointer_type	last_item() const		{ return last_; }
+	const pointer	last_item() const		{ return last_; }
-	pointer_type		last_item()				{ 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 p = first_;
-		pointer_type tmp = p;
+		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 value_type			= typename std::pointer_traits<_PTy>::element_type;
-		using const_pointer_type	= const _PTy;
+		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 pointer			base() const									{ OC_ASSERT(!is_end_); return const_cast<pointer&>(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 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 iterator					= iterator_impl<pointer>;
-	using const_iterator			= iterator_impl<const pointer_type>;
+	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 pointer					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 const pointer			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 pointer					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 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 first_;
-	pointer_type last_;
+	pointer last_;
 };
 
 }  // namespace oc

src/kiwano-imgui/ImGuiLayer.cpp

@@ -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();

src/kiwano-imgui/ImGuiLayer.h

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

src/kiwano/2d/Actor.cpp

@@ -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);
+				PrepareToRender(ctx);
-				OnRender(rt);
+				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);
+				PrepareToRender(ctx);
-				OnRender(rt);
+				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_);
+		ctx.SetTransform(transform_matrix_);
-		rt->SetBrushOpacity(GetDisplayedOpacity());
+		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());
+			ctx.SetCurrentBrush(GetStage()->GetBorderFillBrush());
-			rt->FillRectangle(bounds);
+			ctx.FillRectangle(bounds);
 
-			rt->SetCurrentBrush(GetStage()->GetBorderStrokeBrush());
+			ctx.SetCurrentBrush(GetStage()->GetBorderStrokeBrush());
-			rt->DrawRectangle(bounds, 2.f);
+			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_;

src/kiwano/2d/Actor.h

@@ -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 渲染目标
+		/// @param ctx 渲染上下文
-		virtual void OnRender(RenderTarget* rt);
+		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 检查是否在渲染目标的视区内
+		/// @brief 检查是否在渲染上下文的视区内
-		virtual bool CheckVisibilty(RenderTarget* rt) const;
+		virtual bool CheckVisibilty(RenderContext& ctx) const;
 
 		/// \~chinese
-		/// @brief 渲染前初始化渲染目标状态，仅当 CheckVisibilty 返回真时调用该函数
+		/// @brief 渲染前初始化渲染上下文状态，仅当 CheckVisibilty 返回真时调用该函数
-		virtual void PrepareToRender(RenderTarget* rt);
+		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

src/kiwano/2d/Canvas.cpp

@@ -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_);
+		ctx_->SetCurrentBrush(stroke_brush_);
-		rt_->DrawLine(
+		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_);
+		ctx_->SetCurrentBrush(stroke_brush_);
-		rt_->DrawEllipse(
+		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_);
+		ctx_->SetCurrentBrush(stroke_brush_);
-		rt_->DrawEllipse(
+		ctx_->DrawEllipse(
 			center,
 			radius,
 			stroke_width_,
@@ -150,8 +150,8 @@ namespace kiwano
 	void Canvas::DrawRect(Rect const& rect)
 	{
 		InitRenderTargetAndBrushs();
-		rt_->SetCurrentBrush(stroke_brush_);
+		ctx_->SetCurrentBrush(stroke_brush_);
-		rt_->DrawRectangle(
+		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_);
+		ctx_->SetCurrentBrush(stroke_brush_);
-		rt_->DrawRoundedRectangle(
+		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_);
+		ctx_->SetCurrentBrush(fill_brush_);
-		rt_->FillEllipse(
+		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_);
+		ctx_->SetCurrentBrush(fill_brush_);
-		rt_->FillEllipse(
+		ctx_->FillEllipse(
 			center,
 			radius
 		);
@@ -197,8 +197,8 @@ namespace kiwano
 	void Canvas::FillRect(Rect const& rect)
 	{
 		InitRenderTargetAndBrushs();
-		rt_->SetCurrentBrush(fill_brush_);
+		ctx_->SetCurrentBrush(fill_brush_);
-		rt_->FillRectangle(
+		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_);
+		ctx_->SetCurrentBrush(fill_brush_);
-		rt_->FillRoundedRectangle(
+		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_);
+		ctx_->SetCurrentBrush(stroke_brush_);
-		rt_->DrawGeometry(
+		ctx_->DrawGeometry(
 			geo_sink_.GetGeometry(),
 			stroke_width_,
 			stroke_style_
@@ -287,8 +287,8 @@ namespace kiwano
 	void Canvas::FillPath()
 	{
 		InitRenderTargetAndBrushs();
-		rt_->SetCurrentBrush(fill_brush_);
+		ctx_->SetCurrentBrush(fill_brush_);
-		rt_->FillGeometry(
+		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;
 			}

src/kiwano/2d/Canvas.h

@@ -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_;
 	};
 
 	/** @} */

src/kiwano/2d/DebugActor.cpp

@@ -75,12 +75,11 @@ namespace kiwano
 	{
 	}
 
-	void DebugActor::OnRender(RenderTarget* rt)
+	void DebugActor::OnRender(RenderContext& ctx)
 	{
-		rt->SetCurrentBrush(background_brush_);
+		ctx.SetCurrentBrush(background_brush_);
-		rt->FillRoundedRectangle(GetBounds(), Vec2{ 5.f, 5.f });
+		ctx.FillRoundedRectangle(GetBounds(), Vec2{ 5.f, 5.f });
-
+		ctx.DrawTextLayout(debug_text_, Point(10, 10));
-		rt->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;
 	}

src/kiwano/2d/DebugActor.h

@@ -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_;

src/kiwano/2d/GifSprite.cpp

@@ -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);
 		}
 	}
 

src/kiwano/2d/GifSprite.h

@@ -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_;
 	};
 
 	/** @} */

src/kiwano/2d/Layer.cpp

@@ -61,10 +61,8 @@ namespace kiwano
 
 		if (!swallow_)
 		{
-			ActorPtr prev;
+			for (auto child = GetAllChildren().rbegin(); child != GetAllChildren().rend(); ++child)
-			for (auto child = GetAllChildren().last_item(); child; child = prev)
 			{
-				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;

src/kiwano/2d/Layer.h

@@ -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_;

src/kiwano/2d/ShapeActor.cpp

@@ -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_);
+		ctx.SetCurrentBrush(stroke_brush_);
-		rt->DrawGeometry(geo_, stroke_width_ * 2 /* twice width for widening */, stroke_style_);
+		ctx.DrawGeometry(geo_, stroke_width_ * 2 /* twice width for widening */, stroke_style_);
 
-		rt->SetCurrentBrush(fill_brush_);
+		ctx.SetCurrentBrush(fill_brush_);
-		rt->FillGeometry(geo_);
+		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);
 	}
 
 	//-------------------------------------------------------

src/kiwano/2d/ShapeActor.h

@@ -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_;

src/kiwano/2d/Sprite.cpp

@@ -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);
 	}
 }

src/kiwano/2d/Sprite.h

@@ -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_;

src/kiwano/2d/Stage.cpp

@@ -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);
 	}
 
 }

src/kiwano/2d/Stage.h

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

src/kiwano/2d/TextActor.cpp

@@ -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)

src/kiwano/2d/TextActor.h

@@ -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_;

src/kiwano/2d/Transition.cpp

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

src/kiwano/2d/Transition.h

@@ -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

src/kiwano/2d/action/ActionManager.cpp

@@ -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_;

src/kiwano/2d/action/ActionManager.h

@@ -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;

src/kiwano/core/Component.h

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

src/kiwano/core/EventDispatcher.cpp

@@ -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();
 		}
 	}
 

src/kiwano/core/TimerManager.cpp

@@ -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();
 		}
 	}
 

src/kiwano/platform/Application.cpp

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

src/kiwano/platform/Director.cpp

@@ -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);
 		}
 	}
 

src/kiwano/platform/Director.h

@@ -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;
 

src/kiwano/renderer/Brush.h

@@ -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:

src/kiwano/renderer/Geometry.h

@@ -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;
 

src/kiwano/renderer/GeometrySink.h

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

src/kiwano/renderer/LayerArea.h

@@ -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();

src/kiwano/renderer/RenderContext.cpp

@@ -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!");
+		KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
-		render_target_->PushAxisAlignedClip(
+		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!");
+		KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
-		render_target_->PopAxisAlignedClip();
+		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!");
+		KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
-		render_target_->PopLayer();
+		render_ctx_->PopLayer();
 	}
 
-	void RenderTarget::Clear()
+	void RenderContext::Clear()
 	{
-		KGE_ASSERT(render_target_ && "Render target has not been initialized!");
+		KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
-		render_target_->Clear();
+		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!");
+		KGE_ASSERT(render_ctx_ && "Render target has not been initialized!");
-		render_target_->Clear(DX::ConvertToColorF(clear_color));
+		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;
 

src/kiwano/renderer/RenderContext.h

@@ -32,8 +32,8 @@ namespace kiwano
 {
 	class Renderer;
 
-	KGE_DECLARE_SMART_PTR(RenderTarget);
+	KGE_DECLARE_SMART_PTR(RenderContext);
-	KGE_DECLARE_SMART_PTR(TextureRenderTarget);
+	KGE_DECLARE_SMART_PTR(TextureRenderContext);
 
 	/**
 	* \addtogroup Render
@@ -52,9 +52,9 @@ namespace kiwano
 
 
 	/// \~chinese
-	/// @brief 渲染目标
+	/// @brief 渲染上下文
-	/// @details 渲染目标将完成基础图元的绘制，并将绘制结果输出到特定的目标中（如窗口或纹理）
+	/// @details 渲染上下文将完成基础图元的绘制，并将绘制结果输出到特定的目标中（如窗口或纹理）
-	class KGE_API RenderTarget
+	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 纹理渲染目标
+	/// @brief 纹理渲染上下文
-	/// @details 纹理渲染目标将渲染输出到一个纹理对象中
+	/// @details 纹理渲染上下文将渲染输出到一个纹理对象中
-	class KGE_API TextureRenderTarget
+	class KGE_API TextureRenderContext
-		: public RenderTarget
+		: 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_);
+		KGE_ASSERT(render_ctx_);
-		return render_target_;
+		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;
 	}
 }

src/kiwano/renderer/Renderer.cpp

@@ -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);

src/kiwano/renderer/Renderer.h

@@ -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 创建纹理渲染目标
+		/// @brief 创建纹理渲染上下文
-		/// @param[out] render_target 渲染目标
+		/// @param[out] render_context 渲染上下文
 		void CreateTextureRenderTarget(
-			TextureRenderTargetPtr& render_target
+			TextureRenderContextPtr& render_context
 		);
 
 		/// \~chinese

src/kiwano/renderer/StrokeStyle.h

@@ -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:

src/kiwano/renderer/TextLayout.h

@@ -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:

src/kiwano/renderer/Texture.h

@@ -24,8 +24,8 @@
 
 namespace kiwano
 {
-	class RenderTarget;
+	class RenderContext;
-	class TextureRenderTarget;
+	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 RenderContext;
-		friend class TextureRenderTarget;
+		friend class TextureRenderContext;
 		friend class Renderer;
 
 	public: