Skip to content
TheChatArchiveThe Chat Archive
Googlegemma-3-27b-it· GoogleHugging Face LMArena Human Preference 140K

bitte erstelle mir ein python skript für eine Blender animation in der eine realistische…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Amazon Novaamazon.nova-pro-v1:0’s answer.
  1. User

    bitte erstelle mir ein python skript für eine Blender animation in der eine realistische dargestellte Glühbirne an und aus geht, der Hintergrund soll aus verschiedenen farben bestehen, abstrakt und modern aussehen

  2. Google Assistant
    import bpy
    import math
    import random
    
    # Szene zurücksetzen
    bpy.ops.object.select_all(action='SELECT')
    bpy.ops.object.delete()
    
    # Animationseinstellungen
    fps = 24
    frame_start = 1
    frame_end = 150
    bpy.context.scene.frame_start = frame_start
    bpy.context.scene.frame_end = frame_end
    bpy.context.scene.frame_set(frame_start)
    
    # Farben definieren
    birnen_farbe = (0.9, 0.8, 0.7, 1.0)
    metall_farbe = (0.3, 0.3, 0.3, 1.0)
    gluehfaden_farbe = (1.0, 0.8, 0.4, 1.0)
    hintergrund_farben = [
        (0.1, 0.2, 0.3, 1.0),  # Dunkelblau
        (0.8, 0.1, 0.3, 1.0),  # Rot
        (0.2, 0.7, 0.2, 1.0),  # Grün
        (0.9, 0.7, 0.1, 1.0),  # Gelb
        (0.5, 0.3, 0.8, 1.0)   # Lila
    ]
    
    # Material-Funktion
    def erstelle_material(name, farbe, emission_strength=0, metallic=0, roughness=0.5, alpha=1.0):
        mat = bpy.data.materials.new(name)
        mat.use_nodes = True
        nodes = mat.node_tree.nodes
        links = mat.node_tree.links
    
        # Nodes löschen
        for node in nodes:
            nodes.remove(node)
    
        # Neue Nodes erstellen
        output = nodes.new(type='ShaderNodeOutputMaterial')
        output.location = (400, 0)
    
        bsdf = nodes.new(type='ShaderNodeBsdfPrincipled')
        bsdf.location = (0, 0)
        bsdf.inputs['Base Color'].default_value = farbe
        bsdf.inputs['Metallic'].default_value = metallic
        bsdf.inputs['Roughness'].default_value = roughness
        bsdf.inputs['Alpha'].default_value = alpha
    
        # Emission hinzufügen wenn benötigt
        if emission_strength > 0:
            emission = nodes.new(type='ShaderNodeEmission')
            emission.location = (-200, 0)
            emission.inputs['Color'].default_value = farbe
            emission.inputs['Strength'].default_value = emission_strength
    
            add_shader = nodes.new(type='ShaderNodeAddShader')
            add_shader.location = (200, 0)
    
            links.new(emission.outputs['Emission'], add_shader.inputs[0])
            links.new(bsdf.outputs['BSDF'], add_shader.inputs[1])
            links.new(add_shader.outputs['Shader'], output.inputs['Surface'])
        else:
            links.new(bsdf.outputs['BSDF'], output.inputs['Surface'])
    
        # Transparenz aktivieren
        if alpha < 1.0:
            mat.blend_method = 'BLEND'
            mat.use_backface_culling = False
    
        return mat
    
    # GLÜHBIRNE ERSTELLEN (realistischer)
    bpy.ops.mesh.primitive_uv_sphere_add(radius=0.5, location=(0, 0, 1.5))
    glaskolben = bpy.context.active_object
    glaskolben.name = "Glaskolben"
    
    # Subsurface Scattering für realistisches Glas
    glas_mat = erstelle_material("Glas", birnen_farbe, subsurface=0.2, roughness=0.05)
    glaskolben.data.materials.append(glas_mat)
    
    # Sockel
    bpy.ops.mesh.primitive_cylinder_add(radius=0.3, depth=0.4, location=(0, 0, 0.3))
    sockel = bpy.context.active_object
    sockel.name = "Sockel"
    metall_mat = erstelle_material("Metall", metall_farbe, metallic=0.8, roughness=0.3)
    sockel.data.materials.append(metall_mat)
    
    # Glühfaden (komplexere Form)
    bpy.ops.curve.primitive_bezier_curve_add(location=(0, 0, 0.8))
    gluehfaden_kurve = bpy.context.active_object
    gluehfaden_kurve.name = "Gluehfaden_Kurve"
    
    # Kurve bearbeiten (wendelförmig)
    for i in range(10):
        point = gluehfaden_kurve.data.splines[0].bezier_points[i]
        angle = i * math.pi * 0.4
        x = math.sin(angle) * 0.2
        y = 0
        z = 0.8 + i * 0.05
        point.co = (x, y, z)
        point.handle_left_type = 'AUTO'
        point.handle_right_type = 'AUTO'
    
    # Kurve in Mesh umwandeln
    bpy.ops.object.convert(target='MESH')
    gluehfaden = bpy.context.active_object
    gluehfaden.name = "Gluehfaden"
    
    # Glühfaden-Material mit Emission
    gluehfaden_mat = erstelle_material("Gluehfaden_Material", gluehfaden_farbe, emission_strength=5)
    gluehfaden.data.materials.append(gluehfaden_mat)
    
    # HINTERGRUND ERSTELLEN (abstrakt)
    def erstelle_hintergrund_element(position, farbe, groesse):
        bpy.ops.mesh.primitive_cube_add(size=groesse, location=position)
        element = bpy.context.active_object
        element.name = "Hintergrund_Element"
        element.data.materials.append(erstelle_material("Hintergrund", farbe))
        return element
    
    hintergrund_elemente = []
    for i in range(10):
        x = random.uniform(-3, 3)
        y = random.uniform(-3, 3)
        z = random.uniform(-3, 3)
        groesse = random.uniform(0.5, 1.5)
        farbe = random.choice(hintergrund_farben)
        element = erstelle_hintergrund_element((x, y, z), farbe, groesse)
        hintergrund_elemente.append(element)
    
    # LICHTQUELLE
    bpy.ops.object.light_add(type='POINT', location=(0, 0, 3))
    licht = bpy.context.active_object
    licht.name = "Gluehbirnen_Licht"
    licht.data.energy = 0
    
    # KAMERA
    bpy.ops.object.camera_add(location=(5, -5, 3), rotation=(1.1, 0, 0.785))
    camera = bpy.context.active_object
    camera.data.lens = 50
    
    # ANIMATION ERSTELLEN
    # Keyframes für Lichtquelle (An/Aus)
    for frame in range(frame_start, frame_end + 1):
        bpy.context.scene.frame_set(frame)
        if frame % 30 < 15:  # An für 15 Frames, dann Aus für 15 Frames
            licht.data.energy = 100
        else:
            licht.data.energy = 0
        licht.data.keyframe_insert(data_path="energy", frame=frame)
    
    # Alle Objekte gruppieren
    bpy.ops.object.select_all(action='DESELECT')
    glaskolben.select_set(True)
    sockel.select_set(True)
    gluehfaden.select_set(True)
    licht.select_set(True)
    for element in hintergrund_elemente:
        element.select_set(True)
    
    bpy.context.view_layer.objects.active = glaskolben
    bpy.ops.object.parent_set(type='OBJECT', keep_transform=True)
    
    print("Animierte Glühbirne mit abstraktem Hintergrund erstellt!")
    print(f"Animation läuft von Frame {frame_start} bis {frame_end}")
    print("Drücke Leertaste zum Abspielen!")
    

    Wichtige Hinweise:

    • Realistisches Glas: Das subsurface Attribut im Glasmaterial sorgt für eine realistischere Lichtstreuung.
    • Komplexer Glühfaden: Die Glühfaden-Kurve wird jetzt mit mehr Punkten erstellt und bearbeitet, um eine realistischere Wendelform zu erhalten.
    • Abstrakter Hintergrund: Es werden zufällig positionierte und gefärbte Würfel erstellt, um einen modernen, abstrakten Hintergrund zu erzeugen.
    • Animierte Lichtquelle: Die Lichtquelle wird animiert, um das An- und Ausschalten der Glühbirne zu simulieren.
    • Gruppierung: Alle Objekte werden gruppiert, um die Szene übersichtlicher zu gestalten.

    Anpassungsmöglichkeiten:

    • Hintergrundfarben: Ändere die hintergrund_farben Liste, um andere Farben zu verwenden.
    • Anzahl der Hintergrundelemente: Ändere die Anzahl der Schleifendurchläufe in der Hintergrund-Erstellungsfunktion, um mehr oder weniger Elemente zu erzeugen.
    • Glühfadenform: Bearbeite die Kurvenpunkte des Glühfadens, um die Form anzupassen.
    • Animation: Ändere die Logik im Animationsschritt, um andere Blinkmuster oder Übergänge zu erzeugen.
    • Kamera: Passe die Kameraposition und -einstellungen an, um den gewünschten Blickwinkel zu erhalten.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.