def bind_image(self, image_unit, level=0, access=GL_READ_WRITE): if self.buffer == -1: logger.warn("%s texture is invalid." % self.name) return # flag : GL_READ_WRITE, GL_WRITE_ONLY, GL_READ_ONLY glBindImageTexture(image_unit, self.buffer, level, GL_FALSE, 0, access, self.internal_format)
def get_temporary(self, rendertarget_name, reference_rendertarget=None, scale=1.0): temp_rendertarget = None if rendertarget_name in self.temp_rendertargets: temp_rendertarget = self.temp_rendertargets[rendertarget_name] elif reference_rendertarget: rendertarget_datas = reference_rendertarget.get_texture_info() rendertarget_datas['width'] = int(rendertarget_datas['width'] * scale) rendertarget_datas['height'] = int(rendertarget_datas['height'] * scale) rendertarget_type = rendertarget_datas['texture_type'] if type(rendertarget_type) is str: rendertarget_type = eval(rendertarget_type) temp_rendertarget = rendertarget_type(name=rendertarget_name, **rendertarget_datas) if temp_rendertarget: self.temp_rendertargets[rendertarget_name] = temp_rendertarget # send rendertarget info to GUI self.core_manager.send_render_target_info( temp_rendertarget.name) if temp_rendertarget is None: logger.warn("Failed to get temporary %s render target." % rendertarget_name) return temp_rendertarget
def bind_texture(self, wrap=None): if self.buffer == -1: logger.warn("%s texture is invalid." % self.name) return glBindTexture(self.target, self.buffer) if wrap is not None: self.texure_wrap(wrap)
def bind_uniform_data(self, uniform_name, uniform_data, **kwargs): uniform = self.linked_uniform_map.get(uniform_name) if uniform: uniform[0].bind_uniform(uniform_data, **kwargs) elif uniform_name not in self.show_message or self.show_message[ uniform_name]: self.show_message[uniform_name] = False logger.warn('%s material instance has no %s uniform variable.' % (self.name, uniform_name))
def set_uniform_data_from_string(self, uniform_name, str_uniform_data): uniform = self.linked_uniform_map.get(uniform_name) if uniform: uniform_buffer = uniform[0] if uniform_buffer: uniform_data = CreateUniformDataFromString( uniform_buffer.uniform_type, str_uniform_data) if uniform_data is not None: uniform[1] = uniform_data return True logger.warn( "%s material instance has no %s uniform variable. It may have been optimized by the compiler..)" % (self.name, uniform_name))
def check_validate(self): if self.program >= 0: glValidateProgram(self.program) validation = glGetProgramiv(self.program, GL_VALIDATE_STATUS) if validation == GL_TRUE: return True else: logger.warn("Validation failure (%s): %s" % (validation, glGetProgramInfoLog(self.program))) else: logger.warn("Validation failure : %s" % self.name) # always return True return True
def create_uniform_buffers(self, uniforms): # create uniform buffers from source code active_texture_index = 0 for uniform_type, uniform_name in uniforms: uniform_buffer = CreateUniformBuffer(self.program, uniform_type, uniform_name) if uniform_buffer is not None: # Important : set texture binding index if issubclass(uniform_buffer.__class__, UniformTextureBase): uniform_buffer.set_texture_index(active_texture_index) active_texture_index += 1 self.uniform_buffers[uniform_name] = uniform_buffer else: logger.warn( "%s material has no %s uniform variable. It may have been optimized by the compiler..)" % (self.name, uniform_name)) return True
def generate_mipmap(self): if self.enable_mipmap: glBindTexture(self.target, self.buffer) glGenerateMipmap(self.target) else: logger.warn('%s disable to generate mipmap.' % self.name)
def get_animation_data(self, skeleton_datas): precompute_parent_matrix = True precompute_inv_bind_matrix = True def get_empty_animation_node_data(animation_node_name, bone_name): return dict(name=animation_node_name, target=bone_name) def get_animation_node_data(animation_node_name, animation_node): return dict( name=animation_node_name, precompute_parent_matrix=precompute_parent_matrix, precompute_inv_bind_matrix=precompute_inv_bind_matrix, target=animation_node.target, times=animation_node.inputs, # transforms=[matrix for matrix in transforms], locations=[ extract_location( np.array(matrix, dtype=np.float32).reshape(4, 4)) for matrix in animation_node.outputs ], rotations=[ extract_quaternion( np.array(matrix, dtype=np.float32).reshape(4, 4)) for matrix in animation_node.outputs ], scales=[ np.array([1.0, 1.0, 1.0], dtype=np.float32) for matrix in animation_node.outputs ], interpoations=animation_node.interpolations, in_tangents=animation_node.in_tangents, out_tangents=animation_node.out_tangents) def precompute_animation(children_hierachy, bone_names, inv_bind_matrices, parent_matrix, frame=0): for child in children_hierachy: for child_anim in self.animations: if child_anim.target == child: # just Transpose child bones, no swap y-z. child_transform = np.array(child_anim.outputs[frame], dtype=np.float32).reshape( 4, 4).T if precompute_parent_matrix: child_transform = np.dot(child_transform, parent_matrix) if precompute_inv_bind_matrix: child_bone_index = bone_names.index( child_anim.target) child_inv_bind_matrix = inv_bind_matrices[ child_bone_index] child_anim.outputs[frame] = np.dot( child_inv_bind_matrix, child_transform) else: child_anim.outputs[frame] = child_transform # recursive precompute animation precompute_animation( children_hierachy[child_anim.target], bone_names, inv_bind_matrices, child_transform, frame) break # precompute_animation animation_datas = [] for skeleton_data in skeleton_datas: hierachy = skeleton_data['hierachy'] # tree data bone_names = skeleton_data['bone_names'] inv_bind_matrices = skeleton_data['inv_bind_matrices'] for animation in self.animations: # Currently, parsing only Transform Matrix. Future will parsing from location, rotation, scale. if animation.type != 'transform': continue # Find root bone and skeleton data if animation.target in hierachy: # precompute all animation frames for frame, transform in enumerate(animation.outputs): # only root bone adjust convert_matrix for swap Y-Z Axis transform = swap_up_axis_matrix( np.array(transform, dtype=np.float32).reshape(4, 4), True, False, self.up_axis) if precompute_inv_bind_matrix: bone_index = bone_names.index(animation.target) inv_bind_matrix = inv_bind_matrices[bone_index] animation.outputs[frame] = np.dot( inv_bind_matrix, transform) else: animation.outputs[frame] = transform # recursive precompute animation precompute_animation(hierachy[animation.target], bone_names, inv_bind_matrices, transform, frame) # generate animation data animation_data = [] # bone animation data list order by bone index animation_datas.append(animation_data) for bone_name in bone_names: for animation in self.animations: if animation.target == bone_name: animation_node_name = "%s_%s_%s" % ( self.name, skeleton_data['name'], bone_name) animation_data.append( get_animation_node_data(animation_node_name, animation)) break else: logger.warn('not found %s animation datas' % bone_name) animation_node_name = "%s_%s_%s" % ( self.name, skeleton_data['name'], bone_name) animation_data.append( get_empty_animation_node_data(animation_node_name, bone_name)) return animation_datas
def CreateUniformDataFromString(data_type, strValue=None): """ return converted data from string or default data """ if data_type == 'bool': return np.bool(strValue) if strValue else np.bool(False) elif data_type == 'float': # return float(strValue) if strValue else 0.0 return np.float32(strValue) if strValue else np.float32(0) elif data_type == 'int': # return int(strValue) if strValue else 0 return np.int32(strValue) if strValue else np.int32(0) elif data_type == 'uint': # return int(strValue) if strValue else 0 return np.uint32(strValue) if strValue else np.uint32(0) elif data_type in ('vec2', 'vec3', 'vec4', 'bvec2', 'bvec3', 'bvec4', 'ivec2', 'ivec3', 'ivec4', 'uvec2', 'uvec3', 'uvec4'): if data_type in ('bvec2', 'bvec3', 'bvec4', 'ivec2', 'ivec3', 'ivec4'): dtype = np.int32 elif data_type in ('uvec2', 'uvec3', 'uvec4'): dtype = np.uint32 else: dtype = np.float32 componentCount = int(data_type[-1]) if strValue is not None: vecValue = eval(strValue) if type(strValue) is str else strValue if len(vecValue) == componentCount: return np.array(vecValue, dtype=dtype) else: logger.error(ValueError("%s need %d float members." % (data_type, componentCount))) raise ValueError else: return np.array([1, ] * componentCount, dtype=dtype) elif data_type in ('mat2', 'mat3', 'mat4', 'dmat2', 'dmat3', 'dmat4'): if data_type in ('dmat2', 'dmat3', 'dmat4'): dtype = np.float32 else: dtype = np.double componentCount = int(data_type[-1]) if strValue is not None: vecValue = eval(strValue) if type(strValue) is str else strValue if len(vecValue) == componentCount: return np.array(vecValue, dtype=dtype) else: logger.error(ValueError("%s need %d float members." % (data_type, componentCount))) raise ValueError else: return np.eye(componentCount, dtype=dtype) elif data_type in ('sampler2D', 'image2D'): texture = CoreManager.instance().resource_manager.get_texture(strValue or 'common.flat_gray') return texture elif data_type == 'sampler2DMS': logger.warn('sampler2DMS need multisample texture.') return CoreManager.instance().resource_manager.get_texture(strValue or 'common.flat_gray') elif data_type == 'sampler2DArray': return CoreManager.instance().resource_manager.get_texture(strValue or 'common.default_2d_array') elif data_type in ('sampler3D', 'image3D'): return CoreManager.instance().resource_manager.get_texture(strValue or 'common.default_3d') elif data_type == 'samplerCube': texture = CoreManager.instance().resource_manager.get_texture(strValue or 'common.default_cube') return texture error_message = 'Cannot find uniform data of %s.' % data_type logger.error(error_message) raise ValueError(error_message) return None
def nothing(cmd_enum, value): logger.warn("Nothing to do for %s(%d)" % (str(cmd_enum), cmd_enum.value))