Lines Matching refs: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;
712 pc = emit_DrawArrays_header_old(gc, arrays, &elements_per_request,
716 /* Write the arrays.
723 pc = emit_element_old(pc, arrays, i + first);
744 pc = emit_element_old(pc, arrays, i + first);
765 struct array_state_vector *arrays = state->array_state;
774 single_vertex_size = calculate_single_vertex_size_none(arrays);
806 pc = emit_element_none(pc, arrays, index);
832 struct array_state_vector *arrays = state->array_state;
842 pc = emit_DrawArrays_header_old(gc, arrays, &elements_per_request,
846 /* Write the arrays.
861 pc = emit_element_old(pc, arrays, index);
870 pc = emit_element_old(pc, arrays, index);
879 pc = emit_element_old(pc, arrays, index);
989 struct array_state_vector *arrays = state->array_state;
993 if (!arrays->array_info_cache_valid) {
994 fill_array_info_cache(arrays);
997 arrays->DrawArrays(mode, first, count);
1008 struct array_state_vector *arrays = state->array_state;
1013 single_vertex_size = calculate_single_vertex_size_none(arrays);
1019 gc->pc = emit_element_none(gc->pc, arrays, index);
1034 struct array_state_vector *arrays = state->array_state;
1039 if (!arrays->array_info_cache_valid) {
1040 fill_array_info_cache(arrays);
1043 arrays->DrawElements(mode, count, type, indices);
1056 struct array_state_vector *arrays = state->array_state;
1066 if (!arrays->array_info_cache_valid) {
1067 fill_array_info_cache(arrays);
1070 arrays->DrawElements(mode, count, type, indices);
1082 struct array_state_vector *arrays = state->array_state;
1087 if (!arrays->array_info_cache_valid) {
1088 fill_array_info_cache(arrays);
1093 arrays->DrawArrays(mode, first[i], count[i]);
1108 struct array_state_vector *arrays = state->array_state;
1113 if (!arrays->array_info_cache_valid) {
1114 fill_array_info_cache(arrays);
1119 arrays->DrawElements(mode, count[i], type, indices[i]);
1166 struct array_state_vector *arrays = state->array_state;
1193 a = get_array_entry(arrays, GL_VERTEX_ARRAY, 0);
1199 arrays->array_info_cache_valid = GL_FALSE;
1211 struct array_state_vector *arrays = state->array_state;
1241 a = get_array_entry(arrays, GL_NORMAL_ARRAY, 0);
1246 arrays->array_info_cache_valid = GL_FALSE;
1282 struct array_state_vector *arrays = state->array_state;
1321 a = get_array_entry(arrays, GL_COLOR_ARRAY, 0);
1326 arrays->array_info_cache_valid = GL_FALSE;
1337 struct array_state_vector *arrays = state->array_state;
1367 a = get_array_entry(arrays, GL_INDEX_ARRAY, 0);
1372 arrays->array_info_cache_valid = GL_FALSE;
1382 struct array_state_vector *arrays = state->array_state;
1392 a = get_array_entry(arrays, GL_EDGE_FLAG_ARRAY, 0);
1398 arrays->array_info_cache_valid = GL_FALSE;
1444 struct array_state_vector *arrays = state->array_state;
1455 index = arrays->active_texture_unit;
1499 a = get_array_entry(arrays, GL_TEXTURE_COORD_ARRAY, index);
1505 arrays->array_info_cache_valid = GL_FALSE;
1517 struct array_state_vector *arrays = state->array_state;
1556 a = get_array_entry(arrays, GL_SECONDARY_COLOR_ARRAY, 0);
1565 arrays->array_info_cache_valid = GL_FALSE;
1577 struct array_state_vector *arrays = state->array_state;
1598 a = get_array_entry(arrays, GL_FOG_COORD_ARRAY, 0);
1607 arrays->array_info_cache_valid = GL_FALSE;
1633 struct array_state_vector *arrays = state->array_state;
1640 || (index > arrays->num_vertex_program_attribs)) {
1711 a = get_array_entry(arrays, GL_VERTEX_ATTRIB_ARRAY_POINTER, index);
1724 arrays->array_info_cache_valid = GL_FALSE;
1774 struct array_state_vector *const arrays = state->array_state;
1778 if ((unit < 0) || (unit >= arrays->num_texture_units)) {
1783 arrays->active_texture_unit = unit;
1794 struct array_state_vector *arrays = state->array_state;
1798 /* Texture coordinate arrays have an implict index set when the
1802 index = arrays->active_texture_unit;
1805 a = get_array_entry(arrays, key, index);
1809 arrays->array_info_cache_valid = GL_FALSE;
1819 struct array_state_vector *arrays = state->array_state;
1823 for (i = 0; i < arrays->num_arrays; i++) {
1824 arrays->arrays[i].enabled = GL_FALSE;
1827 arrays->array_info_cache_valid = GL_FALSE;
1837 const struct array_state_vector *arrays = state->array_state;
1839 get_array_entry((struct array_state_vector *) arrays,
1856 const struct array_state_vector *arrays = state->array_state;
1858 get_array_entry((struct array_state_vector *) arrays,
1875 const struct array_state_vector *arrays = state->array_state;
1877 get_array_entry((struct array_state_vector *) arrays,
1894 const struct array_state_vector *arrays = state->array_state;
1896 get_array_entry((struct array_state_vector *) arrays,
1913 const struct array_state_vector *arrays = state->array_state;
1915 get_array_entry((struct array_state_vector *) arrays,
1933 const struct array_state_vector *arrays = state->array_state;
1935 get_array_entry((struct array_state_vector *) arrays,
1959 struct array_state_vector *arrays = state->array_state;
1961 &arrays->stack[(arrays->stack_index * arrays->num_arrays)];
1965 for (i = 0; i < arrays->num_arrays; i++) {
1966 stack[i].data = arrays->arrays[i].data;
1967 stack[i].data_type = arrays->arrays[i].data_type;
1968 stack[i].user_stride = arrays->arrays[i].user_stride;
1969 stack[i].count = arrays->arrays[i].count;
1970 stack[i].key = arrays->arrays[i].key;
1971 stack[i].index = arrays->arrays[i].index;
1972 stack[i].enabled = arrays->arrays[i].enabled;
1975 arrays->active_texture_unit_stack[arrays->stack_index] =
1976 arrays->active_texture_unit;
1978 arrays->stack_index++;
1985 struct array_state_vector *arrays = state->array_state;
1990 arrays->stack_index--;
1991 stack = &arrays->stack[(arrays->stack_index * arrays->num_arrays)];
1993 for (i = 0; i < arrays->num_arrays; i++) {
2012 arrays->active_texture_unit = stack[i].index;
2034 arrays->active_texture_unit =
2035 arrays->active_texture_unit_stack[arrays->stack_index];