struct scene_producer::impl
{
std::wstring producer_name_;
+ std::wstring template_name_;
constraints pixel_constraints_;
video_format_desc format_desc_;
std::list<layer> layers_;
std::map<std::wstring, std::shared_ptr<core::variable>> variables_;
std::vector<std::wstring> variable_names_;
std::multimap<int64_t, marker> markers_by_frame_;
+ std::vector<std::shared_ptr<void>> task_subscriptions_;
monitor::subject monitor_subject_;
bool paused_ = true;
bool removed_ = false;
bool going_to_mark_ = false;
- impl(std::wstring producer_name, int width, int height, const video_format_desc& format_desc)
+ impl(
+ std::wstring producer_name,
+ std::wstring template_name,
+ int width,
+ int height,
+ const video_format_desc& format_desc)
: producer_name_(std::move(producer_name))
+ , template_name_(std::move(template_name))
, format_desc_(format_desc)
, aggregator_([=] (double x, double y) { return collission_detect(x, y); })
{
std::wstring print() const
{
- return L"scene[type=" + name() + L"]";
+ return L"scene[type=" + name() + L" template=" + template_name_ + L"]";
}
std::wstring name() const
boost::property_tree::wptree info;
info.add(L"type", L"scene");
info.add(L"producer-name", name());
+ info.add(L"template-name", template_name_);
info.add(L"frame-number", frame_number_.get());
info.add(L"timeline-frame-number", timeline_frame_number_.get());
}
};
-scene_producer::scene_producer(std::wstring producer_name, int width, int height, const video_format_desc& format_desc)
- : impl_(new impl(std::move(producer_name), width, height, format_desc))
+scene_producer::scene_producer(std::wstring producer_name, std::wstring template_name, int width, int height, const video_format_desc& format_desc)
+ : impl_(new impl(std::move(producer_name), std::move(template_name), width, height, format_desc))
{
}
class scene_producer : public frame_producer_base
{
public:
- scene_producer(std::wstring producer_name, int width, int height, const video_format_desc& format_desc);
+ scene_producer(std::wstring producer_name, std::wstring template_name, int width, int height, const video_format_desc& format_desc);
~scene_producer();
draw_frame receive_impl() override;
if (!found)
return core::frame_producer::empty();
- std::wstring filename = *found;
+ auto filename = *found;
+ auto template_name = get_relative(filename, env::template_folder()).wstring();
- CASPAR_SCOPED_CONTEXT_MSG(get_relative(filename, env::template_folder()).string() + ": ");
+ CASPAR_SCOPED_CONTEXT_MSG(template_name + L": ");
boost::property_tree::wptree root;
boost::filesystem::wifstream file(filename);
int width = ptree_get<int>(root, L"scene.<xmlattr>.width");
int height = ptree_get<int>(root, L"scene.<xmlattr>.height");
- auto scene = spl::make_shared<scene_producer>(L"scene", width, height, dependencies.format_desc);
+ auto scene = spl::make_shared<scene_producer>(L"scene", template_name, width, height, dependencies.format_desc);
for (auto elem : root | witerate_children(L"scene.variables") | welement_context_iteration)
{
std::list<layer_record> layers;
layer_record master;
-
+
spl::shared_ptr<core::scene::scene_producer> scene_;
bool is_root_;
//if we don't have a master already, just assign this
if (master.layer == nullptr)
master = rec;
- else if ((rec.tags & layer_tag::explicit_dynamic) == layer_tag::explicit_dynamic)
+ else if ((rec.tags & layer_tag::explicit_dynamic) == layer_tag::explicit_dynamic)
{
- if((master.tags & layer_tag::explicit_dynamic) == layer_tag::none)
+ if((master.tags & layer_tag::explicit_dynamic) == layer_tag::none)
{
//if we have a master that's not explicitly tagged as dynamic but this layer is; use this as master
master = rec;
psd_document doc;
doc.parse(*found_file);
- auto root = spl::make_shared<core::scene::scene_producer>(L"psd", doc.width(), doc.height(), dependencies.format_desc);
+ auto root = spl::make_shared<core::scene::scene_producer>(L"psd", params.at(0), doc.width(), doc.height(), dependencies.format_desc);
std::vector<std::pair<std::wstring, spl::shared_ptr<core::text_producer>>> text_producers_by_layer_name;
dependencies.format_desc.duration,
dependencies.format_desc.name,
dependencies.format_desc.audio_cadence };
-
- auto group = spl::make_shared<core::scene::scene_producer>(psd_layer->name(), doc.width(), doc.height(), format_desc);
+
+ auto group = spl::make_shared<core::scene::scene_producer>(psd_layer->name(), L"layer group in " + params.at(0), doc.width(), doc.height(), format_desc);
auto& scene_layer = current.scene()->create_layer(group, psd_layer->location().x, psd_layer->location().y, psd_layer->name());
scene_layer.adjustments.opacity.set(psd_layer->opacity() / 255.0);
if(psd_layer->is_text() && !psd_layer->is_static())
{
std::wstring str = psd_layer->text_data().get(L"EngineDict.Editor.Text", L"");
-
+
core::text::text_info text_info(std::move(get_text_info(psd_layer->text_data())));
auto max_scale = std::max(abs(psd_layer->scale().x), abs(psd_layer->scale().y));
text_info.size *= max_scale;
text_info.scale_x = psd_layer->scale().x / max_scale;
text_info.scale_y = psd_layer->scale().y / max_scale;
- text_info.shear = 0;
+ text_info.shear = 0;
auto text_producer = core::text_producer::create(dependencies.frame_factory, 0, 0, str, text_info, doc.width(), doc.height());
//text_producer->pixel_constraints().width.set(psd_layer->size().width);
//text_producer->pixel_constraints().height.set(psd_layer->size().height);
core::text::string_metrics metrics = text_producer->measure_string(str);
-
+
//adjustment_x = -2; //the 2 offset is just a hack for now. don't know why our text is rendered 2 px to the right of that in photoshop
//adjustment_y = metrics.bearingY;
layer_producer = text_producer;
var.on_change([=]() {
hotswap->producer().set(dependencies.producer_registry->create_producer(dependencies, root->get_variable(layer_name).as<std::wstring>().get()));
});*/
-
+
}
else
hotswap->producer().set(dependencies.producer_registry->create_producer(dependencies, layer_name));
-
+
layer_producer = hotswap;
}
else if(psd_layer->is_solid())
if (psd_layer->mask().has_vector()) {
if (psd_layer->is_placeholder() && psd_layer->is_cornerpin()) {
-
+
psd::point<int> layer_pos{ static_cast<int>(scene_layer->position.x.get()), static_cast<int>(scene_layer->position.y.get()) };
auto unbind_and_set = [&layer_pos](caspar::core::scene::coord& c, const caspar::psd::point<int>& pt) {
c.x.unbind();
}
if (scene_stack.size() != 1) {
-
+
}
root->reverse_layers();
scene_stack.top().calculate();
#include <core/help/help_repository.h>
#include <core/help/help_sink.h>
#include <core/help/util.h>
+#include <core/consumer/syncto/syncto_consumer.h>
#include <core/producer/text/text_producer.h>
#include <protocol/amcp/amcp_command_repository.h>