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

移除Collision类；ColliderManager更名为CollisionManager

This commit is contained in:
Nomango 2018-07-08 16:57:12 +08:00
parent 295bf44f40
commit 7e31505529
14 changed files with 446 additions and 478 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core/Base/GC.cpp
View File

@ -57,7 +57,7 @@ e2d::GC::~GC()
Player::destroyInstance();
SceneManager::destroyInstance();
ActionManager::destroyInstance();
ColliderManager::destroyInstance();
CollisionManager::destroyInstance();
}

7
core/Base/Game.cpp
View File

@ -1,7 +1,6 @@
#include "..\e2dbase.h"
#include "..\e2dmanager.h"
#include "..\e2dtool.h"
#include "..\e2dcollider.h"
e2d::Game * e2d::Game::_instance = nullptr;
@ -45,7 +44,7 @@ void e2d::Game::start(bool cleanup)
auto timer = Timer::getInstance();
auto sceneManager = SceneManager::getInstance();
auto actionManager = ActionManager::getInstance();
auto colliderManager = ColliderManager::getInstance();
auto collisionManager = CollisionManager::getInstance();
// 显示窗口
::ShowWindow(window->getHWnd(), SW_SHOWNORMAL);
@ -77,7 +76,7 @@ void e2d::Game::start(bool cleanup)
timer->update(); // 更新定时器
actionManager->update(); // 更新动作管理器
sceneManager->update(); // 更新场景内容
colliderManager->update(); // 更新碰撞体
collisionManager->update(); // 更新碰撞体
renderer->render(); // 渲染游戏画面
GC::flush(); // 刷新内存池
@ -148,7 +147,7 @@ void e2d::Game::cleanup()
// 清除所有动作
ActionManager::getInstance()->clearAll();
// 删除碰撞监听器
Collision::clearAllListeners();
CollisionManager::getInstance()->clearAllListeners();
// 删除输入监听器
Input::clearAllListeners();
// 清空图片缓存

229
core/Collider/Collision.cpp
View File

