3D दृश्य - कैमरा फ्रेम में कैमरा डेटा कैसे प्रदर्शित करें?

Aug 17 2020

क्या प्रदर्शन के विकल्पों का उपयोग करने का एक तरीका है जैसे "ऑब्जेक्ट जानकारी" या "व्यू नेम" (व्यूपोर्ट की प्राथमिकताओं में) अन्य जानकारी प्रदर्शित करने के लिए जैसे कि सक्रिय कैमरा का लेन्थ फोकल और उसकी स्थिति। और क्या इस जानकारी को 3 डी विंडो में कहीं ले जाने का कोई तरीका है? इस उदाहरण में पसंद करें:

इसलिए मुझे एक स्क्रिप्ट मिली, जो मुझे 3 डी विंडो पर फोकल प्वाइंट प्रदर्शित करने की अनुमति देती है।

import bpy
import blf

dns = bpy.app.driver_namespace 
dc = dns.get("dc")
dc.remove_handle()

class DrawingClass:
    def __init__(self, context, prop):
        self.prop = prop
        self.handle = bpy.types.SpaceView3D.draw_handler_add(
                   self.draw_text_callback,(context,),
                   'WINDOW', 'POST_PIXEL')

    def draw_text_callback(self, context):
        font_id = 0  # XXX, need to find out how best to get this.

        # draw some text
        blf.position(font_id, 15, 350, 0)
        blf.size(font_id, 20, 72)
        blf.draw(font_id, "%s %s" % (context.scene.name, self.prop))

    def remove_handle(self):
         bpy.types.SpaceView3D.draw_handler_remove(self.handle, 'WINDOW')

context = bpy.context             
dns = bpy.app.driver_namespace
dns["dc"] = DrawingClass(context, bpy.context.object.data.lens)

पहली 3 पंक्ति मुझे पूर्ववर्ती प्रदर्शन को मिटाने की अनुमति देती है। पहली बार स्क्रिप्ट चलाने के बाद मैं पहली बार 3 पंक्तियों को पढ़ने से कैसे रोक सकता हूं? अभी के लिए स्क्रिप्ट एक बार फोकल पढ़ती है और इसे लिखती है। यह सुनिश्चित करने के लिए कि स्क्रिप्ट को हर बार फोकल बदलने के बाद कैसे पढ़ा जाता है?

जवाब

3 brockmann Aug 20 2020 at 00:55

AFAIK यह डिफ़ॉल्ट रूप से संभव नहीं है और मुझे लगता है कि कोई मौजूदा ऐड-ऑन नहीं है जो कैमरा फ्रेम में किसी भी प्रकार की जानकारी प्रदर्शित करने में सक्षम है।

हालाँकि, आप अजगर के बेल मॉड्यूल का उपयोग करके पाठ को आकर्षित कर सकते हैं और अपना स्वयं का ऐड-ऑन बना सकते हैं। निम्नलिखित उदाहरण कोड हमारे प्रसिद्ध ऑपरेटर मोडल ड्रा टेम्प्लेट पर आधारित है , जो ब्लेंडर के साथ आता है, गेंद को रोल करने के लिए कैमरा व्यू बॉर्डर और मल्टी-लाइन टेक्स्ट इन ब्लोफ (मल्टी कलर ऑप्शन के साथ) के कोर्डिनेट्स के उत्तर द्वारा बढ़ाया जाता है :

hud.py

import bpy
import blf
import bgl


# -> BASED ON: https://blender.stackexchange.com/a/14746/31447
def view3d_find(context):
    # returns first 3d view, normally we get from context
    for area in context.window.screen.areas:
        if area.type == 'VIEW_3D':
            v3d = area.spaces[0]
            rv3d = v3d.region_3d
            for region in area.regions:
                if region.type == 'WINDOW':
                    return region, rv3d
    return None, None

def view3d_camera_border(context):
    obj = context.scene.camera
    cam = obj.data

    frame = cam.view_frame(scene=context.scene)
    # move from object-space into world-space 
    frame = [obj.matrix_world @ v for v in frame]

    # move into pixelspace
    from bpy_extras.view3d_utils import location_3d_to_region_2d
    region, rv3d = view3d_find(context)
    frame_px = [location_3d_to_region_2d(region, rv3d, v) for v in frame]
    return frame_px

