def createIndexBuffer(self, mesh, **kwargs):
if not mesh.hasIndices():
return None
if not kwargs.get("force_recreate", False) and hasattr(
mesh, OpenGL.IndexBufferProperty):
return getattr(mesh, OpenGL.IndexBufferProperty)
buffer = QOpenGLBuffer(QOpenGLBuffer.IndexBuffer)
buffer.create()
buffer.bind()
data = mesh.getIndicesAsByteArray()
if 'index_start' in kwargs and 'index_stop' in kwargs:
buffer.allocate(
data[4 * kwargs['index_start']:4 * kwargs['index_stop']],
4 * (kwargs['index_stop'] - kwargs['index_start']))
else:
buffer.allocate(data, len(data))
buffer.release()
setattr(mesh, OpenGL.IndexBufferProperty, buffer)
return buffer
def _initialize(self):
supports_vao = OpenGLContext.supportsVertexArrayObjects() # fill the OpenGLContext.properties
Logger.log("d", "Support for Vertex Array Objects: %s", supports_vao)
OpenGL.setInstance(OpenGL())
self._gl = OpenGL.getInstance().getBindingsObject()
self._default_material = OpenGL.getInstance().createShaderProgram(Resources.getPath(Resources.Shaders, "default.shader"))
self._render_passes.add(DefaultPass(self._viewport_width, self._viewport_height))
self._render_passes.add(SelectionPass(self._viewport_width, self._viewport_height))
self._render_passes.add(CompositePass(self._viewport_width, self._viewport_height))
buffer = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer)
buffer.create()
buffer.bind()
buffer.allocate(120)
data = numpy.array([
-1.0, -1.0, 0.0,
1.0, 1.0, 0.0,
-1.0, 1.0, 0.0,
-1.0, -1.0, 0.0,
1.0, -1.0, 0.0,
1.0, 1.0, 0.0,
0.0, 0.0,
1.0, 1.0,
0.0, 1.0,
0.0, 0.0,
1.0, 0.0,
1.0, 1.0
], dtype = numpy.float32).tostring()
buffer.write(0, data, len(data))
buffer.release()
self._quad_buffer = buffer
self._initialized = True
self.initialized.emit()
def createIndexBuffer(self, mesh: "MeshData", **kwargs: Any):
if not mesh.hasIndices():
return None
if not kwargs.get("force_recreate", False) and hasattr(
mesh, OpenGL.IndexBufferProperty):
return getattr(mesh, OpenGL.IndexBufferProperty)
buffer = QOpenGLBuffer(QOpenGLBuffer.IndexBuffer)
buffer.create()
buffer.bind()
data = cast(bytes, mesh.getIndicesAsByteArray()
) # We check for None at the beginning of the method
if 'index_start' in kwargs and 'index_stop' in kwargs:
buffer.allocate(
data[4 * kwargs['index_start']:4 * kwargs['index_stop']],
4 * (kwargs['index_stop'] - kwargs['index_start']))
else:
buffer.allocate(data, len(data))
buffer.release()
setattr(mesh, OpenGL.IndexBufferProperty, buffer)
return buffer
def __init__(self, scene, **kwargs):
"""Initialize actor."""
super(Actor, self).__init__()
self._state = 0 #1=scale, 2=rotation, 3=scale
self._lines = None
self._axis = 0 # 1=x, 2=y, 3=z
self._scene = scene
self._transform = kwargs.get("transform", QMatrix4x4())
self._render_mode = kwargs.get("mode", Actor.RenderMode.Triangles)
self._render_type = kwargs.get("type", Actor.RenderType.Solid)
self._material = kwargs.get("material", Material())
self._wireframe = kwargs.get(
"wireframe", Material(diffuse=QVector3D(0.25, 0.25, 0.25)))
self._viewport = kwargs.get("viewport", (0.0, 0.0, 1.0, 1.0))
self._name = kwargs.get("name", "Actor" + str(id(self)))
self._shader_collection = Shaders()
#self._texture_collection = Textures()
self._solid_shader = self._shader_collection.uniformMaterialPhongShader(
)
self._solid_flat_shader = self._shader_collection.uniformMaterialPhongFlatShader(
)
self._nolight_solid_shader = self._shader_collection.uniformMaterialShader(
)
self._wireframe_shader = self._shader_collection.uniformMaterialShader(
)
self._nolight_wireframe_shader = self._shader_collection.uniformMaterialShader(
)
self._normal_visualizing_shader = self._shader_collection.normalVisShader(
)
self._active_shader = self._solid_shader
self._active_material = self._material
self._vao = QOpenGLVertexArrayObject()
self._vbo = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer)
self._ibo = QOpenGLBuffer(QOpenGLBuffer.IndexBuffer)
self._num_vertices = 0
self._num_indices = 0
self._hasNormals = False
self._hasColors = False
self._hasTextureCoords = False
self._hasIndices = False
self._hasFaces = False
self._texture = None
#self._bbox = None
self._visible = True
self._enabled = False
self._pickable = True
self._selectable = False
self._selected = False
self._highlighted = False
self._errorMaterial = Material.ruby()
self._errorHighlight = False
self._warningMaterial = Material.gold()
self._warningHighlight = False
self._pickFactor = 1.0
def createVertexBuffer(self, mesh: "MeshData",
**kwargs: Any) -> QOpenGLBuffer:
if not kwargs.get("force_recreate", False) and hasattr(
mesh, OpenGL.VertexBufferProperty):
return getattr(mesh, OpenGL.VertexBufferProperty)
buffer = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer)
buffer.create()
buffer.bind()
float_size = ctypes.sizeof(ctypes.c_float)
int_size = ctypes.sizeof(ctypes.c_int)
buffer_size = mesh.getVertexCount(
) * 3 * float_size # Vertex count * number of components * sizeof(float32)
if mesh.hasNormals():
buffer_size += mesh.getVertexCount(
) * 3 * float_size # Vertex count * number of components * sizeof(float32)
if mesh.hasColors():
buffer_size += mesh.getVertexCount(
) * 4 * float_size # Vertex count * number of components * sizeof(float32)
if mesh.hasUVCoordinates():
buffer_size += mesh.getVertexCount(
) * 2 * float_size # Vertex count * number of components * sizeof(float32)
for attribute_name in mesh.attributeNames():
attribute = mesh.getAttribute(attribute_name)
if attribute["opengl_type"] == "vector2f":
buffer_size += mesh.getVertexCount() * 2 * float_size
elif attribute["opengl_type"] == "vector4f":
buffer_size += mesh.getVertexCount() * 4 * float_size
elif attribute["opengl_type"] == "int":
buffer_size += mesh.getVertexCount() * int_size
elif attribute["opengl_type"] == "float":
buffer_size += mesh.getVertexCount() * float_size
else:
Logger.log(
"e",
"Could not determine buffer size for attribute [%s] with type [%s]"
% (attribute_name, attribute["opengl_type"]))
buffer.allocate(buffer_size)
offset = 0
vertices = mesh.getVerticesAsByteArray()
if vertices is not None:
buffer.write(0, vertices, len(vertices))
offset += len(vertices)
if mesh.hasNormals():
normals = cast(bytes, mesh.getNormalsAsByteArray())
buffer.write(offset, normals, len(normals))
offset += len(normals)
if mesh.hasColors():
colors = cast(bytes, mesh.getColorsAsByteArray())
buffer.write(offset, colors, len(colors))
offset += len(colors)
if mesh.hasUVCoordinates():
uvs = cast(bytes, mesh.getUVCoordinatesAsByteArray())
buffer.write(offset, uvs, len(uvs))
offset += len(uvs)
for attribute_name in mesh.attributeNames():
attribute = mesh.getAttribute(attribute_name)
attribute_byte_array = attribute["value"].tostring()
buffer.write(offset, attribute_byte_array,
len(attribute_byte_array))
offset += len(attribute_byte_array)
buffer.release()
setattr(mesh, OpenGL.VertexBufferProperty, buffer)
return buffer
def initializeGL(self):
if self.logger:
self.logger.initialize()
self.logger.messageLogged.connect(lambda message: qDebug(
self.__tr("OpenGL debug message: {0}").fomat(message.message())
))
self.logger.startLogging()
gl = QOpenGLContext.currentContext().versionFunctions(glVersionProfile)
QOpenGLContext.currentContext().aboutToBeDestroyed.connect(
self.cleanup)
self.clean = False
fragmentShader = None
vertexShader = vertexShader2D
if self.ddsFile.isCubemap:
fragmentShader = fragmentShaderCube
vertexShader = vertexShaderCube
if QOpenGLContext.currentContext().hasExtension(
b"GL_ARB_seamless_cube_map"):
GL_TEXTURE_CUBE_MAP_SEAMLESS = 0x884F
gl.glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS)
elif self.ddsFile.glFormat.samplerType == "F":
fragmentShader = fragmentShaderFloat
elif self.ddsFile.glFormat.samplerType == "UI":
fragmentShader = fragmentShaderUInt
else:
fragmentShader = fragmentShaderSInt
self.program = QOpenGLShaderProgram(self)
self.program.addShaderFromSourceCode(QOpenGLShader.Vertex,
vertexShader)
self.program.addShaderFromSourceCode(QOpenGLShader.Fragment,
fragmentShader)
self.program.bindAttributeLocation("position", 0)
self.program.bindAttributeLocation("texCoordIn", 1)
self.program.link()
self.transparecyProgram = QOpenGLShaderProgram(self)
self.transparecyProgram.addShaderFromSourceCode(
QOpenGLShader.Vertex, transparencyVS)
self.transparecyProgram.addShaderFromSourceCode(
QOpenGLShader.Fragment, transparencyFS)
self.transparecyProgram.bindAttributeLocation("position", 0)
self.transparecyProgram.link()
self.vao = QOpenGLVertexArrayObject(self)
vaoBinder = QOpenGLVertexArrayObject.Binder(self.vao)
self.vbo = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer)
self.vbo.create()
self.vbo.bind()
theBytes = struct.pack("%sf" % len(vertices), *vertices)
self.vbo.allocate(theBytes, len(theBytes))
gl.glEnableVertexAttribArray(0)
gl.glEnableVertexAttribArray(1)
gl.glVertexAttribPointer(0, 4, gl.GL_FLOAT, False, 6 * 4, 0)
gl.glVertexAttribPointer(1, 2, gl.GL_FLOAT, False, 6 * 4, 4 * 4)
self.texture = self.ddsFile.asQOpenGLTexture(
gl, QOpenGLContext.currentContext())
def __init__(self, scene, **kwargs):
"""Initialize actor."""
super(Actor, self).__init__()
self._isIcosahedron = False
self._scene = scene
self._transform = kwargs.get("transform", QMatrix4x4())
self._render_mode = kwargs.get("mode", Actor.RenderMode.Triangles)
self._render_type = kwargs.get("type", Actor.RenderType.Solid)
self._material = kwargs.get("material", Material())
self._wireframe = kwargs.get(
"wireframe", Material(diffuse=QVector3D(0.25, 0.25, 0.25)))
self._viewport = kwargs.get("viewport", (0.0, 0.0, 1.0, 1.0))
self._name = kwargs.get("name", "Actor" + str(id(self)))
self._shader_collection = Shaders()
self._solid_shader = self._shader_collection.uniformMaterialBRDFShader(
)
self._solid_flat_shader = self._shader_collection.uniformMaterialBRDFShader(
)
self._shader_name = "BRDF"
self._nolight_solid_shader = self._shader_collection.uniformMaterialBRDFShader(
)
self._wireframe_shader = self._shader_collection.uniformMaterialShader(
)
self._nolight_wireframe_shader = self._shader_collection.uniformMaterialShader(
)
self._active_shader = self._solid_shader
self._active_material = self._material
self._vao = QOpenGLVertexArrayObject()
self._vbo = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer)
self._ibo = QOpenGLBuffer(QOpenGLBuffer.IndexBuffer)
self._num_vertices = 0
self._num_indices = 0
self._hasNormals = False
self._hasColors = False
self._hasTextureCoords = False
self._hasIndices = False
self._waves = []
self._portalInteration = False
self._portal1 = []
#vertices
self._portal2 = []
#vertices
#self._bbox = None
self._visible = True
self._enabled = False
self._pickable = True
self._selectable = False
self._selected = False
self._highlighted = False
self._errorMaterial = Material.ruby()
self._errorHighlight = False
self._warningMaterial = Material.gold()
self._warningHighlight = False
self._pickFactor = 1.0
def createVertexBuffer(self, mesh: "MeshData",
**kwargs: Any) -> QOpenGLBuffer:
"""Create a Vertex buffer for a mesh.
This will create a vertex buffer object that is filled with the
vertex data of the mesh.
By default, the associated vertex buffer should be cached using a
custom property on the mesh. This should use the VertexBufferProperty
property name.
:param mesh: The mesh to create a vertex buffer for.
:param kwargs: Keyword arguments.
Possible values:
- force_recreate: Ignore the cached value if set and always create a new buffer.
"""
if not kwargs.get("force_recreate", False) and hasattr(
mesh, OpenGL.VertexBufferProperty):
return getattr(mesh, OpenGL.VertexBufferProperty)
buffer = QOpenGLBuffer(QOpenGLBuffer.VertexBuffer)
buffer.create()
buffer.bind()
float_size = ctypes.sizeof(ctypes.c_float)
int_size = ctypes.sizeof(ctypes.c_int)
buffer_size = mesh.getVertexCount(
) * 3 * float_size # Vertex count * number of components * sizeof(float32)
if mesh.hasNormals():
buffer_size += mesh.getVertexCount(
) * 3 * float_size # Vertex count * number of components * sizeof(float32)
if mesh.hasColors():
buffer_size += mesh.getVertexCount(
) * 4 * float_size # Vertex count * number of components * sizeof(float32)
if mesh.hasUVCoordinates():
buffer_size += mesh.getVertexCount(
) * 2 * float_size # Vertex count * number of components * sizeof(float32)
for attribute_name in mesh.attributeNames():
attribute = mesh.getAttribute(attribute_name)
if attribute["opengl_type"] == "vector2f":
buffer_size += mesh.getVertexCount() * 2 * float_size
elif attribute["opengl_type"] == "vector4f":
buffer_size += mesh.getVertexCount() * 4 * float_size
elif attribute["opengl_type"] == "int":
buffer_size += mesh.getVertexCount() * int_size
elif attribute["opengl_type"] == "float":
buffer_size += mesh.getVertexCount() * float_size
else:
Logger.log(
"e",
"Could not determine buffer size for attribute [%s] with type [%s]"
% (attribute_name, attribute["opengl_type"]))
buffer.allocate(buffer_size)
offset = 0
vertices = mesh.getVerticesAsByteArray()
if vertices is not None:
buffer.write(0, vertices, len(vertices))
offset += len(vertices)
if mesh.hasNormals():
normals = cast(bytes, mesh.getNormalsAsByteArray())
buffer.write(offset, normals, len(normals))
offset += len(normals)
if mesh.hasColors():
colors = cast(bytes, mesh.getColorsAsByteArray())
buffer.write(offset, colors, len(colors))
offset += len(colors)
if mesh.hasUVCoordinates():
uvs = cast(bytes, mesh.getUVCoordinatesAsByteArray())
buffer.write(offset, uvs, len(uvs))
offset += len(uvs)
for attribute_name in mesh.attributeNames():
attribute = mesh.getAttribute(attribute_name)
attribute_byte_array = attribute["value"].tostring()
buffer.write(offset, attribute_byte_array,
len(attribute_byte_array))
offset += len(attribute_byte_array)
buffer.release()
setattr(mesh, OpenGL.VertexBufferProperty, buffer)
return buffer