@ -1,229 +0,0 @@
#include "..\e2dcollider.h"
#include "..\e2dnode.h"
#include "..\e2dtool.h"
typedef std::pair<UINT, UINT> HashPair;
static std::vector<e2d::Listener*> s_vListeners; // 监听器容器
static e2d::Node * s_pActiveNode = nullptr; // 主动碰撞体
static e2d::Node * s_pPassiveNode = nullptr; // 被动碰撞体
static std::set<HashPair> s_sCollisionList; // 碰撞映射
void e2d::Collision::addName(const String & name1, const String & name2)
{
if (!name1.isEmpty() && !name2.isEmpty())
{
s_sCollisionList.insert(HashPair(name1.getHashCode(), name2.getHashCode()));
}
}
void e2d::Collision::addName(const std::vector<std::pair<String, String> >& names)
{
for (auto& name : names)
{
if (!name.first.isEmpty() && !name.second.isEmpty())
{
s_sCollisionList.insert(HashPair(name.first.getHashCode(), name.second.getHashCode()));
}
}
}
bool e2d::Collision::isCollidable(Node * node1, Node * node2)
{
return Collision::isCollidable(node1->getName(), node2->getName());
}
bool e2d::Collision::isCollidable(const String & name1, const String & name2)
{
UINT hashName1 = name1.getHashCode(), hashName2 = name2.getHashCode();
HashPair pair1 = HashPair(hashName1, hashName2), pair2 = HashPair(hashName2, hashName1);
for (auto& pair : s_sCollisionList)
{
if (pair == pair1 || pair == pair2)
{
return true;
}
}
return false;
}
e2d::Node * e2d::Collision::getActiveNode()
{
return s_pActiveNode;
}
e2d::Node * e2d::Collision::getPassiveNode()
{
return s_pPassiveNode;
}
bool e2d::Collision::isCausedBy(const String & name1, const String & name2)
{
String activeName = s_pActiveNode->getName();
String passiveName = s_pPassiveNode->getName();
return (activeName == name1 && passiveName == name2) ||
(activeName == name2 && passiveName == name1);
}
bool e2d::Collision::isCausedBy(Node * node1, Node * node2)
{
return (s_pActiveNode == node1 && s_pPassiveNode == node2) ||
(s_pActiveNode == node2 && s_pPassiveNode == node1);
}
e2d::Node* e2d::Collision::isCausedBy(Node * node)
{
if (s_pActiveNode == node)
return s_pPassiveNode;
if (s_pPassiveNode == node)
return s_pActiveNode;
return nullptr;
}
e2d::Node* e2d::Collision::isCausedBy(const String& name)
{
if (s_pActiveNode->getName() == name)
return s_pActiveNode;
if (s_pPassiveNode->getName() == name)
return s_pPassiveNode;
return nullptr;
}
void e2d::Collision::__update(Node * active, Node * passive)
{
if (s_vListeners.empty() || Game::getInstance()->isPaused())
return;
s_pActiveNode = active;
s_pPassiveNode = passive;
for (size_t i = 0; i < s_vListeners.size(); ++i)
{
auto listener = s_vListeners[i];
// 清除已停止的监听器
if (listener->_stopped)
{
GC::safeRelease(listener);
s_vListeners.erase(s_vListeners.begin() + i);
}
else
{
// 更新监听器
listener->_update();
++i;
}
}
s_pActiveNode = nullptr;
s_pPassiveNode = nullptr;
}
e2d::Listener * e2d::Collision::addListener(const Function& func, const String& name, bool paused)
{
auto listener = new (e2d::autorelease) Listener(func, name, paused);
GC::retain(listener);
s_vListeners.push_back(listener);
return listener;
}
void e2d::Collision::addListener(Listener * listener)
{
if (listener)
{
auto iter = std::find(s_vListeners.begin(), s_vListeners.end(), listener);
if (iter == s_vListeners.end())
{
GC::retain(listener);
s_vListeners.push_back(listener);
}
}
}
void e2d::Collision::removeListener(Listener * listener)
{
if (listener)
{
auto iter = std::find(s_vListeners.begin(), s_vListeners.end(), listener);
if (iter != s_vListeners.end())
{
GC::safeRelease(listener);
s_vListeners.erase(iter);
}
}
}
void e2d::Collision::stopListener(const String& name)
{
if (s_vListeners.empty() || name.isEmpty())
return;
for (auto listener : s_vListeners)
{
if (listener->_name == name)
{
listener->stop();
}
}
}
void e2d::Collision::startListener(const String& name)
{
if (s_vListeners.empty() || name.isEmpty())
return;
for (auto listener : s_vListeners)
{
if (listener->_name == name)
{
listener->start();
}
}
}
void e2d::Collision::removeListener(const String& name)
{
if (s_vListeners.empty() || name.isEmpty())
return;
for (auto listener : s_vListeners)
{
if (listener->_name == name)
{
listener->_stopped = true;
}
}
}
void e2d::Collision::stopAllListeners()
{
for (auto listener : s_vListeners)
{
listener->stop();
}
}
void e2d::Collision::startAllListeners()
{
for (auto listener : s_vListeners)
{
listener->start();
}
}
void e2d::Collision::removeAllListeners()
{
for (auto listener : s_vListeners)
{
listener->_stopped = true;
}
}
void e2d::Collision::clearAllListeners()
{
for (auto listener : s_vListeners)
{
GC::release(listener);
}
s_vListeners.clear();
}

2
core/Common/Collider.cpp
View File

@ -1,4 +1,4 @@
#include "..\e2dcollider.h"
#include "..\e2dcommon.h"
#include "..\e2dmanager.h"
#include "..\e2dnode.h"

92
core/Manager/ColliderManager.cpp
View File

