LumixEngine/src/animation/animation_system.cpp

#include "animation_system.h"
#include "animation/animation.h"
#include "core/base_proxy_allocator.h"
#include "core/blob.h"
#include "core/crc32.h"
#include "core/json_serializer.h"
#include "core/profiler.h"
#include "core/resource_manager.h"
#include "editor/asset_browser.h"
#include "editor/imgui/imgui.h"
#include "editor/property_grid.h"
#include "editor/studio_app.h"
#include "editor/world_editor.h"
#include "engine.h"
#include "engine/property_descriptor.h"
#include "engine/property_register.h"
#include "renderer/model.h"
#include "renderer/pose.h"
#include "renderer/render_scene.h"
#include "universe/universe.h"


namespace Lumix
{

static const uint32 RENDERABLE_HASH = crc32("renderable");
static const uint32 ANIMABLE_HASH = crc32("animable");

namespace FS
{
class FileSystem;
};

class Animation;
class Engine;
class JsonSerializer;
class Universe;


struct AnimationSceneImpl : public IScene
{
	struct Animable
	{
		bool m_is_free;
		ComponentIndex m_renderable;
		float m_time;
		class Animation* m_animation;
		Entity m_entity;
	};


	AnimationSceneImpl(IPlugin& anim_system, Engine& engine, Universe& ctx, IAllocator& allocator)
		: m_universe(ctx)
		, m_engine(engine)
		, m_anim_system(anim_system)
		, m_animables(allocator)
	{
		m_is_game_running = false;
		m_render_scene = nullptr;
		uint32 hash = crc32("renderer");
		for (auto* scene : ctx.getScenes())
		{
			if (crc32(scene->getPlugin().getName()) == hash)
			{
				m_render_scene = static_cast<RenderScene*>(scene);
				break;
			}
		}
		ASSERT(m_render_scene);
		m_render_scene->renderableCreated()
			.bind<AnimationSceneImpl, &AnimationSceneImpl::onRenderableCreated>(this);
		m_render_scene->renderableDestroyed()
			.bind<AnimationSceneImpl, &AnimationSceneImpl::onRenderableDestroyed>(this);
	}


	~AnimationSceneImpl()
	{
		for(auto& animable : m_animables)
		{
			if(animable.m_is_free) continue;
			unloadAnimation(animable.m_animation);
		}

		m_render_scene = static_cast<RenderScene*>(m_universe.getScene(crc32("renderer")));
		if (m_render_scene)
		{
			m_render_scene->renderableCreated()
				.unbind<AnimationSceneImpl, &AnimationSceneImpl::onRenderableCreated>(this);
			m_render_scene->renderableDestroyed()
				.unbind<AnimationSceneImpl, &AnimationSceneImpl::onRenderableDestroyed>(this);
		}
	}


	void startGame() override 
	{
		m_is_game_running = true;
	}


	void stopGame() override
	{
		m_is_game_running = false;
	}



	Universe& getUniverse() override { return m_universe; }


	ComponentIndex getComponent(Entity entity, uint32 type) override
	{
		ASSERT(ownComponentType(type));
		for (int i = 0; i < m_animables.size(); ++i)
		{
			if (!m_animables[i].m_is_free && m_animables[i].m_entity == entity) return i;
		}
		return INVALID_COMPONENT;
	}


	bool ownComponentType(uint32 type) const override
	{
		return type == ANIMABLE_HASH;
	}


	ComponentIndex createComponent(uint32 type,
										   Entity entity) override
	{
		if (type == ANIMABLE_HASH)
		{
			return createAnimable(entity);
		}
		return INVALID_COMPONENT;
	}


	void unloadAnimation(Animation* animation)
	{
		if(!animation) return;

		auto& rm = animation->getResourceManager();
		auto* animation_manager = rm.get(ResourceManager::ANIMATION);
		animation_manager->unload(*animation);
	}


	void destroyComponent(ComponentIndex component, uint32 type) override
	{
		if (type == ANIMABLE_HASH)
		{
			unloadAnimation(m_animables[component].m_animation);
			m_animables[component].m_is_free = true;
			m_universe.destroyComponent(m_animables[component].m_entity, type, this, component);
		}
	}


	void serialize(OutputBlob& serializer) override
	{
		serializer.write((int32)m_animables.size());
		for (int i = 0; i < m_animables.size(); ++i)
		{
			serializer.write(m_animables[i].m_entity);
			serializer.write(m_animables[i].m_time);
			serializer.write(m_animables[i].m_is_free);
			serializer.writeString(
				m_animables[i].m_animation ? m_animables[i].m_animation->getPath().c_str() : "");
		}
	}


