Salut à Tous !

Je suis actuellement sur le script d'un light manager que l'on pourrait gérer via l'interface blender (donc view3D, Tools,papata&Co).

En guise de test pour l'interface en python (ce que je n'ai jamais fait), je fais des choses très simple. Et pourtant, je rencontre actuellement un problème majeur qui est la gestion de ce qu'exécute les différentes commandes une fois qu'elles sont crées, notamment par rapport à un bool. Je souhaite avec ce dernier hide/!hide un cube.
Voici ce à quoi je suis abouti, sans poursuivre plus loin faute de comprendre.

##############################################
import bpy

from bpy.props import (StringProperty,
BoolProperty,
IntProperty,
FloatProperty,
EnumProperty,
PointerProperty,
)

from bpy.types import (Panel,
Operator,
PropertyGroup,
)


class initSceneProperties():
bpy.types.Scene.MyBool = BoolProperty(
name = "Boolean",
description= "None")
bpy.context.scene.MyBool=True

class TestPanel(bpy.types.Panel):
bl_idname = "TestPanel"
bl_label = "Test"
bl_space_type = 'VIEW_3D'
bl_region_type = 'TOOLS'
bl_category = "Tools"

def draw(self, context):
self.layout.operator("mesh.primitive_cube_add")
self.layout.prop(bpy.context.scene, "MyBool")
bpy.utils.register_class(TestPanel)
####################################################

En bref, j'ai juste réussi à créer un bouton pour add un cube

Plus sérieusement, j'ai d'autres questions de débutant à poser :
- par rapport à la ligne :
self.layout.operator("mesh.primitive_cube_add")
j'ai plus de 70 lignes qui vont devoir remplacer mesh.primitive_cuve_add. Dois-je toutes les rajouter à la place ?
- j'ai vu sur plusieurs tuto en ligne :
class ClassName(bpy.types.Operator):
A quoi sert exactement cet appel (que je comprends devoir exécuter des commandes en rapport avec le Panel) si je peux directement exécuter les dites commandes depuis le bpy.types.Panel

