Changeset 8928:9a36fbc5a66e in orange


Ignore:
Timestamp:
09/09/11 01:03:36 (3 years ago)
Author:
matejd <matejd@…>
Branch:
default
Convert:
347911c5608b392db454d9ba9a1eae832d5261d7
Message:

Moved shaders to their own files; applied VertexBuffer several times; removed cones from LinProj3D

Location:
orange/OrangeWidgets
Files:
8 added
4 edited

Legend:

Unmodified
Added
Removed
  • orange/OrangeWidgets/Visualize Qt/OWLinProj3DPlot.py

    r8922 r8928  
     1import os 
     2 
    13from plot.owplot3d import * 
    2 from plot.primitives import parse_obj 
     4from plot.owopenglrenderer import VertexBuffer 
    35from plot import OWPoint 
    46 
     
    3638            self.mouseover_callback = self._update_arrow_values 
    3739 
    38     def setData(self, data, subsetData=None, **args): 
     40    def set_data(self, data, subsetData=None, **args): 
    3941        if data == None: 
    4042            return 
     
    4244        OWPlot3D.initializeGL(self) 
    4345 
    44         if hasattr(self, 'cone_vao_id'): 
     46        if hasattr(self, '_value_lines_shader'): 
    4547            return 
    4648 
     
    4850        self.before_draw_callback = lambda: self.before_draw() 
    4951 
    50         cone_data = parse_obj('cone_hq.obj') 
    51         vertices = [] 
    52         for v0, v1, v2, n0, n1, n2 in cone_data: 
    53             vertices.extend([v0[0],v0[1],v0[2], n0[0],n0[1],n0[2], 
    54                              v1[0],v1[1],v1[2], n1[0],n1[1],n1[2], 
    55                              v2[0],v2[1],v2[2], n2[0],n2[1],n2[2]]) 
    56  
    57         self.cone_vao_id = GLuint(0) 
    58         glGenVertexArrays(1, self.cone_vao_id) 
    59         glBindVertexArray(self.cone_vao_id) 
    60  
    61         vertex_buffer_id = glGenBuffers(1) 
    62         glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_id) 
    63         glBufferData(GL_ARRAY_BUFFER, numpy.array(vertices, 'f'), GL_STATIC_DRAW) 
    64  
    65         vertex_size = (3+3)*4 
    66         glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, vertex_size, c_void_p(0)) 
    67         glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, vertex_size, c_void_p(3*4)) 
    68         glEnableVertexAttribArray(0) 
    69         glEnableVertexAttribArray(1) 
    70  
    71         glBindVertexArray(0) 
    72         glBindBuffer(GL_ARRAY_BUFFER, 0) 
    73  
    74         self.cone_vao_id.num_vertices = len(vertices) / (vertex_size / 4) 
    75  
    76         vertex_shader_source = ''' 
    77             in vec3 position; 
    78             in vec3 normal; 
    79  
    80             varying vec4 color; 
    81  
    82             uniform mat4 projection; 
    83             uniform mat4 modelview; 
    84  
    85             const vec3 light_direction = normalize(vec3(-0.7, 0.42, 0.21)); 
    86  
    87             void main(void) 
    88             { 
    89                 gl_Position = projection * modelview * vec4(position, 1.); 
    90                 float diffuse = clamp(dot(light_direction, normalize((modelview * vec4(normal, 0.)).xyz)), 0., 1.); 
    91                 color = vec4(vec3(1., 1., 1.) * diffuse + 0.1, 1.); 
    92             } 
    93             ''' 
    94  
    95         fragment_shader_source = ''' 
    96             varying vec4 color; 
    97  
    98             void main(void) 
    99             { 
    100                 gl_FragColor = color; 
    101             } 
    102             ''' 
    103  
    104         self.cone_shader = QtOpenGL.QGLShaderProgram() 
    105         self.cone_shader.addShaderFromSourceCode(QtOpenGL.QGLShader.Vertex, vertex_shader_source) 
    106         self.cone_shader.addShaderFromSourceCode(QtOpenGL.QGLShader.Fragment, fragment_shader_source) 
    107  
    108         self.cone_shader.bindAttributeLocation('position', 0) 
    109         self.cone_shader.bindAttributeLocation('normal', 1) 
    110  
    111         if not self.cone_shader.link(): 
    112             print('Failed to link cone shader!') 
    113  
    11452        ## Value lines shader 
    115         vertex_shader_source = ''' 
    116             in vec3 position; 
    117             in vec3 color; 
    118             in vec3 normal; 
    119  
    120             varying vec4 var_color; 
    121  
    122             uniform mat4 projection; 
    123             uniform mat4 modelview; 
    124             uniform float value_line_length; 
    125             uniform vec3 plot_scale; 
    126  
    127             void main(void) 
    128             { 
    129                 gl_Position = projection * modelview * vec4(position*plot_scale + normal*value_line_length, 1.); 
    130                 var_color = vec4(color, 1.); 
    131             } 
    132             ''' 
    133  
    134         fragment_shader_source = ''' 
    135             varying vec4 var_color; 
    136  
    137             void main(void) 
    138             { 
    139                 gl_FragColor = var_color; 
    140             } 
    141             ''' 
    142  
    143         self.value_lines_shader = QtOpenGL.QGLShaderProgram() 
    144         self.value_lines_shader.addShaderFromSourceCode(QtOpenGL.QGLShader.Vertex, vertex_shader_source) 
    145         self.value_lines_shader.addShaderFromSourceCode(QtOpenGL.QGLShader.Fragment, fragment_shader_source) 
    146  
    147         self.value_lines_shader.bindAttributeLocation('position', 0) 
    148         self.value_lines_shader.bindAttributeLocation('color', 1) 
    149         self.value_lines_shader.bindAttributeLocation('normal', 2) 
    150  
    151         if not self.value_lines_shader.link(): 
     53        self._value_lines_shader = QtOpenGL.QGLShaderProgram() 
     54        self._value_lines_shader.addShaderFromSourceFile(QtOpenGL.QGLShader.Vertex, 
     55            os.path.join(os.path.dirname(__file__), 'value-lines.vs')) 
     56        self._value_lines_shader.addShaderFromSourceFile(QtOpenGL.QGLShader.Fragment, 
     57            os.path.join(os.path.dirname(__file__), 'value-lines.fs')) 
     58 
     59        self._value_lines_shader.bindAttributeLocation('position', 0) 
     60        self._value_lines_shader.bindAttributeLocation('color', 1) 
     61        self._value_lines_shader.bindAttributeLocation('normal', 2) 
     62 
     63        if not self._value_lines_shader.link(): 
    15264            print('Failed to link value-lines shader!') 
    15365 
    154     set_data = setData 
     66    setData = set_data  
    15567 
    15668    def before_draw(self): 
     
    17991                x, y, z, label = anchor 
    18092 
    181                 direction = QVector3D(x, y, z).normalized() 
    182                 up = QVector3D(0, 1, 0) 
    183                 right = QVector3D.crossProduct(direction, up).normalized() 
    184                 up = QVector3D.crossProduct(right, direction).normalized() 
    185                 rotation = QMatrix4x4() 
    186                 rotation.setColumn(0, QVector4D(right, 0)) 
    187                 rotation.setColumn(1, QVector4D(up, 0)) 
    188                 rotation.setColumn(2, QVector4D(direction, 0)) 
    189  
    190                 self.cone_shader.bind() 
    191                 self.cone_shader.setUniformValue('projection', self.projection) 
    192                 modelview = QMatrix4x4(self.modelview) 
    193                 modelview.translate(x, y, z) 
    194                 modelview = modelview * rotation 
    195                 modelview.rotate(-90, 1, 0, 0) 
    196                 modelview.translate(0, -0.02, 0) 
    197                 modelview.scale(-0.02, -0.02, -0.02) 
    198                 self.cone_shader.setUniformValue('modelview', modelview) 
    199  
    20093                glDepthMask(GL_TRUE) 
    201                 glBindVertexArray(self.cone_vao_id) 
    202                 glDrawArrays(GL_TRIANGLES, 0, self.cone_vao_id.num_vertices) 
    203                 glBindVertexArray(0) 
    204  
    205                 self.cone_shader.release() 
    206  
    207                 glDepthMask(GL_FALSE) 
    20894                self.qglColor(self._theme.axis_values_color) 
    20995                self.renderText(x*1.2, y*1.2, z*1.2, label) 
    21096 
     97                glDepthMask(GL_FALSE) 
    21198                self.renderer.draw_line( 
    21299                    QVector3D(0, 0, 0), 
     
    239126    def _draw_value_lines(self): 
    240127        if self.showValueLines: 
    241             self.value_lines_shader.bind() 
    242             self.value_lines_shader.setUniformValue('projection', self.projection) 
    243             self.value_lines_shader.setUniformValue('modelview', self.modelview) 
    244             self.value_lines_shader.setUniformValue('value_line_length', float(self.valueLineLength)) 
    245             self.value_lines_shader.setUniformValue('plot_scale', self.plot_scale[0], self.plot_scale[1], self.plot_scale[2]) 
    246  
    247             glBindVertexArray(self.value_lines_vao) 
    248             glDrawArrays(GL_LINES, 0, self.value_lines_vao.num_vertices) 
    249             glBindVertexArray(0) 
    250  
    251             self.value_lines_shader.release() 
     128            self._value_lines_shader.bind() 
     129            self._value_lines_shader.setUniformValue('projection', self.projection) 
     130            self._value_lines_shader.setUniformValue('modelview', self.modelview) 
     131            self._value_lines_shader.setUniformValue('value_line_length', float(self.valueLineLength)) 
     132            self._value_lines_shader.setUniformValue('plot_scale', self.plot_scale[0], self.plot_scale[1], self.plot_scale[2]) 
     133            self._value_lines_buffer.draw(GL_LINES) 
     134            self._value_lines_shader.release() 
    252135 
    253136    def updateData(self, labels=None, setAnchors=0, **args): 
    254137        self.clear() 
    255138        self.clear_plot_transformations() 
    256         self.value_lines = [] 
    257139 
    258140        if labels == None: 
     
    348230        data_size = len(self.raw_data) 
    349231 
     232        value_lines = [] 
    350233        for i in range(data_size): 
    351234            if not valid_data[i]: 
     
    367250 
    368251            for j in range(len_anchor_data): 
    369                 self.value_lines.extend([x_positions[i], y_positions[i], z_positions[i], 
    370                                          color[0]/255., 
    371                                          color[1]/255., 
    372                                          color[2]/255., 
    373                                          0., 0., 0., 
    374                                          x_positions[i], y_positions[i], z_positions[i], 
    375                                          color[0]/255., 
    376                                          color[1]/255., 
    377                                          color[2]/255., 
    378                                          x_directions[j]*example_values[j], 
    379                                          y_directions[j]*example_values[j], 
    380                                          z_directions[j]*example_values[j]]) 
    381  
    382         self.value_lines_vao = GLuint(0) 
    383         glGenVertexArrays(1, self.value_lines_vao) 
    384         glBindVertexArray(self.value_lines_vao) 
    385  
    386         vertex_buffer_id = glGenBuffers(1) 
    387         glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_id) 
    388         glBufferData(GL_ARRAY_BUFFER, numpy.array(self.value_lines, 'f'), GL_STATIC_DRAW) 
    389  
    390         vertex_size = (3+3+3)*4 
    391         glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, vertex_size, c_void_p(0)) 
    392         glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, vertex_size, c_void_p(3*4)) 
    393         glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, vertex_size, c_void_p(6*4)) 
    394         glEnableVertexAttribArray(0) 
    395         glEnableVertexAttribArray(1) 
    396         glEnableVertexAttribArray(2) 
    397  
    398         glBindVertexArray(0) 
    399         glBindBuffer(GL_ARRAY_BUFFER, 0) 
    400  
    401         self.value_lines_vao.num_vertices = len(self.value_lines) / (vertex_size / 4) 
     252                value_lines.extend([x_positions[i], y_positions[i], z_positions[i], 
     253                                    color[0]/255., 
     254                                    color[1]/255., 
     255                                    color[2]/255., 
     256                                    0., 0., 0., 
     257                                    x_positions[i], y_positions[i], z_positions[i], 
     258                                    color[0]/255., 
     259                                    color[1]/255., 
     260                                    color[2]/255., 
     261                                    x_directions[j]*example_values[j], 
     262                                    y_directions[j]*example_values[j], 
     263                                    z_directions[j]*example_values[j]]) 
     264 
     265        self._value_lines_buffer = VertexBuffer(numpy.array(value_lines, numpy.float32), 
     266            [(3, GL_FLOAT), 
     267             (3, GL_FLOAT), 
     268             (3, GL_FLOAT)]) 
    402269 
    403270        self.update() 
     
    468335                    unselected[unselected_index][y_attr] = array[i][1] 
    469336                    unselected[unselected_index][z_attr] = array[i][2] 
    470                     unselIndex += 1 
    471337        else: 
    472338            selected = self.raw_data.selectref(selected_indices) 
  • orange/OrangeWidgets/Visualize Qt/OWScatterPlot3D.py

    r8927 r8928  
    119119        self.before_draw_callback = self.before_draw 
    120120 
    121         color_discrete = symbol_discrete = size_discrete = False 
     121        color_discrete = size_discrete = False 
    122122 
    123123        color_index = -1 
  • orange/OrangeWidgets/Visualize Qt/OWSphereviz3D.py

    r8847 r8928  
    55''' 
    66 
     7import os 
    78from math import pi 
    89from random import choice 
    910 
    1011from plot.owplot3d import * 
     12from plot.owopenglrenderer import VertexBuffer 
    1113from plot.primitives import parse_obj 
    1214from OWLinProjQt import * 
     
    3941                    lines.extend(normalize(a0 + difference*(j+1)/float(num_parts))) 
    4042 
    41         self.grid_vao_id = GLuint(0) 
    42         glGenVertexArrays(1, self.grid_vao_id) 
    43         glBindVertexArray(self.grid_vao_id) 
    44  
    45         vertex_buffer_id = glGenBuffers(1) 
    46         glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_id) 
    47         glBufferData(GL_ARRAY_BUFFER, numpy.array(lines, numpy.float32), GL_STATIC_DRAW) 
    48  
    49         vertex_size = 3*4 
    50         glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, vertex_size, c_void_p(0)) 
    51         glEnableVertexAttribArray(0) 
    52         glBindVertexArray(0) 
    53         glBindBuffer(GL_ARRAY_BUFFER, 0) 
    54  
    55         self.grid_vao_id.num_vertices = len(lines) / 3 
    56  
    57     def updateData(self, labels=None, setAnchors=0, **args): 
     43        self._grid_buffer = VertexBuffer(numpy.array(lines, numpy.float32), [(3, GL_FLOAT)]) 
     44 
     45    def update_data(self, labels=None, setAnchors=0, **args): 
    5846        OWLinProj3DPlot.updateData(self, labels, setAnchors, **args) 
    5947 
     
    6351        self.updateGL() 
    6452 
     53    updateData = update_data 
     54 
    6555    def setData(self, data, subsetData=None, **args): 
    66         OWLinProj3DPlot.setData(self, data, subsetData, **args) 
     56        OWLinProj3DPlot.set_data(self, data, subsetData, **args) 
    6757 
    6858        # No need to generate backgroud grid sphere geometry more than once 
    69         if hasattr(self, 'sphere_vao_id'): 
     59        if hasattr(self, '_sphere_buffer'): 
    7060            return 
     61 
     62        self.makeCurrent() 
    7163 
    7264        lines = [] 
     
    9486                              sin(theta_1)*cos(phi)*r, cos(theta_1)*r, sin(theta_1)*sin(phi)*r]) 
    9587 
    96         self.sphere_vao_id = GLuint(0) 
    97         glGenVertexArrays(1, self.sphere_vao_id) 
    98         glBindVertexArray(self.sphere_vao_id) 
    99  
    100         vertex_buffer_id = glGenBuffers(1) 
    101         glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_id) 
    102         glBufferData(GL_ARRAY_BUFFER, numpy.array(lines, numpy.float32), GL_STATIC_DRAW) 
    103  
    104         vertex_size = 3*4 
    105         glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, vertex_size, c_void_p(0)) 
    106         glEnableVertexAttribArray(0) 
    107         glBindVertexArray(0) 
    108         glBindBuffer(GL_ARRAY_BUFFER, 0) 
    109  
    110         self.sphere_vao_id.num_vertices = len(lines) / 3 
    111  
    112         vertex_shader_source = '''#version 150 
    113             in vec3 position; 
    114             varying float transparency; 
    115  
    116             uniform mat4 projection; 
    117             uniform mat4 modelview; 
    118             uniform vec3 cam_position; 
    119  
    120             void main(void) 
    121             { 
    122                 transparency = clamp(dot(normalize(cam_position-position), normalize(position)), 0., 1.); 
    123                 gl_Position = projection * modelview * vec4(position, 1.); 
    124             } 
    125             ''' 
    126  
    127         fragment_shader_source = ''' 
    128             varying float transparency; 
    129             uniform bool use_transparency; 
    130  
    131             void main(void) 
    132             { 
    133                 gl_FragColor = vec4(0.5, 0.5, 0.5, 1. - transparency - 0.6); 
    134                 if (!use_transparency) 
    135                     gl_FragColor.a = 1.; 
    136             } 
    137             ''' 
    138  
    139         self.sphere_shader = QtOpenGL.QGLShaderProgram() 
    140         self.sphere_shader.addShaderFromSourceCode(QtOpenGL.QGLShader.Vertex, vertex_shader_source) 
    141         self.sphere_shader.addShaderFromSourceCode(QtOpenGL.QGLShader.Fragment, fragment_shader_source) 
    142  
    143         self.sphere_shader.bindAttributeLocation('position', 0) 
    144  
    145         if not self.sphere_shader.link(): 
     88        self._sphere_buffer = VertexBuffer(numpy.array(lines, numpy.float32), [(3, GL_FLOAT)]) 
     89 
     90        self._sphere_shader = QtOpenGL.QGLShaderProgram() 
     91        self._sphere_shader.addShaderFromSourceFile(QtOpenGL.QGLShader.Vertex, 
     92            os.path.join(os.path.dirname(__file__), 'sphere.vs')) 
     93        self._sphere_shader.addShaderFromSourceFile(QtOpenGL.QGLShader.Fragment, 
     94            os.path.join(os.path.dirname(__file__), 'sphere.fs')) 
     95 
     96        self._sphere_shader.bindAttributeLocation('position', 0) 
     97 
     98        if not self._sphere_shader.link(): 
    14699            print('Failed to link sphere shader!') 
    147100 
    148         # Another dummy shader (anchor grid) 
    149         vertex_shader_source = '''#version 150 
    150             in vec3 position; 
    151  
    152             uniform mat4 projection; 
    153             uniform mat4 modelview; 
    154  
    155             void main(void) 
    156             { 
    157                 gl_Position = projection * modelview * vec4(position, 1.); 
    158             } 
    159             ''' 
    160  
    161         fragment_shader_source = ''' 
    162             uniform vec4 color; 
    163  
    164             void main(void) 
    165             { 
    166                 gl_FragColor = color; 
    167             } 
    168             ''' 
    169  
    170         self.grid_shader = QtOpenGL.QGLShaderProgram() 
    171         self.grid_shader.addShaderFromSourceCode(QtOpenGL.QGLShader.Vertex, vertex_shader_source) 
    172         self.grid_shader.addShaderFromSourceCode(QtOpenGL.QGLShader.Fragment, fragment_shader_source) 
    173  
    174         self.grid_shader.bindAttributeLocation('position', 0) 
    175  
    176         if not self.grid_shader.link(): 
     101        ## Cones 
     102        cone_data = parse_obj('cone_hq.obj') 
     103        vertices = [] 
     104        for v0, v1, v2, n0, n1, n2 in cone_data: 
     105            vertices.extend([v0[0],v0[1],v0[2], n0[0],n0[1],n0[2], 
     106                             v1[0],v1[1],v1[2], n1[0],n1[1],n1[2], 
     107                             v2[0],v2[1],v2[2], n2[0],n2[1],n2[2]]) 
     108 
     109        self._cone_buffer = VertexBuffer(numpy.array(vertices, numpy.float32), 
     110            [(3, GL_FLOAT), 
     111             (3, GL_FLOAT)]) 
     112 
     113        self._cone_shader = QtOpenGL.QGLShaderProgram() 
     114        self._cone_shader.addShaderFromSourceFile(QtOpenGL.QGLShader.Vertex, 
     115            os.path.join(os.path.dirname(__file__), 'cone.vs')) 
     116        self._cone_shader.addShaderFromSourceFile(QtOpenGL.QGLShader.Fragment, 
     117            os.path.join(os.path.dirname(__file__), 'cone.fs')) 
     118 
     119        self._cone_shader.bindAttributeLocation('position', 0) 
     120        self._cone_shader.bindAttributeLocation('normal', 1) 
     121 
     122        if not self._cone_shader.link(): 
     123            print('Failed to link cone shader!') 
     124 
     125        ## Another dummy shader (anchor grid) 
     126        self._grid_shader = QtOpenGL.QGLShaderProgram() 
     127        self._grid_shader.addShaderFromSourceFile(QtOpenGL.QGLShader.Vertex, 
     128            os.path.join(os.path.dirname(__file__), 'grid.vs')) 
     129        self._grid_shader.addShaderFromSourceFile(QtOpenGL.QGLShader.Fragment, 
     130            os.path.join(os.path.dirname(__file__), 'grid.fs')) 
     131 
     132        self._grid_shader.bindAttributeLocation('position', 0) 
     133 
     134        if not self._grid_shader.link(): 
    177135            print('Failed to link grid shader!') 
    178136 
     
    217175        self.modelview = modelview 
    218176 
    219         self.draw_sphere() 
     177        self._draw_sphere() 
    220178 
    221179        # Qt text rendering classes still use deprecated OpenGL functionality 
     
    242200                rotation.setColumn(2, QVector4D(direction, 0)) 
    243201 
    244                 self.cone_shader.bind() 
    245                 self.cone_shader.setUniformValue('projection', self.projection) 
    246202                modelview = QMatrix4x4(self.modelview) 
    247203                modelview.translate(x, y, z) 
     
    250206                modelview.translate(0, -0.05, 0) 
    251207                modelview.scale(0.02, 0.02, 0.02) 
    252                 self.cone_shader.setUniformValue('modelview', modelview) 
    253  
    254                 glBindVertexArray(self.cone_vao_id) 
    255                 glDrawArrays(GL_TRIANGLES, 0, self.cone_vao_id.num_vertices) 
    256                 glBindVertexArray(0) 
    257  
    258                 self.cone_shader.release() 
     208 
     209                self._cone_shader.bind() 
     210                self._cone_shader.setUniformValue('projection', self.projection) 
     211                self._cone_shader.setUniformValue('modelview', modelview) 
     212                self._cone_buffer.draw() 
     213                self._cone_shader.release() 
    259214 
    260215                self.qglColor(self._theme.axis_values_color) 
    261216                self.renderText(x*1.2, y*1.2, z*1.2, label) 
    262217 
    263             if self.anchor_data and not hasattr(self, 'grid_vao_id'): 
     218            if self.anchor_data and not hasattr(self, '_grid_buffer'): 
    264219                self._build_anchor_grid() 
    265220 
    266221            # Draw grid between anchors 
    267             self.grid_shader.bind() 
    268             self.grid_shader.setUniformValue('projection', self.projection) 
    269             self.grid_shader.setUniformValue('modelview', self.modelview) 
    270             self.grid_shader.setUniformValue('color', self._theme.axis_color) 
    271             glBindVertexArray(self.grid_vao_id) 
    272  
    273             glDrawArrays(GL_LINES, 0, self.grid_vao_id.num_vertices) 
    274  
    275             glBindVertexArray(0) 
    276             self.grid_shader.release() 
     222            self._grid_shader.bind() 
     223            self._grid_shader.setUniformValue('projection', self.projection) 
     224            self._grid_shader.setUniformValue('modelview', self.modelview) 
     225            self._grid_shader.setUniformValue('color', self._theme.axis_color) 
     226            self._grid_buffer.draw(GL_LINES) 
     227            self._grid_shader.release() 
    277228 
    278229        self._draw_value_lines() 
    279230 
    280     def draw_sphere(self): 
     231    def _draw_sphere(self): 
    281232        glDisable(GL_DEPTH_TEST) 
    282233        glEnable(GL_BLEND) 
    283234        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) 
    284235 
    285         self.sphere_shader.bind() 
    286         self.sphere_shader.setUniformValue('projection', self.projection) 
    287         self.sphere_shader.setUniformValue('modelview', self.modelview) 
    288         self.sphere_shader.setUniformValue('cam_position', QVector3D(*self.camera)*self.camera_distance) 
    289         self.sphere_shader.setUniformValue('use_transparency', self.camera_type == 0) 
    290         glBindVertexArray(self.sphere_vao_id) 
    291  
    292         glDrawArrays(GL_LINES, 0, self.sphere_vao_id.num_vertices) 
    293  
    294         glBindVertexArray(0) 
    295         self.sphere_shader.release() 
     236        self._sphere_shader.bind() 
     237        self._sphere_shader.setUniformValue('projection', self.projection) 
     238        self._sphere_shader.setUniformValue('modelview', self.modelview) 
     239        self._sphere_shader.setUniformValue('cam_position', QVector3D(*self.camera)*self.camera_distance) 
     240        self._sphere_shader.setUniformValue('use_transparency', self.camera_type == 0) 
     241        self._sphere_buffer.draw(GL_LINES) 
     242        self._sphere_shader.release() 
    296243 
    297244    def mouseMoveEvent(self, event): 
  • orange/OrangeWidgets/plot/owopenglrenderer.py

    r8856 r8928  
    1 from ctypes import c_void_p, c_char, c_char_p, POINTER 
     1from ctypes import c_void_p 
    22 
    33from PyQt4.QtCore import * 
     
    3535 
    3636            vertex_size = sum(attribute[0]*4 for attribute in format_description) 
     37            self._num_vertices = len(data) / (vertex_size / 4) 
    3738            current_size = 0 
    3839            for i, (num_components, type) in enumerate(format_description): 
     
    4748            glBindBuffer(GL_ARRAY_BUFFER, self._vbo_id) 
    4849            glBufferData(GL_ARRAY_BUFFER, data, usage) 
     50            self._data_length = len(data) 
    4951            glBindBuffer(GL_ARRAY_BUFFER, 0) 
    5052 
    51     def draw(self, primitives, first, count): 
     53    def draw(self, primitives=GL_TRIANGLES, first=0, count=-1): 
    5254        '''glDrawArrays''' 
    5355        if hasattr(self, '_vao'): 
    5456            glBindVertexArray(self._vao) 
    55             glDrawArrays(primitives, first, count) 
     57            glDrawArrays(primitives, first, 
     58                count if count != -1 else self._num_vertices - first) 
    5659            glBindVertexArray(0) 
    5760        else: 
     
    6568                current_size += num_components*4 
    6669 
    67             glDrawArrays(primitives, first, count) 
     70            glDrawArrays(primitives, first, 
     71                count if count != -1 else self._data_length / (vertex_size / 4) - first) 
     72 
    6873            for i in range(len(self._format_description)): 
    6974                glDisableVertexAttribArray(i) 
     
    7580       (through glDrawArrays for example) should be used instead. This class simplifies 
    7681       the usage of that functionality by providing methods which resemble immediate mode.''' 
     82 
     83    # TODO: research performance optimizations (maybe store primitives and all of them just once at the end?) 
     84 
    7785    def __init__(self): 
    7886        self._projection = QMatrix4x4() 
     
    8189        ## Shader used to draw primitives. Position and color of vertices specified through uniforms. Nothing fancy. 
    8290        vertex_shader_source = ''' 
    83             in float index; 
     91            attribute float index; 
    8492            varying vec4 color; 
    8593 
     
    99107 
    100108        fragment_shader_source = ''' 
    101             in vec4 color; 
     109            varying vec4 color; 
    102110 
    103111            void main(void) 
Note: See TracChangeset for help on using the changeset viewer.