def render_frame(self):
if self.hmd:
self.render_controller_axes()
self.render_stereo_targets()
self.render_companion_window()
left_eye_texture = openvr.Texture_t(
handle=self.left_eye_desc.resolve_texture_id,
eType=openvr.TextureType_OpenGL,
eColorSpace=openvr.ColorSpace_Gamma,
)
right_eye_texture = openvr.Texture_t(
handle=self.right_eye_desc.resolve_texture_id,
eType=openvr.TextureType_OpenGL,
eColorSpace=openvr.ColorSpace_Gamma,
)
try:
openvr.VRCompositor().submit(openvr.Eye_Left, left_eye_texture)
openvr.VRCompositor().submit(openvr.Eye_Right,
right_eye_texture)
except openvr.error_code.CompositorError_DoNotHaveFocus:
pass # First frame fails because waitGetPoses has not been called yet
if (self.tracked_controller_count !=
self.tracked_controller_count_previous
or self.valid_pose_count != self.valid_pose_count_previous):
self.valid_pose_count_previous = self.valid_pose_count
self.tracked_controller_count_previous = self.tracked_controller_count
print(
f'PoseCount:{self.valid_pose_count}({self.pose_classes}) Controllers:{self.tracked_controller_count}'
)
self.update_hmd_pose()
def v_initPost():
''' init vr after MuJoCo init '''
global hmd
for n in range(2):
znear, zfar = 0.05, 50.0
left, right, top, bottom = hmd.system.getProjectionRaw(n)
ctx.scn.camera[n].frustum_bottom = -bottom * znear
ctx.scn.camera[n].frustum_top = -top * znear
ctx.scn.camera[n].frustum_center = 0.5 * (left + right) * znear
ctx.scn.camera[n].frustum_near = znear
ctx.scn.camera[n].frustum_far = zfar
gl.glActiveTexture(gl.GL_TEXTURE2)
hmd.idtex = gl.glGenTextures(1)
gl.glBindTexture(gl.GL_TEXTURE_2D, hmd.idtex)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
gl.GL_NEAREST)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S,
gl.GL_CLAMP_TO_EDGE)
gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T,
gl.GL_CLAMP_TO_EDGE)
gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA8, 2 * hmd.width,
hmd.height, 0, gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, None)
hmd.poses = (openvr.TrackedDevicePose_t *
openvr.k_unMaxTrackedDeviceCount)()
hmd.boundLeft = openvr.VRTextureBounds_t(0., 0., 0.5, 1.)
hmd.boundRight = openvr.VRTextureBounds_t(0.5, 0., 1., 1.)
hmd.vTex = openvr.Texture_t(hmd.idtex, openvr.TextureType_OpenGL,
openvr.ColorSpace_Gamma)
def submit_texture(self, eye, texture):
"""
Submit to OpenVR the rendered frame for the given eye.
Note that this method must be called from within the Draw context in order to have the texture bound.
"""
try:
# Retrieve the texture OpenGL binding
texture_context = texture.prepare_now(
0, self.base.win.gsg.prepared_objects, self.base.win.gsg)
handle = texture_context.get_native_id()
if handle != 0:
ovr_texture = openvr.Texture_t()
ovr_texture.handle = texture_context.get_native_id()
ovr_texture.eType = openvr.TextureType_OpenGL
ovr_texture.eColorSpace = self.color_space
self.compositor.submit(eye, ovr_texture)
except Exception as e:
if hasattr(self, 'on_texture_submit_error'):
if not self.on_texture_submit_error_notified:
print(
"WARNING: 'on_texture_submit_error()' is deprecated and will be removed in a future release"
)
self.on_texture_submit_error_notified = True
self.on_texture_submit_error(e)
else:
if self.submit_error_handler is not None:
self.submit_error_handler(e)
else:
# by default, just reraise the exception
raise e
def _init_framebuffer(self):
self._fbo = glGenFramebuffers(1)
glBindFramebuffer(GL_FRAMEBUFFER, self._fbo)
self._dbo = glGenRenderbuffers(1)
glBindRenderbuffer(GL_RENDERBUFFER, self._dbo)
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, self._width, self._height)
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, self._dbo)
self._view_tex = int(glGenTextures(1))
glBindTexture(GL_TEXTURE_2D, self._view_tex)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, self._width, self._height, 0, GL_RGBA, GL_UNSIGNED_BYTE, None)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
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_MAX_LEVEL, 0)
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self._view_tex, 0)
glDrawBuffers(1, GL_COLOR_ATTACHMENT0)
glBindFramebuffer(GL_FRAMEBUFFER, 0)
status = glCheckFramebufferStatus(GL_FRAMEBUFFER)
if status != GL_FRAMEBUFFER_COMPLETE:
glBindFramebuffer(GL_FRAMEBUFFER, 0)
raise Exception("Incomplete framebuffer")
glBindTexture(GL_TEXTURE_2D, self._view_tex)
self._overlay_tex = openvr.Texture_t()
self._overlay_tex.handle = self._view_tex
self._overlay_tex.eType = openvr.TextureType_OpenGL
self._overlay_tex.eColorSpace = openvr.ColorSpace_Auto
def init_gl(self):
"allocate OpenGL resources"
self.vr_system = openvr.init(openvr.VRApplication_Scene)
w, h = self.vr_system.getRecommendedRenderTargetSize()
self.left_fb = OpenVrFramebuffer(w, h, multisample=self.multisample)
self.right_fb = OpenVrFramebuffer(w, h, multisample=self.multisample)
self.compositor = openvr.VRCompositor()
if self.compositor is None:
raise Exception("Unable to create compositor")
self.left_fb.init_gl()
self.right_fb.init_gl()
# Compute projection matrix
zNear = 0.2
zFar = 500.0
self.projection_left = numpy.asarray(
matrixForOpenVrMatrix(
self.vr_system.getProjectionMatrix(openvr.Eye_Left, zNear,
zFar)))
self.projection_right = numpy.asarray(
matrixForOpenVrMatrix(
self.vr_system.getProjectionMatrix(openvr.Eye_Right, zNear,
zFar)))
self.view_left = matrixForOpenVrMatrix(
self.vr_system.getEyeToHeadTransform(
openvr.Eye_Left)).I # head_X_eye in Kane notation
self.view_right = matrixForOpenVrMatrix(
self.vr_system.getEyeToHeadTransform(
openvr.Eye_Right)).I # head_X_eye in Kane notation
self.zedTextureID_L = glGenTextures(1)
self.zedTextureID_R = glGenTextures(1)
self.texture_t_left = openvr.Texture_t()
self.texture_t_left.eType = openvr.TextureType_OpenGL
self.texture_t_left.eColorSpace = openvr.ColorSpace_Gamma
self.texture_t_right = openvr.Texture_t()
self.texture_t_right.eType = openvr.TextureType_OpenGL
self.texture_t_right.eColorSpace = openvr.ColorSpace_Gamma
# Create left ZED image texture
self.zedTextureID_L = glGenTextures(1)
# Create right ZED image texture
self.zedTextureID_R = glGenTextures(1)
def submit_texture(self, eye, texture):
texture_context = texture.prepare_now(0, base.win.gsg.prepared_objects,
base.win.gsg)
handle = texture_context.get_native_id()
if handle != 0:
ovr_texture = openvr.Texture_t()
ovr_texture.handle = texture_context.get_native_id()
ovr_texture.eType = openvr.TextureType_OpenGL
ovr_texture.eColorSpace = openvr.ColorSpace_Gamma
self.compositor.submit(eye, ovr_texture)
def init_gl(self):
# Set up framebuffer and render textures
self.fb = glGenFramebuffers(1)
glBindFramebuffer(GL_FRAMEBUFFER, self.fb)
self.depth_buffer = glGenRenderbuffers(1)
glBindRenderbuffer(GL_RENDERBUFFER, self.depth_buffer)
if self.multisample > 0:
glRenderbufferStorageMultisample(GL_RENDERBUFFER, self.multisample, GL_DEPTH24_STENCIL8, self.width, self.height)
else:
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, self.width, self.height)
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, self.depth_buffer)
self.texture_id = glGenTextures(1)
if self.multisample > 0:
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, self.texture_id)
glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, self.multisample, GL_RGBA8, self.width, self.height, True)
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, self.texture_id, 0)
else:
glBindTexture(GL_TEXTURE_2D, self.texture_id)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, self.width, self.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, None)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
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_MAX_LEVEL, 0)
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self.texture_id, 0)
status = glCheckFramebufferStatus(GL_FRAMEBUFFER)
if status != GL_FRAMEBUFFER_COMPLETE:
glBindFramebuffer(GL_FRAMEBUFFER, 0)
raise Exception("Incomplete framebuffer")
# Resolver framebuffer in case of multisample antialiasing
if self.multisample > 0:
self.resolve_fb = glGenFramebuffers(1)
glBindFramebuffer(GL_FRAMEBUFFER, self.resolve_fb)
self.resolve_texture_id = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, self.resolve_texture_id)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
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_MAX_LEVEL, 0)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, self.width, self.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, None)
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self.resolve_texture_id, 0)
status = glCheckFramebufferStatus(GL_FRAMEBUFFER)
if status != GL_FRAMEBUFFER_COMPLETE:
glBindFramebuffer(GL_FRAMEBUFFER, 0)
raise Exception("Incomplete framebuffer")
glBindFramebuffer(GL_FRAMEBUFFER, 0)
# OpenVR texture data
self.texture = openvr.Texture_t()
if self.multisample > 0:
self.texture.handle = self.resolve_texture_id #as_ctypes(self.resolve_texture_id)
else:
self.texture.handle = self.texture_id #as_ctypes(self.texture_id)
self.texture.eType = openvr.TextureType_OpenGL
self.texture.eColorSpace = openvr.ColorSpace_Gamma
def run(self):
self.vr_system = openvr.init(openvr.VRApplication_Scene)
self.vr_compositor = openvr.VRCompositor()
poses_t = openvr.TrackedDevicePose_t * openvr.k_unMaxTrackedDeviceCount
self.poses = poses_t()
self.w, self.h = self.vr_system.getRecommendedRenderTargetSize()
SDL_Init(SDL_INIT_VIDEO)
self.window = SDL_CreateWindow(b"test", SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, 100, 100,
SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL)
self.context = SDL_GL_CreateContext(self.window)
SDL_GL_MakeCurrent(self.window, self.context)
self.depth_buffer = glGenRenderbuffers(1)
self.frame_buffers = glGenFramebuffers(2)
self.texture_ids = glGenTextures(2)
self.textures = [None] * 2
self.eyes = [openvr.Eye_Left, openvr.Eye_Right]
self.camToHead = [None] * 2
self.proj_raw = [None] * 2
self.nearZ = 0.01
self.farZ = 500
for eye in range(2):
glBindFramebuffer(GL_FRAMEBUFFER, self.frame_buffers[eye])
glBindRenderbuffer(GL_RENDERBUFFER, self.depth_buffer)
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, self.w,
self.h)
glFramebufferRenderbuffer(GL_FRAMEBUFFER,
GL_DEPTH_STENCIL_ATTACHMENT,
GL_RENDERBUFFER, self.depth_buffer)
glBindTexture(GL_TEXTURE_2D, self.texture_ids[eye])
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, self.w, self.h, 0,
GL_RGBA, GL_UNSIGNED_BYTE, None)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, self.texture_ids[eye], 0)
texture = openvr.Texture_t()
texture.handle = int(self.texture_ids[eye])
texture.eType = openvr.TextureType_OpenGL
texture.eColorSpace = openvr.ColorSpace_Gamma
self.textures[eye] = texture
self.proj_raw[eye] = self.vr_system.getProjectionRaw(
self.eyes[eye]
) #void GetProjectionRaw( Hmd_Eye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom )
eyehead = self.vr_system.getEyeToHeadTransform(
self.eyes[eye]) #[0][3] is eye-center distance
self.camToHead[eye] = numpy.array(
[[eyehead.m[j][i] for i in range(4)] for j in range(3)])
self.setupcameras()
self.setupscene()
while self._running:
self.draw()
def __init__(self):
"One time initialization"
# Glut
glutInit()
glutInitDisplayMode(GLUT_RGBA)
# Create a regular desktop window, just so we can have an OpenGL context to play with
glutInitWindowSize(400, 400)
glutInitWindowPosition(50, 50)
self.win = glutCreateWindow(b"Pink world")
# Set up callback methods for use during the GLUT main loop
glutDisplayFunc(self.display)
glutIdleFunc(self.display)
glutReshapeFunc(self.resize_gl)
glutKeyboardFunc(self.key_press)
# OpenVR
self.vr_system = openvr.init(openvr.VRApplication_Scene)
self.vr_width, self.vr_height = self.vr_system.getRecommendedRenderTargetSize(
)
self.compositor = openvr.VRCompositor()
if self.compositor is None:
raise Exception("Unable to create compositor")
poses_t = openvr.TrackedDevicePose_t * openvr.k_unMaxTrackedDeviceCount
self.poses = poses_t()
#
# Set up framebuffer and render textures
self.fb = glGenFramebuffers(1)
glBindFramebuffer(GL_FRAMEBUFFER, self.fb)
self.depth_buffer = glGenRenderbuffers(1)
glBindRenderbuffer(GL_RENDERBUFFER, self.depth_buffer)
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8,
self.vr_width, self.vr_height)
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
GL_RENDERBUFFER, self.depth_buffer)
self.texture_id = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, self.texture_id)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, self.vr_width, self.vr_height,
0, GL_RGBA, GL_UNSIGNED_BYTE, None)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
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_MAX_LEVEL, 0)
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, self.texture_id, 0)
status = glCheckFramebufferStatus(GL_FRAMEBUFFER)
if status != GL_FRAMEBUFFER_COMPLETE:
glBindFramebuffer(GL_FRAMEBUFFER, 0)
raise Exception("Incomplete framebuffer")
glBindFramebuffer(GL_FRAMEBUFFER, 0)
# OpenVR texture data
self.texture = openvr.Texture_t()
self.texture.handle = self.texture_id
self.texture.eType = openvr.TextureType_OpenGL
self.texture.eColorSpace = openvr.ColorSpace_Gamma
def update(self):
self._update_texture()
glBindFramebuffer(GL_FRAMEBUFFER, self._fbo)
glViewport(0, 0, self._width, self._height)
self._draw()
glBindFramebuffer(GL_FRAMEBUFFER, 0)
glBindTexture(GL_TEXTURE_2D, self._view_tex)
# openvr.IVROverlay().setOverlayFlag(
# self._overlay,
# openvr.VROverlayFlags_SortWithNonSceneOverlays,
# True)
openvr.IVROverlay().showOverlay(self._overlay)
self._overlay_tex = openvr.Texture_t()
self._overlay_tex.handle = self._view_tex
self._overlay_tex.eType = openvr.TextureType_OpenGL
self._overlay_tex.eColorSpace = openvr.ColorSpace_Auto
# openvr.IVROverlay().setOverlayColor(self._overlay, 1.0, 1.0, 1.0)
openvr.IVROverlay().setOverlayTexture(self._overlay, self._overlay_tex)
openvr.IVRCompositor().submit(openvr.Eye_Right,self._overlay_tex)
def __init__(s):
s.vr_system = openvr.init(openvr.VRApplication_Scene)
s.vr_compositor = openvr.VRCompositor()
poses_t = openvr.TrackedDevicePose_t * openvr.k_unMaxTrackedDeviceCount
s.poses = poses_t()
s.w, s.h = s.vr_system.getRecommendedRenderTargetSize()
SDL_Init(SDL_INIT_VIDEO)
s.window = SDL_CreateWindow(b"test", SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, 100, 100,
SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL)
s.context = SDL_GL_CreateContext(s.window)
SDL_GL_MakeCurrent(s.window, s.context)
s.depth_buffer = glGenRenderbuffers(1)
s.frame_buffers = glGenFramebuffers(2)
s.texture_ids = glGenTextures(2)
s.textures = [None] * 2
s.eyes = [openvr.Eye_Left, openvr.Eye_Right]
s.cameraToProjection = [None] * 2
s.headToCamera = [None] * 2
s.col3 = [0, 0, 0, 1]
vertexShader = compileShader(
shader_string("""
layout (location=0) uniform mat4 cameraToProjection;
layout (location=1) uniform mat4 modelToCamera;
void main() {
float angle = gl_VertexID * (3.14159*2/3);
vec4 modelPos = vec4(cos(angle), sin(angle), -2, 1);
gl_Position = cameraToProjection * (modelToCamera * modelPos);
}
"""), GL_VERTEX_SHADER)
fragmentShader = compileShader(
shader_string("""
out vec4 colour;
void main() {
colour = vec4(1, 0, 0, 1);
}
"""), GL_FRAGMENT_SHADER)
s.program = compileProgram(vertexShader, fragmentShader)
s.vertexBuffer = glGenVertexArrays(1)
for eye in range(2):
glBindFramebuffer(GL_FRAMEBUFFER, s.frame_buffers[eye])
glBindRenderbuffer(GL_RENDERBUFFER, s.depth_buffer)
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, s.w,
s.h)
glFramebufferRenderbuffer(GL_FRAMEBUFFER,
GL_DEPTH_STENCIL_ATTACHMENT,
GL_RENDERBUFFER, s.depth_buffer)
glBindTexture(GL_TEXTURE_2D, s.texture_ids[eye])
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, s.w, s.h, 0, GL_RGBA,
GL_UNSIGNED_BYTE, None)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
GL_TEXTURE_2D, s.texture_ids[eye], 0)
texture = openvr.Texture_t()
texture.handle = int(s.texture_ids[eye])
texture.eType = openvr.TextureType_OpenGL
texture.eColorSpace = openvr.ColorSpace_Gamma
s.textures[eye] = texture
proj = s.vr_system.getProjectionMatrix(s.eyes[eye], 0.2, 500.0)
s.cameraToProjection[eye] = numpy.matrix(
[[proj.m[i][j] for i in range(4)] for j in range(4)],
numpy.float32)
camToHead = s.vr_system.getEyeToHeadTransform(s.eyes[eye])
s.headToCamera[eye] = numpy.matrix(
[[camToHead.m[i][j] for i in range(3)] + [s.col3[j]]
for j in range(4)], numpy.float32).I
def render(self):
self.vc = self.viewCoords()
if not self.VRMode:
self.vMat = np.stack((self.vv, self.vVhorz(), self.vVvert()))
self.draw.setPos(self.vc)
self.draw.setVM(self.vMat)
self.draw.clearZBuffer()
s = [0, 1]
self.draw.drawAll(self.matShaders,
mask=self.renderMask,
shadowIds=s,
useOpacitySM=self.useOpSM,
stage=self.stage)
cc = []
for ps in self.particleSystems:
if not ps.started: continue
dist = np.linalg.norm(ps.pos - self.pos)
pv = (ps.pos - self.pos) / dist
if (pv @ self.vv) > (self.cullAngle - 0.2):
cc.append((ps, dist))
cc = sorted(cc, key=lambda a: a[1], reverse=True)
for i in range(len(cc)):
ps = cc[i][0]
if ps.tex is not None:
self.draw.drawPSTex(ps.pc, ps.color, ps.opacity, ps.size,
ps.tex)
else:
self.draw.drawPS(ps.pc, ps.color, ps.opacity, ps.size)
self.postProcess()
result = self.draw.getFrame()
if self.VRMode and self.GL:
self.rgb = np.array(result)[::-1]
else:
self.rgb = result
self.debugOverlay()
if self.VRMode:
if self.GL:
try:
_ = self.VRtex
except:
print('Setup VR')
self.VRtex = openvr.Texture_t()
self.VRtex.handle = int(self.draw.FB_GL)
self.VRtex.eType = openvr.TextureType_OpenGL
self.VRtex.eColorSpace = openvr.ColorSpace_Gamma
self.cmp.submit(openvr.Eye_Left, self.VRtex)
self.cmp.submit(openvr.Eye_Right, self.VRtex)
else:
rgba = np.array(
Image.fromarray(self.rgb.astype("uint8")).convert("RGBA"))
ibuf = ctypes.create_string_buffer(rgba.tobytes())
b = (self.vrBuf1, self.vrBuf2)[self.frameNum % 2]
self.ov.showOverlay(b)
b2 = (self.vrBuf1, self.vrBuf2)[(self.frameNum + 1) % 2]
self.ov.hideOverlay(b2)
self.ov.setOverlayRaw(b2, ibuf, self.W, self.H, 4)
return [
self.rgb, None, self.selecting, (self.pos, self.vv), self.uInfo
]
