# -*- coding: utf-8 -*-
# Max-Planck-Gesellschaft zur Förderung der Wissenschaften e.V. (MPG) is
# holder of all proprietary rights on this computer program.
# You can only use this computer program if you have closed
# a license agreement with MPG or you get the right to use the computer
# program from someone who is authorized to grant you that right.
# Any use of the computer program without a valid license is prohibited and
# liable to prosecution.
#
# Copyright©2019 Max-Planck-Gesellschaft zur Förderung
# der Wissenschaften e.V. (MPG). acting on behalf of its Max Planck Institute
# for Intelligent Systems. All rights reserved.
#
# Contact: ps-license@tuebingen.mpg.de
import numpy as np
import random
from .framework import *
from .cam_render import CamRender
class PRTRender(CamRender):
def __init__(self,
width=1600,
height=1200,
name='PRT Renderer',
uv_mode=False,
ms_rate=1,
egl=False):
program_files = ['prt.vs', 'prt.fs'
] if not uv_mode else ['prt_uv.vs', 'prt_uv.fs']
CamRender.__init__(self,
width,
height,
name,
program_files=program_files,
color_size=8,
ms_rate=ms_rate,
egl=egl)
# WARNING: this differs from vertex_buffer and vertex_data in Render
self.vert_buffer = {}
self.vert_data = {}
self.vert_label_buffer = {}
self.vert_label_data = {}
self.norm_buffer = {}
self.norm_data = {}
self.tan_buffer = {}
self.tan_data = {}
self.btan_buffer = {}
self.btan_data = {}
self.prt1_buffer = {}
self.prt1_data = {}
self.prt2_buffer = {}
self.prt2_data = {}
self.prt3_buffer = {}
self.prt3_data = {}
self.uv_buffer = {}
self.uv_data = {}
self.render_texture_mat = {}
self.vertex_dim = {}
self.n_vertices = {}
self.label_dim = {}
self.norm_mat_unif = glGetUniformLocation(self.program, 'NormMat')
self.normalize_matrix = np.eye(4)
self.shcoeff_unif = glGetUniformLocation(self.program, 'SHCoeffs')
self.shcoeffs = np.zeros((9, 3))
self.shcoeffs[0, :] = 1.0
#self.shcoeffs[1:,:] = np.random.rand(8,3)
self.hasAlbedoUnif = glGetUniformLocation(self.program, 'hasAlbedoMap')
self.hasNormalUnif = glGetUniformLocation(self.program, 'hasNormalMap')
self.analyticUnif = glGetUniformLocation(self.program, 'analytic')
self.analytic = False
self.rot_mat_unif = glGetUniformLocation(self.program, 'RotMat')
self.rot_matrix = np.eye(3)
def set_texture(self, mat_name, smplr_name, texture):
# texture_image: H x W x 3
width = texture.shape[1]
height = texture.shape[0]
texture = np.flip(texture, 0)
img_data = np.fromstring(texture.tostring(), np.uint8)
if mat_name not in self.render_texture_mat:
self.render_texture_mat[mat_name] = {}
if smplr_name in self.render_texture_mat[mat_name].keys():
glDeleteTextures([self.render_texture_mat[mat_name][smplr_name]])
del self.render_texture_mat[mat_name][smplr_name]
self.render_texture_mat[mat_name][smplr_name] = glGenTextures(1)
glActiveTexture(GL_TEXTURE0)
glPixelStorei(GL_UNPACK_ALIGNMENT, 1)
glBindTexture(GL_TEXTURE_2D,
self.render_texture_mat[mat_name][smplr_name])
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB,
GL_UNSIGNED_BYTE, img_data)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 3)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_LINEAR_MIPMAP_LINEAR)
glGenerateMipmap(GL_TEXTURE_2D)
def set_albedo(self, texture_image, mat_name='all'):
self.set_texture(mat_name, 'AlbedoMap', texture_image)
def set_normal_map(self, texture_image, mat_name='all'):
self.set_texture(mat_name, 'NormalMap', texture_image)
def set_mesh(self,
vertices,
faces,
norms,
faces_nml,
uvs,
faces_uvs,
prt,
faces_prt,
tans,
bitans,
verts_label=None,
mat_name='all'):
self.vert_data[mat_name] = vertices[faces.reshape([-1])]
self.vert_label_data[mat_name] = verts_label[faces.reshape([-1])]
self.n_vertices[mat_name] = self.vert_data[mat_name].shape[0]
self.vertex_dim[mat_name] = self.vert_data[mat_name].shape[1]
self.label_dim[mat_name] = self.vert_label_data[mat_name].shape[1]
if mat_name not in self.vert_buffer.keys():
self.vert_buffer[mat_name] = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.vert_buffer[mat_name])
glBufferData(GL_ARRAY_BUFFER, self.vert_data[mat_name], GL_STATIC_DRAW)
if mat_name not in self.vert_label_buffer.keys():
self.vert_label_buffer[mat_name] = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.vert_label_buffer[mat_name])
glBufferData(GL_ARRAY_BUFFER, self.vert_label_data[mat_name],
GL_STATIC_DRAW)
self.uv_data[mat_name] = uvs[faces_uvs.reshape([-1])]
if mat_name not in self.uv_buffer.keys():
self.uv_buffer[mat_name] = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.uv_buffer[mat_name])
glBufferData(GL_ARRAY_BUFFER, self.uv_data[mat_name], GL_STATIC_DRAW)
self.norm_data[mat_name] = norms[faces_nml.reshape([-1])]
if mat_name not in self.norm_buffer.keys():
self.norm_buffer[mat_name] = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.norm_buffer[mat_name])
glBufferData(GL_ARRAY_BUFFER, self.norm_data[mat_name], GL_STATIC_DRAW)
self.tan_data[mat_name] = tans[faces_nml.reshape([-1])]
if mat_name not in self.tan_buffer.keys():
self.tan_buffer[mat_name] = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.tan_buffer[mat_name])
glBufferData(GL_ARRAY_BUFFER, self.tan_data[mat_name], GL_STATIC_DRAW)
self.btan_data[mat_name] = bitans[faces_nml.reshape([-1])]
if mat_name not in self.btan_buffer.keys():
self.btan_buffer[mat_name] = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.btan_buffer[mat_name])
glBufferData(GL_ARRAY_BUFFER, self.btan_data[mat_name], GL_STATIC_DRAW)
self.prt1_data[mat_name] = prt[faces_prt.reshape([-1])][:, :3]
self.prt2_data[mat_name] = prt[faces_prt.reshape([-1])][:, 3:6]
self.prt3_data[mat_name] = prt[faces_prt.reshape([-1])][:, 6:]
if mat_name not in self.prt1_buffer.keys():
self.prt1_buffer[mat_name] = glGenBuffers(1)
if mat_name not in self.prt2_buffer.keys():
self.prt2_buffer[mat_name] = glGenBuffers(1)
if mat_name not in self.prt3_buffer.keys():
self.prt3_buffer[mat_name] = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.prt1_buffer[mat_name])
glBufferData(GL_ARRAY_BUFFER, self.prt1_data[mat_name], GL_STATIC_DRAW)
glBindBuffer(GL_ARRAY_BUFFER, self.prt2_buffer[mat_name])
glBufferData(GL_ARRAY_BUFFER, self.prt2_data[mat_name], GL_STATIC_DRAW)
glBindBuffer(GL_ARRAY_BUFFER, self.prt3_buffer[mat_name])
glBufferData(GL_ARRAY_BUFFER, self.prt3_data[mat_name], GL_STATIC_DRAW)
glBindBuffer(GL_ARRAY_BUFFER, 0)
def set_mesh_mtl(self,
vertices,
faces,
norms,
faces_nml,
uvs,
faces_uvs,
tans,
bitans,
prt,
verts_label=None):
for key in faces:
self.vert_data[key] = vertices[faces[key].reshape([-1])]
self.vert_label_data[key] = verts_label[faces[key].reshape([-1])]
self.n_vertices[key] = self.vert_data[key].shape[0]
self.vertex_dim[key] = self.vert_data[key].shape[1]
self.label_dim[key] = self.vert_label_data[key].shape[1]
if key not in self.vert_buffer.keys():
self.vert_buffer[key] = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.vert_buffer[key])
glBufferData(GL_ARRAY_BUFFER, self.vert_data[key], GL_STATIC_DRAW)
if key not in self.vert_label_buffer.keys():
self.vert_label_buffer[key] = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.vert_label_buffer[key])
glBufferData(GL_ARRAY_BUFFER, self.vert_label_data[key],
GL_STATIC_DRAW)
self.uv_data[key] = uvs[faces_uvs[key].reshape([-1])]
if key not in self.uv_buffer.keys():
self.uv_buffer[key] = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.uv_buffer[key])
glBufferData(GL_ARRAY_BUFFER, self.uv_data[key], GL_STATIC_DRAW)
self.norm_data[key] = norms[faces_nml[key].reshape([-1])]
if key not in self.norm_buffer.keys():
self.norm_buffer[key] = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.norm_buffer[key])
glBufferData(GL_ARRAY_BUFFER, self.norm_data[key], GL_STATIC_DRAW)
self.tan_data[key] = tans[faces_nml[key].reshape([-1])]
if key not in self.tan_buffer.keys():
self.tan_buffer[key] = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.tan_buffer[key])
glBufferData(GL_ARRAY_BUFFER, self.tan_data[key], GL_STATIC_DRAW)
self.btan_data[key] = bitans[faces_nml[key].reshape([-1])]
if key not in self.btan_buffer.keys():
self.btan_buffer[key] = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.btan_buffer[key])
glBufferData(GL_ARRAY_BUFFER, self.btan_data[key], GL_STATIC_DRAW)
self.prt1_data[key] = prt[faces[key].reshape([-1])][:, :3]
self.prt2_data[key] = prt[faces[key].reshape([-1])][:, 3:6]
self.prt3_data[key] = prt[faces[key].reshape([-1])][:, 6:]
if key not in self.prt1_buffer.keys():
self.prt1_buffer[key] = glGenBuffers(1)
if key not in self.prt2_buffer.keys():
self.prt2_buffer[key] = glGenBuffers(1)
if key not in self.prt3_buffer.keys():
self.prt3_buffer[key] = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, self.prt1_buffer[key])
glBufferData(GL_ARRAY_BUFFER, self.prt1_data[key], GL_STATIC_DRAW)
glBindBuffer(GL_ARRAY_BUFFER, self.prt2_buffer[key])
glBufferData(GL_ARRAY_BUFFER, self.prt2_data[key], GL_STATIC_DRAW)
glBindBuffer(GL_ARRAY_BUFFER, self.prt3_buffer[key])
glBufferData(GL_ARRAY_BUFFER, self.prt3_data[key], GL_STATIC_DRAW)
glBindBuffer(GL_ARRAY_BUFFER, 0)
def cleanup(self):
glBindBuffer(GL_ARRAY_BUFFER, 0)
for key in self.vert_data:
glDeleteBuffers(1, [self.vert_buffer[key]])
glDeleteBuffers(1, [self.norm_buffer[key]])
glDeleteBuffers(1, [self.uv_buffer[key]])
glDeleteBuffers(1, [self.vert_label_buffer[key]])
glDeleteBuffers(1, [self.tan_buffer[key]])
glDeleteBuffers(1, [self.btan_buffer[key]])
glDeleteBuffers(1, [self.prt1_buffer[key]])
glDeleteBuffers(1, [self.prt2_buffer[key]])
glDeleteBuffers(1, [self.prt3_buffer[key]])
glDeleteBuffers(1, [])
for smplr in self.render_texture_mat[key]:
glDeleteTextures([self.render_texture_mat[key][smplr]])
self.vert_buffer = {}
self.vert_data = {}
self.vert_label_buffer = {}
self.vert_label_data = {}
self.norm_buffer = {}
self.norm_data = {}
self.tan_buffer = {}
self.tan_data = {}
self.btan_buffer = {}
self.btan_data = {}
self.prt1_buffer = {}
self.prt1_data = {}
self.prt2_buffer = {}
self.prt2_data = {}
self.prt3_buffer = {}
self.prt3_data = {}
self.uv_buffer = {}
self.uv_data = {}
self.render_texture_mat = {}
self.vertex_dim = {}
self.n_vertices = {}
self.label_dim = {}
def randomize_sh(self):
self.shcoeffs[0, :] = 0.8
self.shcoeffs[1:, :] = 1.0 * np.random.rand(8, 3)
def set_sh(self, sh):
self.shcoeffs = sh
def set_norm_mat(self, scale, center):
N = np.eye(4)
N[:3, :3] = scale * np.eye(3)
N[:3, 3] = -scale * center
self.normalize_matrix = N
def draw(self):
self.draw_init()
glDisable(GL_BLEND)
#glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
glEnable(GL_MULTISAMPLE)
glUseProgram(self.program)
glUniformMatrix4fv(self.norm_mat_unif, 1, GL_FALSE,
self.normalize_matrix.transpose())
glUniformMatrix4fv(self.model_mat_unif, 1, GL_FALSE,
self.model_view_matrix.transpose())
glUniformMatrix4fv(self.persp_mat_unif, 1, GL_FALSE,
self.projection_matrix.transpose())
if 'AlbedoMap' in self.render_texture_mat['all']:
glUniform1ui(self.hasAlbedoUnif, GLuint(1))
else:
glUniform1ui(self.hasAlbedoUnif, GLuint(0))
if 'NormalMap' in self.render_texture_mat['all']:
glUniform1ui(self.hasNormalUnif, GLuint(1))
else:
glUniform1ui(self.hasNormalUnif, GLuint(0))
glUniform1ui(self.analyticUnif,
GLuint(1) if self.analytic else GLuint(0))
glUniform3fv(self.shcoeff_unif, 9, self.shcoeffs)
glUniformMatrix3fv(self.rot_mat_unif, 1, GL_FALSE,
self.rot_matrix.transpose())
for mat in self.vert_buffer:
# Handle vertex buffer
glBindBuffer(GL_ARRAY_BUFFER, self.vert_buffer[mat])
glEnableVertexAttribArray(0)
glVertexAttribPointer(0, self.vertex_dim[mat], GL_DOUBLE, GL_FALSE,
0, None)
# Handle normal buffer
glBindBuffer(GL_ARRAY_BUFFER, self.norm_buffer[mat])
glEnableVertexAttribArray(1)
glVertexAttribPointer(1, 3, GL_DOUBLE, GL_FALSE, 0, None)
# Handle uv buffer
glBindBuffer(GL_ARRAY_BUFFER, self.uv_buffer[mat])
glEnableVertexAttribArray(2)
glVertexAttribPointer(2, 2, GL_DOUBLE, GL_FALSE, 0, None)
# Handle tan buffer
glBindBuffer(GL_ARRAY_BUFFER, self.tan_buffer[mat])
glEnableVertexAttribArray(3)
glVertexAttribPointer(3, 3, GL_DOUBLE, GL_FALSE, 0, None)
# Handle btan buffer
glBindBuffer(GL_ARRAY_BUFFER, self.btan_buffer[mat])
glEnableVertexAttribArray(4)
glVertexAttribPointer(4, 3, GL_DOUBLE, GL_FALSE, 0, None)
# Handle PTR buffer
glBindBuffer(GL_ARRAY_BUFFER, self.prt1_buffer[mat])
glEnableVertexAttribArray(5)
glVertexAttribPointer(5, 3, GL_DOUBLE, GL_FALSE, 0, None)
glBindBuffer(GL_ARRAY_BUFFER, self.prt2_buffer[mat])
glEnableVertexAttribArray(6)
glVertexAttribPointer(6, 3, GL_DOUBLE, GL_FALSE, 0, None)
glBindBuffer(GL_ARRAY_BUFFER, self.prt3_buffer[mat])
glEnableVertexAttribArray(7)
glVertexAttribPointer(7, 3, GL_DOUBLE, GL_FALSE, 0, None)
# Handle vertex label buffer
glBindBuffer(GL_ARRAY_BUFFER, self.vert_label_buffer[mat])
glEnableVertexAttribArray(8)
glVertexAttribPointer(8, self.label_dim[mat], GL_DOUBLE, GL_FALSE,
0, None)
for i, smplr in enumerate(self.render_texture_mat[mat]):
glActiveTexture(GL_TEXTURE0 + i)
glBindTexture(GL_TEXTURE_2D,
self.render_texture_mat[mat][smplr])
glUniform1i(glGetUniformLocation(self.program, smplr), i)
glDrawArrays(GL_TRIANGLES, 0, self.n_vertices[mat])
glDisableVertexAttribArray(8)
glDisableVertexAttribArray(7)
glDisableVertexAttribArray(6)
glDisableVertexAttribArray(5)
glDisableVertexAttribArray(4)
glDisableVertexAttribArray(3)
glDisableVertexAttribArray(2)
glDisableVertexAttribArray(1)
glDisableVertexAttribArray(0)
glBindBuffer(GL_ARRAY_BUFFER, 0)
glUseProgram(0)
glDisable(GL_BLEND)
glDisable(GL_MULTISAMPLE)
self.draw_end()