def dup(self):
current_scene = S.obs_scene_from_source(
S.obs_frontend_get_current_scene())
scene_item = S.obs_scene_find_source(current_scene, self.source_name)
info = S.obs_transform_info()
crop = S.obs_sceneitem_crop()
S.obs_sceneitem_get_info(scene_item, info)
S.obs_sceneitem_get_crop(scene_item, crop)
duplicate = S.obs_sceneitem_get_source(scene_item)
duplicated = S.obs_source_duplicate(duplicate,
"duplicate" + self.source_name,
False)
scenes = S.obs_frontend_get_scenes()
for scene in scenes:
name = S.obs_source_get_name(scene)
if name == self.scene_name:
scene = S.obs_scene_from_source(scene)
scene_item2 = S.obs_scene_add(scene, duplicated)
S.obs_sceneitem_set_info(scene_item2, info)
S.obs_sceneitem_set_crop(scene_item2, crop)
S.obs_scene_release(scene)
S.obs_source_release(duplicated)
S.source_list_release(scenes)
S.obs_scene_release(current_scene)
def on_frontend_event(event):
global TALLY_STATUS
if event in (obs.OBS_FRONTEND_EVENT_SCENE_CHANGED,
obs.OBS_FRONTEND_EVENT_PREVIEW_SCENE_CHANGED):
# Check the status of the tally sources
program_source = obs.obs_frontend_get_current_scene()
preview_source = obs.obs_frontend_get_current_preview_scene()
program_scene = obs.obs_scene_from_source(program_source)
preview_scene = obs.obs_scene_from_source(preview_source)
try:
for source_name in TALLY_STATUS.keys():
color = "000000"
source = obs.obs_scene_find_source(preview_scene, source_name)
if source:
color = "00ff00"
source = obs.obs_scene_find_source(program_scene, source_name)
if source:
color = "ff0000"
if TALLY_STATUS[source_name] != color:
CLIENT.publish("cmnd/%s/COLOR" % source_name, color)
TALLY_STATUS[source_name] = color
finally:
obs.obs_source_release(program_source)
obs.obs_source_release(preview_source)
def startCountClick(props, prop):
global itemSource
global xCoord
global yCoord
global Debug_Mode
global jsonItemData
global imagePath
global imageName
global widthCount
global heightCount
if (obs.obs_frontend_preview_program_mode_active()):
sceneSource = obs.obs_frontend_get_current_preview_scene()
else:
sceneSource = obs.obs_frontend_get_current_scene()
sceneWidth = obs.obs_source_get_width(sceneSource)
sceneHeight = obs.obs_source_get_height(sceneSource)
xWidth = math.ceil(sceneWidth / widthCount)
yHeight = math.ceil(sceneHeight / heightCount)
blankImage = np.zeros(shape=[yHeight, xWidth, 4], dtype=np.uint8)
cv2.rectangle(blankImage, (0, 0), (xWidth, yHeight), (169, 169, 169, 255),
2)
if (os.path.isfile(imagePath + imageName)):
os.remove(imagePath + imageName)
cv2.imwrite(imagePath + imageName, blankImage)
if Debug_Mode:
print("startCount")
print(imagePath + imageName)
gridWidth = 0
gridHeight = 0
scene = obs.obs_scene_from_source(sceneSource)
itemData = obs.obs_data_create_from_json(jsonItemData)
itemSource = obs.obs_load_source(itemData)
vec2 = obs.vec2()
position = 0
if itemSource != None:
item = obs.obs_scene_find_source(scene, "OBSWindowGridItem")
while item != None:
obs.obs_sceneitem_remove(item)
item = obs.obs_scene_find_source(scene, "OBSWindowGridItem")
vec2.y = 0
while gridHeight < sceneHeight:
gridWidth = 0
vec2.x = 0
while gridWidth < sceneWidth:
newItem = obs.obs_scene_add(scene, itemSource)
obs.obs_sceneitem_set_pos(newItem, vec2)
obs.obs_sceneitem_set_locked(newItem, True)
obs.obs_sceneitem_set_order_position(newItem, position)
position += 1
vec2.x += xWidth
gridWidth += xWidth
vec2.y += yHeight
gridHeight += yHeight
def playsound(filename, volume, speed):
obs.script_log(obs.LOG_DEBUG,
"Trying to play " + filename + " to source " + sourcename)
scenesource = obs.obs_frontend_get_current_scene()
scene = obs.obs_scene_from_source(scenesource)
#obs.script_log(obs.LOG_DEBUG,"Scene "+str(scene))
sceneitem = obs.obs_scene_find_source(scene, sourcename)
#obs.script_log(obs.LOG_DEBUG,"Scene item "+str(sceneitem))
source = obs.obs_sceneitem_get_source(sceneitem)
obs.obs_source_set_volume(source, volume)
set_source_speed(source, speed)
obs.obs_sceneitem_set_visible(sceneitem, False)
settings = obs.obs_source_get_settings(source)
#obs.script_log(obs.LOG_DEBUG,str(obs.obs_data_get_json(settings)))
obs.obs_data_set_string(settings, "local_file", audiofolder + filename)
#obs.script_log(obs.LOG_DEBUG,str(obs.obs_data_get_json(settings)))
obs.obs_source_update(source, settings)
obs.obs_sceneitem_set_visible(sceneitem, True)
obs.obs_data_release(settings)
obs.obs_source_release(scenesource)
def run_import(props, prop):
global template_scene_name
global video_directory
template_source = obs.obs_get_source_by_name(template_scene_name)
template_scene = obs.obs_scene_from_source(template_source)
files = glob.glob(video_directory + "/*")
files.sort()
transition_number = 0
for filename in files:
transition_number += 1
bare_name = "Transition " + str(transition_number)
new_scene = obs.obs_scene_duplicate(template_scene, bare_name,
obs.OBS_SCENE_DUP_REFS)
source_data = obs.obs_data_create()
obs.obs_data_set_string(source_data, 'local_file', filename)
source = obs.obs_source_create('ffmpeg_source', 'Video - ' + bare_name,
source_data, None)
scene_item = obs.obs_scene_add(new_scene, source)
obs.obs_sceneitem_set_order(scene_item, obs.OBS_ORDER_MOVE_BOTTOM)
import_utils.fit_to_screen(scene_item)
obs.obs_source_release(source)
obs.obs_scene_release(new_scene)
obs.script_log(obs.LOG_INFO,
"created scene '" + bare_name + "' from " + filename)
obs.obs_source_release(template_source)
def get_audio_sources_from_scene(scene, source_dict=None):
if source_dict is None:
source_dict = OrderedDict()
for sceneitem in obspython.obs_scene_enum_items(
obspython.obs_scene_from_source(scene)):
item_source = obspython.obs_sceneitem_get_source(sceneitem)
name = obspython.obs_source_get_name(item_source)
if obspython.obs_source_get_output_flags(
item_source) & obspython.OBS_SOURCE_COMPOSITE:
source_dict = get_audio_sources_from_scene(item_source,
source_dict)
if obspython.obs_source_get_output_flags(
item_source) & obspython.OBS_SOURCE_AUDIO:
source_active = obspython.obs_source_active(item_source)
audio_active = obspython.obs_source_audio_active(item_source)
priv_settings = obspython.obs_source_get_private_settings(
item_source)
hidden = obspython.obs_data_get_bool(priv_settings, "mixer_hidden")
if not source_active or not audio_active or hidden:
continue
source_dict[name] = item_source
return source_dict
def getCurrentSceneItem(self, itemName):
source = obs.obs_frontend_get_current_scene()
item = ''
scene = obs.obs_scene_from_source(source)
item = obs.obs_scene_find_source(scene, itemName)
obs.obs_source_release(source)
return item
def iterSceneItemsByName(self, sourceName):
"""
Iterator over scene items with a given source name, in the
scene currently displayed in the frontend
"""
# This took me a while to figure out, so I'll comment it
# enough to be understandable.
# First, we get the source we need to find items of
with getSourceByName(sourceName) as s:
if s is None: return []
# Now we get the entire scene that's currently streaming
with frontendGetCurrentScene() as currentSceneSource:
if currentSceneSource is None: return []
# (and convert it to a scene)
currentScene = obs.obs_scene_from_source(currentSceneSource)
if currentScene is None: return []
# Now we iterate over all the items in that scene
with sceneEnumItems(currentScene) as items:
for item in items:
if item is None: continue
# Now we find what source this item is using
itemSource = obs.obs_sceneitem_get_source(item)
# And the name of that source
itemSourceName = obs.obs_source_get_name(itemSource)
# And if it's what we want, we yield it!
if itemSourceName == sourceName:
yield item
def update_cursor(self):
source = obs.obs_get_source_by_name(self.source_name)
settings = obs.obs_data_create()
if source is not None:
scene_source = obs.obs_frontend_get_current_scene()
scene_width = obs.obs_source_get_width(source)
scene_height = obs.obs_source_get_height(source)
scene = obs.obs_scene_from_source(scene_source)
scene_item = obs.obs_scene_find_source(scene, self.source_name)
if scene_item:
scale = obs.vec2()
obs.obs_sceneitem_get_scale(scene_item, scale)
scene_width, scene_height = apply_scale(
scale.x, scale.y, scene_width, scene_height
)
next_pos = obs.vec2()
next_pos.x, next_pos.y = get_position()
next_pos.x -= scene_width / 2
next_pos.y -= scene_height / 2
# set position to center of source where cursor is
obs.obs_sceneitem_set_pos(scene_item, next_pos)
obs.obs_data_release(settings)
obs.obs_scene_release(scene)
obs.obs_source_release(source)
def run_import(props, prop):
global template_scene_name
global image_directory
template_source = obs.obs_get_source_by_name(template_scene_name)
template_scene = obs.obs_scene_from_source(template_source)
# expecting filenames like '01 - test.jpg'
files = glob.glob(image_directory + "/*")
files.sort()
for filename in files:
# try to remove the initial ordinal, but don't error if it isn't present.
# '01 - test.jpg' -> 'test'
# 'test.jpg' -> 'test'
parts = Path(filename).stem.split('-')
bare_name = parts[len(parts) - 1].strip()
new_scene = obs.obs_scene_duplicate(template_scene, bare_name, obs.OBS_SCENE_DUP_REFS)
source_data = obs.obs_data_create()
obs.obs_data_set_string(source_data, 'file', filename)
source = obs.obs_source_create('image_source', 'Image - ' + bare_name, source_data, None)
scene_item = obs.obs_scene_add(new_scene, source)
obs.obs_sceneitem_set_order(scene_item, obs.OBS_ORDER_MOVE_BOTTOM)
import_utils.fit_to_screen(scene_item)
obs.obs_source_release(source)
obs.obs_scene_release(new_scene)
obs.script_log(obs.LOG_INFO, "created scene '" + bare_name + "' from " + filename)
obs.obs_source_release(template_source)
def get_sceneitem_from_source_name_in_current_scene(name):
result_sceneitem = None
current_scene_as_source = obs.obs_frontend_get_current_scene()
if current_scene_as_source:
current_scene = obs.obs_scene_from_source(current_scene_as_source)
result_sceneitem = obs.obs_scene_find_source_recursive(current_scene, name)
obs.obs_source_release(current_scene_as_source)
return result_sceneitem
def scene_name_to_scene(scene):
source = obs.obs_get_source_by_name(scene)
if source is not None:
scene = obs.obs_scene_from_source(source)
obs.obs_source_release(source)
return scene
else:
return None
def toggle(source):
scene = obs.obs_frontend_get_current_scene()
sceneitem = obs.obs_scene_find_source(obs.obs_scene_from_source(scene),
source)
obs.obs_sceneitem_set_visible(sceneitem,
not obs.obs_sceneitem_visible(sceneitem))
obs.obs_source_release(scene)
obs.obs_source_release(sceneitem)
def deleteGridClick(props, prop):
if (obs.obs_frontend_preview_program_mode_active()):
sceneSource = obs.obs_frontend_get_current_preview_scene()
else:
sceneSource = obs.obs_frontend_get_current_scene()
scene = obs.obs_scene_from_source(sceneSource)
item = obs.obs_scene_find_source(scene, "OBSWindowGridItem")
while item:
obs.obs_sceneitem_remove(item)
item = obs.obs_scene_find_source(scene, "OBSWindowGridItem")
def _sceneitem_by_name(self, scene_name, name):
with self._source_by_name(scene_name) as source:
scene = _obs.obs_scene_from_source(source)
if not scene:
raise LookupError("no scene named {}".format(scene_name))
i = _obs.obs_scene_find_source_recursive(scene, name)
if i is None:
raise LookupError("no sceneitem named {}".format(name))
_obs.obs_sceneitem_addref(i)
return _SourceReleaser(i, is_sceneitem=True)
def set_logo(blue_config, orange_config): #reused for logo later
default_logo = os.path.join(files_path, 'logo.png')
blue_config_bun = get_bot_config_bundle(blue_config)
orange_config_bun = get_bot_config_bundle(orange_config)
blue_logo = blue_config_bun.get_logo_file()
if blue_logo is None:
blue_logo = default_logo
orange_logo = orange_config_bun.get_logo_file()
if orange_logo is None:
orange_logo = default_logo
default_logo_scale = 0.25
default_logo_size = [400*default_logo_scale, 300*default_logo_scale]
blue_logo_size = list(Image.open(blue_logo).size)
blue_scale = default_logo_size[0]/blue_logo_size[0]
orange_logo_size = list(Image.open(orange_logo).size)
orange_scale = default_logo_size[0]/orange_logo_size[0]
scenes = obs.obs_frontend_get_scenes()
if scenes is not None:
for scene in scenes:
if obs.obs_source_get_name(scene) == 'RLBot - AutoLeague':
scene = obs.obs_scene_from_source(scene)
items = obs.obs_scene_enum_items(scene)
for item in items:
if item is not None:
source_t = obs.obs_sceneitem_get_source(item)
if obs.obs_source_get_name(source_t) == "Logo-0":
source = source_t
settings = obs.obs_data_create()
obs.obs_data_set_string(settings, "file", blue_logo)
obs.obs_source_update(source, settings)
obs.obs_data_release(settings)
vec = obs.vec2()
obs.vec2_set(vec, blue_scale, blue_scale)
obs.obs_sceneitem_set_scale(item, vec)
if obs.obs_source_get_name(source_t) == "Logo-1":
source = source_t
settings = obs.obs_data_create()
obs.obs_data_set_string(settings, "file", orange_logo)
obs.obs_source_update(source, settings)
obs.obs_data_release(settings)
vec = obs.vec2()
obs.vec2_set(vec, orange_scale, orange_scale)
obs.obs_sceneitem_set_scale(item, vec)
obs.source_list_release(scenes)
obs.sceneitem_list_release(items)
def on_visibility_toggle(calldata):
scenes_as_sources = obs.obs_frontend_get_scenes()
sceneitem = obs.calldata_sceneitem(calldata, "item")
visibility = obs.calldata_bool(calldata, "visible")
name = obs.obs_source_get_name(obs.obs_sceneitem_get_source(sceneitem))
for scene_as_source in scenes_as_sources:
scene = obs.obs_scene_from_source(scene_as_source)
match = obs.obs_scene_find_source(scene, name)
if match:
obs.obs_sceneitem_set_visible(match, visibility)
obs.source_list_release(scenes_as_sources)
def set_visible_all(self, visible):
"""Cycle through all scenes, manually toggling visibility of the source
Idea from GitHub user LukyLurks
"""
scenes = obs.obs_frontend_get_scenes()
for scene in scenes:
scene_test = obs.obs_scene_from_source(scene)
in_scene = obs.obs_scene_find_source(scene_test, self.source_name)
if in_scene:
obs.obs_sceneitem_set_visible(in_scene, visible)
obs.source_list_release(scenes)
def findSceneItem(source_name):
scene_item = None
currentSceneName = findCurrentSceneName()
if currentSceneName:
src = obs.obs_get_source_by_name(currentSceneName)
if src:
scene = obs.obs_scene_from_source(src)
if scene:
scene_item = obs.obs_scene_find_source(scene, source_name)
obs.obs_scene_release(scene)
obs.obs_source_release(src)
return scene_item
def crete_text_source(self):
current_scene = obs.obs_frontend_get_current_scene()
scene = obs.obs_scene_from_source(current_scene)
settings = obs.obs_data_create()
obs.obs_data_set_string(settings, "text",
"The quick brown fox jumps over the lazy dog")
source = obs.obs_source_create_private("text_gdiplus", "test_py",
settings)
obs.obs_scene_add(scene, source)
obs.obs_scene_release(scene)
obs.obs_data_release(settings)
obs.obs_source_release(source)
def get_item_names_by_scene(source):
item_names = []
scene = obs.obs_scene_from_source(source)
scene_name = obs.obs_source_get_name(source)
scene_items = obs.obs_scene_enum_items(scene)
if scene_items is not None:
for item in scene_items:
item_source = obs.obs_sceneitem_get_source(item)
item_name = obs.obs_source_get_name(item_source)
if item_name in light_mapping:
item_names.append(item_name)
obs.sceneitem_list_release(scene_items)
return item_names
def save(*args):
currentScene = obs.obs_frontend_get_current_scene()
sceneName = obs.obs_source_get_name(currentScene)
sceneObject = obs.obs_scene_from_source(currentScene)
items = obs.obs_scene_enum_items(sceneObject)
transformations = getTransformationList(items)
loc = filedialog.asksaveasfilename(filetypes=[("JSON", "*.json")],
title="Save Template File",
initialfile=sceneName + ".json")
f = open(loc, 'w')
f.write(json.dumps(transformations))
f.close()
#obs.obs_scene_release(sceneObject)
obs.obs_source_release(currentScene)
return True
def refresh_screen(self):
source = obs.obs_frontend_get_current_scene()
scene = obs.obs_scene_from_source(source)
sceneitem = obs.obs_scene_find_source_recursive(scene, self.source_name)
if sceneitem is not None:
obs.obs_sceneitem_set_visible(sceneitem, False)
if self.debug:
print("off")
time.sleep(self.blink_speed)
obs.obs_sceneitem_set_visible(sceneitem, True)
if self.debug:
print("on")
obs.obs_sceneitem_release(sceneitem)
obs.obs_scene_release(scene)
obs.obs_source_release(source)
def setup_source(source_name, height, width):
# Get the current scene
current_scene = obs.obs_frontend_get_current_scene()
scene = obs.obs_scene_from_source(current_scene)
obs.obs_source_release(current_scene)
# Grab the source
source = obs.obs_scene_find_source(scene, source_name)
# This makes sure that the scaling is done right
obs.obs_sceneitem_set_bounds_type(source, obs.OBS_BOUNDS_SCALE_INNER)
# Set the bounding box size
new_scale = obs.vec2()
new_scale.x = height
new_scale.y = width
obs.obs_sceneitem_set_bounds(source, new_scale)
def update_position():
global source_name
global counter
source = obs.obs_frontend_get_current_scene()
if source is not None:
scene_object = obs.obs_scene_from_source(source)
scene_item = obs.obs_scene_find_source(scene_object, source_name)
pos = obs.vec2()
obs.obs_sceneitem_get_pos(scene_item, pos)
next_pos = obs.vec2()
next_pos.x = pos.x
y_adjust = math.sin(math.radians(counter))
next_pos.y = pos.y + y_adjust / 4
counter += 0.5
if counter == 360:
counter = 0
obs.obs_sceneitem_set_pos(scene_item, next_pos)
obs.obs_source_release(source)
def get_scene_item(name):
scenes = obs.obs_frontend_get_scenes()
if scenes is not None:
for scene in scenes:
if obs.obs_source_get_name(scene) == 'RLBot - AutoLeague':
scene = obs.obs_scene_from_source(scene)
items = obs.obs_scene_enum_items(scene)
for item in items:
if item is not None:
scene_source = obs.obs_sceneitem_get_source(item)
if obs.obs_source_get_name(scene_source) == name:
sceneItem = obs.obs_scene_find_sceneitem_by_id(scene, obs.obs_sceneitem_get_id(item))
obs.source_list_release(scenes)
obs.obs_sceneitem_addref(sceneItem)
obs.sceneitem_list_release(items)
return sceneItem
obs.sceneitem_list_release(items)
obs.source_list_release(scenes)
def set_names(source_name, string):
scenes = obs.obs_frontend_get_scenes()
if scenes is not None:
for scene in scenes:
if obs.obs_source_get_name(scene) == 'RLBot - AutoLeague':
scene = obs.obs_scene_from_source(scene)
items = obs.obs_scene_enum_items(scene)
for item in items:
if item is not None:
source_t = obs.obs_sceneitem_get_source(item)
if obs.obs_source_get_name(source_t) == source_name:
source = source_t
settings = obs.obs_data_create()
obs.obs_data_set_string(settings, "text", str(string))
obs.obs_source_update(source, settings)
obs.obs_data_release(settings)
obs.source_list_release(scenes)
obs.sceneitem_list_release(items)
def move_text_source(self):
current_scene = obs.obs_frontend_get_current_scene()
source = obs.obs_get_source_by_name("test_py")
scene = obs.obs_scene_from_source(current_scene)
scene_item = obs.obs_scene_find_source(scene, "test_py")
if scene_item:
dx, dy = 10, 10
print("old values", self.location.x)
obs.obs_sceneitem_get_pos(
scene_item, self.location
) # update to last position if its changed from OBS
self.location.x += dx
self.location.y += dy
print("new values", self.location.x)
obs.obs_sceneitem_set_pos(scene_item, self.location)
obs.obs_scene_release(scene)
obs.obs_source_release(source)
def hidesource():
#obs.script_log(obs.LOG_DEBUG,"Trying to hide source "+sourcename)
frontendscenes = obs.obs_frontend_get_scenes()
#obs.script_log(obs.LOG_DEBUG,str(frontendscenes))
for scenesource in frontendscenes:
#obs.script_log(obs.LOG_DEBUG,str(scenesource))
#scenesource = obs.obs_frontend_get_current_scene()
scene = obs.obs_scene_from_source(scenesource)
#obs.script_log(obs.LOG_DEBUG,"Scene "+str(scene))
sceneitem = obs.obs_scene_find_source(scene, sourcename)
if sceneitem:
#obs.script_log(obs.LOG_DEBUG,"Scene item "+str(sceneitem))
obs.obs_sceneitem_set_visible(sceneitem, False)
#obs.obs_source_release(scenesource)
obs.source_list_release(frontendscenes)
def start_animation(info):
global animationInfo
global globSettings
global animationRunning
animationInfo["animTime"] = 0
animationInfo["stopTime"] = obs.obs_data_get_int(globSettings,
"duration") / 1000
f = open(info, 'r')
animationInfo["destination"] = json.loads(f.read())
f.close()
animationInfo["animScene"] = obs.obs_get_source_by_name(
obs.obs_data_get_string(globSettings, "scene"))
sceneObject = obs.obs_scene_from_source(animationInfo["animScene"])
items = obs.obs_scene_enum_items(sceneObject)
animationInfo["initial"] = getTransformationList(items)
animationRunning = True
