c-mendoza
8 years ago
23 changed files with 2292 additions and 966 deletions
File diff suppressed because it is too large
@ -0,0 +1,209 @@ |
|||||
|
//
|
||||
|
// magSlide.cpp
|
||||
|
// Copyright (c) 2017 Cristobal Mendoza
|
||||
|
// http://cuppetellimendoza.com
|
||||
|
//
|
||||
|
|
||||
|
#include "magSlide.h" |
||||
|
#include "magSlideTransition.h" |
||||
|
|
||||
|
#pragma mark magSlide |
||||
|
|
||||
|
int magSlide::idCount = 0; |
||||
|
|
||||
|
magSlide::magSlide(std::string type) |
||||
|
{ |
||||
|
this->type = type; |
||||
|
position = ofPoint(0, 0); |
||||
|
id = magSlide::idCount; |
||||
|
magSlide::idCount++; |
||||
|
} |
||||
|
|
||||
|
void magSlide::update(u_int64_t deltaTime) |
||||
|
{ |
||||
|
transition->update(deltaTime); |
||||
|
runningTime += deltaTime; |
||||
|
|
||||
|
switch (slideState) |
||||
|
{ |
||||
|
// case SlideState::BuildIn:
|
||||
|
// if (runningTime >= buildInDuration)
|
||||
|
// {
|
||||
|
// setState(Normal);
|
||||
|
// activeTransition = nullptr;
|
||||
|
// }
|
||||
|
// break;
|
||||
|
|
||||
|
case SlideState::Normal: |
||||
|
if (runningTime >= buildOutStartTime) |
||||
|
{ |
||||
|
setState(BuildOut); |
||||
|
} |
||||
|
break; |
||||
|
|
||||
|
case SlideState::BuildOut: |
||||
|
if (runningTime >= endTime) |
||||
|
{ |
||||
|
setState(Complete); |
||||
|
} |
||||
|
break; |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
void magSlide::setSize(float w, float h) |
||||
|
{ |
||||
|
width = w; |
||||
|
height = h; |
||||
|
} |
||||
|
|
||||
|
void magSlide::setResizeOption(magSlide::ResizeOptions resizeOption) |
||||
|
{ |
||||
|
this->resizeOption = resizeOption; |
||||
|
} |
||||
|
|
||||
|
magSlide::ResizeOptions magSlide::getResizeOption() const |
||||
|
{ |
||||
|
return resizeOption; |
||||
|
} |
||||
|
|
||||
|
void magSlide::setDuration(u_int64_t duration) |
||||
|
{ |
||||
|
this->duration = duration; |
||||
|
} |
||||
|
|
||||
|
void magSlide::setState(SlideState state) |
||||
|
{ |
||||
|
// Don't do anything if the new state is the same
|
||||
|
// as the current one:
|
||||
|
if (slideState == state) return; |
||||
|
|
||||
|
slideState = state; |
||||
|
ofEventArgs args; |
||||
|
ofNotifyEvent(slideStateChangedEvent, args, this); |
||||
|
|
||||
|
if (slideState == Complete) |
||||
|
{ |
||||
|
ofNotifyEvent(slideCompleteEvent, args, this); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void magSlide::setTransitionDuration(u_int64_t tDuration) |
||||
|
{ |
||||
|
buildOutDuration = tDuration; |
||||
|
} |
||||
|
|
||||
|
const std::string magSlide::getSlideStateName() |
||||
|
{ |
||||
|
switch (slideState) |
||||
|
{ |
||||
|
// case SlideState::BuildIn:
|
||||
|
// return "BuildIn";
|
||||
|
case SlideState::BuildOut: |
||||
|
return "BuildOut"; |
||||
|
case Normal: |
||||
|
return "Normal"; |
||||
|
case SlideState::Complete: |
||||
|
return "Complete"; |
||||
|
case SlideState::Off: |
||||
|
return "Off"; |
||||
|
} |
||||
|
|
||||
|
return "unknown"; |
||||
|
} |
||||
|
|
||||
|
void magSlide::start(u_int64_t startTime) |
||||
|
{ |
||||
|
this->startTime = startTime; |
||||
|
runningTime = 0; |
||||
|
endTime = duration + buildOutDuration; |
||||
|
buildOutStartTime = endTime - buildOutDuration; |
||||
|
slideState = magSlide::SlideState::Normal; |
||||
|
// if (buildIn != nullptr)
|
||||
|
// {
|
||||
|
// activeTransition = buildIn;
|
||||
|
// activeTransition->start();
|
||||
|
// }
|
||||
|
position.set(0, 0); |
||||
|
opacity = 255; |
||||
|
isComplete = false; |
||||
|
} |
||||
|
|
||||
|
void magSlide::draw() |
||||
|
{ |
||||
|
ofSetColor(255, opacity); |
||||
|
if(transition->isActive()) |
||||
|
{ |
||||
|
transition->draw(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
|
////////////////////////////////////////////////////////
|
||||
|
#pragma mark MAG_IMAGE_SLIDE |
||||
|
////////////////////////////////////////////////////////
|
||||
|
|
||||
|
magImageSlide::magImageSlide() : magSlide("magImageSlide") {} |
||||
|
|
||||
|
magImageSlide::~magImageSlide() {} |
||||
|
|
||||
|
void magImageSlide::setup(ofImage &image) |
||||
|
{ |
||||
|
// Make a copy of the image:
|
||||
|
this->image = ofImage(image); |
||||
|
image.setAnchorPercent(0.5, 0.5); |
||||
|
width = image.getWidth(); |
||||
|
height = image.getHeight(); |
||||
|
} |
||||
|
|
||||
|
void magImageSlide::draw() |
||||
|
{ |
||||
|
magSlide::draw(); |
||||
|
image.draw(position, width, height); |
||||
|
} |
||||
|
|
||||
|
////////////////////////////////////////////////////////
|
||||
|
#pragma mark MAG_VIDEO_SLIDE |
||||
|
////////////////////////////////////////////////////////
|
||||
|
|
||||
|
magVideoSlide::magVideoSlide() : magSlide("magVideoSlide") |
||||
|
{} |
||||
|
|
||||
|
magVideoSlide::~magVideoSlide() |
||||
|
{ |
||||
|
videoPlayer.stop(); |
||||
|
} |
||||
|
|
||||
|
bool magVideoSlide::setup(ofFile &file, bool useVideoDuration) |
||||
|
{ |
||||
|
|
||||
|
bool success = videoPlayer.load(file.getAbsolutePath()); |
||||
|
|
||||
|
if (success) |
||||
|
{ |
||||
|
videoPlayer.setAnchorPercent(0.5, 0.5); |
||||
|
if (useVideoDuration) |
||||
|
{ |
||||
|
useVideoForDuration(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return success; |
||||
|
} |
||||
|
|
||||
|
void magVideoSlide::update() |
||||
|
{ |
||||
|
videoPlayer.update(); |
||||
|
} |
||||
|
|
||||
|
void magVideoSlide::draw() |
||||
|
{ |
||||
|
magSlide::draw(); |
||||
|
videoPlayer.draw(position.x, position.y, width, height); |
||||
|
} |
||||
|
|
||||
|
void magVideoSlide::useVideoForDuration() |
||||
|
{ |
||||
|
duration = u_int64_t((videoPlayer.getDuration()*1000)) - buildOutDuration; |
||||
|
} |
||||
|
|
||||
@ -0,0 +1,263 @@ |
|||||
|
//
|
||||
|
// Created by Cristobal Mendoza on 11/9/17.
|
||||
|
//
|
||||
|
|
||||
|
#ifndef MAGSLIDE_H |
||||
|
#define MAGSLIDE_H |
||||
|
|
||||
|
#include "ofMain.h" |
||||
|
|
||||
|
class magSlideTransition; |
||||
|
|
||||
|
class magSlide |
||||
|
{ |
||||
|
public: |
||||
|
magSlide(std::string type); |
||||
|
// ~magSlide();
|
||||
|
virtual void update(u_int64_t deltaTime); |
||||
|
virtual void draw(); |
||||
|
|
||||
|
/**
|
||||
|
* Sets the slide up for playback. This method must be |
||||
|
* called before displaying the slide. |
||||
|
* @param startTime |
||||
|
*/ |
||||
|
void start(u_int64_t startTime); |
||||
|
|
||||
|
enum ResizeOptions : short |
||||
|
{ |
||||
|
/**
|
||||
|
* No resizing applied, displays the slide in its native pixel dimensions. |
||||
|
* This is the default behavior. |
||||
|
*/ |
||||
|
NoResize = 0, |
||||
|
/**
|
||||
|
* Explicitly set a slide to display in its native dimension. |
||||
|
* None and NoResize result in the same output, but if you specify |
||||
|
* a default resizing option in your slideshow and you want a particular |
||||
|
* slide not to resize, you must specify this option. Otherwise the |
||||
|
* slide show option will apply. |
||||
|
*/ |
||||
|
Native, |
||||
|
|
||||
|
/**
|
||||
|
* Sets width and height to match the source's. |
||||
|
* This will distort the slide if the aspect ratios |
||||
|
* don't match. |
||||
|
*/ |
||||
|
Fit, |
||||
|
|
||||
|
/**
|
||||
|
* Resizes the largest dimension to the source's max, |
||||
|
* the other dimension is resized proportionally. |
||||
|
*/ |
||||
|
FitProportionally, |
||||
|
|
||||
|
/**
|
||||
|
* Resizes the shortest dimensions to the source's max, |
||||
|
*/ |
||||
|
FillProportionally, |
||||
|
}; |
||||
|
|
||||
|
enum SlideState : short |
||||
|
{ |
||||
|
Off = 0, |
||||
|
// BuildIn,
|
||||
|
Normal, |
||||
|
BuildOut, |
||||
|
Complete |
||||
|
}; |
||||
|
|
||||
|
const std::string &getType() |
||||
|
{ return type; } |
||||
|
|
||||
|
float getWidth() |
||||
|
{ return width; } |
||||
|
|
||||
|
float getHeight() |
||||
|
{ return height; } |
||||
|
|
||||
|
float getOpacity() const |
||||
|
{ |
||||
|
return opacity; |
||||
|
} |
||||
|
|
||||
|
void setOpacity(float opacity) |
||||
|
{ |
||||
|
magSlide::opacity = opacity; |
||||
|
} |
||||
|
|
||||
|
/**
|
||||
|
* Change the display size of a slide. This will implicitly |
||||
|
* set resizeOptions to ResizeOption.NoResize. |
||||
|
* This method does not resize the pixel source of the slide. |
||||
|
* @param w The new width |
||||
|
* @param h The new height |
||||
|
*/ |
||||
|
virtual void setSize(float w, float h); |
||||
|
|
||||
|
u_int64_t getDuration() |
||||
|
{ |
||||
|
return duration; |
||||
|
} |
||||
|
|
||||
|
/**
|
||||
|
* Sets the display time of the slide, excluding |
||||
|
* builds (in or out) |
||||
|
* @param duration in milliseconds. |
||||
|
*/ |
||||
|
void setDuration(u_int64_t duration); |
||||
|
|
||||
|
/**
|
||||
|
* Sets the duration of the buildIn and buildOut |
||||
|
* transitions. Transition times are added to the |
||||
|
* duration of the slide. |
||||
|
* @param tDuration in milliseconds. |
||||
|
*/ |
||||
|
void setTransitionDuration(u_int64_t tDuration); |
||||
|
|
||||
|
ResizeOptions getResizeOption() const; |
||||
|
void setResizeOption(ResizeOptions resizeOption); |
||||
|
|
||||
|
SlideState getSlideState() const |
||||
|
{ |
||||
|
return slideState; |
||||
|
} |
||||
|
|
||||
|
bool isSlideComplete() |
||||
|
{ return isComplete; } |
||||
|
|
||||
|
int getId() |
||||
|
{ return id; } |
||||
|
|
||||
|
const std::string getSlideStateName(); |
||||
|
|
||||
|
//////////////////////////////
|
||||
|
/// Events
|
||||
|
//////////////////////////////
|
||||
|
ofEvent<ofEventArgs> slideCompleteEvent; |
||||
|
ofEvent<ofEventArgs> slideStateChangedEvent; |
||||
|
|
||||
|
friend class magSlideShowSource; |
||||
|
|
||||
|
protected: |
||||
|
int id; |
||||
|
std::string type; |
||||
|
float width; |
||||
|
float height; |
||||
|
ofPoint position; |
||||
|
public: |
||||
|
const ofPoint &getPosition() const |
||||
|
{ |
||||
|
return position; |
||||
|
} |
||||
|
|
||||
|
void setPosition(const ofPoint &position) |
||||
|
{ |
||||
|
magSlide::position = position; |
||||
|
} |
||||
|
|
||||
|
void setPosition(float x, float y) |
||||
|
{ |
||||
|
position.set(x, y); |
||||
|
} |
||||
|
|
||||
|
|
||||
|
protected: |
||||
|
float opacity = 255; |
||||
|
ResizeOptions resizeOption = NoResize; |
||||
|
SlideState slideState = Off; |
||||
|
bool isComplete = false; |
||||
|
|
||||
|
// std::shared_ptr<magSlideTransition> buildIn = nullptr;
|
||||
|
// std::shared_ptr<magSlideTransition> buildOut = nullptr;
|
||||
|
std::shared_ptr<magSlideTransition> transition = nullptr; |
||||
|
public: |
||||
|
const shared_ptr<magSlideTransition> &getTransition() const |
||||
|
{ |
||||
|
return transition; |
||||
|
} |
||||
|
|
||||
|
protected: |
||||
|
/**
|
||||
|
* The duration of the slide in millis, not counting builds |
||||
|
*/ |
||||
|
u_int64_t duration; |
||||
|
|
||||
|
/**
|
||||
|
* The start time of the slide in milliseconds, in "local time". |
||||
|
* In practice, this means that the start time is always 0. |
||||
|
*/ |
||||
|
u_int64_t startTime; |
||||
|
|
||||
|
/**
|
||||
|
* The end time of the slide in milliseconds, in "local time". |
||||
|
* The endTime is startTime + buildInDuration + duration + buildOutDuration. |
||||
|
*/ |
||||
|
u_int64_t endTime; |
||||
|
|
||||
|
/**
|
||||
|
* The duration of the build in transition or effect, in milliseconds. |
||||
|
*/ |
||||
|
// u_int64_t buildInDuration;
|
||||
|
|
||||
|
/**
|
||||
|
* The duration of the build out transition or effect, in milliseconds. |
||||
|
*/ |
||||
|
u_int64_t buildOutDuration; |
||||
|
|
||||
|
/**
|
||||
|
* The "local time" start of the build out transition. This time should also |
||||
|
* signal the enqueuing of the next slide, if applicable. |
||||
|
*/ |
||||
|
u_int64_t buildOutStartTime; |
||||
|
|
||||
|
/**
|
||||
|
* The amount of time the slide has been displayed, in milliseconds. |
||||
|
* This constitutes the "local time" of the slide. |
||||
|
*/ |
||||
|
u_int64_t runningTime; |
||||
|
|
||||
|
void setState(SlideState state); |
||||
|
|
||||
|
static int idCount; |
||||
|
}; |
||||
|
|
||||
|
class magImageSlide : public magSlide |
||||
|
{ |
||||
|
public: |
||||
|
magImageSlide(); |
||||
|
~ magImageSlide(); |
||||
|
/**
|
||||
|
* Sets up an image slide. |
||||
|
* @param image is copied into the member magImageSlide::image and is |
||||
|
* not modified in any way. |
||||
|
*/ |
||||
|
void setup(ofImage &image); |
||||
|
|
||||
|
void draw(); |
||||
|
|
||||
|
protected: |
||||
|
ofImage image; |
||||
|
}; |
||||
|
|
||||
|
class magVideoSlide : public magSlide |
||||
|
{ |
||||
|
public: |
||||
|
magVideoSlide(); |
||||
|
~magVideoSlide(); |
||||
|
bool setup(ofFile &file, bool useVideoDuration = false); |
||||
|
void update(); |
||||
|
void draw(); |
||||
|
|
||||
|
/**
|
||||
|
* Sets the slide duration to the duration of the video. |
||||
|
* magSlide::duration will be changed by this call, so if you later |
||||
|
* change your mind you'll have to use magSlide::setDuration. |
||||
|
*/ |
||||
|
void useVideoForDuration(); |
||||
|
protected: |
||||
|
ofVideoPlayer videoPlayer; |
||||
|
}; |
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,498 @@ |
|||||
|
//
|
||||
|
// magSlideShowSource.cpp
|
||||
|
// Copyright (c) 2017 Cristobal Mendoza
|
||||
|
// http://cuppetellimendoza.com
|
||||
|
//
|
||||
|
|
||||
|
|
||||
|
#include "magSlideShowSource.h" |
||||
|
#include "magSlideTransition.h" |
||||
|
#include "SettingsLoader.h" |
||||
|
#include "magSlideTransitionFactory.h" |
||||
|
|
||||
|
magSlideShowSource::magSlideShowSource() |
||||
|
{ |
||||
|
name = "Slide Show Source"; |
||||
|
currentSlideIndex = 0; |
||||
|
isPlaying = false; |
||||
|
} |
||||
|
|
||||
|
bool magSlideShowSource::initialize(magSlideShowSource::Settings settings) |
||||
|
{ |
||||
|
this->settings = settings; |
||||
|
bool success = true; |
||||
|
|
||||
|
if (settings.width <= 0 || settings.height <= 0) |
||||
|
{ |
||||
|
ofLogError("magSlideShowSource::initialize") << "Invalid value for width or height. Width and height " |
||||
|
"must be assigned in your Settings struct!"; |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
// Allocate the FBO:
|
||||
|
allocate(settings.width, settings.height); |
||||
|
|
||||
|
// If there is a path in slidesFolderPath, attempt
|
||||
|
// to load the folder and any files in it:
|
||||
|
if (!settings.slidesFolderPath.empty()) |
||||
|
{ |
||||
|
// ofDirectory dir = ofDirectory(settings.slidesFolderPath);
|
||||
|
success = createFromFolderContents(settings.slidesFolderPath); |
||||
|
|
||||
|
if (!success) |
||||
|
{ |
||||
|
ofLogError("magSlideShowSource::initialize") << "Failed to create slide show from folder " |
||||
|
<< settings.slidesFolderPath; |
||||
|
return success; |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
else if (!settings.slideshowFilePath.empty()) |
||||
|
{ |
||||
|
// try to load slide show from xml
|
||||
|
success = false; |
||||
|
} |
||||
|
return success; |
||||
|
} |
||||
|
|
||||
|
void magSlideShowSource::setup() |
||||
|
{ |
||||
|
ofx::piMapper::FboSource::setup(); |
||||
|
} |
||||
|
|
||||
|
void magSlideShowSource::update() |
||||
|
{ |
||||
|
if (!isPlaying) return; |
||||
|
|
||||
|
auto nowTime = ofGetElapsedTimeMillis(); |
||||
|
deltaTime = nowTime-lastTime; |
||||
|
runningTime += deltaTime; |
||||
|
lastTime = nowTime; |
||||
|
|
||||
|
// ofLogVerbose() << "Delta: " << deltaTime << " running: " << runningTime;
|
||||
|
|
||||
|
for (auto &slide : activeSlides) |
||||
|
{ |
||||
|
slide->update(deltaTime); |
||||
|
} |
||||
|
|
||||
|
// Erase any complete slides:
|
||||
|
auto iter = activeSlides.begin(); |
||||
|
for (; iter < activeSlides.end(); iter++) |
||||
|
{ |
||||
|
if ((*iter)->isSlideComplete()) |
||||
|
{ |
||||
|
// ofLogVerbose() << "Removing from active slides id: " << (*iter)->getId();
|
||||
|
activeSlides.erase(iter); |
||||
|
--iter; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (activeSlides.size() == 0 && isPlaying) |
||||
|
{ |
||||
|
ofEventArgs args; |
||||
|
isPlaying = false; |
||||
|
ofNotifyEvent(slideshowCompleteEvent, args, this); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void magSlideShowSource::draw() |
||||
|
{ |
||||
|
ofBackground(0, 0); |
||||
|
ofPushMatrix(); |
||||
|
ofPushStyle(); |
||||
|
ofTranslate(getWidth()/2.0f, getHeight()/2.0f); |
||||
|
ofEnableAlphaBlending(); |
||||
|
ofSetRectMode(OF_RECTMODE_CENTER); |
||||
|
ofFill(); |
||||
|
ofSetColor(255, 255); |
||||
|
for (auto &slide : activeSlides) |
||||
|
{ |
||||
|
slide->draw(); |
||||
|
} |
||||
|
ofPopStyle(); |
||||
|
ofPopMatrix(); |
||||
|
ofDisableAlphaBlending(); |
||||
|
} |
||||
|
|
||||
|
bool magSlideShowSource::createFromFolderContents(std::string path) |
||||
|
{ |
||||
|
ofDirectory dir = ofDirectory(path); |
||||
|
slides.clear(); |
||||
|
|
||||
|
if (!dir.isDirectory()) |
||||
|
{ |
||||
|
ofLogError("magSlideShowSource::createFromFolderContents") << "Folder path " << dir.getAbsolutePath() |
||||
|
<< " is not a directory"; |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
auto sortedDir = dir.getSorted(); |
||||
|
auto files = sortedDir.getFiles(); |
||||
|
|
||||
|
if (files.size() < 1) |
||||
|
{ |
||||
|
ofLogError("magSlideShowSource::createFromFolderContents") << "Folder " << dir.getAbsolutePath() << " is empty"; |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
ofImage tempImage; |
||||
|
for (auto &file : files) |
||||
|
{ |
||||
|
if (tempImage.load(file)) |
||||
|
{ |
||||
|
// make a new image slide
|
||||
|
auto slide = std::make_shared<magImageSlide>(); |
||||
|
slide->setup(tempImage); |
||||
|
slide->setDuration(static_cast<u_int64_t>(settings.slideDuration*1000)); |
||||
|
slide->setTransitionDuration(static_cast<u_int64_t>(settings.transitionDuration*1000)); |
||||
|
// if (settings.transitionName == "")
|
||||
|
addSlide(slide); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
auto ext = ofToLower(file.getExtension()); |
||||
|
|
||||
|
static std::vector<std::string> movieExtensions = { |
||||
|
"mov", "qt", // Mac
|
||||
|
"mp4", "m4p", "m4v", // MPEG
|
||||
|
"mpg", "mp2", "mpeg", "mpe", "mpv", "m2v", // MPEG
|
||||
|
"3gp", // Phones
|
||||
|
"avi", "wmv", "asf", // Windows
|
||||
|
"webm", "mkv", "flv", "vob", // Other containers
|
||||
|
"ogv", "ogg", |
||||
|
"drc", "mxf" |
||||
|
}; |
||||
|
|
||||
|
// Check if the extension matches known movie formats:
|
||||
|
if (ofContains(movieExtensions, ext)) |
||||
|
{ |
||||
|
// Make a new video slide
|
||||
|
auto slide = std::make_shared<magVideoSlide>(); |
||||
|
if (slide->setup(file)) |
||||
|
{ |
||||
|
slide->setDuration(settings.slideDuration*1000.0); |
||||
|
slide->setTransitionDuration(settings.transitionDuration*1000.0); |
||||
|
addSlide(slide); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
ofLogError("magSlideShowSource") << "Failed loading video: " << file.getAbsolutePath(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
if (slides.size() > 0) |
||||
|
{ |
||||
|
return true; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
return false; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
bool magSlideShowSource::loadFromXml() |
||||
|
{ |
||||
|
auto *loader = ofx::piMapper::SettingsLoader::instance(); |
||||
|
auto xml = ofxXmlSettings(); |
||||
|
Settings settings; |
||||
|
|
||||
|
if (!xml.load(loader->getLastLoadedFilename())) |
||||
|
{ |
||||
|
ofLogError("magSlideShowSource") << "Could not load settings file " << loader->getLastLoadedFilename(); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
xml.pushTag("surfaces"); |
||||
|
if (!xml.pushTag("magSlideShow")) |
||||
|
{ |
||||
|
ofLogError("magSlideShowSource") << "Slide show settings not found in " << loader->getLastLoadedFilename(); |
||||
|
return false; |
||||
|
} |
||||
|
|
||||
|
settings.width = xml.getValue("Width", settings.width); |
||||
|
settings.height = xml.getValue("Height", settings.height); |
||||
|
|
||||
|
// Default slide duration:
|
||||
|
settings.slideDuration = xml.getValue("SlideDuration", settings.slideDuration); |
||||
|
|
||||
|
// Default loop:
|
||||
|
if (xml.pushTag("Loop")) |
||||
|
{ |
||||
|
auto type = xml.getValue("Type", ""); |
||||
|
if (type == "NONE") |
||||
|
{ |
||||
|
settings.loopType = LoopType::NONE; |
||||
|
} |
||||
|
else if (type == "NORMAL") |
||||
|
{ |
||||
|
settings.loopType = LoopType::NORMAL; |
||||
|
} |
||||
|
else if (type == "PING-PONG") |
||||
|
{ |
||||
|
settings.loopType = LoopType::PING_PONG; |
||||
|
} |
||||
|
|
||||
|
settings.numLoops = xml.getValue("Count", settings.numLoops); |
||||
|
xml.popTag(); |
||||
|
} |
||||
|
|
||||
|
// Default resize options:
|
||||
|
auto ropts = xml.getValue("ResizeOption", ""); |
||||
|
if (ropts == "NoResize") |
||||
|
{ |
||||
|
settings.resizeOption = magSlide::NoResize; |
||||
|
} |
||||
|
else if (ropts == "Native") |
||||
|
{ |
||||
|
settings.resizeOption = magSlide::Native; |
||||
|
} |
||||
|
else if (ropts == "Fit") |
||||
|
{ |
||||
|
settings.resizeOption = magSlide::Fit; |
||||
|
} |
||||
|
else if (ropts == "FitProportionally") |
||||
|
{ |
||||
|
settings.resizeOption = magSlide::FitProportionally; |
||||
|
} |
||||
|
else if (ropts == "FillProportionally") |
||||
|
{ |
||||
|
settings.resizeOption = magSlide::FillProportionally; |
||||
|
} |
||||
|
|
||||
|
settings.transitionName = "Dissolve"; |
||||
|
settings.transitionDuration = 0.5; |
||||
|
initialize(settings); |
||||
|
|
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
void magSlideShowSource::addSlide(std::shared_ptr<magSlide> slide) |
||||
|
{ |
||||
|
// ofLogVerbose("addSlide") << slide->getId();
|
||||
|
slides.insert(slides.begin(), slide); |
||||
|
auto rOption = slide->getResizeOption(); |
||||
|
|
||||
|
// If the slide does not have a resize option assign
|
||||
|
// the slide show's option
|
||||
|
if (rOption == magSlide::ResizeOptions::NoResize) |
||||
|
{ |
||||
|
rOption = settings.resizeOption; |
||||
|
} |
||||
|
|
||||
|
// Resize the slide according to the resize option:
|
||||
|
switch (rOption) |
||||
|
{ |
||||
|
float sw, sh, ratio; |
||||
|
|
||||
|
case magSlide::ResizeOptions::FitProportionally: |
||||
|
sw = slide->getWidth(); |
||||
|
sh = slide->getHeight(); |
||||
|
|
||||
|
if (sw > sh) |
||||
|
{ |
||||
|
ratio = (float) getWidth()/sw; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
ratio = (float) getHeight()/sh; |
||||
|
} |
||||
|
|
||||
|
slide->setSize(sw*ratio, sh*ratio); |
||||
|
break; |
||||
|
|
||||
|
case magSlide::ResizeOptions::FillProportionally: |
||||
|
sw = slide->getWidth(); |
||||
|
sh = slide->getHeight(); |
||||
|
|
||||
|
if (sw > sh) |
||||
|
{ |
||||
|
ratio = (float) getHeight()/sh; |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
ratio = (float) getWidth()/sw; |
||||
|
} |
||||
|
|
||||
|
slide->setSize(sw*ratio, sh*ratio); |
||||
|
break; |
||||
|
|
||||
|
case magSlide::Fit: |
||||
|
slide->setSize(getWidth(), getHeight()); |
||||
|
break; |
||||
|
} |
||||
|
|
||||
|
// Add transitions:
|
||||
|
|
||||
|
if (!settings.transitionName.empty()) |
||||
|
{ |
||||
|
static ofParameterGroup bogusParamGroup; // This is temporary so that things compile
|
||||
|
|
||||
|
auto tf = magSlideTransitionFactory::instance(); |
||||
|
// slide->buildIn = tf->createTransition(settings.transitionName,
|
||||
|
// slide,
|
||||
|
// bogusParamGroup,
|
||||
|
// slide->buildInDuration);
|
||||
|
slide->transition = tf->createTransition(settings.transitionName, |
||||
|
slide, |
||||
|
bogusParamGroup, |
||||
|
slide->buildOutDuration); |
||||
|
} |
||||
|
//// void method(const void * sender, ArgumentsType &args)
|
||||
|
ofAddListener(slide->slideStateChangedEvent, this, &magSlideShowSource::slideStateChanged); |
||||
|
ofAddListener(slide->slideCompleteEvent, this, &magSlideShowSource::slideComplete); |
||||
|
|
||||
|
} |
||||
|
|
||||
|
void magSlideShowSource::play() |
||||
|
{ |
||||
|
if (!isPlaying) |
||||
|
{ |
||||
|
runningTime = 0; |
||||
|
lastTime = ofGetElapsedTimeMillis(); |
||||
|
isPlaying = true; |
||||
|
auto currentSlide = slides[currentSlideIndex]; |
||||
|
enqueueSlide(currentSlide, ofGetElapsedTimeMillis()); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
void magSlideShowSource::pause() |
||||
|
{ |
||||
|
isPlaying = false; |
||||
|
} |
||||
|
|
||||
|
void magSlideShowSource::playNextSlide() |
||||
|
{ |
||||
|
//TODO
|
||||
|
// I should check here to see if there are less than two slides.
|
||||
|
// If so, we should probably return
|
||||
|
|
||||
|
currentSlideIndex += direction; |
||||
|
ofEventArgs args; |
||||
|
|
||||
|
// This makes sure that we are doing a signed integer comparison,
|
||||
|
// otherwise things get weird
|
||||
|
int num = slides.size(); |
||||
|
switch (settings.loopType) |
||||
|
{ |
||||
|
case LoopType::NONE: |
||||
|
if (currentSlideIndex >= slides.size() || currentSlideIndex < 0) |
||||
|
{ |
||||
|
// If we are not looping and we are out of bounds, return
|
||||
|
// without enqueueing a slide. This will cause the slide show
|
||||
|
// to end once the last slide builds out.
|
||||
|
return; |
||||
|
} |
||||
|
break; |
||||
|
case LoopType::NORMAL: |
||||
|
if (currentSlideIndex >= num) |
||||
|
{ |
||||
|
loopCount++; |
||||
|
if (loopCount == settings.numLoops) |
||||
|
{ |
||||
|
// Return without enqueueing a new slide if we have
|
||||
|
// reached the max number of loops.
|
||||
|
return; |
||||
|
} |
||||
|
currentSlideIndex = 0; |
||||
|
ofNotifyEvent(slideshowWillLoopEvent, args, this); |
||||
|
} |
||||
|
else if (currentSlideIndex < 0) |
||||
|
{ |
||||
|
loopCount++; |
||||
|
if (loopCount == settings.numLoops) |
||||
|
{ |
||||
|
// Return without enqueueing a new slide if we have
|
||||
|
// reached the max number of loops.
|
||||
|
return; |
||||
|
} |
||||
|
currentSlideIndex = slides.size()-1; |
||||
|
ofNotifyEvent(slideshowWillLoopEvent, args, this); |
||||
|
} |
||||
|
break; |
||||
|
case LoopType::PING_PONG: |
||||
|
|
||||
|
int num = slides.size(); |
||||
|
if (currentSlideIndex >= num) |
||||
|
{ |
||||
|
loopCount++; |
||||
|
if (loopCount == settings.numLoops) |
||||
|
{ |
||||
|
// Return without enqueueing a new slide if we have
|
||||
|
// reached the max number of loops.
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
direction = -1; |
||||
|
currentSlideIndex = slides.size()-2; |
||||
|
ofNotifyEvent(slideshowWillLoopEvent, args, this); |
||||
|
} |
||||
|
else if (currentSlideIndex < 0) |
||||
|
{ |
||||
|
loopCount++; |
||||
|
if (loopCount == settings.numLoops) |
||||
|
{ |
||||
|
// Return without enqueueing a new slide if we have
|
||||
|
// reached the max number of loops.
|
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
direction = 1; |
||||
|
currentSlideIndex = 1; |
||||
|
ofNotifyEvent(slideshowWillLoopEvent, args, this); |
||||
|
} |
||||
|
break; |
||||
|
} |
||||
|
|
||||
|
enqueueSlide(slides[currentSlideIndex], ofGetElapsedTimeMillis()); |
||||
|
} |
||||
|
|
||||
|
void magSlideShowSource::playPrevSlide() |
||||
|
{ |
||||
|
currentSlideIndex -= (direction*2); |
||||
|
playNextSlide(); |
||||
|
} |
||||
|
|
||||
|
void magSlideShowSource::playSlide(int slideIndex) |
||||
|
{ |
||||
|
currentSlideIndex = slideIndex-direction; |
||||
|
playNextSlide(); |
||||
|
} |
||||
|
|
||||
|
void magSlideShowSource::enqueueSlide(std::shared_ptr<magSlide> slide, u_int64_t startTime) |
||||
|
{ |
||||
|
// ofLogVerbose() << "Enqueuing slide " << currentSlideIndex << " slide id: " << slide->getId();
|
||||
|
slide->start(startTime); |
||||
|
activeSlides.insert(activeSlides.begin(), slide); |
||||
|
} |
||||
|
|
||||
|
void magSlideShowSource::slideStateChanged(const void *sender, ofEventArgs &args) |
||||
|
{ |
||||
|
magSlide *slide = (magSlide *) sender; |
||||
|
|
||||
|
// ofLogVerbose("slideStateChanged") << "Slide id: " << slide->getId() << " Slide state: "
|
||||
|
// << slide->getSlideStateName();
|
||||
|
if (slide->getSlideState() == magSlide::SlideState::BuildOut) |
||||
|
{ |
||||
|
// slide->transition->start();
|
||||
|
// ofLogVerbose() << "BuildOut " << slide->getId();
|
||||
|
playNextSlide(); |
||||
|
if (activeSlides.size() > 1) |
||||
|
{ |
||||
|
activeSlides[1]->transition->start(activeSlides[0]); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
void magSlideShowSource::slideComplete(const void *sender, ofEventArgs &args) |
||||
|
{ |
||||
|
magSlide *slide = (magSlide *) sender; |
||||
|
// ofLogVerbose() << "Slide Complete. id: " << slide->getId();
|
||||
|
slide->isComplete = true; |
||||
|
} |
||||
|
|
||||
|
|
||||
@ -0,0 +1,161 @@ |
|||||
|
//
|
||||
|
// magSlideShowSource.h
|
||||
|
// Copyright (c) 2017 Cristobal Mendoza
|
||||
|
// http://cuppetellimendoza.com
|
||||
|
//
|
||||
|
|
||||
|
#ifndef MAGSLIDESHOWSOURCE_H |
||||
|
#define MAGSLIDESHOWSOURCE_H |
||||
|
|
||||
|
#include "FboSource.h" |
||||
|
#include "magSlide.h" |
||||
|
|
||||
|
class magSlide; |
||||
|
|
||||
|
|
||||
|
class magSlideShowSource : public ofx::piMapper::FboSource |
||||
|
{ |
||||
|
public: |
||||
|
magSlideShowSource(); |
||||
|
struct Settings; // forward declaration
|
||||
|
bool initialize(magSlideShowSource::Settings settings); |
||||
|
void setup() override; |
||||
|
void update() override; |
||||
|
void draw() override; |
||||
|
|
||||
|
/**
|
||||
|
* Removes all slides and then attempts to create a new slide show |
||||
|
* based on the contents of the ofDirectory specified. The files may |
||||
|
* be images or videos, which will be transformed into the appropriate slide type. |
||||
|
* Any other file type in the directory is ignored (including other directories). |
||||
|
* The slide order is alphabetical according to filename. |
||||
|
* |
||||
|
* @param dir The ofDirectory to use as a source for a slide show. |
||||
|
* @return true if at least one slide was created. false is returned |
||||
|
* otherwise. Check the console for the specific error. |
||||
|
*/ |
||||
|
bool createFromFolderContents(std::string path); |
||||
|
|
||||
|
bool loadFromXml(); |
||||
|
void addSlide(std::shared_ptr<magSlide> slide); |
||||
|
void play(); |
||||
|
void pause(); |
||||
|
void playNextSlide(); |
||||
|
void playPrevSlide(); |
||||
|
void playSlide(int slideIndex); |
||||
|
|
||||
|
enum LoopType : int |
||||
|
{ |
||||
|
NONE = 0, |
||||
|
NORMAL, |
||||
|
PING_PONG |
||||
|
}; |
||||
|
|
||||
|
struct Settings |
||||
|
{ |
||||
|
/**
|
||||
|
* The pixel width of the FBO. |
||||
|
*/ |
||||
|
float width = 1280; |
||||
|
|
||||
|
/**
|
||||
|
* The pixel height of the FBO. |
||||
|
*/ |
||||
|
float height = 720; |
||||
|
/**
|
||||
|
* An optional default slide duration, in seconds. |
||||
|
* If a slide specifies a duration this value is ignored. |
||||
|
*/ |
||||
|
float slideDuration = 5; |
||||
|
|
||||
|
/**
|
||||
|
* An optional default transition for the slide show. |
||||
|
*/ |
||||
|
std::string transitionName = ""; |
||||
|
|
||||
|
/**
|
||||
|
* An optional default transition duration. If no transition |
||||
|
* is specified, this value is ignored; |
||||
|
*/ |
||||
|
float transitionDuration = 0; |
||||
|
|
||||
|
/**
|
||||
|
* If specified, all applicable files in the folder will |
||||
|
* be used as slides in the slide show. They will be ordered |
||||
|
* alphabetically according to their file names. |
||||
|
* |
||||
|
* If path is relative, the root will likely be the Data folder. |
||||
|
*/ |
||||
|
std::string slidesFolderPath = "sources/images"; |
||||
|
|
||||
|
/**
|
||||
|
* If specified, |
||||
|
*/ |
||||
|
std::string slideshowFilePath; |
||||
|
|
||||
|
|
||||
|
/**
|
||||
|
* Loop type for the slide show. See @code LoopType for options. |
||||
|
* The default is @code LoopType:None. |
||||
|
*/ |
||||
|
LoopType loopType = LoopType::NONE; |
||||
|
|
||||
|
/**
|
||||
|
* The number of loops to perform, if the loopType is not NONE. |
||||
|
* If the value is 0 or less than 0, the slide show loops forever. |
||||
|
*/ |
||||
|
int numLoops = 0; |
||||
|
|
||||
|
/**
|
||||
|
* The resizing option for the slide show. The default is FitProportionally. |
||||
|
* If a slide already has a resizing option applied, that option will be |
||||
|
* respected and this resizeOption will not be used. |
||||
|
*/ |
||||
|
magSlide::ResizeOptions resizeOption = magSlide::ResizeOptions::FitProportionally; |
||||
|
}; |
||||
|
|
||||
|
////////////////////////////////////////////
|
||||
|
//// Event Listeners
|
||||
|
////////////////////////////////////////////
|
||||
|
void slideStateChanged(const void* sender, ofEventArgs &args); |
||||
|
void slideComplete(const void* sender, ofEventArgs &args); |
||||
|
|
||||
|
|
||||
|
/**
|
||||
|
* Fires when the slide show is done, which happens when |
||||
|
* the loop count is equal to Settings::numLoops, or when |
||||
|
* the last slide is played when @code LoopType::NONE is specified. |
||||
|
* Sender is this slide show. |
||||
|
*/ |
||||
|
ofEvent<ofEventArgs> slideshowCompleteEvent; |
||||
|
|
||||
|
|
||||
|
/**
|
||||
|
* Fires when the slide show reaches the last slide |
||||
|
* and will perform a loop in the next call. |
||||
|
* Sender is this slide show. |
||||
|
*/ |
||||
|
ofEvent<ofEventArgs> slideshowWillLoopEvent; |
||||
|
|
||||
|
protected: |
||||
|
Settings settings; |
||||
|
std::vector<std::shared_ptr<magSlide>> slides; |
||||
|
|
||||
|
private: |
||||
|
// std::shared_ptr<magSlide> currentSlide;
|
||||
|
std::vector<std::shared_ptr<magSlide>> activeSlides; |
||||
|
void enqueueSlide(std::shared_ptr<magSlide> slide, u_int64_t startTime); |
||||
|
|
||||
|
u_int64_t lastTime; |
||||
|
u_int64_t deltaTime; |
||||
|
u_int64_t runningTime; |
||||
|
|
||||
|
bool isInitialized = false; |
||||
|
bool isPlaying = false; |
||||
|
int currentSlideIndex = 0; |
||||
|
int direction = 1; |
||||
|
int loopCount = 0; |
||||
|
}; |
||||
|
|
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,60 @@ |
|||||
|
//
|
||||
|
// magSlideTransition.cpp
|
||||
|
// Copyright (c) 2017 Cristobal Mendoza
|
||||
|
// http://cuppetellimendoza.com
|
||||
|
//
|
||||
|
|
||||
|
#include "magSlideTransition.h" |
||||
|
|
||||
|
void magSlideTransition::start(std::shared_ptr<magSlide> nextSlide) |
||||
|
{ |
||||
|
runningTime = 0; |
||||
|
active = true; |
||||
|
this->nextSlide = nextSlide; |
||||
|
} |
||||
|
|
||||
|
void magSlideTransition::update(u_int64_t timeDelta) |
||||
|
{ |
||||
|
if (!active) return; |
||||
|
|
||||
|
runningTime += timeDelta; |
||||
|
if (runningTime >= duration) |
||||
|
{ |
||||
|
ofEventArgs arghh; // arghhhh...
|
||||
|
nextSlide->setOpacity(255); |
||||
|
nextSlide->setPosition(0, 0); |
||||
|
end(); |
||||
|
transitionCompleteEvent.notify(this, arghh); |
||||
|
active = false; |
||||
|
} |
||||
|
|
||||
|
} |
||||
|
|
||||
|
u_int64_t magSlideTransition::getRunningTime() |
||||
|
{ |
||||
|
return runningTime; |
||||
|
} |
||||
|
|
||||
|
float magSlideTransition::getNormalizedTime() |
||||
|
{ |
||||
|
return (double)runningTime / (double)duration; |
||||
|
} |
||||
|
|
||||
|
|
||||
|
void magDissolveTransition::draw() |
||||
|
{ |
||||
|
slide->setOpacity(255 - (getNormalizedTime() * 255)); |
||||
|
nextSlide->setOpacity(getNormalizedTime()*255); |
||||
|
} |
||||
|
|
||||
|
void magDissolveTransition::start(std::shared_ptr<magSlide> nextSlide) |
||||
|
{ |
||||
|
magSlideTransition::start(nextSlide); |
||||
|
nextSlide->setOpacity(0); |
||||
|
} |
||||
|
|
||||
|
void magDissolveTransition::end() |
||||
|
{ |
||||
|
nextSlide->setOpacity(255); |
||||
|
slide->setOpacity(0); |
||||
|
} |
||||
@ -0,0 +1,129 @@ |
|||||
|
//
|
||||
|
// magSlideTransition.h
|
||||
|
// Copyright (c) 2017 Cristobal Mendoza
|
||||
|
// http://cuppetellimendoza.com
|
||||
|
//
|
||||
|
|
||||
|
#ifndef MAGSLIDETRANSITION_H |
||||
|
#define MAGSLIDETRANSITION_H |
||||
|
|
||||
|
#include "magSlide.h" |
||||
|
|
||||
|
class magSlideTransitionFactory; |
||||
|
|
||||
|
class magSlideTransition |
||||
|
{ |
||||
|
public: |
||||
|
/**
|
||||
|
* Subclassing notes: Make sure to provide a value for name in your |
||||
|
* magSlideTransition subclass. |
||||
|
*/ |
||||
|
magSlideTransition() { name = "Void"; } |
||||
|
/**
|
||||
|
* Begins the transition. This needs to be called in order for the |
||||
|
* transition to do anything. |
||||
|
* @param nextSlide The subsequent slide in the slide show needs to be |
||||
|
* passed here. |
||||
|
* |
||||
|
* You can override this call to set any initial conditions to the transition, |
||||
|
* but make sure to call this method in your override. |
||||
|
*/ |
||||
|
virtual void start(std::shared_ptr<magSlide> nextSlide); |
||||
|
|
||||
|
/**
|
||||
|
* Called automatically when the transition is complete. Useful to set |
||||
|
* end states for the parameters of the slide and nextSlide. Default implementation |
||||
|
* does nothing. |
||||
|
*/ |
||||
|
virtual void end(){} |
||||
|
|
||||
|
/**
|
||||
|
* NOTE: The transition settings system is not yet implemented. |
||||
|
* Called when the transition is created. Loads settings for magSlideTransition |
||||
|
* subclasses. The default implementation does nothing. |
||||
|
* @param settings ofParameterGroup with settings for your custom magSlideTransition |
||||
|
* subclass. |
||||
|
*/ |
||||
|
virtual void loadSettings(ofParameterGroup &settings){} |
||||
|
|
||||
|
/**
|
||||
|
* Updates the transition. |
||||
|
* @param timeDelta The elapsed time (in ms.) between the last call to update() and |
||||
|
* this one (i.e. the frame time). |
||||
|
* |
||||
|
* If you need to override update, make sure to call this implementation |
||||
|
* in your subclass. |
||||
|
*/ |
||||
|
virtual void update(u_int64_t timeDelta); |
||||
|
|
||||
|
/**
|
||||
|
* Draws the transition. Default implementation does nothing. |
||||
|
*/ |
||||
|
virtual void draw(){ |
||||
|
ofLogNotice("magSlideTransition") << "transition draw - this should be overriden " << getNormalizedTime(); |
||||
|
} |
||||
|
|
||||
|
/**
|
||||
|
* Current running time in milliseconds. |
||||
|
* @return u_int64_t |
||||
|
*/ |
||||
|
u_int64_t getRunningTime(); |
||||
|
|
||||
|
/**
|
||||
|
* Returns the current time in normalized form. |
||||
|
* 0 = start, 1 = end. |
||||
|
* @return Float between 0 and 1. |
||||
|
*/ |
||||
|
float getNormalizedTime(); |
||||
|
|
||||
|
string const &getName() const |
||||
|
{ |
||||
|
return name; |
||||
|
} |
||||
|
|
||||
|
const shared_ptr<magSlide> &getNextSlide() const |
||||
|
{ |
||||
|
return nextSlide; |
||||
|
} |
||||
|
|
||||
|
bool isActive() const |
||||
|
{ |
||||
|
return active; |
||||
|
} |
||||
|
|
||||
|
/**
|
||||
|
* Sender is a raw pointer to this magSlideTransition |
||||
|
*/ |
||||
|
ofEvent<ofEventArgs> transitionCompleteEvent; |
||||
|
|
||||
|
protected: |
||||
|
std::string name; |
||||
|
std::shared_ptr<magSlide> slide; |
||||
|
std::shared_ptr<magSlide> nextSlide; |
||||
|
|
||||
|
u_int64_t runningTime; |
||||
|
u_int64_t duration; |
||||
|
u_int64_t endTime; |
||||
|
bool active = false; |
||||
|
|
||||
|
|
||||
|
protected: |
||||
|
|
||||
|
friend class magSlideTransitionFactory; |
||||
|
}; |
||||
|
|
||||
|
class magDissolveTransition : public magSlideTransition |
||||
|
{ |
||||
|
public: |
||||
|
magDissolveTransition() |
||||
|
{ |
||||
|
name = "Dissolve"; |
||||
|
} |
||||
|
|
||||
|
void start(std::shared_ptr<magSlide> nextSlide) override; |
||||
|
|
||||
|
void draw() override; |
||||
|
void end() override; |
||||
|
}; |
||||
|
|
||||
|
#endif |
||||
@ -0,0 +1,76 @@ |
|||||
|
//
|
||||
|
// Created by Cristobal Mendoza on 12/3/17.
|
||||
|
//
|
||||
|
|
||||
|
#include "magSlideTransitionFactory.h" |
||||
|
|
||||
|
/*
|
||||
|
* |
||||
|
* |
||||
|
* |
||||
|
class Base {}; |
||||
|
|
||||
|
class DerivedA : public Base {}; |
||||
|
class DerivedB : public Base {}; |
||||
|
class DerivedC : public Base {}; |
||||
|
|
||||
|
Base* create(const std::string& type) |
||||
|
{ |
||||
|
static std::map<std::string, std::function<Base*()>> type_creator_map = |
||||
|
{ |
||||
|
{"DerivedA", [](){return new DerivedA();}}, |
||||
|
{"DerivedB", [](){return new DerivedB();}}, |
||||
|
{"DerivedC", [](){return new DerivedC();}} |
||||
|
}; |
||||
|
|
||||
|
auto it = type_creator_map.find(type); |
||||
|
if(it != type_creator_map.end()) |
||||
|
{ |
||||
|
return it->second(); |
||||
|
} |
||||
|
|
||||
|
return nullptr; |
||||
|
} |
||||
|
*/ |
||||
|
|
||||
|
magSlideTransitionFactory* magSlideTransitionFactory::_instance = 0; |
||||
|
|
||||
|
magSlideTransitionFactory::magSlideTransitionFactory() |
||||
|
{ |
||||
|
magSlideTransition voidTransition; |
||||
|
magDissolveTransition dissolve; |
||||
|
|
||||
|
registerTransition<magSlideTransition>(voidTransition); |
||||
|
registerTransition<magDissolveTransition>(dissolve); |
||||
|
} |
||||
|
|
||||
|
magSlideTransitionFactory* magSlideTransitionFactory::instance() |
||||
|
{ |
||||
|
if (_instance == 0) |
||||
|
{ |
||||
|
_instance = new magSlideTransitionFactory(); |
||||
|
} |
||||
|
|
||||
|
return _instance; |
||||
|
} |
||||
|
|
||||
|
std::shared_ptr<magSlideTransition> |
||||
|
magSlideTransitionFactory::createTransition(std::string transitionName, std::shared_ptr<magSlide> slide, |
||||
|
ofParameterGroup &settings, u_int64_t duration) |
||||
|
{ |
||||
|
std::shared_ptr<magSlideTransition> transition; |
||||
|
|
||||
|
if (transitionsMap.count(transitionName) > 0) |
||||
|
{ |
||||
|
transition = transitionsMap[transitionName](); |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
transition = transitionsMap[transition->getName()](); |
||||
|
} |
||||
|
|
||||
|
transition->slide = slide; |
||||
|
transition->duration = duration; |
||||
|
transition->loadSettings(settings); |
||||
|
return transition; |
||||
|
} |
||||
@ -0,0 +1,41 @@ |
|||||
|
//
|
||||
|
// Created by Cristobal Mendoza on 12/3/17.
|
||||
|
//
|
||||
|
|
||||
|
#ifndef MAGSLIDETRANSITIONFACTORY_H |
||||
|
#define MAGSLIDETRANSITIONFACTORY_H |
||||
|
|
||||
|
#include "magSlide.h" |
||||
|
#include "magSlideTransition.h" |
||||
|
|
||||
|
/**
|
||||
|
* Factory class to register and instantiate transitions. |
||||
|
*/ |
||||
|
class magSlideTransitionFactory |
||||
|
{ |
||||
|
public: |
||||
|
static magSlideTransitionFactory* instance(); |
||||
|
|
||||
|
std::shared_ptr<magSlideTransition> createTransition(string transitionName, |
||||
|
std::shared_ptr<magSlide> slide, |
||||
|
ofParameterGroup &group, |
||||
|
u_int64_t duration); |
||||
|
template<typename T> |
||||
|
void registerTransition(T transition) |
||||
|
{ |
||||
|
if (transitionsMap.count(transition.getName()) == 0) |
||||
|
{ |
||||
|
transitionsMap[transition.getName()] = [](){ |
||||
|
return std::make_shared<T>(); |
||||
|
}; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
protected: |
||||
|
std::unordered_map<std::string, std::function<std::shared_ptr<magSlideTransition>()>> transitionsMap; |
||||
|
private: |
||||
|
static magSlideTransitionFactory* _instance; |
||||
|
magSlideTransitionFactory(); |
||||
|
}; |
||||
|
|
||||
|
#endif //MAGSLIDETRANSITIONFACTORY_H
|
||||
Loading…
Reference in new issue