]> git.sesse.net Git - movit/blob - widgets.cpp
529d902e878443c704ae5721a78aa1f4df40b34b
[movit] / widgets.cpp
1 #include <epoxy/gl.h>
2 #include <math.h>
3
4 #include "resource_pool.h"
5 #include "widgets.h"
6 #include "util.h"
7
8 #define HSV_WHEEL_SIZE 128
9
10 namespace movit {
11
12 GLuint hsv_wheel_texnum = 0;
13 GLuint textured_program_num = 0, colored_program_num = 0, hsv_vao = 0;
14 ResourcePool resource_pool;
15
16 void draw_black_point(float x, float y, float point_size)
17 {
18         glUseProgram(colored_program_num);
19         check_error();
20
21         float vertices[] = { x, y };
22         float colors[] = { 0.0f, 0.0f, 0.0f };
23
24         glPointSize(point_size);
25         check_error();
26         GLuint position_vbo = fill_vertex_attribute(colored_program_num, "position", 2, GL_FLOAT, sizeof(vertices), vertices);
27         GLuint color_vbo = fill_vertex_attribute(colored_program_num, "color", 3, GL_FLOAT, sizeof(colors), colors);
28         check_error();
29         glDrawArrays(GL_POINTS, 0, 1);
30         check_error();
31         cleanup_vertex_attribute(colored_program_num, "position", position_vbo);
32         cleanup_vertex_attribute(colored_program_num, "color", color_vbo);
33 }
34
35 void draw_hsv_wheel(float y, float rad, float theta, float value)
36 {
37         glUseProgram(textured_program_num);
38         check_error();
39         glActiveTexture(GL_TEXTURE0);
40         check_error();
41         glBindTexture(GL_TEXTURE_2D, hsv_wheel_texnum);
42         check_error();
43         glUniform1i(glGetUniformLocation(textured_program_num, "tex"), 0);  // Bind the 2D sampler.
44         check_error();
45         glEnable(GL_BLEND);
46         check_error();
47         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
48         check_error();
49
50         GLuint vao;
51         glGenVertexArrays(1, &vao);
52         check_error();
53         glBindVertexArray(vao);
54         check_error();
55
56         // wheel
57         float wheel_vertices[] = {
58                 0.0f, y,
59                 0.0f, y + 0.2f,
60                 0.2f * 9.0f / 16.0f, y,
61                 0.2f * 9.0f / 16.0f, y + 0.2f,
62         };
63         float wheel_texcoords[] = {
64                 0.0f, 1.0f,
65                 0.0f, 0.0f,
66                 1.0f, 1.0f,
67                 1.0f, 0.0f,
68         };
69         GLuint position_vbo = fill_vertex_attribute(textured_program_num, "position", 2, GL_FLOAT, sizeof(wheel_vertices), wheel_vertices);
70         GLuint texcoord_vbo = fill_vertex_attribute(textured_program_num, "texcoord", 2, GL_FLOAT, sizeof(wheel_texcoords), wheel_texcoords);
71         check_error();
72
73         glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
74         check_error();
75
76         cleanup_vertex_attribute(textured_program_num, "position", position_vbo);
77         cleanup_vertex_attribute(textured_program_num, "texcoord", texcoord_vbo);
78
79         // wheel selector
80         draw_black_point(
81             (0.1f + rad * cos(theta) * 0.1f) * 9.0f / 16.0f,
82             y + 0.1f - rad * sin(theta) * 0.1f,
83             5.0f);
84
85         // value slider
86         glUseProgram(colored_program_num);
87         float value_vertices[] = {
88                 0.22f * 9.0f / 16.0f, y,
89                 0.22f * 9.0f / 16.0f, y + 0.2f,
90                 0.24f * 9.0f / 16.0f, y,
91                 0.24f * 9.0f / 16.0f, y + 0.2f,
92         };
93         float value_colors[] = {
94                 0.0f, 0.0f, 0.0f,
95                 1.0f, 1.0f, 1.0f,
96                 0.0f, 0.0f, 0.0f,
97                 1.0f, 1.0f, 1.0f,
98         };
99         position_vbo = fill_vertex_attribute(colored_program_num, "position", 2, GL_FLOAT, sizeof(value_vertices), value_vertices);
100         GLuint color_vbo = fill_vertex_attribute(colored_program_num, "color", 3, GL_FLOAT, sizeof(value_colors), value_colors);
101         check_error();
102         glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
103         check_error();
104         cleanup_vertex_attribute(colored_program_num, "position", position_vbo);
105         cleanup_vertex_attribute(colored_program_num, "color", color_vbo);
106
107         // value selector
108         draw_black_point(0.23f * 9.0f / 16.0f, y + value * 0.2f, 5.0f);
109
110         glDeleteVertexArrays(1, &vao);
111         check_error();
112         glUseProgram(0);
113         check_error();
114 }
115
116 void draw_saturation_bar(float y, float saturation)
117 {
118         GLuint vao;
119         glGenVertexArrays(1, &vao);
120         check_error();
121         glBindVertexArray(vao);
122         check_error();
123
124         // value slider
125         glUseProgram(colored_program_num);
126         float value_vertices[] = {
127                 0.0f * 9.0f / 16.0f, y + 0.02f,
128                 0.2f * 9.0f / 16.0f, y + 0.02f,
129                 0.0f * 9.0f / 16.0f, y,
130                 0.2f * 9.0f / 16.0f, y,
131         };
132         float value_colors[] = {
133                 0.0f, 0.0f, 0.0f,
134                 1.0f, 1.0f, 1.0f,
135                 0.0f, 0.0f, 0.0f,
136                 1.0f, 1.0f, 1.0f,
137         };
138         GLuint position_vbo = fill_vertex_attribute(colored_program_num, "position", 2, GL_FLOAT, sizeof(value_vertices), value_vertices);
139         GLuint color_vbo = fill_vertex_attribute(colored_program_num, "color", 3, GL_FLOAT, sizeof(value_colors), value_colors);
140         check_error();
141         glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
142         check_error();
143         cleanup_vertex_attribute(colored_program_num, "position", position_vbo);
144         cleanup_vertex_attribute(colored_program_num, "color", color_vbo);
145
146         // value selector
147         draw_black_point(0.2f * saturation * 9.0f / 16.0f, y + 0.01f, 5.0f);
148
149         glDeleteVertexArrays(1, &vao);
150         check_error();
151         glUseProgram(0);
152         check_error();
153 }
154
155 void make_hsv_wheel_texture()
156 {
157         glGenTextures(1, &hsv_wheel_texnum);
158
159         static unsigned char hsv_pix[HSV_WHEEL_SIZE * HSV_WHEEL_SIZE * 4];
160         for (int y = 0; y < HSV_WHEEL_SIZE; ++y) {
161                 for (int x = 0; x < HSV_WHEEL_SIZE; ++x) {
162                         float yf = 2.0f * y / (float)(HSV_WHEEL_SIZE) - 1.0f;
163                         float xf = 2.0f * x / (float)(HSV_WHEEL_SIZE) - 1.0f;
164                         float rad = hypot(xf, yf);
165                         float theta = atan2(yf, xf);
166
167                         float r, g, b;
168                         hsv2rgb(theta, rad, 1.0f, &r, &g, &b);
169                         hsv_pix[(y * HSV_WHEEL_SIZE + x) * 4 + 0] = lrintf(r * 255.0f);
170                         hsv_pix[(y * HSV_WHEEL_SIZE + x) * 4 + 1] = lrintf(g * 255.0f);
171                         hsv_pix[(y * HSV_WHEEL_SIZE + x) * 4 + 2] = lrintf(b * 255.0f);
172
173                         if (rad > 1.0f) {
174                                 hsv_pix[(y * HSV_WHEEL_SIZE + x) * 4 + 3] = 0;
175                         } else {
176                                 hsv_pix[(y * HSV_WHEEL_SIZE + x) * 4 + 3] = 255;
177                         }
178                 }
179         }
180
181         glBindTexture(GL_TEXTURE_2D, hsv_wheel_texnum);
182         check_error();
183         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
184         check_error();
185         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, HSV_WHEEL_SIZE, HSV_WHEEL_SIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, hsv_pix);
186         check_error();
187 }
188
189 void init_hsv_resources()
190 {
191         textured_program_num = resource_pool.compile_glsl_program(
192                 read_version_dependent_file("vs", "vert"),
193                 read_version_dependent_file("texture1d", "frag"));
194         colored_program_num = resource_pool.compile_glsl_program(
195                 read_version_dependent_file("vs-color", "vert"),
196                 read_version_dependent_file("color", "frag"));
197         make_hsv_wheel_texture();
198 }
199
200 void cleanup_hsv_resources()
201 {
202         resource_pool.release_glsl_program(textured_program_num);
203         resource_pool.release_glsl_program(colored_program_num);
204 }
205
206 void read_colorwheel(float xf, float yf, float *rad, float *theta, float *value)
207 {
208         if (xf < 0.2f && yf < 0.2f) {
209                 float xp = 2.0f * xf / 0.2f - 1.0f;
210                 float yp = -(2.0f * yf / 0.2f - 1.0f);
211                 *rad = hypot(xp, yp);
212                 *theta = atan2(yp, xp);
213                 if (*rad > 1.0) {
214                         *rad = 1.0;
215                 }
216         } else if (xf >= 0.22f && xf <= 0.24f) {
217                 *value = yf / 0.2f;
218         }
219 }
220
221
222 }  // namespace movit