Lines Matching defs:arrays
43 * Implement GLX protocol for vertex arrays and vertex buffer objects.
64 * "vbo", to support multiple texture coordinate arrays, generic attributes,
80 const struct array_state_vector *arrays,
83 const struct array_state_vector *arrays,
86 *arrays, GLenum key,
88 static void fill_array_info_cache(struct array_state_vector *arrays);
117 struct array_state_vector *arrays = state->array_state;
119 if (arrays) {
120 free(arrays->stack);
121 arrays->stack = NULL;
122 free(arrays->arrays);
123 arrays->arrays = NULL;
124 free(arrays);
138 * initialized. These values are used to determine what vertex arrays are
145 struct array_state_vector *arrays;
155 arrays = calloc(1, sizeof(struct array_state_vector));
156 state->array_state = arrays;
158 if (arrays == NULL) {
163 arrays->old_DrawArrays_possible = !state->NoDrawArraysProtocol;
164 arrays->new_DrawArrays_possible = GL_FALSE;
165 arrays->DrawArrays = NULL;
167 arrays->active_texture_unit = 0;
170 /* Determine how many arrays are actually needed. Only arrays that
172 * supports only 2 texture units, then only 2 texture coordinate arrays
205 arrays->num_texture_units = texture_units;
206 arrays->num_vertex_program_attribs = vertex_program_attribs;
208 arrays->num_arrays = array_count;
209 arrays->arrays = calloc(array_count, sizeof(struct array_state));
211 if (arrays->arrays == NULL) {
213 free(arrays);
218 arrays->arrays[0].data_type = GL_FLOAT;
219 arrays->arrays[0].count = 3;
220 arrays->arrays[0].key = GL_NORMAL_ARRAY;
221 arrays->arrays[0].normalized = GL_TRUE;
222 arrays->arrays[0].old_DrawArrays_possible = GL_TRUE;
224 arrays->arrays[1].data_type = GL_FLOAT;
225 arrays->arrays[1].count = 4;
226 arrays->arrays[1].key = GL_COLOR_ARRAY;
227 arrays->arrays[1].normalized = GL_TRUE;
228 arrays->arrays[1].old_DrawArrays_possible = GL_TRUE;
230 arrays->arrays[2].data_type = GL_FLOAT;
231 arrays->arrays[2].count = 1;
232 arrays->arrays[2].key = GL_INDEX_ARRAY;
233 arrays->arrays[2].old_DrawArrays_possible = GL_TRUE;
235 arrays->arrays[3].data_type = GL_UNSIGNED_BYTE;
236 arrays->arrays[3].count = 1;
237 arrays->arrays[3].key = GL_EDGE_FLAG_ARRAY;
238 arrays->arrays[3].old_DrawArrays_possible = GL_TRUE;
241 arrays->arrays[4 + i].data_type = GL_FLOAT;
242 arrays->arrays[4 + i].count = 4;
243 arrays->arrays[4 + i].key = GL_TEXTURE_COORD_ARRAY;
245 arrays->arrays[4 + i].old_DrawArrays_possible = (i == 0);
246 arrays->arrays[4 + i].index = i;
252 arrays->arrays[i].data_type = GL_FLOAT;
253 arrays->arrays[i].count = 1;
254 arrays->arrays[i].key = GL_FOG_COORDINATE_ARRAY;
255 arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
260 arrays->arrays[i].data_type = GL_FLOAT;
261 arrays->arrays[i].count = 3;
262 arrays->arrays[i].key = GL_SECONDARY_COLOR_ARRAY;
263 arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
264 arrays->arrays[i].normalized = GL_TRUE;
273 arrays->arrays[idx + i].data_type = GL_FLOAT;
274 arrays->arrays[idx + i].count = 4;
275 arrays->arrays[idx + i].key = GL_VERTEX_ATTRIB_ARRAY_POINTER;
277 arrays->arrays[idx + i].old_DrawArrays_possible = 0;
278 arrays->arrays[idx + i].index = idx;
288 arrays->arrays[i].data_type = GL_FLOAT;
289 arrays->arrays[i].count = 4;
290 arrays->arrays[i].key = GL_VERTEX_ARRAY;
291 arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
293 assert((i + 1) == arrays->num_arrays);
295 arrays->stack_index = 0;
296 arrays->stack = malloc(sizeof(struct array_stack_state)
297 * arrays->num_arrays
300 if (arrays->stack == NULL) {
302 free(arrays->arrays);
303 free(arrays);
313 * implement the enabled vertex arrays.
316 calculate_single_vertex_size_none(const struct array_state_vector *arrays)
322 for (i = 0; i < arrays->num_arrays; i++) {
323 if (arrays->arrays[i].enabled) {
324 single_vertex_size += arrays->arrays[i].header[0];
337 const struct array_state_vector * arrays, unsigned index)
342 for (i = 0; i < arrays->num_arrays; i++) {
343 if (arrays->arrays[i].enabled) {
344 const size_t offset = index * arrays->arrays[i].true_stride;
352 (void) memset(dst, 0, arrays->arrays[i].header[0]);
354 (void) memcpy(dst, arrays->arrays[i].header, 4);
358 if (arrays->arrays[i].key == GL_TEXTURE_COORD_ARRAY &&
359 arrays->arrays[i].index > 0) {
360 /* Multi-texture coordinate arrays require the texture target
364 GLenum texture = arrays->arrays[i].index + GL_TEXTURE0;
365 if (arrays->arrays[i].data_type == GL_DOUBLE) {
366 (void) memcpy(dst, ((GLubyte *) arrays->arrays[i].data) + offset,
367 arrays->arrays[i].element_size);
368 dst += arrays->arrays[i].element_size;
374 (void) memcpy(dst, ((GLubyte *) arrays->arrays[i].data) + offset,
375 arrays->arrays[i].element_size);
376 dst += __GLX_PAD(arrays->arrays[i].element_size);
378 } else if (arrays->arrays[i].key == GL_VERTEX_ATTRIB_ARRAY_POINTER) {
381 (void) memcpy(dst, &arrays->arrays[i].index, 4);
383 (void) memcpy(dst, ((GLubyte *) arrays->arrays[i].data) + offset,
384 arrays->arrays[i].element_size);
385 dst += __GLX_PAD(arrays->arrays[i].element_size);
387 (void) memcpy(dst, ((GLubyte *) arrays->arrays[i].data) + offset,
388 arrays->arrays[i].element_size);
389 dst += __GLX_PAD(arrays->arrays[i].element_size);
404 const struct array_state_vector * arrays, unsigned index)
409 for (i = 0; i < arrays->num_arrays; i++) {
410 if (arrays->arrays[i].enabled) {
411 const size_t offset = index * arrays->arrays[i].true_stride;
413 (void) memcpy(dst, ((GLubyte *) arrays->arrays[i].data) + offset,
414 arrays->arrays[i].element_size);
416 dst += __GLX_PAD(arrays->arrays[i].element_size);
425 get_array_entry(const struct array_state_vector *arrays,
430 for (i = 0; i < arrays->num_arrays; i++) {
431 if ((arrays->arrays[i].key == key)
432 && (arrays->arrays[i].index == index)) {
433 return &arrays->arrays[i];
442 allocate_array_info_cache(struct array_state_vector *arrays,
446 if (arrays->array_info_cache_buffer_size < required_size) {
447 GLubyte *temp = realloc(arrays->array_info_cache_base,
454 arrays->array_info_cache_base = temp;
455 arrays->array_info_cache = temp + MAX_HEADER_SIZE;
456 arrays->array_info_cache_buffer_size = required_size;
459 arrays->array_info_cache_size = required_size;
467 fill_array_info_cache(struct array_state_vector *arrays)
473 /* Determine how many arrays are enabled.
476 arrays->enabled_client_array_count = 0;
477 old_DrawArrays_possible = arrays->old_DrawArrays_possible;
478 for (i = 0; i < arrays->num_arrays; i++) {
479 if (arrays->arrays[i].enabled) {
480 arrays->enabled_client_array_count++;
481 old_DrawArrays_possible &= arrays->arrays[i].old_DrawArrays_possible;
485 if (arrays->new_DrawArrays_possible) {
486 assert(!arrays->new_DrawArrays_possible);
489 const size_t required_size = arrays->enabled_client_array_count * 12;
493 if (!allocate_array_info_cache(arrays, required_size)) {
498 info = (uint32_t *) arrays->array_info_cache;
499 for (i = 0; i < arrays->num_arrays; i++) {
500 if (arrays->arrays[i].enabled) {
501 *(info++) = arrays->arrays[i].data_type;
502 *(info++) = arrays->arrays[i].count;
503 *(info++) = arrays->arrays[i].key;
507 arrays->DrawArrays = emit_DrawArrays_old;
508 arrays->DrawElements = emit_DrawElements_old;
511 arrays->DrawArrays = emit_DrawArrays_none;
512 arrays->DrawElements = emit_DrawElements_none;
515 arrays->array_info_cache_valid = GL_TRUE;
532 struct array_state_vector *arrays = state->array_state;
541 single_vertex_size = calculate_single_vertex_size_none(arrays);
555 pc = emit_element_none(pc, arrays, first + i);
577 * \param arrays Array state.
592 struct array_state_vector *arrays,
610 for (i = 0; i < arrays->num_arrays; i++) {
611 if (arrays->arrays[i].enabled) {
612 single_vertex_size += __GLX_PAD(arrays->arrays[i].element_size);
616 command_size = arrays->array_info_cache_size + header_size
656 pc = ((GLubyte *) arrays->array_info_cache) - (header_size + 4);
660 *(uint32_t *) (pc + 12) = arrays->enabled_client_array_count;
664 header_size + 4 + arrays->array_info_cache_size);
677 *(uint32_t *) (pc + 8) = arrays->enabled_client_array_count;
682 (void) memcpy(pc, arrays->array_info_cache,
683 arrays->array_info_cache_size);
684 pc += arrays->array_info_cache_size;
703 struct array_state_vector *arrays = state->array_state;
711 pc = emit_DrawArrays_header_old(gc, arrays, &elements_per_request,
715 /* Write the arrays.
722 pc = emit_element_old(pc, arrays, i + first);
743 pc = emit_element_old(pc, arrays, i + first);
763 struct array_state_vector *arrays = state->array_state;
772 single_vertex_size = calculate_single_vertex_size_none(arrays);
804 pc = emit_element_none(pc, arrays, index);
830 struct array_state_vector *arrays = state->array_state;
840 pc = emit_DrawArrays_header_old(gc, arrays, &elements_per_request,
844 /* Write the arrays.
859 pc = emit_element_old(pc, arrays, index);
868 pc = emit_element_old(pc, arrays, index);
877 pc = emit_element_old(pc, arrays, index);
987 struct array_state_vector *arrays = state->array_state;
991 if (!arrays->array_info_cache_valid) {
992 fill_array_info_cache(arrays);
995 arrays->DrawArrays(mode, first, count);
1006 struct array_state_vector *arrays = state->array_state;
1011 single_vertex_size = calculate_single_vertex_size_none(arrays);
1017 gc->pc = emit_element_none(gc->pc, arrays, index);
1032 struct array_state_vector *arrays = state->array_state;
1037 if (!arrays->array_info_cache_valid) {
1038 fill_array_info_cache(arrays);
1041 arrays->DrawElements(mode, count, type, indices);
1054 struct array_state_vector *arrays = state->array_state;
1064 if (!arrays->array_info_cache_valid) {
1065 fill_array_info_cache(arrays);
1068 arrays->DrawElements(mode, count, type, indices);
1080 struct array_state_vector *arrays = state->array_state;
1085 if (!arrays->array_info_cache_valid) {
1086 fill_array_info_cache(arrays);
1091 arrays->DrawArrays(mode, first[i], count[i]);
1106 struct array_state_vector *arrays = state->array_state;
1111 if (!arrays->array_info_cache_valid) {
1112 fill_array_info_cache(arrays);
1117 arrays->DrawElements(mode, count[i], type, indices[i]);
1164 struct array_state_vector *arrays = state->array_state;
1191 a = get_array_entry(arrays, GL_VERTEX_ARRAY, 0);
1197 arrays->array_info_cache_valid = GL_FALSE;
1209 struct array_state_vector *arrays = state->array_state;
1239 a = get_array_entry(arrays, GL_NORMAL_ARRAY, 0);
1244 arrays->array_info_cache_valid = GL_FALSE;
1280 struct array_state_vector *arrays = state->array_state;
1319 a = get_array_entry(arrays, GL_COLOR_ARRAY, 0);
1324 arrays->array_info_cache_valid = GL_FALSE;
1335 struct array_state_vector *arrays = state->array_state;
1365 a = get_array_entry(arrays, GL_INDEX_ARRAY, 0);
1370 arrays->array_info_cache_valid = GL_FALSE;
1380 struct array_state_vector *arrays = state->array_state;
1390 a = get_array_entry(arrays, GL_EDGE_FLAG_ARRAY, 0);
1396 arrays->array_info_cache_valid = GL_FALSE;
1442 struct array_state_vector *arrays = state->array_state;
1453 index = arrays->active_texture_unit;
1497 a = get_array_entry(arrays, GL_TEXTURE_COORD_ARRAY, index);
1503 arrays->array_info_cache_valid = GL_FALSE;
1515 struct array_state_vector *arrays = state->array_state;
1554 a = get_array_entry(arrays, GL_SECONDARY_COLOR_ARRAY, 0);
1563 arrays->array_info_cache_valid = GL_FALSE;
1575 struct array_state_vector *arrays = state->array_state;
1596 a = get_array_entry(arrays, GL_FOG_COORD_ARRAY, 0);
1605 arrays->array_info_cache_valid = GL_FALSE;
1631 struct array_state_vector *arrays = state->array_state;
1638 || (index > arrays->num_vertex_program_attribs)) {
1709 a = get_array_entry(arrays, GL_VERTEX_ATTRIB_ARRAY_POINTER, index);
1722 arrays->array_info_cache_valid = GL_FALSE;
1772 struct array_state_vector *const arrays = state->array_state;
1776 if ((unit < 0) || (unit >= arrays->num_texture_units)) {
1781 arrays->active_texture_unit = unit;
1792 struct array_state_vector *arrays = state->array_state;
1796 /* Texture coordinate arrays have an implict index set when the
1800 index = arrays->active_texture_unit;
1803 a = get_array_entry(arrays, key, index);
1807 arrays->array_info_cache_valid = GL_FALSE;
1817 struct array_state_vector *arrays = state->array_state;
1821 for (i = 0; i < arrays->num_arrays; i++) {
1822 arrays->arrays[i].enabled = GL_FALSE;
1825 arrays->array_info_cache_valid = GL_FALSE;
1835 const struct array_state_vector *arrays = state->array_state;
1837 get_array_entry((struct array_state_vector *) arrays,
1854 const struct array_state_vector *arrays = state->array_state;
1856 get_array_entry((struct array_state_vector *) arrays,
1873 const struct array_state_vector *arrays = state->array_state;
1875 get_array_entry((struct array_state_vector *) arrays,
1892 const struct array_state_vector *arrays = state->array_state;
1894 get_array_entry((struct array_state_vector *) arrays,
1911 const struct array_state_vector *arrays = state->array_state;
1913 get_array_entry((struct array_state_vector *) arrays,
1931 const struct array_state_vector *arrays = state->array_state;
1933 get_array_entry((struct array_state_vector *) arrays,
1957 struct array_state_vector *arrays = state->array_state;
1959 &arrays->stack[(arrays->stack_index * arrays->num_arrays)];
1963 for (i = 0; i < arrays->num_arrays; i++) {
1964 stack[i].data = arrays->arrays[i].data;
1965 stack[i].data_type = arrays->arrays[i].data_type;
1966 stack[i].user_stride = arrays->arrays[i].user_stride;
1967 stack[i].count = arrays->arrays[i].count;
1968 stack[i].key = arrays->arrays[i].key;
1969 stack[i].index = arrays->arrays[i].index;
1970 stack[i].enabled = arrays->arrays[i].enabled;
1973 arrays->active_texture_unit_stack[arrays->stack_index] =
1974 arrays->active_texture_unit;
1976 arrays->stack_index++;
1983 struct array_state_vector *arrays = state->array_state;
1988 arrays->stack_index--;
1989 stack = &arrays->stack[(arrays->stack_index * arrays->num_arrays)];
1991 for (i = 0; i < arrays->num_arrays; i++) {
2010 arrays->active_texture_unit = stack[i].index;
2032 arrays->active_texture_unit =
2033 arrays->active_texture_unit_stack[arrays->stack_index];