262 lines
7.3 KiB
Python
262 lines
7.3 KiB
Python
# ##### BEGIN GPL LICENSE BLOCK #####
|
|
#
|
|
# 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 the Free Software Foundation; either version 2
|
|
# of the License, or (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, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
#
|
|
# ##### END GPL LICENSE BLOCK #####
|
|
|
|
# <pep8 compliant>
|
|
|
|
import logging
|
|
import typing
|
|
|
|
import bpy
|
|
import bgl
|
|
import gpu
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
strip_status_colour = {
|
|
None: (0.7, 0.7, 0.7),
|
|
"approved": (0.6392156862745098, 0.8784313725490196, 0.30196078431372547),
|
|
"final": (0.9058823529411765, 0.9607843137254902, 0.8274509803921568),
|
|
"in_progress": (1.0, 0.7450980392156863, 0.0),
|
|
"on_hold": (0.796078431372549, 0.6196078431372549, 0.08235294117647059),
|
|
"review": (0.8941176470588236, 0.9607843137254902, 0.9764705882352941),
|
|
"todo": (1.0, 0.5019607843137255, 0.5019607843137255),
|
|
}
|
|
|
|
CONFLICT_COLOUR = (0.576, 0.118, 0.035, 1.0) # RGBA tuple
|
|
|
|
gpu_vertex_shader = """
|
|
uniform mat4 ModelViewProjectionMatrix;
|
|
|
|
layout (location = 0) in vec2 pos;
|
|
layout (location = 1) in vec4 color;
|
|
|
|
out vec4 lineColor; // output to the fragment shader
|
|
|
|
void main()
|
|
{
|
|
gl_Position = ModelViewProjectionMatrix * vec4(pos.x, pos.y, 0.0, 1.0);
|
|
lineColor = color;
|
|
}
|
|
"""
|
|
|
|
gpu_fragment_shader = """
|
|
out vec4 fragColor;
|
|
in vec4 lineColor;
|
|
|
|
void main()
|
|
{
|
|
fragColor = lineColor;
|
|
}
|
|
"""
|
|
|
|
Float2 = typing.Tuple[float, float]
|
|
Float3 = typing.Tuple[float, float, float]
|
|
Float4 = typing.Tuple[float, float, float, float]
|
|
|
|
|
|
class AttractLineDrawer:
|
|
def __init__(self):
|
|
self._format = gpu.types.GPUVertFormat()
|
|
self._pos_id = self._format.attr_add(
|
|
id="pos", comp_type="F32", len=2, fetch_mode="FLOAT"
|
|
)
|
|
self._color_id = self._format.attr_add(
|
|
id="color", comp_type="F32", len=4, fetch_mode="FLOAT"
|
|
)
|
|
|
|
self.shader = gpu.types.GPUShader(gpu_vertex_shader, gpu_fragment_shader)
|
|
|
|
def draw(self, coords: typing.List[Float2], colors: typing.List[Float4]):
|
|
if not coords:
|
|
return
|
|
|
|
bgl.glEnable(bgl.GL_BLEND)
|
|
bgl.glLineWidth(2.0)
|
|
|
|
vbo = gpu.types.GPUVertBuf(len=len(coords), format=self._format)
|
|
vbo.attr_fill(id=self._pos_id, data=coords)
|
|
vbo.attr_fill(id=self._color_id, data=colors)
|
|
|
|
batch = gpu.types.GPUBatch(type="LINES", buf=vbo)
|
|
batch.program_set(self.shader)
|
|
batch.draw()
|
|
|
|
|
|
def get_strip_rectf(strip) -> Float4:
|
|
# Get x and y in terms of the grid's frames and channels
|
|
x1 = strip.frame_final_start
|
|
x2 = strip.frame_final_end
|
|
y1 = strip.channel + 0.2
|
|
y2 = strip.channel - 0.2 + 1
|
|
|
|
return x1, y1, x2, y2
|
|
|
|
|
|
def underline_in_strip(
|
|
strip_coords: Float4,
|
|
pixel_size_x: float,
|
|
color: Float4,
|
|
out_coords: typing.List[Float2],
|
|
out_colors: typing.List[Float4],
|
|
):
|
|
# Strip coords
|
|
s_x1, s_y1, s_x2, s_y2 = strip_coords
|
|
|
|
# be careful not to draw over the current frame line
|
|
cf_x = bpy.context.scene.frame_current_final
|
|
|
|
# TODO(Sybren): figure out how to pass one colour per line,
|
|
# instead of one colour per vertex.
|
|
out_coords.append((s_x1, s_y1))
|
|
out_colors.append(color)
|
|
|
|
if s_x1 < cf_x < s_x2:
|
|
# Bad luck, the line passes our strip, so draw two lines.
|
|
out_coords.append((cf_x - pixel_size_x, s_y1))
|
|
out_colors.append(color)
|
|
|
|
out_coords.append((cf_x + pixel_size_x, s_y1))
|
|
out_colors.append(color)
|
|
|
|
out_coords.append((s_x2, s_y1))
|
|
out_colors.append(color)
|
|
|
|
|
|
def strip_conflict(
|
|
strip_coords: Float4,
|
|
out_coords: typing.List[Float2],
|
|
out_colors: typing.List[Float4],
|
|
):
|
|
"""Draws conflicting states between strips."""
|
|
|
|
s_x1, s_y1, s_x2, s_y2 = strip_coords
|
|
|
|
# TODO(Sybren): draw a rectangle instead of a line.
|
|
out_coords.append((s_x1, s_y2))
|
|
out_colors.append(CONFLICT_COLOUR)
|
|
|
|
out_coords.append((s_x2, s_y1))
|
|
out_colors.append(CONFLICT_COLOUR)
|
|
|
|
out_coords.append((s_x2, s_y2))
|
|
out_colors.append(CONFLICT_COLOUR)
|
|
|
|
out_coords.append((s_x1, s_y1))
|
|
out_colors.append(CONFLICT_COLOUR)
|
|
|
|
|
|
def draw_callback_px(line_drawer: AttractLineDrawer):
|
|
context = bpy.context
|
|
|
|
if not context.scene.sequence_editor:
|
|
return
|
|
|
|
from . import shown_strips
|
|
|
|
region = context.region
|
|
xwin1, ywin1 = region.view2d.region_to_view(0, 0)
|
|
xwin2, ywin2 = region.view2d.region_to_view(region.width, region.height)
|
|
one_pixel_further_x, one_pixel_further_y = region.view2d.region_to_view(1, 1)
|
|
pixel_size_x = one_pixel_further_x - xwin1
|
|
|
|
strips = shown_strips(context)
|
|
|
|
coords = [] # type: typing.List[Float2]
|
|
colors = [] # type: typing.List[Float4]
|
|
|
|
# Collect all the lines (vertex coords + vertex colours) to draw.
|
|
for strip in strips:
|
|
if not strip.atc_object_id:
|
|
continue
|
|
|
|
# Get corners (x1, y1), (x2, y2) of the strip rectangle in px region coords
|
|
strip_coords = get_strip_rectf(strip)
|
|
|
|
# check if any of the coordinates are out of bounds
|
|
if (
|
|
strip_coords[0] > xwin2
|
|
or strip_coords[2] < xwin1
|
|
or strip_coords[1] > ywin2
|
|
or strip_coords[3] < ywin1
|
|
):
|
|
continue
|
|
|
|
# Draw
|
|
status = strip.atc_status
|
|
if status in strip_status_colour:
|
|
color = strip_status_colour[status]
|
|
else:
|
|
color = strip_status_colour[None]
|
|
|
|
alpha = 1.0 if strip.atc_is_synced else 0.5
|
|
|
|
underline_in_strip(strip_coords, pixel_size_x, color + (alpha,), coords, colors)
|
|
if strip.atc_is_synced and strip.atc_object_id_conflict:
|
|
strip_conflict(strip_coords, coords, colors)
|
|
|
|
line_drawer.draw(coords, colors)
|
|
|
|
|
|
def tag_redraw_all_sequencer_editors():
|
|
context = bpy.context
|
|
|
|
# Py cant access notifiers
|
|
for window in context.window_manager.windows:
|
|
for area in window.screen.areas:
|
|
if area.type == "SEQUENCE_EDITOR":
|
|
for region in area.regions:
|
|
if region.type == "WINDOW":
|
|
region.tag_redraw()
|
|
|
|
|
|
# This is a list so it can be changed instead of set
|
|
# if it is only changed, it does not have to be declared as a global everywhere
|
|
cb_handle = []
|
|
|
|
|
|
def callback_enable():
|
|
if cb_handle:
|
|
return
|
|
|
|
# Doing GPU stuff in the background crashes Blender, so let's not.
|
|
if bpy.app.background:
|
|
return
|
|
|
|
line_drawer = AttractLineDrawer()
|
|
cb_handle[:] = (
|
|
bpy.types.SpaceSequenceEditor.draw_handler_add(
|
|
draw_callback_px, (line_drawer,), "WINDOW", "POST_VIEW"
|
|
),
|
|
)
|
|
|
|
tag_redraw_all_sequencer_editors()
|
|
|
|
|
|
def callback_disable():
|
|
if not cb_handle:
|
|
return
|
|
|
|
try:
|
|
bpy.types.SpaceSequenceEditor.draw_handler_remove(cb_handle[0], "WINDOW")
|
|
except ValueError:
|
|
# Thrown when already removed.
|
|
pass
|
|
cb_handle.clear()
|
|
|
|
tag_redraw_all_sequencer_editors()
|