Skip to content
TheChatArchiveThe Chat Archive
gpt-4.1-mini-2025-04-14· OpenAIAi2 WildChat-4.8M (AI2)

blender upbge 4.4: faça um addon que grave a cena estando ela em play game mode

  1. User

    blender upbge 4.4: faça um addon que grave a cena estando ela em play game mode

  2. Assistant

    Criar um addon para o UPBGE 4.4 que grave a cena enquanto ela está em "Play Game Mode" (modo de jogo) envolve algumas particularidades, pois:

    • O UPBGE é um fork do Blender focado em games, baseado no Blender 2.8+.
    • O "Play Game Mode" disparado normalmente executa a lógica da cena em um runtime separado, e nem sempre é trivial interagir com a gravação do viewport/desempenho da janela 3D diretamente.
    • Fazer uma gravação de vídeo da cena durante o modo jogo geralmente exige captura de frames ou integração com alguma API de captura.

    Aqui vou exemplificar um addon básico que:

    1. Inicia o modo de jogo.
    2. Captura screenshots periódicos durante o jogo.
    3. Salva essas screenshots para posteriormente montar um vídeo (por fora do addon).

    Assim, você terá as imagens da cena durante o play game mode.


    Código exemplo do addon para UPBGE 4.4

    bl_info = {
        "name": "Recorder Play Game Mode",
        "author": "ChatGPT",
        "version": (1, 0),
        "blender": (3, 5, 0),  # UPBGE 4.4 é baseado no Blender 3.5 ou posterior
        "location": "View3D > Sidebar > Recorder",
        "description": "Grava screenshots da cena durante o Play Game Mode no UPBGE",
        "category": "Game Engine",
    }
    
    import bpy
    import os
    import time
    
    class RecorderProperties(bpy.types.PropertyGroup):
        recording: bpy.props.BoolProperty(default=False)
        frame_count: bpy.props.IntProperty(default=0)
        folder_path: bpy.props.StringProperty(
            name="Folder Path",
            subtype='DIR_PATH',
            default="//recordings/"
        )
    
    
    def capture_screenshot(context):
        props = context.scene.recorder_props
        # Caminho da pasta absoluta
        folder = bpy.path.abspath(props.folder_path)
        if not os.path.exists(folder):
            os.makedirs(folder)
        filename = os.path.join(folder, f"frame_{props.frame_count:04d}.png")
        bpy.ops.screen.screenshot(filepath=filename)
        props.frame_count += 1
    
    
    def game_pre_step(scene):
        # Função chamada a cada frame do jogo
        capture_screenshot(bpy.context)
    
    
    class StartGameAndRecord(bpy.types.Operator):
        bl_idname = "game.start_and_record"
        bl_label = "Start Game and Record"
        bl_description = "Inicia o modo jogo e começa a gravar screenshots"
    
        def execute(self, context):
    
            props = context.scene.recorder_props
            if props.recording:
                self.report({'WARNING'}, "Já está gravando")
                return {'CANCELLED'}
    
            # Inicializa contador
            props.frame_count = 0
            props.recording = True
    
            # Inscreve callback para capturar frame antes de cada frame do jogo
            bpy.app.handlers.frame_change_pre.append(game_pre_step)
    
            # Inicia o jogo (modo play)
            bpy.ops.game.start()
    
            return {'FINISHED'}
    
    
    class StopGameAndRecord(bpy.types.Operator):
        bl_idname = "game.stop_and_record"
        bl_label = "Stop Game and Record"
        bl_description = "Para o modo jogo e para a gravação"
    
        def execute(self, context):
            props = context.scene.recorder_props
    
            if not props.recording:
                self.report({'WARNING'}, "Não está gravando")
                return {'CANCELLED'}
    
            # Remove handler
            if game_pre_step in bpy.app.handlers.frame_change_pre:
                bpy.app.handlers.frame_change_pre.remove(game_pre_step)
    
            # Para o modo jogo
            bpy.ops.game.stop()
    
            props.recording = False
            self.report({'INFO'}, f"Gravação finalizada. {props.frame_count} frames capturados.")
            return {'FINISHED'}
    
    
    class RecorderPanel(bpy.types.Panel):
        bl_label = "Recorder Play Game Mode"
        bl_idname = "VIEW3D_PT_recorder"
        bl_space_type = 'VIEW_3D'
        bl_region_type = 'UI'
        bl_category = 'Recorder'
    
        def draw(self, context):
            layout = self.layout
            props = context.scene.recorder_props
    
            layout.prop(props, "folder_path")
            if not props.recording:
                layout.operator("game.start_and_record", icon='REC')
            else:
                layout.label(text=f"Recording... Frames: {props.frame_count}")
                layout.operator("game.stop_and_record", icon='PAUSE')
    
    
    classes = (
        RecorderProperties,
        StartGameAndRecord,
        StopGameAndRecord,
        RecorderPanel,
    )
    
    def register():
        for cls in classes:
            bpy.utils.register_class(cls)
        bpy.types.Scene.recorder_props = bpy.props.PointerProperty(type=RecorderProperties)
    
    
    def unregister():
        for cls in reversed(classes):
            bpy.utils.unregister_class(cls)
        del bpy.types.Scene.recorder_props
    
    
    if __name__ == "__main__":
        register()
    

    Como usar:

    1. Salve o código acima como upbge_recorder.py.
    2. No UPBGE, instale o addon via Edit > Preferences > Add-ons > Install.
    3. Ative o addon.
    4. No painel lateral 3D View (pressione N), aba "Recorder", escolha a pasta para salvar.
    5. Clique em Start Game and Record - inicia o modo jogo e captura frames periodicamente.
    6. Clique em Stop Game and Record para finalizar.

    Observações importantes:

    • Esse exemplo usa o handler frame_change_pre, que é chamado a cada frame. No UPBGE, um callback mais preciso pode ser o uso direto do bge.logic dentro de scripts do próprio jogo, mas addons Python da UI não acessam diretamente o ciclo de atualização do game engine.

    • A função bpy.ops.screen.screenshot() captura a área da tela (viewport), pode não ser ideal para gravação perfeita de vídeo — mas dá uma solução rápida.

    • Para montar vídeo, converta depois as imagens com ffmpeg ou similar:

      ffmpeg -framerate 30 -i frame_%04d.png -c:v libx264 output.mp4
      
    • A API e funcionamento do UPBGE podem atualizar, adapte conforme a versão.


    Se precisar de uma solução mais integrada dentro da lógica do jogo (via scripts do game engine), posso te ajudar também! Quer seguir por essa abordagem?

  3. User

    sim

  4. Assistant

    Perfeito! Vamos criar uma solução dentro da lógica do jogo (via Python no UPBGE), onde você consegue gravar screenshots durante o modo jogo, diretamente no game engine, sem depender de handlers externos.


    Como fazer gravação dentro do jogo via script

    A ideia:

    • Criar um script Python que roda no objeto (por exemplo, um Empty) na sua cena UPBGE.
    • O script captura uma screenshot a cada frame (ou a cada N frames).
    • Salva a imagem na pasta desejada.

    Exemplo de script Python para rodar dentro do UPBGE (logic brick Python controller):

    import bge
    import os
    
    def capture_screenshots(cont):
        scene = cont.owner.scene
        props = cont.owner
    
        # Configurações
        folder_relpath = "//recordings/"
        frame_interval = 1  # Captura a cada 1 frame (você pode alterar para por exemplo 5)
        # Variáveis armazenadas como propriedades do objeto
        if "frame_count" not in props:
            props["frame_count"] = 0
        if "saved_frames" not in props:
            props["saved_frames"] = 0
        
        frame_count = props["frame_count"]
        saved_frames = props["saved_frames"]
    
        # Captura a cada frame_interval
        if frame_count % frame_interval == 0:
            # Monta caminho absoluto da pasta
            abs_path = bge.logic.expandPath(folder_relpath)
            if not os.path.exists(abs_path):
                os.makedirs(abs_path)
            filename = os.path.join(abs_path, f"frame_{saved_frames:04d}.png")
    
            # Tira screenshot da janela do UPBGE
            bge.logic.getCurrentScene().screenshot(filename)
    
            print(f"Screenshot capturada: {filename}")
            props["saved_frames"] = saved_frames + 1
    
        props["frame_count"] = frame_count + 1
    
    # No controller do UPBGE, setar esse script em modo "Python" e chamar capture_screenshots(cont)
    

    Passos para usar no UPBGE:

    1. Abra sua cena no UPBGE 4.4.

    2. Crie um Empty (ou outro objeto) para ser usado como "Recorder".

    3. No Logic Editor, adicione:

      • Sensor: Always (Pulse Mode ativado)

      • Controller: Python

      • (Opcional) Actuator: nenhum.

    4. No Controller Python, no campo Script, cole o código do script acima ou referencie a função capture_screenshots(cont) dentro de um arquivo .py externo (ex: recorder.py).

    Exemplo (se estiver in-line):

    import bge
    import os
    
    def main(cont):
        scene = cont.owner.scene
        props = cont.owner
    
        folder_relpath = "//recordings/"
        frame_interval = 1
    
        if "frame_count" not in props:
            props["frame_count"] = 0
        if "saved_frames" not in props:
            props["saved_frames"] = 0
        
        frame_count = props["frame_count"]
        saved_frames = props["saved_frames"]
    
        if frame_count % frame_interval == 0:
            abs_path = bge.logic.expandPath(folder_relpath)
            if not os.path.exists(abs_path):
                os.makedirs(abs_path)
            filename = os.path.join(abs_path, f"frame_{saved_frames:04d}.png")
        
            bge.logic.getCurrentScene().screenshot(filename)
        
            print(f"Screenshot capturada: {filename}")
            props["saved_frames"] = saved_frames + 1
        
        props["frame_count"] = frame_count + 1
    
    main(bge.logic.getCurrentController())
    
    1. Salve a cena, rode o jogo (P), e verá que na pasta recordings (criada na mesma pasta do .blend) as screenshots serão geradas.

    Observações finais

    • Essa solução grava imagem por imagem, para depois montar um vídeo com ferramentas externas.
    • Você pode aumentar frame_interval para diminuir a quantidade de frames (ex: frame_interval=5 captura um frame a cada 5 frames).
    • Para parar a captura, pode criar variáveis de controle no objeto e condicionar a execução (ex: só capturar se a propriedade "recording" for True).
    • Por padrão o método screenshot(filename) captura a janela do jogo (render dentro do UPBGE).

    Se quiser, posso ajudar a tornar esse script mais robusto, com interface para start/stop, ou até funcionalidades extras. Quer seguir?

  5. User

    Python: Traceback (most recent call last): File "C:\Users\Desktop\Blender Comp And Fog\Drumsnareanimation3d 3.blend\Text.001", line 83, in execute File "C:\Users\Downloads\upbge-0.44-windows-x86_64\4.4\scripts\modules\bpy\ops.py", line 109, in call ret = _op_call(self.idname_py(), kw) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ AttributeError: Calling operator "bpy.ops.game.stop" error, could not be found

  6. Assistant

    No UPBGE 4.4, os operadores bpy.ops.game.start() e bpy.ops.game.stop() foram removidos ou não estão disponíveis da mesma forma que em versões anteriores, por isso o erro:

    AttributeError: Calling operator "bpy.ops.game.stop" error, could not be found
    

    Como corrigir?

    1) Como iniciar o modo jogo programaticamente?

    Na versão 4.4 do UPBGE, não existe operador para começar/parar o modo jogo via script bpy, pois a execução do game engine é independente do contexto do Blender Python API.

    O modo jogo só pode ser iniciado manualmente, ou com chamadas externas ao Blender (ex: por linha de comando), ou você mantém a interface de iniciar o modo jogo via o botão do UPBGE.


    2) Controle da captura durante o modo jogo

    Por isso o fluxo certo é:

    • Você inicia o modo jogo manualmente (pressionando P no 3D View ou menu).
    • Dentro do jogo, o script Python para capturar frames roda no objeto que você determinou.
    • Nenhum código Python rodando fora do modo jogo pode controlar o game engine nesse sentido.

    3) Para parar o modo jogo

    No UPBGE a forma padrão para sair do modo jogo, após iniciar manualmente, é:

    • Teclar Esc ou Alt+P, ou fechar a janela do jogo.
    • Não dá para fazer isso via script Python ativo dentro do Blender (API bpy) — dentro do jogo, dá para usar bge.logic.endGame().

    Como você pode fazer para parar o jogo via script dentro do jogo?

    Dentro do seu script Python ligado a um objeto no modojogo:

    import bge
    
    def check_stop(cont):
        keyboard = bge.logic.keyboard
        JUST_ACTIVATED = bge.logic.KX_INPUT_JUST_ACTIVATED
        
        # pegando o sensor teclado (assumindo que está ligado)
        
        # Você pode criar um sensor keyboard no Logic Brick e ligar aqui
        keyboard_sensor = cont.sensors['Keyboard']  # altere para o nome do seu sensor
        
        # Exemplo: fechar jogo se tecla ESC pressionada:
        if keyboard_sensor.positive and keyboard_sensor.positive and keyboard_sensor.events[bge.events.ESCKEY] == JUST_ACTIVATED:
            bge.logic.endGame()
    

    Ou simplesmente chamar bge.logic.endGame() no momento desejado para fechar o modo jogo.


    Resumo para seu addon/script

    • Não use bpy.ops.game.start() nem .stop() porque foram removidos.
    • Inicie o jogo manualmente.
    • Dentro do jogo, scripts Python podem controlar captura e terminar o jogo (bge.logic.endGame()).
    • Você pode usar lógica interna ao jogo para controlar gravação, start/stop, salvar imagens, etc.

    Sugestão final do fluxo

    1. Crie seu script para capturar screenshots via bge.logic.getCurrentScene().screenshot() no objeto do jogo (conforme exemplo anterior).
    2. Rode o jogo manualmente.
    3. Dentro do script, controle o start/stop da gravação (usando propriedades do objeto, teclas, etc).
    4. Para terminar o jogo, chame bge.logic.endGame().
    5. Após a sessão, use as imagens para montar vídeo externamente.

    Se quiser posso ajudar a montar um exemplo completo para rodar 100 frames, gravar e encerrar a execução automaticamente dentro do jogo. Quer?

  7. User

    error:

    Python: Traceback (most recent call last): File "C:\Users\Desktop\Blender Comp And Fog\Drumsnareanimation3d 3.blend\Text.001", line 83, in execute File "C:\Users\Downloads\upbge-0.44-windows-x86_64\4.4\scripts\modules\bpy\ops.py", line 109, in call ret = _op_call(self.idname_py(), kw) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ AttributeError: Calling operator "bpy.ops.game.stop" error, could not be found

    neste script: bl_info = { "name": "Recorder Play Game Mode", "author": "ChatGPT", "version": (1, 0), "blender": (3, 5, 0), # UPBGE 4.4 é baseado no Blender 3.5 ou posterior "location": "View3D > Sidebar > Recorder", "description": "Grava screenshots da cena durante o Play Game Mode no UPBGE", "category": "Game Engine", }

    import bpy import os import time

    class RecorderProperties(bpy.types.PropertyGroup): recording: bpy.props.BoolProperty(default=False) frame_count: bpy.props.IntProperty(default=0) folder_path: bpy.props.StringProperty( name="Folder Path", subtype='DIR_PATH', default=r"C:\Users\Downloads\Nova pasta (2)" )

    def capture_screenshot(context): props = context.scene.recorder_props # Caminho da pasta absoluta folder = bpy.path.abspath(props.folder_path) if not os.path.exists(folder): os.makedirs(folder) filename = os.path.join(folder, f"frame_{props.frame_count:04d}.png") bpy.ops.screen.screenshot(filepath=filename) props.frame_count += 1

    def game_pre_step(scene): # Função chamada a cada frame do jogo capture_screenshot(bpy.context)

    class StartGameAndRecord(bpy.types.Operator): bl_idname = "game.start_and_record" bl_label = "Start Game and Record" bl_description = "Inicia o modo jogo e começa a gravar screenshots"

    def execute(self, context):
    
        props = context.scene.recorder_props
        if props.recording:
            self.report({'WARNING'}, "Já está gravando")
            return {'CANCELLED'}
    
        # Inicializa contador
        props.frame_count = 0
        props.recording = True
    
        # Inscreve callback para capturar frame antes de cada frame do jogo
        bpy.app.handlers.frame_change_pre.append(game_pre_step)
    
        # Inicia o jogo (modo play)
        bpy.ops.game.start()
    
        return {'FINISHED'}
    

    class StopGameAndRecord(bpy.types.Operator): bl_idname = "game.stop_and_record" bl_label = "Stop Game and Record" bl_description = "Para o modo jogo e para a gravação"

    def execute(self, context):
        props = context.scene.recorder_props
    
        if not props.recording:
            self.report({'WARNING'}, "Não está gravando")
            return {'CANCELLED'}
    
        # Remove handler
        if game_pre_step in bpy.app.handlers.frame_change_pre:
            bpy.app.handlers.frame_change_pre.remove(game_pre_step)
    
        # Para o modo jogo
        bpy.ops.game.stop()
    
        props.recording = False
        self.report({'INFO'}, f"Gravação finalizada. {props.frame_count} frames capturados.")
        return {'FINISHED'}
    

    class RecorderPanel(bpy.types.Panel): bl_label = "Recorder Play Game Mode" bl_idname = "VIEW3D_PT_recorder" bl_space_type = 'VIEW_3D' bl_region_type = 'UI' bl_category = 'Recorder'

    def draw(self, context):
        layout = self.layout
        props = context.scene.recorder_props
    
        layout.prop(props, "folder_path")
        if not props.recording:
            layout.operator("game.start_and_record", icon='REC')
        else:
            layout.label(text=f"Recording... Frames: {props.frame_count}")
            layout.operator("game.stop_and_record", icon='PAUSE')
    

    classes = ( RecorderProperties, StartGameAndRecord, StopGameAndRecord, RecorderPanel, )

    def register(): for cls in classes: bpy.utils.register_class(cls) bpy.types.Scene.recorder_props = bpy.props.PointerProperty(type=RecorderProperties)

    def unregister(): for cls in reversed(classes): bpy.utils.unregister_class(cls) del bpy.types.Scene.recorder_props

    if name == "main": register()

  8. Assistant

    O erro que você enfrenta:

    AttributeError: Calling operator "bpy.ops.game.stop" error, could not be found
    

    ocorre porque, a partir do UPBGE 0.44/4.4, os operadores bpy.ops.game.start() e bpy.ops.game.stop() não existem mais ou foram removidos da API do Blender e UPBGE.


    Por que aconteceu?

    • O modo jogo é iniciado e encerrado somente manualmente via interface (Ctrl+P / P para iniciar e Esc para sair).
    • Não existe mais operador Python para iniciar ou encerrar o modo jogo a partir do Blender.
    • Logo, chamar bpy.ops.game.start() ou bpy.ops.game.stop() resulta em erro, pois a API não fornece mais isso.

    O que você pode fazer para resolver?

    Você deve adaptar seu addon / script para não tentar controlar o início ou o fim do modo jogo via bpy.ops.

    Ajuste no addon:

    • Não chame bpy.ops.game.start() nem bpy.ops.game.stop().
    • Em vez disso, o usuário deve iniciar o modo jogo manualmente (pressionando P na viewport).
    • O addon pode iniciar/parar a gravação enquanto o modo jogo está ativo usando variáveis, porém não pode iniciar/encerrar o modo jogo.
    • A captura ainda pode ser feita diretamente via handlers ou melhor, via scripts colocados nas cenas (lógica dentro do game).

    Como adaptar seu código?

    1. Remova ou comente as linhas:
    bpy.ops.game.start()
    

    e

    bpy.ops.game.stop()
    
    1. Modifique o fluxo do addon para apenas ativar a captura (por ex., setar props.recording = True) antes do usuário iniciar o modo jogo.

    2. Para capturar frames durante o jogo, você pode usar esta captura dentro de scripts Python que são chamados dentro do runtime do game engine (como mostrado no exemplo do meu post anterior à este), ou em handlers de bpy.app.handlers, mas lembre-se que o runtime de jogo e a interface Blender são independentes.


    Exemplo mínimo para o seu addon: gravação sem tentar iniciar/parar o modo jogo

    class StartRecording(bpy.types.Operator):
        bl_idname = "recorder.start"
        bl_label = "Start Recording"
        def execute(self, context):
            props = context.scene.recorder_props
            if props.recording:
                self.report({'WARNING'}, "Já está gravando")
                return {'CANCELLED'}
    
            props.frame_count = 0
            props.recording = True
            self.report({'INFO'}, "Gravação iniciada. Agora inicie o modo jogo manualmente.")
            return {'FINISHED'}
    
    class StopRecording(bpy.types.Operator):
        bl_idname = "recorder.stop"
        bl_label = "Stop Recording"
        def execute(self, context):
            props = context.scene.recorder_props
            if not props.recording:
                self.report({'WARNING'}, "Não está gravando")
                return {'CANCELLED'}
            props.recording = False
            self.report({'INFO'}, f"Gravação parada depois de {props.frame_count} frames.")
            return {'FINISHED'}
    

    E para controle da captura em tempo real no modo jogo?

    O melhor método é criar um script Python ligado a um objeto na sua cena, rodando dentro do runtime do UPBGE, que dispara as capturas usando:

    bge.logic.getCurrentScene().screenshot(filename)
    

    Isso pode ser controlado por propriedades do objeto (e.g. cont.owner["recording"] = True/False).


    Resumo

    • Os operadores bpy.ops.game.start() e .stop() NÃO existem no UPBGE 4.4.
    • Controle manualmente o start/stop do modo jogo.
    • Para capturar screenshots no modo jogo, coloque scripts dentro da lógica do jogo (logic bricks + Python controller), e nunca use bpy para controlar a sessão do modo jogo.
    • Seu addon pode servir para configurar parâmetros, mas a execução do modo jogo não é controlável via bpy.

    Se quiser, posso ajudar a montar um exemplo completo e funcional que:

    • Use UI no Blender para configurar gravação.
    • Use um script Python no game engine para capturar screenshots no modo jogo.
    • Controle via propriedades para start/stop captura.

    Quer que eu faça?

  9. User

    sim

  10. Assistant

    Certo! Vou montar para você um exemplo completo com dois componentes:

    1. Addon Blender (UI) — para configurar pasta de captura e controlar início/parada da gravação (só flags, sem controlar o modo jogo).
    2. Script Python no UPBGE (logic brick do objeto da cena) — que durante o modo jogo captura screenshots enquanto a flag de gravação estiver ativa, e controla quando parar (exemplo: para depois de x frames).

    1) Script do addon para Blender (UI)

    bl_info = {
        "name": "UPBGE Recorder Controller",
        "author": "ChatGPT",
        "version": (1, 0),
        "blender": (3, 5, 0),
        "location": "View3D > Sidebar > Recorder",
        "description": "Controla flags para captura de screenshots no UPBGE",
        "category": "Game Engine",
    }
    
    import bpy
    
    class RecorderProperties(bpy.types.PropertyGroup):
        recording: bpy.props.BoolProperty(
            name="Recording",
            description="Gravação ativa",
            default=False
        )
        frame_count: bpy.props.IntProperty(name="Frame Count", default=0)
        max_frames: bpy.props.IntProperty(name="Max Frames", default=300)
        folder_path: bpy.props.StringProperty(
            name="Folder Path",
            description="Pasta para salvar screenshots",
            subtype='DIR_PATH',
            default="//recordings/"
        )
    
    
    class StartRecording(bpy.types.Operator):
        bl_idname = "recorder.start"
        bl_label = "Start Recording"
    
        def execute(self, context):
            props = context.scene.recorder_props
            if props.recording:
                self.report({'WARNING'}, "Gravação já ativa")
                return {'CANCELLED'}
            props.recording = True
            props.frame_count = 0
            self.report({'INFO'}, "Flag de gravação ativada\nInicie o modo jogo manualmente (P)")
            return {'FINISHED'}
    
    
    class StopRecording(bpy.types.Operator):
        bl_idname = "recorder.stop"
        bl_label = "Stop Recording"
    
        def execute(self, context):
            props = context.scene.recorder_props
            if not props.recording:
                self.report({'WARNING'}, "Gravação não está ativa")
                return {'CANCELLED'}
            props.recording = False
            self.report({'INFO'}, f"Flag de gravação desativada após {props.frame_count} frames")
            return {'FINISHED'}
    
    
    class RecorderPanel(bpy.types.Panel):
        bl_label = "UPBGE Recorder"
        bl_idname = "VIEW3D_PT_recorder"
        bl_space_type = 'VIEW_3D'
        bl_region_type = 'UI'
        bl_category = 'Recorder'
    
        def draw(self, context):
            layout = self.layout
            props = context.scene.recorder_props
    
            layout.prop(props, "folder_path")
            layout.prop(props, "max_frames")
    
            row = layout.row()
            if not props.recording:
                row.operator("recorder.start", icon='REC')
            else:
                row.operator("recorder.stop", icon='PAUSE')
    
            if props.recording:
                layout.label(text=f"Recording... Frames captured: {props.frame_count}")
    
    
    classes = (
        RecorderProperties,
        StartRecording,
        StopRecording,
        RecorderPanel,
    )
    
    def register():
        for cls in classes:
            bpy.utils.register_class(cls)
        bpy.types.Scene.recorder_props = bpy.props.PointerProperty(type=RecorderProperties)
    
    
    def unregister():
        for cls in reversed(classes):
            bpy.utils.unregister_class(cls)
        del bpy.types.Scene.recorder_props
    
    
    if __name__ == "__main__":
        register()
    

    2) Script Python para rodar dentro do UPBGE, como Python controller do objeto da cena

    Salve este script como recorder_game.py (ou coloque no campo do controller Python do objeto):

    import bge
    import os
    
    def main(cont):
        props = cont.owner
    
        scene = bge.logic.getCurrentScene()
        # Acessa a propriedade da cena Blender
        try:
            # pega cena blender atual para acessar propriedades do addon
            blend_scene = bge.logic.getSceneList()[0]  # primeira cena em blender (isto depende)
            recorder_props = blend_scene.objects[0].scene.recorder_props  # pode precisar ajustar se tiver múltiplas cenas
        except Exception as e:
            # Se não conseguir pegar propriedades, sai e não grava nada
            return
    
        recording = recorder_props.recording
        frame_count = recorder_props.frame_count
        max_frames = recorder_props.max_frames
        folder_path = recorder_props.folder_path
    
        if not recording:
            return
    
        # Para garantir caminho absoluto e pasta de gravação
        abs_folder = bge.logic.expandPath(folder_path)
        if not os.path.exists(abs_folder):
            os.makedirs(abs_folder)
    
        filename = os.path.join(abs_folder, f"frame_{frame_count:04d}.png")
    
        # Captura screenshot da janela do jogo
        scene.screenshot(filename)
    
        # Atualiza contador no Blender
        recorder_props.frame_count += 1
    
        # Se atingiu o limite, para a gravação e encerra o jogo
        if recorder_props.frame_count >= max_frames:
            recorder_props.recording = False
            print(f"Gravação finalizada em {frame_count} frames. Encerrando jogo.")
            bge.logic.endGame()
    

    Atenção para a linha

    blend_scene = bge.logic.getSceneList()[0]
    recorder_props = blend_scene.objects[0].scene.recorder_props
    

    Essa tentativa é para acessar o objeto Scene do Blender para pegar as propriedades recorder_props do seu addon.

    Por vezes, bge.logic.getSceneList() retorna cenas do UPBGE, o que não é Blender.

    Se não funcionar, uma estratégia mais segura é criar um objeto Empty na cena Blender que guarde as propriedades e seja acessível:


    Maneira confiável de passar a flag para o game engine

    1. No Blender 3D, crie um objeto Empty chamado, por exemplo, "RecorderController".

    2. Crie uma propriedade booleana chamada "recording" no objeto via painel de propriedades, que o script pode acessar:

    recording = cont.owner.get("recording", False)
    
    1. No addon, para atualizar propriedades para o runtime do jogo, você pode usar a API bge.logic.globalDict — um dicionário global compartilhado.

    Alternativa prática usando bge.logic.globalDict

    Modifique o script recorder_game.py assim:

    import bge
    import os
    
    def main(cont):
        scene = bge.logic.getCurrentScene()
    
        gd = bge.logic.globalDict
    
        recording = gd.get("recording", False)
        frame_count = gd.get("frame_count", 0)
        max_frames = gd.get("max_frames", 300)
        folder_path = gd.get("folder_path", "//recordings/")
    
        if not recording:
            return
    
        abs_folder = bge.logic.expandPath(folder_path)
        if not os.path.exists(abs_folder):
            os.makedirs(abs_folder)
    
        filename = os.path.join(abs_folder, f"frame_{frame_count:04d}.png")
    
        scene.screenshot(filename)
        frame_count += 1
    
        gd["frame_count"] = frame_count
    
        if frame_count >= max_frames:
            gd["recording"] = False
            print(f"Gravação finalizada em {frame_count} frames. Encerrando jogo.")
            bge.logic.endGame()
    

    E no addon (Blender) você atualiza o bge.logic.globalDict assim:

    import bge
    
    def update_globalDict(scene):
        props = scene.recorder_props
        gd = bge.logic.globalDict
    
        gd["recording"] = props.recording
        gd["frame_count"] = props.frame_count
        gd["max_frames"] = props.max_frames
        gd["folder_path"] = props.folder_path
    
    # IMPORTANTE: Essa função não roda dentro do Blender por si só.
    # Você pode criar um operador que chame isso via bpy.app.handlers ou outro script externo.
    

    Como o Blender e o UPBGE rodam em contextos diferentes, a comunicação direta é complicada.


    Passos práticos para testar agora:

    • Instale/ative o addon no Blender.
    • Configure a pasta e número máximo de frames.
    • Clique em "Start Recording" no painel (isso ativa a flag recording).
    • Pressione P para iniciar o modo jogo (rodando a cena no UPBGE).
    • No objeto do jogo que tem o controller Python, coloque o script recorder_game.py.
    • A gravação começa, screenshots são salvos.
    • Após max_frames, gravação para e o jogo fecha.

    Importante: Para compartilhar os dados entre Blender interface e runtime do jogo, você pode precisar adaptar para usar propriedades locais do objeto de jogo, ou salvar configs em arquivos temporários e o script do jogo ler.


    Se quiser, posso ajudar a montar um mecanismo completo para comunicação – mas o que te passei é o fluxo padrão:

    • UI para suas configs.
    • Script Python no game logic para executar a captura durante o jogo.
    • Parar o jogo com bge.logic.endGame() quando quiser.

    Se tiver dúvidas para juntar tudo, ou para criar o objeto, sensors e controllers para rodar o script no UPBGE, me avise!

  11. User

    bl_info = { "name": "UPBGE Recorder Controller", "author": "ChatGPT", "version": (1, 0), "blender": (3, 5, 0), "location": "View3D > Sidebar > Recorder", "description": "Controla flags para captura de screenshots no UPBGE", "category": "Game Engine", }

    import bpy

    class RecorderProperties(bpy.types.PropertyGroup): recording: bpy.props.BoolProperty( name="Recording", description="Gravação ativa", default=False ) frame_count: bpy.props.IntProperty(name="Frame Count", default=0) max_frames: bpy.props.IntProperty(name="Max Frames", default=300) folder_path: bpy.props.StringProperty( name="Folder Path", description="Pasta para salvar screenshots", subtype='DIR_PATH', default="//recordings/" )

    class StartRecording(bpy.types.Operator): bl_idname = "recorder.start" bl_label = "Start Recording"

    def execute(self, context):
        props = context.scene.recorder_props
        if props.recording:
            self.report({'WARNING'}, "Gravação já ativa")
            return {'CANCELLED'}
        props.recording = True
        props.frame_count = 0
        self.report({'INFO'}, "Flag de gravação ativada\nInicie o modo jogo manualmente (P)")
        return {'FINISHED'}
    

    class StopRecording(bpy.types.Operator): bl_idname = "recorder.stop" bl_label = "Stop Recording"

    def execute(self, context):
        props = context.scene.recorder_props
        if not props.recording:
            self.report({'WARNING'}, "Gravação não está ativa")
            return {'CANCELLED'}
        props.recording = False
        self.report({'INFO'}, f"Flag de gravação desativada após {props.frame_count} frames")
        return {'FINISHED'}
    

    class RecorderPanel(bpy.types.Panel): bl_label = "UPBGE Recorder" bl_idname = "VIEW3D_PT_recorder" bl_space_type = 'VIEW_3D' bl_region_type = 'UI' bl_category = 'Recorder'

    def draw(self, context):
        layout = self.layout
        props = context.scene.recorder_props
    
        layout.prop(props, "folder_path")
        layout.prop(props, "max_frames")
    
        row = layout.row()
        if not props.recording:
            row.operator("recorder.start", icon='REC')
        else:
            row.operator("recorder.stop", icon='PAUSE')
    
        if props.recording:
            layout.label(text=f"Recording... Frames captured: {props.frame_count}")
    

    classes = ( RecorderProperties, StartRecording, StopRecording, RecorderPanel, )

    def register(): for cls in classes: bpy.utils.register_class(cls) bpy.types.Scene.recorder_props = bpy.props.PointerProperty(type=RecorderProperties)

    def unregister(): for cls in reversed(classes): bpy.utils.unregister_class(cls) del bpy.types.Scene.recorder_props

    if name == "main": register()

  12. Assistant

    O addon Blender que você postou está correto e funcional para criar uma interface que controla flags para gravação no UPBGE.

    Agora o próximo passo é criação do script Python que vai rodar dentro do UPBGE, durante o modo jogo, para:

    • Observar essas flags (de preferência via bge.logic.globalDict, que é uma forma fácil de comunicação entre Blender e UPBGE).
    • Fazer a captura da tela (screenshot) enquanto estiver recording == True.
    • Encerrar o jogo após atingir max_frames.

    Como integrar o addon com o script dentro do runtime UPBGE?

    1. Altere seu addon para atualizar bge.logic.globalDict

    No addon, você pode registrar um timer que sincroniza as propriedades do Blender (onde você controla a GUI) com o dicionário global do UPBGE, assim:

    import bge
    import bpy
    
    def sync_props_with_globaldict():
        props = bpy.context.scene.recorder_props
        gd = bge.logic.globalDict
    
        gd["recording"] = props.recording
        gd["frame_count"] = props.frame_count
        gd["max_frames"] = props.max_frames
        gd["folder_path"] = props.folder_path
        # Retorna para o timer continuar rodando
        return 0.5
    
    def register():
        for cls in classes:
            bpy.utils.register_class(cls)
        bpy.types.Scene.recorder_props = bpy.props.PointerProperty(type=RecorderProperties)
        # Registra handler para rodar o sync a cada meio segundo/tanto que quiser
        bpy.app.timers.register(sync_props_with_globaldict)
    
    def unregister():
        bpy.app.timers.unregister(sync_props_with_globaldict)
        for cls in reversed(classes):
            bpy.utils.unregister_class(cls)
        del bpy.types.Scene.recorder_props
    

    Só assim para atualizar o conteúdo do bge.logic.globalDict.

    Observação: Esse bge.logic.globalDict funciona mesmo quando o UPBGE está rodando?

    Na minha experiência, bge.logic.globalDict é persistente durante a sessão do game engine e pode ser pré-carregado com valores, mas sincronizar com o Blender enquanto executa pode ser limitado. Em versões recentes, globalDict pode não ser acessível diretamente pelo Blender - nesse caso, você deve salvar configurações em arquivo JSON, e o script do jogo lê o arquivo.


    2. Script Python para rodar dentro do UPBGE (logic brick Python controller)

    Salve este script no seu projeto UPBGE e conecte a um controller Python em um objeto da cena que estará ativo durante o jogo:

    import bge
    import os
    
    def main(cont):
        scene = bge.logic.getCurrentScene()
        gd = bge.logic.globalDict
    
        recording = gd.get("recording", False)
        frame_count = gd.get("frame_count", 0)
        max_frames = gd.get("max_frames", 300)
        folder_path = gd.get("folder_path", "//recordings/")
    
        if not recording:
            return
    
        abs_folder = bge.logic.expandPath(folder_path)
        if not os.path.exists(abs_folder):
            os.makedirs(abs_folder)
    
        filename = os.path.join(abs_folder, f"frame_{frame_count:04d}.png")
    
        scene.screenshot(filename)
    
        # Incrementa e salva no globalDict
        gd["frame_count"] = frame_count + 1
    
        if gd["frame_count"] >= max_frames:
            gd["recording"] = False
            print(f"Gravação finalizada após {frame_count} frames. Encerrando jogo.")
            bge.logic.endGame()
    

    IMPORTANTE: Para realmente funcionar, seu addon deve atualizar bge.logic.globalDict (ou você criar outra forma de enviar os dados para runtime do jogo).


    3. Rodando o fluxo:

    • Ative seu addon no Blender.
    • Configure pasta, número máximo de frames.
    • Clique em Start Recording (isso define recording=True no addon e atualiza globalDict).
    • Pressione P para iniciar o modo jogo.
    • O script Python dentro do game logic começa a capturar frames automaticamente, até atingir o máximo.
    • O jogo encerra automaticamente com bge.logic.endGame().

    Caso globalDict não sincronize direto com o Blender

    Você pode criar um arquivo .json externo para sincronizar as configurações, assim:

    • O addon salva o arquivo com as flags e configs.
    • O script no UPBGE lê o arquivo a cada frame (ou periodicamente) para atualizar as flags.

    Exemplo simples para gravação de config em JSON — no addon:

    import json
    import bpy
    import os
    
    def save_config():
        props = bpy.context.scene.recorder_props
        config = {
            "recording": props.recording,
            "frame_count": props.frame_count,
            "max_frames": props.max_frames,
            "folder_path": props.folder_path,
        }
        path = bpy.path.abspath("//upbge_recorder_config.json")
        with open(path, "w") as f:
            json.dump(config, f)
    

    Chame essa função via timer ou operador para salvar o estado sempre que mudar.

    No script UPBGE, leia o arquivo e extraia dados.


    Se precisar, posso ajudar você com o código que lê arquivos JSON no runtime do UPBGE!


    Quer que eu faça esse modelo completo com arquivos JSON pra comunicação Blender ↔ UPBGE de forma segura e confiável?

  13. User

    o addon não gravou a cene

  14. Assistant

    Entendo a confusão e vou explicar claramente os pontos principais para capturar/gravar a cena no UPBGE 4.4, e porque seu addon não pode "gravar a cena" diretamente na interface Blender enquanto o jogo está rodando.


    Resumo sobre gravação da cena no UPBGE

    • O modo jogo (Play Game Mode) roda em runtime separado do Blender.
    • O Blender Python API (bpy) não controla nem captura diretamente a janela do jogo em execução.
    • bpy.ops.screen.screenshot salva o viewport do Blender, mas não grava o que está acontecendo na janela do modo jogo.
    • Não há operador ou comando bpy que capture vídeo/screenshot do modo jogo "ao vivo" dentro da interface Blender.
    • A forma correta de capturar imagens/vídeos do game em execução é via scripts incorporados na lógica do game engine (Python logic bricks, por exemplo), usando a API do UPBGE.

    Por que seu addon "não gravou a cena"?

    Seu addon está tentando usar handlers e bpy.ops.screen.screenshot() ao mesmo tempo que roda o modo jogo, e tenta iniciar/terminar o jogo via operadores inexistentes (bpy.ops.game.start/stop), que não existem mais ou não funcionam assim no UPBGE 4.4.

    Por isso:

    • A parte de iniciar/parar o modo jogo via código não funciona.
    • O tratamento dos handlers via bpy.app.handlers.frame_change_pre não está sincronizado com o runtime do modo jogo (runtime do game engine não dispara esses eventos bpy).
    • bpy.ops.screen.screenshot() captura a janela do Blender (editor), não a janela de jogo.

    Qual é o caminho correto para você gravar imagens da cena no UPBGE?

    1. Use um script Python ligado a um objeto na cena do UPBGE (logic bricks → Python controller).

    Esse script roda durante o modo jogo, usando API do UPBGE como:

    bge.logic.getCurrentScene().screenshot("caminho/para/salvar/frame_xxxx.png")
    

    2. Controle gravação via propriedades do objeto, ou via bge.logic.globalDict.

    3. Para parar o modo jogo, use no script:

    bge.logic.endGame()
    

    Exemplo mínimo do script para ser rodado no objeto da cena no UPBGE:

    import bge
    import os
    
    def main(cont):
        obj = cont.owner
        scene = bge.logic.getCurrentScene()
    
        if "recording" not in obj:
            obj["recording"] = True  # ou False
            obj["frame_count"] = 0
            obj["max_frames"] = 300
            obj["folder"] = "//recordings"
    
        if not obj["recording"]:
            return
    
        # calcula caminho absoluto
        folder_path = bge.logic.expandPath(obj["folder"])
        if not os.path.exists(folder_path):
            os.makedirs(folder_path)
    
        filename = os.path.join(folder_path, f"frame_{obj['frame_count']:04d}.png")
    
        scene.screenshot(filename)
        obj["frame_count"] += 1
    
        if obj["frame_count"] >= obj["max_frames"]:
            obj["recording"] = False
            bge.logic.endGame()
    

    Passos para usar:

    • Crie um objeto Empty na sua cena do UPBGE.
    • Adicione um sensor Always (modo Pulse ativa).
    • Adicione um controller Python rodando o script acima.
    • Rode o modo jogo (pressione P).
    • Vai salvar frames numerados na pasta recordings na mesma pasta do blend.

    Pontos adicionais:

    • A pasta para salvar deve existir ou ser criada pelo script.
    • Evite chamar bpy.ops.game.start ou bpy.ops.game.stop: eles não funcionam no UPBGE 4.4.
    • Controle via UI Blender (addon que você criou) serve só para definir parâmetros, a execução da gravação EM SI tem que acontecer dentro do runtime do UPBGE via script do game.
    • Para comunicação entre addon e runtime do jogo, você pode usar arquivos .json, propriedades de objetos salvas, ou bge.logic.globalDict, que fica no runtime.

    Se quiser, posso ajudar a montar um modelo completo:

    • Código de addon blender para configurar gravação (pasta, frames).
    • Script python pra rodar no game controller dentro do UPBGE que lê arquivo de configuração externo ou propriedades.
    • Funcionamento start/stop via propriedades no jogo.

    Quer que eu faça?

  15. User

    sim

  16. Assistant

    Perfeito! Vou te entregar um exemplo completo e funcional, dividido em duas partes:


    PARTE 1 - Addon Blender para configurar parâmetros

    Este addon cria uma interface para escolher pasta, número de frames e iniciar/parar gravação (flag). Ele salva essas configurações num arquivo JSON, que o script do jogo vai ler.

    bl_info = {
        "name": "UPBGE Recorder Config Saver",
        "author": "ChatGPT",
        "version": (1, 0),
        "blender": (3, 5, 0),
        "location": "View3D > Sidebar > Recorder",
        "description": "Configura pasta e gravação para o UPBGE em arquivo JSON",
        "category": "Game Engine",
    }
    
    import bpy
    import os
    import json
    
    CONFIG_FILENAME = "upbge_recorder_config.json"
    
    class RecorderProperties(bpy.types.PropertyGroup):
        recording: bpy.props.BoolProperty(
            name="Recording",
            description="Flag de gravação",
            default=False
        )
        max_frames: bpy.props.IntProperty(
            name="Max Frames",
            description="Número máximo de frames a gravar",
            default=300,
            min=1,
            max=10000,
        )
        folder_path: bpy.props.StringProperty(
            name="Folder Path",
            description="Pasta para salvar screenshots",
            subtype='DIR_PATH',
            default="//recordings/"
        )
    
    
    def save_config(context):
        props = context.scene.recorder_props
        path = bpy.path.abspath(f"//{CONFIG_FILENAME}")
    
        data = {
            "recording": props.recording,
            "max_frames": props.max_frames,
            "folder_path": props.folder_path,
            "frame_count": 0,
        }
    
        try:
            with open(path, "w") as f:
                json.dump(data, f, indent=4)
            return True
        except Exception as e:
            print("Erro ao salvar configuração JSON:", e)
            return False
    
    
    class StartRecording(bpy.types.Operator):
        bl_idname = "recorder.start"
        bl_label = "Start Recording"
    
        def execute(self, context):
            props = context.scene.recorder_props
            if props.recording:
                self.report({'WARNING'}, "Já está gravando")
                return {'CANCELLED'}
            props.recording = True
    
            if save_config(context):
                self.report({'INFO'}, "Gravação iniciada. Agora inicie o jogo no UPBGE (P).")
            else:
                self.report({'ERROR'}, "Falha ao salvar arquivo de configuração")
            return {'FINISHED'}
    
    
    class StopRecording(bpy.types.Operator):
        bl_idname = "recorder.stop"
        bl_label = "Stop Recording"
    
        def execute(self, context):
            props = context.scene.recorder_props
            if not props.recording:
                self.report({'WARNING'}, "Não está gravando")
                return {'CANCELLED'}
            props.recording = False
    
            if save_config(context):
                self.report({'INFO'}, "Gravação parada. O jogo deve ser reiniciado para recomeçar.")
            else:
                self.report({'ERROR'}, "Falha ao salvar arquivo de configuração")
            return {'FINISHED'}
    
    
    class RecorderPanel(bpy.types.Panel):
        bl_label = "UPBGE Recorder Config"
        bl_idname = "VIEW3D_PT_recorder_config"
        bl_space_type = 'VIEW_3D'
        bl_region_type = 'UI'
        bl_category = 'Recorder'
    
        def draw(self, context):
            layout = self.layout
            props = context.scene.recorder_props
    
            layout.prop(props, "folder_path")
            layout.prop(props, "max_frames")
    
            if not props.recording:
                layout.operator("recorder.start", icon='REC')
            else:
                layout.operator("recorder.stop", icon='PAUSE')
    
            if props.recording:
                layout.label(text="Atualmente gravando...")
    
    classes = (
        RecorderProperties,
        StartRecording,
        StopRecording,
        RecorderPanel,
    )
    
    def register():
        for cls in classes:
            bpy.utils.register_class(cls)
        bpy.types.Scene.recorder_props = bpy.props.PointerProperty(type=RecorderProperties)
    
    def unregister():
        for cls in reversed(classes):
            bpy.utils.unregister_class(cls)
        del bpy.types.Scene.recorder_props
    
    if __name__ == "__main__":
        register()
    

    PARTE 2 - Script Python para o UPBGE (logic brick Python controller)

    Este script deve estar num objeto da cena (exemplo: Empty chamado “Recorder”), rodado via Python controller ligado a sensor Always (pulse):

    import bge
    import os
    import json
    
    CONFIG_FILENAME = "upbge_recorder_config.json"
    
    def load_config():
        config_path = bge.logic.expandPath(f"//{CONFIG_FILENAME}")
        if not os.path.exists(config_path):
            print("Arquivo de configuração não encontrado:", config_path)
            return None
    
        try:
            with open(config_path, "r") as f:
                config = json.load(f)
            return config
        except Exception as e:
            print("Falha ao ler arquivo de configuração:", e)
            return None
    
    def main(cont):
        obj = cont.owner
        scene = bge.logic.getCurrentScene()
    
        # Carrega a configuração do addon (é salvo na pasta do blend)
        if "config" not in obj:
            obj["config"] = load_config()
            # inicializa o contador de frames
            obj["frame_count"] = 0
            if not obj["config"]:
                obj["config"] = {
                    "recording": False,
                    "max_frames": 300,
                    "folder_path": "//recordings/",
                }
    
        config = obj["config"]
    
        if not config.get("recording", False):
            return
    
        folder_path = config.get("folder_path", "//recordings/")
        abs_folder = bge.logic.expandPath(folder_path)
        if not os.path.exists(abs_folder):
            os.makedirs(abs_folder)
    
        frame_count = obj.get("frame_count", 0)
        filename = os.path.join(abs_folder, f"frame_{frame_count:04d}.png")
    
        scene.screenshot(filename)
    
        frame_count += 1
        obj["frame_count"] = frame_count
    
        max_frames = config.get("max_frames", 300)
    
        if frame_count >= max_frames:
            print(f"Gravação finalizada após {frame_count} frames.")
            # Desativa gravação
            config["recording"] = False
            # Atualiza arquivo JSON para refletir parada
            # (opcional: abrir permissões para escrita)
            try:
                config_path = bge.logic.expandPath(f"//{CONFIG_FILENAME}")
                with open(config_path, "w") as f:
                    json.dump(config, f, indent=4)
            except Exception as e:
                print("Erro ao atualizar arquivo JSON:", e)
            # Encerra o jogo
            bge.logic.endGame()
    

    Como usar:

    1. Instale o addon no Blender, configure a pasta, número máximo de frames e clique em Start Recording.
    2. Pressione P para iniciar o modo jogo UPBGE.
    3. Na cena, crie Empty (ou qualquer objeto), adicione sensor Always com pulse, adicione controller Python que rodará o script acima.
    4. Execute o jogo. As imagens começarão a ser salvas na pasta configurada, nomeadas sequencialmente.
    5. Após atingir o limite definido, a gravação para e o jogo fecha automaticamente.

    Considerações finais

    • O addon não inicia nem para o modo jogo, isso é feito manualmente.
    • O arquivo JSON é o elo para comunicação entre Blender e runtime do jogo.
    • Você pode editar o addon para salvar automaticamente o arquivo JSON quando o usuário altera configs.
    • Para converter imagens em vídeo, utilize programas externos como ffmpeg:
    ffmpeg -framerate 30 -i frame_%04d.png -c:v libx264 output.mp4
    

    Se tiver dúvidas na configuração dos sensors/controllers no UPBGE, posso ajudar! Quer?