From 3bad85e59644fd1651562c4a41d4f71bd8ff6f47 Mon Sep 17 00:00:00 2001 From: turanszkij Date: Sun, 10 Jan 2016 11:42:10 +0100 Subject: [PATCH] update --- ScriptingAPI-Documentation.md | 48 ++- WickedEngine/Renderable2DComponent.cpp | 51 +-- WickedEngine/Renderable3DComponent.cpp | 11 +- WickedEngine/SpriteAnim_BindLua.cpp | 429 +++++++++++++++++++++++++ WickedEngine/SpriteAnim_BindLua.h | 69 ++++ WickedEngine/wiVersion.cpp | 2 +- 6 files changed, 565 insertions(+), 45 deletions(-) diff --git a/ScriptingAPI-Documentation.md b/ScriptingAPI-Documentation.md index 1a8081075..fe3f1bbf9 100644 --- a/ScriptingAPI-Documentation.md +++ b/ScriptingAPI-Documentation.md @@ -13,6 +13,8 @@ The documentation completion is still pending.... 2. Sprite 1. ImageEffects 2. SpriteAnim + 3. MovingTexAnim + 4. DrawRecAnim 3. Texture 4. Sound 1. SoundEffect @@ -187,7 +189,50 @@ Specify Sprite properties, like position, size, etc. #### SpriteAnim Animate Sprites easily with this helper. - [constructor]SpriteAnim() -- SetRot(float rotation) +- SetRot(float val) +- SetRotation(float val) +- SetOpacity(float val) +- SetFade(float val) +- SetRepeatable(boolean val) +- SetVelocity(Vector val) +- SetScaleX(float val) +- SetScaleY(float val) +- SetMovingTexAnim(MovingTexAnim val) +- SetDrawRecAnim(DrawRecAnim val) +- GetRot() : float result +- GetRotation() : float result +- GetOpacity() : float result +- GetFade() : float result +- GetRepeatable() : boolean result +- GetVelocity() : Vector result +- GetScaleX() : float result +- GetScaleY() : float result +- GetMovingTexAnim() : GetMovingTexAnim result +- GetDrawRecAnim() : GetDrawRecAnim result + +#### MovingTexAnim +Move texture continuously along the sprite. +- [constructor]MovingTexAnim(opt float speedX,speedY) +- SetSpeedX(float val) +- SetSpeedY(float val) +- GetSpeedX() : float result +- GetSpeedY() : float result + +#### DrawRecAnim +Animate sprite frame by frame. +- [constructor]DrawRecAnim() +- SetOnFrameChangeWait(float val) +- SetFrameCount(float val) +- SetJumpX(float val) +- SetJumpY(float val) +- SetSizX(float val) +- SetSizY(float val) +- GetOnFrameChangeWait() : float result +- GetFrameCount() : float result +- GetJumpX() : float result +- GetJumpY() : float result +- GetSizX() : float result +- GetSizY() : float result ### Texture Just holds texture information in VRAM. @@ -295,6 +340,7 @@ It is a renderable entity (optionally), which contains a Mesh. It inherits functions from Cullable. - [void-constructor]Object() - EmitTrail(Vector color, opt float fadeSpeed=0.06) +- SetTrailTex(Texture tex) - SetTrailDistortTex(Texture tex) - SetTransparency(float value) - GetTransparency() : float? result diff --git a/WickedEngine/Renderable2DComponent.cpp b/WickedEngine/Renderable2DComponent.cpp index 7ad87e6a0..b588f4dd6 100644 --- a/WickedEngine/Renderable2DComponent.cpp +++ b/WickedEngine/Renderable2DComponent.cpp @@ -8,6 +8,8 @@ Renderable2DComponent::Renderable2DComponent() { setSpriteSpeed(1.f); addLayer(DEFAULT_RENDERLAYER); + + RenderableComponent(); } @@ -21,11 +23,13 @@ void Renderable2DComponent::Initialize() rtFinal.Initialize( wiRenderer::GetScreenWidth(), wiRenderer::GetScreenHeight() , 1, false); + + RenderableComponent::Initialize(); } void Renderable2DComponent::Load() { - + RenderableComponent::Load(); } void Renderable2DComponent::Unload() { @@ -45,6 +49,8 @@ void Renderable2DComponent::Unload() } } } + + RenderableComponent::Unload(); } void Renderable2DComponent::Start() { @@ -52,30 +58,6 @@ void Renderable2DComponent::Start() } void Renderable2DComponent::Update() { - //vector spritesToDelete(0); - //vector fontsToDelete(0); - - //for (wiSprite* x : m_sprites) - //{ - // if (x != nullptr) - // x->Update(getSpriteSpeed()); - // else - // spritesToDelete.push_back(x); - //} - //for (wiFont* x : m_fonts) - //{ - // if (x == nullptr) - // fontsToDelete.push_back(x); - //} - - //for (wiSprite* x : spritesToDelete) - //{ - // m_sprites.remove(x); - //} - //for (wiFont* x : fontsToDelete) - //{ - // m_fonts.remove(x); - //} for (auto& x : layers) { @@ -91,13 +73,13 @@ void Renderable2DComponent::Update() } } } + + RenderableComponent::Update(); } void Renderable2DComponent::Render() { rtFinal.Activate(wiRenderer::getImmediateContext(), 0, 0, 0, 0); - //wiImage::BatchBegin(); - for (auto& x : layers) { @@ -114,22 +96,13 @@ void Renderable2DComponent::Render() } } - //for (wiSprite* x : m_sprites) - //{ - // if(x != nullptr) - // x->Draw(); - //} - - //for (wiFont* x : m_fonts) - //{ - // if (x != nullptr) - // x->Draw(); - //} + RenderableComponent::Render(); } void Renderable2DComponent::Compose() { - //wiImage::BatchBegin(); wiImage::Draw(rtFinal.shaderResource.back(), wiImageEffects((float)wiRenderer::GetScreenWidth(),(float)wiRenderer::GetScreenHeight())); + + RenderableComponent::Compose(); } diff --git a/WickedEngine/Renderable3DComponent.cpp b/WickedEngine/Renderable3DComponent.cpp index e88e013bd..ff3375ada 100644 --- a/WickedEngine/Renderable3DComponent.cpp +++ b/WickedEngine/Renderable3DComponent.cpp @@ -10,6 +10,8 @@ Renderable3DComponent::Renderable3DComponent() { _needToUpdateRenderData.store(true); + + Renderable2DComponent(); } Renderable3DComponent::~Renderable3DComponent() { @@ -57,7 +59,7 @@ void Renderable3DComponent::setProperties() void Renderable3DComponent::Initialize() { - RenderableComponent::Initialize(); + Renderable2DComponent::Initialize(); rtSSR.Initialize( (UINT)(wiRenderer::GetScreenWidth()), (UINT)(wiRenderer::GetScreenHeight()) @@ -158,7 +160,7 @@ void Renderable3DComponent::Initialize() void Renderable3DComponent::Load() { - RenderableComponent::Load(); + Renderable2DComponent::Load(); wiRenderer::HAIRPARTICLEENABLED = getHairParticlesEnabled(); wiRenderer::EMITTERSENABLED = getEmittedParticlesEnabled(); @@ -170,14 +172,15 @@ void Renderable3DComponent::Start() } void Renderable3DComponent::Update(){ - RenderableComponent::Update(); - wiRenderer::Update(); wiRenderer::UpdateLights(); wiRenderer::SychronizeWithPhysicsEngine(); wiRenderer::UpdateImages(); _needToUpdateRenderData.store(true); + + + Renderable2DComponent::Update(); } void Renderable3DComponent::Compose(){ diff --git a/WickedEngine/SpriteAnim_BindLua.cpp b/WickedEngine/SpriteAnim_BindLua.cpp index c58cebce5..a5b5198b6 100644 --- a/WickedEngine/SpriteAnim_BindLua.cpp +++ b/WickedEngine/SpriteAnim_BindLua.cpp @@ -1,9 +1,30 @@ #include "SpriteAnim_BindLua.h" +#include "Vector_BindLua.h" const char SpriteAnim_BindLua::className[] = "SpriteAnim"; Luna::FunctionType SpriteAnim_BindLua::methods[] = { lunamethod(SpriteAnim_BindLua, SetRot), + lunamethod(SpriteAnim_BindLua, SetRotation), + lunamethod(SpriteAnim_BindLua, SetOpacity), + lunamethod(SpriteAnim_BindLua, SetFade), + lunamethod(SpriteAnim_BindLua, SetRepeatable), + lunamethod(SpriteAnim_BindLua, SetVelocity), + lunamethod(SpriteAnim_BindLua, SetScaleX), + lunamethod(SpriteAnim_BindLua, SetScaleY), + lunamethod(SpriteAnim_BindLua, SetMovingTexAnim), + lunamethod(SpriteAnim_BindLua, SetDrawRecAnim), + + lunamethod(SpriteAnim_BindLua, GetRot), + lunamethod(SpriteAnim_BindLua, GetRotation), + lunamethod(SpriteAnim_BindLua, GetOpacity), + lunamethod(SpriteAnim_BindLua, GetFade), + lunamethod(SpriteAnim_BindLua, GetRepeatable), + lunamethod(SpriteAnim_BindLua, GetVelocity), + lunamethod(SpriteAnim_BindLua, GetScaleX), + lunamethod(SpriteAnim_BindLua, GetScaleY), + lunamethod(SpriteAnim_BindLua, GetMovingTexAnim), + lunamethod(SpriteAnim_BindLua, GetDrawRecAnim), { NULL, NULL } }; Luna::PropertyType SpriteAnim_BindLua::properties[] = { @@ -37,6 +58,188 @@ int SpriteAnim_BindLua::SetRot(lua_State *L) } return 0; } +int SpriteAnim_BindLua::SetRotation(lua_State *L) +{ + return SetRot(L); +} +int SpriteAnim_BindLua::SetOpacity(lua_State *L) +{ + int argc = wiLua::SGetArgCount(L); + if (argc > 0) + { + anim.opa = wiLua::SGetFloat(L, 1); + } + else + { + wiLua::SError(L, "SetOpacity(float val) not enough arguments!"); + } + return 0; +} +int SpriteAnim_BindLua::SetFade(lua_State *L) +{ + int argc = wiLua::SGetArgCount(L); + if (argc > 0) + { + anim.fad = wiLua::SGetFloat(L, 1); + } + else + { + wiLua::SError(L, "SetFade(float val) not enough arguments!"); + } + return 0; +} +int SpriteAnim_BindLua::SetRepeatable(lua_State *L) +{ + int argc = wiLua::SGetArgCount(L); + if (argc > 0) + { + anim.repeatable = wiLua::SGetBool(L, 1); + } + else + { + wiLua::SError(L, "SetRepeatable(float val) not enough arguments!"); + } + return 0; +} +int SpriteAnim_BindLua::SetVelocity(lua_State *L) +{ + int argc = wiLua::SGetArgCount(L); + if (argc > 0) + { + Vector_BindLua* vec = Luna::lightcheck(L, 1); + if (vec != nullptr) + { + XMStoreFloat3(&anim.vel, vec->vector); + } + else + { + wiLua::SError(L, "SetVelocity(Vector val) argument is not a Vector!"); + } + } + else + { + wiLua::SError(L, "SetVelocity(Vector val) not enough arguments!"); + } + return 0; +} +int SpriteAnim_BindLua::SetScaleX(lua_State *L) +{ + int argc = wiLua::SGetArgCount(L); + if (argc > 0) + { + anim.scaleX = wiLua::SGetFloat(L, 1); + } + else + { + wiLua::SError(L, "SetScaleX(float val) not enough arguments!"); + } + return 0; +} +int SpriteAnim_BindLua::SetScaleY(lua_State *L) +{ + int argc = wiLua::SGetArgCount(L); + if (argc > 0) + { + anim.scaleY = wiLua::SGetFloat(L, 1); + } + else + { + wiLua::SError(L, "SetScaleY(float val) not enough arguments!"); + } + return 0; +} +int SpriteAnim_BindLua::SetMovingTexAnim(lua_State *L) +{ + int argc = wiLua::SGetArgCount(L); + if (argc > 0) + { + MovingTexData_BindLua* data = Luna::lightcheck(L, 1); + if (data != nullptr) + { + anim.movingTexAnim = data->data; + } + else + { + wiLua::SError(L, "SetMovingTexAnim(MovingTexAnim data) argument is not a MovingTexAnim!"); + } + } + else + { + wiLua::SError(L, "SetMovingTexAnim(MovingTexAnim data) not enough arguments!"); + } + return 0; +} +int SpriteAnim_BindLua::SetDrawRecAnim(lua_State *L) +{ + int argc = wiLua::SGetArgCount(L); + if (argc > 0) + { + DrawRecData_BindLua* data = Luna::lightcheck(L, 1); + if (data != nullptr) + { + anim.drawRecAnim = data->data; + } + else + { + wiLua::SError(L, "SetDrawRecAnim(DrawRecAnim data) argument is not a DrawRecAnim!"); + } + } + else + { + wiLua::SError(L, "SetDrawRecAnim(DrawRecAnim data) not enough arguments!"); + } + return 0; +} + +int SpriteAnim_BindLua::GetRot(lua_State *L) +{ + wiLua::SSetFloat(L, anim.rot); + return 1; +} +int SpriteAnim_BindLua::GetRotation(lua_State *L) +{ + return GetRot(L); +} +int SpriteAnim_BindLua::GetOpacity(lua_State *L) +{ + wiLua::SSetFloat(L, anim.opa); + return 1; +} +int SpriteAnim_BindLua::GetFade(lua_State *L) +{ + wiLua::SSetFloat(L, anim.fad); + return 1; +} +int SpriteAnim_BindLua::GetRepeatable(lua_State *L) +{ + wiLua::SSetBool(L, anim.repeatable); + return 1; +} +int SpriteAnim_BindLua::GetVelocity(lua_State *L) +{ + Luna::push(L, new Vector_BindLua(XMLoadFloat3(&anim.vel))); + return 1; +} +int SpriteAnim_BindLua::GetScaleX(lua_State *L) +{ + wiLua::SSetFloat(L, anim.scaleX); + return 1; +} +int SpriteAnim_BindLua::GetScaleY(lua_State *L) +{ + wiLua::SSetFloat(L, anim.scaleY); + return 1; +} +int SpriteAnim_BindLua::GetMovingTexAnim(lua_State *L) +{ + Luna::push(L, new MovingTexData_BindLua(anim.movingTexAnim)); + return 1; +} +int SpriteAnim_BindLua::GetDrawRecAnim(lua_State *L) +{ + Luna::push(L, new DrawRecData_BindLua(anim.drawRecAnim)); + return 1; +} void SpriteAnim_BindLua::Bind() { @@ -45,5 +248,231 @@ void SpriteAnim_BindLua::Bind() { initialized = true; Luna::Register(wiLua::GetGlobal()->GetLuaState()); + Luna::Register(wiLua::GetGlobal()->GetLuaState()); + Luna::Register(wiLua::GetGlobal()->GetLuaState()); } } + + + + +const char MovingTexData_BindLua::className[] = "MovingTexAnim"; + +Luna::FunctionType MovingTexData_BindLua::methods[] = { + lunamethod(MovingTexData_BindLua, SetSpeedX), + lunamethod(MovingTexData_BindLua, SetSpeedY), + + lunamethod(MovingTexData_BindLua, GetSpeedX), + lunamethod(MovingTexData_BindLua, GetSpeedY), + { NULL, NULL } +}; +Luna::PropertyType MovingTexData_BindLua::properties[] = { + { NULL, NULL } +}; + +MovingTexData_BindLua::MovingTexData_BindLua(const wiSprite::Anim::MovingTexData& data) :data(data) +{ +} + +MovingTexData_BindLua::MovingTexData_BindLua(lua_State *L) +{ + data = wiSprite::Anim::MovingTexData(); + int argc = wiLua::SGetArgCount(L); + if (argc > 0) + { + data.speedX = wiLua::SGetFloat(L, 1); + if (argc > 1) + { + data.speedY = wiLua::SGetFloat(L, 2); + } + } +} + +MovingTexData_BindLua::~MovingTexData_BindLua() +{ +} + +int MovingTexData_BindLua::SetSpeedX(lua_State *L) +{ + int argc = wiLua::SGetArgCount(L); + if (argc > 0) + { + data.speedX = wiLua::SGetFloat(L, 1); + } + else + { + wiLua::SError(L, "SetSpeedX(float val) not enough arguments!"); + } + return 0; +} +int MovingTexData_BindLua::SetSpeedY(lua_State *L) +{ + int argc = wiLua::SGetArgCount(L); + if (argc > 0) + { + data.speedY = wiLua::SGetFloat(L, 1); + } + else + { + wiLua::SError(L, "SetSpeedY(float val) not enough arguments!"); + } + return 0; +} + +int MovingTexData_BindLua::GetSpeedX(lua_State *L) +{ + wiLua::SSetFloat(L, data.speedX); + return 1; +} +int MovingTexData_BindLua::GetSpeedY(lua_State *L) +{ + wiLua::SSetFloat(L, data.speedY); + return 1; +} + + + +const char DrawRecData_BindLua::className[] = "DrawRecAnim"; + +Luna::FunctionType DrawRecData_BindLua::methods[] = { + lunamethod(DrawRecData_BindLua, SetOnFrameChangeWait), + lunamethod(DrawRecData_BindLua, SetFrameCount), + lunamethod(DrawRecData_BindLua, SetJumpX), + lunamethod(DrawRecData_BindLua, SetJumpY), + lunamethod(DrawRecData_BindLua, SetSizX), + lunamethod(DrawRecData_BindLua, SetSizY), + + lunamethod(DrawRecData_BindLua, GetOnFrameChangeWait), + lunamethod(DrawRecData_BindLua, GetFrameCount), + lunamethod(DrawRecData_BindLua, GetJumpX), + lunamethod(DrawRecData_BindLua, GetJumpY), + lunamethod(DrawRecData_BindLua, GetSizX), + lunamethod(DrawRecData_BindLua, GetSizY), + { NULL, NULL } +}; +Luna::PropertyType DrawRecData_BindLua::properties[] = { + { NULL, NULL } +}; + +DrawRecData_BindLua::DrawRecData_BindLua(const wiSprite::Anim::DrawRecData& data) :data(data) +{ +} + +DrawRecData_BindLua::DrawRecData_BindLua(lua_State *L) +{ + data = wiSprite::Anim::DrawRecData(); +} + +DrawRecData_BindLua::~DrawRecData_BindLua() +{ +} + +int DrawRecData_BindLua::SetOnFrameChangeWait(lua_State* L) +{ + int argc = wiLua::SGetArgCount(L); + if (argc > 0) + { + data.onFrameChangeWait = wiLua::SGetFloat(L, 1); + } + else + { + wiLua::SError(L, "SetOnFrameChangeWait(float val) not enough arguments!"); + } + return 0; +} +int DrawRecData_BindLua::SetFrameCount(lua_State* L) +{ + int argc = wiLua::SGetArgCount(L); + if (argc > 0) + { + data.frameCount = wiLua::SGetFloat(L, 1); + } + else + { + wiLua::SError(L, "SetFrameCount(float val) not enough arguments!"); + } + return 0; +} +int DrawRecData_BindLua::SetJumpX(lua_State* L) +{ + int argc = wiLua::SGetArgCount(L); + if (argc > 0) + { + data.jumpX = wiLua::SGetFloat(L, 1); + } + else + { + wiLua::SError(L, "SetJumpX(float val) not enough arguments!"); + } + return 0; +} +int DrawRecData_BindLua::SetJumpY(lua_State* L) +{ + int argc = wiLua::SGetArgCount(L); + if (argc > 0) + { + data.jumpY = wiLua::SGetFloat(L, 1); + } + else + { + wiLua::SError(L, "SetJumpY(float val) not enough arguments!"); + } + return 0; +} +int DrawRecData_BindLua::SetSizX(lua_State* L) +{ + int argc = wiLua::SGetArgCount(L); + if (argc > 0) + { + data.sizX = wiLua::SGetFloat(L, 1); + } + else + { + wiLua::SError(L, "SetSizX(float val) not enough arguments!"); + } + return 0; +} +int DrawRecData_BindLua::SetSizY(lua_State* L) +{ + int argc = wiLua::SGetArgCount(L); + if (argc > 0) + { + data.sizY = wiLua::SGetFloat(L, 1); + } + else + { + wiLua::SError(L, "SetSizY(float val) not enough arguments!"); + } + return 0; +} + +int DrawRecData_BindLua::GetOnFrameChangeWait(lua_State* L) +{ + wiLua::SSetFloat(L, data.onFrameChangeWait); + return 1; +} +int DrawRecData_BindLua::GetFrameCount(lua_State* L) +{ + wiLua::SSetFloat(L, data.frameCount); + return 1; +} +int DrawRecData_BindLua::GetJumpX(lua_State* L) +{ + wiLua::SSetFloat(L, data.jumpX); + return 1; +} +int DrawRecData_BindLua::GetJumpY(lua_State* L) +{ + wiLua::SSetFloat(L, data.jumpY); + return 1; +} +int DrawRecData_BindLua::GetSizX(lua_State* L) +{ + wiLua::SSetFloat(L, data.sizX); + return 1; +} +int DrawRecData_BindLua::GetSizY(lua_State* L) +{ + wiLua::SSetFloat(L, data.sizY); + return 1; +} \ No newline at end of file diff --git a/WickedEngine/SpriteAnim_BindLua.h b/WickedEngine/SpriteAnim_BindLua.h index 0bb683ad1..f37ffe0f3 100644 --- a/WickedEngine/SpriteAnim_BindLua.h +++ b/WickedEngine/SpriteAnim_BindLua.h @@ -17,7 +17,76 @@ public: ~SpriteAnim_BindLua(); int SetRot(lua_State *L); + int SetRotation(lua_State *L); + int SetOpacity(lua_State *L); + int SetFade(lua_State *L); + int SetRepeatable(lua_State *L); + int SetVelocity(lua_State *L); + int SetScaleX(lua_State *L); + int SetScaleY(lua_State *L); + int SetMovingTexAnim(lua_State *L); + int SetDrawRecAnim(lua_State *L); + + int GetRot(lua_State *L); + int GetRotation(lua_State *L); + int GetOpacity(lua_State *L); + int GetFade(lua_State *L); + int GetRepeatable(lua_State *L); + int GetVelocity(lua_State *L); + int GetScaleX(lua_State *L); + int GetScaleY(lua_State *L); + int GetMovingTexAnim(lua_State *L); + int GetDrawRecAnim(lua_State *L); + static void Bind(); }; +class MovingTexData_BindLua +{ +public: + wiSprite::Anim::MovingTexData data; + + static const char className[]; + static Luna::FunctionType methods[]; + static Luna::PropertyType properties[]; + + MovingTexData_BindLua(const wiSprite::Anim::MovingTexData& data); + MovingTexData_BindLua(lua_State *L); + ~MovingTexData_BindLua(); + + int SetSpeedX(lua_State* L); + int SetSpeedY(lua_State* L); + + int GetSpeedX(lua_State* L); + int GetSpeedY(lua_State* L); +}; + +class DrawRecData_BindLua +{ +public: + wiSprite::Anim::DrawRecData data; + + static const char className[]; + static Luna::FunctionType methods[]; + static Luna::PropertyType properties[]; + + DrawRecData_BindLua(const wiSprite::Anim::DrawRecData& data); + DrawRecData_BindLua(lua_State *L); + ~DrawRecData_BindLua(); + + int SetOnFrameChangeWait(lua_State* L); + int SetFrameCount(lua_State* L); + int SetJumpX(lua_State* L); + int SetJumpY(lua_State* L); + int SetSizX(lua_State* L); + int SetSizY(lua_State* L); + + int GetOnFrameChangeWait(lua_State* L); + int GetFrameCount(lua_State* L); + int GetJumpX(lua_State* L); + int GetJumpY(lua_State* L); + int GetSizX(lua_State* L); + int GetSizY(lua_State* L); +}; + diff --git a/WickedEngine/wiVersion.cpp b/WickedEngine/wiVersion.cpp index 804a7a07c..ae09979ec 100644 --- a/WickedEngine/wiVersion.cpp +++ b/WickedEngine/wiVersion.cpp @@ -7,7 +7,7 @@ namespace wiVersion // minor features, major bug fixes const int minor = 4; // minor bug fixes, alterations, refactors - const int revision = 4; + const int revision = 5; long GetVersion()