I'm using Scene data block to store properties and use them later in my script, e.g.:

def register():
    Scene.bcp_return_result: BoolProperty = BoolProperty(default=return_result,
                                                         name="Return result",
                                                         description="Indicates if result of command should be returned")

And later:


But content of Scene datablock is lost after opening a new scene or creating a new one. What content could I use to still access properties in this way and have them stored between scenes?


1 Answer 1


You use bpy.context.scene. which refers to your current active scene, e.g. bpy.data.scenes['Your Scene Name']. When you change the active scene in Blender the bpy.context.scene. starts to refer to another scene, e.g. bpy.data.scenes['Another Scene Name'] Context in bpy.context means "current". About Blender Properties like bpy.types.BoolProperty and the others - they are supposed to be used to dinamically change values of operators, not for storing any constant information.

If you want to store your properties you can:

1) Set a global variable outside all classes, right in your script body and call it from your functions and methods by marking it global (using global variables in big programs is not a very good idea because as your program grows it is getting hard to manage them):

bcp_return_result = None

def register():
    global bcp_return_result
    bcp_return_result = 1

print(bcp_return_result) # >>>None
print(bcp_return_result) # >>>1

2) Set and change it as your class variable. It can be either Blender Operator class

import bpy
from bpy.utils import register_class, unregister_class

class RegisterOperator(bpy.types.Operator):
    bl_idname='reg.op'              # id_name for bpy.ops, e.g. bpy.ops.reg.op()
    bl_label = 'Register Operator'  # Operator name
    bcp_return_result = 0           # Operator class variable

    def execute(self, context):     # to work as an operator this method must be
                                    # called "execute" and have self and context
                                    # arguments

        op = bpy.types.REG_OT_op    # to access an operator as a class we type:
                                    # "bpy.types", add uppercased start of 
                                    # bl_idname, add _OT_ instead of dot and the
                                    # final part of bl_idname as it is
                                    # Example: 'reg.op' = 'REG_OT_op'

        op.bcp_return_result = 1    # change operator class variable with what
                                    # you need

        return {'FINISHED'}         # also necessary part of operator

register_class(RegisterOperator)    # register operator

op = bpy.types.REG_OT_op            # set variable with operator class

print(op.bcp_return_result)         # >>>0
bpy.ops.reg.op()                    # execute operator
print(op.bcp_return_result)         # >>>1

or just a common Python class:

class RegisterClass():
    bcp_return_result = 0           # Operator class variable

    def __init__(self):

reg = RegisterClass                  # create class instance

print(reg.bcp_return_result)         # >>> 0
reg.bcp_return_result = 1            # change class variable
print(reg.bcp_return_result)         # >>> 1
  • $\begingroup$ Thanks, I did not implement that yet, but it seems to be a comprehensive answer $\endgroup$ Mar 26, 2020 at 17:45

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .