]> git.sesse.net Git - nageru/blobdiff - nageru/scene.cpp
Refactor out find_inputs_for_block().
[nageru] / nageru / scene.cpp
index 090f95be917884a1044239bb4046fc4d6726d613..fded0e00b494c72d8740c7382de31cfa334cea25 100644 (file)
@@ -67,10 +67,10 @@ size_t Scene::compute_chain_number_for_block(size_t block_idx) const
 int Scene::add_input(lua_State* L)
 {
        assert(lua_gettop(L) == 1 || lua_gettop(L) == 2);
-       Scene *chain = (Scene *)luaL_checkudata(L, 1, "Scene");
+       Scene *scene = (Scene *)luaL_checkudata(L, 1, "Scene");
 
        Block *block = new Block;
-       block->idx = chain->blocks.size();
+       block->idx = scene->blocks.size();
        if (lua_gettop(L) == 1) {
                // No parameter given, so a flexible input.
                block->alternatives.emplace_back(new EffectBlueprint(LIVE_INPUT_YCBCR));
@@ -104,18 +104,49 @@ int Scene::add_input(lua_State* L)
                assert(ok);
        }
        block->is_input = true;
-       chain->blocks.push_back(block);
+       scene->blocks.push_back(block);
 
        return wrap_lua_existing_object_nonowned<Block>(L, "Block", block);
 }
 
+void Scene::find_inputs_for_block(lua_State *L, Scene *scene, Block *block)
+{
+       if (lua_gettop(L) == 2) {
+               // Implicitly the last added effect.
+               assert(!scene->blocks.empty());
+               block->inputs.push_back(scene->blocks.size() - 1);
+               return;
+       }
+
+       for (int idx = 3; idx <= lua_gettop(L); ++idx) {
+               Block *input_block = nullptr;
+               if (luaL_testudata(L, idx, "Block")) {
+                       input_block = *(Block **)luaL_checkudata(L, idx, "Block");
+               } else {
+                       EffectBlueprint *blueprint = *(EffectBlueprint **)luaL_checkudata(L, idx, "EffectBlueprint");
+
+                       // Search through all the blocks to figure out which one contains this effect.
+                       for (Block *block : scene->blocks) {
+                               if (find(block->alternatives.begin(), block->alternatives.end(), blueprint) != block->alternatives.end()) {
+                                       input_block = block;
+                                       break;
+                               }
+                       }
+                       if (input_block == nullptr) {
+                               luaL_error(L, "Input effect in parameter #%d has not been added to this scene", idx - 1);
+                       }
+               }
+               block->inputs.push_back(input_block->idx);
+       }
+}
+
 int Scene::add_effect(lua_State* L)
 {
        assert(lua_gettop(L) >= 2);
-       Scene *chain = (Scene *)luaL_checkudata(L, 1, "Scene");
+       Scene *scene = (Scene *)luaL_checkudata(L, 1, "Scene");
 
        Block *block = new Block;
-       block->idx = chain->blocks.size();
+       block->idx = scene->blocks.size();
 
        if (lua_istable(L, 2)) {
                size_t len = lua_objlen(L, 2);
@@ -130,34 +161,8 @@ int Scene::add_effect(lua_State* L)
                block->alternatives.push_back(blueprint);
        }
 
-       // Find the inputs.
-       if (lua_gettop(L) == 2) {
-               assert(!chain->blocks.empty());
-               block->inputs.push_back(chain->blocks.size() - 1);
-       } else {
-               for (int idx = 3; idx <= lua_gettop(L); ++idx) {
-                       Block *input_block = nullptr;
-                       if (luaL_testudata(L, idx, "Block")) {
-                               input_block = *(Block **)luaL_checkudata(L, idx, "Block");
-                       } else {
-                               EffectBlueprint *blueprint = *(EffectBlueprint **)luaL_checkudata(L, idx, "EffectBlueprint");
-
-                               // Search through all the blocks to figure out which one contains this effect.
-                               for (Block *block : chain->blocks) {
-                                       if (find(block->alternatives.begin(), block->alternatives.end(), blueprint) != block->alternatives.end()) {
-                                               input_block = block;
-                                               break;
-                                       }
-                               }
-                               if (input_block == nullptr) {
-                                       luaL_error(L, "Input effect in parameter #%d has not been added to this chain", idx - 1);
-                               }
-                       }
-                       block->inputs.push_back(input_block->idx);
-               }
-       }
-
-       chain->blocks.push_back(block);
+       find_inputs_for_block(L, scene, block);
+       scene->blocks.push_back(block);
 
        return wrap_lua_existing_object_nonowned<Block>(L, "Block", block);
 }
