Rename: offscreen_object > offscreen and color_object > color_texture

space_view3d_virtual_reality/hmd/__init__.py

@@ -58,8 +58,8 @@ class HMD_Base:
         "_head_transformation",
         "_is_direct_mode",
         "_eye_pose",
-        "_offscreen_object",
-        "_color_object",
+        "_offscreen",
+        "_color_texture",
         "_modelview_matrix",
         "_near",
         "_far",
@@ -74,8 +74,8 @@ class HMD_Base:
         self._height = [0, 0]
         self._projection_matrix = [Matrix.Identity(4), Matrix.Identity(4)]
         self._modelview_matrix = [Matrix.Identity(4), Matrix.Identity(4)]
-        self._color_object = [0, 0]
-        self._offscreen_object = [None, None]
+        self._color_texture = [0, 0]
+        self._offscreen = [None, None]
         self._eye_orientation_raw = [[1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]]
         self._eye_position_raw = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]
         self._scale = self._calculateScale(context)
@@ -103,13 +103,12 @@ class HMD_Base:
         self._height[self._current_eye] = value
 
     @property
-    def offscreen_object(self):
-        return self._offscreen_object[self._current_eye]
+    def offscreen(self):
+        return self._offscreen[self._current_eye]
 
     @property
-    @property
-    def color_object(self):
-        return self._color_object[self._current_eye]
+    def color_texture(self):
+        return self._color_texture[self._current_eye]
 
     @property
     def projection_matrix(self):
@@ -131,13 +130,13 @@ class HMD_Base:
         """
         try:
             for i in range(2):
-                self._offscreen_object[i] = gpu.offscreen.new(self._width[i], self._height[i], 0)
-                self._color_object[i] = self._offscreen_object[i].color_object
+                self._offscreen[i] = gpu.offscreen.new(self._width[i], self._height[i], 0)
+                self._color_texture[i] = self._offscreen[i].color_texture
 
         except Exception as E:
             print(E)
-            self._offscreen_object[0] = None
-            self._offscreen_object[1] = None
+            self._offscreen[0] = None
+            self._offscreen[1] = None
             return False
 
         else:
@@ -171,7 +170,7 @@ class HMD_Base:
         """
         try:
             for i in range(2):
-                self._offscreen_object[i] = None
+                self._offscreen[i] = None
 
         except Exception as E:
             print(E)

space_view3d_virtual_reality/hmd/oculus.py

@@ -77,7 +77,7 @@ class Oculus(HMD_Base):
             return True
 
     def _setup(self):
-        return self._hmd.setup(self._color_object[0], self._color_object[1])
+        return self._hmd.setup(self._color_texture[0], self._color_texture[1])
 
     def loop(self, context):
         """

space_view3d_virtual_reality/operator.py

@@ -266,12 +266,12 @@ class VirtualRealityDisplayOperator(bpy.types.Operator):
             return False
 
         # get the data from device
-        color_object = [0, 0]
+        color_texture = [0, 0]
         for i in range(2):
             self._hmd.setEye(i)
-            color_object[i] = self._hmd.color_object
+            color_texture[i] = self._hmd.color_texture
 
-        self._preview.init(color_object[0], color_object[1])
+        self._preview.init(color_texture[0], color_texture[1])
         return True
 
     def _slaveSetup(self, context):
@@ -409,15 +409,15 @@ class VirtualRealityDisplayOperator(bpy.types.Operator):
         for i in range(2):
             self._hmd.setEye(i)
 
-            offscreen_object = self._hmd.offscreen_object
+            offscreen = self._hmd.offscreen
             projection_matrix = self._hmd.projection_matrix
             modelview_matrix = self._hmd.modelview_matrix
 
             # drawing
             try:
-                offscreen_object.draw_view3d(projection_matrix, modelview_matrix)
+                offscreen.draw_view3d(projection_matrix, modelview_matrix)
             except:
-                offscreen_object.draw_view3d(scene, view3d, region, projection_matrix, modelview_matrix)
+                offscreen.draw_view3d(scene, view3d, region, projection_matrix, modelview_matrix)
 
         self._hmd.frameReady()
         self._is_rendering = False

space_view3d_virtual_reality/preview.py

@@ -16,20 +16,20 @@ from bgl import *
 
 class Preview:
     __slots__ = {
-            "_color_object_left",
-            "_color_object_right",
+            "_color_texture_left",
+            "_color_texture_right",
             }
 
-    def init(self, color_object_left, color_object_right):
+    def init(self, color_texture_left, color_texture_right):
         """
         Initialize preview window
 
-        :param color_object_left: 2D Texture binding ID (bind to the Framebuffer Object) for left eye
-        :type color_object_left: bgl.GLuint
-        :param color_object_right: 2D Texture binding ID (bind to the Framebuffer Object) for right eye
-        :type color_object_right: bgl.GLuint
+        :param color_texture_left: 2D Texture binding ID (bind to the Framebuffer Object) for left eye
+        :type color_texture_left: bgl.GLuint
+        :param color_texture_right: 2D Texture binding ID (bind to the Framebuffer Object) for right eye
+        :type color_texture_right: bgl.GLuint
         """
-        self.update(color_object_left, color_object_right)
+        self.update(color_texture_left, color_texture_right)
 
     def quit(self):
         """
@@ -37,17 +37,17 @@ class Preview:
         """
         pass
 
-    def update(self, color_object_left, color_object_right):
+    def update(self, color_texture_left, color_texture_right):
         """
         Update OpenGL binding textures
 
-        :param color_object_left: 2D Texture binding ID (bind to the Framebuffer Object) for left eye
-        :type color_object_left: bgl.GLuint
-        :param color_object_right: 2D Texture binding ID (bind to the Framebuffer Object) for right eye
-        :type color_object_right: bgl.GLuint
+        :param color_texture_left: 2D Texture binding ID (bind to the Framebuffer Object) for left eye
+        :type color_texture_left: bgl.GLuint
+        :param color_texture_right: 2D Texture binding ID (bind to the Framebuffer Object) for right eye
+        :type color_texture_right: bgl.GLuint
         """
-        self._color_object_left = color_object_left
-        self._color_object_right = color_object_right
+        self._color_texture_left = color_texture_left
+        self._color_texture_right = color_texture_right
 
 
     def _drawRectangle(self, eye):
@@ -92,10 +92,10 @@ class Preview:
         glEnable(GL_TEXTURE_2D)
         glActiveTexture(GL_TEXTURE0)
 
-        glBindTexture(GL_TEXTURE_2D, self._color_object_left)
+        glBindTexture(GL_TEXTURE_2D, self._color_texture_left)
         self._drawRectangle(0)
 
-        glBindTexture(GL_TEXTURE_2D, self._color_object_right)
+        glBindTexture(GL_TEXTURE_2D, self._color_texture_right)
         self._drawRectangle(1)
 
         glBindTexture(GL_TEXTURE_2D, act_tex[0])