@ -1,92 +0,0 @@
#include "..\e2dmanager.h"
#include "..\e2dnode.h"
#include "..\e2dcollider.h"
e2d::ColliderManager * e2d::ColliderManager::_instance = nullptr;
e2d::ColliderManager * e2d::ColliderManager::getInstance()
{
if (!_instance)
_instance = new (std::nothrow) ColliderManager;
return _instance;
}
void e2d::ColliderManager::destroyInstance()
{
if (_instance)
{
delete _instance;
_instance = nullptr;
}
}
e2d::ColliderManager::ColliderManager()
{
}
e2d::ColliderManager::~ColliderManager()
{
}
void e2d::ColliderManager::__remove(Node * node)
{
if (node)
{
auto iter = std::find(_nodes.begin(), _nodes.end(), node);
if (iter != _nodes.end())
{
_nodes.erase(iter);
}
}
}
void e2d::ColliderManager::updateCollider(Node * node)
{
if (node)
{
if (node->getCollider()->_type != Collider::Type::None)
{
node->getCollider()->_recreate();
_nodes.insert(node);
}
}
}
void e2d::ColliderManager::update()
{
// 判断碰撞监听是否打开
if (Game::getInstance()->isPaused() ||
!Game::getInstance()->getConfig()->isCollisionEnabled() ||
SceneManager::getInstance()->isTransitioning())
{
_nodes.clear();
return;
}
for (auto iter1 = _nodes.begin(); iter1 != _nodes.end(); iter1++)
{
auto node1 = (*iter1);
// 判断与其他碰撞体的交集情况
auto iter2 = iter1;
iter2++;
for (; iter2 != _nodes.end(); iter2++)
{
auto node2 = (*iter2);
// 判断两物体是否是相互冲突的物体
if (Collision::isCollidable(node1, node2))
{
// 判断两碰撞体交集情况
Collider::Relation relation = node1->getCollider()->getRelationWith(node2->getCollider());
// 忽略 UNKNOWN 和 DISJOIN 情况
if (relation != Collider::Relation::Unknown &&
relation != Collider::Relation::Disjoin)
{
// 更新碰撞监听器
Collision::__update(node1, node2);
}
}
}
}
_nodes.clear();
}

312
core/Manager/CollisionManager.cpp Normal file
View File