@@ -165,11 +170,11 @@ int Scene::add_effect(lua_State* L)
 int Scene::add_optional_effect(lua_State* L)
 {
        assert(lua_gettop(L) >= 2);
-       Scene *chain = (Scene *)luaL_checkudata(L, 1, "Scene");
+       Scene *scene = (Scene *)luaL_checkudata(L, 1, "Scene");
 
        // NOTE: We only support effects with a single parent, since that's what IdentityEffect does.
        Block *block = new Block;
-       block->idx = chain->blocks.size();
+       block->idx = scene->blocks.size();
 
        EffectBlueprint *blueprint = *(EffectBlueprint **)luaL_checkudata(L, 2, "EffectBlueprint");
        block->alternatives.push_back(blueprint);
@@ -177,8 +182,8 @@ int Scene::add_optional_effect(lua_State* L)
        // An IdentityEffect will be the alternative for when the effect is disabled.
        block->alternatives.push_back(new EffectBlueprint(IDENTITY_EFFECT));
 
-       block->inputs.push_back(chain->blocks.size() - 1);
-       chain->blocks.push_back(block);
+       block->inputs.push_back(scene->blocks.size() - 1);
+       scene->blocks.push_back(block);
 
        return wrap_lua_existing_object_nonowned<Block>(L, "Block", block);
 }
@@ -191,8 +196,7 @@ Effect *Scene::instantiate_effects(const Block *block, size_t chain_idx, Scene::
        }
 
        // Find the chosen alternative for this block in this instance.
-       size_t chosen_alternative = (chain_idx / block->cardinality_base) % block->alternatives.size();
-       EffectType chosen_type = block->alternatives[chosen_alternative]->effect_type;
+       EffectType chosen_type = block->alternatives[block->chosen_alternative(chain_idx)]->effect_type;
 
        Effect *effect;
        switch (chosen_type) {
@@ -225,7 +229,7 @@ Effect *Scene::instantiate_effects(const Block *block, size_t chain_idx, Scene::
                break;
        }
        default:
-               effect = instantiate_effect(instantiation->chain.get(), block->alternatives[chosen_alternative]->effect_type);
+               effect = instantiate_effect(instantiation->chain.get(), chosen_type);
                instantiation->chain->add_effect(effect, inputs);
                break;
        }
@@ -243,11 +247,11 @@ int Scene::finalize(lua_State* L)
        } else {
                assert(lua_gettop(L) == 1);
        }
-       Scene *chain = (Scene *)luaL_checkudata(L, 1, "Scene");
+       Scene *scene = (Scene *)luaL_checkudata(L, 1, "Scene");
        Theme *theme = get_theme_updata(L);
 
        size_t base = 1;
-       for (Block *block : chain->blocks) {
+       for (Block *block : scene->blocks) {
                block->cardinality_base = base;
                base *= block->alternatives.size();
        }
@@ -259,20 +263,20 @@ int Scene::finalize(lua_State* L)
                        total_cardinality);
        }
 
-       Block *output_block = chain->blocks.back();
+       Block *output_block = scene->blocks.back();
        for (bool is_main_chain : { false, true }) {
                for (size_t chain_idx = 0; chain_idx < cardinality; ++chain_idx) {
                        if (only_one_mode && is_main_chain != chosen_mode) {
-                               chain->chains.emplace_back();
+                               scene->chains.emplace_back();
                                continue;
                        }
 
                        Scene::Instantiation instantiation;
-                       instantiation.chain.reset(new EffectChain(chain->aspect_nom, chain->aspect_denom, theme->get_resource_pool()));
-                       chain->instantiate_effects(output_block, chain_idx, &instantiation);
+                       instantiation.chain.reset(new EffectChain(scene->aspect_nom, scene->aspect_denom, theme->get_resource_pool()));
+                       scene->instantiate_effects(output_block, chain_idx, &instantiation);
 
                        add_outputs_and_finalize(instantiation.chain.get(), is_main_chain);
-                       chain->chains.emplace_back(move(instantiation));
+                       scene->chains.emplace_back(move(instantiation));
                }
        }
        return 0;
@@ -328,7 +332,7 @@ Scene::get_chain(Theme *theme, lua_State *L, unsigned num, const InputState &inp
                        } else if (block->signal_type_to_connect == Block::CONNECT_VIDEO) {
                                signals_to_connect.emplace(input, block->video_to_connect->get_card_index());
                        } else if (block->signal_type_to_connect == Block::CONNECT_NONE) {
-                               luaL_error(L, "An input in a chain was not connected to anything (forgot to call display())");
+                               luaL_error(L, "An input in a scene was not connected to anything (forgot to call display())");
                        } else {
                                assert(false);
                        }
@@ -532,6 +536,20 @@ int Block_enable(lua_State *L)
        return 0;
 }
 
+int Block_enable_if(lua_State *L)
+{
+       assert(lua_gettop(L) == 2);
+       Block *block = *(Block **)luaL_checkudata(L, 1, "Block");
+
+       if (block->alternatives.size() != 2 ||
+           block->alternatives[1]->effect_type != IDENTITY_EFFECT) {
+               luaL_error(L, "enable_if() called on something that wasn't added with add_optional_effect()");
+       }
+       bool enabled = checkbool(L, 2);
+       block->currently_chosen_alternative = enabled ? 0 : 1;
+       return 0;
+}
+
 int Block_disable(lua_State *L)
 {
        assert(lua_gettop(L) == 1);