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))