# -> BASED ON: https://blender.stackexchange.com/a/31799/31447
def draw_string(x, y, packed_strings):
    font_id = 0
    blf.size(font_id, 18, 72) 
    x_offset = 0
    y_offset = 0
    line_height = (blf.dimensions(font_id, "M")[1] * 1.45)
    for command in packed_strings:
        if len(command) == 2:
            pstr, pcol = command
            blf.color(font_id, pcol[0], pcol[1], pcol[2], pcol[3]) # #bgl.glColor4f(pcol)
            text_width, text_height = blf.dimensions(font_id, pstr)
            blf.position(font_id, (x + x_offset), (y + y_offset), 0)
            blf.draw(font_id, pstr)
            x_offset += text_width
        else:
            x_offset = 0
            y_offset -= line_height

def draw_callback_px(self, context):
    
    WHITE = (1, 1, 1, .7)
    CR = "Carriage Return"
    
    x, y = view3d_camera_border(context)[3]
    cam_ob = context.scene.camera
    
    if cam_ob is not None:
        ps = [
            ("{} {}mm".format(cam_ob.name, cam_ob.data.lens), WHITE), 
            CR,
            CR, 
            ("T: {:.2f}, {:.2f}, {:.2f}".format(
                cam_ob.location.x, 
                cam_ob.location.y, 
                cam_ob.location.z), WHITE),
            CR,
            ("R: {:.2f}, {:.2f}, {:.2f}".format(
                cam_ob.rotation_euler.x, 
                cam_ob.rotation_euler.y, 
                cam_ob.rotation_euler.z), WHITE),        
        ]
    
    draw_string(x+10, y-20, ps)
    # restore opengl defaults
    bgl.glLineWidth(1)
    bgl.glDisable(bgl.GL_BLEND)

# -> MODAL OPERATOR TEMPLATE
class ModalDrawOperator(bpy.types.Operator):
    """Draw a line with the mouse"""
    bl_idname = "view3d.modal_operator"
    bl_label = "Simple Modal View3D Operator"

    @classmethod
    def poll(cls, context):
        return context.area.type == 'VIEW_3D'
    
    def modal(self, context, event):
        context.area.tag_redraw()
        
        if event.type in {'RIGHTMOUSE', 'ESC'}:
            bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW')
            return {'CANCELLED'}
        
        return {'PASS_THROUGH'}

    def invoke(self, context, event):
        if context.space_data.region_3d.view_perspective == 'CAMERA':
            # the arguments we pass the the callback
            args = (self, context)
            # Add the region OpenGL drawing callback
            # draw in view space with 'POST_VIEW' and 'PRE_VIEW'
            self._handle = bpy.types.SpaceView3D.draw_handler_add(draw_callback_px, args, 'WINDOW', 'POST_PIXEL')

            context.window_manager.modal_handler_add(self)
            return {'RUNNING_MODAL'}
        else:
            self.report({'WARNING'}, "Switch into Camera View")
            return {'CANCELLED'}



def register():
    bpy.utils.register_class(ModalDrawOperator)


def unregister():
    bpy.utils.unregister_class(ModalDrawOperator)


if __name__ == "__main__":
    register()

पाठ संपादक में स्क्रिप्ट को कॉपी और पेस्ट करें, इसे चलाएं, 3 डी दृश्य में आगे बढ़ें, F3निष्पादित करने के लिए "सरल ऑपरेटर ..." दबाएं और टाइप करें। यदि आप इसे एक ऐड-ऑन में बदलना चाहते हैं, तो बस अपने ऐडऑन के शीर्ष पर "bl_info" नामक एक अजगर शब्द जोड़ें:https://wiki.blender.org/wiki/Process/Addons/Guidelines/metainfo


2.7x संस्करणों के लिए इसे काम करने के लिए आपको मैट्रिक्स गुणन में परिवर्तन के कारण 2 लाइनों को बदलना होगा और नए संस्करणों में blf.color का उपयोग करके टेक्स्ट का रंग कैसे सेट करना है :

# draw_string()
- blf.color(font_id, pcol[0], pcol[1], pcol[2], pcol[3]) # Blender 2.8x
+ bgl.glColor4f(*pcol) # Blender 2.7x

# view3d_camera_border()
- frame = [obj.matrix_world @ v for v in frame] # Blender 2.8x
+ frame = [obj.matrix_world * v for v in frame] # Blender 2.7x