Glenn Maynard
6 years ago
parent
303283624a
commit
2628c078fa
@ -0,0 +1,416 @@ |
|||||||
|
#include "SMXPanelAnimation.h" |
||||||
|
#include "SMXManager.h" |
||||||
|
#include "SMXDevice.h" |
||||||
|
#include "SMXThread.h" |
||||||
|
using namespace std; |
||||||
|
using namespace SMX; |
||||||
|
|
||||||
|
namespace { |
||||||
|
Mutex g_Lock; |
||||||
|
} |
||||||
|
|
||||||
|
#define LIGHTS_PER_PANEL 16 |
||||||
|
|
||||||
|
// XXX: go to sleep if there are no pads connected
|
||||||
|
|
||||||
|
struct AnimationState |
||||||
|
{ |
||||||
|
SMXPanelAnimation animation; |
||||||
|
|
||||||
|
// Seconds into the animation:
|
||||||
|
float fTime = 0; |
||||||
|
|
||||||
|
// The currently displayed frame:
|
||||||
|
int iCurrentFrame = 0; |
||||||
|
|
||||||
|
bool bPlaying = false; |
||||||
|
|
||||||
|
double m_fLastUpdateTime = -1; |
||||||
|
|
||||||
|
// Return the current animation frame.
|
||||||
|
const vector<SMXGif::Color> &GetAnimationFrame() const |
||||||
|
{ |
||||||
|
// If we're not playing, return an empty array. As a sanity check, do this
|
||||||
|
// if the frame is out of bounds too.
|
||||||
|
if(!bPlaying || iCurrentFrame >= animation.m_aPanelGraphics.size()) |
||||||
|
{ |
||||||
|
static vector<SMXGif::Color> dummy; |
||||||
|
return dummy; |
||||||
|
} |
||||||
|
|
||||||
|
return animation.m_aPanelGraphics[iCurrentFrame]; |
||||||
|
} |
||||||
|
|
||||||
|
// Start the animation if it's not playing.
|
||||||
|
void Play() |
||||||
|
{ |
||||||
|
bPlaying = true; |
||||||
|
} |
||||||
|
|
||||||
|
// Stop and disable the animation.
|
||||||
|
void Stop() |
||||||
|
{ |
||||||
|
bPlaying = false; |
||||||
|
Rewind(); |
||||||
|
} |
||||||
|
|
||||||
|
// Reset to the first frame.
|
||||||
|
void Rewind() |
||||||
|
{ |
||||||
|
fTime = 0; |
||||||
|
iCurrentFrame = 0; |
||||||
|
} |
||||||
|
|
||||||
|
// Advance the animation by fSeconds.
|
||||||
|
void Update() |
||||||
|
{ |
||||||
|
// fSeconds is the time since the last update:
|
||||||
|
double fNow = SMX::GetMonotonicTime(); |
||||||
|
double fSeconds = m_fLastUpdateTime == -1? 0: (fNow - m_fLastUpdateTime); |
||||||
|
m_fLastUpdateTime = fNow; |
||||||
|
|
||||||
|
if(!bPlaying || animation.m_aPanelGraphics.empty()) |
||||||
|
return; |
||||||
|
|
||||||
|
// If the current frame is past the end, a new animation was probably
|
||||||
|
// loaded.
|
||||||
|
if(iCurrentFrame >= animation.m_aPanelGraphics.size()) |
||||||
|
Rewind(); |
||||||
|
|
||||||
|
// Advance time.
|
||||||
|
fTime += fSeconds; |
||||||
|
|
||||||
|
// If we're still on this frame, we're done.
|
||||||
|
float fFrameDuration = animation.m_iFrameDurations[iCurrentFrame]; |
||||||
|
if(fTime - 0.00001f < fFrameDuration) |
||||||
|
return; |
||||||
|
|
||||||
|
// If we've passed the end of the frame, move to the next frame. Don't
|
||||||
|
// skip frames if we're updating too quickly.
|
||||||
|
fTime -= fFrameDuration; |
||||||
|
if(fTime > 0) |
||||||
|
fTime = 0; |
||||||
|
|
||||||
|
// Advance the frame.
|
||||||
|
iCurrentFrame++; |
||||||
|
|
||||||
|
// If we're at the end of the frame, rewind to the loop frame.
|
||||||
|
if(iCurrentFrame == animation.m_aPanelGraphics.size()) |
||||||
|
iCurrentFrame = animation.m_iLoopFrame; |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
struct AnimationStateForPad |
||||||
|
{ |
||||||
|
// asLightsData is an array of lights data to send to the pad and graphic
|
||||||
|
// is an animation graphic. Overlay graphic on top of the lights.
|
||||||
|
void OverlayLights(char *asLightsData, const vector<SMXGif::Color> &graphic) const |
||||||
|
{ |
||||||
|
// Stop if this graphic isn't loaded or is paused.
|
||||||
|
if(graphic.empty()) |
||||||
|
return; |
||||||
|
|
||||||
|
for(int i = 0; i < graphic.size(); ++i) |
||||||
|
{ |
||||||
|
if(i >= LIGHTS_PER_PANEL) |
||||||
|
return; |
||||||
|
|
||||||
|
// If this color is transparent, leave the released animation alone.
|
||||||
|
if(graphic[i].color[3] == 0) |
||||||
|
continue; |
||||||
|
|
||||||
|
asLightsData[i*3+0] = graphic[i].color[0]; |
||||||
|
asLightsData[i*3+1] = graphic[i].color[1]; |
||||||
|
asLightsData[i*3+2] = graphic[i].color[2]; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Return the command to set the current animation state as pad lights.
|
||||||
|
string GetLightsCommand(int iPadState, const SMXConfig &config) const |
||||||
|
{ |
||||||
|
g_Lock.AssertLockedByCurrentThread(); |
||||||
|
|
||||||
|
// If AutoLightingUsePressedAnimations is set, use lights animations.
|
||||||
|
// If it's not (the config tool is set to step color), mimic the built-in
|
||||||
|
// step color behavior instead of using pressed animations. Any released
|
||||||
|
// animation will always be used.
|
||||||
|
bool bUsePressedAnimations = config.flags & PlatformFlags_AutoLightingUsePressedAnimations; |
||||||
|
|
||||||
|
const int iBytesPerPanel = LIGHTS_PER_PANEL*3; |
||||||
|
const int iTotalLights = 9*iBytesPerPanel; |
||||||
|
string result(iTotalLights, 0); |
||||||
|
|
||||||
|
for(int panel = 0; panel < 9; ++panel) |
||||||
|
{ |
||||||
|
// The portion of lights data for this panel:
|
||||||
|
char *out = &result[panel*iBytesPerPanel]; |
||||||
|
|
||||||
|
// Add the released animation, then overlay the pressed animation if we're pressed.
|
||||||
|
OverlayLights(out, animations[panel][SMX_LightsType_Released].GetAnimationFrame()); |
||||||
|
bool bPressed = bool(iPadState & (1 << panel)); |
||||||
|
if(bPressed && bUsePressedAnimations) |
||||||
|
OverlayLights(out, animations[panel][SMX_LightsType_Pressed].GetAnimationFrame()); |
||||||
|
else if(bPressed && !bUsePressedAnimations) |
||||||
|
{ |
||||||
|
// Light all LEDs on this panel using stepColor.
|
||||||
|
double LightsScaleFactor = 0.666666f; |
||||||
|
const uint8_t *color = &config.stepColor[panel*3]; |
||||||
|
|
||||||
|
for(int light = 0; light < LIGHTS_PER_PANEL; ++light) |
||||||
|
{ |
||||||
|
for(int i = 0; i < 3; ++i) |
||||||
|
{ |
||||||
|
// stepColor is scaled to the 0-170 range. Scale it back to the 0-255 range.
|
||||||
|
// User applications don't need to worry about this since they normally don't
|
||||||
|
// need to care about stepColor.
|
||||||
|
uint8_t c = color[i]; |
||||||
|
c = (uint8_t) lrintf(min(255.0f, c / LightsScaleFactor)); |
||||||
|
out[light*3+i] = c; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
return result; |
||||||
|
} |
||||||
|
|
||||||
|
// State for both animations on each panel:
|
||||||
|
AnimationState animations[9][NUM_SMX_LightsType]; |
||||||
|
}; |
||||||
|
|
||||||
|
namespace |
||||||
|
{ |
||||||
|
// Animations and animation states for both pads.
|
||||||
|
AnimationStateForPad pad_states[2]; |
||||||
|
} |
||||||
|
|
||||||
|
namespace { |
||||||
|
// Given a 23x24 graphic frame and a panel number, return an array of 25 colors, containing
|
||||||
|
// each light in the order it's sent to the master controller.
|
||||||
|
void ConvertToPanelGraphic(const SMXGif::GIFImage &src, vector<SMXGif::Color> &dst, int panel) |
||||||
|
{ |
||||||
|
vector<pair<int,int>> graphic_positions = { |
||||||
|
{ 0,0 }, |
||||||
|
{ 1,0 }, |
||||||
|
{ 2,0 }, |
||||||
|
{ 0,1 }, |
||||||
|
{ 1,1 }, |
||||||
|
{ 2,1 }, |
||||||
|
{ 0,2 }, |
||||||
|
{ 1,2 }, |
||||||
|
{ 2,2 }, |
||||||
|
}; |
||||||
|
|
||||||
|
dst.clear(); |
||||||
|
|
||||||
|
// The top-left corner for this panel:
|
||||||
|
int x = graphic_positions[panel].first * 8; |
||||||
|
int y = graphic_positions[panel].second * 8; |
||||||
|
|
||||||
|
// Add the 4x4 grid first.
|
||||||
|
for(int dy = 0; dy < 4; ++dy) |
||||||
|
for(int dx = 0; dx < 4; ++dx) |
||||||
|
dst.push_back(src.get(x+dx*2, y+dy*2)); |
||||||
|
|
||||||
|
// Add the 3x3 grid.
|
||||||
|
for(int dy = 0; dy < 3; ++dy) |
||||||
|
for(int dx = 0; dx < 3; ++dx) |
||||||
|
dst.push_back(src.get(x+dx*2+1, y+dy*2+1)); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Return the SMXPanelAnimation. The rest of the animation state is internal.
|
||||||
|
SMXPanelAnimation SMXPanelAnimation::GetLoadedAnimation(int pad, int panel, SMX_LightsType type) |
||||||
|
{ |
||||||
|
g_Lock.AssertNotLockedByCurrentThread(); |
||||||
|
LockMutex L(g_Lock); |
||||||
|
return pad_states[pad].animations[panel][type].animation; |
||||||
|
} |
||||||
|
|
||||||
|
// Load an array of animation frames as a panel animation. Each frame must
|
||||||
|
// be 14x15.
|
||||||
|
void SMXPanelAnimation::Load(const vector<SMXGif::SMXGifFrame> &frames, int panel) |
||||||
|
{ |
||||||
|
m_aPanelGraphics.clear(); |
||||||
|
m_iFrameDurations.clear(); |
||||||
|
m_iLoopFrame = -1; |
||||||
|
|
||||||
|
for(int frame_no = 0; frame_no < frames.size(); ++frame_no) |
||||||
|
{ |
||||||
|
const SMXGif::SMXGifFrame &gif_frame = frames[frame_no]; |
||||||
|
|
||||||
|
// If the bottom-left pixel is opaque, this is the loop frame, which marks the
|
||||||
|
// frame the animation should start at after a loop. This is global to the
|
||||||
|
// animation, not specific to each panel.
|
||||||
|
if(gif_frame.frame.get(0, gif_frame.frame.height-1).color[3] != 0) |
||||||
|
{ |
||||||
|
// We shouldn't see more than one of these. If we do, use the first.
|
||||||
|
if(m_iLoopFrame != -1) |
||||||
|
m_iLoopFrame = frame_no; |
||||||
|
} |
||||||
|
|
||||||
|
// Extract this frame.
|
||||||
|
vector<SMXGif::Color> panel_graphic; |
||||||
|
ConvertToPanelGraphic(gif_frame.frame, panel_graphic, panel); |
||||||
|
m_aPanelGraphics.push_back(panel_graphic); |
||||||
|
|
||||||
|
// GIFs have a very low-resolution duration field, with 10ms units.
|
||||||
|
// The panels run at 30 FPS internally, or 33 1/3 ms, but GIF can only
|
||||||
|
// represent 30ms or 40ms. Most applications will probably output 30,
|
||||||
|
// but snap both 30ms and 40ms to exactly 30 FPS to make sure animations
|
||||||
|
// that are meant to run at native framerate do.
|
||||||
|
float seconds; |
||||||
|
if(gif_frame.milliseconds == 30 || gif_frame.milliseconds == 40) |
||||||
|
seconds = 1 / 30.0f; |
||||||
|
else |
||||||
|
seconds = gif_frame.milliseconds / 1000.0; |
||||||
|
|
||||||
|
m_iFrameDurations.push_back(seconds); |
||||||
|
} |
||||||
|
|
||||||
|
// By default, loop back to the first frame.
|
||||||
|
if(m_iLoopFrame == -1) |
||||||
|
m_iLoopFrame = 0; |
||||||
|
} |
||||||
|
|
||||||
|
// Load a GIF into SMXLoadedPanelAnimations::animations.
|
||||||
|
bool SMX_LightsAnimation_Load(const char *gif, int size, int pad, SMX_LightsType type, const char **error) |
||||||
|
{ |
||||||
|
// Parse the GIF.
|
||||||
|
string buf(gif, size); |
||||||
|
vector<SMXGif::SMXGifFrame> frames; |
||||||
|
if(!SMXGif::DecodeGIF(buf, frames) || frames.empty()) |
||||||
|
{ |
||||||
|
*error = "The GIF couldn't be read."; |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
// Check the dimensions of the image. We only need to check the first, the
|
||||||
|
// others will always have the same size.
|
||||||
|
if(frames[0].width != 14 || frames[0].height != 15) |
||||||
|
{ |
||||||
|
*error = "The GIF must be 14x15."; |
||||||
|
return false; |
||||||
|
} |
||||||
|
|
||||||
|
// Lock while we access pad_states.
|
||||||
|
g_Lock.AssertNotLockedByCurrentThread(); |
||||||
|
LockMutex L(g_Lock); |
||||||
|
|
||||||
|
// Load the animation for each panel into SMXPanelAnimations.
|
||||||
|
for(int panel = 0; panel < 9; ++panel) |
||||||
|
{ |
||||||
|
SMXPanelAnimation &animation = pad_states[pad].animations[panel][type].animation; |
||||||
|
animation.Load(frames, panel); |
||||||
|
} |
||||||
|
|
||||||
|
return true; |
||||||
|
} |
||||||
|
|
||||||
|
// A thread to handle setting light animations. We do this in a separate
|
||||||
|
// thread rather than in the SMXManager thread so this can be treated as
|
||||||
|
// if it's external application thread, and it's making normal threaded
|
||||||
|
// calls to SetLights.
|
||||||
|
class PanelAnimationThread: public SMXThread |
||||||
|
{ |
||||||
|
public: |
||||||
|
static shared_ptr<PanelAnimationThread> g_pSingleton; |
||||||
|
PanelAnimationThread(): |
||||||
|
SMXThread(g_Lock) |
||||||
|
{ |
||||||
|
Start("SMX light animations"); |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
void ThreadMain() |
||||||
|
{ |
||||||
|
m_Lock.Lock(); |
||||||
|
|
||||||
|
// Update lights at 30 FPS.
|
||||||
|
const int iDelayMS = 33; |
||||||
|
|
||||||
|
while(!m_bShutdown) |
||||||
|
{ |
||||||
|
// Run a single panel lights update.
|
||||||
|
UpdateLights(); |
||||||
|
|
||||||
|
// Wait up to 30 FPS, or until we're signalled. We can only be signalled
|
||||||
|
// if we're shutting down, so we don't need to worry about partial frame
|
||||||
|
// delays.
|
||||||
|
m_Event.Wait(iDelayMS); |
||||||
|
} |
||||||
|
|
||||||
|
m_Lock.Unlock(); |
||||||
|
} |
||||||
|
|
||||||
|
// Return lights for the given pad and pad state, using the loaded panel animations.
|
||||||
|
void GetCurrentLights(string &asLightsDataOut, int pad, int iPadState) |
||||||
|
{ |
||||||
|
m_Lock.AssertLockedByCurrentThread(); |
||||||
|
|
||||||
|
// Get this pad's configuration.
|
||||||
|
SMXConfig config; |
||||||
|
if(!SMXManager::g_pSMX->GetDevice(pad)->GetConfig(config)) |
||||||
|
return; |
||||||
|
|
||||||
|
AnimationStateForPad &pad_state = pad_states[pad]; |
||||||
|
|
||||||
|
// Make sure the correct animations are playing.
|
||||||
|
for(int panel = 0; panel < 9; ++panel) |
||||||
|
{ |
||||||
|
// The released animation is always playing.
|
||||||
|
pad_state.animations[panel][SMX_LightsType_Released].Play(); |
||||||
|
|
||||||
|
// The pressed animation only plays while the button is pressed,
|
||||||
|
// and rewind when it's released.
|
||||||
|
bool bPressed = iPadState & (1 << panel); |
||||||
|
if(bPressed) |
||||||
|
pad_state.animations[panel][SMX_LightsType_Pressed].Play(); |
||||||
|
else |
||||||
|
pad_state.animations[panel][SMX_LightsType_Pressed].Stop(); |
||||||
|
} |
||||||
|
|
||||||
|
// Set the current state.
|
||||||
|
asLightsDataOut = pad_state.GetLightsCommand(iPadState, config); |
||||||
|
|
||||||
|
// Advance animations.
|
||||||
|
for(int panel = 0; panel < 9; ++panel) |
||||||
|
{ |
||||||
|
for(auto &animation_state: pad_state.animations[panel]) |
||||||
|
animation_state.Update(); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Run a single light animation update.
|
||||||
|
void UpdateLights() |
||||||
|
{ |
||||||
|
string asLightsData[2]; |
||||||
|
for(int pad = 0; pad < 2; pad++) |
||||||
|
{ |
||||||
|
int iPadState = SMXManager::g_pSMX->GetDevice(pad)->GetInputState(); |
||||||
|
GetCurrentLights(asLightsData[pad], pad, iPadState); |
||||||
|
} |
||||||
|
|
||||||
|
// Update lights.
|
||||||
|
SMXManager::g_pSMX->SetLights(asLightsData); |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
void SMX_LightsAnimation_SetAuto(bool enable) |
||||||
|
{ |
||||||
|
if(!enable) |
||||||
|
{ |
||||||
|
// If we're turning off, shut down the thread if it's running.
|
||||||
|
if(PanelAnimationThread::g_pSingleton) |
||||||
|
PanelAnimationThread::g_pSingleton->Shutdown(); |
||||||
|
PanelAnimationThread::g_pSingleton.reset(); |
||||||
|
return; |
||||||
|
} |
||||||
|
|
||||||
|
// Create the animation thread if it's not already running.
|
||||||
|
if(PanelAnimationThread::g_pSingleton) |
||||||
|
return; |
||||||
|
PanelAnimationThread::g_pSingleton.reset(new PanelAnimationThread()); |
||||||
|
} |
||||||
|
|
||||||
|
shared_ptr<PanelAnimationThread> PanelAnimationThread::g_pSingleton; |
||||||
@ -0,0 +1,50 @@ |
|||||||
|
#ifndef SMXPanelAnimation_h |
||||||
|
#define SMXPanelAnimation_h |
||||||
|
|
||||||
|
#include <vector> |
||||||
|
#include "SMXGif.h" |
||||||
|
|
||||||
|
enum SMX_LightsType |
||||||
|
{ |
||||||
|
SMX_LightsType_Released, // animation while panels are released
|
||||||
|
SMX_LightsType_Pressed, // animation while panel is pressed
|
||||||
|
NUM_SMX_LightsType, |
||||||
|
}; |
||||||
|
|
||||||
|
// SMXPanelAnimation holds an animation, with graphics for a single panel.
|
||||||
|
class SMXPanelAnimation |
||||||
|
{ |
||||||
|
public: |
||||||
|
// Return the animation loaded by SMX_LightsAnimation_Load.
|
||||||
|
static SMXPanelAnimation GetLoadedAnimation(int pad, int panel, SMX_LightsType type); |
||||||
|
|
||||||
|
void Load(const std::vector<SMXGif::SMXGifFrame> &frames, int panel); |
||||||
|
|
||||||
|
// The high-level animated GIF frames:
|
||||||
|
std::vector<std::vector<SMXGif::Color>> m_aPanelGraphics; |
||||||
|
|
||||||
|
// The animation starts on frame 0. When it reaches the end, it loops
|
||||||
|
// back to this frame.
|
||||||
|
int m_iLoopFrame = 0; |
||||||
|
|
||||||
|
// The duration of each frame in seconds.
|
||||||
|
std::vector<float> m_iFrameDurations; |
||||||
|
}; |
||||||
|
|
||||||
|
// For SMX_API:
|
||||||
|
#include "../SMX.h" |
||||||
|
|
||||||
|
// High-level interface for C# bindings:
|
||||||
|
//
|
||||||
|
// Load an animated GIF as a panel animation. pad is the pad this animation is for (0 or 1),
|
||||||
|
// and type is which animation this is for. Any previously loaded animation will be replaced.
|
||||||
|
// On error, false is returned and error is set to a plain-text error message which is valid
|
||||||
|
// until the next call.
|
||||||
|
SMX_API bool SMX_LightsAnimation_Load(const char *gif, int size, int pad, SMX_LightsType type, const char **error); |
||||||
|
|
||||||
|
// Enable or disable automatically handling lights animations. If enabled, any animations
|
||||||
|
// loaded with SMX_LightsAnimation_Load will run automatically as long as the SDK is loaded.
|
||||||
|
// XXX: should we automatically disable SMX_SetLights when this is enabled?
|
||||||
|
SMX_API void SMX_LightsAnimation_SetAuto(bool enable); |
||||||
|
|
||||||
|
#endif |
||||||
Loading…
Reference in new issue