MeasureIt: More conversion of APIs (WIP)

Still the render is not working. The idea is replace the old system generating a image with alpha background and only the measures.

3 files changed, 99 insertions, 263 deletions

diff --git a/measureit/__init__.py b/measureit/__init__.py
index fc5252a3..2d248d9c 100644
--- a/measureit/__init__.py
+++ b/measureit/__init__.py
@@ -250,11 +250,8 @@ def register():
                                           description="Save an image with measures over"
                                                       " render image",
                                           default=False)
-    Scene.measureit_render_type = EnumProperty(items=(('1', "*Current", "Use current render"),
-                                                      ('2', "OpenGL", ""),
-                                                      ('3', "Animation OpenGL", ""),
-                                                      ('4', "Image", ""),
-                                                      ('5', "Animation", "")),
+    Scene.measureit_render_type = EnumProperty(items=(('1', "Frame", "Render current frame"),
+                                                      ('2', "Animation", "")),
                                                name="Render type",
                                                description="Type of render image")
     Scene.measureit_sum = EnumProperty(items=(('99', "-", "Select a group for sum"),
diff --git a/measureit/measureit_main.py b/measureit/measureit_main.py
index 82f269ac..aa5ded6d 100644
--- a/measureit/measureit_main.py
+++ b/measureit/measureit_main.py
@@ -1740,75 +1740,22 @@ class MEASUREIT_OT_RenderSegment(Operator):
             self.report({'ERROR'}, camera_msg)
             return {'FINISHED'}
         # -----------------------------
-        # Use default render
+        # Frame render
         # -----------------------------
         if scene.measureit_render_type == "1":
             # noinspection PyBroadException
-            try:
-                result = bpy.data.images['Render Result']
-                bpy.ops.render.render()
-            except:
-                bpy.ops.render.render()
-            print("MeasureIt: Using current render image on buffer")
             if render_main(self, context) is True:
                 self.report({'INFO'}, msg)
-
-        # -----------------------------
-        # OpenGL image
-        # -----------------------------
-        if scene.measureit_render_type == "2":
-            self.set_camera_view()
-            self.set_only_render(True)
-
-            print("MeasureIt: Rendering opengl image")
-            bpy.ops.render.opengl()
-            if render_main(self, context) is True:
-                self.report({'INFO'}, msg)
-
-            self.set_only_render(False)
-
-        # -----------------------------
-        # OpenGL Animation
-        # -----------------------------
-        if scene.measureit_render_type == "3":
-            oldframe = scene.frame_current
-            self.set_camera_view()
-            self.set_only_render(True)
-            flag = False
-            # loop frames
-            for frm in range(scene.frame_start, scene.frame_end + 1):
-                scene.frame_set(frm)
-                print("MeasureIt: Rendering opengl frame %04d" % frm)
-                bpy.ops.render.opengl()
-                flag = render_main(self, context, True)
-                if flag is False:
-                    break
-
-            self.set_only_render(False)
-            scene.frame_current = oldframe
-            if flag is True:
-                self.report({'INFO'}, msg)
-
-        # -----------------------------
-        # Image
-        # -----------------------------
-        if scene.measureit_render_type == "4":
-            print("MeasureIt: Rendering image")
-            bpy.ops.render.render()
-            if render_main(self, context) is True:
-                self.report({'INFO'}, msg)
-
         # -----------------------------
         # Animation
         # -----------------------------
-        if scene.measureit_render_type == "5":
+        if scene.measureit_render_type == "2":
             oldframe = scene.frame_current
             flag = False
             # loop frames
             for frm in range(scene.frame_start, scene.frame_end + 1):
                 scene.frame_set(frm)
                 print("MeasureIt: Rendering frame %04d" % frm)
-                bpy.ops.render.render()
                 flag = render_main(self, context, True)
                 if flag is False:
                     break
diff --git a/measureit/measureit_render.py b/measureit/measureit_render.py
index 491c0071..212d12be 100644
--- a/measureit/measureit_render.py
+++ b/measureit/measureit_render.py
@@ -25,7 +25,7 @@
 # ----------------------------------------------------------
 # noinspection PyUnresolvedReferences
 import bpy
-# noinspection PyUnresolvedReferences
+import gpu
 import bgl
 # noinspection PyUnresolvedReferences
 import blf
@@ -46,216 +46,108 @@ from .measureit_geometry import *
 #
 # -------------------------------------------------------------
 def render_main(self, context, animation=False):
-    # noinspection PyBroadException,PyBroadException
     # Save old info
     settings = bpy.context.scene.render.image_settings
     depth = settings.color_depth
     settings.color_depth = '8'
-    # noinspection PyBroadException
-    try:
-        scene = context.scene
-        # Get object list
-        objlist = context.scene.objects
-        # --------------------
-        # Get resolution
-        # --------------------
-        scene = bpy.context.scene
-        render_scale = scene.render.resolution_percentage / 100
 
-        width = int(scene.render.resolution_x * render_scale)
-        height = int(scene.render.resolution_y * render_scale)
-        # ---------------------------------------
-        # Get output path
-        # ---------------------------------------
-        temp_path = path.realpath(bpy.app.tempdir)
-        if len(temp_path) > 0:
-            outpath = path.join(temp_path, "measureit_tmp_render.png")
-        else:
-            self.report({'ERROR'},
-                        "MeasureIt: Unable to save temporary render image. Define a valid temp path")
-            settings.color_depth = depth
-            return False
-
-        # Get Render Image
-        img = get_render_image(outpath)
-        if img is None:
-            self.report({'ERROR'},
-                        "MeasureIt: Unable to save temporary render image. Define a valid temp path")
-            settings.color_depth = depth
-            return False
+    # Get object list
+    scene = context.scene
+    objlist = context.scene.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)
+
+    # --------------------------------------
+    # Loop to draw all lines in Offsecreen
+    # --------------------------------------
+    offscreen = gpu.types.GPUOffScreen(width, height)
+    view_matrix = scene.camera.matrix_world.inverted()
+    projection_matrix = scene.camera.calc_matrix_camera(context.depsgraph, x=width, y=height)
+
+    with offscreen.bind():
+        bgl.glClear(bgl.GL_COLOR_BUFFER_BIT)
+        gpu.matrix.reset()
+        gpu.matrix.load_matrix(view_matrix)
+        gpu.matrix.load_projection_matrix(projection_matrix)
 
         # -----------------------------
-        # Calculate rows and columns
+        # Loop to draw all objects
         # -----------------------------
-        tile_x = 240
-        tile_y = 216
-        row_num = ceil(height / tile_y)
-        col_num = ceil(width / tile_x)
-        print("MeasureIt: Image divided in " + str(row_num) + "x" + str(col_num) + " tiles")
-
-        # pixels out of visible area
-        cut4 = (col_num * tile_x * 4) - width * 4  # pixels aout of drawing area
-        totpixel4 = width * height * 4  # total pixels RGBA
-        viewport_info = bgl.Buffer(bgl.GL_INT, 4)
-        bgl.glGetIntegerv(bgl.GL_VIEWPORT, viewport_info)
-
-        # Load image on memory
-        img.gl_load(frame=0, filter=bgl.GL_NEAREST, mag=bgl.GL_NEAREST)
-        tex = img.bindcode
-
-        # --------------------------------------------
-        # Create output image (to apply texture)
-        # --------------------------------------------
-        if "measureit_output" in bpy.data.images:
-            out_img = bpy.data.images["measureit_output"]
-            if out_img is not None:
-                bpy.data.images.remove(out_img)
-
-        out = bpy.data.images.new("measureit_output", width, height)
-        tmp_pixels = [1] * totpixel4
-
-        # --------------------------------
-        # Loop for all tiles
-        # --------------------------------
-        for row in range(row_num):
-            for col in range(col_num):
-                buffer = bgl.Buffer(bgl.GL_FLOAT, width * height * 4)
-                bgl.glDisable(bgl.GL_SCISSOR_TEST)  # if remove this line, get blender screenshot not image
-                bgl.glViewport(0, 0, tile_x, tile_y)
-
-                bgl.glMatrixMode(bgl.GL_PROJECTION)
-                gpu.matrix.load_identity()
-
-                # defines ortographic view for single tile
-                x1 = tile_x * col
-                y1 = tile_y * row
-                bgl.gluOrtho2D(x1, x1 + tile_x, y1, y1 + tile_y)
-
-                # Clear
-                bgl.glClearColor(0.0, 0.0, 0.0, 0.0)
-                bgl.glClear(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_DEPTH_BUFFER_BIT)
-
-                bgl.glEnable(bgl.GL_TEXTURE_2D)
-                bgl.glBindTexture(bgl.GL_TEXTURE_2D, tex)
-
-                # defines drawing area
-                bgl.glBegin(bgl.GL_QUADS)
-
-                bgl.glColor3f(1.0, 1.0, 1.0)
-                bgl.glTexCoord2f(0.0, 0.0)
-                bgl.glVertex2f(0.0, 0.0)
-
-                bgl.glTexCoord2f(1.0, 0.0)
-                bgl.glVertex2f(width, 0.0)
-
-                bgl.glTexCoord2f(1.0, 1.0)
-                bgl.glVertex2f(width, height)
-
-                bgl.glTexCoord2f(0.0, 1.0)
-                bgl.glVertex2f(0.0, height)
-
-                bgl.glEnd()
-
-                # -----------------------------
-                # Loop to draw all lines
-                # -----------------------------
-                for myobj in objlist:
-                    if myobj.visible_get() is True:
-                        if 'MeasureGenerator' in myobj:
-                            op = myobj.MeasureGenerator[0]
-                            draw_segments(context, myobj, op, None, None)
-
-                # -----------------------------
-                # Loop to draw all debug
-                # -----------------------------
-                if scene.measureit_debug is True:
-                    selobj = bpy.context.selected_objects
-                    for myobj in selobj:
-                        if scene.measureit_debug_objects is True:
-                            draw_object(context, myobj, None, None)
-                        elif scene.measureit_debug_object_loc is True:
-                            draw_object(context, myobj, None, None)
-                        if scene.measureit_debug_vertices is True:
-                            draw_vertices(context, myobj, None, None)
-                        elif scene.measureit_debug_vert_loc is True:
-                            draw_vertices(context, myobj, None, None)
-                        if scene.measureit_debug_edges is True:
-                            draw_edges(context, myobj, None, None)
-                        if scene.measureit_debug_faces is True or scene.measureit_debug_normals is True:
-                            draw_faces(context, myobj, None, None)
-
-                if scene.measureit_rf is True:
-                    rfcolor = scene.measureit_rf_color
-                    rfborder = scene.measureit_rf_border
-                    rfline = scene.measureit_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), rfcolor)
-
-                # --------------------------------
-                # copy pixels to temporary area
-                # --------------------------------
-                bgl.glFinish()
-                bgl.glReadPixels(0, 0, width, height, bgl.GL_RGBA, bgl.GL_FLOAT, buffer)  # read image data
-                for y in range(tile_y):
-                    # final image pixels position
-                    p1 = (y * width * 4) + (row * tile_y * width * 4) + (col * tile_x * 4)
-                    p2 = p1 + (tile_x * 4)
-                    # buffer pixels position
-                    b1 = y * width * 4
-                    b2 = b1 + (tile_x * 4)
-
-                    if p1 < totpixel4:  # avoid pixel row out of area
-                        if col == col_num - 1:  # avoid pixel columns out of area
-                            p2 -= cut4
-                            b2 -= cut4
-
-                        tmp_pixels[p1:p2] = buffer[b1:b2]
-
-        # -----------------------
-        # Copy temporary to final
-        # -----------------------
-        out.pixels = tmp_pixels[:]  # Assign image data
-        img.gl_free()  # free opengl image memory
-
-        # delete image
-        bpy.data.images.remove(img)
-        # remove temp file
-        remove(outpath)
-        # reset
-        bgl.glEnable(bgl.GL_SCISSOR_TEST)
-        # -----------------------
-        # restore opengl defaults
-        # -----------------------
-        bgl.glLineWidth(1)
-        bgl.glDisable(bgl.GL_BLEND)
-        # Saves image
-        if out is not None and (scene.measureit_render is True or animation is True):
-            ren_path = bpy.context.scene.render.filepath
-            filename = "mit_frame"
-            if len(ren_path) > 0:
-                if ren_path.endswith(path.sep):
-                    initpath = path.realpath(ren_path) + path.sep
-                else:
-                    (initpath, filename) = path.split(ren_path)
-
-            ftxt = "%04d" % scene.frame_current
-            outpath = path.realpath(path.join(initpath, filename + ftxt + ".png"))
-
-            save_image(self, outpath, out)
-
-        settings.color_depth = depth
-        return True
-
-    except:
-        settings.color_depth = depth
-        print("Unexpected error:" + str(exc_info()))
-        self.report({'ERROR'}, "MeasureIt: Unable to create render image. Be sure the output render path is correct")
-        return False
+        for myobj in objlist:
+            if myobj.visible_get() is True:
+                if 'MeasureGenerator' in myobj:
+                    op = myobj.MeasureGenerator[0]
+                    draw_segments(context, myobj, op, None, None)
+        # -----------------------------
+        # Loop to draw all debug
+        # -----------------------------
+        if scene.measureit_debug is True:
+            selobj = bpy.context.selected_objects
+            for myobj in selobj:
+                if scene.measureit_debug_objects is True:
+                    draw_object(context, myobj, None, None)
+                elif scene.measureit_debug_object_loc is True:
+                    draw_object(context, myobj, None, None)
+                if scene.measureit_debug_vertices is True:
+                    draw_vertices(context, myobj, None, None)
+                elif scene.measureit_debug_vert_loc is True:
+                    draw_vertices(context, myobj, None, None)
+                if scene.measureit_debug_edges is True:
+                    draw_edges(context, myobj, None, None)
+                if scene.measureit_debug_faces is True or scene.measureit_debug_normals is True:
+                    draw_faces(context, myobj, None, None)
+        # -----------------------------
+        # Draw a rectangle frame
+        # -----------------------------
+        if scene.measureit_rf is True:
+            rfcolor = scene.measureit_rf_color
+            rfborder = scene.measureit_rf_border
+            rfline = scene.measureit_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), rfcolor)
+
+        buffer = bgl.Buffer(bgl.GL_BYTE, width * height * 4)
+        bgl.glReadBuffer(bgl.GL_BACK)
+        bgl.glReadPixels(0, 0, width, height, bgl.GL_RGBA, bgl.GL_UNSIGNED_BYTE, buffer)
+
+    offscreen.free()
+
+    # -----------------------------
+    # Create image
+    # -----------------------------
+    image_name = "measureit_output"
+    if not image_name 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_render is True or animation is True):
+        ren_path = bpy.context.scene.render.filepath
+        filename = "mit_frame"
+        if len(ren_path) > 0:
+            if ren_path.endswith(path.sep):
+                initpath = path.realpath(ren_path) + path.sep
+            else:
+                (initpath, filename) = path.split(ren_path)
+
+        ftxt = "%04d" % scene.frame_current
+        outpath = path.realpath(path.join(initpath, filename + ftxt + ".png"))
+        save_image(self, outpath, image)
+
+    # restore default value
+    settings.color_depth = depth
 
 
 # --------------------------------------------------------------------