	void deserialize(InputBlob& serializer, int) override
	{
		int32 count;
		serializer.read(count);
		m_animables.resize(count);
		for (int i = 0; i < count; ++i)
		{
			serializer.read(m_animables[i].m_entity);
			ComponentIndex renderable =
				m_render_scene->getRenderableComponent(m_animables[i].m_entity);
			if (renderable >= 0)
			{
				m_animables[i].m_renderable = renderable;
			}
			serializer.read(m_animables[i].m_time);
			serializer.read(m_animables[i].m_is_free);
			char path[MAX_PATH_LENGTH];
			serializer.readString(path, sizeof(path));
			m_animables[i].m_animation = path[0] == '\0' ? nullptr : loadAnimation(Path(path));
			m_universe.addComponent(m_animables[i].m_entity, ANIMABLE_HASH, this, i);
		}
	}


	Path getAnimation(ComponentIndex cmp)
	{
		return m_animables[cmp].m_animation
				   ? m_animables[cmp].m_animation->getPath()
				   : Path("");
	}


	void setAnimation(ComponentIndex cmp, const Path& path)
	{
		unloadAnimation(m_animables[cmp].m_animation);
		m_animables[cmp].m_animation = loadAnimation(path);
		m_animables[cmp].m_time = 0;
	}


	void updateAnimable(ComponentIndex cmp, float time_delta)
	{
		Animable& animable = m_animables[cmp];
		if(!animable.m_is_free && animable.m_animation &&
			animable.m_animation->isReady())
		{
			auto* pose = m_render_scene->getPose(animable.m_renderable);
			if(!pose) return;
			animable.m_animation->getPose(
				animable.m_time,
				*pose,
				*m_render_scene->getRenderableModel(animable.m_renderable));

			auto* model = m_render_scene->getRenderableModel(animable.m_renderable);
			for (int i = 0; i < pose->getCount(); ++i)
			{
				if (model->getBone(i).parent_idx >= 0)
				{
					m_render_scene->addDebugLine(pose->getPositions()[i],
						pose->getPositions()[model->getBone(i).parent_idx], 0xffffffff, 0);
					m_render_scene->addDebugLine(model->getBone(i).position,
						model->getBone(model->getBone(i).parent_idx).position, 0xfff00fff, 0);

				}
				

			}
			
			float t = animable.m_time + time_delta;
			float l = animable.m_animation->getLength();
			while(t > l)
			{
				t -= l;
			}
			animable.m_time = t;
		}
	}


	void update(float time_delta, bool paused) override
	{
		PROFILE_FUNCTION();
		if (m_animables.empty()) return;
		if (!m_is_game_running) return;

		for (int i = 0, c = m_animables.size(); i < c; ++i)
		{
			updateAnimable(i, time_delta);
		}
	}


	Animation* loadAnimation(const Path& path)
	{
		ResourceManager& rm = m_engine.getResourceManager();
		return static_cast<Animation*>(rm.get(ResourceManager::ANIMATION)->load(path));
	}


	void onRenderableCreated(ComponentIndex cmp)
	{
		Entity entity = m_render_scene->getRenderableEntity(cmp);
		for (int i = 0; i < m_animables.size(); ++i)
		{
			if (m_animables[i].m_entity == entity)
			{
				m_animables[i].m_renderable = cmp;
				break;
			}
		}
	}


	void onRenderableDestroyed(ComponentIndex cmp)
	{
		Entity entity = m_render_scene->getRenderableEntity(cmp);
		for (int i = 0; i < m_animables.size(); ++i)
		{
			if (m_animables[i].m_entity == entity)
			{
				m_animables[i].m_renderable = INVALID_COMPONENT;
				break;
			}
		}
	}


	ComponentIndex createAnimable(Entity entity)
	{
		Animable* src = nullptr;
		for (int i = 0, c = m_animables.size(); i < c; ++i)
		{
			if (m_animables[i].m_is_free)
			{
				src = &m_animables[i];
				break;
			}
		}
		Animable& animable = src ? *src : m_animables.emplace();
		animable.m_time = 0;
		animable.m_is_free = false;
		animable.m_renderable = INVALID_COMPONENT;
		animable.m_animation = nullptr;
		animable.m_entity = entity;

		ComponentIndex renderable =
			m_render_scene->getRenderableComponent(entity);
		if (renderable >= 0)
		{
			animable.m_renderable = renderable;
		}

		m_universe.addComponent(
			entity, ANIMABLE_HASH, this, m_animables.size() - 1);
		return m_animables.size() - 1;
	}


	IPlugin& getPlugin() const override { return m_anim_system; }