@ -0,0 +1,312 @@
#include "..\e2dmanager.h"
#include "..\e2dnode.h"
#include "..\e2dtool.h"
e2d::CollisionManager * e2d::CollisionManager::_instance = nullptr;
e2d::CollisionManager * e2d::CollisionManager::getInstance()
{
if (!_instance)
_instance = new (std::nothrow) CollisionManager;
return _instance;
}
void e2d::CollisionManager::destroyInstance()
{
if (_instance)
{
delete _instance;
_instance = nullptr;
}
}
e2d::CollisionManager::CollisionManager()
: _activeNode(nullptr)
, _passiveNode(nullptr)
{
}
e2d::CollisionManager::~CollisionManager()
{
}
void e2d::CollisionManager::__remove(Node * node)
{
if (node)
{
auto iter = std::find(_collisionNodes.begin(), _collisionNodes.end(), node);
if (iter != _collisionNodes.end())
{
_collisionNodes.erase(iter);
}
}
}
void e2d::CollisionManager::updateCollider(Node * node)
{
if (node)
{
if (node->getCollider()->_type != Collider::Type::None)
{
node->getCollider()->_recreate();
_collisionNodes.insert(node);
}
}
}
void e2d::CollisionManager::update()
{
// 判断碰撞监听是否打开
if (Game::getInstance()->isPaused() ||
!Game::getInstance()->getConfig()->isCollisionEnabled() ||
SceneManager::getInstance()->isTransitioning())
{
_collisionNodes.clear();
return;
}
for (auto iter1 = _collisionNodes.begin(); iter1 != _collisionNodes.end(); iter1++)
{
auto node1 = (*iter1);
// 判断与其他碰撞体的交集情况
auto iter2 = iter1;
iter2++;
for (; iter2 != _collisionNodes.end(); iter2++)
{
auto node2 = (*iter2);
// 判断两物体是否是相互冲突的物体
if (CollisionManager::isCollidable(node1, node2))
{
// 判断两碰撞体交集情况
Collider::Relation relation = node1->getCollider()->getRelationWith(node2->getCollider());
// 忽略 UNKNOWN 和 DISJOIN 情况
if (relation != Collider::Relation::Unknown &&
relation != Collider::Relation::Disjoin)
{
// 更新碰撞监听器
CollisionManager::__update(node1, node2);
}
}
}
}
_collisionNodes.clear();
}
void e2d::CollisionManager::addName(const String & name1, const String & name2)
{
if (!name1.isEmpty() && !name2.isEmpty())
{
_collisionList.insert(HashPair(name1.getHashCode(), name2.getHashCode()));
}
}
void e2d::CollisionManager::addName(const std::vector<std::pair<String, String> >& names)
{
for (auto& name : names)
{
if (!name.first.isEmpty() && !name.second.isEmpty())
{
_collisionList.insert(HashPair(name.first.getHashCode(), name.second.getHashCode()));
}
}
}
bool e2d::CollisionManager::isCollidable(Node * node1, Node * node2)
{
return CollisionManager::isCollidable(node1->getName(), node2->getName());
}
bool e2d::CollisionManager::isCollidable(const String & name1, const String & name2)
{
UINT hashName1 = name1.getHashCode(), hashName2 = name2.getHashCode();
HashPair pair1 = HashPair(hashName1, hashName2), pair2 = HashPair(hashName2, hashName1);
for (auto& pair : _collisionList)
{
if (pair == pair1 || pair == pair2)
{
return true;
}
}
return false;
}
e2d::Node * e2d::CollisionManager::getActiveNode()
{
return _activeNode;
}
e2d::Node * e2d::CollisionManager::getPassiveNode()
{
return _passiveNode;
}
bool e2d::CollisionManager::isCausedBy(const String & name1, const String & name2)
{
String activeName = _activeNode->getName();
String passiveName = _passiveNode->getName();
return (activeName == name1 && passiveName == name2) ||
(activeName == name2 && passiveName == name1);
}
bool e2d::CollisionManager::isCausedBy(Node * node1, Node * node2)
{
return (_activeNode == node1 && _passiveNode == node2) ||
(_activeNode == node2 && _passiveNode == node1);
}
e2d::Node* e2d::CollisionManager::isCausedBy(Node * node)
{
if (_activeNode == node)
return _passiveNode;
if (_passiveNode == node)
return _activeNode;
return nullptr;
}
e2d::Node* e2d::CollisionManager::isCausedBy(const String& name)
{
if (_activeNode->getName() == name)
return _activeNode;
if (_passiveNode->getName() == name)
return _passiveNode;
return nullptr;
}
void e2d::CollisionManager::__update(Node * active, Node * passive)
{
if (_listeners.empty() || Game::getInstance()->isPaused())
return;
_activeNode = active;
_passiveNode = passive;
for (size_t i = 0; i < _listeners.size(); ++i)
{
auto listener = _listeners[i];
// 清除已停止的监听器
if (listener->_stopped)
{
GC::safeRelease(listener);
_listeners.erase(_listeners.begin() + i);
}
else
{
// 更新监听器
listener->_update();
++i;
}
}
_activeNode = nullptr;
_passiveNode = nullptr;
}
e2d::Listener * e2d::CollisionManager::addListener(const Function& func, const String& name, bool paused)
{
auto listener = new (e2d::autorelease) Listener(func, name, paused);
GC::retain(listener);
_listeners.push_back(listener);
return listener;
}
void e2d::CollisionManager::addListener(Listener * listener)
{
if (listener)
{
auto iter = std::find(_listeners.begin(), _listeners.end(), listener);
if (iter == _listeners.end())
{
GC::retain(listener);
_listeners.push_back(listener);
}
}
}
void e2d::CollisionManager::removeListener(Listener * listener)
{
if (listener)
{
auto iter = std::find(_listeners.begin(), _listeners.end(), listener);
if (iter != _listeners.end())
{
GC::safeRelease(listener);
_listeners.erase(iter);
}
}
}
void e2d::CollisionManager::stopListener(const String& name)
{
if (_listeners.empty() || name.isEmpty())
return;
for (auto listener : _listeners)
{
if (listener->_name == name)
{
listener->stop();
}
}
}
void e2d::CollisionManager::startListener(const String& name)
{
if (_listeners.empty() || name.isEmpty())
return;
for (auto listener : _listeners)
{
if (listener->_name == name)
{
listener->start();
}
}
}
void e2d::CollisionManager::removeListener(const String& name)
{
if (_listeners.empty() || name.isEmpty())
return;
for (auto listener : _listeners)
{
if (listener->_name == name)
{
listener->_stopped = true;
}
}
}
void e2d::CollisionManager::stopAllListeners()
{
for (auto listener : _listeners)
{
listener->stop();
}
}
void e2d::CollisionManager::startAllListeners()
{
for (auto listener : _listeners)
{
listener->start();
}
}
void e2d::CollisionManager::removeAllListeners()
{
for (auto listener : _listeners)
{
listener->_stopped = true;
}
}
void e2d::CollisionManager::clearAllListeners()
{
for (auto listener : _listeners)
{
GC::release(listener);
}
_listeners.clear();
}

