jp9000
/
obs-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
obs-studio/libobs/obs-scene.c

3957 lines
97 KiB
C
Raw Permalink Normal View History

first commit
2013-09-30 19:37:13 -07:00
/******************************************************************************
libobs: Replace item_move_* signals These signals introduce unnecessary complexity. Instead of emitting a signal for a specific move direction, just signal that the scene has been reordered, that way the target just refreshes the list.
2015-02-17 09:54:45 -08:00
Copyright (C) 2013-2015 by Hugh Bailey <obs.jim@gmail.com>
Philippe Groarke <philippe.groarke@gmail.com>
first commit
2013-09-30 19:37:13 -07:00
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
With the permission of my fellow contributors, I'm switching obs-studio back to GPL v2+ to prevent issues between this project and the original OBS project, and for personal reasons to avoid legal ambiguity (not political reasons, I admittedly would prefer GPL v3+)
2013-12-02 21:24:38 -08:00
the Free Software Foundation, either version 2 of the License, or
first commit
2013-09-30 19:37:13 -07:00
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
#include "util/threading.h"
libobs: Implement and use better scaling function for 64-bit integers As os_gettime_ns() gets large the current scaling methods, mostly by casting to uint64_t, may lead to numerical overflows. Sweep the code and use util_mul_div64() where applicable. Signed-off-by: Hans Petter Selasky <hps@selasky.org>
2020-03-21 02:55:12 -07:00
#include "util/util_uint64.h"
first commit
2013-09-30 19:37:13 -07:00
#include "graphics/math-defs.h"
#include "obs-scene.h"
libobs: Fix leaking obs-internal.h Removes prior attempt to expose libcaption headers which really shouldnt have public. This instead moves the obs-internal include out of the public obs-scene.h and into it's implementation.
2021-01-28 18:43:15 -08:00
#include "obs-internal.h"
first commit
2013-09-30 19:37:13 -07:00
libobs: Change groups to actual public types (This commit also modifies UI) Changes groups to their own independent type, "group". This allows them to be used like other regular types, and allows the ability to reference groups in multiple scenes. Before, a group would always be linked to the scene it was in. This made it cumbersome for users to modify groups if they had a similar group in multiple scenes (they would have to modify each group in each scene). Making groups like other source types makes more sense to solve this issue so they can be referenced in multiple scenes at once. This also removes a significant amount of group-specific handling code required for implementing groups in the front-end. One limitation however: due to the way sub-items of groups are seamlessly modifiable and sortable as part of the whole scene, the user cannot have multiple references to the same group within one scene.
2018-07-15 18:50:33 -07:00
const struct obs_source_info group_info;
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
static void resize_group(obs_sceneitem_t *group);
libobs: Change groups to actual public types (This commit also modifies UI) Changes groups to their own independent type, "group". This allows them to be used like other regular types, and allows the ability to reference groups in multiple scenes. Before, a group would always be linked to the scene it was in. This made it cumbersome for users to modify groups if they had a similar group in multiple scenes (they would have to modify each group in each scene). Making groups like other source types makes more sense to solve this issue so they can be referenced in multiple scenes at once. This also removes a significant amount of group-specific handling code required for implementing groups in the front-end. One limitation however: due to the way sub-items of groups are seamlessly modifiable and sortable as part of the whole scene, the user cannot have multiple references to the same group within one scene.
2018-07-15 18:50:33 -07:00
static void resize_scene(obs_scene_t *scene);
libobs: Refactor item signaling (add func to signal parent)
2018-06-01 02:34:32 -07:00
static void signal_parent(obs_scene_t *parent, const char *name,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
calldata_t *params);
static void get_ungrouped_transform(obs_sceneitem_t *group, struct vec2 *pos,
struct vec2 *scale, float *rot);
libobs: Defer update of scene item texture If the scene item crop/filtering is updated, instead of creating/destroying the item texture on the spot, update it in the graphics thread to prevent potential race conditions (especially when the crop function for example could be called from within obs_scene_enum_items in some situations, which would lock the graphics and scene mutexes in the wrong order).
2018-07-19 00:53:30 -07:00
static inline bool crop_enabled(const struct obs_sceneitem_crop *crop);
static inline bool item_texture_enabled(const struct obs_scene_item *item);
libobs: When ungrouping groups, duplicate items Because groups can now be used in multiple scenes at once, it's important that if the user wishes to ungroup a group, that they must be able to keep the group intact if it exists in other scenes. This requires duplicating all scene items (as well as their hotkey/private data) instead of just reparenting the subitems. This fixes an issue where if the user had the group referenced in multiple scenes, the group would become empty in other scenes.
2018-08-05 04:11:22 -07:00
static void init_hotkeys(obs_scene_t *scene, obs_sceneitem_t *item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
const char *name);
libobs: Refactor item signaling (add func to signal parent)
2018-06-01 02:34:32 -07:00
libobs: Add comment warning about scene mutex lock ordering A comment that serves as a reminder to anyone who might need to edit the scene code. If the graphics mutex must be locked, it must be locked first before entering the scene mutexes, or outside of the scene mutexes.
2016-01-16 10:53:28 -08:00
/* NOTE: For proper mutex lock order (preventing mutual cross-locks), never
* lock the graphics mutex inside either of the scene mutexes.
*
* Another thing that must be done to prevent that cross-lock (and improve
* performance), is to not create/release/update sources within the scene
* mutexes.
*
* It's okay to lock the graphics mutex before locking either of the scene
* mutexes, but not after.
*/
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
static const char *obs_scene_signals[] = {
"void item_add(ptr scene, ptr item)",
"void item_remove(ptr scene, ptr item)",
libobs: Replace item_move_* signals These signals introduce unnecessary complexity. Instead of emitting a signal for a specific move direction, just signal that the scene has been reordered, that way the target just refreshes the list.
2015-02-17 09:54:45 -08:00
"void reorder(ptr scene)",
libobs: Add refresh signal to scenes This signal is used to specify when a scene needs a full refresh of its item list.
2020-02-07 16:35:20 -08:00
"void refresh(ptr scene)",
libobs: Add API to hide/show scene items
2015-03-22 20:28:27 -07:00
"void item_visible(ptr scene, ptr item, bool visible)",
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
"void item_select(ptr scene, ptr item)",
"void item_deselect(ptr scene, ptr item)",
"void item_transform(ptr scene, ptr item)",
libobs, UI: Implement item_locked event Similar to item_visible, this event fires whenever a scene item is locked or unlocked. This allows the UI and libobs to remain in sync regarding scene elements' statuses.
2019-05-24 04:34:41 -07:00
"void item_locked(ptr scene, ptr item, bool locked)",
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
NULL,
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
};
libobs: Implement additional source blending modes
2021-10-24 08:45:15 -07:00
static const struct {
enum gs_blend_type src_color;
enum gs_blend_type src_alpha;
enum gs_blend_type dst_color;
enum gs_blend_type dst_alpha;
enum gs_blend_op_type op;
} obs_blend_mode_params[] = {
/* clang-format off */
// OBS_BLEND_NORMAL
{
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_INVSRCALPHA,
GS_BLEND_INVSRCALPHA,
GS_BLEND_OP_ADD,
},
// OBS_BLEND_ADDITIVE
{
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_OP_ADD,
},
// OBS_BLEND_SUBTRACT
{
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_OP_REVERSE_SUBTRACT,
},
// OBS_BLEND_SCREEN
{
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_INVSRCCOLOR,
GS_BLEND_INVSRCALPHA,
GS_BLEND_OP_ADD
},
// OBS_BLEND_MULTIPLY
{
GS_BLEND_DSTCOLOR,
GS_BLEND_DSTALPHA,
GS_BLEND_INVSRCALPHA,
GS_BLEND_INVSRCALPHA,
GS_BLEND_OP_ADD
},
// OBS_BLEND_LIGHTEN
{
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_OP_MAX,
},
// OBS_BLEND_DARKEN
{
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_ONE,
GS_BLEND_OP_MIN,
},
/* clang-format on */
};
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
static inline void signal_item_remove(struct obs_scene_item *item)
Added add/remove signals to scenes Scenes will now signal via their source when an item has been added or removed from them. "add" - Item added to the scene. Parameters: "scene": Scene that the item was added to. "item": Item that was added. "remove" - Item removed from the scene. Parameters: "scene": Scene that the item was removed from. "item": Item that was removed.
2014-01-04 12:38:56 -08:00
{
libobs: Use calldata with stack for simple signals Makes signals use stack memory rather than allocate memory each time. Most likely a completely insignificant and pointless optimization.
2016-01-18 20:01:58 -08:00
struct calldata params;
uint8_t stack[128];
calldata_init_fixed(&params, stack, sizeof(stack));
(API Change) libobs/callback: Unsquish names Renamed: To: ------------------------------------------------- calldata_getdata calldata_get_data calldata_getint calldata_get_int calldata_getfloat calldata_get_float calldata_getbool calldata_get_bool calldata_getptr calldata_get_ptr calldata_getstring calldata_get_string calldata_setdata calldata_set_data calldata_setint calldata_set_int calldata_setfloat calldata_set_float calldata_setbool calldata_set_bool calldata_setptr calldata_set_ptr calldata_setstring calldata_set_string
2014-08-05 17:49:28 -07:00
calldata_set_ptr(&params, "item", item);
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
libobs: Refactor item signaling (add func to signal parent)
2018-06-01 02:34:32 -07:00
signal_parent(item->parent, "item_remove", &params);
Added add/remove signals to scenes Scenes will now signal via their source when an item has been added or removed from them. "add" - Item added to the scene. Parameters: "scene": Scene that the item was added to. "item": Item that was added. "remove" - Item removed from the scene. Parameters: "scene": Scene that the item was removed from. "item": Item that was removed.
2014-01-04 12:38:56 -08:00
}
(API Change) libobs: Pass type data to get_name callbacks API changed from: obs_source_info::get_name(void) obs_output_info::get_name(void) obs_encoder_info::get_name(void) obs_service_info::get_name(void) API changed to: obs_source_info::get_name(void *type_data) obs_output_info::get_name(void *type_data) obs_encoder_info::get_name(void *type_data) obs_service_info::get_name(void *type_data) This allows the type data to be used when getting the name of the object (useful for plugin wrappers primarily). NOTE: Though a parameter was added, this is backward-compatible with older plugins due to calling convention. The new parameter will simply be ignored by older plugins, and the stack (if used) will be cleaned up by the caller.
2015-09-16 01:30:51 -07:00
static const char *scene_getname(void *unused)
added support for jansson, added new output files, made some adjustments to the API, fixed a UI subclass issue
2013-11-13 05:24:20 -08:00
{
(API Change) libobs: Pass type data to get_name callbacks API changed from: obs_source_info::get_name(void) obs_output_info::get_name(void) obs_encoder_info::get_name(void) obs_service_info::get_name(void) API changed to: obs_source_info::get_name(void *type_data) obs_output_info::get_name(void *type_data) obs_encoder_info::get_name(void *type_data) obs_service_info::get_name(void *type_data) This allows the type data to be used when getting the name of the object (useful for plugin wrappers primarily). NOTE: Though a parameter was added, this is backward-compatible with older plugins due to calling convention. The new parameter will simply be ignored by older plugins, and the stack (if used) will be cleaned up by the caller.
2015-09-16 01:30:51 -07:00
UNUSED_PARAMETER(unused);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
return "Scene";
added support for jansson, added new output files, made some adjustments to the API, fixed a UI subclass issue
2013-11-13 05:24:20 -08:00
}
libobs: Change groups to actual public types (This commit also modifies UI) Changes groups to their own independent type, "group". This allows them to be used like other regular types, and allows the ability to reference groups in multiple scenes. Before, a group would always be linked to the scene it was in. This made it cumbersome for users to modify groups if they had a similar group in multiple scenes (they would have to modify each group in each scene). Making groups like other source types makes more sense to solve this issue so they can be referenced in multiple scenes at once. This also removes a significant amount of group-specific handling code required for implementing groups in the front-end. One limitation however: due to the way sub-items of groups are seamlessly modifiable and sortable as part of the whole scene, the user cannot have multiple references to the same group within one scene.
2018-07-15 18:50:33 -07:00
static const char *group_getname(void *unused)
{
UNUSED_PARAMETER(unused);
return "Group";
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
static void *scene_create(obs_data_t *settings, struct obs_source *source)
first commit
2013-09-30 19:37:13 -07:00
{
libobs: Zero scene data instead of setting members manually
2018-06-01 02:09:46 -07:00
struct obs_scene *scene = bzalloc(sizeof(struct obs_scene));
scene->source = source;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
libobs: Fix groups not being recognized as groups The id of the source was being pointer compared rather than string compared, so naturally with the source versioning system where the string is duplicated, the pointers no longer matched.
2020-03-09 17:08:51 -07:00
if (strcmp(source->info.id, group_info.id) == 0) {
libobs: Change groups to actual public types (This commit also modifies UI) Changes groups to their own independent type, "group". This allows them to be used like other regular types, and allows the ability to reference groups in multiple scenes. Before, a group would always be linked to the scene it was in. This made it cumbersome for users to modify groups if they had a similar group in multiple scenes (they would have to modify each group in each scene). Making groups like other source types makes more sense to solve this issue so they can be referenced in multiple scenes at once. This also removes a significant amount of group-specific handling code required for implementing groups in the front-end. One limitation however: due to the way sub-items of groups are seamlessly modifiable and sortable as part of the whole scene, the user cannot have multiple references to the same group within one scene.
2018-07-15 18:50:33 -07:00
scene->is_group = true;
scene->custom_size = true;
scene->cx = 0;
scene->cy = 0;
}
(API Change) Use 'get' convention in libobs (base) Instead of having functions like obs_signal_handler() that can fail to properly specify their actual intent in the name (does it signal a handler, or does it return a signal handler?), always prefix functions that are meant to get information with 'get' to make its functionality more explicit. Previous names: New names: ----------------------------------------------------------- obs_audio obs_get_audio obs_video obs_get_video obs_signalhandler obs_get_signal_handler obs_prochandler obs_get_proc_handler obs_source_signalhandler obs_source_get_signal_handler obs_source_prochandler obs_source_get_proc_handler obs_output_signalhandler obs_output_get_signal_handler obs_output_prochandler obs_output_get_proc_handler obs_service_signalhandler obs_service_get_signal_handler obs_service_prochandler obs_service_get_proc_handler
2014-08-04 09:09:02 -07:00
signal_handler_add_array(obs_source_get_signal_handler(source),
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_scene_signals);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
libobs: Fix pthread mutex leaks
2021-08-23 22:06:00 -07:00
if (pthread_mutex_init_recursive(&scene->audio_mutex) != 0) {
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
blog(LOG_ERROR, "scene_create: Couldn't initialize audio "
"mutex");
goto fail;
}
libobs: Fix pthread mutex leaks
2021-08-23 22:06:00 -07:00
if (pthread_mutex_init_recursive(&scene->video_mutex) != 0) {
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
blog(LOG_ERROR, "scene_create: Couldn't initialize video "
"mutex");
Use recursive mutex for scene mutex Fixes a deadlock when trying to remove a source from the GUI. The scene item signal handlers would mark the source as removed which results in the video thread also trying to run obs_sceneitem_destroy thereby deadlocking the video thread (and the GUI thread)
2014-01-29 13:46:39 -08:00
goto fail;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
}
first commit
2013-09-30 19:37:13 -07:00
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
UNUSED_PARAMETER(settings);
first commit
2013-09-30 19:37:13 -07:00
return scene;
Use recursive mutex for scene mutex Fixes a deadlock when trying to remove a source from the GUI. The scene item signal handlers would mark the source as removed which results in the video thread also trying to run obs_sceneitem_destroy thereby deadlocking the video thread (and the GUI thread)
2014-01-29 13:46:39 -08:00
fail:
bfree(scene);
return NULL;
first commit
2013-09-30 19:37:13 -07:00
}
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
#define audio_lock(scene) pthread_mutex_lock(&scene->audio_mutex)
#define video_lock(scene) pthread_mutex_lock(&scene->video_mutex)
#define audio_unlock(scene) pthread_mutex_unlock(&scene->audio_mutex)
#define video_unlock(scene) pthread_mutex_unlock(&scene->video_mutex)
static inline void full_lock(struct obs_scene *scene)
{
video_lock(scene);
audio_lock(scene);
}
static inline void full_unlock(struct obs_scene *scene)
{
audio_unlock(scene);
video_unlock(scene);
}
libobs: Release scene items outside of scene mutexes Prevents a mutual lock with the scene mutex and graphics mutex. In libobs/obs-video.c, the graphics mutex could be locked first, then the scene mutexes second, while in the UI thread, the scene mutexes could be locked first, then when a scene item is being destroyed, a source could be destroyed, and sometimes sources would lock the graphics mutex second. A possible additional solution is to defer source destroys to the video thread.
2016-01-03 15:42:10 -08:00
static void set_visibility(struct obs_scene_item *item, bool vis);
static inline void detach_sceneitem(struct obs_scene_item *item);
static inline void remove_without_release(struct obs_scene_item *item)
{
item->removed = true;
set_visibility(item, false);
signal_item_remove(item);
detach_sceneitem(item);
}
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
static void remove_all_items(struct obs_scene *scene)
first commit
2013-09-30 19:37:13 -07:00
{
And cover the one in scene_destroy
2014-01-30 11:41:11 -08:00
struct obs_scene_item *item;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
DARRAY(struct obs_scene_item *) items;
libobs: Release scene items outside of scene mutexes Prevents a mutual lock with the scene mutex and graphics mutex. In libobs/obs-video.c, the graphics mutex could be locked first, then the scene mutexes second, while in the UI thread, the scene mutexes could be locked first, then when a scene item is being destroyed, a source could be destroyed, and sometimes sources would lock the graphics mutex second. A possible additional solution is to defer source destroys to the video thread.
2016-01-03 15:42:10 -08:00
da_init(items);
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_lock(scene);
first commit
2013-09-30 19:37:13 -07:00
And cover the one in scene_destroy
2014-01-30 11:41:11 -08:00
item = scene->first_item;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
while (item) {
struct obs_scene_item *del_item = item;
item = item->next;
libobs: Release scene items outside of scene mutexes Prevents a mutual lock with the scene mutex and graphics mutex. In libobs/obs-video.c, the graphics mutex could be locked first, then the scene mutexes second, while in the UI thread, the scene mutexes could be locked first, then when a scene item is being destroyed, a source could be destroyed, and sometimes sources would lock the graphics mutex second. A possible additional solution is to defer source destroys to the video thread.
2016-01-03 15:42:10 -08:00
remove_without_release(del_item);
da_push_back(items, &del_item);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
}
first commit
2013-09-30 19:37:13 -07:00
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_unlock(scene);
libobs: Release scene items outside of scene mutexes Prevents a mutual lock with the scene mutex and graphics mutex. In libobs/obs-video.c, the graphics mutex could be locked first, then the scene mutexes second, while in the UI thread, the scene mutexes could be locked first, then when a scene item is being destroyed, a source could be destroyed, and sometimes sources would lock the graphics mutex second. A possible additional solution is to defer source destroys to the video thread.
2016-01-03 15:42:10 -08:00
for (size_t i = 0; i < items.num; i++)
obs_sceneitem_release(items.array[i]);
da_free(items);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
}
static void scene_destroy(void *data)
{
struct obs_scene *scene = data;
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
remove_all_items(scene);
libobs: Release scene items outside of scene mutexes Prevents a mutual lock with the scene mutex and graphics mutex. In libobs/obs-video.c, the graphics mutex could be locked first, then the scene mutexes second, while in the UI thread, the scene mutexes could be locked first, then when a scene item is being destroyed, a source could be destroyed, and sometimes sources would lock the graphics mutex second. A possible additional solution is to defer source destroys to the video thread.
2016-01-03 15:42:10 -08:00
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
pthread_mutex_destroy(&scene->video_mutex);
pthread_mutex_destroy(&scene->audio_mutex);
first commit
2013-09-30 19:37:13 -07:00
bfree(scene);
}
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
static inline bool transition_active(obs_source_t *transition)
{
return transition && (transition->transitioning_audio ||
transition->transitioning_video);
}
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
static void scene_enum_sources(void *data, obs_source_enum_proc_t enum_callback,
void *param, bool active)
Add functions to enumerate source children/tree
2014-02-20 16:44:42 -08:00
{
struct obs_scene *scene = data;
struct obs_scene_item *item;
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
struct obs_scene_item *next;
Add functions to enumerate source children/tree
2014-02-20 16:44:42 -08:00
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_lock(scene);
Add functions to enumerate source children/tree
2014-02-20 16:44:42 -08:00
item = scene->first_item;
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
Add functions to enumerate source children/tree
2014-02-20 16:44:42 -08:00
while (item) {
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
next = item->next;
Add functions to enumerate source children/tree
2014-02-20 16:44:42 -08:00
obs_sceneitem_addref(item);
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
if (active) {
if (item->visible &&
transition_active(item->show_transition))
enum_callback(scene->source,
item->show_transition, param);
else if (!item->visible &&
transition_active(item->hide_transition))
enum_callback(scene->source,
item->hide_transition, param);
else if (os_atomic_load_long(&item->active_refs) > 0)
enum_callback(scene->source, item->source,
param);
} else {
if (item->show_transition)
enum_callback(scene->source,
item->show_transition, param);
if (item->hide_transition)
enum_callback(scene->source,
item->hide_transition, param);
libobs: Make scene item visibility activate/deactivate Before if a source was set to invisible it would still be considered active. This changes it so that the source is deactivated when the source is invisible to reduce needless resource usage or capturing.
2015-12-22 05:25:31 -08:00
enum_callback(scene->source, item->source, param);
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
}
Add functions to enumerate source children/tree
2014-02-20 16:44:42 -08:00
obs_sceneitem_release(item);
item = next;
}
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_unlock(scene);
Add functions to enumerate source children/tree
2014-02-20 16:44:42 -08:00
}
libobs: Add callback for enumerating all scene children Prevents infinite recursion when adding children to a scene.
2017-01-16 09:55:15 -08:00
static void scene_enum_active_sources(void *data,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_source_enum_proc_t enum_callback,
void *param)
libobs: Add callback for enumerating all scene children Prevents infinite recursion when adding children to a scene.
2017-01-16 09:55:15 -08:00
{
scene_enum_sources(data, enum_callback, param, true);
}
static void scene_enum_all_sources(void *data,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_source_enum_proc_t enum_callback,
void *param)
libobs: Add callback for enumerating all scene children Prevents infinite recursion when adding children to a scene.
2017-01-16 09:55:15 -08:00
{
scene_enum_sources(data, enum_callback, param, false);
}
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
static inline void detach_sceneitem(struct obs_scene_item *item)
{
if (item->prev)
item->prev->next = item->next;
else
item->parent->first_item = item->next;
if (item->next)
item->next->prev = item->prev;
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
item->parent = NULL;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
}
Add ability to move source up/down/etc
2014-05-15 17:40:53 -07:00
static inline void attach_sceneitem(struct obs_scene *parent,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct obs_scene_item *item,
struct obs_scene_item *prev)
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
item->prev = prev;
Add ability to move source up/down/etc
2014-05-15 17:40:53 -07:00
item->parent = parent;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
if (prev) {
item->next = prev->next;
if (prev->next)
prev->next->prev = item;
prev->next = item;
} else {
libobs: Fix bug (last scene item potentially lost)
2015-02-13 08:02:35 -08:00
item->next = parent->first_item;
if (parent->first_item)
parent->first_item->prev = item;
parent->first_item = item;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
}
}
libobs: Allow add_alignment to be used by other source files
2016-01-03 15:13:51 -08:00
void add_alignment(struct vec2 *v, uint32_t align, int cx, int cy)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
{
if (align & OBS_ALIGN_RIGHT)
v->x += (float)cx;
else if ((align & OBS_ALIGN_LEFT) == 0)
v->x += (float)(cx / 2);
if (align & OBS_ALIGN_BOTTOM)
v->y += (float)cy;
else if ((align & OBS_ALIGN_TOP) == 0)
v->y += (float)(cy / 2);
}
static void calculate_bounds_data(struct obs_scene_item *item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct vec2 *origin, struct vec2 *scale,
uint32_t *cx, uint32_t *cy)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
float width = (float)(*cx) * fabsf(scale->x);
float height = (float)(*cy) * fabsf(scale->y);
float item_aspect = width / height;
float bounds_aspect = item->bounds.x / item->bounds.y;
uint32_t bounds_type = item->bounds_type;
float width_diff, height_diff;
UI: Add scene editing So, scene editing was interesting (and by interesting I mean excruciating). I almost implemented 'manipulator' visuals (ala 3dsmax for example), and used 3 modes for controlling position/rotation/size, but in a 2D editing, it felt clunky, so I defaulted back to simply click-and-drag for movement, and then took a similar though slightly different looking approach for handling scaling and reszing. I also added a number of menu item helpers related to positioning, scaling, rotating, flipping, and resetting the transform back to default. There is also a new 'transform' dialog (accessible via menu) which will allow you to manually edit every single transform variable of a scene item directly if desired. If a scene item does not have bounds active, pulling on the sides of a source will cause it to resize it via base scale rather than by the bounding box system (if the source resizes that scale will apply). If bounds are active, it will modify the bounding box only instead. How a source scales when a bounding box is active depends on the type of bounds being used. You can set it to scale to the inner bounds, the outer bounds, scale to bounds width only, scale to bounds height only, and a setting to stretch to bounds (which forces a source to always draw at the bounding box size rather than be affected by its internal size). You can also set it to be used as a 'maximum' size, so that the source doesn't necessarily get scaled unless it extends beyond the bounds. Like in OBS1, objects will snap to the edges unless the control key is pressed. However, this will now happen even if the object is rotated or oriented in any strange way. Snapping will also occur when stretching or changing the bounding box size.
2014-06-15 00:54:48 -07:00
if (item->bounds_type == OBS_BOUNDS_MAX_ONLY)
if (width > item->bounds.x || height > item->bounds.y)
bounds_type = OBS_BOUNDS_SCALE_INNER;
if (bounds_type == OBS_BOUNDS_SCALE_INNER ||
bounds_type == OBS_BOUNDS_SCALE_OUTER) {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
bool use_width = (bounds_aspect < item_aspect);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
float mul;
if (item->bounds_type == OBS_BOUNDS_SCALE_OUTER)
use_width = !use_width;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
mul = use_width ? item->bounds.x / width
: item->bounds.y / height;
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
vec2_mulf(scale, scale, mul);
UI: Add scene editing So, scene editing was interesting (and by interesting I mean excruciating). I almost implemented 'manipulator' visuals (ala 3dsmax for example), and used 3 modes for controlling position/rotation/size, but in a 2D editing, it felt clunky, so I defaulted back to simply click-and-drag for movement, and then took a similar though slightly different looking approach for handling scaling and reszing. I also added a number of menu item helpers related to positioning, scaling, rotating, flipping, and resetting the transform back to default. There is also a new 'transform' dialog (accessible via menu) which will allow you to manually edit every single transform variable of a scene item directly if desired. If a scene item does not have bounds active, pulling on the sides of a source will cause it to resize it via base scale rather than by the bounding box system (if the source resizes that scale will apply). If bounds are active, it will modify the bounding box only instead. How a source scales when a bounding box is active depends on the type of bounds being used. You can set it to scale to the inner bounds, the outer bounds, scale to bounds width only, scale to bounds height only, and a setting to stretch to bounds (which forces a source to always draw at the bounding box size rather than be affected by its internal size). You can also set it to be used as a 'maximum' size, so that the source doesn't necessarily get scaled unless it extends beyond the bounds. Like in OBS1, objects will snap to the edges unless the control key is pressed. However, this will now happen even if the object is rotated or oriented in any strange way. Snapping will also occur when stretching or changing the bounding box size.
2014-06-15 00:54:48 -07:00
} else if (bounds_type == OBS_BOUNDS_SCALE_TO_WIDTH) {
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
vec2_mulf(scale, scale, item->bounds.x / width);
UI: Add scene editing So, scene editing was interesting (and by interesting I mean excruciating). I almost implemented 'manipulator' visuals (ala 3dsmax for example), and used 3 modes for controlling position/rotation/size, but in a 2D editing, it felt clunky, so I defaulted back to simply click-and-drag for movement, and then took a similar though slightly different looking approach for handling scaling and reszing. I also added a number of menu item helpers related to positioning, scaling, rotating, flipping, and resetting the transform back to default. There is also a new 'transform' dialog (accessible via menu) which will allow you to manually edit every single transform variable of a scene item directly if desired. If a scene item does not have bounds active, pulling on the sides of a source will cause it to resize it via base scale rather than by the bounding box system (if the source resizes that scale will apply). If bounds are active, it will modify the bounding box only instead. How a source scales when a bounding box is active depends on the type of bounds being used. You can set it to scale to the inner bounds, the outer bounds, scale to bounds width only, scale to bounds height only, and a setting to stretch to bounds (which forces a source to always draw at the bounding box size rather than be affected by its internal size). You can also set it to be used as a 'maximum' size, so that the source doesn't necessarily get scaled unless it extends beyond the bounds. Like in OBS1, objects will snap to the edges unless the control key is pressed. However, this will now happen even if the object is rotated or oriented in any strange way. Snapping will also occur when stretching or changing the bounding box size.
2014-06-15 00:54:48 -07:00
} else if (bounds_type == OBS_BOUNDS_SCALE_TO_HEIGHT) {
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
vec2_mulf(scale, scale, item->bounds.y / height);
UI: Add scene editing So, scene editing was interesting (and by interesting I mean excruciating). I almost implemented 'manipulator' visuals (ala 3dsmax for example), and used 3 modes for controlling position/rotation/size, but in a 2D editing, it felt clunky, so I defaulted back to simply click-and-drag for movement, and then took a similar though slightly different looking approach for handling scaling and reszing. I also added a number of menu item helpers related to positioning, scaling, rotating, flipping, and resetting the transform back to default. There is also a new 'transform' dialog (accessible via menu) which will allow you to manually edit every single transform variable of a scene item directly if desired. If a scene item does not have bounds active, pulling on the sides of a source will cause it to resize it via base scale rather than by the bounding box system (if the source resizes that scale will apply). If bounds are active, it will modify the bounding box only instead. How a source scales when a bounding box is active depends on the type of bounds being used. You can set it to scale to the inner bounds, the outer bounds, scale to bounds width only, scale to bounds height only, and a setting to stretch to bounds (which forces a source to always draw at the bounding box size rather than be affected by its internal size). You can also set it to be used as a 'maximum' size, so that the source doesn't necessarily get scaled unless it extends beyond the bounds. Like in OBS1, objects will snap to the edges unless the control key is pressed. However, this will now happen even if the object is rotated or oriented in any strange way. Snapping will also occur when stretching or changing the bounding box size.
2014-06-15 00:54:48 -07:00
} else if (bounds_type == OBS_BOUNDS_STRETCH) {
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
scale->x = item->bounds.x / (float)(*cx);
scale->y = item->bounds.y / (float)(*cy);
}
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
width = (float)(*cx) * scale->x;
height = (float)(*cy) * scale->y;
width_diff = item->bounds.x - width;
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
height_diff = item->bounds.y - height;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
*cx = (uint32_t)item->bounds.x;
*cy = (uint32_t)item->bounds.y;
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
add_alignment(origin, item->bounds_align, (int)-width_diff,
(int)-height_diff);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
}
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
static inline uint32_t calc_cx(const struct obs_scene_item *item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
uint32_t width)
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
{
uint32_t crop_cx = item->crop.left + item->crop.right;
return (crop_cx > width) ? 2 : (width - crop_cx);
}
static inline uint32_t calc_cy(const struct obs_scene_item *item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
uint32_t height)
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
{
uint32_t crop_cy = item->crop.top + item->crop.bottom;
return (crop_cy > height) ? 2 : (height - crop_cy);
}
libobs: Only update scene item texture on frame tick Instead of updating the scene item texture any time update_item_transform() is called, only update it when obs_scene_item::update_transform is called. Prevents having to lock the graphics mutex needlessly.
2018-07-24 02:28:43 -07:00
static void update_item_transform(struct obs_scene_item *item, bool update_tex)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
uint32_t width;
uint32_t height;
uint32_t cx;
uint32_t cy;
struct vec2 base_origin;
struct vec2 origin;
struct vec2 scale;
libobs: Use calldata with stack for simple signals Makes signals use stack memory rather than allocate memory each time. Most likely a completely insignificant and pointless optimization.
2016-01-18 20:01:58 -08:00
struct calldata params;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
uint8_t stack[128];
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
libobs: Add functions to defer scene item update Allows the ability to defer updating the item transform until all functions have been executed.
2016-03-30 18:35:59 -07:00
if (os_atomic_load_long(&item->defer_update) > 0)
return;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
width = obs_source_get_width(item->source);
height = obs_source_get_height(item->source);
cx = calc_cx(item, width);
cy = calc_cy(item, height);
scale = item->scale;
item->last_width = width;
libobs: Fix bug where cropped items would recalc transform Fixes a bug where items that had cropping would recalculate transform every frame. obs_scene_item::last_width and obs_scene_item::last_height would be set to the cropped sizes rather than the source's actual size.
2018-06-01 02:11:45 -07:00
item->last_height = height;
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
width = cx;
height = cy;
Fix a number of warnings Structures with anonymous unions would a warning when you do a brace assignment on them. Also fixed some unused parameters and removed some unused variables.
2014-06-16 17:55:48 -07:00
vec2_zero(&base_origin);
vec2_zero(&origin);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
/* ----------------------- */
if (item->bounds_type != OBS_BOUNDS_NONE) {
calculate_bounds_data(item, &origin, &scale, &cx, &cy);
} else {
cx = (uint32_t)((float)cx * scale.x);
cy = (uint32_t)((float)cy * scale.y);
}
add_alignment(&origin, item->align, (int)cx, (int)cy);
matrix4_identity(&item->draw_transform);
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
matrix4_scale3f(&item->draw_transform, &item->draw_transform, scale.x,
scale.y, 1.0f);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
matrix4_translate3f(&item->draw_transform, &item->draw_transform,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
-origin.x, -origin.y, 0.0f);
matrix4_rotate_aa4f(&item->draw_transform, &item->draw_transform, 0.0f,
0.0f, 1.0f, RAD(item->rot));
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
matrix4_translate3f(&item->draw_transform, &item->draw_transform,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
item->pos.x, item->pos.y, 0.0f);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
item->output_scale = scale;
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
/* ----------------------- */
if (item->bounds_type != OBS_BOUNDS_NONE) {
vec2_copy(&scale, &item->bounds);
} else {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
scale.x = (float)width * item->scale.x;
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
scale.y = (float)height * item->scale.y;
}
libobs: UI: Fix rotated line scale The line drawing functions previously assumed the upper-left 3x3 for box_transform only held scale. The matrix can also hold rotation, so pass in scale separately. Fixes https://obsproject.com/mantis/view.php?id=1442
2019-04-19 06:35:42 -07:00
item->box_scale = scale;
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
add_alignment(&base_origin, item->align, (int)scale.x, (int)scale.y);
matrix4_identity(&item->box_transform);
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
matrix4_scale3f(&item->box_transform, &item->box_transform, scale.x,
scale.y, 1.0f);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
matrix4_translate3f(&item->box_transform, &item->box_transform,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
-base_origin.x, -base_origin.y, 0.0f);
matrix4_rotate_aa4f(&item->box_transform, &item->box_transform, 0.0f,
0.0f, 1.0f, RAD(item->rot));
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
matrix4_translate3f(&item->box_transform, &item->box_transform,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
item->pos.x, item->pos.y, 0.0f);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
/* ----------------------- */
libobs: Use calldata with stack for simple signals Makes signals use stack memory rather than allocate memory each time. Most likely a completely insignificant and pointless optimization.
2016-01-18 20:01:58 -08:00
calldata_init_fixed(&params, stack, sizeof(stack));
(API Change) libobs/callback: Unsquish names Renamed: To: ------------------------------------------------- calldata_getdata calldata_get_data calldata_getint calldata_get_int calldata_getfloat calldata_get_float calldata_getbool calldata_get_bool calldata_getptr calldata_get_ptr calldata_getstring calldata_get_string calldata_setdata calldata_set_data calldata_setint calldata_set_int calldata_setfloat calldata_set_float calldata_setbool calldata_set_bool calldata_setptr calldata_set_ptr calldata_setstring calldata_set_string
2014-08-05 17:49:28 -07:00
calldata_set_ptr(&params, "item", item);
libobs: Refactor item signaling (add func to signal parent)
2018-06-01 02:34:32 -07:00
signal_parent(item->parent, "item_transform", &params);
libobs: Defer and refactor scene item transform update Defers updating the scene item transform to the graphics thread to reduce the number of transform update calls.
2018-06-01 07:41:33 -07:00
libobs: Only update scene item texture on frame tick Instead of updating the scene item texture any time update_item_transform() is called, only update it when obs_scene_item::update_transform is called. Prevents having to lock the graphics mutex needlessly.
2018-07-24 02:28:43 -07:00
if (!update_tex)
return;
libobs: Defer and refactor scene item transform update Defers updating the scene item transform to the graphics thread to reduce the number of transform update calls.
2018-06-01 07:41:33 -07:00
os_atomic_set_bool(&item->update_transform, false);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
}
static inline bool source_size_changed(struct obs_scene_item *item)
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
uint32_t width = obs_source_get_width(item->source);
(API Change) Unsquish libobs (base) names Previous names: New names: ----------------------------------------------------------- obs_view_setsource obs_view_set_source obs_view_getsource obs_view_get_source obs_source_getdisplayname obs_source_get_display_name obs_source_getwidth obs_source_get_width obs_source_getheight obs_source_get_height obs_filter_getparent obs_filter_get_parent obs_filter_gettarget obs_filter_get_target obs_source_filter_setorder obs_source_filter_set_order obs_source_getsettings obs_source_get_settings obs_source_getname obs_source_get_name obs_source_setname obs_source_set_name obs_source_setvolume obs_source_set_volume obs_source_getvolume obs_source_get_volume obs_scene_getsource obs_scene_get_source obs_scene_fromsource obs_scene_from_source obs_scene_findsource obs_scene_find_source obs_output_getdisplayname obs_output_get_display_name obs_output_getname obs_output_get_name obs_encoder_getname obs_encoder_get_name obs_service_getdisplayname obs_service_get_display_name obs_service_getname obs_service_get_name
2014-08-04 08:41:15 -07:00
uint32_t height = obs_source_get_height(item->source);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
return item->last_width != width || item->last_height != height;
}
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
static inline bool crop_enabled(const struct obs_sceneitem_crop *crop)
{
return crop->left || crop->right || crop->top || crop->bottom;
}
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
static inline bool scale_filter_enabled(const struct obs_scene_item *item)
{
return item->scale_filter != OBS_SCALE_DISABLE;
}
libobs: Implement additional source blending modes
2021-10-24 08:45:15 -07:00
static inline bool default_blending_enabled(const struct obs_scene_item *item)
{
return item->blend_type == OBS_BLEND_NORMAL;
}
libobs: Use item texture if scene item is scene Allows rendering scenes as scene items without off-screen sub-source of the scene popping out on the sides.
2016-07-01 15:21:12 -07:00
static inline bool item_is_scene(const struct obs_scene_item *item)
{
return item->source && item->source->info.type == OBS_SOURCE_TYPE_SCENE;
}
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
static inline bool item_texture_enabled(const struct obs_scene_item *item)
{
libobs: Use item texture if scene item is scene Allows rendering scenes as scene items without off-screen sub-source of the scene popping out on the sides.
2016-07-01 15:21:12 -07:00
return crop_enabled(&item->crop) || scale_filter_enabled(item) ||
libobs: Add support for nonlinear SRGB blending
2022-03-31 19:15:10 -07:00
(item->blend_method == OBS_BLEND_METHOD_SRGB_OFF) ||
libobs: Implement additional source blending modes
2021-10-24 08:45:15 -07:00
!default_blending_enabled(item) ||
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
(item_is_scene(item) && !item->is_group);
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
}
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
static void render_item_texture(struct obs_scene_item *item,
enum gs_color_space current_space,
enum gs_color_space source_space)
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
{
gs_texture_t *tex = gs_texrender_get_texture(item->item_render);
libobs: Don't render scene item texture if it's null
2019-08-29 21:44:34 -07:00
if (!tex) {
return;
}
libobs: Call debug marker after null check, not before
2019-08-29 21:46:13 -07:00
GS_DEBUG_MARKER_BEGIN(GS_DEBUG_COLOR_ITEM_TEXTURE,
"render_item_texture");
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
gs_effect_t *effect = obs->video.default_effect;
enum obs_scale_type type = item->scale_filter;
uint32_t cx = gs_texture_get_width(tex);
uint32_t cy = gs_texture_get_height(tex);
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
bool upscale = false;
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
if (type != OBS_SCALE_DISABLE) {
if (type == OBS_SCALE_POINT) {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
gs_eparam_t *image =
gs_effect_get_param_by_name(effect, "image");
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
gs_effect_set_next_sampler(image,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs->video.point_sampler);
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
} else if (!close_float(item->output_scale.x, 1.0f, EPSILON) ||
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
!close_float(item->output_scale.y, 1.0f, EPSILON)) {
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
if (item->output_scale.x < 0.5f ||
item->output_scale.y < 0.5f) {
effect = obs->video.bilinear_lowres_effect;
} else if (type == OBS_SCALE_BICUBIC) {
effect = obs->video.bicubic_effect;
} else if (type == OBS_SCALE_LANCZOS) {
effect = obs->video.lanczos_effect;
Add "Area" scale filter This new scale filter computes pixels by weighing the coverage area of source pixels over the target pixel. This algorithm works well for both upsampling and downsampling, but was mainly designed to upscale high-quality low-resolution sources like RGB/HDMI retro consoles. I've heard of people using odd workarounds like scaling up to very high resolutions before scaling back down to preserve pixel shartpness. This algorithm directly addresses this use-case in a much more direct fashion. The Area scale filter does a better job of preserving the thickness of thin features than the Point filter. The Area scale filter does not look at source pixels that lie outside of the target pixel, leading to a much sharper image than Bilinear, Bicubic, and Lanczos filters. This filter should interpolate pixels in linear space, but OBS is not equipped to do that at the moment. libobs: Add GPU effect, and wire up scene serialization. obs-filters: Add Area as an option for scale_filter. UI: Add Area as an option for both scene items, and canvas downscaling.
2019-03-06 20:53:15 -08:00
} else if (type == OBS_SCALE_AREA) {
effect = obs->video.area_effect;
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
upscale = (item->output_scale.x >= 1.0f) &&
(item->output_scale.y >= 1.0f);
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
}
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
gs_eparam_t *const scale_param =
gs_effect_get_param_by_name(effect,
"base_dimension");
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
if (scale_param) {
libobs: Fix benign typo
2019-07-25 00:39:28 -07:00
struct vec2 base_res = {(float)cx, (float)cy};
libobs: obs-filters: Area upscale shader Add a separate shader for area upscaling to take advantage of bilinear filtering. Iterating over texels is unnecessary in the upscale case because a target pixel can only overlap 1 or 2 texels in X and Y directions. When only overlapping one texel, adjust UVs to sample texel center to avoid filtering. Also add "base_dimension" uniform to avoid unnecessary division. Intel HD Graphics 530, 644x478 -> 1323x1080: ~836 us -> ~232 us
2019-07-17 21:11:18 -07:00
libobs: Fix benign typo
2019-07-25 00:39:28 -07:00
gs_effect_set_vec2(scale_param, &base_res);
libobs: obs-filters: Area upscale shader Add a separate shader for area upscaling to take advantage of bilinear filtering. Iterating over texels is unnecessary in the upscale case because a target pixel can only overlap 1 or 2 texels in X and Y directions. When only overlapping one texel, adjust UVs to sample texel center to avoid filtering. Also add "base_dimension" uniform to avoid unnecessary division. Intel HD Graphics 530, 644x478 -> 1323x1080: ~836 us -> ~232 us
2019-07-17 21:11:18 -07:00
}
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
gs_eparam_t *const scale_i_param =
gs_effect_get_param_by_name(effect,
"base_dimension_i");
libobs: obs-filters: Area upscale shader Add a separate shader for area upscaling to take advantage of bilinear filtering. Iterating over texels is unnecessary in the upscale case because a target pixel can only overlap 1 or 2 texels in X and Y directions. When only overlapping one texel, adjust UVs to sample texel center to avoid filtering. Also add "base_dimension" uniform to avoid unnecessary division. Intel HD Graphics 530, 644x478 -> 1323x1080: ~836 us -> ~232 us
2019-07-17 21:11:18 -07:00
if (scale_i_param) {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct vec2 base_res_i = {1.0f / (float)cx,
1.0f / (float)cy};
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
libobs: obs-filters: Area upscale shader Add a separate shader for area upscaling to take advantage of bilinear filtering. Iterating over texels is unnecessary in the upscale case because a target pixel can only overlap 1 or 2 texels in X and Y directions. When only overlapping one texel, adjust UVs to sample texel center to avoid filtering. Also add "base_dimension" uniform to avoid unnecessary division. Intel HD Graphics 530, 644x478 -> 1323x1080: ~836 us -> ~232 us
2019-07-17 21:11:18 -07:00
gs_effect_set_vec2(scale_i_param, &base_res_i);
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
}
}
}
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
float multiplier = 1.f;
switch (current_space) {
case GS_CS_709_SCRGB:
switch (source_space) {
case GS_CS_SRGB:
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
case GS_CS_SRGB_16F:
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
case GS_CS_709_EXTENDED:
multiplier = obs_get_video_sdr_white_level() / 80.f;
}
}
switch (source_space) {
case GS_CS_709_SCRGB:
switch (current_space) {
case GS_CS_SRGB:
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
case GS_CS_SRGB_16F:
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
case GS_CS_709_EXTENDED:
multiplier = 80.f / obs_get_video_sdr_white_level();
}
}
const char *tech_name = "Draw";
if (upscale) {
tech_name = "DrawUpscale";
switch (source_space) {
case GS_CS_SRGB:
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
case GS_CS_SRGB_16F:
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
switch (current_space) {
case GS_CS_709_SCRGB:
tech_name = "DrawUpscaleMultiply";
}
break;
case GS_CS_709_EXTENDED:
switch (current_space) {
case GS_CS_SRGB:
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
case GS_CS_SRGB_16F:
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
tech_name = "DrawUpscaleTonemap";
break;
case GS_CS_709_SCRGB:
tech_name = "DrawUpscaleMultiply";
}
break;
case GS_CS_709_SCRGB:
switch (current_space) {
case GS_CS_SRGB:
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
case GS_CS_SRGB_16F:
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
tech_name = "DrawUpscaleMultiplyTonemap";
break;
case GS_CS_709_EXTENDED:
tech_name = "DrawUpscaleMultiply";
}
}
} else {
switch (source_space) {
case GS_CS_SRGB:
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
case GS_CS_SRGB_16F:
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
switch (current_space) {
case GS_CS_709_SCRGB:
tech_name = "DrawMultiply";
}
break;
case GS_CS_709_EXTENDED:
switch (current_space) {
case GS_CS_SRGB:
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
case GS_CS_SRGB_16F:
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
tech_name = "DrawTonemap";
break;
case GS_CS_709_SCRGB:
tech_name = "DrawMultiply";
}
break;
case GS_CS_709_SCRGB:
switch (current_space) {
case GS_CS_SRGB:
libobs: Add high-precision sRGB support
2022-03-30 22:39:53 -07:00
case GS_CS_SRGB_16F:
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
tech_name = "DrawMultiplyTonemap";
break;
case GS_CS_709_EXTENDED:
tech_name = "DrawMultiply";
}
}
}
gs_eparam_t *const multiplier_param =
gs_effect_get_param_by_name(effect, "multiplier");
if (multiplier_param)
gs_effect_set_float(multiplier_param, multiplier);
libobs: Fix various alpha issues There are cases where alpha is multiplied unnecessarily. This change attempts to use premultiplied alpha blending for composition. To keep this change simple, The filter chain will continue to use straight alpha. Otherwise, every source would need to modified to output premultiplied, and every filter modified for premultiplied input. "DrawAlphaDivide" shader techniques have been added to convert from premultiplied alpha to straight alpha for final output. "DrawMatrix" techniques ignore alpha, so they do not appear to need changing. One remaining issue is that scale effects are set up here to use the same shader logic for both scale filters (straight alpha - incorrectly), and output composition (premultiplied alpha - correctly). A fix could be made to add additional shaders for straight alpha, but the "real" fix may be to eliminate the straight alpha path at some point. For graphics, SrcBlendAlpha and DestBlendAlpha were both ONE, and could combine together to form alpha values greater than one. This is not as noticeable of a problem for UNORM targets because the channels are clamped, but it will likely become a problem in more situations if FLOAT targets are used. This change switches DestBlendAlpha to INVSRCALPHA. The blending behavior of stacked transparents is preserved without overflowing the alpha channel. obs-transitions: Use premultiplied alpha blend, and simplify shaders because both inputs and outputs use premultiplied alpha now. Fixes https://obsproject.com/mantis/view.php?id=1108
2019-05-03 03:54:17 -07:00
gs_blend_state_push();
libobs: Implement additional source blending modes
2021-10-24 08:45:15 -07:00
gs_blend_function_separate(
obs_blend_mode_params[item->blend_type].src_color,
obs_blend_mode_params[item->blend_type].dst_color,
obs_blend_mode_params[item->blend_type].src_alpha,
obs_blend_mode_params[item->blend_type].dst_alpha);
gs_blend_op(obs_blend_mode_params[item->blend_type].op);
libobs: Fix various alpha issues There are cases where alpha is multiplied unnecessarily. This change attempts to use premultiplied alpha blending for composition. To keep this change simple, The filter chain will continue to use straight alpha. Otherwise, every source would need to modified to output premultiplied, and every filter modified for premultiplied input. "DrawAlphaDivide" shader techniques have been added to convert from premultiplied alpha to straight alpha for final output. "DrawMatrix" techniques ignore alpha, so they do not appear to need changing. One remaining issue is that scale effects are set up here to use the same shader logic for both scale filters (straight alpha - incorrectly), and output composition (premultiplied alpha - correctly). A fix could be made to add additional shaders for straight alpha, but the "real" fix may be to eliminate the straight alpha path at some point. For graphics, SrcBlendAlpha and DestBlendAlpha were both ONE, and could combine together to form alpha values greater than one. This is not as noticeable of a problem for UNORM targets because the channels are clamped, but it will likely become a problem in more situations if FLOAT targets are used. This change switches DestBlendAlpha to INVSRCALPHA. The blending behavior of stacked transparents is preserved without overflowing the alpha channel. obs-transitions: Use premultiplied alpha blend, and simplify shaders because both inputs and outputs use premultiplied alpha now. Fixes https://obsproject.com/mantis/view.php?id=1108
2019-05-03 03:54:17 -07:00
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
while (gs_effect_loop(effect, tech_name))
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
obs_source_draw(tex, 0, 0, 0, 0, 0);
libobs: UI: Use graphics debug markers Add D3D/GL debug markers to make RenderDoc captures easier to tranverse. Also add obs_source_get_name_no_null() to avoid boilerplate for safe string formatting. Closes obsproject/obs-studio#1799
2019-04-02 23:23:37 -07:00
libobs: Fix various alpha issues There are cases where alpha is multiplied unnecessarily. This change attempts to use premultiplied alpha blending for composition. To keep this change simple, The filter chain will continue to use straight alpha. Otherwise, every source would need to modified to output premultiplied, and every filter modified for premultiplied input. "DrawAlphaDivide" shader techniques have been added to convert from premultiplied alpha to straight alpha for final output. "DrawMatrix" techniques ignore alpha, so they do not appear to need changing. One remaining issue is that scale effects are set up here to use the same shader logic for both scale filters (straight alpha - incorrectly), and output composition (premultiplied alpha - correctly). A fix could be made to add additional shaders for straight alpha, but the "real" fix may be to eliminate the straight alpha path at some point. For graphics, SrcBlendAlpha and DestBlendAlpha were both ONE, and could combine together to form alpha values greater than one. This is not as noticeable of a problem for UNORM targets because the channels are clamped, but it will likely become a problem in more situations if FLOAT targets are used. This change switches DestBlendAlpha to INVSRCALPHA. The blending behavior of stacked transparents is preserved without overflowing the alpha channel. obs-transitions: Use premultiplied alpha blend, and simplify shaders because both inputs and outputs use premultiplied alpha now. Fixes https://obsproject.com/mantis/view.php?id=1108
2019-05-03 03:54:17 -07:00
gs_blend_state_pop();
libobs: UI: Use graphics debug markers Add D3D/GL debug markers to make RenderDoc captures easier to tranverse. Also add obs_source_get_name_no_null() to avoid boilerplate for safe string formatting. Closes obsproject/obs-studio#1799
2019-04-02 23:23:37 -07:00
GS_DEBUG_MARKER_END();
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
}
libobs: Plumb texcoord hint to reduce GPU cost In order to do linear-correct filtering cheaply when scale filtering is disabled, we need to know whether or not texture coordinates will always sample from texel centers. This can be computed at the scene item level relatively easily, and passed along to sources when rendering. Scene items will use obs_source_set_texcoords_centered to set hint status, and sources will use obs_source_get_texcoords_centered to retrieve it.
2021-07-06 22:03:45 -07:00
static bool are_texcoords_centered(struct matrix4 *m)
{
static const struct matrix4 identity = {
{1.0f, 0.0f, 0.0f, 0.0f},
{0.0f, 1.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 1.0f, 0.0f},
{0.0f, 0.0f, 0.0f, 1.0f},
};
struct matrix4 copy = identity;
copy.t.x = floorf(m->t.x);
copy.t.y = floorf(m->t.y);
return memcmp(m, &copy, sizeof(*m)) == 0;
}
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
static inline void render_item(struct obs_scene_item *item)
{
libobs: UI: Use graphics debug markers Add D3D/GL debug markers to make RenderDoc captures easier to tranverse. Also add obs_source_get_name_no_null() to avoid boilerplate for safe string formatting. Closes obsproject/obs-studio#1799
2019-04-02 23:23:37 -07:00
GS_DEBUG_MARKER_BEGIN_FORMAT(GS_DEBUG_COLOR_ITEM, "Item: %s",
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_source_get_name(item->source));
libobs: UI: Use graphics debug markers Add D3D/GL debug markers to make RenderDoc captures easier to tranverse. Also add obs_source_get_name_no_null() to avoid boilerplate for safe string formatting. Closes obsproject/obs-studio#1799
2019-04-02 23:23:37 -07:00
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
const bool use_texrender = item_texture_enabled(item);
obs_source_t *const source = item->source;
const enum gs_color_space current_space = gs_get_color_space();
const enum gs_color_space source_space =
obs_source_get_color_space(source, 1, &current_space);
const enum gs_color_format format =
gs_get_format_from_space(source_space);
if (item->item_render &&
(!use_texrender ||
(gs_texrender_get_format(item->item_render) != format))) {
gs_texrender_destroy(item->item_render);
item->item_render = NULL;
}
if (!item->item_render && use_texrender) {
item->item_render = gs_texrender_create(format, GS_ZS_NONE);
}
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
if (item->item_render) {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
uint32_t width = obs_source_get_width(item->source);
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
uint32_t height = obs_source_get_height(item->source);
libobs: Do not draw item texture if source size 0
2018-06-01 02:31:36 -07:00
libobs: UI: Use graphics debug markers Add D3D/GL debug markers to make RenderDoc captures easier to tranverse. Also add obs_source_get_name_no_null() to avoid boilerplate for safe string formatting. Closes obsproject/obs-studio#1799
2019-04-02 23:23:37 -07:00
if (!width || !height) {
goto cleanup;
}
libobs: Do not draw item texture if source size 0
2018-06-01 02:31:36 -07:00
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
uint32_t cx = calc_cx(item, width);
uint32_t cy = calc_cy(item, height);
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
if (cx && cy &&
gs_texrender_begin_with_color_space(item->item_render, cx,
cy, source_space)) {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
float cx_scale = (float)width / (float)cx;
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
float cy_scale = (float)height / (float)cy;
libobs: Reset projection transform when cropping The crop texture would not always render correctly because the projection matrix had not been set.
2016-03-31 11:00:04 -07:00
struct vec4 clear_color;
Revert "libobs: libobs-d3d11: obs-filters: No excess alpha" This reverts commit d91bd327d7a8bb4597562fc26da4edb7b56874ff, which broke alpha with sources, scenes, and filter, causing them all to become opaque unintentionally.
2019-04-25 08:36:41 -07:00
vec4_zero(&clear_color);
libobs: Reset projection transform when cropping The crop texture would not always render correctly because the projection matrix had not been set.
2016-03-31 11:00:04 -07:00
gs_clear(GS_CLEAR_COLOR, &clear_color, 0.0f, 0);
gs_ortho(0.0f, (float)width, 0.0f, (float)height,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
-100.0f, 100.0f);
libobs: Reset projection transform when cropping The crop texture would not always render correctly because the projection matrix had not been set.
2016-03-31 11:00:04 -07:00
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
gs_matrix_scale3f(cx_scale, cy_scale, 1.0f);
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
gs_matrix_translate3f(-(float)item->crop.left,
-(float)item->crop.top, 0.0f);
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
if (item->user_visible &&
transition_active(item->show_transition)) {
const int cx =
obs_source_get_width(item->source);
const int cy =
obs_source_get_height(item->source);
obs_transition_set_size(item->show_transition,
cx, cy);
obs_source_video_render(item->show_transition);
} else if (!item->user_visible &&
transition_active(item->hide_transition)) {
const int cx =
obs_source_get_width(item->source);
const int cy =
obs_source_get_height(item->source);
obs_transition_set_size(item->hide_transition,
cx, cy);
obs_source_video_render(item->hide_transition);
} else {
libobs: Plumb texcoord hint to reduce GPU cost In order to do linear-correct filtering cheaply when scale filtering is disabled, we need to know whether or not texture coordinates will always sample from texel centers. This can be computed at the scene item level relatively easily, and passed along to sources when rendering. Scene items will use obs_source_set_texcoords_centered to set hint status, and sources will use obs_source_get_texcoords_centered to retrieve it.
2021-07-06 22:03:45 -07:00
obs_source_set_texcoords_centered(item->source,
true);
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
obs_source_video_render(item->source);
libobs: Plumb texcoord hint to reduce GPU cost In order to do linear-correct filtering cheaply when scale filtering is disabled, we need to know whether or not texture coordinates will always sample from texel centers. This can be computed at the scene item level relatively easily, and passed along to sources when rendering. Scene items will use obs_source_set_texcoords_centered to set hint status, and sources will use obs_source_get_texcoords_centered to retrieve it.
2021-07-06 22:03:45 -07:00
obs_source_set_texcoords_centered(item->source,
false);
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
}
libobs: Fix various alpha issues There are cases where alpha is multiplied unnecessarily. This change attempts to use premultiplied alpha blending for composition. To keep this change simple, The filter chain will continue to use straight alpha. Otherwise, every source would need to modified to output premultiplied, and every filter modified for premultiplied input. "DrawAlphaDivide" shader techniques have been added to convert from premultiplied alpha to straight alpha for final output. "DrawMatrix" techniques ignore alpha, so they do not appear to need changing. One remaining issue is that scale effects are set up here to use the same shader logic for both scale filters (straight alpha - incorrectly), and output composition (premultiplied alpha - correctly). A fix could be made to add additional shaders for straight alpha, but the "real" fix may be to eliminate the straight alpha path at some point. For graphics, SrcBlendAlpha and DestBlendAlpha were both ONE, and could combine together to form alpha values greater than one. This is not as noticeable of a problem for UNORM targets because the channels are clamped, but it will likely become a problem in more situations if FLOAT targets are used. This change switches DestBlendAlpha to INVSRCALPHA. The blending behavior of stacked transparents is preserved without overflowing the alpha channel. obs-transitions: Use premultiplied alpha blend, and simplify shaders because both inputs and outputs use premultiplied alpha now. Fixes https://obsproject.com/mantis/view.php?id=1108
2019-05-03 03:54:17 -07:00
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
gs_texrender_end(item->item_render);
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
}
}
libobs: Add support for nonlinear SRGB blending
2022-03-31 19:15:10 -07:00
const bool linear_srgb =
!item->item_render ||
(item->blend_method != OBS_BLEND_METHOD_SRGB_OFF);
const bool previous = gs_set_linear_srgb(linear_srgb);
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
gs_matrix_push();
gs_matrix_mul(&item->draw_transform);
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
if (item->item_render) {
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
render_item_texture(item, current_space, source_space);
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
} else if (item->user_visible &&
transition_active(item->show_transition)) {
const int cx = obs_source_get_width(item->source);
const int cy = obs_source_get_height(item->source);
obs_transition_set_size(item->show_transition, cx, cy);
obs_source_video_render(item->show_transition);
} else if (!item->user_visible &&
transition_active(item->hide_transition)) {
const int cx = obs_source_get_width(item->source);
const int cy = obs_source_get_height(item->source);
obs_transition_set_size(item->hide_transition, cx, cy);
obs_source_video_render(item->hide_transition);
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
} else {
libobs: Plumb texcoord hint to reduce GPU cost In order to do linear-correct filtering cheaply when scale filtering is disabled, we need to know whether or not texture coordinates will always sample from texel centers. This can be computed at the scene item level relatively easily, and passed along to sources when rendering. Scene items will use obs_source_set_texcoords_centered to set hint status, and sources will use obs_source_get_texcoords_centered to retrieve it.
2021-07-06 22:03:45 -07:00
const bool centered =
are_texcoords_centered(&item->draw_transform);
obs_source_set_texcoords_centered(item->source, centered);
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
obs_source_video_render(item->source);
libobs: Plumb texcoord hint to reduce GPU cost In order to do linear-correct filtering cheaply when scale filtering is disabled, we need to know whether or not texture coordinates will always sample from texel centers. This can be computed at the scene item level relatively easily, and passed along to sources when rendering. Scene items will use obs_source_set_texcoords_centered to set hint status, and sources will use obs_source_get_texcoords_centered to retrieve it.
2021-07-06 22:03:45 -07:00
obs_source_set_texcoords_centered(item->source, false);
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
}
gs_matrix_pop();
libobs: Update render_item to enable linear SRGB Does nothing without linear-aware modifications to sources.
2021-01-19 15:01:51 -08:00
gs_set_linear_srgb(previous);
libobs: UI: Use graphics debug markers Add D3D/GL debug markers to make RenderDoc captures easier to tranverse. Also add obs_source_get_name_no_null() to avoid boilerplate for safe string formatting. Closes obsproject/obs-studio#1799
2019-04-02 23:23:37 -07:00
cleanup:
GS_DEBUG_MARKER_END();
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
}
static void scene_video_tick(void *data, float seconds)
{
struct obs_scene *scene = data;
struct obs_scene_item *item;
video_lock(scene);
item = scene->first_item;
while (item) {
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
if (item->item_render)
gs_texrender_reset(item->item_render);
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
item = item->next;
}
video_unlock(scene);
UNUSED_PARAMETER(seconds);
}
libobs: Defer and refactor scene item transform update Defers updating the scene item transform to the graphics thread to reduce the number of transform update calls.
2018-06-01 07:41:33 -07:00
/* assumes video lock */
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
static void
update_transforms_and_prune_sources(obs_scene_t *scene,
struct darray *remove_items,
obs_sceneitem_t *group_sceneitem)
libobs: Defer and refactor scene item transform update Defers updating the scene item transform to the graphics thread to reduce the number of transform update calls.
2018-06-01 07:41:33 -07:00
{
struct obs_scene_item *item = scene->first_item;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
bool rebuild_group =
group_sceneitem &&
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
os_atomic_load_bool(&group_sceneitem->update_group_resize);
libobs: Defer and refactor scene item transform update Defers updating the scene item transform to the graphics thread to reduce the number of transform update calls.
2018-06-01 07:41:33 -07:00
while (item) {
if (obs_source_removed(item->source)) {
struct obs_scene_item *del_item = item;
item = item->next;
remove_without_release(del_item);
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
darray_push_back(sizeof(struct obs_scene_item *),
remove_items, &del_item);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
rebuild_group = true;
libobs: Defer and refactor scene item transform update Defers updating the scene item transform to the graphics thread to reduce the number of transform update calls.
2018-06-01 07:41:33 -07:00
continue;
}
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
if (item->is_group) {
obs_scene_t *group_scene = item->source->context.data;
video_lock(group_scene);
update_transforms_and_prune_sources(group_scene,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
remove_items, item);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
video_unlock(group_scene);
}
libobs: Defer and refactor scene item transform update Defers updating the scene item transform to the graphics thread to reduce the number of transform update calls.
2018-06-01 07:41:33 -07:00
if (os_atomic_load_bool(&item->update_transform) ||
source_size_changed(item)) {
libobs: Only update scene item texture on frame tick Instead of updating the scene item texture any time update_item_transform() is called, only update it when obs_scene_item::update_transform is called. Prevents having to lock the graphics mutex needlessly.
2018-07-24 02:28:43 -07:00
update_item_transform(item, true);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
rebuild_group = true;
libobs: Defer and refactor scene item transform update Defers updating the scene item transform to the graphics thread to reduce the number of transform update calls.
2018-06-01 07:41:33 -07:00
}
item = item->next;
}
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
if (rebuild_group && group_sceneitem)
resize_group(group_sceneitem);
libobs: Defer and refactor scene item transform update Defers updating the scene item transform to the graphics thread to reduce the number of transform update calls.
2018-06-01 07:41:33 -07:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
static void scene_video_render(void *data, gs_effect_t *effect)
first commit
2013-09-30 19:37:13 -07:00
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
DARRAY(struct obs_scene_item *) remove_items;
Fix another bug (don't commit without compiling) Also don't code in anger
2014-01-30 11:42:20 -08:00
struct obs_scene *scene = data;
struct obs_scene_item *item;
libobs: Release scene items outside of scene mutexes Prevents a mutual lock with the scene mutex and graphics mutex. In libobs/obs-video.c, the graphics mutex could be locked first, then the scene mutexes second, while in the UI thread, the scene mutexes could be locked first, then when a scene item is being destroyed, a source could be destroyed, and sometimes sources would lock the graphics mutex second. A possible additional solution is to defer source destroys to the video thread.
2016-01-03 15:42:10 -08:00
da_init(remove_items);
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
video_lock(scene);
first commit
2013-09-30 19:37:13 -07:00
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
if (!scene->is_group) {
update_transforms_and_prune_sources(scene, &remove_items.da,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
NULL);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
}
libobs: Use alpha when rendering scenes This is just in case a filter is applied to a scene, filters will turn off the blending so it's necessary to set the blending.
2015-03-21 10:33:10 -07:00
gs_blend_state_push();
libobs: Use default blend state with scenes Instead of manually setting the blend state to the desired values, use gs_reset_blend_state to ensure we have the default blend state (which for color is a typical srcalpha/invsrcalpha alpha blending operation, then the alpha channels are added together). This fixes an issue where filtered scenes would look strange due to the fact that alpha was not being blended properly.
2015-03-27 11:22:58 -07:00
gs_reset_blend_state();
libobs: Use alpha when rendering scenes This is just in case a filter is applied to a scene, filters will turn off the blending so it's necessary to set the blending.
2015-03-21 10:33:10 -07:00
libobs: Defer and refactor scene item transform update Defers updating the scene item transform to the graphics thread to reduce the number of transform update calls.
2018-06-01 07:41:33 -07:00
item = scene->first_item;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
while (item) {
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
if (item->user_visible ||
transition_active(item->hide_transition))
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
render_item(item);
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
item = item->next;
first commit
2013-09-30 19:37:13 -07:00
}
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
libobs: Use alpha when rendering scenes This is just in case a filter is applied to a scene, filters will turn off the blending so it's necessary to set the blending.
2015-03-21 10:33:10 -07:00
gs_blend_state_pop();
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
video_unlock(scene);
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
libobs: Release scene items outside of scene mutexes Prevents a mutual lock with the scene mutex and graphics mutex. In libobs/obs-video.c, the graphics mutex could be locked first, then the scene mutexes second, while in the UI thread, the scene mutexes could be locked first, then when a scene item is being destroyed, a source could be destroyed, and sometimes sources would lock the graphics mutex second. A possible additional solution is to defer source destroys to the video thread.
2016-01-03 15:42:10 -08:00
for (size_t i = 0; i < remove_items.num; i++)
obs_sceneitem_release(remove_items.array[i]);
da_free(remove_items);
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
UNUSED_PARAMETER(effect);
}
libobs: Release scene items outside of scene mutexes Prevents a mutual lock with the scene mutex and graphics mutex. In libobs/obs-video.c, the graphics mutex could be locked first, then the scene mutexes second, while in the UI thread, the scene mutexes could be locked first, then when a scene item is being destroyed, a source could be destroyed, and sometimes sources would lock the graphics mutex second. A possible additional solution is to defer source destroys to the video thread.
2016-01-03 15:42:10 -08:00
static void set_visibility(struct obs_scene_item *item, bool vis)
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
{
pthread_mutex_lock(&item->actions_mutex);
da_resize(item->audio_actions, 0);
if (os_atomic_load_long(&item->active_refs) > 0) {
if (!vis)
obs_source_remove_active_child(item->parent->source,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
item->source);
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
} else if (vis) {
obs_source_add_active_child(item->parent->source, item->source);
}
os_atomic_set_long(&item->active_refs, vis ? 1 : 0);
item->visible = vis;
item->user_visible = vis;
pthread_mutex_unlock(&item->actions_mutex);
}
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
static void scene_load(void *data, obs_data_t *settings);
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
static void scene_load_item(struct obs_scene *scene, obs_data_t *item_data)
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
const char *name = obs_data_get_string(item_data, "name");
obs_source_t *source;
const char *scale_filter_str;
libobs: Add support for nonlinear SRGB blending
2022-03-31 19:15:10 -07:00
const char *blend_method_str;
libobs: Implement additional source blending modes
2021-10-24 08:45:15 -07:00
const char *blend_str;
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
struct obs_scene_item *item;
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
bool visible;
UI, libobs: Add ability to lock individual scene items Adds a lock checkbox to allow the user to lock a specific scene item. Closes jp9000/obs-studio#949
2017-06-17 17:10:42 -07:00
bool lock;
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
if (obs_data_get_bool(item_data, "group_item_backup"))
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
return;
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
libobs: Change groups to actual public types (This commit also modifies UI) Changes groups to their own independent type, "group". This allows them to be used like other regular types, and allows the ability to reference groups in multiple scenes. Before, a group would always be linked to the scene it was in. This made it cumbersome for users to modify groups if they had a similar group in multiple scenes (they would have to modify each group in each scene). Making groups like other source types makes more sense to solve this issue so they can be referenced in multiple scenes at once. This also removes a significant amount of group-specific handling code required for implementing groups in the front-end. One limitation however: due to the way sub-items of groups are seamlessly modifiable and sortable as part of the whole scene, the user cannot have multiple references to the same group within one scene.
2018-07-15 18:50:33 -07:00
source = obs_get_source_by_name(name);
if (!source) {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
blog(LOG_WARNING,
"[scene_load_item] Source %s not "
"found!",
name);
libobs: Change groups to actual public types (This commit also modifies UI) Changes groups to their own independent type, "group". This allows them to be used like other regular types, and allows the ability to reference groups in multiple scenes. Before, a group would always be linked to the scene it was in. This made it cumbersome for users to modify groups if they had a similar group in multiple scenes (they would have to modify each group in each scene). Making groups like other source types makes more sense to solve this issue so they can be referenced in multiple scenes at once. This also removes a significant amount of group-specific handling code required for implementing groups in the front-end. One limitation however: due to the way sub-items of groups are seamlessly modifiable and sortable as part of the whole scene, the user cannot have multiple references to the same group within one scene.
2018-07-15 18:50:33 -07:00
return;
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
}
item = obs_scene_add(scene, source);
libobs: Handle obs_scene_add failure Previously a NULL item would cause a crash when reading transform info. The crash can be reproduced by e.g. editing scenes.json so that two scenes contain each other. Example scenes.json: { "current_scene": "Scene", "sources": [ { "flags": 0, "id": "scene", "mixers": 0, "name": "Scene", "settings": { "items": [ { "align": 5, "bounds": { "x": 1440.0, "y": 900.0 }, "bounds_align": 0, "bounds_type": 2, "name": "Scene 2", "pos": { "x": 0.0, "y": 0.0 }, "rot": 0.0, "scale": { "x": 1.0, "y": 1.0 }, "visible": true } ] }, "sync": 0, "volume": 1.0 }, { "flags": 0, "id": "scene", "mixers": 0, "name": "Scene 2", "settings": { "items": [ { "align": 5, "bounds": { "x": 1.0, "y": 1.0 }, "bounds_align": 0, "bounds_type": 0, "name": "Scene", "pos": { "x": 854.0, "y": -520.0 }, "rot": 0.0, "scale": { "x": 1.75, "y": 1.7562724351882935 }, "visible": true } ] }, "sync": 0, "volume": 1.0 } ] }
2015-02-17 03:08:08 -08:00
if (!item) {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
blog(LOG_WARNING,
"[scene_load_item] Could not add source '%s' "
"to scene '%s'!",
name, obs_source_get_name(scene->source));
libobs: Handle obs_scene_add failure Previously a NULL item would cause a crash when reading transform info. The crash can be reproduced by e.g. editing scenes.json so that two scenes contain each other. Example scenes.json: { "current_scene": "Scene", "sources": [ { "flags": 0, "id": "scene", "mixers": 0, "name": "Scene", "settings": { "items": [ { "align": 5, "bounds": { "x": 1440.0, "y": 900.0 }, "bounds_align": 0, "bounds_type": 2, "name": "Scene 2", "pos": { "x": 0.0, "y": 0.0 }, "rot": 0.0, "scale": { "x": 1.0, "y": 1.0 }, "visible": true } ] }, "sync": 0, "volume": 1.0 }, { "flags": 0, "id": "scene", "mixers": 0, "name": "Scene 2", "settings": { "items": [ { "align": 5, "bounds": { "x": 1.0, "y": 1.0 }, "bounds_align": 0, "bounds_type": 0, "name": "Scene", "pos": { "x": 854.0, "y": -520.0 }, "rot": 0.0, "scale": { "x": 1.75, "y": 1.7562724351882935 }, "visible": true } ] }, "sync": 0, "volume": 1.0 } ] }
2015-02-17 03:08:08 -08:00
obs_source_release(source);
return;
}
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
libobs: Fix groups not being recognized as groups The id of the source was being pointer compared rather than string compared, so naturally with the source versioning system where the string is duplicated, the pointers no longer matched.
2020-03-09 17:08:51 -07:00
item->is_group = strcmp(source->info.id, group_info.id) == 0;
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
obs_data_set_default_int(item_data, "align",
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
OBS_ALIGN_TOP | OBS_ALIGN_LEFT);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
libobs: Add scene item IDs Adds a method of uniquely identifying scene items, as well as finding those scene items via that unique ID.
2017-05-15 00:13:28 -07:00
if (obs_data_has_user_value(item_data, "id"))
item->id = obs_data_get_int(item_data, "id");
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
item->rot = (float)obs_data_get_double(item_data, "rot");
item->align = (uint32_t)obs_data_get_int(item_data, "align");
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
visible = obs_data_get_bool(item_data, "visible");
UI, libobs: Add ability to lock individual scene items Adds a lock checkbox to allow the user to lock a specific scene item. Closes jp9000/obs-studio#949
2017-06-17 17:10:42 -07:00
lock = obs_data_get_bool(item_data, "locked");
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_data_get_vec2(item_data, "pos", &item->pos);
obs_data_get_vec2(item_data, "scale", &item->scale);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
libobs: Add private settings to scene items/sources Allows setting and sharing of user data for sources and scene items.
2017-09-13 03:12:56 -07:00
obs_data_release(item->private_settings);
item->private_settings =
obs_data_get_obj(item_data, "private_settings");
if (!item->private_settings)
item->private_settings = obs_data_create();
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
set_visibility(item, visible);
UI, libobs: Add ability to lock individual scene items Adds a lock checkbox to allow the user to lock a specific scene item. Closes jp9000/obs-studio#949
2017-06-17 17:10:42 -07:00
obs_sceneitem_set_locked(item, lock);
libobs: Make scene item visibility activate/deactivate Before if a source was set to invisible it would still be considered active. This changes it so that the source is deactivated when the source is invisible to reduce needless resource usage or capturing.
2015-12-22 05:25:31 -08:00
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
item->bounds_type = (enum obs_bounds_type)obs_data_get_int(
item_data, "bounds_type");
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
item->bounds_align =
(API Change) Unsquish obs_data_* names Changed: To: ----------------------------------------------- obs_data_getjson obs_data_get_json obs_data_getstring obs_data_get_string obs_data_getint obs_data_get_int obs_data_getdouble obs_data_get_double obs_data_getbool obs_data_get_bool obs_data_getobj obs_data_get_obj obs_data_getarray obs_data_get_array obs_data_setstring obs_data_set_string obs_data_setint obs_data_set_int obs_data_setdouble obs_data_set_double obs_data_setbool obs_data_set_bool obs_data_setobj obs_data_set_obj obs_data_setarray obs_data_set_array obs_data_item_getstring obs_data_item_get_string obs_data_item_getint obs_data_item_get_int obs_data_item_getdouble obs_data_item_get_double obs_data_item_getbool obs_data_item_get_bool obs_data_item_getobj obs_data_item_get_obj obs_data_item_getarray obs_data_item_get_array obs_data_item_setstring obs_data_item_set_string obs_data_item_setint obs_data_item_set_int obs_data_item_setdouble obs_data_item_set_double obs_data_item_setbool obs_data_item_set_bool obs_data_item_setobj obs_data_item_set_obj obs_data_item_setarray obs_data_item_set_array
2014-08-05 11:09:29 -07:00
(uint32_t)obs_data_get_int(item_data, "bounds_align");
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
obs_data_get_vec2(item_data, "bounds", &item->bounds);
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
item->crop.left = (uint32_t)obs_data_get_int(item_data, "crop_left");
item->crop.top = (uint32_t)obs_data_get_int(item_data, "crop_top");
item->crop.right = (uint32_t)obs_data_get_int(item_data, "crop_right");
item->crop.bottom =
(uint32_t)obs_data_get_int(item_data, "crop_bottom");
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
libobs: Use strings instead of enums when saving scale data Saves the scene item scale filters as strings instead of enums. It's important to save data in a form that won't break if an API enum changes.
2016-06-29 08:19:23 -07:00
scale_filter_str = obs_data_get_string(item_data, "scale_filter");
item->scale_filter = OBS_SCALE_DISABLE;
if (scale_filter_str) {
if (astrcmpi(scale_filter_str, "point") == 0)
item->scale_filter = OBS_SCALE_POINT;
else if (astrcmpi(scale_filter_str, "bilinear") == 0)
item->scale_filter = OBS_SCALE_BILINEAR;
else if (astrcmpi(scale_filter_str, "bicubic") == 0)
item->scale_filter = OBS_SCALE_BICUBIC;
else if (astrcmpi(scale_filter_str, "lanczos") == 0)
item->scale_filter = OBS_SCALE_LANCZOS;
Add "Area" scale filter This new scale filter computes pixels by weighing the coverage area of source pixels over the target pixel. This algorithm works well for both upsampling and downsampling, but was mainly designed to upscale high-quality low-resolution sources like RGB/HDMI retro consoles. I've heard of people using odd workarounds like scaling up to very high resolutions before scaling back down to preserve pixel shartpness. This algorithm directly addresses this use-case in a much more direct fashion. The Area scale filter does a better job of preserving the thickness of thin features than the Point filter. The Area scale filter does not look at source pixels that lie outside of the target pixel, leading to a much sharper image than Bilinear, Bicubic, and Lanczos filters. This filter should interpolate pixels in linear space, but OBS is not equipped to do that at the moment. libobs: Add GPU effect, and wire up scene serialization. obs-filters: Add Area as an option for scale_filter. UI: Add Area as an option for both scene items, and canvas downscaling.
2019-03-06 20:53:15 -08:00
else if (astrcmpi(scale_filter_str, "area") == 0)
item->scale_filter = OBS_SCALE_AREA;
libobs: Use strings instead of enums when saving scale data Saves the scene item scale filters as strings instead of enums. It's important to save data in a form that won't break if an API enum changes.
2016-06-29 08:19:23 -07:00
}
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
libobs: Add support for nonlinear SRGB blending
2022-03-31 19:15:10 -07:00
blend_method_str = obs_data_get_string(item_data, "blend_method");
item->blend_method = OBS_BLEND_METHOD_DEFAULT;
if (blend_method_str) {
if (astrcmpi(blend_method_str, "srgb_off") == 0)
item->blend_method = OBS_BLEND_METHOD_SRGB_OFF;
}
libobs: Implement additional source blending modes
2021-10-24 08:45:15 -07:00
blend_str = obs_data_get_string(item_data, "blend_type");
item->blend_type = OBS_BLEND_NORMAL;
if (blend_str) {
libobs: Remove unnecessary blend_type assignment The code pattern for all other assignments skips the default value. Detected by PVS Studio.
2022-04-18 18:14:24 -07:00
if (astrcmpi(blend_str, "additive") == 0)
libobs: Implement additional source blending modes
2021-10-24 08:45:15 -07:00
item->blend_type = OBS_BLEND_ADDITIVE;
else if (astrcmpi(blend_str, "subtract") == 0)
item->blend_type = OBS_BLEND_SUBTRACT;
else if (astrcmpi(blend_str, "screen") == 0)
item->blend_type = OBS_BLEND_SCREEN;
else if (astrcmpi(blend_str, "multiply") == 0)
item->blend_type = OBS_BLEND_MULTIPLY;
else if (astrcmpi(blend_str, "lighten") == 0)
item->blend_type = OBS_BLEND_LIGHTEN;
else if (astrcmpi(blend_str, "darken") == 0)
item->blend_type = OBS_BLEND_DARKEN;
}
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
obs_data_t *show_data = obs_data_get_obj(item_data, "show_transition");
if (show_data) {
libobs: Add transition save/load functions Moves the transition saving/loading to functions, and refactors existing code to use those functions instead.
2021-04-11 09:42:41 -07:00
obs_sceneitem_transition_load(item, show_data, true);
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
obs_data_release(show_data);
}
obs_data_t *hide_data = obs_data_get_obj(item_data, "hide_transition");
if (hide_data) {
libobs: Add transition save/load functions Moves the transition saving/loading to functions, and refactors existing code to use those functions instead.
2021-04-11 09:42:41 -07:00
obs_sceneitem_transition_load(item, hide_data, false);
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
obs_data_release(hide_data);
}
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
obs_source_release(source);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
libobs: Only update scene item texture on frame tick Instead of updating the scene item texture any time update_item_transform() is called, only update it when obs_scene_item::update_transform is called. Prevents having to lock the graphics mutex needlessly.
2018-07-24 02:28:43 -07:00
update_item_transform(item, false);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
}
libobs: Add scene item IDs Adds a method of uniquely identifying scene items, as well as finding those scene items via that unique ID.
2017-05-15 00:13:28 -07:00
static void scene_load(void *data, obs_data_t *settings)
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
{
libobs: Add scene item IDs Adds a method of uniquely identifying scene items, as well as finding those scene items via that unique ID.
2017-05-15 00:13:28 -07:00
struct obs_scene *scene = data;
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
obs_data_array_t *items = obs_data_get_array(settings, "items");
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
size_t count, i;
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
remove_all_items(scene);
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
if (!items)
return;
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
count = obs_data_array_count(items);
for (i = 0; i < count; i++) {
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
obs_data_t *item_data = obs_data_array_item(items, i);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
scene_load_item(scene, item_data);
obs_data_release(item_data);
}
libobs: Add scene item IDs Adds a method of uniquely identifying scene items, as well as finding those scene items via that unique ID.
2017-05-15 00:13:28 -07:00
if (obs_data_has_user_value(settings, "id_counter"))
scene->id_counter = obs_data_get_int(settings, "id_counter");
libobs: Add custom size support to scenes Allows scenes to have a custom size. Mainly used for grouping, but can be extended with public API later.
2018-06-01 08:18:19 -07:00
if (obs_data_get_bool(settings, "custom_size")) {
scene->cx = (uint32_t)obs_data_get_int(settings, "cx");
scene->cy = (uint32_t)obs_data_get_int(settings, "cy");
scene->custom_size = true;
}
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
obs_data_array_release(items);
}
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
static void scene_save(void *data, obs_data_t *settings);
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
static void scene_save_item(obs_data_array_t *array,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct obs_scene_item *item,
struct obs_scene_item *backup_group)
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
{
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
obs_data_t *item_data = obs_data_create();
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
const char *name = obs_source_get_name(item->source);
libobs: Use strings instead of enums when saving scale data Saves the scene item scale filters as strings instead of enums. It's important to save data in a form that won't break if an API enum changes.
2016-06-29 08:19:23 -07:00
const char *scale_filter;
libobs: Add support for nonlinear SRGB blending
2022-03-31 19:15:10 -07:00
const char *blend_method;
libobs: Implement additional source blending modes
2021-10-24 08:45:15 -07:00
const char *blend_type;
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
struct vec2 pos = item->pos;
struct vec2 scale = item->scale;
float rot = item->rot;
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
if (backup_group) {
get_ungrouped_transform(backup_group, &pos, &scale, &rot);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
}
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_data_set_string(item_data, "name", name);
obs_data_set_bool(item_data, "visible", item->user_visible);
obs_data_set_bool(item_data, "locked", item->locked);
obs_data_set_double(item_data, "rot", rot);
obs_data_set_vec2(item_data, "pos", &pos);
obs_data_set_vec2(item_data, "scale", &scale);
obs_data_set_int(item_data, "align", (int)item->align);
obs_data_set_int(item_data, "bounds_type", (int)item->bounds_type);
obs_data_set_int(item_data, "bounds_align", (int)item->bounds_align);
obs_data_set_vec2(item_data, "bounds", &item->bounds);
obs_data_set_int(item_data, "crop_left", (int)item->crop.left);
obs_data_set_int(item_data, "crop_top", (int)item->crop.top);
obs_data_set_int(item_data, "crop_right", (int)item->crop.right);
obs_data_set_int(item_data, "crop_bottom", (int)item->crop.bottom);
obs_data_set_int(item_data, "id", item->id);
obs_data_set_bool(item_data, "group_item_backup", !!backup_group);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
if (item->is_group) {
obs_scene_t *group_scene = item->source->context.data;
obs_sceneitem_t *group_item;
/* save group items as part of main scene, but ignored.
* causes an automatic ungroup if scene collection file
* is loaded in previous versions. */
full_lock(group_scene);
group_item = group_scene->first_item;
while (group_item) {
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
scene_save_item(array, group_item, item);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
group_item = group_item->next;
}
full_unlock(group_scene);
}
libobs: Use strings instead of enums when saving scale data Saves the scene item scale filters as strings instead of enums. It's important to save data in a form that won't break if an API enum changes.
2016-06-29 08:19:23 -07:00
if (item->scale_filter == OBS_SCALE_POINT)
scale_filter = "point";
else if (item->scale_filter == OBS_SCALE_BILINEAR)
scale_filter = "bilinear";
else if (item->scale_filter == OBS_SCALE_BICUBIC)
scale_filter = "bicubic";
else if (item->scale_filter == OBS_SCALE_LANCZOS)
scale_filter = "lanczos";
Add "Area" scale filter This new scale filter computes pixels by weighing the coverage area of source pixels over the target pixel. This algorithm works well for both upsampling and downsampling, but was mainly designed to upscale high-quality low-resolution sources like RGB/HDMI retro consoles. I've heard of people using odd workarounds like scaling up to very high resolutions before scaling back down to preserve pixel shartpness. This algorithm directly addresses this use-case in a much more direct fashion. The Area scale filter does a better job of preserving the thickness of thin features than the Point filter. The Area scale filter does not look at source pixels that lie outside of the target pixel, leading to a much sharper image than Bilinear, Bicubic, and Lanczos filters. This filter should interpolate pixels in linear space, but OBS is not equipped to do that at the moment. libobs: Add GPU effect, and wire up scene serialization. obs-filters: Add Area as an option for scale_filter. UI: Add Area as an option for both scene items, and canvas downscaling.
2019-03-06 20:53:15 -08:00
else if (item->scale_filter == OBS_SCALE_AREA)
scale_filter = "area";
libobs: Use strings instead of enums when saving scale data Saves the scene item scale filters as strings instead of enums. It's important to save data in a form that won't break if an API enum changes.
2016-06-29 08:19:23 -07:00
else
scale_filter = "disable";
obs_data_set_string(item_data, "scale_filter", scale_filter);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
libobs: Add support for nonlinear SRGB blending
2022-03-31 19:15:10 -07:00
if (item->blend_method == OBS_BLEND_METHOD_SRGB_OFF)
blend_method = "srgb_off";
else
blend_method = "default";
obs_data_set_string(item_data, "blend_method", blend_method);
libobs: Implement additional source blending modes
2021-10-24 08:45:15 -07:00
if (item->blend_type == OBS_BLEND_NORMAL)
blend_type = "normal";
else if (item->blend_type == OBS_BLEND_ADDITIVE)
blend_type = "additive";
else if (item->blend_type == OBS_BLEND_SUBTRACT)
blend_type = "subtract";
else if (item->blend_type == OBS_BLEND_SCREEN)
blend_type = "screen";
else if (item->blend_type == OBS_BLEND_MULTIPLY)
blend_type = "multiply";
else if (item->blend_type == OBS_BLEND_LIGHTEN)
blend_type = "lighten";
else if (item->blend_type == OBS_BLEND_DARKEN)
blend_type = "darken";
else
blend_type = "normal";
obs_data_set_string(item_data, "blend_type", blend_type);
libobs: Add transition save/load functions Moves the transition saving/loading to functions, and refactors existing code to use those functions instead.
2021-04-11 09:42:41 -07:00
obs_data_t *show_data = obs_sceneitem_transition_save(item, true);
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
obs_data_set_obj(item_data, "show_transition", show_data);
obs_data_release(show_data);
libobs: Add transition save/load functions Moves the transition saving/loading to functions, and refactors existing code to use those functions instead.
2021-04-11 09:42:41 -07:00
obs_data_t *hide_data = obs_sceneitem_transition_save(item, false);
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
obs_data_set_obj(item_data, "hide_transition", hide_data);
obs_data_release(hide_data);
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_data_set_obj(item_data, "private_settings", item->private_settings);
libobs: Add private settings to scene items/sources Allows setting and sharing of user data for sources and scene items.
2017-09-13 03:12:56 -07:00
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
obs_data_array_push_back(array, item_data);
obs_data_release(item_data);
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
static void scene_save(void *data, obs_data_t *settings)
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct obs_scene *scene = data;
obs_data_array_t *array = obs_data_array_create();
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
struct obs_scene_item *item;
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_lock(scene);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
item = scene->first_item;
while (item) {
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
scene_save_item(array, item, NULL);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
item = item->next;
}
libobs: Add scene item IDs Adds a method of uniquely identifying scene items, as well as finding those scene items via that unique ID.
2017-05-15 00:13:28 -07:00
obs_data_set_int(settings, "id_counter", scene->id_counter);
libobs: Add custom size support to scenes Allows scenes to have a custom size. Mainly used for grouping, but can be extended with public API later.
2018-06-01 08:18:19 -07:00
obs_data_set_bool(settings, "custom_size", scene->custom_size);
if (scene->custom_size) {
obs_data_set_int(settings, "cx", scene->cx);
obs_data_set_int(settings, "cy", scene->cy);
}
libobs: Add scene item IDs Adds a method of uniquely identifying scene items, as well as finding those scene items via that unique ID.
2017-05-15 00:13:28 -07:00
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_unlock(scene);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
(API Change) Unsquish obs_data_* names Changed: To: ----------------------------------------------- obs_data_getjson obs_data_get_json obs_data_getstring obs_data_get_string obs_data_getint obs_data_get_int obs_data_getdouble obs_data_get_double obs_data_getbool obs_data_get_bool obs_data_getobj obs_data_get_obj obs_data_getarray obs_data_get_array obs_data_setstring obs_data_set_string obs_data_setint obs_data_set_int obs_data_setdouble obs_data_set_double obs_data_setbool obs_data_set_bool obs_data_setobj obs_data_set_obj obs_data_setarray obs_data_set_array obs_data_item_getstring obs_data_item_get_string obs_data_item_getint obs_data_item_get_int obs_data_item_getdouble obs_data_item_get_double obs_data_item_getbool obs_data_item_get_bool obs_data_item_getobj obs_data_item_get_obj obs_data_item_getarray obs_data_item_get_array obs_data_item_setstring obs_data_item_set_string obs_data_item_setint obs_data_item_set_int obs_data_item_setdouble obs_data_item_set_double obs_data_item_setbool obs_data_item_set_bool obs_data_item_setobj obs_data_item_set_obj obs_data_item_setarray obs_data_item_set_array
2014-08-05 11:09:29 -07:00
obs_data_set_array(settings, "items", array);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
obs_data_array_release(array);
}
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
static uint32_t scene_getwidth(void *data)
{
libobs: Add custom size support to scenes Allows scenes to have a custom size. Mainly used for grouping, but can be extended with public API later.
2018-06-01 08:18:19 -07:00
obs_scene_t *scene = data;
return scene->custom_size ? scene->cx : obs->video.base_width;
first commit
2013-09-30 19:37:13 -07:00
}
Remove majority of warnings There were a *lot* of warnings, managed to remove most of them. Also, put warning flags before C_FLAGS and CXX_FLAGS, rather than after, as -Wall -Wextra was overwriting flags that came before it.
2014-02-14 14:13:36 -08:00
static uint32_t scene_getheight(void *data)
first commit
2013-09-30 19:37:13 -07:00
{
libobs: Add custom size support to scenes Allows scenes to have a custom size. Mainly used for grouping, but can be extended with public API later.
2018-06-01 08:18:19 -07:00
obs_scene_t *scene = data;
return scene->custom_size ? scene->cy : obs->video.base_height;
first commit
2013-09-30 19:37:13 -07:00
}
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
static void apply_scene_item_audio_actions(struct obs_scene_item *item,
libobs: Avoid unnecessary mallocs in audio processing
2020-09-02 16:49:54 -07:00
float *buf, uint64_t ts,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
size_t sample_rate)
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
{
bool cur_visible = item->visible;
uint64_t frame_num = 0;
size_t deref_count = 0;
pthread_mutex_lock(&item->actions_mutex);
for (size_t i = 0; i < item->audio_actions.num; i++) {
struct item_action action = item->audio_actions.array[i];
uint64_t timestamp = action.timestamp;
uint64_t new_frame_num;
if (timestamp < ts)
timestamp = ts;
libobs: Implement and use better scaling function for 64-bit integers As os_gettime_ns() gets large the current scaling methods, mostly by casting to uint64_t, may lead to numerical overflows. Sweep the code and use util_mul_div64() where applicable. Signed-off-by: Hans Petter Selasky <hps@selasky.org>
2020-03-21 02:55:12 -07:00
new_frame_num = util_mul_div64(timestamp - ts, sample_rate,
1000000000ULL);
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
libobs: Process all scene audio actions if no audio playing When there are audio sources in a scene and they've all stopped playing their audio (audio is pending), all scene item audio actions (volume changes, toggling visibility) will perpetually buffer and no longer be processed until audio plays again. So instead of that, if all audio sources have stopped playing in the scene, just process all pending scene item audio actions immediately to prevent them from never being processed while waiting for a scene item to start playing audio.
2016-12-22 00:25:23 -08:00
if (ts && new_frame_num >= AUDIO_OUTPUT_FRAMES)
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
break;
da_erase(item->audio_actions, i--);
item->visible = action.visible;
if (!item->visible)
deref_count++;
libobs: Process all scene audio actions if no audio playing When there are audio sources in a scene and they've all stopped playing their audio (audio is pending), all scene item audio actions (volume changes, toggling visibility) will perpetually buffer and no longer be processed until audio plays again. So instead of that, if all audio sources have stopped playing in the scene, just process all pending scene item audio actions immediately to prevent them from never being processed while waiting for a scene item to start playing audio.
2016-12-22 00:25:23 -08:00
if (buf && new_frame_num > frame_num) {
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
for (; frame_num < new_frame_num; frame_num++)
buf[frame_num] = cur_visible ? 1.0f : 0.0f;
}
cur_visible = item->visible;
}
libobs: Process all scene audio actions if no audio playing When there are audio sources in a scene and they've all stopped playing their audio (audio is pending), all scene item audio actions (volume changes, toggling visibility) will perpetually buffer and no longer be processed until audio plays again. So instead of that, if all audio sources have stopped playing in the scene, just process all pending scene item audio actions immediately to prevent them from never being processed while waiting for a scene item to start playing audio.
2016-12-22 00:25:23 -08:00
if (buf) {
for (; frame_num < AUDIO_OUTPUT_FRAMES; frame_num++)
buf[frame_num] = cur_visible ? 1.0f : 0.0f;
}
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
pthread_mutex_unlock(&item->actions_mutex);
while (deref_count--) {
if (os_atomic_dec_long(&item->active_refs) == 0) {
obs_source_remove_active_child(item->parent->source,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
item->source);
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
}
}
}
libobs: Avoid unnecessary mallocs in audio processing
2020-09-02 16:49:54 -07:00
static bool apply_scene_item_volume(struct obs_scene_item *item, float *buf,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
uint64_t ts, size_t sample_rate)
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
{
bool actions_pending;
struct item_action action;
pthread_mutex_lock(&item->actions_mutex);
actions_pending = item->audio_actions.num > 0;
if (actions_pending)
action = item->audio_actions.array[0];
pthread_mutex_unlock(&item->actions_mutex);
if (actions_pending) {
libobs: Implement and use better scaling function for 64-bit integers As os_gettime_ns() gets large the current scaling methods, mostly by casting to uint64_t, may lead to numerical overflows. Sweep the code and use util_mul_div64() where applicable. Signed-off-by: Hans Petter Selasky <hps@selasky.org>
2020-03-21 02:55:12 -07:00
uint64_t duration = util_mul_div64(AUDIO_OUTPUT_FRAMES,
1000000000ULL, sample_rate);
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
libobs: Process all scene audio actions if no audio playing When there are audio sources in a scene and they've all stopped playing their audio (audio is pending), all scene item audio actions (volume changes, toggling visibility) will perpetually buffer and no longer be processed until audio plays again. So instead of that, if all audio sources have stopped playing in the scene, just process all pending scene item audio actions immediately to prevent them from never being processed while waiting for a scene item to start playing audio.
2016-12-22 00:25:23 -08:00
if (!ts || action.timestamp < (ts + duration)) {
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
apply_scene_item_audio_actions(item, buf, ts,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
sample_rate);
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
return true;
}
}
return false;
}
libobs: Process all scene audio actions if no audio playing When there are audio sources in a scene and they've all stopped playing their audio (audio is pending), all scene item audio actions (volume changes, toggling visibility) will perpetually buffer and no longer be processed until audio plays again. So instead of that, if all audio sources have stopped playing in the scene, just process all pending scene item audio actions immediately to prevent them from never being processed while waiting for a scene item to start playing audio.
2016-12-22 00:25:23 -08:00
static void process_all_audio_actions(struct obs_scene_item *item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
size_t sample_rate)
libobs: Process all scene audio actions if no audio playing When there are audio sources in a scene and they've all stopped playing their audio (audio is pending), all scene item audio actions (volume changes, toggling visibility) will perpetually buffer and no longer be processed until audio plays again. So instead of that, if all audio sources have stopped playing in the scene, just process all pending scene item audio actions immediately to prevent them from never being processed while waiting for a scene item to start playing audio.
2016-12-22 00:25:23 -08:00
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
while (apply_scene_item_volume(item, NULL, 0, sample_rate))
;
libobs: Process all scene audio actions if no audio playing When there are audio sources in a scene and they've all stopped playing their audio (audio is pending), all scene item audio actions (volume changes, toggling visibility) will perpetually buffer and no longer be processed until audio plays again. So instead of that, if all audio sources have stopped playing in the scene, just process all pending scene item audio actions immediately to prevent them from never being processed while waiting for a scene item to start playing audio.
2016-12-22 00:25:23 -08:00
}
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
static void mix_audio_with_buf(float *p_out, float *p_in, float *buf_in,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
size_t pos, size_t count)
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
{
register float *out = p_out;
register float *buf = buf_in + pos;
register float *in = p_in + pos;
register float *end = in + count;
while (in < end)
*(out++) += *(in++) * *(buf++);
}
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
static inline void mix_audio(float *p_out, float *p_in, size_t pos,
size_t count)
libobs: Make scenes mix audio of sub-sources Mark scenes as composite sources and use audio_render to mix and output the audio of their sub-sources.
2015-12-17 07:31:05 -08:00
{
register float *out = p_out;
register float *in = p_in + pos;
register float *end = in + count;
while (in < end)
*(out++) += *(in++);
}
static bool scene_audio_render(void *data, uint64_t *ts_out,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct obs_source_audio_mix *audio_output,
uint32_t mixers, size_t channels,
size_t sample_rate)
libobs: Make scenes mix audio of sub-sources Mark scenes as composite sources and use audio_render to mix and output the audio of their sub-sources.
2015-12-17 07:31:05 -08:00
{
uint64_t timestamp = 0;
libobs: Avoid unnecessary mallocs in audio processing
2020-09-02 16:49:54 -07:00
float buf[AUDIO_OUTPUT_FRAMES];
libobs: Make scenes mix audio of sub-sources Mark scenes as composite sources and use audio_render to mix and output the audio of their sub-sources.
2015-12-17 07:31:05 -08:00
struct obs_source_audio_mix child_audio;
struct obs_scene *scene = data;
struct obs_scene_item *item;
audio_lock(scene);
item = scene->first_item;
while (item) {
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
struct obs_source *source;
if (item->visible && transition_active(item->show_transition))
source = item->show_transition;
else if (!item->visible &&
transition_active(item->hide_transition))
source = item->hide_transition;
else
source = item->source;
if (!obs_source_audio_pending(source) &&
(item->visible ||
transition_active(item->hide_transition))) {
libobs: Make scenes mix audio of sub-sources Mark scenes as composite sources and use audio_render to mix and output the audio of their sub-sources.
2015-12-17 07:31:05 -08:00
uint64_t source_ts =
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
obs_source_get_audio_timestamp(source);
libobs: Make scenes mix audio of sub-sources Mark scenes as composite sources and use audio_render to mix and output the audio of their sub-sources.
2015-12-17 07:31:05 -08:00
libobs: Fix bug where scenes would not properly mix audio
2017-02-26 08:17:14 -08:00
if (source_ts && (!timestamp || source_ts < timestamp))
libobs: Make scenes mix audio of sub-sources Mark scenes as composite sources and use audio_render to mix and output the audio of their sub-sources.
2015-12-17 07:31:05 -08:00
timestamp = source_ts;
}
item = item->next;
}
if (!timestamp) {
libobs: Process all scene audio actions if no audio playing When there are audio sources in a scene and they've all stopped playing their audio (audio is pending), all scene item audio actions (volume changes, toggling visibility) will perpetually buffer and no longer be processed until audio plays again. So instead of that, if all audio sources have stopped playing in the scene, just process all pending scene item audio actions immediately to prevent them from never being processed while waiting for a scene item to start playing audio.
2016-12-22 00:25:23 -08:00
/* just process all pending audio actions if no audio playing,
* otherwise audio actions will just never be processed */
item = scene->first_item;
while (item) {
process_all_audio_actions(item, sample_rate);
item = item->next;
}
libobs: Make scenes mix audio of sub-sources Mark scenes as composite sources and use audio_render to mix and output the audio of their sub-sources.
2015-12-17 07:31:05 -08:00
audio_unlock(scene);
return false;
}
item = scene->first_item;
while (item) {
uint64_t source_ts;
size_t pos, count;
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
bool apply_buf;
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
struct obs_source *source;
if (item->visible && transition_active(item->show_transition))
source = item->show_transition;
else if (!item->visible &&
transition_active(item->hide_transition))
source = item->hide_transition;
else
source = item->source;
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
libobs: Avoid unnecessary mallocs in audio processing
2020-09-02 16:49:54 -07:00
apply_buf = apply_scene_item_volume(item, buf, timestamp,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
sample_rate);
libobs: Make scenes mix audio of sub-sources Mark scenes as composite sources and use audio_render to mix and output the audio of their sub-sources.
2015-12-17 07:31:05 -08:00
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
if (obs_source_audio_pending(source)) {
libobs: Make scenes mix audio of sub-sources Mark scenes as composite sources and use audio_render to mix and output the audio of their sub-sources.
2015-12-17 07:31:05 -08:00
item = item->next;
continue;
}
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
source_ts = obs_source_get_audio_timestamp(source);
libobs: Fix bug where scenes would not properly mix audio
2017-02-26 08:17:14 -08:00
if (!source_ts) {
item = item->next;
continue;
}
libobs: Make scenes mix audio of sub-sources Mark scenes as composite sources and use audio_render to mix and output the audio of their sub-sources.
2015-12-17 07:31:05 -08:00
pos = (size_t)ns_to_audio_frames(sample_rate,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
source_ts - timestamp);
libobs: Make scenes mix audio of sub-sources Mark scenes as composite sources and use audio_render to mix and output the audio of their sub-sources.
2015-12-17 07:31:05 -08:00
count = AUDIO_OUTPUT_FRAMES - pos;
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
if (!apply_buf && !item->visible &&
!transition_active(item->hide_transition)) {
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
item = item->next;
continue;
}
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
obs_source_get_audio_mix(source, &child_audio);
libobs: Make scenes mix audio of sub-sources Mark scenes as composite sources and use audio_render to mix and output the audio of their sub-sources.
2015-12-17 07:31:05 -08:00
for (size_t mix = 0; mix < MAX_AUDIO_MIXES; mix++) {
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
if ((mixers & (1 << mix)) == 0)
continue;
libobs: Make scenes mix audio of sub-sources Mark scenes as composite sources and use audio_render to mix and output the audio of their sub-sources.
2015-12-17 07:31:05 -08:00
for (size_t ch = 0; ch < channels; ch++) {
float *out = audio_output->output[mix].data[ch];
float *in = child_audio.output[mix].data[ch];
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
if (apply_buf)
mix_audio_with_buf(out, in, buf, pos,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
count);
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
else
mix_audio(out, in, pos, count);
libobs: Make scenes mix audio of sub-sources Mark scenes as composite sources and use audio_render to mix and output the audio of their sub-sources.
2015-12-17 07:31:05 -08:00
}
}
item = item->next;
}
*ts_out = timestamp;
audio_unlock(scene);
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
libobs: Make scenes mix audio of sub-sources Mark scenes as composite sources and use audio_render to mix and output the audio of their sub-sources.
2015-12-17 07:31:05 -08:00
return true;
}
libobs: Replace OBS_UNUSED with UNUSED_PARAMETER OBS_UNUSED is not portable to MSVC.
2022-07-19 10:28:49 -07:00
enum gs_color_space
scene_video_get_color_space(void *data, size_t count,
const enum gs_color_space *preferred_spaces)
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
{
libobs: Replace OBS_UNUSED with UNUSED_PARAMETER OBS_UNUSED is not portable to MSVC.
2022-07-19 10:28:49 -07:00
UNUSED_PARAMETER(data);
UNUSED_PARAMETER(count);
UNUSED_PARAMETER(preferred_spaces);
libobs: Lock scene to video color space Fixes studio mode preview on SDR monitor for HDR canvas rendering SDR source into SDR swap chain. Needs to render SDR source into HDR render target, and then tonemap into SDR swap chain for preview.
2022-05-13 19:27:33 -07:00
enum gs_color_space space = GS_CS_SRGB;
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
struct obs_video_info ovi;
if (obs_get_video_info(&ovi)) {
switch (ovi.colorspace) {
libobs: Rename Rec. 2020 to Rec. 2100 Rec. 2020 is really an SDR spec, but I think HDR10 made it okay to slap PQ on it, call it an HDR spec. Rec. 2100 came along after and formally allowed the use of PQ/HLG, so we should use 2100 instead.
2022-04-09 20:54:28 -07:00
case VIDEO_CS_2100_PQ:
case VIDEO_CS_2100_HLG:
libobs: Lock scene to video color space Fixes studio mode preview on SDR monitor for HDR canvas rendering SDR source into SDR swap chain. Needs to render SDR source into HDR render target, and then tonemap into SDR swap chain for preview.
2022-05-13 19:27:33 -07:00
space = GS_CS_709_EXTENDED;
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
}
}
return space;
}
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
const struct obs_source_info scene_info = {
.id = "scene",
.type = OBS_SOURCE_TYPE_SCENE,
.output_flags = OBS_SOURCE_VIDEO | OBS_SOURCE_CUSTOM_DRAW |
libobs, obs-filters: SRGB backwards compatibility Add OBS_SOURCE_SRGB to indicate sources that support SRGB rendering. We can use this flag to know which sources do not know how to handle SRGB, and disable accordingly inside obs_source_main_render(). We can also use this flag to clean up the filter interface and remove the SRGB-specific functions. We also need to disable direct rendering if the filter source wants to render SRGB, but the parent source does not support it. Scenes and groups are marked as having SRGB support, and those are internal sources that we control.
2021-05-02 22:36:37 -07:00
OBS_SOURCE_COMPOSITE | OBS_SOURCE_DO_NOT_DUPLICATE |
OBS_SOURCE_SRGB,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
.get_name = scene_getname,
.create = scene_create,
.destroy = scene_destroy,
.video_tick = scene_video_tick,
.video_render = scene_video_render,
.audio_render = scene_audio_render,
.get_width = scene_getwidth,
.get_height = scene_getheight,
.load = scene_load,
.save = scene_save,
libobs: Add callback for enumerating all scene children Prevents infinite recursion when adding children to a scene.
2017-01-16 09:55:15 -08:00
.enum_active_sources = scene_enum_active_sources,
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
.enum_all_sources = scene_enum_all_sources,
.video_get_color_space = scene_video_get_color_space,
};
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
const struct obs_source_info group_info = {
.id = "group",
.type = OBS_SOURCE_TYPE_SCENE,
.output_flags = OBS_SOURCE_VIDEO | OBS_SOURCE_CUSTOM_DRAW |
libobs, obs-filters: SRGB backwards compatibility Add OBS_SOURCE_SRGB to indicate sources that support SRGB rendering. We can use this flag to know which sources do not know how to handle SRGB, and disable accordingly inside obs_source_main_render(). We can also use this flag to clean up the filter interface and remove the SRGB-specific functions. We also need to disable direct rendering if the filter source wants to render SRGB, but the parent source does not support it. Scenes and groups are marked as having SRGB support, and those are internal sources that we control.
2021-05-02 22:36:37 -07:00
OBS_SOURCE_COMPOSITE | OBS_SOURCE_SRGB,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
.get_name = group_getname,
.create = scene_create,
.destroy = scene_destroy,
.video_tick = scene_video_tick,
.video_render = scene_video_render,
.audio_render = scene_audio_render,
.get_width = scene_getwidth,
.get_height = scene_getheight,
.load = scene_load,
.save = scene_save,
libobs: Change groups to actual public types (This commit also modifies UI) Changes groups to their own independent type, "group". This allows them to be used like other regular types, and allows the ability to reference groups in multiple scenes. Before, a group would always be linked to the scene it was in. This made it cumbersome for users to modify groups if they had a similar group in multiple scenes (they would have to modify each group in each scene). Making groups like other source types makes more sense to solve this issue so they can be referenced in multiple scenes at once. This also removes a significant amount of group-specific handling code required for implementing groups in the front-end. One limitation however: due to the way sub-items of groups are seamlessly modifiable and sortable as part of the whole scene, the user cannot have multiple references to the same group within one scene.
2018-07-15 18:50:33 -07:00
.enum_active_sources = scene_enum_active_sources,
libobs: Add color space management This provides the framework for automatically compositing SDR and HDR sources together. Source will need to leverage the new video_get_color_space to opt into HDR support.
2022-03-16 01:41:00 -07:00
.enum_all_sources = scene_enum_all_sources,
.video_get_color_space = scene_video_get_color_space,
};
libobs: Change groups to actual public types (This commit also modifies UI) Changes groups to their own independent type, "group". This allows them to be used like other regular types, and allows the ability to reference groups in multiple scenes. Before, a group would always be linked to the scene it was in. This made it cumbersome for users to modify groups if they had a similar group in multiple scenes (they would have to modify each group in each scene). Making groups like other source types makes more sense to solve this issue so they can be referenced in multiple scenes at once. This also removes a significant amount of group-specific handling code required for implementing groups in the front-end. One limitation however: due to the way sub-items of groups are seamlessly modifiable and sortable as part of the whole scene, the user cannot have multiple references to the same group within one scene.
2018-07-15 18:50:33 -07:00
libobs: Refactor creation of scenes Allows using a different source type (I.E. "group" instead of "scene").
2018-07-15 18:39:08 -07:00
static inline obs_scene_t *create_id(const char *id, const char *name)
first commit
2013-09-30 19:37:13 -07:00
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct obs_source *source = obs_source_create(id, name, NULL, NULL);
Add preliminary saving/loading of scene/sources This saves scenes/sources from json on exit, and properly loads it back up when starting up the program again, as well as the currently active scene. I had to add a 'load' and 'save' callback to the source interface structure because I realizes that certain sources (such as scenes) operate different with their saved data; scenes for example would have to keep track of their settings information constantly, and that was somewhat unacceptable to make it functional. The optional 'load' callback will be called only after having loaded setttings specifically from file/imported data, and the 'save' function will be called only specifically when data actually needs to be saved. I also had to adjust the obs_scene code so that it's a regular input source type now, and I also modified it so that it doesn't have some strange custom creation code anymore. The obs_scene_create function is now simply just a wrapper for obs_source_create. You could even create a scene with obs_source_create manually as well.
2014-04-26 23:47:50 -07:00
return source->context.data;
first commit
2013-09-30 19:37:13 -07:00
}
libobs: Refactor creation of scenes Allows using a different source type (I.E. "group" instead of "scene").
2018-07-15 18:39:08 -07:00
static inline obs_scene_t *create_private_id(const char *id, const char *name)
libobs: Add obs_scene_create_private function Creates a scene marked as a private source
2016-01-12 16:56:16 -08:00
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct obs_source *source = obs_source_create_private(id, name, NULL);
libobs: Add obs_scene_create_private function Creates a scene marked as a private source
2016-01-12 16:56:16 -08:00
return source->context.data;
}
libobs: Refactor creation of scenes Allows using a different source type (I.E. "group" instead of "scene").
2018-07-15 18:39:08 -07:00
obs_scene_t *obs_scene_create(const char *name)
{
return create_id("scene", name);
}
obs_scene_t *obs_scene_create_private(const char *name)
{
return create_private_id("scene", name);
}
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
static obs_source_t *get_child_at_idx(obs_scene_t *scene, size_t idx)
libobs: Add function to duplicate scenes
2015-08-28 15:01:15 -07:00
{
struct obs_scene_item *item = scene->first_item;
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
while (item && idx--)
item = item->next;
return item ? item->source : NULL;
}
static inline obs_source_t *dup_child(struct darray *array, size_t idx,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_scene_t *new_scene, bool private)
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
DARRAY(struct obs_scene_item *) old_items;
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
obs_source_t *source;
old_items.da = *array;
source = old_items.array[idx]->source;
/* if the old item is referenced more than once in the old scene,
* make sure they're referenced similarly in the new scene to reduce
* load times */
for (size_t i = 0; i < idx; i++) {
struct obs_scene_item *item = old_items.array[i];
if (item->source == source) {
source = get_child_at_idx(new_scene, i);
libobs: Replace addref calls with get_ref
2022-01-24 13:47:56 -08:00
return obs_source_get_ref(source);
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
}
}
libobs: Duplicate source name for private sources Allows for identification of sources in studio mode
2020-12-02 23:57:31 -08:00
return obs_source_duplicate(
source, private ? obs_source_get_name(source) : NULL, private);
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
}
static inline obs_source_t *new_ref(obs_source_t *source)
{
libobs: Replace addref calls with get_ref
2022-01-24 13:47:56 -08:00
return obs_source_get_ref(source);
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
}
libobs: Add internal function to dup. scene item data Adds an internal function to duplicate scene item data.
2018-08-05 04:10:06 -07:00
static inline void duplicate_item_data(struct obs_scene_item *dst,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct obs_scene_item *src,
bool defer_texture_update,
bool duplicate_hotkeys,
bool duplicate_private_data)
libobs: Add internal function to dup. scene item data Adds an internal function to duplicate scene item data.
2018-08-05 04:10:06 -07:00
{
struct obs_scene *dst_scene = dst->parent;
if (!src->user_visible)
set_visibility(dst, false);
dst->selected = src->selected;
dst->pos = src->pos;
dst->rot = src->rot;
dst->scale = src->scale;
dst->align = src->align;
dst->last_width = src->last_width;
dst->last_height = src->last_height;
dst->output_scale = src->output_scale;
dst->scale_filter = src->scale_filter;
libobs: Implement additional source blending modes
2021-10-24 08:45:15 -07:00
dst->blend_type = src->blend_type;
libobs: Add internal function to dup. scene item data Adds an internal function to duplicate scene item data.
2018-08-05 04:10:06 -07:00
dst->box_transform = src->box_transform;
libobs: UI: Fix rotated line scale The line drawing functions previously assumed the upper-left 3x3 for box_transform only held scale. The matrix can also hold rotation, so pass in scale separately. Fixes https://obsproject.com/mantis/view.php?id=1442
2019-04-19 06:35:42 -07:00
dst->box_scale = src->box_scale;
libobs: Add internal function to dup. scene item data Adds an internal function to duplicate scene item data.
2018-08-05 04:10:06 -07:00
dst->draw_transform = src->draw_transform;
dst->bounds_type = src->bounds_type;
dst->bounds_align = src->bounds_align;
dst->bounds = src->bounds;
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
if (src->show_transition) {
obs_source_t *transition = obs_source_duplicate(
src->show_transition,
obs_source_get_name(src->show_transition), true);
libobs: Refactor hide/show transition functions Having two separate functions for each hide/show transition action is silly and makes code awful.
2022-03-24 22:32:41 -07:00
obs_sceneitem_set_transition(dst, true, transition);
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
obs_source_release(transition);
}
if (src->hide_transition) {
obs_source_t *transition = obs_source_duplicate(
src->hide_transition,
obs_source_get_name(src->hide_transition), true);
libobs: Refactor hide/show transition functions Having two separate functions for each hide/show transition action is silly and makes code awful.
2022-03-24 22:32:41 -07:00
obs_sceneitem_set_transition(dst, false, transition);
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
obs_source_release(transition);
}
dst->show_transition_duration = src->show_transition_duration;
dst->hide_transition_duration = src->hide_transition_duration;
libobs: Add internal function to dup. scene item data Adds an internal function to duplicate scene item data.
2018-08-05 04:10:06 -07:00
if (duplicate_hotkeys && !dst_scene->source->context.private) {
obs_data_array_t *data0 = NULL;
obs_data_array_t *data1 = NULL;
obs_hotkey_pair_save(src->toggle_visibility, &data0, &data1);
obs_hotkey_pair_load(dst->toggle_visibility, data0, data1);
obs_data_array_release(data0);
obs_data_array_release(data1);
}
obs_sceneitem_set_crop(dst, &src->crop);
libobs: Set lock state when duplicating scene item Fixes bug where the lock state wouldn't be copied when duplicating a scene.
2020-12-31 08:20:12 -08:00
obs_sceneitem_set_locked(dst, src->locked);
libobs: Add internal function to dup. scene item data Adds an internal function to duplicate scene item data.
2018-08-05 04:10:06 -07:00
if (defer_texture_update) {
os_atomic_set_bool(&dst->update_transform, true);
}
if (duplicate_private_data) {
obs_data_apply(dst->private_settings, src->private_settings);
}
}
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
obs_scene_t *obs_scene_duplicate(obs_scene_t *scene, const char *name,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
enum obs_scene_duplicate_type type)
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
bool make_unique = ((int)type & (1 << 0)) != 0;
bool make_private = ((int)type & (1 << 1)) != 0;
DARRAY(struct obs_scene_item *) items;
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
struct obs_scene *new_scene;
struct obs_scene_item *item;
struct obs_source *source;
da_init(items);
if (!obs_ptr_valid(scene, "obs_scene_duplicate"))
return NULL;
/* --------------------------------- */
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_lock(scene);
libobs: Add function to duplicate scenes
2015-08-28 15:01:15 -07:00
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
item = scene->first_item;
libobs: Add function to duplicate scenes
2015-08-28 15:01:15 -07:00
while (item) {
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
da_push_back(items, &item);
obs_sceneitem_addref(item);
item = item->next;
}
full_unlock(scene);
/* --------------------------------- */
libobs: Refactor creation of scenes Allows using a different source type (I.E. "group" instead of "scene").
2018-07-15 18:39:08 -07:00
new_scene = make_private
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
? create_private_id(scene->source->info.id, name)
: create_id(scene->source->info.id, name);
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
libobs: Fix scene filter duplication Scene filters were not being copied when a scene was duplicated with obs_scene_duplicate. Closes jp9000/obs-studio#1104
2017-12-04 12:03:08 -08:00
obs_source_copy_filters(new_scene->source, scene->source);
libobs: Duplicate private scene/source settings Ensures that private settings data is also duplicated when a scene or a source is duplicated.
2017-11-30 05:04:39 -08:00
obs_data_apply(new_scene->source->private_settings,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
scene->source->private_settings);
libobs: Duplicate private scene/source settings Ensures that private settings data is also duplicated when a scene or a source is duplicated.
2017-11-30 05:04:39 -08:00
libobs: Allow group duplication
2018-07-15 18:58:28 -07:00
/* never duplicate sub-items for groups */
if (scene->is_group)
make_unique = false;
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
for (size_t i = 0; i < items.num; i++) {
item = items.array[i];
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
source = make_unique ? dup_child(&items.da, i, new_scene,
make_private)
: new_ref(item->source);
libobs: Add function to duplicate scenes
2015-08-28 15:01:15 -07:00
if (source) {
struct obs_scene_item *new_item =
obs_scene_add(new_scene, source);
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
if (!new_item) {
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
obs_source_release(source);
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
continue;
}
libobs: Add internal function to dup. scene item data Adds an internal function to duplicate scene item data.
2018-08-05 04:10:06 -07:00
duplicate_item_data(new_item, item, false, false,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
false);
libobs: Fix item copying during scene duplication When item in the old scene had only Scale Filter, texture renderer was not created for an item in the new scene. However if the item also had Crop set, the texture renderer was created. Now after copying the data, texture renderer is created for the item in the new scene when needed. Closes jp9000/obs-studio#969
2017-07-18 15:37:27 -07:00
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
obs_source_release(source);
}
libobs: Add function to duplicate scenes
2015-08-28 15:01:15 -07:00
}
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
for (size_t i = 0; i < items.num; i++)
obs_sceneitem_release(items.array[i]);
libobs: Add function to duplicate scenes
2015-08-28 15:01:15 -07:00
libobs: Allow group duplication
2018-07-15 18:58:28 -07:00
if (new_scene->is_group)
resize_scene(new_scene);
(API Change) libobs: Add 'type' to obs_scene_duplicate (Note: This commit also modifies the UI) Allows the ability to duplicate sources fully copied, and/or have the scene and its duplicates be private sources
2016-01-12 17:04:01 -08:00
da_free(items);
libobs: Add function to duplicate scenes
2015-08-28 15:01:15 -07:00
return new_scene;
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
void obs_scene_addref(obs_scene_t *scene)
update API and implement preliminary ability to add sources to scenes
2013-12-30 05:56:39 -08:00
{
Remove external ref count visibility The returned ref count was never used and the returned value doesn't actually confer any meaning in a multithreaded environment
2014-02-02 17:34:06 -08:00
if (scene)
obs_source_addref(scene->source);
update API and implement preliminary ability to add sources to scenes
2013-12-30 05:56:39 -08:00
}
libobs: Add obs_scene_get_ref()
2022-01-24 13:02:39 -08:00
obs_scene_t *obs_scene_get_ref(obs_scene_t *scene)
{
if (!scene)
return NULL;
if (obs_source_get_ref(scene->source) != NULL)
return scene;
return NULL;
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
void obs_scene_release(obs_scene_t *scene)
first commit
2013-09-30 19:37:13 -07:00
{
Remove external ref count visibility The returned ref count was never used and the returned value doesn't actually confer any meaning in a multithreaded environment
2014-02-02 17:34:06 -08:00
if (scene)
obs_source_release(scene->source);
first commit
2013-09-30 19:37:13 -07:00
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 15:25:59 -07:00
obs_source_t *obs_scene_get_source(const obs_scene_t *scene)
first commit
2013-09-30 19:37:13 -07:00
{
Improve thread safety in UI code - Implemented better C++ classes for handling scenes/sources/items in obs.hpp, allowing them to automatically increment and decrement the references of each, as well as assign them to QVariants. - Because QVariants are now using the C++ classes, remove the pointer QVariant wrapper. - Use the new C++ classes with the QVariant user data of list box items, both for the sake of thread safety and to ensure that the data referenced is not freed until removed. NOTE: still might need some testing. - Implemented a source-remove signal from libobs, and start using that signal instead of the source-destroy signal for signalling item removal.
2014-02-02 13:26:23 -08:00
return scene ? scene->source : NULL;
first commit
2013-09-30 19:37:13 -07:00
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 15:25:59 -07:00
obs_scene_t *obs_scene_from_source(const obs_source_t *source)
implement scene adding callbacks, make a few API tweaks
2013-12-28 04:33:16 -08:00
{
libobs: Compare scene/group ids by strcmp
2020-03-09 05:57:01 -07:00
if (!source || strcmp(source->info.id, scene_info.id) != 0)
implement scene adding callbacks, make a few API tweaks
2013-12-28 04:33:16 -08:00
return NULL;
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
return source->context.data;
implement scene adding callbacks, make a few API tweaks
2013-12-28 04:33:16 -08:00
}
libobs: Allow group duplication
2018-07-15 18:58:28 -07:00
obs_scene_t *obs_group_from_source(const obs_source_t *source)
{
libobs: Compare scene/group ids by strcmp
2020-03-09 05:57:01 -07:00
if (!source || strcmp(source->info.id, group_info.id) != 0)
libobs: Allow group duplication
2018-07-15 18:58:28 -07:00
return NULL;
return source->context.data;
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
obs_sceneitem_t *obs_scene_find_source(obs_scene_t *scene, const char *name)
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
{
struct obs_scene_item *item;
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (!scene)
return NULL;
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_lock(scene);
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
item = scene->first_item;
while (item) {
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
if (strcmp(item->source->context.name, name) == 0)
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
break;
item = item->next;
}
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_unlock(scene);
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
return item;
}
libobs: Add obs_scene_find_source_recursive Same as obs_scene_find_source but also searches groups within the scene.
2020-01-27 14:36:53 -08:00
obs_sceneitem_t *obs_scene_find_source_recursive(obs_scene_t *scene,
const char *name)
{
struct obs_scene_item *item;
if (!scene)
return NULL;
full_lock(scene);
item = scene->first_item;
while (item) {
if (strcmp(item->source->context.name, name) == 0)
break;
if (item->is_group) {
obs_scene_t *group = item->source->context.data;
obs_sceneitem_t *child =
obs_scene_find_source(group, name);
if (child) {
item = child;
break;
}
}
item = item->next;
}
full_unlock(scene);
return item;
}
UI/libobs: Undo/Redo Sources and Scenes Implements the Undo/Redo for scenes and sources, ranging from renaming, deletion, addition. It also adds several elements to libobs that were designed to facilitate undo/redo, and should not affect the rest of libobs.
2021-03-21 21:39:02 -07:00
struct sceneitem_check {
obs_source_t *source_in;
obs_sceneitem_t *item_out;
};
bool check_sceneitem_exists(obs_scene_t *scene, obs_sceneitem_t *item,
void *vp_check)
{
UNUSED_PARAMETER(scene);
struct sceneitem_check *check = (struct sceneitem_check *)vp_check;
if (obs_sceneitem_get_source(item) == check->source_in) {
check->item_out = item;
obs_sceneitem_addref(item);
return false;
}
return true;
}
obs_sceneitem_t *obs_scene_sceneitem_from_source(obs_scene_t *scene,
obs_source_t *source)
{
struct sceneitem_check check = {source, NULL};
obs_scene_enum_items(scene, check_sceneitem_exists, (void *)&check);
return check.item_out;
}
libobs: Add scene item IDs Adds a method of uniquely identifying scene items, as well as finding those scene items via that unique ID.
2017-05-15 00:13:28 -07:00
obs_sceneitem_t *obs_scene_find_sceneitem_by_id(obs_scene_t *scene, int64_t id)
{
struct obs_scene_item *item;
if (!scene)
return NULL;
full_lock(scene);
item = scene->first_item;
while (item) {
if (item->id == id)
break;
item = item->next;
}
full_unlock(scene);
return item;
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
void obs_scene_enum_items(obs_scene_t *scene,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
bool (*callback)(obs_scene_t *, obs_sceneitem_t *,
void *),
void *param)
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
{
struct obs_scene_item *item;
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (!scene || !callback)
return;
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_lock(scene);
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
item = scene->first_item;
while (item) {
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
struct obs_scene_item *next = item->next;
obs_sceneitem_addref(item);
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
if (!callback(scene, item, param)) {
obs_sceneitem_release(item);
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
break;
Simplify and extend callback/signalling system - Signals and dynamic callbacks now require declarations to be made before being used. What this does is allows us to get information about the functions dynamically which can be relayed to the user and plugins for future extended usage (this should have big implications later for scripting in particular, hopefully). - Reduced the number of types calldata uses from "everything I could think of" to simply integer, float, bool, pointer/object, string. Integer data is now stored as long long. Floats are now stored as doubles (check em). - Use a more consistent naming scheme for lexer error/warning macros. - Fixed a rather nasty bug where switching to an existing scene would cause it to increment sourceSceneRefs, which would mean that it would never end up never properly removing the source when the user clicks removed (stayed in limbo, obs_source_remove never got called)
2014-03-01 04:54:55 -08:00
}
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
obs_sceneitem_release(item);
item = next;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
}
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_unlock(scene);
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
}
libobs: Add scene item hotkeys
2015-05-08 18:33:55 -07:00
static obs_sceneitem_t *sceneitem_get_ref(obs_sceneitem_t *si)
{
libobs: Update compare-exchange pattern Use function that updates previous value automatically. Also load initial value seq_cst to be safe.
2021-02-02 22:41:20 -08:00
long owners = os_atomic_load_long(&si->ref);
libobs: Add scene item hotkeys
2015-05-08 18:33:55 -07:00
while (owners > 0) {
libobs: Update compare-exchange pattern Use function that updates previous value automatically. Also load initial value seq_cst to be safe.
2021-02-02 22:41:20 -08:00
if (os_atomic_compare_exchange_long(&si->ref, &owners,
owners + 1)) {
libobs: Add scene item hotkeys
2015-05-08 18:33:55 -07:00
return si;
libobs: Update compare-exchange pattern Use function that updates previous value automatically. Also load initial value seq_cst to be safe.
2021-02-02 22:41:20 -08:00
}
libobs: Add scene item hotkeys
2015-05-08 18:33:55 -07:00
}
return NULL;
}
static bool hotkey_show_sceneitem(void *data, obs_hotkey_pair_id id,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_hotkey_t *hotkey, bool pressed)
libobs: Add scene item hotkeys
2015-05-08 18:33:55 -07:00
{
UNUSED_PARAMETER(id);
UNUSED_PARAMETER(hotkey);
obs_sceneitem_t *si = sceneitem_get_ref(data);
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
if (pressed && si && !si->user_visible) {
libobs: Add scene item hotkeys
2015-05-08 18:33:55 -07:00
obs_sceneitem_set_visible(si, true);
obs_sceneitem_release(si);
return true;
}
obs_sceneitem_release(si);
return false;
}
static bool hotkey_hide_sceneitem(void *data, obs_hotkey_pair_id id,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_hotkey_t *hotkey, bool pressed)
libobs: Add scene item hotkeys
2015-05-08 18:33:55 -07:00
{
UNUSED_PARAMETER(id);
UNUSED_PARAMETER(hotkey);
obs_sceneitem_t *si = sceneitem_get_ref(data);
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
if (pressed && si && si->user_visible) {
libobs: Add scene item hotkeys
2015-05-08 18:33:55 -07:00
obs_sceneitem_set_visible(si, false);
obs_sceneitem_release(si);
return true;
}
obs_sceneitem_release(si);
return false;
}
static void init_hotkeys(obs_scene_t *scene, obs_sceneitem_t *item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
const char *name)
libobs: Add scene item hotkeys
2015-05-08 18:33:55 -07:00
{
struct dstr show = {0};
struct dstr hide = {0};
struct dstr show_desc = {0};
struct dstr hide_desc = {0};
dstr_copy(&show, "libobs.show_scene_item.%1");
dstr_replace(&show, "%1", name);
dstr_copy(&hide, "libobs.hide_scene_item.%1");
dstr_replace(&hide, "%1", name);
dstr_copy(&show_desc, obs->hotkeys.sceneitem_show);
dstr_replace(&show_desc, "%1", name);
dstr_copy(&hide_desc, obs->hotkeys.sceneitem_hide);
dstr_replace(&hide_desc, "%1", name);
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
item->toggle_visibility = obs_hotkey_pair_register_source(
scene->source, show.array, show_desc.array, hide.array,
hide_desc.array, hotkey_show_sceneitem, hotkey_hide_sceneitem,
item, item);
libobs: Add scene item hotkeys
2015-05-08 18:33:55 -07:00
dstr_free(&show);
dstr_free(&hide);
dstr_free(&show_desc);
dstr_free(&hide_desc);
}
libobs: Update hotkey label on scene item rename
2018-05-28 18:21:50 -07:00
static void sceneitem_rename_hotkey(const obs_sceneitem_t *scene_item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
const char *new_name)
libobs: Update hotkey label on scene item rename
2018-05-28 18:21:50 -07:00
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct dstr show = {0};
struct dstr hide = {0};
struct dstr show_desc = {0};
struct dstr hide_desc = {0};
libobs: Update hotkey label on scene item rename
2018-05-28 18:21:50 -07:00
dstr_copy(&show, "libobs.show_scene_item.%1");
dstr_replace(&show, "%1", new_name);
dstr_copy(&hide, "libobs.hide_scene_item.%1");
dstr_replace(&hide, "%1", new_name);
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_hotkey_pair_set_names(scene_item->toggle_visibility, show.array,
hide.array);
libobs: Update hotkey label on scene item rename
2018-05-28 18:21:50 -07:00
dstr_copy(&show_desc, obs->hotkeys.sceneitem_show);
dstr_replace(&show_desc, "%1", new_name);
dstr_copy(&hide_desc, obs->hotkeys.sceneitem_hide);
dstr_replace(&hide_desc, "%1", new_name);
obs_hotkey_pair_set_descriptions(scene_item->toggle_visibility,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
show_desc.array, hide_desc.array);
libobs: Update hotkey label on scene item rename
2018-05-28 18:21:50 -07:00
dstr_free(&show);
dstr_free(&hide);
dstr_free(&show_desc);
dstr_free(&hide_desc);
}
static void sceneitem_renamed(void *param, calldata_t *data)
{
obs_sceneitem_t *scene_item = param;
const char *name = calldata_string(data, "new_name");
sceneitem_rename_hotkey(scene_item, name);
}
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
static inline bool source_has_audio(obs_source_t *source)
{
return (source->info.output_flags &
(OBS_SOURCE_AUDIO | OBS_SOURCE_COMPOSITE)) != 0;
}
libobs: Refactor obs_scene_add to allow adding internally Allows using obs_scene_add_internal to add without sending signals.
2018-03-07 16:27:43 -08:00
static obs_sceneitem_t *obs_scene_add_internal(obs_scene_t *scene,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_source_t *source,
libobs: Remove unused parameters
2022-07-19 23:07:04 -07:00
obs_sceneitem_t *insert_after)
first commit
2013-09-30 19:37:13 -07:00
{
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
struct obs_scene_item *last;
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
struct obs_scene_item *item;
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
pthread_mutex_t mutex;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct item_action action = {.visible = true,
.timestamp = os_gettime_ns()};
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
if (!scene)
return NULL;
libobs: Replace addref calls with get_ref
2022-01-24 13:47:56 -08:00
source = obs_source_get_ref(source);
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
if (!source) {
Be more consistent about log levels LOG_ERROR should be used in places where though recoverable (or at least something that can be handled safely), was unexpected, and may affect the user/application. LOG_WARNING should be used in places where it's not entirely unexpected, is recoverable, and doesn't really affect the user/application.
2014-02-28 19:02:29 -08:00
blog(LOG_ERROR, "Tried to add a NULL source to a scene");
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
return NULL;
}
libobs: Block sceneitem create if item source is removed There are some cases where an item may attempt to be created for a removed source. Previously, items created from removed sources would lead to the item itself being saved, but the underlying source not being saved. While this does not break OBS immediately, it means that the source along with all associated items will disappear on OBS reload. This prevents the item from being created in the first place, reducing the chances of user work being lost.
2021-09-13 00:42:21 -07:00
if (source->removed) {
blog(LOG_WARNING, "Tried to add a removed source to a scene");
libobs: Replace addref calls with get_ref
2022-01-24 13:47:56 -08:00
goto release_source_and_fail;
libobs: Block sceneitem create if item source is removed There are some cases where an item may attempt to be created for a removed source. Previously, items created from removed sources would lead to the item itself being saved, but the underlying source not being saved. While this does not break OBS immediately, it means that the source along with all associated items will disappear on OBS reload. This prevents the item from being created in the first place, reducing the chances of user work being lost.
2021-09-13 00:42:21 -07:00
}
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
if (pthread_mutex_init(&mutex, NULL) != 0) {
blog(LOG_WARNING, "Failed to create scene item mutex");
libobs: Replace addref calls with get_ref
2022-01-24 13:47:56 -08:00
goto release_source_and_fail;
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
}
(API Change) libobs: Rename funcs relating to active child sources Renames: ---------------------------------------- obs_source_add_child obs_source_remove_child obs_source_enum_sources obs_source_enum_tree obs_source_info::enum_sources To: ---------------------------------------- obs_source_add_active_child obs_source_remove_active_child obs_source_enum_active_sources obs_source_enum_active_tree obs_source_info::enum_active_sources These functions/callbacks had misleading names: they originally implied any child sources, when they actually meant active child sources that are being used to render video or audio. It's important that the function names represent their actual purpose.
2015-12-22 04:59:02 -08:00
if (!obs_source_add_active_child(scene->source, source)) {
libobs: Prevent infinite source recursion Changed the design from using obs_source::enum_refs to just simply preventing infinite source recursion in general, rather than allowing it through the enum_refs variable. obs_source_add_child has been changed so that it now returns a boolean, and if the function fails, it means that the child cannot be added due to that potential recursion.
2014-12-27 20:21:22 -08:00
blog(LOG_WARNING, "Failed to add source to scene due to "
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
"infinite source recursion");
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
pthread_mutex_destroy(&mutex);
libobs: Replace addref calls with get_ref
2022-01-24 13:47:56 -08:00
goto release_source_and_fail;
libobs: Prevent infinite source recursion Changed the design from using obs_source::enum_refs to just simply preventing infinite source recursion in general, rather than allowing it through the enum_refs variable. obs_source_add_child has been changed so that it now returns a boolean, and if the function fails, it means that the child cannot be added due to that potential recursion.
2014-12-27 20:21:22 -08:00
}
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
item = bzalloc(sizeof(struct obs_scene_item));
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
item->source = source;
item->id = ++scene->id_counter;
item->parent = scene;
item->ref = 1;
item->align = OBS_ALIGN_TOP | OBS_ALIGN_LEFT;
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
item->actions_mutex = mutex;
item->user_visible = true;
UI, libobs: Add ability to lock individual scene items Adds a lock checkbox to allow the user to lock a specific scene item. Closes jp9000/obs-studio#949
2017-06-17 17:10:42 -07:00
item->locked = false;
libobs: Fix groups not being recognized as groups The id of the source was being pointer compared rather than string compared, so naturally with the source versioning system where the string is duplicated, the pointers no longer matched.
2020-03-09 17:08:51 -07:00
item->is_group = strcmp(source->info.id, group_info.id) == 0;
libobs: Add private settings to scene items/sources Allows setting and sharing of user data for sources and scene items.
2017-09-13 03:12:56 -07:00
item->private_settings = obs_data_create();
libobs: Initialize hotkey pair ID variable properly The value of 0 can represent a valid hotkey ID, so make sure that when we initialize a hotkey variable, that we use OBS_INVALID_HOTKEY_ID or OBS_INVALID_HOTKEY_PAIR_ID and not 0. This fixes a bug where scene item hotkey pair IDs would be initialized to 0, and it would unregister valid unrelated hotkeys. Particularly, the start/stop streaming hotkey pair ID, which would commonly be the first hotkey pair created, thus having the hotkey pair ID of 0. The start/streaming hotkey pair would unintentionally be unregistered via code in obs-scene.c.
2018-08-14 13:06:05 -07:00
item->toggle_visibility = OBS_INVALID_HOTKEY_PAIR_ID;
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
os_atomic_set_long(&item->active_refs, 1);
first commit
2013-09-30 19:37:13 -07:00
vec2_set(&item->scale, 1.0f, 1.0f);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
matrix4_identity(&item->draw_transform);
matrix4_identity(&item->box_transform);
first commit
2013-09-30 19:37:13 -07:00
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
if (source_has_audio(source)) {
item->visible = false;
da_push_back(item->audio_actions, &action);
} else {
item->visible = true;
}
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_lock(scene);
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
libobs: Refactor obs_scene_add to allow adding internally Allows using obs_scene_add_internal to add without sending signals.
2018-03-07 16:27:43 -08:00
if (insert_after) {
obs_sceneitem_t *next = insert_after->next;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
if (next)
next->prev = item;
libobs: Refactor obs_scene_add to allow adding internally Allows using obs_scene_add_internal to add without sending signals.
2018-03-07 16:27:43 -08:00
item->next = insert_after->next;
item->prev = insert_after;
insert_after->next = item;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
} else {
libobs: Refactor obs_scene_add to allow adding internally Allows using obs_scene_add_internal to add without sending signals.
2018-03-07 16:27:43 -08:00
last = scene->first_item;
if (!last) {
scene->first_item = item;
} else {
while (last->next)
last = last->next;
last->next = item;
item->prev = last;
}
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
}
Added add/remove signals to scenes Scenes will now signal via their source when an item has been added or removed from them. "add" - Item added to the scene. Parameters: "scene": Scene that the item was added to. "item": Item that was added. "remove" - Item removed from the scene. Parameters: "scene": Scene that the item was removed from. "item": Item that was removed.
2014-01-04 12:38:56 -08:00
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_unlock(scene);
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
libobs: Add obs_scene_create_private function Creates a scene marked as a private source
2016-01-12 16:56:16 -08:00
if (!scene->source->context.private)
init_hotkeys(scene, item, obs_source_get_name(source));
libobs: Add scene item hotkeys
2015-05-08 18:33:55 -07:00
libobs: Update hotkey label on scene item rename
2018-05-28 18:21:50 -07:00
signal_handler_connect(obs_source_get_signal_handler(source), "rename",
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
sceneitem_renamed, item);
libobs: Update hotkey label on scene item rename
2018-05-28 18:21:50 -07:00
libobs: Refactor obs_scene_add to allow adding internally Allows using obs_scene_add_internal to add without sending signals.
2018-03-07 16:27:43 -08:00
return item;
libobs: Replace addref calls with get_ref
2022-01-24 13:47:56 -08:00
release_source_and_fail:
obs_source_release(source);
return NULL;
libobs: Refactor obs_scene_add to allow adding internally Allows using obs_scene_add_internal to add without sending signals.
2018-03-07 16:27:43 -08:00
}
obs_sceneitem_t *obs_scene_add(obs_scene_t *scene, obs_source_t *source)
{
libobs: Remove unused parameters
2022-07-19 23:07:04 -07:00
obs_sceneitem_t *item = obs_scene_add_internal(scene, source, NULL);
libobs: Refactor obs_scene_add to allow adding internally Allows using obs_scene_add_internal to add without sending signals.
2018-03-07 16:27:43 -08:00
struct calldata params;
uint8_t stack[128];
libobs: Check return value from obs_scene_add_internal Errors in obs_scene_add_internal would cause a crash as the null item is passed to various signal handlers.
2020-03-11 16:02:46 -07:00
if (!item)
return NULL;
libobs: Use calldata with stack for simple signals Makes signals use stack memory rather than allocate memory each time. Most likely a completely insignificant and pointless optimization.
2016-01-18 20:01:58 -08:00
calldata_init_fixed(&params, stack, sizeof(stack));
(API Change) libobs/callback: Unsquish names Renamed: To: ------------------------------------------------- calldata_getdata calldata_get_data calldata_getint calldata_get_int calldata_getfloat calldata_get_float calldata_getbool calldata_get_bool calldata_getptr calldata_get_ptr calldata_getstring calldata_get_string calldata_setdata calldata_set_data calldata_setint calldata_set_int calldata_setfloat calldata_set_float calldata_setbool calldata_set_bool calldata_setptr calldata_set_ptr calldata_setstring calldata_set_string
2014-08-05 17:49:28 -07:00
calldata_set_ptr(&params, "scene", scene);
calldata_set_ptr(&params, "item", item);
libobs: Add services API, reduce repeated code Add API for streaming services. The services API simplifies the creation of custom service features and user interface. Custom streaming services later on will be able to do things such as: - Be able to use service-specific APIs via modules, allowing a more direct means of communicating with the service and requesting or setting service-specific information - Get URL/stream key via other means of authentication such as OAuth, or be able to build custom URLs for services that require that sort of thing. - Query information (such as viewer count, chat, follower notifications, and other information) - Set channel information (such as current game, current channel title, activating commercials) Also, I reduce some repeated code that was used for all libobs objects. This includes the name of the object, the private data, settings, as well as the signal and procedure handlers. I also switched to using linked lists for the global object lists, rather than using an array of pointers (you could say it was.. pointless.) ..Anyway, the linked list info is also stored in the shared context data structure.
2014-04-19 20:38:53 -07:00
signal_handler_signal(scene->source->context.signals, "item_add",
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
&params);
first commit
2013-09-30 19:37:13 -07:00
return item;
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
static void obs_sceneitem_destroy(obs_sceneitem_t *item)
first commit
2013-09-30 19:37:13 -07:00
{
Fix the design flaw with obs_sceneitem_destroy The previous commit used the scene as a parameter to check to see if the scene item was still present within the scene before destroying, but this was actually unnecessary because the fault was because the destroy signal was being triggered *before* the scene's mutex locked, thus causing a race condition. I changed the code so that it signals after the lock instead of before, so the scene parameter should no longer be necessary.
2014-01-29 17:27:42 -08:00
if (item) {
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
if (item->item_render) {
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
obs_enter_graphics();
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
gs_texrender_destroy(item->item_render);
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
obs_leave_graphics();
}
libobs: Add private settings to scene items/sources Allows setting and sharing of user data for sources and scene items.
2017-09-13 03:12:56 -07:00
obs_data_release(item->private_settings);
libobs: Add scene item hotkeys
2015-05-08 18:33:55 -07:00
obs_hotkey_pair_unregister(item->toggle_visibility);
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
pthread_mutex_destroy(&item->actions_mutex);
libobs: Update hotkey label on scene item rename
2018-05-28 18:21:50 -07:00
signal_handler_disconnect(
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_source_get_signal_handler(item->source), "rename",
sceneitem_renamed, item);
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
if (item->show_transition)
obs_source_release(item->show_transition);
if (item->hide_transition)
obs_source_release(item->hide_transition);
cleaned up main internal data structure design, changed to reference counting for sources to ensure safe destruction of source objects from all parts of the system, added some service-related stuff for testing
2013-11-20 14:00:16 -08:00
if (item->source)
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
obs_source_release(item->source);
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
da_free(item->audio_actions);
first commit
2013-09-30 19:37:13 -07:00
bfree(item);
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
}
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
void obs_sceneitem_addref(obs_sceneitem_t *item)
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
{
Remove external ref count visibility The returned ref count was never used and the returned value doesn't actually confer any meaning in a multithreaded environment
2014-02-02 17:34:06 -08:00
if (item)
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
os_atomic_inc_long(&item->ref);
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
}
update API and implement preliminary ability to add sources to scenes
2013-12-30 05:56:39 -08:00
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
void obs_sceneitem_release(obs_sceneitem_t *item)
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
{
Remove external ref count visibility The returned ref count was never used and the returned value doesn't actually confer any meaning in a multithreaded environment
2014-02-02 17:34:06 -08:00
if (!item)
return;
Use recursive mutex for scene mutex Fixes a deadlock when trying to remove a source from the GUI. The scene item signal handlers would mark the source as removed which results in the video thread also trying to run obs_sceneitem_destroy thereby deadlocking the video thread (and the GUI thread)
2014-01-29 13:46:39 -08:00
Use atomic functions where appropriate Also, rename atomic functions to be consistent with the rest of the platform/threading functions, and move atomic functions to threading* files rather than platform* files
2014-03-16 18:26:46 -07:00
if (os_atomic_dec_long(&item->ref) == 0)
Remove external ref count visibility The returned ref count was never used and the returned value doesn't actually confer any meaning in a multithreaded environment
2014-02-02 17:34:06 -08:00
obs_sceneitem_destroy(item);
update API and implement preliminary ability to add sources to scenes
2013-12-30 05:56:39 -08:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
void obs_sceneitem_remove(obs_sceneitem_t *item)
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
{
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
obs_scene_t *scene;
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
Use mutex instead of variable for RC check
2014-01-30 11:29:13 -08:00
if (!item)
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
return;
Use mutex instead of variable for RC check
2014-01-30 11:29:13 -08:00
scene = item->parent;
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
Fix various null pointer issues detected by Coverity
2017-02-25 07:45:45 -08:00
full_lock(scene);
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
Clean up the previous commit a bit The was_removed variable was rather unnecessary
2014-01-30 11:35:21 -08:00
if (item->removed) {
Use mutex instead of variable for RC check
2014-01-30 11:29:13 -08:00
if (scene)
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_unlock(scene);
Use mutex instead of variable for RC check
2014-01-30 11:29:13 -08:00
return;
}
Clean up the previous commit a bit The was_removed variable was rather unnecessary
2014-01-30 11:35:21 -08:00
item->removed = true;
Add NULL checks and assertions to fix clang static analysis problems Also remove an unused variable from obs-encoder.c (via clang static analysis)
2014-04-14 13:55:14 -07:00
assert(scene != NULL);
assert(scene->source != NULL);
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
set_visibility(item, false);
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
Use mutex instead of variable for RC check
2014-01-30 11:29:13 -08:00
signal_item_remove(item);
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
detach_sceneitem(item);
Use mutex instead of variable for RC check
2014-01-30 11:29:13 -08:00
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_unlock(scene);
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
libobs: Refactor hide/show transition functions Having two separate functions for each hide/show transition action is silly and makes code awful.
2022-03-24 22:32:41 -07:00
obs_sceneitem_set_transition(item, true, NULL);
obs_sceneitem_set_transition(item, false, NULL);
libobs: Fix deadlock removing scene item
2021-05-07 23:34:43 -07:00
Improve thread safety for scene items Scene items previously were removed by calling obs_sceneitem_destroy, but this proved to be a potential race condition where two different threads could try to destroy the same scene item at the same time. Instead of doing that, reference counting is now used on scene items, and an explicit obs_sceneitem_remove function is used instead for item removal, which sets a 'removed' variable to ensure it can only be called exactly one time.
2014-01-30 00:31:52 -08:00
obs_sceneitem_release(item);
}
UI/libobs: Undo/Redo Sources and Scenes Implements the Undo/Redo for scenes and sources, ranging from renaming, deletion, addition. It also adds several elements to libobs that were designed to facilitate undo/redo, and should not affect the rest of libobs.
2021-03-21 21:39:02 -07:00
void obs_sceneitem_save(obs_sceneitem_t *item, obs_data_array_t *arr)
{
scene_save_item(arr, item, NULL);
}
void sceneitem_restore(obs_data_t *data, void *vp)
{
obs_scene_t *scene = (obs_scene_t *)vp;
scene_load_item(scene, data);
}
void obs_sceneitems_add(obs_scene_t *scene, obs_data_array_t *data)
{
obs_data_array_enum(data, sceneitem_restore, scene);
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 15:25:59 -07:00
obs_scene_t *obs_sceneitem_get_scene(const obs_sceneitem_t *item)
Added add/remove signals to scenes Scenes will now signal via their source when an item has been added or removed from them. "add" - Item added to the scene. Parameters: "scene": Scene that the item was added to. "item": Item that was added. "remove" - Item removed from the scene. Parameters: "scene": Scene that the item was removed from. "item": Item that was removed.
2014-01-04 12:38:56 -08:00
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
return item ? item->parent : NULL;
Added add/remove signals to scenes Scenes will now signal via their source when an item has been added or removed from them. "add" - Item added to the scene. Parameters: "scene": Scene that the item was added to. "item": Item that was added. "remove" - Item removed from the scene. Parameters: "scene": Scene that the item was removed from. "item": Item that was removed.
2014-01-04 12:38:56 -08:00
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 15:25:59 -07:00
obs_source_t *obs_sceneitem_get_source(const obs_sceneitem_t *item)
update API and implement preliminary ability to add sources to scenes
2013-12-30 05:56:39 -08:00
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
return item ? item->source : NULL;
first commit
2013-09-30 19:37:13 -07:00
}
libobs: Refactor item signaling (add func to signal parent)
2018-06-01 02:34:32 -07:00
static void signal_parent(obs_scene_t *parent, const char *command,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
calldata_t *params)
libobs: Refactor item signaling (add func to signal parent)
2018-06-01 02:34:32 -07:00
{
calldata_set_ptr(params, "scene", parent);
signal_handler_signal(parent->source->context.signals, command, params);
}
UI: Undo/Redo Transformations Implements undo/redo for transformations of sources, both through preview and the transformations properties.
2021-03-21 22:14:37 -07:00
struct passthrough {
obs_data_array_t *ids;
UI: Fix wrong behavior with undo/redo and groups
2021-04-03 13:20:00 -07:00
obs_data_array_t *scenes_and_groups;
UI: Undo/Redo Transformations Implements undo/redo for transformations of sources, both through preview and the transformations properties.
2021-03-21 22:14:37 -07:00
bool all_items;
};
bool save_transform_states(obs_scene_t *scene, obs_sceneitem_t *item,
void *vp_pass)
{
struct passthrough *pass = (struct passthrough *)vp_pass;
if (obs_sceneitem_selected(item) || pass->all_items) {
obs_data_t *temp = obs_data_create();
obs_data_array_t *item_ids = (obs_data_array_t *)pass->ids;
struct obs_transform_info info;
struct obs_sceneitem_crop crop;
obs_sceneitem_get_info(item, &info);
obs_sceneitem_get_crop(item, &crop);
struct vec2 pos = info.pos;
struct vec2 scale = info.scale;
float rot = info.rot;
uint32_t alignment = info.alignment;
uint32_t bounds_type = info.bounds_type;
uint32_t bounds_alignment = info.bounds_alignment;
struct vec2 bounds = info.bounds;
obs_data_set_int(temp, "id", obs_sceneitem_get_id(item));
obs_data_set_vec2(temp, "pos", &pos);
obs_data_set_vec2(temp, "scale", &scale);
libobs: obs-scene type fixes Replace "rot" int usages with double. Add explicit narrowing casts to fix warnings.
2021-03-31 05:20:07 -07:00
obs_data_set_double(temp, "rot", rot);
UI: Undo/Redo Transformations Implements undo/redo for transformations of sources, both through preview and the transformations properties.
2021-03-21 22:14:37 -07:00
obs_data_set_int(temp, "alignment", alignment);
obs_data_set_int(temp, "bounds_type", bounds_type);
obs_data_set_vec2(temp, "bounds", &bounds);
obs_data_set_int(temp, "bounds_alignment", bounds_alignment);
obs_data_set_int(temp, "top", crop.top);
obs_data_set_int(temp, "bottom", crop.bottom);
obs_data_set_int(temp, "left", crop.left);
obs_data_set_int(temp, "right", crop.right);
obs_data_array_push_back(item_ids, temp);
obs_data_release(temp);
}
UI: Fix wrong behavior with undo/redo and groups
2021-04-03 13:20:00 -07:00
obs_source_t *item_source = obs_sceneitem_get_source(item);
if (obs_source_is_group(item_source)) {
obs_data_t *temp = obs_data_create();
obs_data_array_t *nids = obs_data_array_create();
obs_data_set_string(temp, "scene_name",
obs_source_get_name(item_source));
obs_data_set_bool(temp, "is_group", true);
obs_data_set_string(
temp, "group_parent",
obs_source_get_name(obs_scene_get_source(scene)));
struct passthrough npass = {nids, pass->scenes_and_groups,
pass->all_items};
obs_sceneitem_group_enum_items(item, save_transform_states,
(void *)&npass);
obs_data_set_array(temp, "items", nids);
obs_data_array_push_back(pass->scenes_and_groups, temp);
obs_data_release(temp);
obs_data_array_release(nids);
}
UI: Undo/Redo Transformations Implements undo/redo for transformations of sources, both through preview and the transformations properties.
2021-03-21 22:14:37 -07:00
return true;
}
obs_data_t *obs_scene_save_transform_states(obs_scene_t *scene, bool all_items)
{
obs_data_t *wrapper = obs_data_create();
UI: Fix wrong behavior with undo/redo and groups
2021-04-03 13:20:00 -07:00
obs_data_array_t *scenes_and_groups = obs_data_array_create();
UI: Undo/Redo Transformations Implements undo/redo for transformations of sources, both through preview and the transformations properties.
2021-03-21 22:14:37 -07:00
obs_data_array_t *item_ids = obs_data_array_create();
UI: Fix wrong behavior with undo/redo and groups
2021-04-03 13:20:00 -07:00
struct passthrough pass = {item_ids, scenes_and_groups, all_items};
obs_data_t *temp = obs_data_create();
obs_data_set_string(temp, "scene_name",
UI: Undo/Redo Transformations Implements undo/redo for transformations of sources, both through preview and the transformations properties.
2021-03-21 22:14:37 -07:00
obs_source_get_name(obs_scene_get_source(scene)));
UI: Fix wrong behavior with undo/redo and groups
2021-04-03 13:20:00 -07:00
obs_data_set_bool(temp, "is_group", false);
obs_scene_enum_items(scene, save_transform_states, (void *)&pass);
obs_data_set_array(temp, "items", item_ids);
obs_data_array_push_back(scenes_and_groups, temp);
obs_data_set_array(wrapper, "scenes_and_groups", scenes_and_groups);
UI: Undo/Redo Transformations Implements undo/redo for transformations of sources, both through preview and the transformations properties.
2021-03-21 22:14:37 -07:00
obs_data_array_release(item_ids);
UI: Fix wrong behavior with undo/redo and groups
2021-04-03 13:20:00 -07:00
obs_data_array_release(scenes_and_groups);
obs_data_release(temp);
UI: Undo/Redo Transformations Implements undo/redo for transformations of sources, both through preview and the transformations properties.
2021-03-21 22:14:37 -07:00
return wrapper;
}
void load_transform_states(obs_data_t *temp, void *vp_scene)
{
obs_scene_t *scene = (obs_scene_t *)vp_scene;
int64_t id = obs_data_get_int(temp, "id");
obs_sceneitem_t *item = obs_scene_find_sceneitem_by_id(scene, id);
struct obs_transform_info info;
struct obs_sceneitem_crop crop;
obs_data_get_vec2(temp, "pos", &info.pos);
obs_data_get_vec2(temp, "scale", &info.scale);
libobs: obs-scene type fixes Replace "rot" int usages with double. Add explicit narrowing casts to fix warnings.
2021-03-31 05:20:07 -07:00
info.rot = (float)obs_data_get_double(temp, "rot");
info.alignment = (uint32_t)obs_data_get_int(temp, "alignment");
UI: Undo/Redo Transformations Implements undo/redo for transformations of sources, both through preview and the transformations properties.
2021-03-21 22:14:37 -07:00
info.bounds_type =
(enum obs_bounds_type)obs_data_get_int(temp, "bounds_type");
libobs: obs-scene type fixes Replace "rot" int usages with double. Add explicit narrowing casts to fix warnings.
2021-03-31 05:20:07 -07:00
info.bounds_alignment =
(uint32_t)obs_data_get_int(temp, "bounds_alignment");
UI: Undo/Redo Transformations Implements undo/redo for transformations of sources, both through preview and the transformations properties.
2021-03-21 22:14:37 -07:00
obs_data_get_vec2(temp, "bounds", &info.bounds);
libobs: obs-scene type fixes Replace "rot" int usages with double. Add explicit narrowing casts to fix warnings.
2021-03-31 05:20:07 -07:00
crop.top = (int)obs_data_get_int(temp, "top");
crop.bottom = (int)obs_data_get_int(temp, "bottom");
crop.left = (int)obs_data_get_int(temp, "left");
crop.right = (int)obs_data_get_int(temp, "right");
UI: Undo/Redo Transformations Implements undo/redo for transformations of sources, both through preview and the transformations properties.
2021-03-21 22:14:37 -07:00
obs_sceneitem_defer_update_begin(item);
obs_sceneitem_set_info(item, &info);
obs_sceneitem_set_crop(item, &crop);
obs_sceneitem_defer_update_end(item);
}
UI: Fix wrong behavior with undo/redo and groups
2021-04-03 13:20:00 -07:00
void iterate_scenes_and_groups_transform_states(obs_data_t *data, void *vp)
{
obs_data_array_t *items = obs_data_get_array(data, "items");
obs_source_t *scene_source =
obs_get_source_by_name(obs_data_get_string(data, "scene_name"));
obs_scene_t *scene = obs_scene_from_source(scene_source);
if (obs_data_get_bool(data, "is_group")) {
obs_source_t *parent_source = obs_get_source_by_name(
obs_data_get_string(data, "group_parent"));
obs_scene_t *parent = obs_scene_from_source(parent_source);
obs_sceneitem_t *group = obs_scene_get_group(
parent, obs_data_get_string(data, "scene_name"));
scene = obs_sceneitem_group_get_scene(group);
obs_source_release(parent_source);
}
obs_data_array_enum(items, load_transform_states, (void *)scene);
UNUSED_PARAMETER(vp);
obs_data_array_release(items);
obs_source_release(scene_source);
}
UI: Undo/Redo Transformations Implements undo/redo for transformations of sources, both through preview and the transformations properties.
2021-03-21 22:14:37 -07:00
void obs_scene_load_transform_states(const char *data)
{
obs_data_t *dat = obs_data_create_from_json(data);
UI: Fix wrong behavior with undo/redo and groups
2021-04-03 13:20:00 -07:00
obs_data_array_t *scenes_and_groups =
obs_data_get_array(dat, "scenes_and_groups");
obs_data_array_enum(scenes_and_groups,
iterate_scenes_and_groups_transform_states, NULL);
UI: Undo/Redo Transformations Implements undo/redo for transformations of sources, both through preview and the transformations properties.
2021-03-21 22:14:37 -07:00
obs_data_release(dat);
UI: Fix wrong behavior with undo/redo and groups
2021-04-03 13:20:00 -07:00
obs_data_array_release(scenes_and_groups);
UI: Undo/Redo Transformations Implements undo/redo for transformations of sources, both through preview and the transformations properties.
2021-03-21 22:14:37 -07:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
void obs_sceneitem_select(obs_sceneitem_t *item, bool select)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
{
libobs: Use calldata with stack for simple signals Makes signals use stack memory rather than allocate memory each time. Most likely a completely insignificant and pointless optimization.
2016-01-18 20:01:58 -08:00
struct calldata params;
uint8_t stack[128];
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
const char *command = select ? "item_select" : "item_deselect";
libobs: Fix possible null pointer dereference
2016-07-09 06:31:16 -07:00
if (!item || item->selected == select || !item->parent)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
return;
item->selected = select;
libobs: Use calldata with stack for simple signals Makes signals use stack memory rather than allocate memory each time. Most likely a completely insignificant and pointless optimization.
2016-01-18 20:01:58 -08:00
calldata_init_fixed(&params, stack, sizeof(stack));
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
calldata_set_ptr(&params, "item", item);
libobs: Refactor item signaling (add func to signal parent)
2018-06-01 02:34:32 -07:00
signal_parent(item->parent, command, &params);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 15:25:59 -07:00
bool obs_sceneitem_selected(const obs_sceneitem_t *item)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
{
return item ? item->selected : false;
}
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
#define do_update_transform(item) \
do { \
if (!item->parent || item->parent->is_group) \
libobs: Always try to update transform in current thread Due to the recent change in which scene items now only update their transforms during the next frame's tick, snapping sources would sometimes jitter and have incorrect snapping. This fixes that issue by reverting to the behavior of updating the transform immediately rather than deferring the update to the next frame tick, but only on non-group items. This should not be done on items that are sub-items of groups because we rely on the obs_scene_item::update_transform variable to update the parent group's transform in addition.
2018-07-24 01:54:04 -07:00
os_atomic_set_bool(&item->update_transform, true); \
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
else \
update_item_transform(item, false); \
libobs: Always try to update transform in current thread Due to the recent change in which scene items now only update their transforms during the next frame's tick, snapping sources would sometimes jitter and have incorrect snapping. This fixes that issue by reverting to the behavior of updating the transform immediately rather than deferring the update to the next frame tick, but only on non-group items. This should not be done on items that are sub-items of groups because we rely on the obs_scene_item::update_transform variable to update the parent group's transform in addition.
2018-07-24 01:54:04 -07:00
} while (false)
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
void obs_sceneitem_set_pos(obs_sceneitem_t *item, const struct vec2 *pos)
first commit
2013-09-30 19:37:13 -07:00
{
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
if (item) {
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
vec2_copy(&item->pos, pos);
libobs: Always try to update transform in current thread Due to the recent change in which scene items now only update their transforms during the next frame's tick, snapping sources would sometimes jitter and have incorrect snapping. This fixes that issue by reverting to the behavior of updating the transform immediately rather than deferring the update to the next frame tick, but only on non-group items. This should not be done on items that are sub-items of groups because we rely on the obs_scene_item::update_transform variable to update the parent group's transform in addition.
2018-07-24 01:54:04 -07:00
do_update_transform(item);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
}
first commit
2013-09-30 19:37:13 -07:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
void obs_sceneitem_set_rot(obs_sceneitem_t *item, float rot)
first commit
2013-09-30 19:37:13 -07:00
{
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
if (item) {
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
item->rot = rot;
libobs: Always try to update transform in current thread Due to the recent change in which scene items now only update their transforms during the next frame's tick, snapping sources would sometimes jitter and have incorrect snapping. This fixes that issue by reverting to the behavior of updating the transform immediately rather than deferring the update to the next frame tick, but only on non-group items. This should not be done on items that are sub-items of groups because we rely on the obs_scene_item::update_transform variable to update the parent group's transform in addition.
2018-07-24 01:54:04 -07:00
do_update_transform(item);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
}
first commit
2013-09-30 19:37:13 -07:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
void obs_sceneitem_set_scale(obs_sceneitem_t *item, const struct vec2 *scale)
first commit
2013-09-30 19:37:13 -07:00
{
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
if (item) {
vec2_copy(&item->scale, scale);
libobs: Always try to update transform in current thread Due to the recent change in which scene items now only update their transforms during the next frame's tick, snapping sources would sometimes jitter and have incorrect snapping. This fixes that issue by reverting to the behavior of updating the transform immediately rather than deferring the update to the next frame tick, but only on non-group items. This should not be done on items that are sub-items of groups because we rely on the obs_scene_item::update_transform variable to update the parent group's transform in addition.
2018-07-24 01:54:04 -07:00
do_update_transform(item);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
}
first commit
2013-09-30 19:37:13 -07:00
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
void obs_sceneitem_set_alignment(obs_sceneitem_t *item, uint32_t alignment)
first commit
2013-09-30 19:37:13 -07:00
{
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
if (item) {
item->align = alignment;
libobs: Always try to update transform in current thread Due to the recent change in which scene items now only update their transforms during the next frame's tick, snapping sources would sometimes jitter and have incorrect snapping. This fixes that issue by reverting to the behavior of updating the transform immediately rather than deferring the update to the next frame tick, but only on non-group items. This should not be done on items that are sub-items of groups because we rely on the obs_scene_item::update_transform variable to update the parent group's transform in addition.
2018-07-24 01:54:04 -07:00
do_update_transform(item);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
}
first commit
2013-09-30 19:37:13 -07:00
}
libobs: Replace item_move_* signals These signals introduce unnecessary complexity. Instead of emitting a signal for a specific move direction, just signal that the scene has been reordered, that way the target just refreshes the list.
2015-02-17 09:54:45 -08:00
static inline void signal_reorder(struct obs_scene_item *item)
Add ability to move source up/down/etc
2014-05-15 17:40:53 -07:00
{
Fix 'potentially uninitialized' warning on var
2014-06-27 21:37:40 -07:00
const char *command = NULL;
libobs: Use calldata with stack for simple signals Makes signals use stack memory rather than allocate memory each time. Most likely a completely insignificant and pointless optimization.
2016-01-18 20:01:58 -08:00
struct calldata params;
uint8_t stack[128];
Add ability to move source up/down/etc
2014-05-15 17:40:53 -07:00
libobs: Replace item_move_* signals These signals introduce unnecessary complexity. Instead of emitting a signal for a specific move direction, just signal that the scene has been reordered, that way the target just refreshes the list.
2015-02-17 09:54:45 -08:00
command = "reorder";
Add ability to move source up/down/etc
2014-05-15 17:40:53 -07:00
libobs: Use calldata with stack for simple signals Makes signals use stack memory rather than allocate memory each time. Most likely a completely insignificant and pointless optimization.
2016-01-18 20:01:58 -08:00
calldata_init_fixed(&params, stack, sizeof(stack));
libobs: Refactor item signaling (add func to signal parent)
2018-06-01 02:34:32 -07:00
signal_parent(item->parent, command, &params);
Add ability to move source up/down/etc
2014-05-15 17:40:53 -07:00
}
libobs: Add refresh signal to scenes This signal is used to specify when a scene needs a full refresh of its item list.
2020-02-07 16:35:20 -08:00
static inline void signal_refresh(obs_scene_t *scene)
{
const char *command = NULL;
struct calldata params;
uint8_t stack[128];
command = "refresh";
calldata_init_fixed(&params, stack, sizeof(stack));
signal_parent(scene, command, &params);
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
void obs_sceneitem_set_order(obs_sceneitem_t *item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
enum obs_order_movement movement)
first commit
2013-09-30 19:37:13 -07:00
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
if (!item)
return;
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
Add ability to move source up/down/etc
2014-05-15 17:40:53 -07:00
struct obs_scene_item *next, *prev;
libobs: Replace addref calls with get_ref
2022-01-24 13:47:56 -08:00
struct obs_scene *scene = obs_scene_get_ref(item->parent);
if (!scene)
return;
first commit
2013-09-30 19:37:13 -07:00
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_lock(scene);
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
Add ability to move source up/down/etc
2014-05-15 17:40:53 -07:00
next = item->next;
prev = item->prev;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
detach_sceneitem(item);
(API Change) Rename order_movement Prefix with obs_ for the sake of consistency Renamed enums: - order_movement (now obs_order_movement) Affected functions: - obs_source_filter_setorder - obs_sceneitem_setorder
2014-08-02 01:33:53 -07:00
if (movement == OBS_ORDER_MOVE_DOWN) {
Add ability to move source up/down/etc
2014-05-15 17:40:53 -07:00
attach_sceneitem(scene, item, prev ? prev->prev : NULL);
first commit
2013-09-30 19:37:13 -07:00
(API Change) Rename order_movement Prefix with obs_ for the sake of consistency Renamed enums: - order_movement (now obs_order_movement) Affected functions: - obs_source_filter_setorder - obs_sceneitem_setorder
2014-08-02 01:33:53 -07:00
} else if (movement == OBS_ORDER_MOVE_UP) {
Add ability to move source up/down/etc
2014-05-15 17:40:53 -07:00
attach_sceneitem(scene, item, next ? next : prev);
first commit
2013-09-30 19:37:13 -07:00
(API Change) Rename order_movement Prefix with obs_ for the sake of consistency Renamed enums: - order_movement (now obs_order_movement) Affected functions: - obs_source_filter_setorder - obs_sceneitem_setorder
2014-08-02 01:33:53 -07:00
} else if (movement == OBS_ORDER_MOVE_TOP) {
Add ability to move source up/down/etc
2014-05-15 17:40:53 -07:00
struct obs_scene_item *last = next;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
if (!last) {
Add ability to move source up/down/etc
2014-05-15 17:40:53 -07:00
last = prev;
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
} else {
while (last->next)
last = last->next;
}
first commit
2013-09-30 19:37:13 -07:00
Add ability to move source up/down/etc
2014-05-15 17:40:53 -07:00
attach_sceneitem(scene, item, last);
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
(API Change) Rename order_movement Prefix with obs_ for the sake of consistency Renamed enums: - order_movement (now obs_order_movement) Affected functions: - obs_source_filter_setorder - obs_sceneitem_setorder
2014-08-02 01:33:53 -07:00
} else if (movement == OBS_ORDER_MOVE_BOTTOM) {
Add ability to move source up/down/etc
2014-05-15 17:40:53 -07:00
attach_sceneitem(scene, item, NULL);
first commit
2013-09-30 19:37:13 -07:00
}
make scene items use linked list rather than array (containers are a bad habit), add a few functions for getting scene item information, also use a mutex to prevent race conditions when using the linked list
2014-01-01 09:22:55 -08:00
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_unlock(scene);
libobs: Do not signal reorder while scene mutex locked Prevents a potential race condition with the scene mutex.
2018-06-01 07:44:44 -07:00
signal_reorder(item);
Implement source activation/deactivation Now sources will be properly activated and deactivated when they are in use or not in use. Had to figure out a way to handle child sources, and children of children, just ended up implementing simple functions that parents use to signal adding/removal to help with hierarchial activation and deactivation of child sources. To prevent the source activate/deactivate callbacks from being called more than once, added an activation reference counter. The first increment will call the activate callback, and the last decrement will call the deactivate callback. Added "source-activate" and "source-deactivate" signals to the main obs signal handler, and "activate" and "deactivate" to individual source signal handlers. Also, fixed the main window so it properly selects a source when the current active scene has been changed.
2014-02-20 21:04:14 -08:00
obs_scene_release(scene);
first commit
2013-09-30 19:37:13 -07:00
}
UI/libobs: Undo/Redo Sources and Scenes Implements the Undo/Redo for scenes and sources, ranging from renaming, deletion, addition. It also adds several elements to libobs that were designed to facilitate undo/redo, and should not affect the rest of libobs.
2021-03-21 21:39:02 -07:00
int obs_sceneitem_get_order_position(obs_sceneitem_t *item)
{
struct obs_scene *scene = item->parent;
struct obs_scene_item *next = scene->first_item;
full_lock(scene);
int index = 0;
while (next && next != item) {
next = next->next;
++index;
}
full_unlock(scene);
return index;
}
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
void obs_sceneitem_set_order_position(obs_sceneitem_t *item, int position)
libobs: Add function to set scene item position Allows setting a specific position for scene items rather than just up/down/top/bottom
2015-02-13 08:29:48 -08:00
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
if (!item)
return;
libobs: Add function to set scene item position Allows setting a specific position for scene items rather than just up/down/top/bottom
2015-02-13 08:29:48 -08:00
libobs: Replace addref calls with get_ref
2022-01-24 13:47:56 -08:00
struct obs_scene *scene = obs_scene_get_ref(item->parent);
libobs: Add function to set scene item position Allows setting a specific position for scene items rather than just up/down/top/bottom
2015-02-13 08:29:48 -08:00
struct obs_scene_item *next;
libobs: Replace addref calls with get_ref
2022-01-24 13:47:56 -08:00
if (!scene)
return;
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_lock(scene);
libobs: Add function to set scene item position Allows setting a specific position for scene items rather than just up/down/top/bottom
2015-02-13 08:29:48 -08:00
detach_sceneitem(item);
next = scene->first_item;
if (position == 0) {
attach_sceneitem(scene, item, NULL);
} else {
for (int i = position; i > 1; --i) {
if (next->next == NULL)
break;
next = next->next;
}
attach_sceneitem(scene, item, next);
}
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_unlock(scene);
libobs: Do not signal reorder while scene mutex locked Prevents a potential race condition with the scene mutex.
2018-06-01 07:44:44 -07:00
signal_reorder(item);
libobs: Add function to set scene item position Allows setting a specific position for scene items rather than just up/down/top/bottom
2015-02-13 08:29:48 -08:00
obs_scene_release(scene);
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
void obs_sceneitem_set_bounds_type(obs_sceneitem_t *item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
enum obs_bounds_type type)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
{
if (item) {
item->bounds_type = type;
libobs: Always try to update transform in current thread Due to the recent change in which scene items now only update their transforms during the next frame's tick, snapping sources would sometimes jitter and have incorrect snapping. This fixes that issue by reverting to the behavior of updating the transform immediately rather than deferring the update to the next frame tick, but only on non-group items. This should not be done on items that are sub-items of groups because we rely on the obs_scene_item::update_transform variable to update the parent group's transform in addition.
2018-07-24 01:54:04 -07:00
do_update_transform(item);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
}
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
void obs_sceneitem_set_bounds_alignment(obs_sceneitem_t *item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
uint32_t alignment)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
{
if (item) {
item->bounds_align = alignment;
libobs: Always try to update transform in current thread Due to the recent change in which scene items now only update their transforms during the next frame's tick, snapping sources would sometimes jitter and have incorrect snapping. This fixes that issue by reverting to the behavior of updating the transform immediately rather than deferring the update to the next frame tick, but only on non-group items. This should not be done on items that are sub-items of groups because we rely on the obs_scene_item::update_transform variable to update the parent group's transform in addition.
2018-07-24 01:54:04 -07:00
do_update_transform(item);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
}
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
void obs_sceneitem_set_bounds(obs_sceneitem_t *item, const struct vec2 *bounds)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
{
if (item) {
item->bounds = *bounds;
libobs: Always try to update transform in current thread Due to the recent change in which scene items now only update their transforms during the next frame's tick, snapping sources would sometimes jitter and have incorrect snapping. This fixes that issue by reverting to the behavior of updating the transform immediately rather than deferring the update to the next frame tick, but only on non-group items. This should not be done on items that are sub-items of groups because we rely on the obs_scene_item::update_transform variable to update the parent group's transform in addition.
2018-07-24 01:54:04 -07:00
do_update_transform(item);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
}
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 15:25:59 -07:00
void obs_sceneitem_get_pos(const obs_sceneitem_t *item, struct vec2 *pos)
first commit
2013-09-30 19:37:13 -07:00
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (item)
vec2_copy(pos, &item->pos);
first commit
2013-09-30 19:37:13 -07:00
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 15:25:59 -07:00
float obs_sceneitem_get_rot(const obs_sceneitem_t *item)
first commit
2013-09-30 19:37:13 -07:00
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
return item ? item->rot : 0.0f;
first commit
2013-09-30 19:37:13 -07:00
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 15:25:59 -07:00
void obs_sceneitem_get_scale(const obs_sceneitem_t *item, struct vec2 *scale)
first commit
2013-09-30 19:37:13 -07:00
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (item)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
vec2_copy(scale, &item->scale);
first commit
2013-09-30 19:37:13 -07:00
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 15:25:59 -07:00
uint32_t obs_sceneitem_get_alignment(const obs_sceneitem_t *item)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
{
return item ? item->align : 0;
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 15:25:59 -07:00
enum obs_bounds_type obs_sceneitem_get_bounds_type(const obs_sceneitem_t *item)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
{
return item ? item->bounds_type : OBS_BOUNDS_NONE;
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 15:25:59 -07:00
uint32_t obs_sceneitem_get_bounds_alignment(const obs_sceneitem_t *item)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
{
return item ? item->bounds_align : 0;
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 15:25:59 -07:00
void obs_sceneitem_get_bounds(const obs_sceneitem_t *item, struct vec2 *bounds)
first commit
2013-09-30 19:37:13 -07:00
{
Add more checks for NULL pointers
2014-02-23 21:39:33 -08:00
if (item)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
*bounds = item->bounds;
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 15:25:59 -07:00
void obs_sceneitem_get_info(const obs_sceneitem_t *item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct obs_transform_info *info)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
{
if (item && info) {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
info->pos = item->pos;
info->rot = item->rot;
info->scale = item->scale;
info->alignment = item->align;
info->bounds_type = item->bounds_type;
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
info->bounds_alignment = item->bounds_align;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
info->bounds = item->bounds;
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
}
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
void obs_sceneitem_set_info(obs_sceneitem_t *item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
const struct obs_transform_info *info)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
{
if (item && info) {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
item->pos = info->pos;
item->rot = info->rot;
item->scale = info->scale;
item->align = info->alignment;
item->bounds_type = info->bounds_type;
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
item->bounds_align = info->bounds_alignment;
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
item->bounds = info->bounds;
libobs: Always try to update transform in current thread Due to the recent change in which scene items now only update their transforms during the next frame's tick, snapping sources would sometimes jitter and have incorrect snapping. This fixes that issue by reverting to the behavior of updating the transform immediately rather than deferring the update to the next frame tick, but only on non-group items. This should not be done on items that are sub-items of groups because we rely on the obs_scene_item::update_transform variable to update the parent group's transform in addition.
2018-07-24 01:54:04 -07:00
do_update_transform(item);
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
}
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 15:25:59 -07:00
void obs_sceneitem_get_draw_transform(const obs_sceneitem_t *item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct matrix4 *transform)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
{
if (item)
matrix4_copy(transform, &item->draw_transform);
}
(API Change) Use const params where applicable This Fixes a minor flaw with the API where data had to always be mutable to be usable by the API. Functions that do not modify the fundamental underlying data of a structure should be marked as constant, both for safety and to signify that the parameter is input only and will not be modified by the function using it.
2014-09-26 15:25:59 -07:00
void obs_sceneitem_get_box_transform(const obs_sceneitem_t *item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct matrix4 *transform)
Scenes: Implement more item positioning features There are a ridiculous number of features related to scaling and positioning due to requests by a number of people who complained that they hated the way that OBS1 would always resize their sources when the source's base size changed. There were also people who wanted more control for how the resizing was handled, or the ability to completely prevent resizing entirely if desired. So I made it so that you can optionally use a 'bounds' system, which allows you to specify different styles of controlling resizing. If disabled, the source will always automatically resize and only the base scale is applied. If enabled, you have a variety of different ways to limit/control how it can resize within the bounds, or make it so it can't resize at all. You can also control alignment within that bounding box, so you can make it so that a source always aligns to a side or corner of the box. I also added an alignment value which changes how the source is oriented relative to the position of the scene item. For example, setting bottom-right alignment will make it so that the position of the item is the bottom right corner of the source. When the source resizies, it will resize leftward and upward in that case, which solves the problem of how a source resizes relative to a desired position.
2014-06-15 00:16:03 -07:00
{
if (item)
matrix4_copy(transform, &item->box_transform);
first commit
2013-09-30 19:37:13 -07:00
}
libobs: Add API to hide/show scene items
2015-03-22 20:28:27 -07:00
libobs: UI: Fix rotated line scale The line drawing functions previously assumed the upper-left 3x3 for box_transform only held scale. The matrix can also hold rotation, so pass in scale separately. Fixes https://obsproject.com/mantis/view.php?id=1442
2019-04-19 06:35:42 -07:00
void obs_sceneitem_get_box_scale(const obs_sceneitem_t *item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct vec2 *scale)
libobs: UI: Fix rotated line scale The line drawing functions previously assumed the upper-left 3x3 for box_transform only held scale. The matrix can also hold rotation, so pass in scale separately. Fixes https://obsproject.com/mantis/view.php?id=1442
2019-04-19 06:35:42 -07:00
{
if (item)
*scale = item->box_scale;
}
libobs: Add API to hide/show scene items
2015-03-22 20:28:27 -07:00
bool obs_sceneitem_visible(const obs_sceneitem_t *item)
{
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
return item ? item->user_visible : false;
libobs: Add API to hide/show scene items
2015-03-22 20:28:27 -07:00
}
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
static bool group_item_transition(obs_scene_t *scene, obs_sceneitem_t *item,
void *param)
{
if (!param || !item)
return true;
const bool visible = *(bool *)param;
if (obs_sceneitem_visible(item))
obs_sceneitem_do_transition(item, visible);
UNUSED_PARAMETER(scene);
return true;
}
libobs: Make scene item visibility activate/deactivate Before if a source was set to invisible it would still be considered active. This changes it so that the source is deactivated when the source is invisible to reduce needless resource usage or capturing.
2015-12-22 05:25:31 -08:00
bool obs_sceneitem_set_visible(obs_sceneitem_t *item, bool visible)
libobs: Add API to hide/show scene items
2015-03-22 20:28:27 -07:00
{
libobs: Use calldata with stack for simple signals Makes signals use stack memory rather than allocate memory each time. Most likely a completely insignificant and pointless optimization.
2016-01-18 20:01:58 -08:00
struct calldata cd;
uint8_t stack[256];
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct item_action action = {.visible = visible,
.timestamp = os_gettime_ns()};
libobs: Add API to hide/show scene items
2015-03-22 20:28:27 -07:00
if (!item)
libobs: Make scene item visibility activate/deactivate Before if a source was set to invisible it would still be considered active. This changes it so that the source is deactivated when the source is invisible to reduce needless resource usage or capturing.
2015-12-22 05:25:31 -08:00
return false;
libobs: Add API to hide/show scene items
2015-03-22 20:28:27 -07:00
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
if (item->user_visible == visible)
libobs: Make scene item visibility activate/deactivate Before if a source was set to invisible it would still be considered active. This changes it so that the source is deactivated when the source is invisible to reduce needless resource usage or capturing.
2015-12-22 05:25:31 -08:00
return false;
libobs: Add API to hide/show scene items
2015-03-22 20:28:27 -07:00
if (!item->parent)
libobs: Make scene item visibility activate/deactivate Before if a source was set to invisible it would still be considered active. This changes it so that the source is deactivated when the source is invisible to reduce needless resource usage or capturing.
2015-12-22 05:25:31 -08:00
return false;
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
obs_sceneitem_do_transition(item, visible);
if (obs_sceneitem_is_group(item))
obs_sceneitem_group_enum_items(item, group_item_transition,
&visible);
item->user_visible = visible;
libobs: Make scene item visibility activate/deactivate Before if a source was set to invisible it would still be considered active. This changes it so that the source is deactivated when the source is invisible to reduce needless resource usage or capturing.
2015-12-22 05:25:31 -08:00
if (visible) {
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
if (os_atomic_inc_long(&item->active_refs) == 1) {
if (!obs_source_add_active_child(item->parent->source,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
item->source)) {
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
os_atomic_dec_long(&item->active_refs);
return false;
}
}
libobs: Make scene item visibility activate/deactivate Before if a source was set to invisible it would still be considered active. This changes it so that the source is deactivated when the source is invisible to reduce needless resource usage or capturing.
2015-12-22 05:25:31 -08:00
}
libobs: Use calldata with stack for simple signals Makes signals use stack memory rather than allocate memory each time. Most likely a completely insignificant and pointless optimization.
2016-01-18 20:01:58 -08:00
calldata_init_fixed(&cd, stack, sizeof(stack));
libobs: Add API to hide/show scene items
2015-03-22 20:28:27 -07:00
calldata_set_ptr(&cd, "item", item);
calldata_set_bool(&cd, "visible", visible);
libobs: Refactor item signaling (add func to signal parent)
2018-06-01 02:34:32 -07:00
signal_parent(item->parent, "item_visible", &cd);
libobs: Buffer scene item visibility actions This buffers scene item visibility actions so that if obs_sceneitem_set_visible to true or false, that it will ensure that the action is mapped to the exact sample point time in which obs_sceneitem_set_visible is called. Mapping to the exact sample point isn't necessary, but it's a nice thing to have.
2015-12-25 01:01:12 -08:00
if (source_has_audio(item->source)) {
pthread_mutex_lock(&item->actions_mutex);
da_push_back(item->audio_actions, &action);
pthread_mutex_unlock(&item->actions_mutex);
} else {
set_visibility(item, visible);
}
libobs: Make scene item visibility activate/deactivate Before if a source was set to invisible it would still be considered active. This changes it so that the source is deactivated when the source is invisible to reduce needless resource usage or capturing.
2015-12-22 05:25:31 -08:00
return true;
libobs: Add API to hide/show scene items
2015-03-22 20:28:27 -07:00
}
libobs: Add obs_scene_atomic_update
2015-06-26 19:18:13 -07:00
UI, libobs: Add ability to lock individual scene items Adds a lock checkbox to allow the user to lock a specific scene item. Closes jp9000/obs-studio#949
2017-06-17 17:10:42 -07:00
bool obs_sceneitem_locked(const obs_sceneitem_t *item)
{
return item ? item->locked : false;
}
bool obs_sceneitem_set_locked(obs_sceneitem_t *item, bool lock)
{
libobs, UI: Implement item_locked event Similar to item_visible, this event fires whenever a scene item is locked or unlocked. This allows the UI and libobs to remain in sync regarding scene elements' statuses.
2019-05-24 04:34:41 -07:00
struct calldata cd;
uint8_t stack[256];
UI, libobs: Add ability to lock individual scene items Adds a lock checkbox to allow the user to lock a specific scene item. Closes jp9000/obs-studio#949
2017-06-17 17:10:42 -07:00
if (!item)
return false;
if (item->locked == lock)
return false;
if (!item->parent)
return false;
item->locked = lock;
libobs, UI: Implement item_locked event Similar to item_visible, this event fires whenever a scene item is locked or unlocked. This allows the UI and libobs to remain in sync regarding scene elements' statuses.
2019-05-24 04:34:41 -07:00
calldata_init_fixed(&cd, stack, sizeof(stack));
calldata_set_ptr(&cd, "item", item);
calldata_set_bool(&cd, "locked", lock);
signal_parent(item->parent, "item_locked", &cd);
UI, libobs: Add ability to lock individual scene items Adds a lock checkbox to allow the user to lock a specific scene item. Closes jp9000/obs-studio#949
2017-06-17 17:10:42 -07:00
return true;
}
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
static bool sceneitems_match(obs_scene_t *scene, obs_sceneitem_t *const *items,
size_t size, bool *order_matches)
libobs: Add obs_scene_reorder_items
2015-06-26 18:47:46 -07:00
{
obs_sceneitem_t *item = scene->first_item;
size_t count = 0;
while (item) {
bool found = false;
for (size_t i = 0; i < size; i++) {
if (items[i] != item)
continue;
if (count != i)
*order_matches = false;
found = true;
break;
}
if (!found)
return false;
item = item->next;
count += 1;
}
return count == size;
}
bool obs_scene_reorder_items(obs_scene_t *scene,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_sceneitem_t *const *item_order,
size_t item_order_size)
libobs: Add obs_scene_reorder_items
2015-06-26 18:47:46 -07:00
{
if (!scene || !item_order_size)
return false;
libobs: Replace addref calls with get_ref
2022-01-24 13:47:56 -08:00
scene = obs_scene_get_ref(scene);
if (!scene)
return false;
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_lock(scene);
libobs: Add obs_scene_reorder_items
2015-06-26 18:47:46 -07:00
bool order_matches = true;
if (!sceneitems_match(scene, item_order, item_order_size,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
&order_matches) ||
order_matches) {
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_unlock(scene);
libobs: Add obs_scene_reorder_items
2015-06-26 18:47:46 -07:00
obs_scene_release(scene);
return false;
}
scene->first_item = item_order[0];
obs_sceneitem_t *prev = NULL;
for (size_t i = 0; i < item_order_size; i++) {
item_order[i]->prev = prev;
item_order[i]->next = NULL;
if (prev)
prev->next = item_order[i];
prev = item_order[i];
}
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_unlock(scene);
libobs: Do not signal reorder while scene mutex locked Prevents a potential race condition with the scene mutex.
2018-06-01 07:44:44 -07:00
signal_reorder(scene->first_item);
libobs: Add obs_scene_reorder_items
2015-06-26 18:47:46 -07:00
obs_scene_release(scene);
return true;
}
libobs: Add obs_scene_atomic_update
2015-06-26 19:18:13 -07:00
void obs_scene_atomic_update(obs_scene_t *scene,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_scene_atomic_update_func func, void *data)
libobs: Add obs_scene_atomic_update
2015-06-26 19:18:13 -07:00
{
if (!scene)
return;
libobs: Replace addref calls with get_ref
2022-01-24 13:47:56 -08:00
scene = obs_scene_get_ref(scene);
if (!scene)
return;
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_lock(scene);
libobs: Add obs_scene_atomic_update
2015-06-26 19:18:13 -07:00
func(data, scene);
libobs: Split scene mutex to improve performance Splits the scene mutex in to an audio/video mutex to allow video/audio thread to use the same data at the same time without locking on each other.
2015-12-17 07:26:40 -08:00
full_unlock(scene);
libobs: Add obs_scene_atomic_update
2015-06-26 19:18:13 -07:00
obs_scene_release(scene);
}
libobs: Add functions to defer scene item update Allows the ability to defer updating the item transform until all functions have been executed.
2016-03-30 18:35:59 -07:00
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
static inline bool crop_equal(const struct obs_sceneitem_crop *crop1,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
const struct obs_sceneitem_crop *crop2)
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
return crop1->left == crop2->left && crop1->right == crop2->right &&
crop1->top == crop2->top && crop1->bottom == crop2->bottom;
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
}
void obs_sceneitem_set_crop(obs_sceneitem_t *item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
const struct obs_sceneitem_crop *crop)
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
{
if (!obs_ptr_valid(item, "obs_sceneitem_set_crop"))
return;
if (!obs_ptr_valid(crop, "obs_sceneitem_set_crop"))
return;
if (crop_equal(crop, &item->crop))
return;
memcpy(&item->crop, crop, sizeof(*crop));
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
if (item->crop.left < 0)
item->crop.left = 0;
if (item->crop.right < 0)
item->crop.right = 0;
if (item->crop.top < 0)
item->crop.top = 0;
if (item->crop.bottom < 0)
item->crop.bottom = 0;
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
libobs: Defer and refactor scene item transform update Defers updating the scene item transform to the graphics thread to reduce the number of transform update calls.
2018-06-01 07:41:33 -07:00
os_atomic_set_bool(&item->update_transform, true);
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
}
void obs_sceneitem_get_crop(const obs_sceneitem_t *item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct obs_sceneitem_crop *crop)
libobs: Add functions to crop individual scene items Renders the scene item to a texture if crop is enabled; otherwise renders directly.
2016-03-30 18:42:25 -07:00
{
if (!obs_ptr_valid(item, "obs_sceneitem_get_crop"))
return;
if (!obs_ptr_valid(crop, "obs_sceneitem_get_crop"))
return;
memcpy(crop, &item->crop, sizeof(*crop));
}
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
void obs_sceneitem_set_scale_filter(obs_sceneitem_t *item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
enum obs_scale_type filter)
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
{
if (!obs_ptr_valid(item, "obs_sceneitem_set_scale_filter"))
return;
item->scale_filter = filter;
libobs: Defer and refactor scene item transform update Defers updating the scene item transform to the graphics thread to reduce the number of transform update calls.
2018-06-01 07:41:33 -07:00
os_atomic_set_bool(&item->update_transform, true);
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
}
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
enum obs_scale_type obs_sceneitem_get_scale_filter(obs_sceneitem_t *item)
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
{
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
return obs_ptr_valid(item, "obs_sceneitem_get_scale_filter")
? item->scale_filter
: OBS_SCALE_DISABLE;
libobs: Add ability to use scale filters on scene items Allows the ability to use scale filters such as point, bicubic, lanczos on specific scene items, disabled by default. When using one of the latter two options, if the item's scale is under half of the source's original size, it uses the bilinear low resolution downscale shader instead.
2016-06-29 06:08:54 -07:00
}
libobs: Add support for nonlinear SRGB blending
2022-03-31 19:15:10 -07:00
void obs_sceneitem_set_blending_method(obs_sceneitem_t *item,
enum obs_blending_method method)
{
if (!obs_ptr_valid(item, "obs_sceneitem_set_blending_method"))
return;
item->blend_method = method;
}
enum obs_blending_method
obs_sceneitem_get_blending_method(obs_sceneitem_t *item)
{
return obs_ptr_valid(item, "obs_sceneitem_get_blending_method")
? item->blend_method
libobs: Fix wrong enum in obs_sceneitem_get_blending_method Detected by PVS Studio.
2022-04-18 18:09:55 -07:00
: OBS_BLEND_METHOD_DEFAULT;
libobs: Add support for nonlinear SRGB blending
2022-03-31 19:15:10 -07:00
}
libobs: Implement additional source blending modes
2021-10-24 08:45:15 -07:00
void obs_sceneitem_set_blending_mode(obs_sceneitem_t *item,
enum obs_blending_type type)
{
if (!obs_ptr_valid(item, "obs_sceneitem_set_blending_mode"))
return;
item->blend_type = type;
os_atomic_set_bool(&item->update_transform, true);
}
enum obs_blending_type obs_sceneitem_get_blending_mode(obs_sceneitem_t *item)
{
return obs_ptr_valid(item, "obs_sceneitem_get_blending_mode")
? item->blend_type
: OBS_BLEND_NORMAL;
}
libobs: Add functions to defer scene item update Allows the ability to defer updating the item transform until all functions have been executed.
2016-03-30 18:35:59 -07:00
void obs_sceneitem_defer_update_begin(obs_sceneitem_t *item)
{
if (!obs_ptr_valid(item, "obs_sceneitem_defer_update_begin"))
return;
os_atomic_inc_long(&item->defer_update);
}
void obs_sceneitem_defer_update_end(obs_sceneitem_t *item)
{
if (!obs_ptr_valid(item, "obs_sceneitem_defer_update_end"))
return;
if (os_atomic_dec_long(&item->defer_update) == 0)
libobs: Always try to update transform in current thread Due to the recent change in which scene items now only update their transforms during the next frame's tick, snapping sources would sometimes jitter and have incorrect snapping. This fixes that issue by reverting to the behavior of updating the transform immediately rather than deferring the update to the next frame tick, but only on non-group items. This should not be done on items that are sub-items of groups because we rely on the obs_scene_item::update_transform variable to update the parent group's transform in addition.
2018-07-24 01:54:04 -07:00
do_update_transform(item);
libobs: Add functions to defer scene item update Allows the ability to defer updating the item transform until all functions have been executed.
2016-03-30 18:35:59 -07:00
}
libobs: Add scene item IDs Adds a method of uniquely identifying scene items, as well as finding those scene items via that unique ID.
2017-05-15 00:13:28 -07:00
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
void obs_sceneitem_defer_group_resize_begin(obs_sceneitem_t *item)
{
if (!obs_ptr_valid(item, "obs_sceneitem_defer_group_resize_begin"))
return;
os_atomic_inc_long(&item->defer_group_resize);
}
void obs_sceneitem_defer_group_resize_end(obs_sceneitem_t *item)
{
if (!obs_ptr_valid(item, "obs_sceneitem_defer_group_resize_end"))
return;
if (os_atomic_dec_long(&item->defer_group_resize) == 0)
os_atomic_set_bool(&item->update_group_resize, true);
}
libobs: Add scene item IDs Adds a method of uniquely identifying scene items, as well as finding those scene items via that unique ID.
2017-05-15 00:13:28 -07:00
int64_t obs_sceneitem_get_id(const obs_sceneitem_t *item)
{
if (!obs_ptr_valid(item, "obs_sceneitem_get_id"))
return 0;
return item->id;
}
libobs: Add private settings to scene items/sources Allows setting and sharing of user data for sources and scene items.
2017-09-13 03:12:56 -07:00
UI/libobs: Undo/Redo Sources and Scenes Implements the Undo/Redo for scenes and sources, ranging from renaming, deletion, addition. It also adds several elements to libobs that were designed to facilitate undo/redo, and should not affect the rest of libobs.
2021-03-21 21:39:02 -07:00
void obs_sceneitem_set_id(obs_sceneitem_t *item, int64_t id)
{
item->id = id;
}
libobs: Add private settings to scene items/sources Allows setting and sharing of user data for sources and scene items.
2017-09-13 03:12:56 -07:00
obs_data_t *obs_sceneitem_get_private_settings(obs_sceneitem_t *item)
{
if (!obs_ptr_valid(item, "obs_sceneitem_get_private_settings"))
return NULL;
obs_data_addref(item->private_settings);
return item->private_settings;
}
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
libobs: Add missing return type As declared, transform_val is static inline, but it should be marked as a static inline void since it does not return.
2018-07-01 09:01:47 -07:00
static inline void transform_val(struct vec2 *v2, struct matrix4 *transform)
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
{
struct vec3 v;
vec3_set(&v, v2->x, v2->y, 0.0f);
vec3_transform(&v, &v, transform);
v2->x = v.x;
v2->y = v.y;
}
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
static void get_ungrouped_transform(obs_sceneitem_t *group, struct vec2 *pos,
struct vec2 *scale, float *rot)
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
{
struct matrix4 transform;
struct matrix4 mat;
struct vec4 x_base;
vec4_set(&x_base, 1.0f, 0.0f, 0.0f, 0.0f);
matrix4_copy(&transform, &group->draw_transform);
transform_val(pos, &transform);
vec4_set(&transform.t, 0.0f, 0.0f, 0.0f, 1.0f);
vec4_set(&mat.x, scale->x, 0.0f, 0.0f, 0.0f);
vec4_set(&mat.y, 0.0f, scale->y, 0.0f, 0.0f);
vec4_set(&mat.z, 0.0f, 0.0f, 1.0f, 0.0f);
vec4_set(&mat.t, 0.0f, 0.0f, 0.0f, 1.0f);
matrix4_mul(&mat, &mat, &transform);
libobs: Fix applying group transform of flipped sources Fixes a bug where sources that are flipped vertically and/or horizontally would not maintain their flipped state.
2018-08-15 10:02:05 -07:00
scale->x = vec4_len(&mat.x) * (scale->x > 0.0f ? 1.0f : -1.0f);
scale->y = vec4_len(&mat.y) * (scale->y > 0.0f ? 1.0f : -1.0f);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
*rot += group->rot;
}
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
static void remove_group_transform(obs_sceneitem_t *group,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_sceneitem_t *item)
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
{
obs_scene_t *parent = item->parent;
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
if (!parent || !group)
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
return;
get_ungrouped_transform(group, &item->pos, &item->scale, &item->rot);
libobs: Only update scene item texture on frame tick Instead of updating the scene item texture any time update_item_transform() is called, only update it when obs_scene_item::update_transform is called. Prevents having to lock the graphics mutex needlessly.
2018-07-24 02:28:43 -07:00
update_item_transform(item, false);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
}
static void apply_group_transform(obs_sceneitem_t *item, obs_sceneitem_t *group)
{
struct matrix4 transform;
struct matrix4 mat;
struct vec4 x_base;
vec4_set(&x_base, 1.0f, 0.0f, 0.0f, 0.0f);
matrix4_inv(&transform, &group->draw_transform);
transform_val(&item->pos, &transform);
vec4_set(&transform.t, 0.0f, 0.0f, 0.0f, 1.0f);
vec4_set(&mat.x, item->scale.x, 0.0f, 0.0f, 0.0f);
vec4_set(&mat.y, 0.0f, item->scale.y, 0.0f, 0.0f);
vec4_set(&mat.z, 0.0f, 0.0f, 1.0f, 0.0f);
vec4_set(&mat.t, 0.0f, 0.0f, 0.0f, 1.0f);
matrix4_mul(&mat, &mat, &transform);
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
item->scale.x =
vec4_len(&mat.x) * (item->scale.x > 0.0f ? 1.0f : -1.0f);
item->scale.y =
vec4_len(&mat.y) * (item->scale.y > 0.0f ? 1.0f : -1.0f);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
item->rot -= group->rot;
libobs: Only update scene item texture on frame tick Instead of updating the scene item texture any time update_item_transform() is called, only update it when obs_scene_item::update_transform is called. Prevents having to lock the graphics mutex needlessly.
2018-07-24 02:28:43 -07:00
update_item_transform(item, false);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
}
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
static bool resize_scene_base(obs_scene_t *scene, struct vec2 *minv,
struct vec2 *maxv, struct vec2 *scale)
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
{
libobs: Abstract resize_group to resize_scene_base
2018-07-15 18:40:49 -07:00
vec2_set(minv, M_INFINITE, M_INFINITE);
vec2_set(maxv, -M_INFINITE, -M_INFINITE);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
obs_sceneitem_t *item = scene->first_item;
if (!item) {
scene->cx = 0;
scene->cy = 0;
libobs: Abstract resize_group to resize_scene_base
2018-07-15 18:40:49 -07:00
return false;
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
}
while (item) {
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
#define get_min_max(x_val, y_val) \
do { \
struct vec3 v; \
vec3_set(&v, x_val, y_val, 0.0f); \
vec3_transform(&v, &v, &item->box_transform); \
if (v.x < minv->x) \
minv->x = v.x; \
if (v.y < minv->y) \
minv->y = v.y; \
if (v.x > maxv->x) \
maxv->x = v.x; \
if (v.y > maxv->y) \
maxv->y = v.y; \
} while (false)
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
get_min_max(0.0f, 0.0f);
get_min_max(1.0f, 0.0f);
get_min_max(0.0f, 1.0f);
get_min_max(1.0f, 1.0f);
#undef get_min_max
item = item->next;
}
item = scene->first_item;
while (item) {
libobs: Abstract resize_group to resize_scene_base
2018-07-15 18:40:49 -07:00
vec2_sub(&item->pos, &item->pos, minv);
libobs: Only update scene item texture on frame tick Instead of updating the scene item texture any time update_item_transform() is called, only update it when obs_scene_item::update_transform is called. Prevents having to lock the graphics mutex needlessly.
2018-07-24 02:28:43 -07:00
update_item_transform(item, false);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
item = item->next;
}
libobs: Abstract resize_group to resize_scene_base
2018-07-15 18:40:49 -07:00
vec2_sub(scale, maxv, minv);
scene->cx = (uint32_t)ceilf(scale->x);
scene->cy = (uint32_t)ceilf(scale->y);
return true;
}
static void resize_scene(obs_scene_t *scene)
{
struct vec2 minv;
struct vec2 maxv;
struct vec2 scale;
resize_scene_base(scene, &minv, &maxv, &scale);
}
/* assumes group scene and parent scene is locked */
static void resize_group(obs_sceneitem_t *group)
{
obs_scene_t *scene = group->source->context.data;
struct vec2 minv;
struct vec2 maxv;
struct vec2 scale;
if (os_atomic_load_long(&group->defer_group_resize) > 0)
return;
if (!resize_scene_base(scene, &minv, &maxv, &scale))
return;
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
if (group->bounds_type == OBS_BOUNDS_NONE) {
struct vec2 new_pos;
if ((group->align & OBS_ALIGN_LEFT) != 0)
new_pos.x = minv.x;
else if ((group->align & OBS_ALIGN_RIGHT) != 0)
new_pos.x = maxv.x;
else
new_pos.x = (maxv.x - minv.x) * 0.5f + minv.x;
if ((group->align & OBS_ALIGN_TOP) != 0)
new_pos.y = minv.y;
else if ((group->align & OBS_ALIGN_BOTTOM) != 0)
new_pos.y = maxv.y;
else
new_pos.y = (maxv.y - minv.y) * 0.5f + minv.y;
transform_val(&new_pos, &group->draw_transform);
vec2_copy(&group->pos, &new_pos);
}
os_atomic_set_bool(&group->update_group_resize, false);
libobs: Only update scene item texture on frame tick Instead of updating the scene item texture any time update_item_transform() is called, only update it when obs_scene_item::update_transform is called. Prevents having to lock the graphics mutex needlessly.
2018-07-24 02:28:43 -07:00
update_item_transform(group, false);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
}
obs_sceneitem_t *obs_scene_add_group(obs_scene_t *scene, const char *name)
{
return obs_scene_insert_group(scene, name, NULL, 0);
}
libobs: Add group functions that can signal refresh Adds API: obs_scene_add_group2 obs_scene_insert_group2 obs_sceneitem_group_ungroup2 These functions should be used by plugins if they need to use these functions and need to send a refresh signal. If a major API rework ever happens the old functions should be removed. The old functions should eventually be deprecated. The reason why specifying a 'signal' parameter is useful is because it's a bit more seamless for the user interface to be able to have custom handling of these specific cases. It looks better and doesn't require completely erasing/recreating the entire list, which is visually unappealing.
2020-02-07 16:41:44 -08:00
obs_sceneitem_t *obs_scene_add_group2(obs_scene_t *scene, const char *name,
bool signal)
{
return obs_scene_insert_group2(scene, name, NULL, 0, signal);
}
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_sceneitem_t *obs_scene_insert_group(obs_scene_t *scene, const char *name,
obs_sceneitem_t **items, size_t count)
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
{
if (!scene)
return NULL;
/* don't allow groups or sub-items of other groups */
for (size_t i = count; i > 0; i--) {
obs_sceneitem_t *item = items[i - 1];
if (item->parent != scene || item->is_group)
return NULL;
}
libobs: Change groups to actual public types (This commit also modifies UI) Changes groups to their own independent type, "group". This allows them to be used like other regular types, and allows the ability to reference groups in multiple scenes. Before, a group would always be linked to the scene it was in. This made it cumbersome for users to modify groups if they had a similar group in multiple scenes (they would have to modify each group in each scene). Making groups like other source types makes more sense to solve this issue so they can be referenced in multiple scenes at once. This also removes a significant amount of group-specific handling code required for implementing groups in the front-end. One limitation however: due to the way sub-items of groups are seamlessly modifiable and sortable as part of the whole scene, the user cannot have multiple references to the same group within one scene.
2018-07-15 18:50:33 -07:00
obs_scene_t *sub_scene = create_id("group", name);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
obs_sceneitem_t *last_item = items ? items[count - 1] : NULL;
libobs: Remove unused parameters
2022-07-19 23:07:04 -07:00
obs_sceneitem_t *item =
obs_scene_add_internal(scene, sub_scene->source, last_item);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
obs_scene_release(sub_scene);
if (!items || !count)
return item;
/* ------------------------- */
full_lock(scene);
full_lock(sub_scene);
libobs: Remove unnecessary null check
2018-08-10 16:55:49 -07:00
sub_scene->first_item = items[0];
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
for (size_t i = count; i > 0; i--) {
size_t idx = i - 1;
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
remove_group_transform(item, items[idx]);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
detach_sceneitem(items[idx]);
}
for (size_t i = 0; i < count; i++) {
size_t idx = i;
if (idx != (count - 1)) {
size_t next_idx = idx + 1;
items[idx]->next = items[next_idx];
items[next_idx]->prev = items[idx];
} else {
items[idx]->next = NULL;
}
items[idx]->parent = sub_scene;
apply_group_transform(items[idx], item);
}
items[0]->prev = NULL;
resize_group(item);
full_unlock(sub_scene);
full_unlock(scene);
libobs,UI: Issue appropriate signals on group / ungroup Due to the way the frontend works, the logic for inserting the row for the group in the UI was dropped since the new item_add message will insert one automatically since it forces a refresh of the scene items. The reliance on that implicit row insertion when grouping items is a bit of a code smell, although the alternative would be to add logic to disable handling the signal for that instant, which is probably a worse choice.
2022-04-13 02:52:25 -07:00
struct calldata params;
uint8_t stack[128];
calldata_init_fixed(&params, stack, sizeof(stack));
calldata_set_ptr(&params, "scene", scene);
calldata_set_ptr(&params, "item", item);
signal_handler_signal(scene->source->context.signals, "item_add",
&params);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
/* ------------------------- */
return item;
}
libobs: Add group functions that can signal refresh Adds API: obs_scene_add_group2 obs_scene_insert_group2 obs_sceneitem_group_ungroup2 These functions should be used by plugins if they need to use these functions and need to send a refresh signal. If a major API rework ever happens the old functions should be removed. The old functions should eventually be deprecated. The reason why specifying a 'signal' parameter is useful is because it's a bit more seamless for the user interface to be able to have custom handling of these specific cases. It looks better and doesn't require completely erasing/recreating the entire list, which is visually unappealing.
2020-02-07 16:41:44 -08:00
obs_sceneitem_t *obs_scene_insert_group2(obs_scene_t *scene, const char *name,
obs_sceneitem_t **items, size_t count,
bool signal)
{
obs_sceneitem_t *item =
obs_scene_insert_group(scene, name, items, count);
if (signal && item)
signal_refresh(scene);
return item;
}
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
obs_sceneitem_t *obs_scene_get_group(obs_scene_t *scene, const char *name)
{
if (!scene || !name || !*name) {
return NULL;
}
obs_sceneitem_t *group = NULL;
obs_sceneitem_t *item;
full_lock(scene);
item = scene->first_item;
while (item) {
if (item->is_group && item->source->context.name) {
if (strcmp(item->source->context.name, name) == 0) {
group = item;
break;
}
}
item = item->next;
}
full_unlock(scene);
return group;
}
bool obs_sceneitem_is_group(obs_sceneitem_t *item)
{
return item && item->is_group;
}
obs_scene_t *obs_sceneitem_group_get_scene(const obs_sceneitem_t *item)
{
return (item && item->is_group) ? item->source->context.data : NULL;
}
void obs_sceneitem_group_ungroup(obs_sceneitem_t *item)
{
if (!item || !item->is_group)
return;
obs_scene_t *scene = item->parent;
obs_scene_t *subscene = item->source->context.data;
libobs: When ungrouping groups, duplicate items Because groups can now be used in multiple scenes at once, it's important that if the user wishes to ungroup a group, that they must be able to keep the group intact if it exists in other scenes. This requires duplicating all scene items (as well as their hotkey/private data) instead of just reparenting the subitems. This fixes an issue where if the user had the group referenced in multiple scenes, the group would become empty in other scenes.
2018-08-05 04:11:22 -07:00
obs_sceneitem_t *insert_after = item;
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
obs_sceneitem_t *first;
obs_sceneitem_t *last;
libobs,UI: Issue appropriate signals on group / ungroup Due to the way the frontend works, the logic for inserting the row for the group in the UI was dropped since the new item_add message will insert one automatically since it forces a refresh of the scene items. The reliance on that implicit row insertion when grouping items is a bit of a code smell, although the alternative would be to add logic to disable handling the signal for that instant, which is probably a worse choice.
2022-04-13 02:52:25 -07:00
signal_item_remove(item);
libobs: When ungrouping groups, duplicate items Because groups can now be used in multiple scenes at once, it's important that if the user wishes to ungroup a group, that they must be able to keep the group intact if it exists in other scenes. This requires duplicating all scene items (as well as their hotkey/private data) instead of just reparenting the subitems. This fixes an issue where if the user had the group referenced in multiple scenes, the group would become empty in other scenes.
2018-08-05 04:11:22 -07:00
full_lock(scene);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
/* ------------------------- */
full_lock(subscene);
first = subscene->first_item;
last = first;
while (last) {
libobs: When ungrouping groups, duplicate items Because groups can now be used in multiple scenes at once, it's important that if the user wishes to ungroup a group, that they must be able to keep the group intact if it exists in other scenes. This requires duplicating all scene items (as well as their hotkey/private data) instead of just reparenting the subitems. This fixes an issue where if the user had the group referenced in multiple scenes, the group would become empty in other scenes.
2018-08-05 04:11:22 -07:00
obs_sceneitem_t *dst;
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
remove_group_transform(item, last);
libobs: Remove unused parameters
2022-07-19 23:07:04 -07:00
dst = obs_scene_add_internal(scene, last->source, insert_after);
libobs: When ungrouping groups, duplicate items Because groups can now be used in multiple scenes at once, it's important that if the user wishes to ungroup a group, that they must be able to keep the group intact if it exists in other scenes. This requires duplicating all scene items (as well as their hotkey/private data) instead of just reparenting the subitems. This fixes an issue where if the user had the group referenced in multiple scenes, the group would become empty in other scenes.
2018-08-05 04:11:22 -07:00
duplicate_item_data(dst, last, true, true, true);
apply_group_transform(last, item);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
if (!last->next)
break;
libobs: When ungrouping groups, duplicate items Because groups can now be used in multiple scenes at once, it's important that if the user wishes to ungroup a group, that they must be able to keep the group intact if it exists in other scenes. This requires duplicating all scene items (as well as their hotkey/private data) instead of just reparenting the subitems. This fixes an issue where if the user had the group referenced in multiple scenes, the group would become empty in other scenes.
2018-08-05 04:11:22 -07:00
insert_after = dst;
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
last = last->next;
}
full_unlock(subscene);
/* ------------------------- */
libobs: When ungrouping groups, duplicate items Because groups can now be used in multiple scenes at once, it's important that if the user wishes to ungroup a group, that they must be able to keep the group intact if it exists in other scenes. This requires duplicating all scene items (as well as their hotkey/private data) instead of just reparenting the subitems. This fixes an issue where if the user had the group referenced in multiple scenes, the group would become empty in other scenes.
2018-08-05 04:11:22 -07:00
detach_sceneitem(item);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
full_unlock(scene);
obs_sceneitem_release(item);
}
libobs: Add group functions that can signal refresh Adds API: obs_scene_add_group2 obs_scene_insert_group2 obs_sceneitem_group_ungroup2 These functions should be used by plugins if they need to use these functions and need to send a refresh signal. If a major API rework ever happens the old functions should be removed. The old functions should eventually be deprecated. The reason why specifying a 'signal' parameter is useful is because it's a bit more seamless for the user interface to be able to have custom handling of these specific cases. It looks better and doesn't require completely erasing/recreating the entire list, which is visually unappealing.
2020-02-07 16:41:44 -08:00
void obs_sceneitem_group_ungroup2(obs_sceneitem_t *item, bool signal)
{
obs_scene_t *scene = item->parent;
obs_sceneitem_group_ungroup(item);
if (signal)
signal_refresh(scene);
}
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
void obs_sceneitem_group_add_item(obs_sceneitem_t *group, obs_sceneitem_t *item)
{
if (!group || !group->is_group || !item)
return;
obs_scene_t *scene = group->parent;
obs_scene_t *groupscene = group->source->context.data;
if (item->parent != scene)
return;
libobs: fix obs_sceneitem_group_XXX_item API `obs_sceneitem_group_add_item` and `obs_Sceneitem_group_remove_item` were leaving the affected scene in an inconsistent state. To resolve, simplify and make the code more readable, we replace the manual linked lists mutation with existing `detach_sceneitem` and `attach_sceneitem` calls.
2020-02-08 03:17:02 -08:00
if (item->parent == groupscene)
return;
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
/* ------------------------- */
full_lock(scene);
libobs: fix obs_sceneitem_group_XXX_item API `obs_sceneitem_group_add_item` and `obs_Sceneitem_group_remove_item` were leaving the affected scene in an inconsistent state. To resolve, simplify and make the code more readable, we replace the manual linked lists mutation with existing `detach_sceneitem` and `attach_sceneitem` calls.
2020-02-08 03:17:02 -08:00
full_lock(groupscene);
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
remove_group_transform(group, item);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
libobs: fix obs_sceneitem_group_XXX_item API `obs_sceneitem_group_add_item` and `obs_Sceneitem_group_remove_item` were leaving the affected scene in an inconsistent state. To resolve, simplify and make the code more readable, we replace the manual linked lists mutation with existing `detach_sceneitem` and `attach_sceneitem` calls.
2020-02-08 03:17:02 -08:00
detach_sceneitem(item);
attach_sceneitem(groupscene, item, NULL);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
apply_group_transform(item, group);
libobs: fix obs_sceneitem_group_XXX_item API `obs_sceneitem_group_add_item` and `obs_Sceneitem_group_remove_item` were leaving the affected scene in an inconsistent state. To resolve, simplify and make the code more readable, we replace the manual linked lists mutation with existing `detach_sceneitem` and `attach_sceneitem` calls.
2020-02-08 03:17:02 -08:00
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
resize_group(group);
libobs: fix obs_sceneitem_group_XXX_item API `obs_sceneitem_group_add_item` and `obs_Sceneitem_group_remove_item` were leaving the affected scene in an inconsistent state. To resolve, simplify and make the code more readable, we replace the manual linked lists mutation with existing `detach_sceneitem` and `attach_sceneitem` calls.
2020-02-08 03:17:02 -08:00
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
full_unlock(groupscene);
libobs: fix obs_sceneitem_group_XXX_item API `obs_sceneitem_group_add_item` and `obs_Sceneitem_group_remove_item` were leaving the affected scene in an inconsistent state. To resolve, simplify and make the code more readable, we replace the manual linked lists mutation with existing `detach_sceneitem` and `attach_sceneitem` calls.
2020-02-08 03:17:02 -08:00
full_unlock(scene);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
/* ------------------------- */
libobs: Make group subitem add/remove funcs signal refresh Fixes a bug where the UI would not know that a group had been updated.
2020-02-07 16:37:15 -08:00
signal_refresh(scene);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
}
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
void obs_sceneitem_group_remove_item(obs_sceneitem_t *group,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_sceneitem_t *item)
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
{
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
if (!item || !group || !group->is_group)
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
return;
obs_scene_t *groupscene = item->parent;
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
obs_scene_t *scene = group->parent;
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
/* ------------------------- */
full_lock(scene);
full_lock(groupscene);
libobs: fix obs_sceneitem_group_XXX_item API `obs_sceneitem_group_add_item` and `obs_Sceneitem_group_remove_item` were leaving the affected scene in an inconsistent state. To resolve, simplify and make the code more readable, we replace the manual linked lists mutation with existing `detach_sceneitem` and `attach_sceneitem` calls.
2020-02-08 03:17:02 -08:00
remove_group_transform(group, item);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
libobs: fix obs_sceneitem_group_XXX_item API `obs_sceneitem_group_add_item` and `obs_Sceneitem_group_remove_item` were leaving the affected scene in an inconsistent state. To resolve, simplify and make the code more readable, we replace the manual linked lists mutation with existing `detach_sceneitem` and `attach_sceneitem` calls.
2020-02-08 03:17:02 -08:00
detach_sceneitem(item);
attach_sceneitem(scene, item, NULL);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
resize_group(group);
libobs: fix obs_sceneitem_group_XXX_item API `obs_sceneitem_group_add_item` and `obs_Sceneitem_group_remove_item` were leaving the affected scene in an inconsistent state. To resolve, simplify and make the code more readable, we replace the manual linked lists mutation with existing `detach_sceneitem` and `attach_sceneitem` calls.
2020-02-08 03:17:02 -08:00
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
full_unlock(groupscene);
full_unlock(scene);
libobs: Make group subitem add/remove funcs signal refresh Fixes a bug where the UI would not know that a group had been updated.
2020-02-07 16:37:15 -08:00
libobs: fix obs_sceneitem_group_XXX_item API `obs_sceneitem_group_add_item` and `obs_Sceneitem_group_remove_item` were leaving the affected scene in an inconsistent state. To resolve, simplify and make the code more readable, we replace the manual linked lists mutation with existing `detach_sceneitem` and `attach_sceneitem` calls.
2020-02-08 03:17:02 -08:00
/* ------------------------- */
libobs: Make group subitem add/remove funcs signal refresh Fixes a bug where the UI would not know that a group had been updated.
2020-02-07 16:37:15 -08:00
signal_refresh(scene);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
}
libobs: Restore order
2020-02-09 18:36:58 -08:00
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
static void
build_current_order_info(obs_scene_t *scene,
struct obs_sceneitem_order_info **items_out,
size_t *size_out)
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
{
DARRAY(struct obs_sceneitem_order_info) items;
da_init(items);
obs_sceneitem_t *item = scene->first_item;
while (item) {
libobs: Fix stack buffer overflow in build_current_order_info
2021-07-18 23:17:53 -07:00
struct obs_sceneitem_order_info info = {0};
info.item = item;
da_push_back(items, &info);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
if (item->is_group) {
obs_scene_t *sub_scene = item->source->context.data;
full_lock(sub_scene);
obs_sceneitem_t *sub_item = sub_scene->first_item;
while (sub_item) {
libobs: Fix stack buffer overflow in build_current_order_info
2021-07-18 23:17:53 -07:00
info.group = item;
info.item = sub_item;
da_push_back(items, &info);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
sub_item = sub_item->next;
}
full_unlock(sub_scene);
}
item = item->next;
}
*items_out = items.array;
*size_out = items.num;
}
static bool sceneitems_match2(obs_scene_t *scene,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct obs_sceneitem_order_info *items,
size_t size)
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
{
struct obs_sceneitem_order_info *cur_items;
size_t cur_size;
build_current_order_info(scene, &cur_items, &cur_size);
if (cur_size != size) {
bfree(cur_items);
return false;
}
for (size_t i = 0; i < size; i++) {
struct obs_sceneitem_order_info *new = &items[i];
struct obs_sceneitem_order_info *old = &cur_items[i];
libobs: Fix equality check Removes a likely unintentional self-comparison.
2018-06-30 12:25:39 -07:00
if (new->group != old->group || new->item != old->item) {
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
bfree(cur_items);
return false;
}
}
bfree(cur_items);
return true;
}
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
static obs_sceneitem_t *
get_sceneitem_parent_group(obs_scene_t *scene, obs_sceneitem_t *group_subitem)
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
{
if (group_subitem->is_group)
return NULL;
obs_sceneitem_t *item = scene->first_item;
while (item) {
if (item->is_group &&
item->source->context.data == group_subitem->parent)
return item;
item = item->next;
}
return NULL;
}
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
bool obs_scene_reorder_items2(obs_scene_t *scene,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
struct obs_sceneitem_order_info *item_order,
size_t item_order_size)
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
{
if (!scene || !item_order_size || !item_order)
return false;
libobs: Replace addref calls with get_ref
2022-01-24 13:47:56 -08:00
scene = obs_scene_get_ref(scene);
if (!scene)
return false;
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
full_lock(scene);
if (sceneitems_match2(scene, item_order, item_order_size)) {
full_unlock(scene);
obs_scene_release(scene);
return false;
}
for (size_t i = 0; i < item_order_size; i++) {
struct obs_sceneitem_order_info *info = &item_order[i];
if (!info->item->is_group) {
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
obs_sceneitem_t *group =
get_sceneitem_parent_group(scene, info->item);
remove_group_transform(group, info->item);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
}
}
scene->first_item = item_order[0].item;
obs_sceneitem_t *prev = NULL;
for (size_t i = 0; i < item_order_size; i++) {
struct obs_sceneitem_order_info *info = &item_order[i];
obs_sceneitem_t *item = info->item;
if (info->item->is_group) {
obs_sceneitem_t *sub_prev = NULL;
obs_scene_t *sub_scene =
info->item->source->context.data;
sub_scene->first_item = NULL;
obs_scene_addref(sub_scene);
full_lock(sub_scene);
for (i++; i < item_order_size; i++) {
struct obs_sceneitem_order_info *sub_info =
&item_order[i];
obs_sceneitem_t *sub_item = sub_info->item;
if (sub_info->group != info->item) {
i--;
break;
}
if (!sub_scene->first_item)
sub_scene->first_item = sub_item;
sub_item->prev = sub_prev;
sub_item->next = NULL;
sub_item->parent = sub_scene;
if (sub_prev)
sub_prev->next = sub_item;
apply_group_transform(sub_info->item,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
sub_info->group);
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
sub_prev = sub_item;
}
resize_group(info->item);
full_unlock(sub_scene);
obs_scene_release(sub_scene);
}
item->prev = prev;
item->next = NULL;
item->parent = scene;
if (prev)
prev->next = item;
prev = item;
}
full_unlock(scene);
signal_reorder(scene->first_item);
obs_scene_release(scene);
return true;
}
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
obs_sceneitem_t *obs_sceneitem_get_group(obs_scene_t *scene,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_sceneitem_t *group_subitem)
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
{
if (!scene || !group_subitem || group_subitem->is_group)
return NULL;
full_lock(scene);
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
obs_sceneitem_t *group =
get_sceneitem_parent_group(scene, group_subitem);
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
full_unlock(scene);
return group;
}
bool obs_source_is_group(const obs_source_t *source)
{
libobs: Fix groups not being recognized as groups The id of the source was being pointer compared rather than string compared, so naturally with the source versioning system where the string is duplicated, the pointers no longer matched.
2020-03-09 17:08:51 -07:00
return source && strcmp(source->info.id, group_info.id) == 0;
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
}
libobs: Add obs_source_is_scene()
2021-04-09 04:13:41 -07:00
bool obs_source_is_scene(const obs_source_t *source)
{
return source && strcmp(source->info.id, scene_info.id) == 0;
}
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
bool obs_scene_is_group(const obs_scene_t *scene)
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
{
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
return scene ? scene->is_group : false;
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
}
void obs_sceneitem_group_enum_items(obs_sceneitem_t *group,
clang-format: Apply formatting Code submissions have continually suffered from formatting inconsistencies that constantly have to be addressed. Using clang-format simplifies this by making code formatting more consistent, and allows automation of the code formatting so that maintainers can focus more on the code itself instead of code formatting.
2019-06-22 22:13:45 -07:00
bool (*callback)(obs_scene_t *,
obs_sceneitem_t *, void *),
void *param)
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
{
libobs: Remove group_sceneitem from obs_scene struct (This commit also modifies UI) Removes obs_scene::group_sceneitem and replaces it with obs_scene::is_group. Changes a number of other functions related to groups so that a group is not inherently tied to a specific scene, and helps allow a single group to be referenced in multiple scenes if desired.
2018-07-15 18:18:25 -07:00
if (!group || !group->is_group)
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
return;
libobs: Change groups to actual public types (This commit also modifies UI) Changes groups to their own independent type, "group". This allows them to be used like other regular types, and allows the ability to reference groups in multiple scenes. Before, a group would always be linked to the scene it was in. This made it cumbersome for users to modify groups if they had a similar group in multiple scenes (they would have to modify each group in each scene). Making groups like other source types makes more sense to solve this issue so they can be referenced in multiple scenes at once. This also removes a significant amount of group-specific handling code required for implementing groups in the front-end. One limitation however: due to the way sub-items of groups are seamlessly modifiable and sortable as part of the whole scene, the user cannot have multiple references to the same group within one scene.
2018-07-15 18:50:33 -07:00
obs_scene_t *scene = group->source->context.data;
libobs: Add scene item grouping Allows the ability to group scene items. Groups internally are sub-scenes, which allows the ability to add unique filters and transforms to each group.
2018-06-01 08:25:49 -07:00
if (scene)
obs_scene_enum_items(scene, callback, param);
}
libobs: Add function to force a sceneitem transform update Useful when you need to modify transform properties of group sub-items and have the transform available immediately (group sub-items always automatically defer their transform update to the next frame).
2018-08-16 08:42:19 -07:00
void obs_sceneitem_force_update_transform(obs_sceneitem_t *item)
{
if (!item)
return;
if (os_atomic_set_bool(&item->update_transform, false))
update_item_transform(item, false);
}
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
void obs_sceneitem_set_show_transition(obs_sceneitem_t *item,
obs_source_t *transition)
{
if (!item)
return;
if (item->show_transition)
obs_source_release(item->show_transition);
libobs: Replace addref calls with get_ref
2022-01-24 13:47:56 -08:00
item->show_transition = obs_source_get_ref(transition);
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
}
void obs_sceneitem_set_show_transition_duration(obs_sceneitem_t *item,
uint32_t duration_ms)
{
if (!item)
return;
item->show_transition_duration = duration_ms;
}
obs_source_t *obs_sceneitem_get_show_transition(obs_sceneitem_t *item)
{
if (!item)
return NULL;
return item->show_transition;
}
uint32_t obs_sceneitem_get_show_transition_duration(obs_sceneitem_t *item)
{
if (!item)
return 0;
return item->show_transition_duration;
}
void obs_sceneitem_set_hide_transition(obs_sceneitem_t *item,
obs_source_t *transition)
{
if (!item)
return;
if (item->hide_transition)
obs_source_release(item->hide_transition);
libobs: Replace addref calls with get_ref
2022-01-24 13:47:56 -08:00
item->hide_transition = obs_source_get_ref(transition);
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
}
void obs_sceneitem_set_hide_transition_duration(obs_sceneitem_t *item,
uint32_t duration_ms)
{
if (!item)
return;
item->hide_transition_duration = duration_ms;
}
obs_source_t *obs_sceneitem_get_hide_transition(obs_sceneitem_t *item)
{
if (!item)
return NULL;
return item->hide_transition;
}
uint32_t obs_sceneitem_get_hide_transition_duration(obs_sceneitem_t *item)
{
if (!item)
return 0;
return item->hide_transition_duration;
}
libobs: Refactor hide/show transition functions Having two separate functions for each hide/show transition action is silly and makes code awful.
2022-03-24 22:32:41 -07:00
void obs_sceneitem_set_transition(obs_sceneitem_t *item, bool show,
obs_source_t *transition)
{
if (!item)
return;
obs_source_t **target = show ? &item->show_transition
: &item->hide_transition;
if (*target)
obs_source_release(*target);
*target = obs_source_get_ref(transition);
}
obs_source_t *obs_sceneitem_get_transition(obs_sceneitem_t *item, bool show)
{
if (!item)
return NULL;
return show ? item->show_transition : item->hide_transition;
}
void obs_sceneitem_set_transition_duration(obs_sceneitem_t *item, bool show,
uint32_t duration_ms)
{
if (!item)
return;
if (show)
item->show_transition_duration = duration_ms;
else
item->hide_transition_duration = duration_ms;
}
uint32_t obs_sceneitem_get_transition_duration(obs_sceneitem_t *item, bool show)
{
if (!item)
return 0;
return show ? item->show_transition_duration
: item->hide_transition_duration;
}
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
void obs_sceneitem_transition_stop(void *data, calldata_t *calldata)
{
obs_source_t *parent = data;
obs_source_t *transition;
calldata_get_ptr(calldata, "source", &transition);
obs_source_remove_active_child(parent, transition);
signal_handler_t *sh = obs_source_get_signal_handler(transition);
if (sh)
signal_handler_disconnect(sh, "transition_stop",
obs_sceneitem_transition_stop,
parent);
}
void obs_sceneitem_do_transition(obs_sceneitem_t *item, bool visible)
{
if (!item)
return;
if (transition_active(item->show_transition))
obs_transition_force_stop(item->show_transition);
if (transition_active(item->hide_transition))
obs_transition_force_stop(item->hide_transition);
libobs: Refactor hide/show transition functions Having two separate functions for each hide/show transition action is silly and makes code awful.
2022-03-24 22:32:41 -07:00
obs_source_t *transition = obs_sceneitem_get_transition(item, visible);
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
if (!transition)
return;
int duration =
libobs: Refactor hide/show transition functions Having two separate functions for each hide/show transition action is silly and makes code awful.
2022-03-24 22:32:41 -07:00
(int)obs_sceneitem_get_transition_duration(item, visible);
UI: Add visibility transitions This also modifies libobs. This adds the ability for scene items to have transitions when their visibility is toggled.
2020-04-27 02:58:05 -07:00
const int cx = obs_source_get_width(item->source);
const int cy = obs_source_get_height(item->source);
obs_transition_set_size(transition, cx, cy);
obs_transition_set_alignment(transition, OBS_ALIGN_CENTER);
obs_transition_set_scale_type(transition, OBS_TRANSITION_SCALE_ASPECT);
if (duration == 0)
duration = 300;
obs_scene_t *scene = obs_sceneitem_get_scene(item);
obs_source_t *parent = obs_scene_get_source(scene);
obs_source_add_active_child(parent, transition);
signal_handler_t *sh = obs_source_get_signal_handler(transition);
if (sh)
signal_handler_connect(sh, "transition_stop",
obs_sceneitem_transition_stop, parent);
if (!visible) {
obs_transition_set(transition, item->source);
obs_transition_start(transition, OBS_TRANSITION_MODE_AUTO,
duration, NULL);
} else {
obs_transition_set(transition, NULL);
obs_transition_start(transition, OBS_TRANSITION_MODE_AUTO,
duration, item->source);
}
}
libobs: Add transition save/load functions Moves the transition saving/loading to functions, and refactors existing code to use those functions instead.
2021-04-11 09:42:41 -07:00
void obs_sceneitem_transition_load(struct obs_scene_item *item,
obs_data_t *data, bool show)
{
if (!item || !data)
return;
const char *id = obs_data_get_string(data, "id");
if (id && strlen(id)) {
const char *tn = obs_data_get_string(data, "name");
obs_data_t *s = obs_data_get_obj(data, "transition");
obs_source_t *t = obs_source_create_private(id, tn, s);
libobs: Refactor hide/show transition functions Having two separate functions for each hide/show transition action is silly and makes code awful.
2022-03-24 22:32:41 -07:00
obs_sceneitem_set_transition(item, show, t);
libobs: Add transition save/load functions Moves the transition saving/loading to functions, and refactors existing code to use those functions instead.
2021-04-11 09:42:41 -07:00
obs_source_release(t);
obs_data_release(s);
libobs: Unload show/hide transition on load if none Fixes an issue where a scene item's show/hide transition would stick around if there was no show/hide transition in the loaded data
2022-03-24 23:33:53 -07:00
} else {
obs_sceneitem_set_transition(item, show, NULL);
libobs: Add transition save/load functions Moves the transition saving/loading to functions, and refactors existing code to use those functions instead.
2021-04-11 09:42:41 -07:00
}
libobs: Refactor small bit of code
2022-03-24 23:03:35 -07:00
obs_sceneitem_set_transition_duration(
item, show, (uint32_t)obs_data_get_int(data, "duration"));
libobs: Add transition save/load functions Moves the transition saving/loading to functions, and refactors existing code to use those functions instead.
2021-04-11 09:42:41 -07:00
}
obs_data_t *obs_sceneitem_transition_save(struct obs_scene_item *item,
bool show)
{
obs_data_t *data = obs_data_create();
struct obs_source *transition = show ? item->show_transition
: item->hide_transition;
if (transition) {
obs_data_set_string(data, "id",
obs_source_get_unversioned_id(transition));
obs_data_set_string(data, "versioned_id",
obs_source_get_id(transition));
obs_data_set_string(data, "name",
obs_source_get_name(transition));
obs_data_t *s = obs_source_get_settings(transition);
obs_data_set_obj(data, "transition", s);
obs_data_release(s);
}
obs_data_set_int(data, "duration",
show ? item->show_transition_duration
: item->hide_transition_duration);
return data;
}
libobs: Add obs_scene_prune_sources Adds a function that goes through the scene and releases all sources that have been removed.
2021-11-12 16:28:52 -08:00
void obs_scene_prune_sources(obs_scene_t *scene)
{
DARRAY(struct obs_scene_item *) remove_items;
da_init(remove_items);
video_lock(scene);
update_transforms_and_prune_sources(scene, &remove_items.da, NULL);
video_unlock(scene);
for (size_t i = 0; i < remove_items.num; i++)
obs_sceneitem_release(remove_items.array[i]);
da_free(remove_items);
}