Last active
November 23, 2019 22:33
-
-
Save furby-tm/10e0253ab8dc32a903850aed8218dfc0 to your computer and use it in GitHub Desktop.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import gpu | |
| import bgl | |
| import numpy as np | |
| from gpu_extras.batch import batch_for_shader | |
| import barnold.props as props | |
| from array import array | |
| class GPU: | |
| def __init__(self, engine, scene, width, height, offset_x, offset_y, rect): | |
| self._width = width | |
| self._height = height | |
| # self.buffer = bgl.Buffer(bgl.GL_SHORT, rect.shape, rect) | |
| rects = np.array_split(rect, 2) | |
| # WARNING DO NOT ATTEMPT TO DO MATH ON THIS, IT WILL MESS UP THE TYPE | |
| self.buff_width1 = rects[0].shape[1] | |
| self.buff_height1 = rects[0].shape[0] | |
| rect1 = np.ascontiguousarray(rects[0][0:self.buff_height1, 0:self.buff_width1], dtype="uint16") | |
| self.buff_width2 = rects[1].shape[1] | |
| self.buff_height2 = rects[1].shape[0] | |
| rect2 = np.ascontiguousarray(rects[1][0:self.buff_height2, 0:self.buff_width2], dtype="uint16") | |
| print(rect1.shape) | |
| print(rect1) | |
| self.buffer1 = bgl.Buffer(bgl.GL_SHORT, rect1.shape, rect1) | |
| self.buffer2 = bgl.Buffer(bgl.GL_SHORT, rect2.shape, rect2) | |
| # self.buffer3 = bgl.Buffer(bgl.GL_SHORT, rects[2].shape, rects[2]) | |
| # self.buffer4 = bgl.Buffer(bgl.GL_SHORT, rects[3].shape, rects[3]) | |
| # self.sx = rects[0].shape[1] // 2 | |
| # self.sy = rects[0].shape[0] // 2 | |
| # self.data_size = self._width * self._height * 4 | |
| # self.half_width = self._width // 2 | |
| # self.half_height = self._height // 2 | |
| # self.half_buffer = bgl.Buffer(bgl.GL_SHORT, half_rect.shape, half_rect) | |
| # self.vbo = bgl.Buffer(bgl.GL_INT, 1) | |
| # self.vbo_id = self.vbo[0] | |
| # bgl.glGenBuffers(1, self.vbo) | |
| # bgl.glBindBuffer(bgl.GL_PIXEL_UNPACK_BUFFER, self.vbo_id) | |
| # PBO OBJECT BUFFERDATA NOT WORKING | |
| # bgl.glBufferData(bgl.GL_PIXEL_UNPACK_BUFFER, self.data_size, 0, bgl.GL_STREAM_DRAW) | |
| # bgl.glBufferData(bgl.GL_PIXEL_UNPACK_BUFFER, self.data_size, self.buffer, bgl.GL_STREAM_DRAW) | |
| # bgl.glBindBuffer(bgl.GL_PIXEL_UNPACK_BUFFER, 0) | |
| # err = bgl.glGetError() | |
| # if err != bgl.GL_NO_ERROR: | |
| # print("!!!!!!!!!!GL Error:", err) | |
| self.engine = engine | |
| self.scene = scene | |
| self.cscene = scene.arnold | |
| # 4 textures striped offset | |
| self.texture1_offset_x = bgl.Buffer(bgl.GL_INT, 1) | |
| self.texture1_offset_y = bgl.Buffer(bgl.GL_INT, 1) | |
| self.texture1_offset_x[0] = 0 | |
| self.texture1_offset_y[0] = 0 | |
| self.texture2_offset_x = bgl.Buffer(bgl.GL_INT, 1) | |
| self.texture2_offset_y = bgl.Buffer(bgl.GL_INT, 1) | |
| self.texture2_offset_x[0] = 0 | |
| self.texture2_offset_y[0] = self.buff_height2 | |
| # 4 textures squared offset | |
| # self.texture1_offset_x = bgl.Buffer(bgl.GL_INT, 1) | |
| # self.texture1_offset_y = bgl.Buffer(bgl.GL_INT, 1) | |
| # self.texture1_offset_x[0] = 0 | |
| # self.texture1_offset_y[0] = 0 | |
| # self.texture2_offset_x = bgl.Buffer(bgl.GL_INT, 1) | |
| # self.texture2_offset_y = bgl.Buffer(bgl.GL_INT, 1) | |
| # self.texture2_offset_x[0] = self._width // 2 | |
| # self.texture2_offset_y[0] = 0 | |
| # self.texture3_offset_x = bgl.Buffer(bgl.GL_INT, 1) | |
| # self.texture3_offset_y = bgl.Buffer(bgl.GL_INT, 1) | |
| # self.texture3_offset_x[0] = 0 | |
| # self.texture3_offset_y[0] = self._height // 2 | |
| # self.texture4_offset_x = bgl.Buffer(bgl.GL_INT, 1) | |
| # self.texture4_offset_y = bgl.Buffer(bgl.GL_INT, 1) | |
| # self.texture4_offset_x[0] = self._width // 2 | |
| # self.texture4_offset_y[0] = self._height // 2 | |
| # 2 textures offset | |
| # self.texture1_offset_x = bgl.Buffer(bgl.GL_INT, 1) | |
| # self.texture1_offset_y = bgl.Buffer(bgl.GL_INT, 1) | |
| # self.texture1_offset_x[0] = 0 | |
| # self.texture1_offset_y[0] = 0 | |
| # self.texture2_offset_x = bgl.Buffer(bgl.GL_INT, 1) | |
| # self.texture2_offset_y = bgl.Buffer(bgl.GL_INT, 1) | |
| # self.texture2_offset_x[0] = 0 | |
| # self.texture2_offset_y[0] = self._height // 2 | |
| self.bucket_index = 0 | |
| # pixels = bgl.Buffer(bgl.GL_SHORT, rect.shape, rect) | |
| # Generate texture | |
| bgl.glEnable(bgl.GL_TEXTURE_2D) | |
| self.texture = bgl.Buffer(bgl.GL_SHORT, 4) | |
| bgl.glGenTextures(4, self.texture) | |
| self.texture1 = self.texture[0] = 0 # 300 | |
| self.texture2 = self.texture[1] = 0 # 1 | |
| self.texture3 = self.texture[2] = 0 # 0 | |
| self.texture4 = self.texture[3] = 0 # 3 | |
| if self.cscene.transparency == True: | |
| self.user_set_format = bgl.GL_RGBA16F | |
| else: | |
| self.user_set_format = bgl.GL_RGB16F | |
| self.index = 0 | |
| self.nextIndex = 1 | |
| self.update_buckets() | |
| self._init_opengl() | |
| textures = [bgl.GL_TEXTURE1, bgl.GL_TEXTURE2, bgl.GL_TEXTURE3, bgl.GL_TEXTURE4] | |
| for i in range(0, 2): | |
| self._initialize_textures(textures[i], self.texture[i]) | |
| # self.init_buffers(rect) | |
| # def init_buffers(self, rect): | |
| # sx = self.sx | |
| # sy = self.sy | |
| # buff1 = np.ascontiguousarray(rect[0:sx, 0:sy], dtype="uint16") | |
| # buff2 = np.ascontiguousarray( | |
| # rect[sx + 1 : sx * 2, sy + 1 : sy * 2], dtype="uint16" | |
| # ) | |
| # buff3 = np.ascontiguousarray( | |
| # rect[(sx * 2) + 1 : sx * 3, (sy * 2) + 1 : sy * 3], dtype="uint16" | |
| # ) | |
| # buff4 = np.ascontiguousarray( | |
| # rect[(sx * 3) + 1 : -1, (sy * 3) + 1 : -1], dtype="uint16" | |
| # ) | |
| # print(sx) | |
| # print(sy) | |
| # print(buff1.shape) | |
| # print(buff2.shape) | |
| # print(buff3.shape) | |
| # print(buff4.shape) | |
| # self.half_buffer1 = bgl.Buffer(bgl.GL_SHORT, buff1.shape, buff1) | |
| # # self.half_buffer2 = bgl.Buffer(bgl.GL_SHORT, buff2.shape, buff2) | |
| # # self.half_buffer3 = bgl.Buffer(bgl.GL_SHORT, buff3.shape, buff3) | |
| # # self.half_buffer4 = bgl.Buffer(bgl.GL_SHORT, buff4.shape, buff4) | |
| def _initialize_textures(self, _texture, _subtexture): | |
| bgl.glActiveTexture(_texture) | |
| bgl.glBindTexture(bgl.GL_TEXTURE_2D, _subtexture) | |
| bgl.glTexImage2D( | |
| bgl.GL_TEXTURE_2D, | |
| 0, | |
| self.user_set_format, | |
| self._width, | |
| self._height, | |
| 0, | |
| bgl.GL_RGBA, | |
| bgl.GL_UNSIGNED_SHORT, | |
| None, | |
| ) | |
| bgl.glTexParameteri( | |
| bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_S, bgl.GL_CLAMP_TO_EDGE | |
| ) | |
| bgl.glTexParameteri( | |
| bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_T, bgl.GL_CLAMP_TO_EDGE | |
| ) | |
| bgl.glTexParameteri( | |
| bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_NEAREST | |
| ) | |
| bgl.glTexParameteri( | |
| bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEAREST | |
| ) | |
| return | |
| def _init_opengl(self): | |
| vertex_shader = """ | |
| uniform mat4 ModelViewProjectionMatrix; | |
| /* Keep in sync with intern/opencolorio/gpu_shader_display_transform_vertex.glsl */ | |
| in vec2 texCoord; | |
| in vec2 pos; | |
| out vec2 texCoord_interp; | |
| void main() | |
| { | |
| gl_Position = ModelViewProjectionMatrix * vec4(pos.xy, 0.0f, 1.0f); | |
| gl_Position.z = 1.0; | |
| texCoord_interp = texCoord; | |
| } | |
| """ | |
| fragment_shader = """ | |
| #extension GL_ARB_shading_language_420pack : enable | |
| in vec2 texCoord_interp; | |
| out vec4 fragColor; | |
| /* layout(binding = 1) */ uniform sampler2D texture1; | |
| /* layout(binding = 2) */ uniform sampler2D texture2; | |
| /* layout(binding = 3) */ uniform sampler2D texture3; | |
| /* layout(binding = 4) */ uniform sampler2D texture4; | |
| void main() | |
| { | |
| fragColor = texture(texture1, texCoord_interp) + texture(texture2, texCoord_interp) + texture(texture3, texCoord_interp) + texture(texture4, texCoord_interp); | |
| } | |
| """ | |
| self.shader = gpu.types.GPUShader(vertex_shader, fragment_shader) | |
| self.shader.bind() | |
| # self.shader_program = self.shader.program | |
| # self.texture1_location = self.shader.uniform_from_name("texture1") | |
| # self.texture2_location = self.shader.uniform_from_name("texture2") | |
| # self.texture3_location = self.shader.uniform_from_name("texture3") | |
| # self.texture4_location = self.shader.uniform_from_name("texture4") | |
| self.seq = 0 | |
| # self.engine.bind_display_space_shader(self.scene) | |
| self.vertex_buffer = bgl.Buffer(bgl.GL_INT, 1) | |
| bgl.glGenBuffers(1, self.vertex_buffer) | |
| bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[0]) | |
| bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 64, 0, bgl.GL_STREAM_DRAW) | |
| # shader_program = bgl.Buffer(bgl.GL_INT, 1) | |
| # bgl.glGetIntegerv(self.shader.program, shader_program) | |
| # # Generate vertex array | |
| self.vertex_array = bgl.Buffer(bgl.GL_INT, 1) | |
| bgl.glGenVertexArrays(1, self.vertex_array) | |
| bgl.glBindVertexArray(self.vertex_array[0]) | |
| texturecoord_location = bgl.glGetAttribLocation(self.shader.program, "texCoord") | |
| position_location = bgl.glGetAttribLocation(self.shader.program, "pos") | |
| # self.image_texture_location = bgl.glGetUniformLocation(shader_program[0], "image_texture") | |
| # # self.fullscreen_location = bgl.glGetUniformLocation(fallback_shader_program[0], "fullscreen") | |
| # # bgl.glUniform2f(self.fullscreen_location, self._width, self._height) | |
| bgl.glEnableVertexAttribArray(texturecoord_location) | |
| bgl.glEnableVertexAttribArray(position_location) | |
| self.vpointer = bgl.Buffer(bgl.GL_FLOAT, len(self.vpointer), self.vpointer) | |
| # # texcoord = bgl.Buffer(bgl.GL_FLOAT, len(texcoord), texcoord) | |
| bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 64, self.vpointer, bgl.GL_STREAM_DRAW) | |
| # bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, self.vertex_buffer[1]) | |
| # bgl.glBufferData(bgl.GL_ARRAY_BUFFER, 32, texcoord, bgl.GL_STREAM_DRAW) | |
| bgl.glVertexAttribPointer( | |
| texturecoord_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 16, 0 | |
| ) | |
| bgl.glVertexAttribPointer( | |
| position_location, 2, bgl.GL_FLOAT, bgl.GL_FALSE, 16, 8 | |
| ) | |
| # bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0) | |
| bgl.glBindVertexArray(0) | |
| # self.engine.unbind_display_space_shader() | |
| def __del__(self): | |
| bgl.glBindBuffer(bgl.GL_ARRAY_BUFFER, 0) | |
| bgl.glDeleteBuffers(1, self.buffer1) | |
| bgl.glDeleteBuffers(1, self.buffer2) | |
| # self.half_buffer = None | |
| self.buffer1 = None | |
| self.buffer2 = None | |
| # bgl.glDeleteBuffers(1, self.vbo) | |
| bgl.glDeleteBuffers(1, self.vertex_buffer) | |
| bgl.glDeleteVertexArrays(1, self.vertex_array) | |
| bgl.glBindTexture(bgl.GL_TEXTURE_2D, 0) | |
| bgl.glDeleteTextures(4, self.texture) | |
| # bgl.glDeleteBuffers(2, self.render_buffer) | |
| def update_buckets(self): | |
| self.bucket_size = self.engine.AI.bucket_size | |
| self.bucket_array = self.engine.AI.bucket_array | |
| self.x = self.bucket_array[self.bucket_index][0][0] | |
| self.y = self.bucket_array[self.bucket_index][0][1] | |
| self.bucket_width = self.bucket_array[self.bucket_index][0][2] | |
| self.bucket_height = self.bucket_array[self.bucket_index][0][3] | |
| self.vpointer = [ | |
| 0.0, | |
| 0.0, | |
| self.x, | |
| self._height + self.y, | |
| 1.0, | |
| 0.0, | |
| self._width + self.x, | |
| self._height + self.y, | |
| 1.0, | |
| 1.0, | |
| self._width + self.x, | |
| self.y, | |
| 0.0, | |
| 1.0, | |
| self.x, | |
| self.y, | |
| ] | |
| def update(self): | |
| # self.update_buckets() | |
| self.blit_buffer() | |
| def subtex1(self): | |
| bgl.glActiveTexture(bgl.GL_TEXTURE1) | |
| bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture1) | |
| bgl.glTexSubImage2D( | |
| bgl.GL_TEXTURE_2D, | |
| 0, | |
| self.texture1_offset_x[0], | |
| self.texture1_offset_y[0], | |
| self.buff_width1, | |
| self.buff_height1, | |
| bgl.GL_RGBA, | |
| bgl.GL_UNSIGNED_SHORT, | |
| self.buffer1, | |
| ) | |
| return | |
| def subtex2(self): | |
| # TOP RIGHT | |
| bgl.glActiveTexture(bgl.GL_TEXTURE2) | |
| bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture2) | |
| bgl.glTexSubImage2D( | |
| bgl.GL_TEXTURE_2D, | |
| 0, | |
| self.texture2_offset_x[0], | |
| self.texture2_offset_y[0], | |
| self.buff_width2, | |
| self.buff_height2, | |
| bgl.GL_RGBA, | |
| bgl.GL_UNSIGNED_SHORT, | |
| self.buffer2, | |
| ) | |
| return | |
| def subtex3(self): | |
| # BOTTOM LEFT | |
| bgl.glActiveTexture(bgl.GL_TEXTURE3) | |
| bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture3) | |
| bgl.glTexSubImage2D( | |
| bgl.GL_TEXTURE_2D, | |
| 0, | |
| self.texture3_offset_x[0], | |
| self.texture3_offset_y[0], | |
| self.half_width, | |
| self.half_height, | |
| bgl.GL_RGBA, | |
| bgl.GL_UNSIGNED_SHORT, | |
| self.buffer3, | |
| ) | |
| return | |
| def subtex4(self): | |
| # BOTTOM RIGHT | |
| # self.shader.bind() | |
| # bgl.glUniform1iv(self.texture4_location, 4, self.value) | |
| bgl.glActiveTexture(bgl.GL_TEXTURE4) | |
| bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture4) | |
| # bgl.glUniform1i(self.texture1_location, 0) | |
| # self.shader.uniform_int("texture1", 5) | |
| # # bgl.glBindBuffer(bgl.GL_PIXEL_UNPACK_BUFFER, self.vbo_id) | |
| bgl.glTexSubImage2D( | |
| bgl.GL_TEXTURE_2D, | |
| 0, | |
| self.texture4_offset_x[0], | |
| self.texture4_offset_y[0], | |
| self.half_width, | |
| self.half_height, | |
| bgl.GL_RGBA, | |
| bgl.GL_UNSIGNED_SHORT, | |
| self.buffer4, | |
| ) | |
| return | |
| def blit_buffer(self): | |
| """Blit a buffer into 4 subtextures. | |
| """ | |
| bgl.glPixelStorei(bgl.GL_UNPACK_ALIGNMENT, 4) | |
| # bgl.glPixelStorei(bgl.GL_UNPACK_ROW_LENGTH, int(self._width)) | |
| # bgl.glPixelStorei(bgl.GL_UNPACK_SKIP_PIXELS, self.texture1_offset_x[0]) | |
| # bgl.glPixelStorei(bgl.GL_UNPACK_SKIP_ROWS, self.texture1_offset_y[0]) | |
| self.subtex1() | |
| # bgl.glPixelStorei(bgl.GL_UNPACK_SKIP_PIXELS, self.texture2_offset_x[0]) | |
| # bgl.glPixelStorei(bgl.GL_UNPACK_SKIP_ROWS, self.texture2_offset_y[0]) | |
| self.subtex2() | |
| # bgl.glPixelStorei(bgl.GL_UNPACK_SKIP_PIXELS, self.texture3_offset_x[0]) | |
| # bgl.glPixelStorei(bgl.GL_UNPACK_SKIP_ROWS, self.texture3_offset_y[0]) | |
| # self.subtex3() | |
| # bgl.glPixelStorei(bgl.GL_UNPACK_SKIP_PIXELS, self.texture4_offset_x[0]) | |
| # bgl.glPixelStorei(bgl.GL_UNPACK_SKIP_ROWS, self.texture4_offset_y[0]) | |
| # self.subtex4() | |
| # def _init_texture2(self): | |
| # bgl.glActiveTexture(bgl.GL_TEXTURE2) | |
| # bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture2) | |
| # bgl.glTexImage2D( | |
| # bgl.GL_TEXTURE_2D, | |
| # 0, | |
| # self.user_set_format, | |
| # self._width, | |
| # self._height, | |
| # 0, | |
| # bgl.GL_RGBA, | |
| # bgl.GL_UNSIGNED_SHORT, | |
| # 0, | |
| # ) | |
| # bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_S, bgl.GL_CLAMP_TO_EDGE) | |
| # bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_T, bgl.GL_CLAMP_TO_EDGE) | |
| # bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_NEAREST) | |
| # bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEAREST) | |
| # return | |
| # def _init_texture3(self): | |
| # bgl.glActiveTexture(bgl.GL_TEXTURE3) | |
| # bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture3) | |
| # bgl.glTexImage2D( | |
| # bgl.GL_TEXTURE_2D, | |
| # 0, | |
| # self.user_set_format, | |
| # self._width, | |
| # self._height, | |
| # 0, | |
| # bgl.GL_RGBA, | |
| # bgl.GL_UNSIGNED_SHORT, | |
| # 0, | |
| # ) | |
| # bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_S, bgl.GL_CLAMP_TO_EDGE) | |
| # bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_T, bgl.GL_CLAMP_TO_EDGE) | |
| # bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_NEAREST) | |
| # bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEAREST) | |
| # return | |
| # def _init_texture4(self): | |
| # bgl.glActiveTexture(bgl.GL_TEXTURE4) | |
| # bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture4) | |
| # bgl.glTexImage2D( | |
| # bgl.GL_TEXTURE_2D, | |
| # 0, | |
| # self.user_set_format, | |
| # self._width, | |
| # self._height, | |
| # 0, | |
| # bgl.GL_RGBA, | |
| # bgl.GL_UNSIGNED_SHORT, | |
| # 0, | |
| # ) | |
| # bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_S, bgl.GL_CLAMP_TO_EDGE) | |
| # bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_WRAP_T, bgl.GL_CLAMP_TO_EDGE) | |
| # bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MIN_FILTER, bgl.GL_NEAREST) | |
| # bgl.glTexParameteri(bgl.GL_TEXTURE_2D, bgl.GL_TEXTURE_MAG_FILTER, bgl.GL_NEAREST) | |
| # return | |
| def draw(self): | |
| # if self._transparent: | |
| bgl.glEnable(bgl.GL_BLEND) | |
| bgl.glBlendFunc(bgl.GL_ONE, bgl.GL_ONE_MINUS_SRC_ALPHA) | |
| self.engine.bind_display_space_shader(self.scene) | |
| # bgl.glUniform1i(self.texture1_location, 0) | |
| # bgl.glActiveTexture(bgl.GL_TEXTURE1) | |
| # bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture1) | |
| # bgl.glActiveTexture(bgl.GL_TEXTURE2) | |
| # bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture2) | |
| # bgl.glActiveTexture(bgl.GL_TEXTURE3) | |
| # bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture3) | |
| # bgl.glActiveTexture(bgl.GL_TEXTURE4) | |
| # bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture4) | |
| # bgl.glUniform1i(self.image_texture_location, self.texture2) | |
| # bgl.glUniform1i(self.texture1_location, 1) | |
| # bgl.glActiveTexture(bgl.GL_TEXTURE1) | |
| # bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture2) | |
| # bgl.glUniform1i(bgl.glGetUniformLocation(self.shader.program, "texture1"), 1) | |
| # bgl.glUniform1i(self.texture1_location, 2) | |
| # bgl.glActiveTexture(bgl.GL_TEXTURE2) | |
| # bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture3) | |
| # bgl.glUniform1i(bgl.glGetUniformLocation(self.shader.program, "texture1"), 2) | |
| # bgl.glUniform1i(self.texture1_location, 3) | |
| # bgl.glActiveTexture(bgl.GL_TEXTURE3) | |
| # bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture4) | |
| # bgl.glUniform1i(bgl.glGetUniformLocation(self.shader.program, "texture1"), 3) | |
| # bgl.glUniform1i(bgl.glGetUniformLocation(self.shader.program, "texture1"), 0) | |
| # self.shader.uniform_int("texture1", 0) | |
| # self.shader.uniform_int("texture1", 64) | |
| # self.batch.draw(self.shader) | |
| # self.seq += 1 | |
| # self.shader.uniform_int("texture1", 1) | |
| # self.batch.draw(self.shader) | |
| # self.shader.uniform_int("texture1", 2) | |
| # self.batch.draw(self.shader) | |
| # self.shader.uniform_int("texture1", 3) | |
| # self.batch.draw(self.shader) | |
| # bgl.glActiveTexture(bgl.GL_TEXTURE2) | |
| # bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture3) | |
| # self.shader.bind() | |
| # self.shader.uniform_int("image", 0) | |
| # bgl.glActiveTexture(bgl.GL_TEXTURE3) | |
| # bgl.glBindTexture(bgl.GL_TEXTURE_2D, self.texture4) | |
| bgl.glBindVertexArray(self.vertex_array[0]) | |
| bgl.glDrawArrays(bgl.GL_TRIANGLE_FAN, 0, 4) | |
| bgl.glBindVertexArray(0) | |
| # | |
| self.engine.unbind_display_space_shader() | |
| err = bgl.glGetError() | |
| if err != bgl.GL_NO_ERROR: | |
| print("GL Error:", err) | |
| # if self._transparent: | |
| bgl.glDisable(bgl.GL_BLEND) | |
| @staticmethod | |
| def restore_opengl_defaults(): | |
| bgl.glLineWidth(1) | |
| bgl.glDisable(bgl.GL_BLEND) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment