def set_camera(self, camera, target, up):
self.camera = camera
self.target = target
self.up = up
V = lookat(self.camera, self.target, up=self.up)
self.V = np.ascontiguousarray(V, np.float32)
def __init__(self,
width=512,
height=512,
fov=90,
device_idx=0,
use_fisheye=False):
"""
:param width: width of the renderer output
:param height: width of the renderer output
:param fov: vertical field of view for the renderer
:param device_idx: which GPU to run the renderer on
:param use_fisheye: use fisheye shader or not
"""
self.shaderProgram = None
self.fbo = None
self.color_tex_rgb, self.color_tex_normal, self.color_tex_semantics, self.color_tex_3d = None, None, None, None
self.depth_tex = None
self.VAOs = []
self.VBOs = []
self.textures = []
self.objects = []
self.visual_objects = []
self.texUnitUniform = None
self.width = width
self.height = height
self.faces = []
self.instances = []
self.fisheye = use_fisheye
# self.context = glcontext.Context()
# self.context.create_opengl_context((self.width, self.height))
available_devices = get_available_devices()
if device_idx < len(available_devices):
device = available_devices[device_idx]
print("using device {}".format(device))
else:
print(
"device index is larger than number of devices, falling back to use 0"
)
device = 0
self.device_idx = device_idx
self.device_minor = device
self.r = MeshRendererContext.MeshRendererContext(width, height, device)
self.r.init()
self.glstring = GL.glGetString(GL.GL_VERSION)
from OpenGL.GL import shaders
self.shaders = shaders
self.colors = colormap
self.lightcolor = [1, 1, 1]
print("fisheye", self.fisheye)
if self.fisheye:
vertexShader = self.shaders.compileShader(
"".join(
open(
os.path.join(os.path.dirname(mesh_renderer.__file__),
'shaders/fisheye_vert.shader')).readlines(
)).replace("FISHEYE_SIZE",
str(self.width / 2)),
GL.GL_VERTEX_SHADER)
fragmentShader = self.shaders.compileShader(
"".join(
open(
os.path.join(os.path.dirname(mesh_renderer.__file__),
'shaders/fisheye_frag.shader')).readlines(
)).replace("FISHEYE_SIZE",
str(self.width / 2)),
GL.GL_FRAGMENT_SHADER)
else:
vertexShader = self.shaders.compileShader(
"".join(
open(
os.path.join(os.path.dirname(mesh_renderer.__file__),
'shaders/vert.shader')).readlines()),
GL.GL_VERTEX_SHADER)
fragmentShader = self.shaders.compileShader(
"".join(
open(
os.path.join(os.path.dirname(mesh_renderer.__file__),
'shaders/frag.shader')).readlines()),
GL.GL_FRAGMENT_SHADER)
self.shaderProgram = self.shaders.compileProgram(
vertexShader, fragmentShader)
self.texUnitUniform = GL.glGetUniformLocation(self.shaderProgram,
'texUnit')
self.lightpos = [0, 0, 0]
self.setup_framebuffer()
self.fov = fov
self.camera = [1, 0, 0]
self.target = [0, 0, 0]
self.up = [0, 0, 1]
P = perspective(self.fov,
float(self.width) / float(self.height), 0.01, 100)
V = lookat(self.camera, self.target, up=self.up)
self.V = np.ascontiguousarray(V, np.float32)
self.P = np.ascontiguousarray(P, np.float32)
self.materials_mapping = {}
self.mesh_materials = []
def render(self):
"""
Render this instance
"""
if self.renderer is None:
return
# softbody: reload vertex position
if self.softbody:
# construct new vertex position into shape format
object_idx = self.object.VAO_ids[0]
vertices = p.getMeshData(self.pybullet_uuid)[1]
vertices_flattened = [
item for sublist in vertices for item in sublist
]
vertex_position = np.array(vertices_flattened).reshape(
(len(vertices_flattened) // 3, 3))
shape = self.renderer.shapes[object_idx]
n_indices = len(shape.mesh.indices)
np_indices = shape.mesh.numpy_indices().reshape((n_indices, 3))
shape_vertex_index = np_indices[:, 0]
shape_vertex = vertex_position[shape_vertex_index]
# update new vertex position in buffer data
new_data = self.renderer.vertex_data[object_idx]
new_data[:, 0:shape_vertex.shape[1]] = shape_vertex
new_data = new_data.astype(np.float32)
# transform and rotation already included in mesh data
self.pose_trans = np.eye(4)
self.pose_rot = np.eye(4)
# update buffer data into VBO
self.renderer.r.render_softbody_instance(
self.renderer.VAOs[object_idx], self.renderer.VBOs[object_idx],
new_data)
# print(self.renderer.camera, self.renderer.target, self.renderer.up)
v_array = [] # posZ, negZ
forward_dir = [
self.renderer.target[0] - self.renderer.camera[0],
self.renderer.target[1] - self.renderer.camera[1],
self.renderer.target[2] - self.renderer.camera[2]
]
target_array = [
[
self.renderer.camera[0] + forward_dir[1],
self.renderer.camera[1] - forward_dir[0],
self.renderer.camera[2]
],
[
self.renderer.camera[0] - forward_dir[1],
self.renderer.camera[1] + forward_dir[0],
self.renderer.camera[2]
],
# [self.renderer.camera[0], self.renderer.camera[1], self.renderer.camera[2] - 1], # dir = (0, 1, 0)
# [self.renderer.camera[0], self.renderer.camera[1], self.renderer.camera[2] + 1], # dir = (0, 1, 0)
[
self.renderer.camera[0], self.renderer.camera[1],
self.renderer.camera[2] - 1
], # dir = (1, 0, 0)
[
self.renderer.camera[0], self.renderer.camera[1],
self.renderer.camera[2] + 1
], # dir = (1, 0, 0)
[
self.renderer.camera[0] + forward_dir[0],
self.renderer.camera[1] + forward_dir[1],
self.renderer.camera[2]
],
[
self.renderer.camera[0] - forward_dir[0],
self.renderer.camera[1] - forward_dir[1],
self.renderer.camera[2]
]
]
up_array = [
[0, 0, 1],
[0, 0, 1],
# [-1, 0, 0], # dir = (0, 1, 0)
# [ 1, 0, 0], # dir = (0, 1, 0)
[forward_dir[0], forward_dir[1], 0], # dir = (1, 0, 0)
[-forward_dir[0], -forward_dir[1], 0], # dir = (1, 0, 0)
[0, 0, 1],
[0, 0, 1]
]
for i in range(6):
_camera = self.renderer.camera
_target = target_array[i]
_up = up_array[i]
v_array.append(
np.ascontiguousarray(lookat(_camera, _target, up=_up),
dtype=np.float32))
V_array = np.ascontiguousarray(np.array(v_array), dtype=np.float32)
if self.renderer.pano:
self.renderer.r.initvar_instance_cubemap(
self.renderer.shaderProgram, V_array, self.renderer.P,
self.pose_trans, self.pose_rot, self.renderer.lightpos,
self.renderer.lightcolor)
else:
self.renderer.r.initvar_instance(self.renderer.shaderProgram,
self.renderer.V, self.renderer.P,
self.pose_trans, self.pose_rot,
self.renderer.lightpos,
self.renderer.lightcolor)
for object_idx in self.object.VAO_ids:
self.renderer.r.init_material_instance(
self.renderer.shaderProgram,
float(self.class_id) / 255.0, self.renderer.materials_mapping[
self.renderer.mesh_materials[object_idx]].kd,
float(self.renderer.materials_mapping[
self.renderer.mesh_materials[object_idx]].is_texture()))
try:
texture_id = self.renderer.materials_mapping[
self.renderer.mesh_materials[object_idx]].texture_id
if texture_id is None:
texture_id = -1
if self.renderer.msaa:
buffer = self.renderer.fbo_ms
else:
buffer = self.renderer.fbo
self.renderer.r.draw_elements_instance(
self.renderer.materials_mapping[
self.renderer.mesh_materials[object_idx]].is_texture(),
texture_id, self.renderer.texUnitUniform,
self.renderer.VAOs[object_idx],
self.renderer.faces[object_idx].size,
self.renderer.faces[object_idx], buffer)
finally:
self.renderer.r.cglBindVertexArray(0)
self.renderer.r.cglUseProgram(0)
def __init__(self,
width=512,
height=512,
vertical_fov=90,
device_idx=0,
use_fisheye=False,
msaa=False):
"""
:param width: width of the renderer output
:param height: width of the renderer output
:param vertical_fov: vertical field of view for the renderer
:param device_idx: which GPU to run the renderer on
:param use_fisheye: use fisheye shader or not
"""
self.shaderProgram = None
self.fbo = None
self.color_tex_rgb, self.color_tex_normal, self.color_tex_semantics, self.color_tex_3d = None, None, None, None
self.depth_tex = None
self.VAOs = []
self.VBOs = []
self.textures = []
self.objects = []
self.visual_objects = []
self.vertex_data = []
self.shapes = []
self.texUnitUniform = None
self.width = width
self.height = height
self.faces = []
self.instances = []
self.fisheye = use_fisheye
# self.context = glcontext.Context()
# self.context.create_opengl_context((self.width, self.height))
available_devices = get_available_devices()
if device_idx < len(available_devices):
device = available_devices[device_idx]
logging.info("Using device {} for rendering".format(device))
else:
logging.info(
"Device index is larger than number of devices, falling back to use 0"
)
device = 0
self.device_idx = device_idx
self.device_minor = device
self.msaa = msaa
if platform.system() == 'Darwin':
from gibson2.core.render.mesh_renderer import GLFWRendererContext
self.r = GLFWRendererContext.GLFWRendererContext(width, height)
else:
self.r = MeshRendererContext.MeshRendererContext(
width, height, device)
self.r.init()
self.glstring = self.r.getstring_meshrenderer()
logging.debug('Rendering device and GL version')
logging.debug(self.glstring)
self.colors = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
self.lightcolor = [1, 1, 1]
logging.debug('Is using fisheye camera: {}'.format(self.fisheye))
if self.fisheye:
[self.shaderProgram,
self.texUnitUniform] = self.r.compile_shader_meshrenderer(
"".join(
open(
os.path.join(os.path.dirname(mesh_renderer.__file__),
'shaders/fisheye_vert.shader')).
readlines()).replace("FISHEYE_SIZE", str(self.width / 2)),
"".join(
open(
os.path.join(os.path.dirname(mesh_renderer.__file__),
'shaders/fisheye_frag.shader')).
readlines()).replace("FISHEYE_SIZE", str(self.width / 2)))
else:
[self.shaderProgram,
self.texUnitUniform] = self.r.compile_shader_meshrenderer(
"".join(
open(
os.path.join(os.path.dirname(mesh_renderer.__file__),
'shaders/vert.shader')).readlines()),
"".join(
open(
os.path.join(os.path.dirname(mesh_renderer.__file__),
'shaders/frag.shader')).readlines()))
self.lightpos = [0, 0, 0]
self.setup_framebuffer()
self.vertical_fov = vertical_fov
self.camera = [1, 0, 0]
self.target = [0, 0, 0]
self.up = [0, 0, 1]
P = perspective(self.vertical_fov,
float(self.width) / float(self.height), 0.01, 100)
V = lookat(self.camera, self.target, up=self.up)
self.V = np.ascontiguousarray(V, np.float32)
self.P = np.ascontiguousarray(P, np.float32)
self.materials_mapping = {}
self.mesh_materials = []
def __init__(self, width=512, height=512, device_idx=0, use_fisheye=False):
self.shaderProgram = None
self.fbo = None
self.color_tex_rgb, self.color_tex_normal, self.color_tex_semantics, self.color_tex_3d = None, None, None, None
self.depth_tex = None
self.VAOs = []
self.VBOs = []
self.textures = []
self.objects = []
self.visual_objects = []
self.texUnitUniform = None
self.width = width
self.height = height
self.faces = []
self.instances = []
self.fisheye = use_fisheye
# self.context = glcontext.Context()
# self.context.create_opengl_context((self.width, self.height))
available_devices = get_available_devices()
assert (device_idx < len(available_devices))
device = available_devices[device_idx]
self.r = CppMeshRenderer.CppMeshRenderer(width, height, device)
self.r.init()
self.glstring = GL.glGetString(GL.GL_VERSION)
from OpenGL.GL import shaders
self.shaders = shaders
self.colors = colormap
self.lightcolor = [1, 1, 1]
print("fisheye", self.fisheye)
if self.fisheye:
vertexShader = self.shaders.compileShader(
"".join(
open(
os.path.join(os.path.dirname(mesh_renderer.__file__),
'shaders/fisheye_vert.shader')).readlines(
)).replace("FISHEYE_SIZE",
str(self.width / 2)),
GL.GL_VERTEX_SHADER)
fragmentShader = self.shaders.compileShader(
"".join(
open(
os.path.join(os.path.dirname(mesh_renderer.__file__),
'shaders/fisheye_frag.shader')).readlines(
)).replace("FISHEYE_SIZE",
str(self.width / 2)),
GL.GL_FRAGMENT_SHADER)
else:
vertexShader = self.shaders.compileShader(
"".join(
open(
os.path.join(os.path.dirname(mesh_renderer.__file__),
'shaders/vert.shader')).readlines()),
GL.GL_VERTEX_SHADER)
fragmentShader = self.shaders.compileShader(
"".join(
open(
os.path.join(os.path.dirname(mesh_renderer.__file__),
'shaders/frag.shader')).readlines()),
GL.GL_FRAGMENT_SHADER)
self.shaderProgram = self.shaders.compileProgram(
vertexShader, fragmentShader)
self.texUnitUniform = GL.glGetUniformLocation(self.shaderProgram,
'texUnit')
self.lightpos = [0, 0, 0]
self.setup_framebuffer()
self.fov = 20
self.camera = [1, 0, 0]
self.target = [0, 0, 0]
self.up = [0, 0, 1]
P = perspective(self.fov,
float(self.width) / float(self.height), 0.01, 100)
V = lookat(self.camera, self.target, up=self.up)
self.V = np.ascontiguousarray(V, np.float32)
self.P = np.ascontiguousarray(P, np.float32)
self.materials_mapping = {}
self.mesh_materials = []
