Madiator2011/Blender-Pipeline
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
Blender-Pipeline/studio/studio_shot_linkLayer.py

664 lines
21 KiB
Python
Raw Permalink Normal View History

Upload files to 'studio'
2020-12-19 11:20:34 +01:00
# THIS FILE IS A PART OF VCStudio
# PYTHON 3
import os
from subprocess import *
# GTK module ( Graphical interface
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
from gi.repository import GLib
from gi.repository import Gdk
import cairo
# Own modules
from settings import settings
from settings import oscalls
from settings import talk
from settings import fileformats
from project_manager import pm_project
#UI modules
from UI import UI_elements
from UI import UI_color
# story
from studio import story
from studio import analytics
from studio import history
from studio import studio_dialogs
Upload files to 'studio'
2020-12-25 15:20:34 +01:00
from studio import history
Upload files to 'studio'
2020-12-19 11:20:34 +01:00
def link_from_script(win):
#########################################################################
# This file is here because there are multiple places in the window where
# I want to link assets based on what's written in the text of the script.
# So this file will basically parse the text and add the assets it finds
# linked to the link list.
#########################################################################
print("Reading from the scene")
# Fist we need to know what scene and shot are we.
if win.cur.count("/") > 1:
tmp = win.cur.replace("/","",1).split("/")
scene, shotis = tmp[0], tmp[1]
else:
scene = win.cur[win.cur.rfind("/")+1:]
shotis = ""
print(scene, shotis)
# Now let's read through the scene.
for shot in win.story["scenes"][scene]["shots"]:
# Ignore the non shots.
if shot[0] != "shot_block":
continue
# Ingore all other shots.
if shot[1] != shotis:
continue
# Let's read the shot
for asset in shot[-1]:
# Ignore text
if asset[0] == "text":
continue
# It's it's a staight up link. Just add it.
if asset[0] == "link" and "/dev"+asset[1] not in win.current["linking_asset_data"]["assets"]:
win.current["linking_asset_data"]["assets"].append("/dev"+asset[1])
# It's a link in a frase.
if asset[0] == "frase" and asset[1][0] == "link" and "/dev"+asset[1][1] not in win.current["linking_asset_data"]["assets"]:
win.current["linking_asset_data"]["assets"].append("/dev"+asset[1][1])
def layer(win, call):
# Making the layer
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, win.current['w'],
win.current['h'])
layer = cairo.Context(surface)
#text setting
layer.select_font_face("Monospace", cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL)
UI_color.set(layer, win, "dark_overdrop")
layer.rectangle(
0,
0,
win.current["w"],
win.current["h"],
)
layer.fill()
UI_color.set(layer, win, "node_background")
UI_elements.roundrect(layer, win,
40,
40,
win.current["w"]-80,
win.current["h"]-80,
10)
##############################################################################
# This file is configuring and lanunching the linking into blend files. But it's
# not the only file in the chain of files that is responsible for this operation.
# For example the linking it self does studio/bpy_do_linking.py that is running
# inside blender and communicates with this file for the UI side of things.
##############################################################################
# Okay
if not win.current["linking_asset_data"]["fraction"]:
def do():
Upload files to 'studio'
2020-12-25 15:20:34 +01:00
# Before we start let's record the history for it.
history.record(win, win.project+win.current["linking_asset_data"]["linking_to"], "[Linked]")
Upload files to 'studio'
2020-12-19 11:20:34 +01:00
if not win.current["linking_asset_data"]["process"]:
# So this is an apply button. I know it's a little not in the right
# order. So please read the rest of the file to see what it does.
# So now when a person clicks okay. We first need to save the
# autolink.data.
datafile = open(win.project+"/rnd"+win.cur+"/extra/autolink.data", "w")
for asset in win.current["linking_asset_data"]["assets"]:
datafile.write("Link : "+asset+"\n")
# Also let's write the mode. Because it's important.
datafile.write("Mode : "+win.current["linking_asset_data"]["mode"]+"\n")
datafile.close()
# Okay... now that we have the file. We can start the process of linking
# Which will be done using Blender. So let's get blender's url
blenderpath = oscalls.get_current_blender(win)
# Now here is the fun part. We gonna start a background process
# open there blender and will start linking stuff.
win.current["linking_asset_data"]["process"] = Popen(['stdbuf', '-o0', blenderpath, \
"-b", win.project+win.current["linking_asset_data"]["linking_to"], \
"-P", os.getcwd()+"/studio/bpy_do_linking.py"],\
stdout=PIPE, universal_newlines=True)
win.current["linking_asset_data"]["fraction"] = 0.01
# Hell of a command isn't it.
UI_elements.roundrect(layer, win,
win.current["w"]-120,
win.current["h"]-80,
40,
40,
10,
button=do,
icon="ok",
tip=talk.text("checked"),
url="asset_link")
Upload files to 'studio'
2020-12-25 15:20:34 +01:00
# Documentation entry
def do():
def after(win, var):
pass
studio_dialogs.help(win, "help", after, SEARCH=talk.text("documentation_link_assets"))
UI_elements.roundrect(layer, win,
300,
50,
40,
40,
10,
do,
"question")
Upload files to 'studio'
2020-12-19 11:20:34 +01:00
# CANCEl
if not win.current["linking_asset_data"]["process"]:
def do():
if not win.current["linking_asset_data"]["process"]:
win.current["calls"][call]["var"] = False
win.assets = {}
UI_elements.roundrect(layer, win,
win.current["w"]-80,
win.current["h"]-80,
40,
40,
10,
button=do,
icon="cancel",
tip=talk.text("cancel"),
url="asset_link")
# Short cut ESC
if 65307 in win.current["keys"] and not win.textactive:
do()
# Now let's prepare the ground for the next part.
# Before we do anything we need to make sure that there is an autolink.data
# file in the extra folder of the shot. But since this is a system that is
# designed to be very simple on the user side. There could not even be the
# extra folder. So...
try:
os.mkdir(win.project+"/rnd"+win.cur+"/extra")
except:
pass
# Next thing will be to see if there is a file called autolink.data. And if
# yes read from it. We are going to load the data into the memory.
# So if there is nothing yet loaded let's try loading it from file. Try
# because there nothing quarantees that the file exists. If file does not
# exists we gonna populate it with assets from the shot. As marked in the
# scene the user wrote. But it's going to be a separate function since I
# want to make a button to do it.
if not win.current["linking_asset_data"]["assets"] and not win.current["linking_asset_data"]["read"]:
win.current["linking_asset_data"]["read"] = True
try:
datafile = open(win.project+"/rnd"+win.cur+"/extra/autolink.data")
datafile = datafile.read()
datafile = datafile.split("\n")
for line in datafile:
if line.startswith("Link : "):
asset = line[7:]
win.current["linking_asset_data"]["assets"].append(asset)
except:
# So if it fails to load the file. Probably because it's not created
# yet. Let's load from the story. What's so bad about it?
link_from_script(win)
# Now keep in mind that to help the script that runs inside blender all
# assets have /dev/ in their folder. So to reach /ast/ blend file we will
# need to parse the link. It's not hard just reminding it here.
# IK everything is all over the place in the file but...
# If there is a process. We should be able to see what it does.
# Draw like a litte progress bar and stuff
if win.current["linking_asset_data"]["process"]:
# Basically during the execution of the linking. I want to read the
# output and give the user some feedback of what is going on.
currentline = win.current["linking_asset_data"]["process"].stdout.readline()[:-1]
# In the bpy_do_linking.py file there is an instruction to write
# out a fraction of a current operation into terminal. Which is
# piped into the VCStudio and I can read it. So we can use it
# to draw a progress bar.
if currentline.startswith("FRACTION:"):
try:
fraction = float(currentline.split(":")[1])
win.current["linking_asset_data"]["fraction"] = fraction
except:
pass
if currentline == "FINISHED":
win.current["linking_asset_data"]["process"] = False
win.current["linking_asset_data"]["fraction"] = 1
# The prgoress bar:
if win.current["linking_asset_data"]["fraction"]:
fraction = win.current["linking_asset_data"]["fraction"]
UI_color.set(layer, win, "progress_background")
UI_elements.roundrect(layer, win,
70,
win.current["h"]-75,
(win.current["w"]-220),
0,
7)
UI_color.set(layer, win, "progress_active")
UI_elements.roundrect(layer, win,
70,
win.current["h"]-75,
(win.current["w"]-220)*fraction,
0,
7)
# This file will fuel of nightmares. Okay. So while developping it I realzed
# one little problem. Overrides are kind a still buggy. Tho it's good to
# have them for future releases. And most of rigs work just fine.
# The thing that I want to do is to give the user options. Let's say their
# rig is broken when trying Library- Overrides but it's okay if you do
# legacy Proxy thing. So why not give the user the option of doing both.
# And also sometimes you just want to link and decide later what you do with
# your rig.
# So I gonna make 3 icons. 3 modes so to speak. LINK, OVERRIDE, PROXY.
linkoptions = {
"link":"link_mode_link",
"override":"link_mode_overrides", # Icon / Mode : Tooltip
"proxy":"link_mode_proxy"
}
for num, mode in enumerate(linkoptions):
if win.current["linking_asset_data"]["mode"] == mode:
UI_color.set(layer, win, "progress_time")
UI_elements.roundrect(layer, win,
50+(40*num),
50,
40,
40,
10)
def do():
win.current["linking_asset_data"]["mode"] = mode
UI_elements.roundrect(layer, win,
50+(40*num),
50,
40,
40,
10,
do,
mode,
tip=talk.text(linkoptions[mode]))
# Let's add a button that adds assets based on what's written in the script.
def do():
link_from_script(win)
UI_elements.roundrect(layer, win,
200,
50,
40,
40,
10,
do,
"scene_new",
tip=talk.text("link_add_from_scene"))
if not os.path.exists(win.project+win.current["linking_asset_data"]["selected"]+"/autolink.data")\
or not os.path.exists(win.project+win.current["linking_asset_data"]["selected"].replace("/dev/","/ast/")+".blend"):
def do():
def after(win, var):
print(var)
studio_dialogs.asset_configure(win, "configuring_asset", after,
win.current["linking_asset_data"]["selected"].replace("/dev",""))
UI_elements.roundrect(layer, win,
250,
50,
40,
40,
10,
button=do,
icon="link_configure")
# That's it. Now we are clipping and drawing the assets them selves.
UI_elements.roundrect(layer, win,
50,
100,
win.current["w"]-100,
win.current["h"]-200,
10,
fill=False)
layer.clip()
tileX = 70
current_Y = 0
if "asset_link" not in win.scroll:
win.scroll["asset_link"] = 0
#############################
# Let's draw the list of assets that the user chose.
for num, asset in enumerate(win.current["linking_asset_data"]["assets"]):
cur, name = asset.split("/")[2], asset.split("/")[3]
if int(current_Y + win.scroll["asset_link"] + 100) in range(0-100, win.current["h"]):
# Making the layer
nodesurface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 170, 200)
node = cairo.Context(nodesurface)
node.select_font_face("Monospace", cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL)
UI_elements.roundrect(node, win,
0,
0,
170,
200,
10,
fill=False)
node.clip()
# Background
UI_color.set(node, win, "dark_overdrop")
node.rectangle(0,0,170, 200)
node.fill()
# Banner
UI_color.set(node, win, "node_asset")
# Now the banner will be node_asset color if the asset is configured
# but it could be not configured. Or not even have the asset blend.
# so we need to quickly check both. And if any of them missing. Make
# the banner a node_badfile color.
warning = ""
if not os.path.exists(win.project+asset+"/autolink.data")\
or not os.path.exists(win.project+asset.replace("/dev/","/ast/")+".blend"):
UI_color.set(node, win, "node_badfile")
warning = "\n"+talk.text("link_asset_not_configured")
# Let's do even cooler. And let's draw a thing arround the asset.
node.set_line_width(10)
UI_elements.roundrect(node, win,
0,
0,
170,
200,
10,
fill=False)
node.stroke()
node.set_line_width(2)
# Even cooler. Let's put a configuration button right into here
node.rectangle(0,0,170, 20)
node.fill()
# Outputting the layer
layer.set_source_surface(nodesurface,
tileX-10,
current_Y + win.scroll["asset_link"] + 120)
layer.paint()
# Previes image
if os.path.exists(win.project+asset+"/renders/Preview.png"):
UI_elements.image(layer, win, win.project+asset+"/renders/Preview.png",
tileX,
current_Y + win.scroll["asset_link"] + 140,
150,
150)
elif os.path.exists(win.project+asset+"/renders/Preview.jpg"):
UI_elements.image(layer, win, win.project+asset+"/renders/Preview.jpg",
tileX,
current_Y + win.scroll["asset_link"] + 140,
150,
150)
else:
UI_elements.image(layer, win, "settings/themes/"+win.settings["Theme"]+"/icons/"+cur+".png",
tileX+55,
current_Y + win.scroll["asset_link"] + 150+55,
150,
150)
UI_color.set(layer, win, "text_normal")
layer.set_font_size(12)
layer.move_to(tileX,
current_Y + win.scroll["asset_link"] + 135)
layer.show_text(name[:22])
# Let's make a selection of an asset so you could delete one. Or
# do other stuff. Maybe.
if win.current["linking_asset_data"]["selected"] == asset:
layer.set_line_width(4)
UI_color.set(layer, win, "progress_background")
UI_elements.roundrect(layer, win,
tileX-10,
current_Y + win.scroll["asset_link"] + 120,
170,
200,
10,
fill=False)
layer.stroke()
layer.set_line_width(2)
# And the delete key.
if 65535 in win.current["keys"]:
try:
win.current["linking_asset_data"]["assets"].remove(asset)
except:
pass
win.current["keys"] = []
# Button to activate it
def do():
win.current["linking_asset_data"]["selected"] = asset
layer.set_line_width(4)
UI_elements.roundrect(layer, win,
tileX-10,
current_Y + win.scroll["asset_link"] + 120,
170,
200,
10,
button=do,
tip=talk.text(cur)+": "+name+warning,
fill=False,
clip=[
50,
100,
win.current["w"]-100,
win.current["h"]-200
],
url="asset_link")
layer.stroke()
layer.set_line_width(2)
tileX += 200
if tileX > win.current["w"]-220:
tileX = 70
current_Y += 230
# Now here I want to put the add new one button. So you could add assets
# to the stuff manually.
def do():
# Now this is going to be wild. Because I'm going to run a dialog with
# in a dialog. And I hope that it's going to work.
def after(win, var):
# Funny that it's actually working.
# Tho there is a little rub. If you press Cancel there is a bug that
# makes nothing unusable. so...
try:
del win.current["calls"]["link_add_asset_select"]
except:
pass
if var and "/dev"+var not in win.current["linking_asset_data"]["assets"]:
win.current["linking_asset_data"]["assets"].append("/dev"+var)
# So basically I want to add one only if there is not one already.
# And then select it. So if the use gets which one is added or
# whether it was already there.
win.current["linking_asset_data"]["selected"] = "/dev"+var
# And since it could allight with the add button. Let's clear the
# click
win.current["LMB"] = False
win.previous["LMB"] = False
studio_dialogs.asset_select(win, "link_add_asset_select", after)
UI_elements.roundrect(layer, win,
tileX-10,
current_Y + win.scroll["asset_link"] + 120,
170,
200,
10,
button=do,
url="asset_link")
UI_color.set(layer, win, "progress_background")
UI_elements.roundrect(layer, win,
tileX-10,
current_Y + win.scroll["asset_link"] + 120,
170,
200,
10,
fill=False)
layer.stroke()
UI_elements.image(layer, win,
"settings/themes/"+win.settings["Theme"]+"/icons/asset_new.png",
tileX+55,
current_Y + win.scroll["asset_link"] + 200,
40, 40)
#############################
current_Y += 230
UI_elements.scroll_area(layer, win, "asset_link",
50,
100,
win.current["w"]-100,
win.current["h"]-200,
current_Y,
bar=True,
mmb=True,
url="asset_link",
strenght=130
)
return surface
Reference in a new issue Copy permalink