Lines Matching refs:arrays
41 * Implement GLX protocol for vertex arrays and vertex buffer objects.
62 * "vbo", to support multiple texture coordinate arrays, generic attributes,
78 const struct array_state_vector *arrays,
81 const struct array_state_vector *arrays,
84 *arrays, GLenum key,
86 static void fill_array_info_cache(struct array_state_vector *arrays);
115 struct array_state_vector *arrays = state->array_state;
117 if (arrays) {
118 free(arrays->stack);
119 arrays->stack = NULL;
120 free(arrays->arrays);
121 arrays->arrays = NULL;
122 free(arrays);
136 * initialized. These values are used to determine what vertex arrays are
143 struct array_state_vector *arrays;
153 arrays = calloc(1, sizeof(struct array_state_vector));
154 state->array_state = arrays;
156 if (arrays == NULL) {
161 arrays->old_DrawArrays_possible = !state->NoDrawArraysProtocol;
162 arrays->new_DrawArrays_possible = GL_FALSE;
163 arrays->DrawArrays = NULL;
165 arrays->active_texture_unit = 0;
168 /* Determine how many arrays are actually needed. Only arrays that
170 * supports only 2 texture units, then only 2 texture coordinate arrays
203 arrays->num_texture_units = texture_units;
204 arrays->num_vertex_program_attribs = vertex_program_attribs;
206 arrays->num_arrays = array_count;
207 arrays->arrays = calloc(array_count, sizeof(struct array_state));
209 if (arrays->arrays == NULL) {
211 free(arrays);
216 arrays->arrays[0].data_type = GL_FLOAT;
217 arrays->arrays[0].count = 3;
218 arrays->arrays[0].key = GL_NORMAL_ARRAY;
219 arrays->arrays[0].normalized = GL_TRUE;
220 arrays->arrays[0].old_DrawArrays_possible = GL_TRUE;
222 arrays->arrays[1].data_type = GL_FLOAT;
223 arrays->arrays[1].count = 4;
224 arrays->arrays[1].key = GL_COLOR_ARRAY;
225 arrays->arrays[1].normalized = GL_TRUE;
226 arrays->arrays[1].old_DrawArrays_possible = GL_TRUE;
228 arrays->arrays[2].data_type = GL_FLOAT;
229 arrays->arrays[2].count = 1;
230 arrays->arrays[2].key = GL_INDEX_ARRAY;
231 arrays->arrays[2].old_DrawArrays_possible = GL_TRUE;
233 arrays->arrays[3].data_type = GL_UNSIGNED_BYTE;
234 arrays->arrays[3].count = 1;
235 arrays->arrays[3].key = GL_EDGE_FLAG_ARRAY;
236 arrays->arrays[3].old_DrawArrays_possible = GL_TRUE;
239 arrays->arrays[4 + i].data_type = GL_FLOAT;
240 arrays->arrays[4 + i].count = 4;
241 arrays->arrays[4 + i].key = GL_TEXTURE_COORD_ARRAY;
243 arrays->arrays[4 + i].old_DrawArrays_possible = (i == 0);
244 arrays->arrays[4 + i].index = i;
250 arrays->arrays[i].data_type = GL_FLOAT;
251 arrays->arrays[i].count = 1;
252 arrays->arrays[i].key = GL_FOG_COORDINATE_ARRAY;
253 arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
258 arrays->arrays[i].data_type = GL_FLOAT;
259 arrays->arrays[i].count = 3;
260 arrays->arrays[i].key = GL_SECONDARY_COLOR_ARRAY;
261 arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
262 arrays->arrays[i].normalized = GL_TRUE;
271 arrays->arrays[idx + i].data_type = GL_FLOAT;
272 arrays->arrays[idx + i].count = 4;
273 arrays->arrays[idx + i].key = GL_VERTEX_ATTRIB_ARRAY_POINTER;
275 arrays->arrays[idx + i].old_DrawArrays_possible = 0;
276 arrays->arrays[idx + i].index = idx;
286 arrays->arrays[i].data_type = GL_FLOAT;
287 arrays->arrays[i].count = 4;
288 arrays->arrays[i].key = GL_VERTEX_ARRAY;
289 arrays->arrays[i].old_DrawArrays_possible = GL_TRUE;
291 assert((i + 1) == arrays->num_arrays);
293 arrays->stack_index = 0;
294 arrays->stack = malloc(sizeof(struct array_stack_state)
295 * arrays->num_arrays
298 if (arrays->stack == NULL) {
300 free(arrays->arrays);
301 free(arrays);
311 * implement the enabled vertex arrays.
314 calculate_single_vertex_size_none(const struct array_state_vector *arrays)
320 for (i = 0; i < arrays->num_arrays; i++) {
321 if (arrays->arrays[i].enabled) {
322 single_vertex_size += arrays->arrays[i].header[0];
335 const struct array_state_vector * arrays, unsigned index)
340 for (i = 0; i < arrays->num_arrays; i++) {
341 if (arrays->arrays[i].enabled) {
342 const size_t offset = index * arrays->arrays[i].true_stride;
350 (void) memset(dst, 0, arrays->arrays[i].header[0]);
352 (void) memcpy(dst, arrays->arrays[i].header, 4);
356 if (arrays->arrays[i].key == GL_TEXTURE_COORD_ARRAY &&
357 arrays->arrays[i].index > 0) {
358 /* Multi-texture coordinate arrays require the texture target
362 GLenum texture = arrays->arrays[i].index + GL_TEXTURE0;
363 if (arrays->arrays[i].data_type == GL_DOUBLE) {
364 (void) memcpy(dst, ((GLubyte *) arrays->arrays[i].data) + offset,
365 arrays->arrays[i].element_size);
366 dst += arrays->arrays[i].element_size;
372 (void) memcpy(dst, ((GLubyte *) arrays->arrays[i].data) + offset,
373 arrays->arrays[i].element_size);
374 dst += __GLX_PAD(arrays->arrays[i].element_size);
376 } else if (arrays->arrays[i].key == GL_VERTEX_ATTRIB_ARRAY_POINTER) {
379 (void) memcpy(dst, &arrays->arrays[i].index, 4);
381 (void) memcpy(dst, ((GLubyte *) arrays->arrays[i].data) + offset,
382 arrays->arrays[i].element_size);
383 dst += __GLX_PAD(arrays->arrays[i].element_size);
385 (void) memcpy(dst, ((GLubyte *) arrays->arrays[i].data) + offset,
386 arrays->arrays[i].element_size);
387 dst += __GLX_PAD(arrays->arrays[i].element_size);
402 const struct array_state_vector * arrays, unsigned index)
407 for (i = 0; i < arrays->num_arrays; i++) {
408 if (arrays->arrays[i].enabled) {
409 const size_t offset = index * arrays->arrays[i].true_stride;
411 (void) memcpy(dst, ((GLubyte *) arrays->arrays[i].data) + offset,
412 arrays->arrays[i].element_size);
414 dst += __GLX_PAD(arrays->arrays[i].element_size);
423 get_array_entry(const struct array_state_vector *arrays,
428 for (i = 0; i < arrays->num_arrays; i++) {
429 if ((arrays->arrays[i].key == key)
430 && (arrays->arrays[i].index == index)) {
431 return &arrays->arrays[i];
440 allocate_array_info_cache(struct array_state_vector *arrays,
444 if (arrays->array_info_cache_buffer_size < required_size) {
445 GLubyte *temp = realloc(arrays->array_info_cache_base,
452 arrays->array_info_cache_base = temp;
453 arrays->array_info_cache = temp + MAX_HEADER_SIZE;
454 arrays->array_info_cache_buffer_size = required_size;
457 arrays->array_info_cache_size = required_size;
465 fill_array_info_cache(struct array_state_vector *arrays)
471 /* Determine how many arrays are enabled.
474 arrays->enabled_client_array_count = 0;
475 old_DrawArrays_possible = arrays->old_DrawArrays_possible;
476 for (i = 0; i < arrays->num_arrays; i++) {
477 if (arrays->arrays[i].enabled) {
478 arrays->enabled_client_array_count++;
479 old_DrawArrays_possible &= arrays->arrays[i].old_DrawArrays_possible;
483 if (arrays->new_DrawArrays_possible) {
484 assert(!arrays->new_DrawArrays_possible);
487 const size_t required_size = arrays->enabled_client_array_count * 12;
491 if (!allocate_array_info_cache(arrays, required_size)) {
496 info = (uint32_t *) arrays->array_info_cache;
497 for (i = 0; i < arrays->num_arrays; i++) {
498 if (arrays->arrays[i].enabled) {
499 *(info++) = arrays->arrays[i].data_type;
500 *(info++) = arrays->arrays[i].count;
501 *(info++) = arrays->arrays[i].key;
505 arrays->DrawArrays = emit_DrawArrays_old;
506 arrays->DrawElements = emit_DrawElements_old;
509 arrays->DrawArrays = emit_DrawArrays_none;
510 arrays->DrawElements = emit_DrawElements_none;
513 arrays->array_info_cache_valid = GL_TRUE;
530 struct array_state_vector *arrays = state->array_state;
539 single_vertex_size = calculate_single_vertex_size_none(arrays);
553 pc = emit_element_none(pc, arrays, first + i);
575 * \param arrays Array state.
590 struct array_state_vector *arrays,
608 for (i = 0; i < arrays->num_arrays; i++) {
609 if (arrays->arrays[i].enabled) {
610 single_vertex_size += __GLX_PAD(arrays->arrays[i].element_size);
614 command_size = arrays->array_info_cache_size + header_size
654 pc = ((GLubyte *) arrays->array_info_cache) - (header_size + 4);
658 *(uint32_t *) (pc + 12) = arrays->enabled_client_array_count;
662 header_size + 4 + arrays->array_info_cache_size);
675 *(uint32_t *) (pc + 8) = arrays->enabled_client_array_count;
680 (void) memcpy(pc, arrays->array_info_cache,
681 arrays->array_info_cache_size);
682 pc += arrays->array_info_cache_size;
701 struct array_state_vector *arrays = state->array_state;
710 pc = emit_DrawArrays_header_old(gc, arrays, &elements_per_request,
714 /* Write the arrays.
721 pc = emit_element_old(pc, arrays, i + first);
742 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];