Bref, j'ai plein d'autres questions pour le moment, comment est-il possible de rentrer une position de Vector2(cqfd : X,Y) en input interface à la manière de C4D (comme un slider, mais en deux dimensions), afin de gérer la position x et y d'un objet ?
- A quoi sert réellement la commande class initSceneProperties() ?
- Est-il possible de définir une variable public qui récupère des informations de location ? Typiquement, linker un objet spécifique dans la scène, qui a donc la position (x,y,z), valeurs de position qu'on souhaite garder ?
(peut-être pas possible en python, c'est plutôt une logique de C# de récup des transform.position, mais peut-être ....)

Je me contenterai de celles là pour l'instant !!

En vous remerciant,
Une bonne nuit

Bonjour à tous et surpris de n'avoir eu aucune réponse

Bref, j'ai progressé, mais j'ai toujours des problèmes pour utiliser autre chose que des strings ou des button. J'arrive à afficher ce qui m'intéresse mais impossible de les utiliser.
J'aimerais utiliser mon BoolShading pour afficher ou cacher mes planes lights à la place de mon operator Reveal/Hide.

Pareil, si quelqu'un pouvait m'expliquer également comment utiliser un IntProperty ou un float property pour changer (notamment des translations) en temps réel des objets dans ma scène.

En vous remerciant d'avance,

Cdlt,
Snains

##############################
import bpy
from bpy.props import *

bpy.context.scene.render.engine = 'CYCLES'
bpy.context.scene.cursor_location=(0,0,0)
bpy.context.scene.layers=[i==0 for i in range(20)]

def initSceneProperties(scn):
bpy.types.Scene.MyString = StringProperty(
name="Object",
description="Obj u want to texturize")
scn['MyString'] = "Click & Drop obj"

bpy.types.Scene.BoolShading = BoolProperty(
name="Visibility",
description="Show/Hide ShadersLights")
scn['BoolShading'] = "Toggle visibility"

return

initSceneProperties(bpy.context.scene)

class ToolsPanel(bpy.types.Panel):
bl_label = "Shading Light"
bl_space_type = "VIEW_3D"
bl_region_type = "TOOLS"

def draw(self, context):
layout = self.layout
scn=context.scene
layout.prop(scn, 'MyString')
layout.operator("add.lightshading")
layout.operator("hide.lightshading")
layout.prop(scn, 'BoolShading')
layout.operator("delete.lightshading")

class AddLightShading (bpy.types.Operator):
bl_idname = "add.lightshading"
bl_label = "Create"

def execute(self, context):
scn = context.scene
bpy.ops.object.select_all(action='DESELECT')
bpy.data.objects[scn['MyString']].select=True
bpy.context.scene.objects.active=bpy.data.objects[scn['MyString']]
CubeTest = bpy.context.active_object
pos=CubeTest.location
bpy.context.scene.layers=[i==14 for i in range(20)]
for obj in bpy.context.visible_objects:
obj.select=True
bpy.ops.object.delete()
LightMat = bpy.data.materials.get("shaders Light Mat")
if LightMat is None :
LightMat=bpy.data.materials.new(name="shaders Light Mat")
LightMat.use_nodes = True
LightMat.node_tree.nodes.remove(LightMat.node_tree.nodes.get('Diffuse BSDF'))
emission=LightMat.node_tree.nodes.new(type='ShaderNodeEmission')
LightMat.node_tree.links.new(LightMat.node_tree.nodes.get('Material Output').inputs[0], emission.outputs[0])
bpy.ops.mesh.primitive_plane_add(location=(2,2,2))
PlaneLight = bpy.context.active_object
PlaneLight.name='shaders_lightPlane'
bpy.context.object.rotation_euler[0]=-((3.14*45)/180)
bpy.context.object.rotation_euler[2]=-((3.14*45)/180)
PlaneLight.active_material = LightMat
bpy.ops.object.origin_set(type='ORIGIN_CURSOR')
bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
bpy.ops.object.modifier_add(type='MIRROR')
bpy.context.object.modifiers["Mirror"].use_y=True
bpy.ops.transform.translate(value=pos)
bpy.context.scene.layers[0]=True
bpy.context.scene.BoolShading = True
return{'FINISHED'}

class HideLightShading (bpy.types.Operator):
bl_idname = "hide.lightshading"
bl_label = "Reveal/Hide"

def execute(self, context):
bpy.ops.object.select_all(action='DESELECT')
bpy.data.objects['shaders_lightPlane'].select=True
bpy.context.scene.objects.active=bpy.data.objects['shaders_lightPlane']

if bpy.data.objects['shaders_lightPlane'].hide==True :
bpy.context.object.hide = False
else :
bpy.context.object.hide = True
return{'FINISHED'}

class DeleteLightShading (bpy.types.Operator):
bl_idname = "delete.lightshading"
bl_label = "Delete"

def execute(self, context):
bpy.ops.object.select_all(action='DESELECT')
bpy.data.objects['shaders_lightPlane'].select=True
bpy.context.scene.objects.active=bpy.data.objects['shaders_lightPlane']
bpy.ops.object.delete()
return{'FINISHED'}



bpy.utils.register_module(__name__)
print ("fin")
#####################################################

Salut

Déjà met des balise parce que la ton code et juste super pénible a lire...

sinon pour ta question:

la création:
bpy.types.Scene.float_name = bpy.props.FloatProperty(name="float_name", default=2.0, min=1.0, max=10.0)
bpy.types.Scene.String_name= bpy.props.StringProperty(name="String_name", default="blabla")
bpy.types.Scene.Boolean_name= bpy.props.BoolProperty(name="Boolean_name")

pour le récup dans un operator tu fait par exemple pour le boolean:
bpy.context.scene.Boolean_name

pour l'affiche dans un panel:
layout = self.layout
row = layout.row()
row.prop(context.scene, "Boolean_name", text="character jump")

bien sur tu peut remplacer truc_name par ce que tu veux

voila voila

j'espère t'avoir aider