def draw(self, context):
log("Draw")
if not self.is_synced:
return
stage = self.stage
if not stage:
return
view_settings = ViewSettings(context)
if view_settings.width * view_settings.height == 0:
return
gf_camera = view_settings.export_camera()
self.renderer.SetCameraState(
gf_camera.frustum.ComputeViewMatrix(),
gf_camera.frustum.ComputeProjectionMatrix())
if self.is_gl_delegate:
self.renderer.SetRenderViewport(
(*view_settings.border[0], *view_settings.border[1]))
else:
self.renderer.SetRenderViewport((0, 0, *view_settings.border[1]))
self.renderer.SetRendererAov('color')
self.render_params.renderResolution = (view_settings.width,
view_settings.height)
if self.is_gl_delegate:
bgl.glEnable(bgl.GL_DEPTH_TEST)
else:
bgl.glDisable(bgl.GL_DEPTH_TEST)
bgl.glViewport(*view_settings.border[0], *view_settings.border[1])
bgl.glClearColor(0.0, 0.0, 0.0, 0.0)
bgl.glClearDepth(1.0)
bgl.glClear(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_DEPTH_BUFFER_BIT)
# Bind shader that converts from scene linear to display space,
bgl.glEnable(bgl.GL_BLEND)
bgl.glBlendFunc(bgl.GL_ONE, bgl.GL_ONE_MINUS_SRC_ALPHA)
self.render_engine.bind_display_space_shader(context.scene)
try:
self.renderer.Render(stage.GetPseudoRoot(), self.render_params)
except Exception as e:
log.error(e)
self.render_engine.unbind_display_space_shader()
bgl.glDisable(bgl.GL_BLEND)
if not self.renderer.IsConverged():
self.notify_status("Rendering...", "")
else:
self.notify_status("Rendering Done", "", False)
def clear(self):
is_bound = self is _SnapOffscreen.bound
if not is_bound:
self.bind()
bgl.glColorMask(bgl.GL_TRUE, bgl.GL_TRUE, bgl.GL_TRUE, bgl.GL_TRUE)
bgl.glClearColor(0.0, 0.0, 0.0, 0.0)
bgl.glDepthMask(bgl.GL_TRUE)
bgl.glClearDepth(1.0);
bgl.glClear(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_DEPTH_BUFFER_BIT)
if not is_bound:
self.unbind()
def clear(self):
is_bound = self is _SnapOffscreen.bound
if not is_bound:
self.bind()
bgl.glColorMask(bgl.GL_TRUE, bgl.GL_TRUE, bgl.GL_TRUE, bgl.GL_TRUE)
bgl.glClearColor(0.0, 0.0, 0.0, 0.0)
bgl.glDepthMask(bgl.GL_TRUE)
bgl.glClearDepth(1.0);
bgl.glClear(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_DEPTH_BUFFER_BIT)
if not is_bound:
self.unbind()
def _render_gl(self, scene):
CLEAR_COLOR = (0.0, 0.0, 0.0, 0.0)
CLEAR_DEPTH = 1.0
# creating draw_target
draw_target = Glf.DrawTarget(self.width, self.height)
draw_target.Bind()
draw_target.AddAttachment("color", bgl.GL_RGBA, bgl.GL_FLOAT, bgl.GL_RGBA)
draw_target.AddAttachment("depth", bgl.GL_DEPTH_COMPONENT, bgl.GL_FLOAT,
bgl.GL_DEPTH_COMPONENT32F)
# creating renderer
renderer = UsdImagingGL.Engine()
log("Hydra render:", scene.hdusd.final.delegate)
renderer.SetRendererPlugin(scene.hdusd.final.delegate)
# setting camera
self._set_scene_camera(renderer, scene)
renderer.SetRenderViewport((0, 0, self.width, self.height))
renderer.SetRendererAov('color')
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glViewport(0, 0, self.width, self.height)
bgl.glClearColor(*CLEAR_COLOR)
bgl.glClearDepth(CLEAR_DEPTH)
bgl.glClear(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_DEPTH_BUFFER_BIT)
root = self.stage.GetPseudoRoot()
params = UsdImagingGL.RenderParams()
params.renderResolution = (self.width, self.height)
params.frame = Usd.TimeCode.Default()
params.clearColor = CLEAR_COLOR
try:
renderer.Render(root, params)
except Exception as e:
log.error(e)
self.update_render_result({
'Combined': gl.get_framebuffer_data(self.width, self.height)
})
draw_target.Unbind()
# it's important to clear data explicitly
draw_target = None
renderer = None
def draw_callback(self, context):
"""
:type context: bpy.types.Context
"""
prefs = QuickBooleanPreferences.get_instance()
color = prefs.color
snap_color = prefs.snap_color
region = context.region
glsettings = vagl.GLSettings(context)
glsettings.push()
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(*color)
show_reversed = False
if self.reverse:
if self.mode == 'POLYGON':
if len(self.mouse_coords) >= 3:
show_reversed = True
else:
if len(self.mouse_coords) >= 2:
if self.mouse_coords[0] != self.mouse_coords[1]:
show_reversed = True
if show_reversed:
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glClearDepth(1.0)
bgl.glClear(bgl.GL_DEPTH_BUFFER_BIT)
bgl.glDepthMask(1)
bgl.glColorMask(0, 0, 0, 0)
lines = []
if self.mouse_coords:
if self.mode == 'LINE':
w = region.width
h = region.height
p1, p2 = self.mouse_coords
line = (p2 - p1).normalized()
normal = Vector([-line[1], line[0]])
corners = [
Vector([0, 0]),
Vector([w, 0]),
Vector([w, h]),
Vector([0, h])
]
corners_ofs = [v - p1 for v in corners]
dists = [v.project(line).dot(line) for v in corners_ofs]
i = dists.index(min(dists))
line_min = corners_ofs[i].project(line) + p1
i = dists.index(max(dists))
line_max = corners_ofs[i].project(line) + p1
dists = [v.project(normal).dot(normal) for v in corners_ofs]
i = dists.index(max(dists))
normal_max_f = corners_ofs[i].project(normal).dot(normal)
vec = normal * normal_max_f
coords = [line_min, line_max, line_max + vec, line_min + vec]
bgl.glBegin(bgl.GL_QUADS)
for co in coords:
bgl.glVertex2f(*co)
bgl.glEnd()
lines = self.mouse_coords
elif self.mode == 'BOX':
p1, p2 = self.mouse_coords
bgl.glRectf(p1[0], p1[1], p2[0], p2[1])
lines = [
p1,
Vector((p2[0], p1[1])),
Vector((p2[0], p2[1])),
Vector((p1[0], p2[1])), p1
]
elif self.mode == 'CIRCLE':
p1, p2 = self.mouse_coords
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
bgl.glVertex2f(*p1)
r = (p2 - p1).length
coords = calc_circle_coords(p1, r, self.circle_segments,
self.circle_direction)
for co in coords:
bgl.glVertex2f(*co)
bgl.glVertex2f(*coords[0])
bgl.glEnd()
lines = coords + [coords[0]]
elif self.mode == 'POLYGON':
if len(self.mouse_coords) >= 3:
tris = mathutils.geometry.tessellate_polygon(
[[co.to_3d() for co in self.mouse_coords]])
bgl.glBegin(bgl.GL_TRIANGLES)
for tri in tris:
for i in tri:
bgl.glVertex2f(*self.mouse_coords[i])
bgl.glEnd()
if len(self.mouse_coords) > 1:
lines = self.mouse_coords + [self.mouse_coords[0]]
if show_reversed:
bgl.glColorMask(1, 1, 1, 1)
bgl.glBegin(bgl.GL_QUADS)
bgl.glVertex3f(0, 0, -1)
bgl.glVertex3f(region.width, 0, -1)
bgl.glVertex3f(region.width, region.height, -1)
bgl.glVertex3f(0, region.height, -1)
bgl.glEnd()
bgl.glDisable(bgl.GL_DEPTH_TEST)
bgl.glColor4f(*color[:3], 1.0)
bgl.glPointSize(1)
bgl.glLineWidth(1)
if len(lines) > 1:
bgl.glBegin(bgl.GL_LINE_STRIP)
for co in lines:
bgl.glVertex2f(*co)
bgl.glEnd()
if self.mode == 'POLYGON':
if len(self.mouse_coords) == 1:
bgl.glPointSize(5)
bgl.glBegin(bgl.GL_POINTS)
for co in self.mouse_coords:
bgl.glVertex2f(*co)
bgl.glEnd()
bgl.glPointSize(1)
bgl.glLineWidth(1)
if self.mco_ctrl:
SIZE = 12
bgl.glColor4f(*snap_color)
bgl.glBegin(bgl.GL_LINE_LOOP)
v = self.mco_mod
x = v[0] - SIZE / 2
y = v[1] - SIZE / 2
bgl.glVertex2f(x, y)
bgl.glVertex2f(x + SIZE, y)
bgl.glVertex2f(x + SIZE, y + SIZE)
bgl.glVertex2f(x, y + SIZE)
bgl.glEnd()
glsettings.pop()
glsettings.font_size()
def render_main_svg(self, context, animation=False):
# Save old info
scene = context.scene
sceneProps= scene.MeasureItArchProps
sceneProps.is_render_draw = True
sceneProps.is_vector_draw = True
clipdepth = context.scene.camera.data.clip_end
path = scene.render.filepath
objlist = context.view_layer.objects
# --------------------
# Get resolution
# --------------------
render_scale = scene.render.resolution_percentage / 100
width = int(scene.render.resolution_x * render_scale)
height = int(scene.render.resolution_y * render_scale)
offscreen = gpu.types.GPUOffScreen(width, height)
view_matrix_3d = scene.camera.matrix_world.inverted()
projection_matrix = scene.camera.calc_matrix_camera(context.view_layer.depsgraph, x=width, y=height)
# Render Depth Buffer
with offscreen.bind():
# Clear Depth Buffer, set Clear Depth to Cameras Clip Distance
bgl.glClear(bgl.GL_DEPTH_BUFFER_BIT)
bgl.glClearDepth(clipdepth)
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glDepthFunc(bgl.GL_LEQUAL)
gpu.matrix.reset()
gpu.matrix.load_matrix(view_matrix_3d)
gpu.matrix.load_projection_matrix(projection_matrix)
texture_buffer = bgl.Buffer(bgl.GL_BYTE, width * height * 4)
draw_scene(self, context, projection_matrix)
bgl.glReadBuffer(bgl.GL_BACK)
bgl.glReadPixels(0, 0, width, height, bgl.GL_RGBA, bgl.GL_UNSIGNED_BYTE, texture_buffer)
if 'depthbuffer' in sceneProps:
del sceneProps['depthbuffer']
sceneProps['depthbuffer'] = texture_buffer
offscreen.free()
if True:
if not str('test') in bpy.data.images:
bpy.data.images.new(str('test'), width, height)
image = bpy.data.images[str('test')]
image.scale(width, height)
image.pixels = [v / 255 for v in texture_buffer]
# Setup Output Path
ren_path = bpy.context.scene.render.filepath
filename = "mit_vector"
ftxt = "%04d" % scene.frame_current
outpath = (ren_path + filename + ftxt + '.svg')
# Setup basic svg
svg = svgwrite.Drawing(
outpath,
debug=False,
size=('{}mm'.format(width), '{}mm'.format(height)),
viewBox=('0 0 {} {}'.format(width,height)),
id='root',
)
# -----------------------------
# Loop to draw all objects
# -----------------------------
for myobj in objlist:
if myobj.visible_get() is True:
mat = myobj.matrix_world
if 'DimensionGenerator' in myobj:
measureGen = myobj.DimensionGenerator[0]
if 'alignedDimensions' in measureGen:
for linDim in measureGen.alignedDimensions:
draw_alignedDimension(context, myobj, measureGen,linDim,mat,svg=svg)
if 'angleDimensions' in measureGen:
for dim in measureGen.angleDimensions:
draw_angleDimension(context, myobj, measureGen,dim,mat,svg=svg)
if 'axisDimensions' in measureGen:
for dim in measureGen.axisDimensions:
draw_axisDimension(context, myobj, measureGen,dim,mat,svg=svg)
if 'boundsDimensions' in measureGen:
for dim in measureGen.boundsDimensions:
draw_boundsDimension(context, myobj, measureGen,dim,mat,svg=svg)
if 'arcDimensions' in measureGen:
for dim in measureGen.arcDimensions:
draw_arcDimension(context, myobj, measureGen,dim,mat,svg=svg)
if 'areaDimensions' in measureGen:
for dim in measureGen.areaDimensions:
draw_areaDimension(context, myobj, measureGen,dim,mat,svg=svg)
if 'LineGenerator' in myobj:
# Draw Line Groups
op = myobj.LineGenerator[0]
draw_line_group(context, myobj, op, mat,svg=svg)
#if 'AnnotationGenerator' in myobj:
# op = myobj.AnnotationGenerator[0]
# draw_annotation(context, myobj, op, mat)
if False:
# Draw Instance
deps = bpy.context.view_layer.depsgraph
for obj_int in deps.object_instances:
if obj_int.is_instance:
myobj = obj_int.object
mat = obj_int.matrix_world
if 'LineGenerator' in myobj:
lineGen = myobj.LineGenerator[0]
draw_line_group(context,myobj,lineGen,mat)
if sceneProps.instance_dims:
if 'AnnotationGenerator' in myobj:
annotationGen = myobj.AnnotationGenerator[0]
draw_annotation(context,myobj,annotationGen,mat)
if 'DimensionGenerator' in myobj:
DimGen = myobj.DimensionGenerator[0]
for alignedDim in DimGen.alignedDimensions:
draw_alignedDimension(context, myobj, DimGen, alignedDim,mat)
for angleDim in DimGen.angleDimensions:
draw_angleDimension(context, myobj, DimGen, angleDim,mat)
for axisDim in DimGen.axisDimensions:
draw_axisDimension(context,myobj,DimGen,axisDim,mat)
svg.save(pretty=True)
# restore default value
sceneProps.is_render_draw = False
sceneProps.is_vector_draw = False
return True
def render_main(self, context, animation=False):
# Save old info
scene = context.scene
sceneProps= scene.MeasureItArchProps
sceneProps.is_render_draw = True
bgl.glEnable(bgl.GL_MULTISAMPLE)
clipdepth = context.scene.camera.data.clip_end
objlist = context.view_layer.objects
# --------------------
# Get resolution
# --------------------
render_scale = scene.render.resolution_percentage / 100
width = int(scene.render.resolution_x * render_scale)
height = int(scene.render.resolution_y * render_scale)
# --------------------------------------
# Draw all lines in Offsecreen
# --------------------------------------
offscreen = gpu.types.GPUOffScreen(width, height)
view_matrix = Matrix([
[2 / width, 0, 0, -1],
[0, 2 / height, 0, -1],
[0, 0, 1, 0],
[0, 0, 0, 1]])
view_matrix_3d = scene.camera.matrix_world.inverted()
projection_matrix = scene.camera.calc_matrix_camera(context.view_layer.depsgraph, x=width, y=height)
with offscreen.bind():
# Clear Depth Buffer, set Clear Depth to Cameras Clip Distance
bgl.glClear(bgl.GL_DEPTH_BUFFER_BIT)
bgl.glClearDepth(clipdepth)
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glDepthFunc(bgl.GL_LEQUAL)
gpu.matrix.reset()
gpu.matrix.load_matrix(view_matrix_3d)
gpu.matrix.load_projection_matrix(projection_matrix)
draw_scene(self, context, projection_matrix)
# Clear Color Keep on depth info
bgl.glClearColor(0,0,0,0)
bgl.glClear(bgl.GL_COLOR_BUFFER_BIT)
# -----------------------------
# Loop to draw all objects
# -----------------------------
for myobj in objlist:
if myobj.visible_get() is True:
mat = myobj.matrix_world
sheetGen = myobj.SheetGenerator
for sheet_view in sheetGen.sheet_views:
draw_sheet_views(context,myobj,sheetGen,sheet_view,mat)
if 'DimensionGenerator' in myobj:
measureGen = myobj.DimensionGenerator[0]
if 'alignedDimensions' in measureGen:
for linDim in measureGen.alignedDimensions:
draw_alignedDimension(context, myobj, measureGen,linDim,mat)
if 'angleDimensions' in measureGen:
for dim in measureGen.angleDimensions:
draw_angleDimension(context, myobj, measureGen,dim,mat)
if 'axisDimensions' in measureGen:
for dim in measureGen.axisDimensions:
draw_axisDimension(context, myobj, measureGen,dim,mat)
if 'boundsDimensions' in measureGen:
for dim in measureGen.boundsDimensions:
draw_boundsDimension(context, myobj, measureGen,dim,mat)
if 'arcDimensions' in measureGen:
for dim in measureGen.arcDimensions:
draw_arcDimension(context, myobj, measureGen,dim,mat)
if 'areaDimensions' in measureGen:
for dim in measureGen.areaDimensions:
draw_areaDimension(context, myobj, measureGen,dim,mat)
if 'LineGenerator' in myobj:
# Set 3D Projection Martix
gpu.matrix.reset()
gpu.matrix.load_matrix(view_matrix_3d)
gpu.matrix.load_projection_matrix(projection_matrix)
# Draw Line Groups
op = myobj.LineGenerator[0]
draw_line_group(context, myobj, op, mat)
if 'AnnotationGenerator' in myobj:
# Set 3D Projection Martix
gpu.matrix.reset()
gpu.matrix.load_matrix(view_matrix_3d)
gpu.matrix.load_projection_matrix(projection_matrix)
# Draw Line Groups
op = myobj.AnnotationGenerator[0]
draw_annotation(context, myobj, op, mat)
# Draw Instance
deps = bpy.context.view_layer.depsgraph
for obj_int in deps.object_instances:
if obj_int.is_instance:
myobj = obj_int.object
mat = obj_int.matrix_world
if 'LineGenerator' in myobj:
lineGen = myobj.LineGenerator[0]
draw_line_group(context,myobj,lineGen,mat)
if sceneProps.instance_dims:
if 'AnnotationGenerator' in myobj:
annotationGen = myobj.AnnotationGenerator[0]
draw_annotation(context,myobj,annotationGen,mat)
if 'DimensionGenerator' in myobj:
DimGen = myobj.DimensionGenerator[0]
for alignedDim in DimGen.alignedDimensions:
draw_alignedDimension(context, myobj, DimGen, alignedDim,mat)
for angleDim in DimGen.angleDimensions:
draw_angleDimension(context, myobj, DimGen, angleDim,mat)
for axisDim in DimGen.axisDimensions:
draw_axisDimension(context,myobj,DimGen,axisDim,mat)
buffer = bgl.Buffer(bgl.GL_BYTE, width * height * 4)
bgl.glReadBuffer(bgl.GL_COLOR_ATTACHMENT0)
bgl.glReadPixels(0, 0, width, height, bgl.GL_RGBA, bgl.GL_UNSIGNED_BYTE, buffer)
offscreen.free()
# -----------------------------
# Create image
# -----------------------------
image_name = "measureit_arch_output"
if image_name not in bpy.data.images:
bpy.data.images.new(image_name, width, height)
image = bpy.data.images[image_name]
image.scale(width, height)
image.pixels = [v / 255 for v in buffer]
# Saves image
if image is not None and (scene.measureit_arch_render is True or animation is True):
ren_path = bpy.context.scene.render.filepath
filename = "mit_frame"
ftxt = "%04d" % scene.frame_current
outpath = (ren_path + filename + ftxt + '.png')
save_image(self, outpath, image)
# restore default value
sceneProps.is_render_draw = False
return True, buffer
def render_main(self, context, animation=False):
# Save old info
bgl.glEnable(bgl.GL_MULTISAMPLE)
settings = bpy.context.scene.render.image_settings
depth = settings.color_depth
settings.color_depth = '16'
scene = context.scene
clipdepth = context.scene.camera.data.clip_end
path = scene.render.filepath
objlist = context.view_layer.objects
# --------------------
# Get resolution
# --------------------
render_scale = scene.render.resolution_percentage / 100
width = int(scene.render.resolution_x * render_scale)
height = int(scene.render.resolution_y * render_scale)
# --------------------------------------
# Draw all lines in Offsecreen
# --------------------------------------
offscreen = gpu.types.GPUOffScreen(width, height)
view_matrix = Matrix([
[2 / width, 0, 0, -1],
[0, 2 / height, 0, -1],
[0, 0, 1, 0],
[0, 0, 0, 1]])
view_matrix_3d = scene.camera.matrix_world.inverted()
projection_matrix = scene.camera.calc_matrix_camera(context.view_layer.depsgraph, x=width, y=height)
scene.measureit_arch_is_render_draw = True
with offscreen.bind():
# Clear Depth Buffer, set Clear Depth to Cameras Clip Distance
bgl.glClearDepth(clipdepth)
bgl.glClear(bgl.GL_DEPTH_BUFFER_BIT)
# Draw Scene If Necessary
if scene.measureit_arch_use_depth_clipping is True:
draw_scene(self, context, projection_matrix)
# Clear Color Keep on depth info
bgl.glClear(bgl.GL_COLOR_BUFFER_BIT)
# -----------------------------
# Loop to draw all objects
# -----------------------------
for myobj in objlist:
if myobj.visible_get() is True:
if 'DimensionGenerator' in myobj:
measureGen = myobj.DimensionGenerator[0]
for linDim in measureGen.alignedDimensions:
draw_alignedDimension(context, myobj, measureGen,linDim)
for dim in measureGen.angleDimensions:
draw_angleDimension(context, myobj, measureGen,dim)
if 'LineGenerator' in myobj:
# Set 3D Projection Martix
gpu.matrix.reset()
gpu.matrix.load_matrix(view_matrix_3d)
gpu.matrix.load_projection_matrix(projection_matrix)
# Draw Line Groups
op = myobj.LineGenerator[0]
draw_line_group(context, myobj, op)
if 'AnnotationGenerator' in myobj:
# Set 3D Projection Martix
gpu.matrix.reset()
gpu.matrix.load_matrix(view_matrix_3d)
gpu.matrix.load_projection_matrix(projection_matrix)
# Draw Line Groups
op = myobj.AnnotationGenerator[0]
draw_annotation(context, myobj, op)
# -----------------------------
# Loop to draw all debug
# -----------------------------
if scene.measureit_arch_debug is True:
selobj = bpy.context.selected_objects
for myobj in selobj:
if scene.measureit_arch_debug_objects is True:
draw_object(context, myobj, None, None)
elif scene.measureit_arch_debug_object_loc is True:
draw_object(context, myobj, None, None)
if scene.measureit_arch_debug_vertices is True:
draw_vertices(context, myobj, None, None)
elif scene.measureit_arch_debug_vert_loc is True:
draw_vertices(context, myobj, None, None)
if scene.measureit_arch_debug_edges is True:
draw_edges(context, myobj, None, None)
if scene.measureit_arch_debug_faces is True or scene.measureit_arch_debug_normals is True:
draw_faces(context, myobj, None, None)
# -----------------------------
# Draw a rectangle frame
# -----------------------------
if scene.measureit_arch_rf is True:
rfcolor = scene.measureit_arch_rf_color
rfborder = scene.measureit_arch_rf_border
rfline = scene.measureit_arch_rf_line
bgl.glLineWidth(rfline)
x1 = rfborder
x2 = width - rfborder
y1 = int(ceil(rfborder / (width / height)))
y2 = height - y1
draw_rectangle((x1, y1), (x2, y2))
buffer = bgl.Buffer(bgl.GL_BYTE, width * height * 4)
bgl.glReadBuffer(bgl.GL_COLOR_ATTACHMENT0)
bgl.glReadPixels(0, 0, width, height, bgl.GL_RGBA, bgl.GL_UNSIGNED_BYTE, buffer)
offscreen.free()
scene.measureit_arch_is_render_draw = False
# -----------------------------
# Create image
# -----------------------------
image_name = "measureit_arch_output"
if image_name not in bpy.data.images:
bpy.data.images.new(image_name, width, height)
image = bpy.data.images[image_name]
image.scale(width, height)
image.pixels = [v / 255 for v in buffer]
# Saves image
if image is not None and (scene.measureit_arch_render is True or animation is True):
ren_path = bpy.context.scene.render.filepath
filename = "mit_frame"
ftxt = "%04d" % scene.frame_current
outpath = (ren_path + filename + ftxt + ".png")
save_image(self, outpath, image)
# restore default value
settings.color_depth = depth
def render_main_svg(self, context, animation=False):
# Save old info
scene = context.scene
sceneProps = scene.MeasureItArchProps
sceneProps.is_render_draw = True
sceneProps.is_vector_draw = True
clipdepth = context.scene.camera.data.clip_end
path = bpy.path.abspath(scene.render.filepath)
objlist = context.view_layer.objects
# --------------------
# Get resolution
# --------------------
render_scale = scene.render.resolution_percentage / 100
width = int(scene.render.resolution_x * render_scale)
height = int(scene.render.resolution_y * render_scale)
offscreen = gpu.types.GPUOffScreen(width, height)
view_matrix_3d = scene.camera.matrix_world.inverted()
projection_matrix = scene.camera.calc_matrix_camera(
context.view_layer.depsgraph, x=width, y=height)
# Render Depth Buffer
print("Rendering Depth Buffer")
if sceneProps.vector_depthtest:
with offscreen.bind():
# Clear Depth Buffer, set Clear Depth to Cameras Clip Distance
set_OpenGL_Settings(True)
bgl.glClear(bgl.GL_DEPTH_BUFFER_BIT)
bgl.glClearDepth(clipdepth)
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glDepthFunc(bgl.GL_LEQUAL)
gpu.matrix.reset()
gpu.matrix.load_matrix(view_matrix_3d)
gpu.matrix.load_projection_matrix(projection_matrix)
texture_buffer = bgl.Buffer(bgl.GL_FLOAT, width * height)
draw_scene(self, context, projection_matrix)
bgl.glReadBuffer(bgl.GL_BACK)
bgl.glReadPixels(0, 0, width, height, bgl.GL_DEPTH_COMPONENT,
bgl.GL_FLOAT, texture_buffer)
if 'depthbuffer' in sceneProps:
del sceneProps['depthbuffer']
sceneProps['depthbuffer'] = texture_buffer
offscreen.free()
set_OpenGL_Settings(False)
if False:
imageName = 'depthBufferTest'
if not imageName in bpy.data.images:
bpy.data.images.new(imageName,
width,
height,
alpha=False,
float_buffer=True,
is_data=True)
image = bpy.data.images[imageName]
image.scale(width, height)
image.pixels = [v for v in texture_buffer]
# Setup Output Path
ren_path = path
filename = "mit_vector"
ftxt = "%04d" % scene.frame_current
outpath = (ren_path + filename + ftxt + '.svg')
view = get_view()
paperWidth = width / sceneProps.default_resolution
paperHeight = height / sceneProps.default_resolution
try:
if view.res_type == 'res_type_paper':
paperWidth = round(view.width * 39.370078740196853, 3)
paperHeight = round(view.height * 39.370078740196853, 3)
except:
print('No View Present, using default resolution')
# Setup basic svg
svg = svgwrite.Drawing(
outpath,
debug=False,
size=('{}in'.format(paperWidth), '{}in'.format(paperHeight)),
viewBox=('0 0 {} {}'.format(width, height)),
id='root',
)
if sceneProps.embed_scene_render:
lastformat = scene.render.image_settings.file_format
scene.render.image_settings.file_format = 'PNG'
scene.render.use_file_extension = True
bpy.ops.render.render(write_still=True)
image_path = bpy.context.scene.render.filepath
svg.add(
svg.image(os.path.basename(image_path + '.png'), **{
'width': width,
'height': height
}))
scene.render.image_settings.file_format = lastformat
# -----------------------------
# Loop to draw all objects
# -----------------------------
draw3d_loop(context, objlist, svg=svg)
draw_titleblock(context, svg=svg)
svg.save(pretty=True)
# restore default value
sceneProps.is_render_draw = False
sceneProps.is_vector_draw = False
return True
def render_main(self, context, animation=False):
scene = context.scene
sceneProps = scene.MeasureItArchProps
sceneProps.is_render_draw = True
clipdepth = context.scene.camera.data.clip_end
objlist = context.view_layer.objects
# Get resolution
render_scale = scene.render.resolution_percentage / 100
width = int(scene.render.resolution_x * render_scale)
height = int(scene.render.resolution_y * render_scale)
# Draw all lines in Offsecreen
renderoffscreen = gpu.types.GPUOffScreen(width, height)
view_matrix_3d = scene.camera.matrix_world.inverted()
projection_matrix = scene.camera.calc_matrix_camera(
context.view_layer.depsgraph, x=width, y=height)
set_OpenGL_Settings(True)
with renderoffscreen.bind():
# Clear Depth Buffer, set Clear Depth to Cameras Clip Distance
bgl.glClear(bgl.GL_DEPTH_BUFFER_BIT)
bgl.glClearDepth(clipdepth)
gpu.matrix.reset()
gpu.matrix.load_matrix(view_matrix_3d)
gpu.matrix.load_projection_matrix(projection_matrix)
# Draw Scene for the depth buffer
draw_scene(self, context, projection_matrix)
# Clear Color Buffer, we only need the depth info
bgl.glClearColor(0, 0, 0, 0)
bgl.glClear(bgl.GL_COLOR_BUFFER_BIT)
# -----------------------------
# Loop to draw all objects
# -----------------------------
draw3d_loop(context, objlist)
draw_titleblock(context)
buffer = bgl.Buffer(bgl.GL_BYTE, width * height * 4)
bgl.glReadBuffer(bgl.GL_COLOR_ATTACHMENT0)
bgl.glReadPixels(0, 0, width, height, bgl.GL_RGBA,
bgl.GL_UNSIGNED_BYTE, buffer)
# -----------------------------
# Create image
# -----------------------------
image_name = "measureit_arch_output"
if image_name not in bpy.data.images:
image = bpy.data.images.new(image_name, width, height)
image = bpy.data.images[image_name]
image.scale(width, height)
image.pixels = [v / 255 for v in buffer]
renderoffscreen.free()
# Saves image
if image is not None and animation is True:
ren_path = bpy.context.scene.render.filepath
filename = "mit_frame"
ftxt = "%04d" % scene.frame_current
outpath = (ren_path + filename + ftxt + '.png')
save_image(self, outpath, image)
# restore default value
set_OpenGL_Settings(False)
sceneProps.is_render_draw = False
return True, buffer
def draw_callback(self, context):
"""
:type context: bpy.types.Context
"""
prefs = QuickBooleanPreferences.get_instance()
color = prefs.color
snap_color = prefs.snap_color
region = context.region
glsettings = vagl.GLSettings(context)
glsettings.push()
bgl.glEnable(bgl.GL_BLEND)
bgl.glColor4f(*color)
show_reversed = False
if self.reverse:
if self.mode == 'POLYGON':
if len(self.mouse_coords) >= 3:
show_reversed = True
else:
if len(self.mouse_coords) >= 2:
if self.mouse_coords[0] != self.mouse_coords[1]:
show_reversed = True
if show_reversed:
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glClearDepth(1.0)
bgl.glClear(bgl.GL_DEPTH_BUFFER_BIT)
bgl.glDepthMask(1)
bgl.glColorMask(0, 0, 0, 0)
lines = []
if self.mouse_coords:
if self.mode == 'LINE':
w = region.width
h = region.height
p1, p2 = self.mouse_coords
line = (p2 - p1).normalized()
normal = Vector([-line[1], line[0]])
corners = [Vector([0, 0]), Vector([w, 0]), Vector([w, h]),
Vector([0, h])]
corners_ofs = [v - p1 for v in corners]
dists = [v.project(line).dot(line) for v in corners_ofs]
i = dists.index(min(dists))
line_min = corners_ofs[i].project(line) + p1
i = dists.index(max(dists))
line_max = corners_ofs[i].project(line) + p1
dists = [v.project(normal).dot(normal) for v in corners_ofs]
i = dists.index(max(dists))
normal_max_f = corners_ofs[i].project(normal).dot(normal)
vec = normal * normal_max_f
coords = [line_min, line_max, line_max + vec, line_min + vec]
bgl.glBegin(bgl.GL_QUADS)
for co in coords:
bgl.glVertex2f(*co)
bgl.glEnd()
lines = self.mouse_coords
elif self.mode == 'BOX':
p1, p2 = self.mouse_coords
bgl.glRectf(p1[0], p1[1], p2[0], p2[1])
lines = [p1,
Vector((p2[0], p1[1])),
Vector((p2[0], p2[1])),
Vector((p1[0], p2[1])),
p1]
elif self.mode == 'CIRCLE':
p1, p2 = self.mouse_coords
bgl.glBegin(bgl.GL_TRIANGLE_FAN)
bgl.glVertex2f(*p1)
r = (p2 - p1).length
coords = calc_circle_coords(p1, r, self.circle_segments,
self.circle_direction)
for co in coords:
bgl.glVertex2f(*co)
bgl.glVertex2f(*coords[0])
bgl.glEnd()
lines = coords + [coords[0]]
elif self.mode == 'POLYGON':
if len(self.mouse_coords) >= 3:
tris = mathutils.geometry.tessellate_polygon(
[[co.to_3d() for co in self.mouse_coords]])
bgl.glBegin(bgl.GL_TRIANGLES)
for tri in tris:
for i in tri:
bgl.glVertex2f(*self.mouse_coords[i])
bgl.glEnd()
if len(self.mouse_coords) > 1:
lines = self.mouse_coords + [self.mouse_coords[0]]
if show_reversed:
bgl.glColorMask(1, 1, 1, 1)
bgl.glBegin(bgl.GL_QUADS)
bgl.glVertex3f(0, 0, -1)
bgl.glVertex3f(region.width, 0, -1)
bgl.glVertex3f(region.width, region.height, -1)
bgl.glVertex3f(0, region.height, -1)
bgl.glEnd()
bgl.glDisable(bgl.GL_DEPTH_TEST)
bgl.glColor4f(*color[:3], 1.0)
bgl.glPointSize(1)
bgl.glLineWidth(1)
if len(lines) > 1:
bgl.glBegin(bgl.GL_LINE_STRIP)
for co in lines:
bgl.glVertex2f(*co)
bgl.glEnd()
if self.mode == 'POLYGON':
if len(self.mouse_coords) == 1:
bgl.glPointSize(5)
bgl.glBegin(bgl.GL_POINTS)
for co in self.mouse_coords:
bgl.glVertex2f(*co)
bgl.glEnd()
bgl.glPointSize(1)
bgl.glLineWidth(1)
if self.mco_ctrl:
SIZE = 12
bgl.glColor4f(*snap_color)
bgl.glBegin(bgl.GL_LINE_LOOP)
v = self.mco_mod
x = v[0] - SIZE / 2
y = v[1] - SIZE / 2
bgl.glVertex2f(x, y)
bgl.glVertex2f(x + SIZE, y)
bgl.glVertex2f(x + SIZE, y + SIZE)
bgl.glVertex2f(x, y + SIZE)
bgl.glEnd()
glsettings.pop()
glsettings.font_size()
def execute(self, refholder):
# pass
tr = self.nodeTree.properties.TextureResolution
print("begining execution " + str(tr))
# compute A'
mask = np.array([[0.05, 0.2, 0.05], [0.2, -1, 0.2], [0.05, 0.2, 0.05]])
# Input data pixels
A = self.inputs[0].getPixels()
B = self.inputs[1].getPixels()
# print(A)
bgl.glGetIntegerv(bgl.GL_CURRENT_PROGRAM,
self.rdData[self.name]["prev_program"])
bgl.glUseProgram(self.rdData[self.name]["program"])
#set any uniforms needed
bgl.glUniform1f(self.rdData[self.name]["feed_loc"],
self.inputs[2].value)
bgl.glUniform1f(self.rdData[self.name]["kill_loc"],
self.inputs[3].value)
bgl.glUniform1f(self.rdData[self.name]["da_loc"], self.inputs[4].value)
bgl.glUniform1f(self.rdData[self.name]["db_loc"], self.inputs[5].value)
bgl.glUniform1f(self.rdData[self.name]["dt_loc"], self.inputs[6].value)
bgl.glUniform1f(self.rdData[self.name]["step_loc"], 1 / tr)
bgl.glDisable(bgl.GL_SCISSOR_TEST)
bgl.glViewport(0, 0, tr, tr)
bgl.glMatrixMode(bgl.GL_MODELVIEW)
bgl.glPushMatrix()
bgl.glLoadIdentity()
bgl.glMatrixMode(bgl.GL_PROJECTION)
bgl.glPushMatrix()
bgl.glLoadIdentity()
bgl.gluOrtho2D(0, 1, 0, 1)
bgl.glEnable(bgl.GL_TEXTURE_2D)
bgl.glActiveTexture(bgl.GL_TEXTURE0)
channels = []
if self.channels == '0':
channels = [0]
elif self.channels == '1':
channels = [0, 1, 2]
for j in channels:
self.rdData[self.name]["npArray"][:, :, 0] = A[:, :, j]
self.rdData[self.name]["npArray"][:, :, 1] = B[:, :, j]
# Caution: Interfacing with Cython requires toList()
self.rdData[self.name]["image"].pixels = self.rdData[
self.name]["npArray"].flatten()
self.rdData[self.name]["image"].gl_load(0, bgl.GL_LINEAR,
bgl.GL_LINEAR)
bgl.glBindTexture(bgl.GL_TEXTURE_2D,
self.rdData[self.name]["image"].bindcode[0])
bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_S,
bgl.GL_REPEAT)
bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_T,
bgl.GL_REPEAT)
for i in range(self.inputs[7].value):
bgl.glClearDepth(1.0)
bgl.glClearColor(0.0, 0.0, 0.0, 0.0)
bgl.glClear(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_DEPTH_BUFFER_BIT)
bgl.glBegin(bgl.GL_TRIANGLES)
bgl.glColor3f(1.0, 1.0, 1.0)
bgl.glTexCoord2f(0.0, 0.0)
bgl.glVertex2f(-1.0, -1.0)
bgl.glTexCoord2f(1.0, 0.0)
bgl.glVertex2f(1.0, -1.0)
bgl.glTexCoord2f(1.0, 1.0)
bgl.glVertex2f(1.0, 1.0)
bgl.glColor3f(1.0, 1.0, 1.0)
bgl.glTexCoord2f(0.0, 0.0)
bgl.glVertex2f(-1.0, -1.0)
bgl.glTexCoord2f(1.0, 1.0)
bgl.glVertex2f(1.0, 1.0)
bgl.glTexCoord2f(0.0, 1.0)
bgl.glVertex2f(-1.0, 1.0)
bgl.glEnd()
bgl.glCopyTexImage2D(
bgl.GL_TEXTURE_2D, #target
0, #level
bgl.GL_RGBA, #internalformat
0, #x
0, #y
tr,
tr,
0 #border
)
#glFlush glFinish or none here?
bgl.glFinish()
bgl.glReadPixels(0, 0, tr, tr, bgl.GL_RGBA, bgl.GL_FLOAT,
self.rdData[self.name]["buffer"])
self.rdData[self.name]["image"].pixels = self.rdData[
self.name]["buffer"][:]
#write the image channel
npImage = np.asarray(self.rdData[self.name]["image"].pixels,
dtype="float")
self.rdData[self.name]["npArray"] = npImage.reshape(
tr, tr, self.rdData[self.name]["image"].channels)
self.outputs[0].setPackedImageFromChannels(
self.rdData[self.name]["npArray"][:, :, 0], j, flatten=True)
self.outputs[1].setPackedImageFromChannels(
self.rdData[self.name]["npArray"][:, :, 1], j, flatten=True)
self.outputs[2].setPackedImageFromPixels(
self.rdData[self.name]["npArray"])
self.inputs[0].setPackedImageFromChannels(
self.rdData[self.name]["npArray"][:, :, 0], j, flatten=True)
self.inputs[1].setPackedImageFromChannels(
self.rdData[self.name]["npArray"][:, :, 1], j, flatten=True)
# ================================= Test bed
# self.outputs[0].getTexture().image.copy()
# self.outputs[1].getTexture().image.copy()
# self.outputs[2].getTexture().image.copy()
# nparr = np.asarray(self.outputs[0].getTexture().image.pixels, dtype="float")
# nparr = nparr.reshape(tr, tr, 4)
# print(nparr)
self.rdData[self.name]["image"].gl_free()
#restore the state so blender wont break
bgl.glEnable(bgl.GL_SCISSOR_TEST)
bgl.glUseProgram(self.rdData[self.name]["prev_program"][0])
bgl.glActiveTexture(bgl.GL_TEXTURE0)
def render_main_svg(self, context, animation=False):
# Save old info
scene = context.scene
sceneProps = scene.MeasureItArchProps
sceneProps.is_render_draw = True
sceneProps.is_vector_draw = True
clipdepth = context.scene.camera.data.clip_end
path = bpy.path.abspath(scene.render.filepath)
objlist = context.view_layer.objects
# --------------------
# Get resolution
# --------------------
render_scale = scene.render.resolution_percentage / 100
width = int(scene.render.resolution_x * render_scale)
height = int(scene.render.resolution_y * render_scale)
offscreen = gpu.types.GPUOffScreen(width, height)
view_matrix_3d = scene.camera.matrix_world.inverted()
projection_matrix = scene.camera.calc_matrix_camera(
context.view_layer.depsgraph, x=width, y=height)
# Render Depth Buffer
print("Rendering Depth Buffer")
if sceneProps.vector_depthtest:
with offscreen.bind():
# Clear Depth Buffer, set Clear Depth to Cameras Clip Distance
set_OpenGL_Settings(True)
bgl.glClear(bgl.GL_DEPTH_BUFFER_BIT)
bgl.glClearDepth(clipdepth)
bgl.glEnable(bgl.GL_DEPTH_TEST)
bgl.glDepthFunc(bgl.GL_LEQUAL)
gpu.matrix.reset()
gpu.matrix.load_matrix(view_matrix_3d)
gpu.matrix.load_projection_matrix(projection_matrix)
texture_buffer = bgl.Buffer(bgl.GL_FLOAT, width * height)
draw_scene(self, context, projection_matrix)
bgl.glReadBuffer(bgl.GL_BACK)
bgl.glReadPixels(0, 0, width, height, bgl.GL_DEPTH_COMPONENT,
bgl.GL_FLOAT, texture_buffer)
if 'depthbuffer' in sceneProps:
del sceneProps['depthbuffer']
sceneProps['depthbuffer'] = texture_buffer
offscreen.free()
set_OpenGL_Settings(False)
if False:
imageName = 'depthBufferTest'
if not imageName in bpy.data.images:
bpy.data.images.new(imageName,
width,
height,
alpha=False,
float_buffer=True,
is_data=True)
image = bpy.data.images[imageName]
image.scale(width, height)
image.pixels = [v for v in texture_buffer]
# Setup Output Path
outpath = "{}_{:04d}.svg".format(path, scene.frame_current)
view = get_view()
paperWidth = width / sceneProps.default_resolution
paperHeight = height / sceneProps.default_resolution
try:
if view.res_type == 'res_type_paper':
paperWidth = round(view.width * 39.370078740196853, 3)
paperHeight = round(view.height * 39.370078740196853, 3)
except:
print('No View Present, using default resolution')
# Setup basic svg
svg = svgwrite.Drawing(
outpath,
debug=False,
size=('{}in'.format(paperWidth), '{}in'.format(paperHeight)),
viewBox=('0 0 {} {}'.format(width, height)),
id='root',
)
if sceneProps.embed_scene_render:
lastformat = scene.render.image_settings.file_format
scene.render.image_settings.file_format = 'PNG'
scene.render.use_file_extension = True
bpy.ops.render.render(write_still=True)
image_path = bpy.context.scene.render.filepath
png_image_path = os.path.basename("{}.png".format(image_path))
svg.add(svg.image(png_image_path, **{
'width': width,
'height': height
}))
scene.render.image_settings.file_format = lastformat
# -----------------------------
# Loop to draw all objects
# -----------------------------
draw3d_loop(context, objlist, svg=svg)
draw_titleblock(context, svg=svg)
if sceneProps.embed_freestyle_svg:
# If "FreeStyle SVG export" addon is loaded, we render the scene to SVG
# and embed the output in the final SVG.
freestyle_svg_export = 'render_freestyle_svg' in get_loaded_addons()
lastformat = scene.render.image_settings.file_format, scene.render.use_freestyle, scene.svg_export.use_svg_export, scene.svg_export.mode
if freestyle_svg_export:
scene.render.use_freestyle = True
scene.svg_export.use_svg_export = True
scene.svg_export.mode = 'FRAME'
base_path = bpy.context.scene.render.filepath
bpy.context.scene.render.filepath += '_freestyle_'
scene.render.image_settings.file_format = 'PNG'
scene.render.use_file_extension = True
bpy.ops.render.render(write_still=False)
image_path = bpy.context.scene.render.filepath
if freestyle_svg_export:
frame = scene.frame_current
svg_image_path = bpy.path.abspath("{}{:04d}.svg".format(
image_path, frame))
svg_root = ET.parse(svg_image_path).getroot()
for elem in svg_root:
svg.add(SVGWriteElement(elem))
if os.path.exists(
svg_image_path) and not sceneProps.keep_freestyle_svg:
os.remove(svg_image_path)
scene.render.image_settings.file_format = lastformat[0]
scene.render.use_freestyle = lastformat[1]
scene.svg_export.use_svg_export = lastformat[2]
scene.svg_export.mode = lastformat[3]
bpy.context.scene.render.filepath = base_path
svg.save(pretty=True)
# restore default value
sceneProps.is_render_draw = False
sceneProps.is_vector_draw = False
return True