4
core/Node/Node.cpp
View File

@ -43,7 +43,7 @@ e2d::Node::~Node()
SafeRelease(_outline);
ActionManager::getInstance()->clearAllBindedWith(this);
ColliderManager::getInstance()->__remove(this);
CollisionManager::getInstance()->__remove(this);
for (auto child : _children)
{
GC::release(child);
@ -234,7 +234,7 @@ void e2d::Node::_updateTransform()
_outline = transformedGeo;
// 更新碰撞体
ColliderManager::getInstance()->updateCollider(this);
CollisionManager::getInstance()->updateCollider(this);
// 标志已执行过变换
_needTransform = false;

123
core/e2dcollider.h
View File

@ -1,123 +0,0 @@
#pragma once
#include "e2dbase.h"
namespace e2d
{
class Node;
class Listener;
class ColliderManager;
// 碰撞事件
class Collision
{
friend class ColliderManager;
public:
// 添加可互相碰撞物体的名称
static void addName(
const String& name1,
const String& name2
);
// 添加可互相碰撞物体的名称
static void addName(
const std::vector<std::pair<String, String> >& names
);
// 判断两个物体是否是可碰撞的
static bool isCollidable(
Node * node1,
Node * node2
);
// 判断两个物体是否是可碰撞的
static bool isCollidable(
const String& name1,
const String& name2
);
// 获取碰撞发生时的主动体
static Node * getActiveNode();
// 获取碰撞发生时的被动体
static Node * getPassiveNode();
// 判断发生碰撞的节点名称是否相同
static bool isCausedBy(
const String& name1,
const String& name2
);
// 判断两物体是否发生碰撞
static bool isCausedBy(
Node * node1,
Node * node2
);
// 判断发生碰撞的任意一方名称是否相同
// 若相同，返回其指针，否则返回空
static Node * isCausedBy(
const String& name
);
// 判断物体是否发生碰撞
// 如果是，返回与其相撞的节点指针，否则返回空
static Node * isCausedBy(
Node * node
);
// 添加碰撞监听
static Listener * addListener(
const Function& func, /* 监听到碰撞时的执行函数 */
const String& name = L"", /* 监听器名称 */
bool paused = false /* 是否暂停 */
);
// 添加碰撞监听
static void addListener(
Listener * listener /* 监听器 */
);
// 移除监听器
static void removeListener(
Listener * listener /* 监听器 */
);
// 启动碰撞监听
static void startListener(
const String& name
);
// 停止碰撞监听
static void stopListener(
const String& name
);
// 移除碰撞监听
static void removeListener(
const String& name
);
// 启动所有监听器
static void startAllListeners();
// 停止所有监听器
static void stopAllListeners();
// 移除所有监听器
static void removeAllListeners();
// 强制清除所有监听器
static void clearAllListeners();
private:
// 更新监听器
static void __update(
Node * active,
Node * passive
);
};
}

4
core/e2dcommon.h
View File

@ -441,13 +441,13 @@ public:
class Node;
class ColliderManager;
class CollisionManager;
// ÅöײÌå
class Collider
{
friend class Node;
friend class ColliderManager;
friend class CollisionManager;
public:
// ÅöײÌåÀà±ð

127
core/e2dmanager.h
View File

@ -170,18 +170,117 @@ private:
};
class Listener;
// 碰撞体管理器
class ColliderManager
class CollisionManager
{
friend class Node;
public:
// 获取碰撞体管理器实例
static ColliderManager * getInstance();
static CollisionManager * getInstance();
// 销毁实例
static void destroyInstance();
// 添加可互相碰撞物体的名称
void addName(
const String& name1,
const String& name2
);
// 添加可互相碰撞物体的名称
void addName(
const std::vector<std::pair<String, String> >& names
);
// 判断两个物体是否是可碰撞的
bool isCollidable(
Node * node1,
Node * node2
);
// 判断两个物体是否是可碰撞的
bool isCollidable(
const String& name1,
const String& name2
);
// 获取碰撞发生时的主动体
Node * getActiveNode();
// 获取碰撞发生时的被动体
Node * getPassiveNode();
// 判断发生碰撞的节点名称是否相同
bool isCausedBy(
const String& name1,
const String& name2
);
// 判断两物体是否发生碰撞
bool isCausedBy(
Node * node1,
Node * node2
);
// 判断发生碰撞的任意一方名称是否相同
// 若相同，返回其指针，否则返回空
Node * isCausedBy(
const String& name
);
// 判断物体是否发生碰撞
// 如果是，返回与其相撞的节点指针，否则返回空
Node * isCausedBy(
Node * node
);
// 添加碰撞监听
Listener * addListener(
const Function& func, /* 监听到碰撞时的执行函数 */
const String& name = L"", /* 监听器名称 */
bool paused = false /* 是否暂停 */
);
// 添加碰撞监听
void addListener(
Listener * listener /* 监听器 */
);
// 移除监听器
void removeListener(
Listener * listener /* 监听器 */
);
// 启动碰撞监听
void startListener(
const String& name
);
// 停止碰撞监听
void stopListener(
const String& name
);
// 移除碰撞监听
void removeListener(
const String& name
);
// 启动所有监听器
void startAllListeners();
// 停止所有监听器
void stopAllListeners();
// 移除所有监听器
void removeAllListeners();
// 强制清除所有监听器
void clearAllListeners();
// 更新碰撞体
void updateCollider(
Node * node
@ -191,20 +290,32 @@ public:
void update();
private:
ColliderManager();
CollisionManager();
~ColliderManager();
~CollisionManager();
E2D_DISABLE_COPY(ColliderManager);
E2D_DISABLE_COPY(CollisionManager);
void __remove(
Node* node
);
private:
std::set<Node*> _nodes;
// 更新监听器
void __update(
Node * active,
Node * passive
);
static ColliderManager * _instance;
private:
typedef std::pair<UINT, UINT> HashPair;
e2d::Node * _activeNode;
e2d::Node * _passiveNode;
std::set<Node*> _collisionNodes;
std::set<HashPair> _collisionList;
std::vector<Listener*> _listeners;
static CollisionManager * _instance;
};
}

4
core/e2dtool.h
View File

@ -377,14 +377,14 @@ private:
};
class Collision;
class CollisionManager;
// 监听器
class Listener :
public Ref
{
friend class Input;
friend class Collision;
friend class CollisionManager;
public:
Listener();

1
core/easy2d.h
View File

@ -26,7 +26,6 @@
#include "e2dtool.h"
#include "e2daction.h"
#include "e2dtransition.h"
#include "e2dcollider.h"
#if defined(DEBUG) || defined(_DEBUG)

4
project/vs2017/Easy2D.vcxproj
View File

@ -221,7 +221,6 @@
<ClCompile Include="..\..\core\Base\Renderer.cpp" />
<ClCompile Include="..\..\core\Base\Time.cpp" />
<ClCompile Include="..\..\core\Base\Window.cpp" />
<ClCompile Include="..\..\core\Collider\Collision.cpp" />
<ClCompile Include="..\..\core\Common\Collider.cpp" />
<ClCompile Include="..\..\core\Common\Color.cpp" />
<ClCompile Include="..\..\core\Common\Config.cpp" />
@ -240,7 +239,7 @@
<ClCompile Include="..\..\core\Custom\TextRenderer.cpp" />
<ClCompile Include="..\..\core\Custom\VoiceCallback.cpp" />
<ClCompile Include="..\..\core\Manager\ActionManager.cpp" />
<ClCompile Include="..\..\core\Manager\ColliderManager.cpp" />
<ClCompile Include="..\..\core\Manager\CollisionManager.cpp" />
<ClCompile Include="..\..\core\Manager\SceneManager.cpp" />
<ClCompile Include="..\..\core\Node\Button.cpp" />
<ClCompile Include="..\..\core\Node\ToggleButton.cpp" />
@ -274,7 +273,6 @@
<ClInclude Include="..\..\core\easy2d.h" />
<ClInclude Include="..\..\core\e2dbase.h" />
<ClInclude Include="..\..\core\e2dcommon.h" />
<ClInclude Include="..\..\core\e2dcollider.h" />
<ClInclude Include="..\..\core\e2dmacros.h" />
<ClInclude Include="..\..\core\e2dmanager.h" />
<ClInclude Include="..\..\core\e2dnode.h" />

13
project/vs2017/Easy2D.vcxproj.filters
View File

@ -22,9 +22,6 @@
<Filter Include="Common">
<UniqueIdentifier>{be5d9314-b00a-4f11-bd2a-1f720dc32407}</UniqueIdentifier>
</Filter>
<Filter Include="Collider">
<UniqueIdentifier>{765a2a00-5764-40f9-a15d-17b0640c6b53}</UniqueIdentifier>
</Filter>
<Filter Include="Node\Shape">
<UniqueIdentifier>{eb72b49a-5b2f-4fc0-9ad2-8f5e02efac6f}</UniqueIdentifier>
</Filter>
@ -96,9 +93,6 @@
<ClCompile Include="..\..\core\Tool\Path.cpp">
<Filter>Tool</Filter>
</ClCompile>
<ClCompile Include="..\..\core\Manager\ColliderManager.cpp">
<Filter>Manager</Filter>
</ClCompile>
<ClCompile Include="..\..\core\Node\Shape\Shape.cpp">
<Filter>Node\Shape</Filter>
</ClCompile>
@ -168,9 +162,6 @@
<ClCompile Include="..\..\core\Tool\Music.cpp">
<Filter>Tool</Filter>
</ClCompile>
<ClCompile Include="..\..\core\Collider\Collision.cpp">
<Filter>Collider</Filter>
</ClCompile>
<ClCompile Include="..\..\core\Action\Animation.cpp">
<Filter>Action</Filter>
</ClCompile>
@ -246,12 +237,14 @@
<ClCompile Include="..\..\core\Common\Resource.cpp">
<Filter>Common</Filter>
</ClCompile>
<ClCompile Include="..\..\core\Manager\CollisionManager.cpp">
<Filter>Manager</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\core\easy2d.h" />
<ClInclude Include="..\..\core\e2daction.h" />
<ClInclude Include="..\..\core\e2dbase.h" />
<ClInclude Include="..\..\core\e2dcollider.h" />
<ClInclude Include="..\..\core\e2dcommon.h" />
<ClInclude Include="..\..\core\e2dmacros.h" />
<ClInclude Include="..\..\core\e2dmanager.h" />