blender upbge 4.4: faça um addon que grave a cena estando ela em play game mode
- User
blender upbge 4.4: faça um addon que grave a cena estando ela em play game mode
- 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:
- Inicia o modo de jogo.
- Captura screenshots periódicos durante o jogo.
- 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:
- Salve o código acima como
upbge_recorder.py. - No UPBGE, instale o addon via Edit > Preferences > Add-ons > Install.
- Ative o addon.
- No painel lateral 3D View (pressione
N), aba "Recorder", escolha a pasta para salvar. - Clique em Start Game and Record - inicia o modo jogo e captura frames periodicamente.
- 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 dobge.logicdentro 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
ffmpegou 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?
- User
sim
- 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:
-
Abra sua cena no UPBGE 4.4.
-
Crie um Empty (ou outro objeto) para ser usado como "Recorder".
-
No Logic Editor, adicione:
-
Sensor: Always (Pulse Mode ativado)
-
Controller: Python
-
(Opcional) Actuator: nenhum.
-
-
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.pyexterno (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())- Salve a cena, rode o jogo (
P), e verá que na pastarecordings(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_intervalpara diminuir a quantidade de frames (ex:frame_interval=5captura 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?
- 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
- Assistant
No UPBGE 4.4, os operadores
bpy.ops.game.start()ebpy.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
EscouAlt+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
- Crie seu script para capturar screenshots via
bge.logic.getCurrentScene().screenshot()no objeto do jogo (conforme exemplo anterior). - Rode o jogo manualmente.
- Dentro do script, controle o start/stop da gravação (usando propriedades do objeto, teclas, etc).
- Para terminar o jogo, chame
bge.logic.endGame(). - 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?
- 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()
- Assistant
O erro que você enfrenta:
AttributeError: Calling operator "bpy.ops.game.stop" error, could not be foundocorre porque, a partir do UPBGE 0.44/4.4, os operadores
bpy.ops.game.start()ebpy.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()oubpy.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()nembpy.ops.game.stop(). - Em vez disso, o usuário deve iniciar o modo jogo manualmente (pressionando
Pna 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?
- Remova ou comente as linhas:
bpy.ops.game.start()e
bpy.ops.game.stop()-
Modifique o fluxo do addon para apenas ativar a captura (por ex., setar
props.recording = True) antes do usuário iniciar o modo jogo. -
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?
- User
sim
- Assistant
Certo! Vou montar para você um exemplo completo com dois componentes:
- Addon Blender (UI) — para configurar pasta de captura e controlar início/parada da gravação (só flags, sem controlar o modo jogo).
- 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_propsEssa tentativa é para acessar o objeto
Scenedo Blender para pegar as propriedadesrecorder_propsdo 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
-
No Blender 3D, crie um objeto Empty chamado, por exemplo,
"RecorderController". -
Crie uma propriedade booleana chamada
"recording"no objeto via painel de propriedades, que o script pode acessar:
recording = cont.owner.get("recording", False)- 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.pyassim: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.globalDictassim: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
Ppara 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!
- 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()
- 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 estiverrecording == 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.globalDictNo 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_propsSó assim para atualizar o conteúdo do
bge.logic.globalDict.Observação: Esse
bge.logic.globalDictfunciona 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,globalDictpode 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=Trueno addon e atualizaglobalDict). - 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
globalDictnão sincronize direto com o BlenderVocê pode criar um arquivo
.jsonexterno 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?
- Observar essas flags (de preferência via
- User
o addon não gravou a cene
- 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.screenshotsalva 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_prenã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
recordingsna mesma pasta do blend.
Pontos adicionais:
- A pasta para salvar deve existir ou ser criada pelo script.
- Evite chamar
bpy.ops.game.startoubpy.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, oubge.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?
- User
sim
- 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:
- Instale o addon no Blender, configure a pasta, número máximo de frames e clique em Start Recording.
- Pressione
Ppara iniciar o modo jogo UPBGE. - Na cena, crie Empty (ou qualquer objeto), adicione sensor Always com pulse, adicione controller Python que rodará o script acima.
- Execute o jogo. As imagens começarão a ser salvas na pasta configurada, nomeadas sequencialmente.
- 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?