	Universe& m_universe;
	IPlugin& m_anim_system;
	Engine& m_engine;
	Array<Animable> m_animables;
	RenderScene* m_render_scene;
	bool m_is_game_running;
};


struct AnimationSystemImpl : public IPlugin
{
public:
	AnimationSystemImpl(Engine& engine)
		: m_allocator(engine.getAllocator())
		, m_engine(engine)
		, m_animation_manager(m_allocator)
	{
		PropertyRegister::registerComponentType("animable", "Animable");

		PropertyRegister::add("animable", LUMIX_NEW(m_allocator, ResourcePropertyDescriptor<AnimationSceneImpl>)("Animation",
			&AnimationSceneImpl::getAnimation,
			&AnimationSceneImpl::setAnimation,
			"Animation (*.ani)",
			ResourceManager::ANIMATION,
			m_allocator));
	}

	IScene* createScene(Universe& ctx) override
	{
		return LUMIX_NEW(m_allocator, AnimationSceneImpl)(
			*this, m_engine, ctx, m_allocator);
	}


	void destroyScene(IScene* scene) override
	{
		LUMIX_DELETE(m_allocator, scene);
	}


	const char* getName() const override { return "animation"; }


	bool create() override
	{
		m_animation_manager.create(ResourceManager::ANIMATION,
								   m_engine.getResourceManager());
		return true;
	}


	void destroy() override {}

	Lumix::IAllocator& m_allocator;
	Engine& m_engine;
	AnimationManager m_animation_manager;

private:
	void operator=(const AnimationSystemImpl&);
	AnimationSystemImpl(const AnimationSystemImpl&);
};


struct AssetBrowserPlugin : AssetBrowser::IPlugin
{

	AssetBrowserPlugin(StudioApp& app)
		: m_app(app)
	{}


	bool onGUI(Lumix::Resource* resource, Lumix::uint32 type) override
	{
		if(type == ResourceManager::ANIMATION)
		{
			auto* animation = static_cast<Animation*>(resource);
			ImGui::LabelText("FPS", "%d", animation->getFPS());
			ImGui::LabelText("Length", "%.3fs", animation->getLength());
			ImGui::LabelText("Frames", "%d", animation->getFrameCount());

			return true;
		}
		return false;
	}


	void onResourceUnloaded(Resource* resource) override
	{
	}


	const char* getName() const override
	{
		return "Animation";
	}


	bool hasResourceManager(uint32 type) const override
	{
		return type == ResourceManager::ANIMATION;
	}


	uint32 getResourceType(const char* ext) override
	{
		if(compareString(ext, "ani") == 0) return ResourceManager::ANIMATION;
		return 0;
	}


	StudioApp& m_app;

};


struct PropertyGridPlugin : PropertyGrid::IPlugin
{
	PropertyGridPlugin(StudioApp& app)
		: m_app(app)
	{
		m_is_playing = false;
		m_time_scale = 1;
	}


	void onGUI(PropertyGrid& grid, Lumix::ComponentUID cmp) override
	{
		if(cmp.type != ANIMABLE_HASH) return;

		auto* scene = static_cast<AnimationSceneImpl*>(cmp.scene);
		auto& animable = scene->m_animables[cmp.index];
		if(!animable.m_animation) return;
		if(!animable.m_animation->isReady()) return;

		ImGui::Checkbox("Play", &m_is_playing);
		if(ImGui::SliderFloat("Time", &animable.m_time, 0, animable.m_animation->getLength()))
		{
			scene->updateAnimable(cmp.index, 0);
		}

		if(m_is_playing)
		{
			ImGui::InputFloat("Time scale", &m_time_scale, 0.1f, 1.0f);
			m_time_scale = Math::maxValue(0.0f, m_time_scale);
			float time_delta = m_app.getWorldEditor()->getEngine().getLastTimeDelta();
			scene->updateAnimable(cmp.index, time_delta * m_time_scale);
		}

	}


	StudioApp& m_app;
	bool m_is_playing;
	float m_time_scale;
};


extern "C" LUMIX_ANIMATION_API void setStudioApp(StudioApp& app)
{
	auto& allocator = app.getWorldEditor()->getAllocator();
	auto* ab_plugin = LUMIX_NEW(allocator, AssetBrowserPlugin)(app);
	app.getAssetBrowser()->addPlugin(*ab_plugin);

	auto* pg_plugin = LUMIX_NEW(allocator, PropertyGridPlugin)(app);
	app.getPropertyGrid()->addPlugin(*pg_plugin);
}


extern "C" IPlugin* createPlugin(Engine& engine)
{
	return LUMIX_NEW(engine.getAllocator(), AnimationSystemImpl)(engine);
}


} // ~namespace Lumix