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 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 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 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 script_unload():
global target_scene
global group_name
scene = scene_name_to_scene(target_scene)
group = obs.obs_scene_find_source(scene, group_name)
if group is not None:
obs.obs_sceneitem_remove(group)
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 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 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 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 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 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 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 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 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 scan_folder():
global target_scene
global group_name
scene = scene_name_to_scene(target_scene)
group = obs.obs_scene_find_source(scene, group_name)
if group is not None:
obs.obs_sceneitem_remove(group)
group = obs.obs_scene_add_group(scene, group_name)
for file in os.listdir(song_directories):
if file.endswith((".mp3", ".webm", ".m4a", ".ogg")):
settings = obs.obs_data_create()
obs.obs_data_set_string(settings, "local_file",
song_directories + "/" + file)
obs.obs_data_set_string(settings, "group", group_name)
source = obs.obs_source_create("ffmpeg_source", file, settings,
None)
scene_item = obs.obs_scene_add(scene, source)
group = obs.obs_scene_get_group(scene, group_name)
obs.obs_sceneitem_group_add_item(group, scene_item)
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 tremor_effect(self):
flag = next(self.position_swap)
if flag:
self.update_text(self.scripted_text)
current_scene = obs.obs_frontend_get_current_scene()
with source_ar(self.source_name) as source, scene_ar(
current_scene) as scene:
scene_item = obs.obs_scene_find_source(scene, self.source_name)
pos = obs.vec2()
self.location = pos
obs.obs_sceneitem_get_pos(
scene_item, self.location
) # update to last position if its changed from OBS
if not self.last_jump_x == 0:
if self.last_jump_x < 0:
# minus minus
self.location.x -= self.last_jump_x
if self.last_jump_x > 0:
self.location.x -= self.last_jump_x
if not self.last_jump_y == 0:
if self.last_jump_y < 0:
self.location.y -= self.last_jump_y
if self.last_jump_y > 0:
self.location.y -= self.last_jump_y
if scene_item:
obs.obs_sceneitem_set_pos(scene_item, self.location)
else:
self.update_text(self.scripted_text)
current_scene = obs.obs_frontend_get_current_scene()
with source_ar(self.source_name) as source, scene_ar(
current_scene) as scene:
scene_item = obs.obs_scene_find_source(scene, self.source_name)
pos = obs.vec2()
self.location = pos
obs.obs_sceneitem_get_pos(
scene_item, self.location
) # update to last position if its changed from OBS
if scene_item:
# finish early , and set to default
if self.duration // self.refresh_rate <= 3:
self.duration = 0
obs.obs_sceneitem_set_pos(scene_item, self.location)
else:
next_pos = obs.vec2()
withoutzero = list(range(-101, 0)) + list(range(
1, 101))
self.last_jump_x = choice(withoutzero)
self.last_jump_y = choice(withoutzero)
dx, dy = self.last_jump_x, self.last_jump_y
next_pos.x, next_pos.y = (
self.location.x + dx,
self.location.y + dy,
)
obs.obs_sceneitem_set_pos(scene_item, next_pos)
def toggle(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)
boolean = not S.obs_sceneitem_visible(scene_item)
S.obs_sceneitem_set_visible(scene_item, boolean)
S.obs_scene_release(current_scene)
def sad_threaded(props, prop):
# 1. Make it grayscale
cam_source = obs.obs_get_source_by_name("Shitty Webcam")
grayscale_filter = obs.obs_source_get_filter_by_name(cam_source, "Gray")
data = obs.obs_data_create()
obs.obs_data_set_double(data, "clut_amount", 1.0)
obs.obs_source_update(grayscale_filter, data)
# 2. Save initial props
current_scene_source = obs.obs_frontend_get_current_scene()
obs.obs_frontend_set_current_preview_scene(current_scene_source)
current_scene = obs.obs_scene_from_source(current_scene_source)
cam_sceneitem = obs.obs_scene_find_source(current_scene, "Shitty Webcam")
initial_scale = obs.vec2()
obs.obs_sceneitem_get_scale(cam_sceneitem, initial_scale)
initial_pos = obs.vec2()
obs.obs_sceneitem_get_pos(cam_sceneitem, initial_pos)
initial_box_transform = obs.matrix4()
obs.obs_sceneitem_get_box_transform(cam_sceneitem, initial_box_transform)
initial_crop = obs.obs_sceneitem_crop()
obs.obs_sceneitem_get_crop(cam_sceneitem, initial_crop)
# matrix4.x.x -> x size
# matrix4.y.y -> y size
# matrix4.t.x -> x position
# matrix4.t.y -> y position
# for prop in ["x", "y", "z", "t"]:
# print(f"Matrix property {prop}")
# vec = getattr(initial_box_transform, prop)
# print(dir(vec))
# for vec_prop in ["m", "w", "x", "y", "z"]:
# print(f"Vec Property {vec_prop}: {getattr(vec, vec_prop)}")
size_x = initial_box_transform.x.x
size_y = initial_box_transform.y.y
initial_draw_transform = obs.matrix4()
obs.obs_sceneitem_get_draw_transform(cam_sceneitem, initial_draw_transform)
print(dir(initial_draw_transform))
# 3. Mute desktop audio, play sound of silence
desktop_audio = obs.obs_get_output_source(4)
obs.obs_source_set_muted(desktop_audio, True)
song = obs.obs_source_create("ffmpeg_source", "Sound of Silence", None,
None)
song_settings = obs.obs_data_create()
obs.obs_data_set_string(
song_settings, "local_file",
"C:\\Users\\avikn\\Downloads\\sound_of_silence.mp3")
obs.obs_source_update(song, song_settings)
obs.obs_data_release(song_settings)
song_item = obs.obs_scene_add(current_scene, song)
# 4. Scale up / reposition the camera.
# It's gross but it works don't touch it.
dynamic_scale = obs.vec2()
obs.vec2_copy(dynamic_scale, initial_scale)
increment = obs.vec2()
increment.x = 0.0015
increment.y = 0.0015
crop = (initial_crop.top, initial_crop.right, initial_crop.bottom,
initial_crop.left)
size_x, size_y = get_size(cam_sceneitem)
dynamic_crop = obs.obs_sceneitem_crop()
bounds = obs.vec2()
bounds.x = size_x
bounds.y = size_y
obs.obs_sceneitem_set_bounds(cam_sceneitem, bounds)
for _ in range(240):
obs.obs_sceneitem_set_bounds_type(cam_sceneitem, 0)
obs.vec2_add(dynamic_scale, dynamic_scale, increment)
obs.obs_sceneitem_set_scale(cam_sceneitem, dynamic_scale)
nsize_x, nsize_y = get_size(cam_sceneitem)
x_delta = nsize_x - size_x + (dynamic_crop.right * 2)
y_delta = nsize_y - size_y + (dynamic_crop.top * 2)
dynamic_crop.top = int(y_delta / 2)
dynamic_crop.right = int(x_delta / 2)
dynamic_crop.bottom = int(y_delta / 2)
dynamic_crop.left = int(x_delta / 2)
obs.obs_sceneitem_set_crop(cam_sceneitem, dynamic_crop)
obs.obs_sceneitem_set_bounds_type(cam_sceneitem, 1)
obs.obs_frontend_preview_program_trigger_transition()
time.sleep(0.1)
# 5. Cleanup
obs.obs_source_set_muted(desktop_audio, False)
obs.obs_sceneitem_set_scale(cam_sceneitem, initial_scale)
obs.obs_sceneitem_set_crop(cam_sceneitem, initial_crop)
obs.obs_data_set_double(data, "clut_amount", 0.0)
obs.obs_source_update(grayscale_filter, data)
obs.obs_sceneitem_remove(song_item)
obs.obs_source_release(song)
time.sleep(0.1)
obs.obs_frontend_preview_program_trigger_transition()
def set_visibility(val): scene = get_scene() #source = obs.obs_get_source_by_name(image_source_name) source = obs.obs_scene_find_source(scene, image_source_name) obs.obs_sceneitem_set_visible(source, val)
def changeSourceToMousePosition():
#Get current scene
currentScene = currentSceneName()
if currentScene is None:
return
#Get scene item
src = obs.obs_get_source_by_name(currentScene)
if src is None:
return
scene = obs.obs_scene_from_source(src)
if scene is None:
return
obs.obs_source_release(src)
for sourceName in [sourceName1, sourceName2]:
sceneItem = obs.obs_scene_find_source(scene, sourceName)
if sceneItem is None:
break
#Variables
global currentLeft
global currentTop
global currentRight
global currentBottom
global wantedLeft
global wantedTop
global wantedRight
global wantedBottom
#Following mouse
if followingMouse:
global currentCamera
mousePos = queryMousePosition()
wantedCamera = mousePos
xSizeNow = xMaxSize - currentRight - currentLeft
ySizeNow = yMaxSize - currentBottom - currentTop
scaleRateFixer = ((xMaxSize + yMaxSize) / (xSizeNow + ySizeNow))
xDiff = (wantedCamera.x -
currentCamera[0]) * followRate / 100 * scaleRateFixer
yDiff = (wantedCamera.y -
currentCamera[1]) * followRate / 100 * scaleRateFixer
#Check if already reached wanted camera
if abs(currentCamera[0] + xDiff -
wantedCamera.x) > abs(currentCamera[0] - wantedCamera.x):
xDiff = wantedCamera.x - currentCamera[0]
if abs(currentCamera[1] + yDiff -
wantedCamera.y) > abs(currentCamera[1] - wantedCamera.y):
yDiff = wantedCamera.y - currentCamera[1]
#Move camera
currentCamera[0] += xDiff
currentCamera[1] += yDiff
#Move crop
wantedLeft += xDiff
wantedRight -= xDiff
wantedTop += yDiff
wantedBottom -= yDiff
#When rectangle is outside
fixedWantedLeft = wantedLeft
fixedWantedTop = wantedTop
fixedWantedRight = wantedRight
fixedWantedBottom = wantedBottom
if fixedWantedLeft < 0:
fixedWantedRight += fixedWantedLeft
fixedWantedLeft = 0
elif fixedWantedRight < 0:
fixedWantedLeft += fixedWantedRight
fixedWantedRight = 0
if fixedWantedTop < 0:
fixedWantedBottom += fixedWantedTop
fixedWantedTop = 0
elif fixedWantedBottom < 0:
fixedWantedTop += fixedWantedBottom
fixedWantedBottom = 0
#If zoom is off
if not wantsZoom:
fixedWantedLeft = 0
fixedWantedTop = 0
fixedWantedRight = 0
fixedWantedBottom = 0
#Move crop
currentLeft += (fixedWantedLeft - currentLeft) * zoomRate / 100
currentTop += (fixedWantedTop - currentTop) * zoomRate / 100
currentRight += (fixedWantedRight - currentRight) * zoomRate / 100
currentBottom += (fixedWantedBottom - currentBottom) * zoomRate / 100
#Set to OBS
cropZone = obs.obs_sceneitem_crop()
cropZone.left = int(round(currentLeft))
cropZone.top = int(round(currentTop))
cropZone.right = int(round(currentRight))
cropZone.bottom = int(round(currentBottom))
obs.obs_sceneitem_set_crop(sceneItem, cropZone)
def _set_sceneitem(self, source_name):
source = obs.obs_frontend_get_current_scene()
scene = obs.obs_scene_from_source(source)
sceneitem = obs.obs_scene_find_source(scene, source_name)
obs.obs_source_release(source)
return sceneitem
def visibility_source(source_name, hide):
current_scene = obs.obs_scene_from_source(
obs.obs_frontend_get_current_scene())
scene_item = obs.obs_scene_find_source(current_scene, source_name)
if scene_item is not None:
obs.obs_sceneitem_set_visible(scene_item, hide)
