1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // This file is auto-generated from
6 // gpu/command_buffer/build_gles2_cmd_buffer.py
7 // It's formatted by clang-format using chromium coding style:
8 // clang-format -i -style=chromium filename
9 // DO NOT EDIT!
10
11 // It is included by context_state.cc
12 #ifndef GPU_COMMAND_BUFFER_SERVICE_CONTEXT_STATE_IMPL_AUTOGEN_H_
13 #define GPU_COMMAND_BUFFER_SERVICE_CONTEXT_STATE_IMPL_AUTOGEN_H_
14
EnableFlags()15 ContextState::EnableFlags::EnableFlags()
16 : blend(false),
17 cached_blend(false),
18 cull_face(false),
19 cached_cull_face(false),
20 depth_test(false),
21 cached_depth_test(false),
22 dither(true),
23 cached_dither(true),
24 polygon_offset_fill(false),
25 cached_polygon_offset_fill(false),
26 sample_alpha_to_coverage(false),
27 cached_sample_alpha_to_coverage(false),
28 sample_coverage(false),
29 cached_sample_coverage(false),
30 scissor_test(false),
31 cached_scissor_test(false),
32 stencil_test(false),
33 cached_stencil_test(false) {
34 }
35
Initialize()36 void ContextState::Initialize() {
37 blend_color_red = 0.0f;
38 blend_color_green = 0.0f;
39 blend_color_blue = 0.0f;
40 blend_color_alpha = 0.0f;
41 blend_equation_rgb = GL_FUNC_ADD;
42 blend_equation_alpha = GL_FUNC_ADD;
43 blend_source_rgb = GL_ONE;
44 blend_dest_rgb = GL_ZERO;
45 blend_source_alpha = GL_ONE;
46 blend_dest_alpha = GL_ZERO;
47 color_clear_red = 0.0f;
48 color_clear_green = 0.0f;
49 color_clear_blue = 0.0f;
50 color_clear_alpha = 0.0f;
51 depth_clear = 1.0f;
52 stencil_clear = 0;
53 color_mask_red = true;
54 cached_color_mask_red = true;
55 color_mask_green = true;
56 cached_color_mask_green = true;
57 color_mask_blue = true;
58 cached_color_mask_blue = true;
59 color_mask_alpha = true;
60 cached_color_mask_alpha = true;
61 cull_mode = GL_BACK;
62 depth_func = GL_LESS;
63 depth_mask = true;
64 cached_depth_mask = true;
65 z_near = 0.0f;
66 z_far = 1.0f;
67 front_face = GL_CCW;
68 hint_generate_mipmap = GL_DONT_CARE;
69 hint_fragment_shader_derivative = GL_DONT_CARE;
70 line_width = 1.0f;
71 pack_alignment = 4;
72 unpack_alignment = 4;
73 polygon_offset_factor = 0.0f;
74 polygon_offset_units = 0.0f;
75 sample_coverage_value = 1.0f;
76 sample_coverage_invert = false;
77 scissor_x = 0;
78 scissor_y = 0;
79 scissor_width = 1;
80 scissor_height = 1;
81 stencil_front_func = GL_ALWAYS;
82 stencil_front_ref = 0;
83 stencil_front_mask = 0xFFFFFFFFU;
84 stencil_back_func = GL_ALWAYS;
85 stencil_back_ref = 0;
86 stencil_back_mask = 0xFFFFFFFFU;
87 stencil_front_writemask = 0xFFFFFFFFU;
88 cached_stencil_front_writemask = 0xFFFFFFFFU;
89 stencil_back_writemask = 0xFFFFFFFFU;
90 cached_stencil_back_writemask = 0xFFFFFFFFU;
91 stencil_front_fail_op = GL_KEEP;
92 stencil_front_z_fail_op = GL_KEEP;
93 stencil_front_z_pass_op = GL_KEEP;
94 stencil_back_fail_op = GL_KEEP;
95 stencil_back_z_fail_op = GL_KEEP;
96 stencil_back_z_pass_op = GL_KEEP;
97 viewport_x = 0;
98 viewport_y = 0;
99 viewport_width = 1;
100 viewport_height = 1;
101 }
102
InitCapabilities(const ContextState * prev_state)103 void ContextState::InitCapabilities(const ContextState* prev_state) const {
104 if (prev_state) {
105 if (prev_state->enable_flags.cached_blend != enable_flags.cached_blend)
106 EnableDisable(GL_BLEND, enable_flags.cached_blend);
107 if (prev_state->enable_flags.cached_cull_face !=
108 enable_flags.cached_cull_face)
109 EnableDisable(GL_CULL_FACE, enable_flags.cached_cull_face);
110 if (prev_state->enable_flags.cached_depth_test !=
111 enable_flags.cached_depth_test)
112 EnableDisable(GL_DEPTH_TEST, enable_flags.cached_depth_test);
113 if (prev_state->enable_flags.cached_dither != enable_flags.cached_dither)
114 EnableDisable(GL_DITHER, enable_flags.cached_dither);
115 if (prev_state->enable_flags.cached_polygon_offset_fill !=
116 enable_flags.cached_polygon_offset_fill)
117 EnableDisable(GL_POLYGON_OFFSET_FILL,
118 enable_flags.cached_polygon_offset_fill);
119 if (prev_state->enable_flags.cached_sample_alpha_to_coverage !=
120 enable_flags.cached_sample_alpha_to_coverage)
121 EnableDisable(GL_SAMPLE_ALPHA_TO_COVERAGE,
122 enable_flags.cached_sample_alpha_to_coverage);
123 if (prev_state->enable_flags.cached_sample_coverage !=
124 enable_flags.cached_sample_coverage)
125 EnableDisable(GL_SAMPLE_COVERAGE, enable_flags.cached_sample_coverage);
126 if (prev_state->enable_flags.cached_scissor_test !=
127 enable_flags.cached_scissor_test)
128 EnableDisable(GL_SCISSOR_TEST, enable_flags.cached_scissor_test);
129 if (prev_state->enable_flags.cached_stencil_test !=
130 enable_flags.cached_stencil_test)
131 EnableDisable(GL_STENCIL_TEST, enable_flags.cached_stencil_test);
132 } else {
133 EnableDisable(GL_BLEND, enable_flags.cached_blend);
134 EnableDisable(GL_CULL_FACE, enable_flags.cached_cull_face);
135 EnableDisable(GL_DEPTH_TEST, enable_flags.cached_depth_test);
136 EnableDisable(GL_DITHER, enable_flags.cached_dither);
137 EnableDisable(GL_POLYGON_OFFSET_FILL,
138 enable_flags.cached_polygon_offset_fill);
139 EnableDisable(GL_SAMPLE_ALPHA_TO_COVERAGE,
140 enable_flags.cached_sample_alpha_to_coverage);
141 EnableDisable(GL_SAMPLE_COVERAGE, enable_flags.cached_sample_coverage);
142 EnableDisable(GL_SCISSOR_TEST, enable_flags.cached_scissor_test);
143 EnableDisable(GL_STENCIL_TEST, enable_flags.cached_stencil_test);
144 }
145 }
146
InitState(const ContextState * prev_state)147 void ContextState::InitState(const ContextState* prev_state) const {
148 if (prev_state) {
149 if ((blend_color_red != prev_state->blend_color_red) ||
150 (blend_color_green != prev_state->blend_color_green) ||
151 (blend_color_blue != prev_state->blend_color_blue) ||
152 (blend_color_alpha != prev_state->blend_color_alpha))
153 glBlendColor(blend_color_red,
154 blend_color_green,
155 blend_color_blue,
156 blend_color_alpha);
157 if ((blend_equation_rgb != prev_state->blend_equation_rgb) ||
158 (blend_equation_alpha != prev_state->blend_equation_alpha))
159 glBlendEquationSeparate(blend_equation_rgb, blend_equation_alpha);
160 if ((blend_source_rgb != prev_state->blend_source_rgb) ||
161 (blend_dest_rgb != prev_state->blend_dest_rgb) ||
162 (blend_source_alpha != prev_state->blend_source_alpha) ||
163 (blend_dest_alpha != prev_state->blend_dest_alpha))
164 glBlendFuncSeparate(blend_source_rgb,
165 blend_dest_rgb,
166 blend_source_alpha,
167 blend_dest_alpha);
168 if ((color_clear_red != prev_state->color_clear_red) ||
169 (color_clear_green != prev_state->color_clear_green) ||
170 (color_clear_blue != prev_state->color_clear_blue) ||
171 (color_clear_alpha != prev_state->color_clear_alpha))
172 glClearColor(color_clear_red,
173 color_clear_green,
174 color_clear_blue,
175 color_clear_alpha);
176 if ((depth_clear != prev_state->depth_clear))
177 glClearDepth(depth_clear);
178 if ((stencil_clear != prev_state->stencil_clear))
179 glClearStencil(stencil_clear);
180 if ((cached_color_mask_red != prev_state->cached_color_mask_red) ||
181 (cached_color_mask_green != prev_state->cached_color_mask_green) ||
182 (cached_color_mask_blue != prev_state->cached_color_mask_blue) ||
183 (cached_color_mask_alpha != prev_state->cached_color_mask_alpha))
184 glColorMask(cached_color_mask_red,
185 cached_color_mask_green,
186 cached_color_mask_blue,
187 cached_color_mask_alpha);
188 if ((cull_mode != prev_state->cull_mode))
189 glCullFace(cull_mode);
190 if ((depth_func != prev_state->depth_func))
191 glDepthFunc(depth_func);
192 if ((cached_depth_mask != prev_state->cached_depth_mask))
193 glDepthMask(cached_depth_mask);
194 if ((z_near != prev_state->z_near) || (z_far != prev_state->z_far))
195 glDepthRange(z_near, z_far);
196 if ((front_face != prev_state->front_face))
197 glFrontFace(front_face);
198 if (prev_state->hint_generate_mipmap != hint_generate_mipmap)
199 glHint(GL_GENERATE_MIPMAP_HINT, hint_generate_mipmap);
200 if (feature_info_->feature_flags().oes_standard_derivatives)
201 if (prev_state->hint_fragment_shader_derivative !=
202 hint_fragment_shader_derivative)
203 glHint(GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES,
204 hint_fragment_shader_derivative);
205 if ((line_width != prev_state->line_width))
206 glLineWidth(line_width);
207 if (prev_state->pack_alignment != pack_alignment)
208 glPixelStorei(GL_PACK_ALIGNMENT, pack_alignment);
209 if (prev_state->unpack_alignment != unpack_alignment)
210 glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_alignment);
211 if ((polygon_offset_factor != prev_state->polygon_offset_factor) ||
212 (polygon_offset_units != prev_state->polygon_offset_units))
213 glPolygonOffset(polygon_offset_factor, polygon_offset_units);
214 if ((sample_coverage_value != prev_state->sample_coverage_value) ||
215 (sample_coverage_invert != prev_state->sample_coverage_invert))
216 glSampleCoverage(sample_coverage_value, sample_coverage_invert);
217 if ((scissor_x != prev_state->scissor_x) ||
218 (scissor_y != prev_state->scissor_y) ||
219 (scissor_width != prev_state->scissor_width) ||
220 (scissor_height != prev_state->scissor_height))
221 glScissor(scissor_x, scissor_y, scissor_width, scissor_height);
222 if ((stencil_front_func != prev_state->stencil_front_func) ||
223 (stencil_front_ref != prev_state->stencil_front_ref) ||
224 (stencil_front_mask != prev_state->stencil_front_mask))
225 glStencilFuncSeparate(
226 GL_FRONT, stencil_front_func, stencil_front_ref, stencil_front_mask);
227 if ((stencil_back_func != prev_state->stencil_back_func) ||
228 (stencil_back_ref != prev_state->stencil_back_ref) ||
229 (stencil_back_mask != prev_state->stencil_back_mask))
230 glStencilFuncSeparate(
231 GL_BACK, stencil_back_func, stencil_back_ref, stencil_back_mask);
232 if ((cached_stencil_front_writemask !=
233 prev_state->cached_stencil_front_writemask))
234 glStencilMaskSeparate(GL_FRONT, cached_stencil_front_writemask);
235 if ((cached_stencil_back_writemask !=
236 prev_state->cached_stencil_back_writemask))
237 glStencilMaskSeparate(GL_BACK, cached_stencil_back_writemask);
238 if ((stencil_front_fail_op != prev_state->stencil_front_fail_op) ||
239 (stencil_front_z_fail_op != prev_state->stencil_front_z_fail_op) ||
240 (stencil_front_z_pass_op != prev_state->stencil_front_z_pass_op))
241 glStencilOpSeparate(GL_FRONT,
242 stencil_front_fail_op,
243 stencil_front_z_fail_op,
244 stencil_front_z_pass_op);
245 if ((stencil_back_fail_op != prev_state->stencil_back_fail_op) ||
246 (stencil_back_z_fail_op != prev_state->stencil_back_z_fail_op) ||
247 (stencil_back_z_pass_op != prev_state->stencil_back_z_pass_op))
248 glStencilOpSeparate(GL_BACK,
249 stencil_back_fail_op,
250 stencil_back_z_fail_op,
251 stencil_back_z_pass_op);
252 if ((viewport_x != prev_state->viewport_x) ||
253 (viewport_y != prev_state->viewport_y) ||
254 (viewport_width != prev_state->viewport_width) ||
255 (viewport_height != prev_state->viewport_height))
256 glViewport(viewport_x, viewport_y, viewport_width, viewport_height);
257 } else {
258 glBlendColor(blend_color_red,
259 blend_color_green,
260 blend_color_blue,
261 blend_color_alpha);
262 glBlendEquationSeparate(blend_equation_rgb, blend_equation_alpha);
263 glBlendFuncSeparate(
264 blend_source_rgb, blend_dest_rgb, blend_source_alpha, blend_dest_alpha);
265 glClearColor(color_clear_red,
266 color_clear_green,
267 color_clear_blue,
268 color_clear_alpha);
269 glClearDepth(depth_clear);
270 glClearStencil(stencil_clear);
271 glColorMask(cached_color_mask_red,
272 cached_color_mask_green,
273 cached_color_mask_blue,
274 cached_color_mask_alpha);
275 glCullFace(cull_mode);
276 glDepthFunc(depth_func);
277 glDepthMask(cached_depth_mask);
278 glDepthRange(z_near, z_far);
279 glFrontFace(front_face);
280 glHint(GL_GENERATE_MIPMAP_HINT, hint_generate_mipmap);
281 if (feature_info_->feature_flags().oes_standard_derivatives)
282 glHint(GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES,
283 hint_fragment_shader_derivative);
284 glLineWidth(line_width);
285 glPixelStorei(GL_PACK_ALIGNMENT, pack_alignment);
286 glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_alignment);
287 glPolygonOffset(polygon_offset_factor, polygon_offset_units);
288 glSampleCoverage(sample_coverage_value, sample_coverage_invert);
289 glScissor(scissor_x, scissor_y, scissor_width, scissor_height);
290 glStencilFuncSeparate(
291 GL_FRONT, stencil_front_func, stencil_front_ref, stencil_front_mask);
292 glStencilFuncSeparate(
293 GL_BACK, stencil_back_func, stencil_back_ref, stencil_back_mask);
294 glStencilMaskSeparate(GL_FRONT, cached_stencil_front_writemask);
295 glStencilMaskSeparate(GL_BACK, cached_stencil_back_writemask);
296 glStencilOpSeparate(GL_FRONT,
297 stencil_front_fail_op,
298 stencil_front_z_fail_op,
299 stencil_front_z_pass_op);
300 glStencilOpSeparate(GL_BACK,
301 stencil_back_fail_op,
302 stencil_back_z_fail_op,
303 stencil_back_z_pass_op);
304 glViewport(viewport_x, viewport_y, viewport_width, viewport_height);
305 }
306 }
GetEnabled(GLenum cap)307 bool ContextState::GetEnabled(GLenum cap) const {
308 switch (cap) {
309 case GL_BLEND:
310 return enable_flags.blend;
311 case GL_CULL_FACE:
312 return enable_flags.cull_face;
313 case GL_DEPTH_TEST:
314 return enable_flags.depth_test;
315 case GL_DITHER:
316 return enable_flags.dither;
317 case GL_POLYGON_OFFSET_FILL:
318 return enable_flags.polygon_offset_fill;
319 case GL_SAMPLE_ALPHA_TO_COVERAGE:
320 return enable_flags.sample_alpha_to_coverage;
321 case GL_SAMPLE_COVERAGE:
322 return enable_flags.sample_coverage;
323 case GL_SCISSOR_TEST:
324 return enable_flags.scissor_test;
325 case GL_STENCIL_TEST:
326 return enable_flags.stencil_test;
327 default:
328 NOTREACHED();
329 return false;
330 }
331 }
332
GetStateAsGLint(GLenum pname,GLint * params,GLsizei * num_written)333 bool ContextState::GetStateAsGLint(GLenum pname,
334 GLint* params,
335 GLsizei* num_written) const {
336 switch (pname) {
337 case GL_BLEND_COLOR:
338 *num_written = 4;
339 if (params) {
340 params[0] = static_cast<GLint>(blend_color_red);
341 params[1] = static_cast<GLint>(blend_color_green);
342 params[2] = static_cast<GLint>(blend_color_blue);
343 params[3] = static_cast<GLint>(blend_color_alpha);
344 }
345 return true;
346 case GL_BLEND_EQUATION_RGB:
347 *num_written = 1;
348 if (params) {
349 params[0] = static_cast<GLint>(blend_equation_rgb);
350 }
351 return true;
352 case GL_BLEND_EQUATION_ALPHA:
353 *num_written = 1;
354 if (params) {
355 params[0] = static_cast<GLint>(blend_equation_alpha);
356 }
357 return true;
358 case GL_BLEND_SRC_RGB:
359 *num_written = 1;
360 if (params) {
361 params[0] = static_cast<GLint>(blend_source_rgb);
362 }
363 return true;
364 case GL_BLEND_DST_RGB:
365 *num_written = 1;
366 if (params) {
367 params[0] = static_cast<GLint>(blend_dest_rgb);
368 }
369 return true;
370 case GL_BLEND_SRC_ALPHA:
371 *num_written = 1;
372 if (params) {
373 params[0] = static_cast<GLint>(blend_source_alpha);
374 }
375 return true;
376 case GL_BLEND_DST_ALPHA:
377 *num_written = 1;
378 if (params) {
379 params[0] = static_cast<GLint>(blend_dest_alpha);
380 }
381 return true;
382 case GL_COLOR_CLEAR_VALUE:
383 *num_written = 4;
384 if (params) {
385 params[0] = static_cast<GLint>(color_clear_red);
386 params[1] = static_cast<GLint>(color_clear_green);
387 params[2] = static_cast<GLint>(color_clear_blue);
388 params[3] = static_cast<GLint>(color_clear_alpha);
389 }
390 return true;
391 case GL_DEPTH_CLEAR_VALUE:
392 *num_written = 1;
393 if (params) {
394 params[0] = static_cast<GLint>(depth_clear);
395 }
396 return true;
397 case GL_STENCIL_CLEAR_VALUE:
398 *num_written = 1;
399 if (params) {
400 params[0] = static_cast<GLint>(stencil_clear);
401 }
402 return true;
403 case GL_COLOR_WRITEMASK:
404 *num_written = 4;
405 if (params) {
406 params[0] = static_cast<GLint>(color_mask_red);
407 params[1] = static_cast<GLint>(color_mask_green);
408 params[2] = static_cast<GLint>(color_mask_blue);
409 params[3] = static_cast<GLint>(color_mask_alpha);
410 }
411 return true;
412 case GL_CULL_FACE_MODE:
413 *num_written = 1;
414 if (params) {
415 params[0] = static_cast<GLint>(cull_mode);
416 }
417 return true;
418 case GL_DEPTH_FUNC:
419 *num_written = 1;
420 if (params) {
421 params[0] = static_cast<GLint>(depth_func);
422 }
423 return true;
424 case GL_DEPTH_WRITEMASK:
425 *num_written = 1;
426 if (params) {
427 params[0] = static_cast<GLint>(depth_mask);
428 }
429 return true;
430 case GL_DEPTH_RANGE:
431 *num_written = 2;
432 if (params) {
433 params[0] = static_cast<GLint>(z_near);
434 params[1] = static_cast<GLint>(z_far);
435 }
436 return true;
437 case GL_FRONT_FACE:
438 *num_written = 1;
439 if (params) {
440 params[0] = static_cast<GLint>(front_face);
441 }
442 return true;
443 case GL_GENERATE_MIPMAP_HINT:
444 *num_written = 1;
445 if (params) {
446 params[0] = static_cast<GLint>(hint_generate_mipmap);
447 }
448 return true;
449 case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
450 *num_written = 1;
451 if (params) {
452 params[0] = static_cast<GLint>(hint_fragment_shader_derivative);
453 }
454 return true;
455 case GL_LINE_WIDTH:
456 *num_written = 1;
457 if (params) {
458 params[0] = static_cast<GLint>(line_width);
459 }
460 return true;
461 case GL_PACK_ALIGNMENT:
462 *num_written = 1;
463 if (params) {
464 params[0] = static_cast<GLint>(pack_alignment);
465 }
466 return true;
467 case GL_UNPACK_ALIGNMENT:
468 *num_written = 1;
469 if (params) {
470 params[0] = static_cast<GLint>(unpack_alignment);
471 }
472 return true;
473 case GL_POLYGON_OFFSET_FACTOR:
474 *num_written = 1;
475 if (params) {
476 params[0] = static_cast<GLint>(polygon_offset_factor);
477 }
478 return true;
479 case GL_POLYGON_OFFSET_UNITS:
480 *num_written = 1;
481 if (params) {
482 params[0] = static_cast<GLint>(polygon_offset_units);
483 }
484 return true;
485 case GL_SAMPLE_COVERAGE_VALUE:
486 *num_written = 1;
487 if (params) {
488 params[0] = static_cast<GLint>(sample_coverage_value);
489 }
490 return true;
491 case GL_SAMPLE_COVERAGE_INVERT:
492 *num_written = 1;
493 if (params) {
494 params[0] = static_cast<GLint>(sample_coverage_invert);
495 }
496 return true;
497 case GL_SCISSOR_BOX:
498 *num_written = 4;
499 if (params) {
500 params[0] = static_cast<GLint>(scissor_x);
501 params[1] = static_cast<GLint>(scissor_y);
502 params[2] = static_cast<GLint>(scissor_width);
503 params[3] = static_cast<GLint>(scissor_height);
504 }
505 return true;
506 case GL_STENCIL_FUNC:
507 *num_written = 1;
508 if (params) {
509 params[0] = static_cast<GLint>(stencil_front_func);
510 }
511 return true;
512 case GL_STENCIL_REF:
513 *num_written = 1;
514 if (params) {
515 params[0] = static_cast<GLint>(stencil_front_ref);
516 }
517 return true;
518 case GL_STENCIL_VALUE_MASK:
519 *num_written = 1;
520 if (params) {
521 params[0] = static_cast<GLint>(stencil_front_mask);
522 }
523 return true;
524 case GL_STENCIL_BACK_FUNC:
525 *num_written = 1;
526 if (params) {
527 params[0] = static_cast<GLint>(stencil_back_func);
528 }
529 return true;
530 case GL_STENCIL_BACK_REF:
531 *num_written = 1;
532 if (params) {
533 params[0] = static_cast<GLint>(stencil_back_ref);
534 }
535 return true;
536 case GL_STENCIL_BACK_VALUE_MASK:
537 *num_written = 1;
538 if (params) {
539 params[0] = static_cast<GLint>(stencil_back_mask);
540 }
541 return true;
542 case GL_STENCIL_WRITEMASK:
543 *num_written = 1;
544 if (params) {
545 params[0] = static_cast<GLint>(stencil_front_writemask);
546 }
547 return true;
548 case GL_STENCIL_BACK_WRITEMASK:
549 *num_written = 1;
550 if (params) {
551 params[0] = static_cast<GLint>(stencil_back_writemask);
552 }
553 return true;
554 case GL_STENCIL_FAIL:
555 *num_written = 1;
556 if (params) {
557 params[0] = static_cast<GLint>(stencil_front_fail_op);
558 }
559 return true;
560 case GL_STENCIL_PASS_DEPTH_FAIL:
561 *num_written = 1;
562 if (params) {
563 params[0] = static_cast<GLint>(stencil_front_z_fail_op);
564 }
565 return true;
566 case GL_STENCIL_PASS_DEPTH_PASS:
567 *num_written = 1;
568 if (params) {
569 params[0] = static_cast<GLint>(stencil_front_z_pass_op);
570 }
571 return true;
572 case GL_STENCIL_BACK_FAIL:
573 *num_written = 1;
574 if (params) {
575 params[0] = static_cast<GLint>(stencil_back_fail_op);
576 }
577 return true;
578 case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
579 *num_written = 1;
580 if (params) {
581 params[0] = static_cast<GLint>(stencil_back_z_fail_op);
582 }
583 return true;
584 case GL_STENCIL_BACK_PASS_DEPTH_PASS:
585 *num_written = 1;
586 if (params) {
587 params[0] = static_cast<GLint>(stencil_back_z_pass_op);
588 }
589 return true;
590 case GL_VIEWPORT:
591 *num_written = 4;
592 if (params) {
593 params[0] = static_cast<GLint>(viewport_x);
594 params[1] = static_cast<GLint>(viewport_y);
595 params[2] = static_cast<GLint>(viewport_width);
596 params[3] = static_cast<GLint>(viewport_height);
597 }
598 return true;
599 case GL_BLEND:
600 *num_written = 1;
601 if (params) {
602 params[0] = static_cast<GLint>(enable_flags.blend);
603 }
604 return true;
605 case GL_CULL_FACE:
606 *num_written = 1;
607 if (params) {
608 params[0] = static_cast<GLint>(enable_flags.cull_face);
609 }
610 return true;
611 case GL_DEPTH_TEST:
612 *num_written = 1;
613 if (params) {
614 params[0] = static_cast<GLint>(enable_flags.depth_test);
615 }
616 return true;
617 case GL_DITHER:
618 *num_written = 1;
619 if (params) {
620 params[0] = static_cast<GLint>(enable_flags.dither);
621 }
622 return true;
623 case GL_POLYGON_OFFSET_FILL:
624 *num_written = 1;
625 if (params) {
626 params[0] = static_cast<GLint>(enable_flags.polygon_offset_fill);
627 }
628 return true;
629 case GL_SAMPLE_ALPHA_TO_COVERAGE:
630 *num_written = 1;
631 if (params) {
632 params[0] = static_cast<GLint>(enable_flags.sample_alpha_to_coverage);
633 }
634 return true;
635 case GL_SAMPLE_COVERAGE:
636 *num_written = 1;
637 if (params) {
638 params[0] = static_cast<GLint>(enable_flags.sample_coverage);
639 }
640 return true;
641 case GL_SCISSOR_TEST:
642 *num_written = 1;
643 if (params) {
644 params[0] = static_cast<GLint>(enable_flags.scissor_test);
645 }
646 return true;
647 case GL_STENCIL_TEST:
648 *num_written = 1;
649 if (params) {
650 params[0] = static_cast<GLint>(enable_flags.stencil_test);
651 }
652 return true;
653 default:
654 return false;
655 }
656 }
657
GetStateAsGLfloat(GLenum pname,GLfloat * params,GLsizei * num_written)658 bool ContextState::GetStateAsGLfloat(GLenum pname,
659 GLfloat* params,
660 GLsizei* num_written) const {
661 switch (pname) {
662 case GL_BLEND_COLOR:
663 *num_written = 4;
664 if (params) {
665 params[0] = static_cast<GLfloat>(blend_color_red);
666 params[1] = static_cast<GLfloat>(blend_color_green);
667 params[2] = static_cast<GLfloat>(blend_color_blue);
668 params[3] = static_cast<GLfloat>(blend_color_alpha);
669 }
670 return true;
671 case GL_BLEND_EQUATION_RGB:
672 *num_written = 1;
673 if (params) {
674 params[0] = static_cast<GLfloat>(blend_equation_rgb);
675 }
676 return true;
677 case GL_BLEND_EQUATION_ALPHA:
678 *num_written = 1;
679 if (params) {
680 params[0] = static_cast<GLfloat>(blend_equation_alpha);
681 }
682 return true;
683 case GL_BLEND_SRC_RGB:
684 *num_written = 1;
685 if (params) {
686 params[0] = static_cast<GLfloat>(blend_source_rgb);
687 }
688 return true;
689 case GL_BLEND_DST_RGB:
690 *num_written = 1;
691 if (params) {
692 params[0] = static_cast<GLfloat>(blend_dest_rgb);
693 }
694 return true;
695 case GL_BLEND_SRC_ALPHA:
696 *num_written = 1;
697 if (params) {
698 params[0] = static_cast<GLfloat>(blend_source_alpha);
699 }
700 return true;
701 case GL_BLEND_DST_ALPHA:
702 *num_written = 1;
703 if (params) {
704 params[0] = static_cast<GLfloat>(blend_dest_alpha);
705 }
706 return true;
707 case GL_COLOR_CLEAR_VALUE:
708 *num_written = 4;
709 if (params) {
710 params[0] = static_cast<GLfloat>(color_clear_red);
711 params[1] = static_cast<GLfloat>(color_clear_green);
712 params[2] = static_cast<GLfloat>(color_clear_blue);
713 params[3] = static_cast<GLfloat>(color_clear_alpha);
714 }
715 return true;
716 case GL_DEPTH_CLEAR_VALUE:
717 *num_written = 1;
718 if (params) {
719 params[0] = static_cast<GLfloat>(depth_clear);
720 }
721 return true;
722 case GL_STENCIL_CLEAR_VALUE:
723 *num_written = 1;
724 if (params) {
725 params[0] = static_cast<GLfloat>(stencil_clear);
726 }
727 return true;
728 case GL_COLOR_WRITEMASK:
729 *num_written = 4;
730 if (params) {
731 params[0] = static_cast<GLfloat>(color_mask_red);
732 params[1] = static_cast<GLfloat>(color_mask_green);
733 params[2] = static_cast<GLfloat>(color_mask_blue);
734 params[3] = static_cast<GLfloat>(color_mask_alpha);
735 }
736 return true;
737 case GL_CULL_FACE_MODE:
738 *num_written = 1;
739 if (params) {
740 params[0] = static_cast<GLfloat>(cull_mode);
741 }
742 return true;
743 case GL_DEPTH_FUNC:
744 *num_written = 1;
745 if (params) {
746 params[0] = static_cast<GLfloat>(depth_func);
747 }
748 return true;
749 case GL_DEPTH_WRITEMASK:
750 *num_written = 1;
751 if (params) {
752 params[0] = static_cast<GLfloat>(depth_mask);
753 }
754 return true;
755 case GL_DEPTH_RANGE:
756 *num_written = 2;
757 if (params) {
758 params[0] = static_cast<GLfloat>(z_near);
759 params[1] = static_cast<GLfloat>(z_far);
760 }
761 return true;
762 case GL_FRONT_FACE:
763 *num_written = 1;
764 if (params) {
765 params[0] = static_cast<GLfloat>(front_face);
766 }
767 return true;
768 case GL_GENERATE_MIPMAP_HINT:
769 *num_written = 1;
770 if (params) {
771 params[0] = static_cast<GLfloat>(hint_generate_mipmap);
772 }
773 return true;
774 case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
775 *num_written = 1;
776 if (params) {
777 params[0] = static_cast<GLfloat>(hint_fragment_shader_derivative);
778 }
779 return true;
780 case GL_LINE_WIDTH:
781 *num_written = 1;
782 if (params) {
783 params[0] = static_cast<GLfloat>(line_width);
784 }
785 return true;
786 case GL_PACK_ALIGNMENT:
787 *num_written = 1;
788 if (params) {
789 params[0] = static_cast<GLfloat>(pack_alignment);
790 }
791 return true;
792 case GL_UNPACK_ALIGNMENT:
793 *num_written = 1;
794 if (params) {
795 params[0] = static_cast<GLfloat>(unpack_alignment);
796 }
797 return true;
798 case GL_POLYGON_OFFSET_FACTOR:
799 *num_written = 1;
800 if (params) {
801 params[0] = static_cast<GLfloat>(polygon_offset_factor);
802 }
803 return true;
804 case GL_POLYGON_OFFSET_UNITS:
805 *num_written = 1;
806 if (params) {
807 params[0] = static_cast<GLfloat>(polygon_offset_units);
808 }
809 return true;
810 case GL_SAMPLE_COVERAGE_VALUE:
811 *num_written = 1;
812 if (params) {
813 params[0] = static_cast<GLfloat>(sample_coverage_value);
814 }
815 return true;
816 case GL_SAMPLE_COVERAGE_INVERT:
817 *num_written = 1;
818 if (params) {
819 params[0] = static_cast<GLfloat>(sample_coverage_invert);
820 }
821 return true;
822 case GL_SCISSOR_BOX:
823 *num_written = 4;
824 if (params) {
825 params[0] = static_cast<GLfloat>(scissor_x);
826 params[1] = static_cast<GLfloat>(scissor_y);
827 params[2] = static_cast<GLfloat>(scissor_width);
828 params[3] = static_cast<GLfloat>(scissor_height);
829 }
830 return true;
831 case GL_STENCIL_FUNC:
832 *num_written = 1;
833 if (params) {
834 params[0] = static_cast<GLfloat>(stencil_front_func);
835 }
836 return true;
837 case GL_STENCIL_REF:
838 *num_written = 1;
839 if (params) {
840 params[0] = static_cast<GLfloat>(stencil_front_ref);
841 }
842 return true;
843 case GL_STENCIL_VALUE_MASK:
844 *num_written = 1;
845 if (params) {
846 params[0] = static_cast<GLfloat>(stencil_front_mask);
847 }
848 return true;
849 case GL_STENCIL_BACK_FUNC:
850 *num_written = 1;
851 if (params) {
852 params[0] = static_cast<GLfloat>(stencil_back_func);
853 }
854 return true;
855 case GL_STENCIL_BACK_REF:
856 *num_written = 1;
857 if (params) {
858 params[0] = static_cast<GLfloat>(stencil_back_ref);
859 }
860 return true;
861 case GL_STENCIL_BACK_VALUE_MASK:
862 *num_written = 1;
863 if (params) {
864 params[0] = static_cast<GLfloat>(stencil_back_mask);
865 }
866 return true;
867 case GL_STENCIL_WRITEMASK:
868 *num_written = 1;
869 if (params) {
870 params[0] = static_cast<GLfloat>(stencil_front_writemask);
871 }
872 return true;
873 case GL_STENCIL_BACK_WRITEMASK:
874 *num_written = 1;
875 if (params) {
876 params[0] = static_cast<GLfloat>(stencil_back_writemask);
877 }
878 return true;
879 case GL_STENCIL_FAIL:
880 *num_written = 1;
881 if (params) {
882 params[0] = static_cast<GLfloat>(stencil_front_fail_op);
883 }
884 return true;
885 case GL_STENCIL_PASS_DEPTH_FAIL:
886 *num_written = 1;
887 if (params) {
888 params[0] = static_cast<GLfloat>(stencil_front_z_fail_op);
889 }
890 return true;
891 case GL_STENCIL_PASS_DEPTH_PASS:
892 *num_written = 1;
893 if (params) {
894 params[0] = static_cast<GLfloat>(stencil_front_z_pass_op);
895 }
896 return true;
897 case GL_STENCIL_BACK_FAIL:
898 *num_written = 1;
899 if (params) {
900 params[0] = static_cast<GLfloat>(stencil_back_fail_op);
901 }
902 return true;
903 case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
904 *num_written = 1;
905 if (params) {
906 params[0] = static_cast<GLfloat>(stencil_back_z_fail_op);
907 }
908 return true;
909 case GL_STENCIL_BACK_PASS_DEPTH_PASS:
910 *num_written = 1;
911 if (params) {
912 params[0] = static_cast<GLfloat>(stencil_back_z_pass_op);
913 }
914 return true;
915 case GL_VIEWPORT:
916 *num_written = 4;
917 if (params) {
918 params[0] = static_cast<GLfloat>(viewport_x);
919 params[1] = static_cast<GLfloat>(viewport_y);
920 params[2] = static_cast<GLfloat>(viewport_width);
921 params[3] = static_cast<GLfloat>(viewport_height);
922 }
923 return true;
924 case GL_BLEND:
925 *num_written = 1;
926 if (params) {
927 params[0] = static_cast<GLfloat>(enable_flags.blend);
928 }
929 return true;
930 case GL_CULL_FACE:
931 *num_written = 1;
932 if (params) {
933 params[0] = static_cast<GLfloat>(enable_flags.cull_face);
934 }
935 return true;
936 case GL_DEPTH_TEST:
937 *num_written = 1;
938 if (params) {
939 params[0] = static_cast<GLfloat>(enable_flags.depth_test);
940 }
941 return true;
942 case GL_DITHER:
943 *num_written = 1;
944 if (params) {
945 params[0] = static_cast<GLfloat>(enable_flags.dither);
946 }
947 return true;
948 case GL_POLYGON_OFFSET_FILL:
949 *num_written = 1;
950 if (params) {
951 params[0] = static_cast<GLfloat>(enable_flags.polygon_offset_fill);
952 }
953 return true;
954 case GL_SAMPLE_ALPHA_TO_COVERAGE:
955 *num_written = 1;
956 if (params) {
957 params[0] = static_cast<GLfloat>(enable_flags.sample_alpha_to_coverage);
958 }
959 return true;
960 case GL_SAMPLE_COVERAGE:
961 *num_written = 1;
962 if (params) {
963 params[0] = static_cast<GLfloat>(enable_flags.sample_coverage);
964 }
965 return true;
966 case GL_SCISSOR_TEST:
967 *num_written = 1;
968 if (params) {
969 params[0] = static_cast<GLfloat>(enable_flags.scissor_test);
970 }
971 return true;
972 case GL_STENCIL_TEST:
973 *num_written = 1;
974 if (params) {
975 params[0] = static_cast<GLfloat>(enable_flags.stencil_test);
976 }
977 return true;
978 default:
979 return false;
980 }
981 }
982 #endif // GPU_COMMAND_BUFFER_SERVICE_CONTEXT_STATE_IMPL_AUTOGEN_H_
983