def delete(self):
logger.info("Delete %s" % GetClassName(self))
self.set_color_textures()
self.set_depth_texture(None)
glDeleteFramebuffers(1, [
self.buffer,
])
def initialize(self, core_manager):
logger.info("initialize " + GetClassName(self))
self.core_manager = core_manager
self.resource_manager = core_manager.resource_manager
self.scene_loader = self.resource_manager.scene_loader
self.renderer = core_manager.renderer
self.effect_manager = core_manager.effect_manager
def get_save_data(self):
save_data = dict(
object_type=GetClassName(self),
mesh=self.mesh.name if self.mesh is not None else '',
material_instances=[material_instance.name for material_instance in self.material_instances]
)
return save_data
def initialize(self, core_manager, project_filename=""):
self.core_manager = core_manager
self.scene_manager = core_manager.scene_manager
self.resource_manager = core_manager.resource_manager
# default project
if project_filename == "":
project_filename = self.resource_manager.DefaultProjectFile
else:
project_filename = os.path.relpath(project_filename, ".")
logger.info("initialize %s : %s" %
(GetClassName(self), project_filename))
try:
self.next_open_project_filename = ""
self.project_name = os.path.splitext(
os.path.split(project_filename)[1])[0]
self.project_dir = os.path.split(project_filename)[0]
self.project_filename = project_filename
self.config = Config(project_filename, log_level)
# set default config
self.config.setDefaultValue("Screen", "size", [1280, 720])
self.config.setDefaultValue("Screen", "full_screen", False)
meter_per_unit = 1.0 # 1 unit = 1 m
self.config.setDefaultValue("Camera", "meter_per_unit",
meter_per_unit)
self.config.setDefaultValue("Camera", "near",
0.1 / meter_per_unit) # 10 cm
self.config.setDefaultValue("Camera", "far",
2000.0 / meter_per_unit) # 2 km
self.config.setDefaultValue("Camera", "fov", 60)
self.config.setDefaultValue("Camera", "move_speed", meter_per_unit)
self.config.setDefaultValue("Camera", "pan_speed", meter_per_unit)
self.config.setDefaultValue("Camera", "rotation_speed", 0.3)
except BaseException:
logger.info("Cannot open %s : %s" %
(GetClassName(self), project_filename))
return False
return True
def add_object(self, **object_data):
model = object_data.get('model')
if model:
object_data['name'] = self.generate_object_name(object_data.get('name', model.name))
objType = GetClassName(model)
logger.info("add %s : %s" % (objType, object_data['name']))
if model.mesh and model.mesh.has_bone():
obj_instance = SkeletonActor(**object_data)
else:
obj_instance = StaticActor(**object_data)
# regist
self.regist_object(obj_instance)
return obj_instance
return None
def exit(self):
# send a message to close ui
if self.uiCmdQueue:
self.uiCmdQueue.put(COMMAND.CLOSE_UI)
# write config
if self.valid:
self.config.setValue("Project", "recent",
self.project_manager.project_filename)
self.config.setValue("Project", "game_backend",
self.last_game_backend)
self.config.save() # save config
# save project
self.project_manager.close_project()
self.renderer.close()
self.resource_manager.close()
self.game_backend.quit()
logger.info("Process Stop : %s" % GetClassName(self)) # process stop
def __init__(self):
logger.info("Create " + GetClassName(self))
self.buffer = glGenFramebuffers(1)
self.max_draw_buffers = glGetInteger(GL_MAX_DRAW_BUFFERS)
self.color_textures = [
None,
] * self.max_draw_buffers
self.attach_count = 0
self.attachments = [
0,
] * self.max_draw_buffers
self.depth_texture = None
self.width = 0
self.height = 0
self.viewport_width = 0
self.viewport_height = 0
self.viewport_scale = 1.0
self.commands = []
self.target_face = GL_TEXTURE_CUBE_MAP_POSITIVE_X # cubemap face
self.target_layer = 0 # 3d texture layer
self.target_level = 0 # mipmap level
def delete(self):
logger.info("Delete %s : %s" % (GetClassName(self), self.name))
glDeleteTextures([self.buffer, ])
self.buffer = -1
def create_texture(self, **texture_data):
if self.buffer != -1:
self.delete()
self.attachment = False
self.image_mode = texture_data.get('image_mode')
self.internal_format = texture_data.get('internal_format')
self.texture_format = texture_data.get('texture_format')
self.sRGB = texture_data.get('sRGB', False)
self.clear_color = texture_data.get('clear_color')
self.multisample_count = 0
if self.internal_format is None and self.image_mode:
self.internal_format = get_internal_format(self.image_mode)
if self.texture_format is None and self.image_mode:
self.texture_format = get_texture_format(self.image_mode)
if self.image_mode is None and self.texture_format:
self.image_mode = get_image_mode(self.texture_format)
# Convert to sRGB
if self.sRGB:
if self.internal_format == GL_RGB:
self.internal_format = GL_SRGB8
elif self.internal_format == GL_RGBA:
self.internal_format = GL_SRGB8_ALPHA8
if GL_RGBA == self.internal_format:
self.internal_format = GL_RGBA8
if GL_RGB == self.internal_format:
self.internal_format = GL_RGB8
self.width = int(texture_data.get('width', 0))
self.height = int(texture_data.get('height', 0))
self.depth = int(max(1, texture_data.get('depth', 1)))
self.data_type = texture_data.get('data_type', GL_UNSIGNED_BYTE)
self.min_filter = texture_data.get('min_filter', GL_LINEAR_MIPMAP_LINEAR)
self.mag_filter = texture_data.get('mag_filter', GL_LINEAR) # GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR, GL_NEAREST
mipmap_filters = (GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_NEAREST,
GL_NEAREST_MIPMAP_LINEAR, GL_NEAREST_MIPMAP_NEAREST)
self.enable_mipmap = self.min_filter in mipmap_filters
if self.target == GL_TEXTURE_2D_MULTISAMPLE:
self.enable_mipmap = False
self.wrap = texture_data.get('wrap', self.default_wrap) # GL_REPEAT, GL_CLAMP
self.wrap_s = texture_data.get('wrap_s')
self.wrap_t = texture_data.get('wrap_t')
self.wrap_r = texture_data.get('wrap_r')
self.buffer = -1
self.sampler_handle = -1
# texture parameter overwrite
# self.sampler_handle = glGenSamplers(1)
# glSamplerParameteri(self.sampler_handle, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
# glBindSampler(0, self.sampler_handle)
logger.info("Create %s : %s %dx%dx%d %s mipmap(%s)." % (
GetClassName(self), self.name, self.width, self.height, self.depth, str(self.internal_format),
'Enable' if self.enable_mipmap else 'Disable'))
self.attribute = Attributes()
def initialize(self, cmdQueue, uiCmdQueue, cmdPipe, project_filename=""):
# process start
logger.info('Platform : %s' % platformModule.platform())
logger.info("Process Start : %s" % GetClassName(self))
self.cmdQueue = cmdQueue
self.uiCmdQueue = uiCmdQueue
self.cmdPipe = cmdPipe
self.config = Config("config.ini", log_level)
self.regist_command()
# ready to launch - send message to ui
if self.cmdPipe:
self.cmdPipe.SendAndRecv(COMMAND.UI_RUN, None, COMMAND.UI_RUN_OK,
None)
from PyEngine3D.UI import ViewportManager
from PyEngine3D.OpenGLContext import OpenGLContext
from PyEngine3D.ResourceManager import ResourceManager
from PyEngine3D.Render import Renderer, RenderTargetManager, FontManager, RenderOptionManager, EffectManager
from .SceneManager import SceneManager
from .ProjectManager import ProjectManager
self.opengl_context = OpenGLContext
self.viewport_manager = ViewportManager.instance()
self.render_option_manager = RenderOptionManager.instance()
self.rendertarget_manager = RenderTargetManager.instance()
self.resource_manager = ResourceManager.instance()
self.font_manager = FontManager.instance()
self.renderer = Renderer.instance()
self.scene_manager = SceneManager.instance()
self.effect_manager = EffectManager.instance()
self.project_manager = ProjectManager.instance()
# check invalid project
if not self.project_manager.initialize(self, project_filename):
self.valid = False
self.exit()
return False
# do First than other manager initalize. Because have to been opengl init from pygame.display.set_mode
width, height = self.project_manager.config.Screen.size
full_screen = self.project_manager.config.Screen.full_screen
if self.config.hasValue('Project', 'game_backend'):
self.last_game_backend = self.config.getValue(
'Project', 'game_backend')
self.last_game_backend = self.last_game_backend.lower()
def run_pygame():
from .GameBackend import GameBackend_pygame
self.game_backend = GameBackend_pygame.PyGame(self)
self.last_game_backend = GameBackNames.PYGAME
def run_pyglet():
from .GameBackend import GameBackend_pyglet
self.game_backend = GameBackend_pyglet.PyGlet(self)
self.last_game_backend = GameBackNames.PYGLET
# try 2 times.
for i in range(2):
if self.last_game_backend == GameBackNames.PYGAME:
try:
run_pygame()
break
except:
logger.error(
"The pygame library does not exist and execution failed. Run again with the pyglet."
)
self.last_game_backend = GameBackNames.PYGLET
else:
try:
run_pyglet()
break
except:
logger.error(
"The pyglet library does not exist and execution failed. Run again with the pygame."
)
self.last_game_backend = GameBackNames.PYGAME
else:
logger.error(
'PyGame or PyGlet is required. Please run "pip install -r requirements.txt" and try again.'
)
# send a message to close ui
if self.uiCmdQueue:
self.uiCmdQueue.put(COMMAND.CLOSE_UI)
return False
self.game_backend.create_window(width, height, full_screen)
self.opengl_context.initialize()
self.send_game_backend_list(self.game_backend_list)
index = self.game_backend_list.index(
self.last_game_backend
) if self.last_game_backend in self.game_backend_list else 0
self.send_current_game_backend_index(index)
if not self.game_backend.valid:
self.error('game_backend initializing failed')
# initialize managers
self.resource_manager.initialize(self,
self.project_manager.project_dir)
self.viewport_manager.initialize(self)
self.render_option_manager.initialize(self)
self.rendertarget_manager.initialize(self)
self.font_manager.initialize(self)
self.renderer.initialize(self)
self.effect_manager.initialize(self)
self.scene_manager.initialize(self)
self.viewport_manager.build_ui()
self.script_manager = None
# self.load_script_manager(reload=False)
# new scene
self.game_backend.reset_screen()
self.scene_manager.new_scene()
self.send(COMMAND.SORT_UI_ITEMS)
return True
def send_object_info(self, obj):
object_name = obj.name if hasattr(obj, 'name') else str(obj)
object_class_name = GetClassName(obj)
self.send(COMMAND.TRANS_OBJECT_INFO, (object_name, object_class_name))
def delete(self):
logger.info("Delete %s : %s" % (GetClassName(self), self.name))
glDeleteRenderbuffers(1, [
self.buffer,
])
self.buffer = -1
def __init__(self, shader_name, shader_code):
logger.info("Load " + GetClassName(self) + " : " + shader_name)
self.name = shader_name
self.shader_code = shader_code
self.include_files = []
self.attribute = Attributes()
