Cleanup: replace attrib w/ attr
[blender.git] / source / blender / gpu / intern / gpu_state.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor(s): Ray Molenkamp
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/gpu/intern/gpu_state.c
24  *  \ingroup gpu
25  *
26  */
27
28 #include "DNA_userdef_types.h"
29
30 #include "GPU_glew.h"
31 #include "GPU_state.h"
32 #include "GPU_extensions.h"
33
34 static GLenum gpu_get_gl_blendfunction(eGPUBlendFunction blend)
35 {
36         switch (blend) {
37                 case GPU_ONE:
38                         return GL_ONE;
39                 case GPU_SRC_ALPHA:
40                         return GL_SRC_ALPHA;
41                 case GPU_ONE_MINUS_SRC_ALPHA:
42                         return GL_ONE_MINUS_SRC_ALPHA;
43                 case GPU_DST_COLOR:
44                         return GL_DST_COLOR;
45                 case GPU_ZERO:
46                         return GL_ZERO;
47                 default:
48                         BLI_assert(!"Unhandled blend mode");
49                         return GL_ZERO;
50         }
51 }
52
53 void GPU_blend(bool enable)
54 {
55         if (enable) {
56                 glEnable(GL_BLEND);
57         }
58         else {
59                 glDisable(GL_BLEND);
60         }
61 }
62
63 void GPU_blend_set_func(eGPUBlendFunction sfactor, eGPUBlendFunction dfactor)
64 {
65         glBlendFunc(gpu_get_gl_blendfunction(sfactor), gpu_get_gl_blendfunction(dfactor));
66 }
67
68 void GPU_blend_set_func_separate(
69         eGPUBlendFunction src_rgb, eGPUBlendFunction dst_rgb,
70         eGPUBlendFunction src_alpha, eGPUBlendFunction dst_alpha)
71 {
72         glBlendFuncSeparate(
73                 gpu_get_gl_blendfunction(src_rgb),
74                 gpu_get_gl_blendfunction(dst_rgb),
75                 gpu_get_gl_blendfunction(src_alpha),
76                 gpu_get_gl_blendfunction(dst_alpha));
77 }
78
79 void GPU_depth_range(float near, float far)
80 {
81         /* glDepthRangef is only for OpenGL 4.1 or higher */
82         glDepthRange(near, far);
83 }
84
85 void GPU_depth_test(bool enable)
86 {
87         if (enable) {
88                 glEnable(GL_DEPTH_TEST);
89         }
90         else {
91                 glDisable(GL_DEPTH_TEST);
92         }
93 }
94
95 bool GPU_depth_test_enabled()
96 {
97         return glIsEnabled(GL_DEPTH_TEST);
98 }
99
100 void GPU_line_smooth(bool enable)
101 {
102         if (enable) {
103                 glEnable(GL_LINE_SMOOTH);
104         }
105         else {
106                 glDisable(GL_LINE_SMOOTH);
107         }
108 }
109
110 void GPU_line_stipple(bool enable)
111 {
112         if (enable) {
113                 glEnable(GL_LINE_STIPPLE);
114         }
115         else {
116                 glDisable(GL_LINE_STIPPLE);
117         }
118 }
119
120 void GPU_line_width(float width)
121 {
122         float max_size = GPU_max_line_width();
123         float final_size = width * U.pixelsize;
124         /* Fix opengl errors on certain platform / drivers. */
125         CLAMP(final_size, 1.0f, max_size);
126         glLineWidth(final_size);
127 }
128
129 void GPU_point_size(float size)
130 {
131         glPointSize(size * U.pixelsize);
132 }
133
134 void GPU_polygon_smooth(bool enable)
135 {
136         if (enable) {
137                 glEnable(GL_POLYGON_SMOOTH);
138         }
139         else {
140                 glDisable(GL_POLYGON_SMOOTH);
141         }
142 }
143
144 void GPU_scissor(int x, int y, int width, int height)
145 {
146         glScissor(x, y, width, height);
147 }
148
149 void GPU_scissor_get_f(float coords[4])
150 {
151         glGetFloatv(GL_SCISSOR_BOX, coords);
152 }
153
154 void GPU_scissor_get_i(int coords[4])
155 {
156         glGetIntegerv(GL_SCISSOR_BOX, coords);
157 }
158
159 void GPU_viewport_size_get_f(float coords[4])
160 {
161         glGetFloatv(GL_VIEWPORT, coords);
162 }
163
164 void GPU_viewport_size_get_i(int coords[4])
165 {
166         glGetIntegerv(GL_VIEWPORT, coords);
167 }
168
169 void GPU_flush(void)
170 {
171         glFlush();
172 }
173
174 void GPU_finish(void)
175 {
176         glFinish();
177 }