Merge branch 'master' into blender2.8
[blender.git] / intern / cycles / device / device_cuda.cpp
index 3a29538aa1353686301c0499629a902e575f41aa..e53aec0fbb97a61c1fd04a45bc0e1bce665b1906 100644 (file)
@@ -1632,10 +1632,14 @@ public:
                }
        }
 
-       void draw_pixels(device_memory& mem, int y, int w, int h, int dx, int dy, int width, int height, bool transparent,
+       void draw_pixels(
+           device_memory& mem, int y,
+           int w, int h, int width, int height,
+           int dx, int dy, int dw, int dh, bool transparent,
                const DeviceDrawParams &draw_params)
        {
                if(!background) {
+                       const bool use_fallback_shader = (draw_params.bind_display_space_shader_cb == NULL);
                        PixelMem pmem = pixel_mem_map[mem.device_pointer];
                        float *vpointer;
 
@@ -1652,10 +1656,12 @@ public:
 
                        glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pmem.cuPBO);
                        glBindTexture(GL_TEXTURE_2D, pmem.cuTexId);
-                       if(mem.data_type == TYPE_HALF)
+                       if(mem.data_type == TYPE_HALF) {
                                glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, GL_RGBA, GL_HALF_FLOAT, (void*)offset);
-                       else
+                       }
+                       else {
                                glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, (void*)offset);
+                       }
                        glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
 
                        glEnable(GL_TEXTURE_2D);
@@ -1665,14 +1671,21 @@ public:
                                glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
                        }
 
-                       glColor3f(1.0f, 1.0f, 1.0f);
-
-                       if(draw_params.bind_display_space_shader_cb) {
+                       GLint shader_program;
+                       if(use_fallback_shader) {
+                               if(!bind_fallback_display_space_shader(dw, dh)) {
+                                       return;
+                               }
+                               shader_program = fallback_shader_program;
+                       }
+                       else {
                                draw_params.bind_display_space_shader_cb();
+                               glGetIntegerv(GL_CURRENT_PROGRAM, &shader_program);
                        }
 
-                       if(!vertex_buffer)
+                       if(!vertex_buffer) {
                                glGenBuffers(1, &vertex_buffer);
+                       }
 
                        glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
                        /* invalidate old contents - avoids stalling if buffer is still waiting in queue to be rendered */
@@ -1705,25 +1718,33 @@ public:
                                glUnmapBuffer(GL_ARRAY_BUFFER);
                        }
 
-                       glTexCoordPointer(2, GL_FLOAT, 4 * sizeof(float), 0);
-                       glVertexPointer(2, GL_FLOAT, 4 * sizeof(float), (char *)NULL + 2 * sizeof(float));
+                       GLuint vertex_array_object;
+                       GLuint position_attribute, texcoord_attribute;
 
-                       glEnableClientState(GL_VERTEX_ARRAY);
-                       glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+                       glGenVertexArrays(1, &vertex_array_object);
+                       glBindVertexArray(vertex_array_object);
 
-                       glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+                       texcoord_attribute = glGetAttribLocation(shader_program, "texCoord");
+                       position_attribute = glGetAttribLocation(shader_program, "pos");
 
-                       glDisableClientState(GL_TEXTURE_COORD_ARRAY);
-                       glDisableClientState(GL_VERTEX_ARRAY);
+                       glEnableVertexAttribArray(texcoord_attribute);
+                       glEnableVertexAttribArray(position_attribute);
 
-                       glBindBuffer(GL_ARRAY_BUFFER, 0);
+                       glVertexAttribPointer(texcoord_attribute, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (const GLvoid *)0);
+                       glVertexAttribPointer(position_attribute, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (const GLvoid *)(sizeof(float) * 2));
+
+                       glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
-                       if(draw_params.unbind_display_space_shader_cb) {
+                       if(use_fallback_shader) {
+                               glUseProgram(0);
+                       }
+                       else {
                                draw_params.unbind_display_space_shader_cb();
                        }
 
-                       if(transparent)
+                       if(transparent) {
                                glDisable(GL_BLEND);
+                       }
 
                        glBindTexture(GL_TEXTURE_2D, 0);
                        glDisable(GL_TEXTURE_2D);
@@ -1733,7 +1754,7 @@ public:
                        return;
                }
 
-               Device::draw_pixels(mem, y, w, h, dx, dy, width, height, transparent, draw_params);
+               Device::draw_pixels(mem, y, w, h, width, height, dx, dy, dw, dh, transparent, draw_params);
        }
 
        void thread_run(DeviceTask *task)