st_draw.c File Reference

Include dependency graph for st_draw.c:

Go to the source code of this file.

Functions
GLuint	st_pipe_vertex_format (GLenum type, GLuint size, GLboolean normalized)
	Return a PIPE_FORMAT_x for the given GL datatype and size.
static void *	setup_edgeflags (GLcontext *ctx, GLenum primMode, GLint start, GLint count, const struct gl_client_array *array)
static GLboolean	is_interleaved_arrays (const struct st_vertex_program *vp, const struct gl_client_array **arrays, GLboolean *userSpace)
	Examine the active arrays to determine if we have interleaved vertex arrays all living in one VBO, or all living in user space.
static void	get_user_arrays_bounds (const struct st_vertex_program *vp, const struct gl_client_array **arrays, GLuint max_index, const GLubyte **low, const GLubyte **high)
	Once we know all the arrays are in user space, this function computes the memory range occupied by the arrays.
static void	setup_interleaved_attribs (GLcontext *ctx, const struct st_vertex_program *vp, const struct gl_client_array **arrays, GLuint max_index, GLboolean userSpace, struct pipe_vertex_buffer *vbuffer, struct pipe_vertex_element velements[])
	Set up for drawing interleaved arrays that all live in one VBO or all live in user space.
static void	setup_non_interleaved_attribs (GLcontext *ctx, const struct st_vertex_program *vp, const struct gl_client_array **arrays, GLuint max_index, GLboolean *userSpace, struct pipe_vertex_buffer vbuffer[], struct pipe_vertex_element velements[])
	Set up a separate pipe_vertex_buffer and pipe_vertex_element for each vertex attribute.
static void	check_uniforms (GLcontext *ctx)
	Prior to drawing, check that any uniforms referenced by the current shader have been set.
void	st_draw_vbo (GLcontext *ctx, const struct gl_client_array **arrays, const struct _mesa_prim *prims, GLuint nr_prims, const struct _mesa_index_buffer *ib, GLuint min_index, GLuint max_index)
	This function gets plugged into the VBO module and is called when we have something to render.
void	st_init_draw (struct st_context *st)
void	st_destroy_draw (struct st_context *st)
Variables
static GLuint	double_types [4]
static GLuint	float_types [4]
static GLuint	uint_types_norm [4]
static GLuint	uint_types_scale [4]
static GLuint	int_types_norm [4]
static GLuint	int_types_scale [4]
static GLuint	ushort_types_norm [4]
static GLuint	ushort_types_scale [4]
static GLuint	short_types_norm [4]
static GLuint	short_types_scale [4]
static GLuint	ubyte_types_norm [4]
static GLuint	ubyte_types_scale [4]
static GLuint	byte_types_norm [4]
static GLuint	byte_types_scale [4]
static GLuint	fixed_types [4]

---

Function Documentation

static void check_uniforms

(

GLcontext *

ctx

)

[static]

Prior to drawing, check that any uniforms referenced by the current shader have been set.

If a uniform has not been set, issue a warning.

Definition at line 495 of file st_draw.c.

{
   const struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
   if (shProg && shProg->LinkStatus) {
      GLuint i;
      for (i = 0; i < shProg->Uniforms->NumUniforms; i++) {
         const struct gl_uniform *u = &shProg->Uniforms->Uniforms[i];
         if (!u->Initialized) {
            _mesa_warning(ctx,
                          "Using shader with uninitialized uniform: %s",
                          u->Name);
         }
      }
   }
}

static void get_user_arrays_bounds	(	const struct st_vertex_program *	vp,
		const struct gl_client_array **	arrays,
		GLuint	max_index,
		const GLubyte **	low,
		const GLubyte **	high
	)			[static]

Once we know all the arrays are in user space, this function computes the memory range occupied by the arrays.

Definition at line 315 of file st_draw.c.

References st_vertex_program::index_to_input, MIN2, st_vertex_program::num_inputs, and stride().

{
   const GLubyte *low_addr = NULL;
   GLuint attr;
   GLint stride;

   for (attr = 0; attr < vp->num_inputs; attr++) {
      const GLuint mesaAttr = vp->index_to_input[attr];
      const GLubyte *start = arrays[mesaAttr]->Ptr;
      stride = arrays[mesaAttr]->StrideB;
      if (attr == 0) {
         low_addr = start;
      }
      else {
         low_addr = MIN2(low_addr, start);
      }
   }

   *low = low_addr;
   *high = low_addr + (max_index + 1) * stride;
}

static GLboolean is_interleaved_arrays	(	const struct st_vertex_program *	vp,
		const struct gl_client_array **	arrays,
		GLboolean *	userSpace
	)			[static]

Examine the active arrays to determine if we have interleaved vertex arrays all living in one VBO, or all living in user space.

Parameters:

userSpace

returns whether the arrays are in user space.

Definition at line 260 of file st_draw.c.

References abs(), st_vertex_program::index_to_input, st_vertex_program::num_inputs, and stride().

{
   GLuint attr;
   const struct gl_buffer_object *firstBufObj = NULL;
   GLint firstStride = -1;
   GLuint num_client_arrays = 0;
   const GLubyte *client_addr = NULL;

   for (attr = 0; attr < vp->num_inputs; attr++) {
      const GLuint mesaAttr = vp->index_to_input[attr];
      const struct gl_buffer_object *bufObj = arrays[mesaAttr]->BufferObj;
      const GLsizei stride = arrays[mesaAttr]->StrideB; /* in bytes */

      if (firstStride < 0) {
         firstStride = stride;
      }
      else if (firstStride != stride) {
         return GL_FALSE;
      }
         
      if (!bufObj || !bufObj->Name) {
         num_client_arrays++;
         /* Try to detect if the client-space arrays are
          * "close" to each other.
          */
         if (!client_addr) {
            client_addr = arrays[mesaAttr]->Ptr;
         }
         else if (abs(arrays[mesaAttr]->Ptr - client_addr) > firstStride) {
            /* arrays start too far apart */
            return GL_FALSE;
         }
      }
      else if (!firstBufObj) {
         firstBufObj = bufObj;
      }
      else if (bufObj != firstBufObj) {
         return GL_FALSE;
      }
   }

   *userSpace = (num_client_arrays == vp->num_inputs);
   /*printf("user space: %d\n", (int) *userSpace);*/

   return GL_TRUE;
}

static void* setup_edgeflags	(	GLcontext *	ctx,
		GLenum	primMode,
		GLint	start,
		GLint	count,
		const struct gl_client_array *	array
	)			[static]

Definition at line 207 of file st_draw.c.

References st_buffer_object::buffer, pipe_buffer_map(), pipe_buffer_unmap(), PIPE_BUFFER_USAGE_CPU_READ, pipe_context::screen, pipe_context::set_edgeflags, and st_buffer_object().

{
   struct pipe_context *pipe = ctx->st->pipe;

   if ((primMode == GL_TRIANGLES ||
        primMode == GL_QUADS ||
        primMode == GL_POLYGON) &&
       (ctx->Polygon.FrontMode != GL_FILL ||
        ctx->Polygon.BackMode != GL_FILL)) {
      /* need edge flags */
      GLint i;
      unsigned *vec;
      struct st_buffer_object *stobj = st_buffer_object(array->BufferObj);
      ubyte *map;

      if (!stobj)
         return NULL;

      vec = (unsigned *) calloc(sizeof(unsigned), (count + 31) / 32);
      if (!vec)
         return NULL;

      map = pipe_buffer_map(pipe->screen, stobj->buffer, PIPE_BUFFER_USAGE_CPU_READ);
      map = ADD_POINTERS(map, array->Ptr);

      for (i = 0; i < count; i++) {
         if (*((float *) map))
            vec[i/32] |= 1 << (i % 32);

         map += array->StrideB;
      }

      pipe_buffer_unmap(pipe->screen, stobj->buffer);

      pipe->set_edgeflags(pipe, vec);

      return vec;
   }
   else {
      /* edge flags not needed */
      pipe->set_edgeflags(pipe, NULL);
      return NULL;
   }
}

static void setup_interleaved_attribs	(	GLcontext *	ctx,
		const struct st_vertex_program *	vp,
		const struct gl_client_array **	arrays,
		GLuint	max_index,
		GLboolean	userSpace,
		struct pipe_vertex_buffer *	vbuffer,
		struct pipe_vertex_element	velements[]
	)			[static]

Set up for drawing interleaved arrays that all live in one VBO or all live in user space.

Parameters:

	vbuffer	returns vertex buffer info
	velements	returns vertex element info

Definition at line 348 of file st_draw.c.

References assert, st_buffer_object::buffer, pipe_vertex_buffer::buffer, pipe_vertex_buffer::buffer_offset, get_user_arrays_bounds(), st_vertex_program::index_to_input, pipe_vertex_buffer::max_index, pipe_vertex_element::nr_components, st_vertex_program::num_inputs, pipe_buffer_reference(), pipe_user_buffer_create(), pipe_vertex_buffer::pitch, pipe_context::screen, pipe_vertex_element::src_format, pipe_vertex_element::src_offset, st_buffer_object(), st_pipe_vertex_format(), stride(), and pipe_vertex_element::vertex_buffer_index.

{
   struct pipe_context *pipe = ctx->st->pipe;
   GLuint attr;
   const GLubyte *offset0;

   for (attr = 0; attr < vp->num_inputs; attr++) {
      const GLuint mesaAttr = vp->index_to_input[attr];
      struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj;
      struct st_buffer_object *stobj = st_buffer_object(bufobj);
      GLsizei stride = arrays[mesaAttr]->StrideB;

      /*printf("stobj %u = %p\n", attr, (void*)stobj);*/

      if (attr == 0) {
         if (userSpace) {
            const GLubyte *low, *high;
            get_user_arrays_bounds(vp, arrays, max_index, &low, &high);
            /*printf("user buffer range: %p %p  %d\n", low, high, high-low);*/
            vbuffer->buffer =
               pipe_user_buffer_create(pipe->screen, (void *) low, high - low);
            vbuffer->buffer_offset = 0;
            offset0 = low;
         }
         else {
            vbuffer->buffer = NULL;
            pipe_buffer_reference(pipe->screen, &vbuffer->buffer, stobj->buffer);
            vbuffer->buffer_offset = (unsigned) arrays[mesaAttr]->Ptr;
            offset0 = arrays[mesaAttr]->Ptr;
         }
         vbuffer->pitch = stride; /* in bytes */
         vbuffer->max_index = max_index;
      }

      velements[attr].src_offset =
         (unsigned) (arrays[mesaAttr]->Ptr - offset0);
      velements[attr].vertex_buffer_index = 0;
      velements[attr].nr_components = arrays[mesaAttr]->Size;
      velements[attr].src_format =
         st_pipe_vertex_format(arrays[mesaAttr]->Type,
                               arrays[mesaAttr]->Size,
                               arrays[mesaAttr]->Normalized);
      assert(velements[attr].src_format);
   }
}

static void setup_non_interleaved_attribs	(	GLcontext *	ctx,
		const struct st_vertex_program *	vp,
		const struct gl_client_array **	arrays,
		GLuint	max_index,
		GLboolean *	userSpace,
		struct pipe_vertex_buffer	vbuffer[],
		struct pipe_vertex_element	velements[]
	)			[static]

Set up a separate pipe_vertex_buffer and pipe_vertex_element for each vertex attribute.

Parameters:

	vbuffer	returns vertex buffer info
	velements	returns vertex element info

Definition at line 408 of file st_draw.c.

References assert, pipe_vertex_buffer::buffer, st_buffer_object::buffer, pipe_vertex_buffer::buffer_offset, st_vertex_program::index_to_input, pipe_vertex_buffer::max_index, pipe_vertex_element::nr_components, st_vertex_program::num_inputs, pipe_buffer_reference(), pipe_user_buffer_create(), pipe_vertex_buffer::pitch, pipe_context::screen, pipe_vertex_element::src_format, pipe_vertex_element::src_offset, st_buffer_object(), st_pipe_vertex_format(), stride(), and pipe_vertex_element::vertex_buffer_index.

{
   struct pipe_context *pipe = ctx->st->pipe;
   GLuint attr;

   for (attr = 0; attr < vp->num_inputs; attr++) {
      const GLuint mesaAttr = vp->index_to_input[attr];
      struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj;
      GLsizei stride = arrays[mesaAttr]->StrideB;

      *userSpace = GL_FALSE;

      if (bufobj && bufobj->Name) {
         /* Attribute data is in a VBO.
          * Recall that for VBOs, the gl_client_array->Ptr field is
          * really an offset from the start of the VBO, not a pointer.
          */
         struct st_buffer_object *stobj = st_buffer_object(bufobj);
         assert(stobj->buffer);
         /*printf("stobj %u = %p\n", attr, (void*) stobj);*/

         vbuffer[attr].buffer = NULL;
         pipe_buffer_reference(pipe->screen, &vbuffer[attr].buffer, stobj->buffer);
         vbuffer[attr].buffer_offset = (unsigned) arrays[mesaAttr]->Ptr;
         velements[attr].src_offset = 0;
      }
      else {
         /* attribute data is in user-space memory, not a VBO */
         uint bytes;
         /*printf("user-space array %d stride %d\n", attr, stride);*/
        
         *userSpace = GL_TRUE;

         /* wrap user data */
         if (arrays[mesaAttr]->Ptr) {
            /* user's vertex array */
            if (arrays[mesaAttr]->StrideB) {
               bytes = arrays[mesaAttr]->StrideB * (max_index + 1);
            }
            else {
               bytes = arrays[mesaAttr]->Size
                  * _mesa_sizeof_type(arrays[mesaAttr]->Type);
            }
            vbuffer[attr].buffer = pipe_user_buffer_create(pipe->screen,
                           (void *) arrays[mesaAttr]->Ptr, bytes);
         }
         else {
            /* no array, use ctx->Current.Attrib[] value */
            bytes = sizeof(ctx->Current.Attrib[0]);
            vbuffer[attr].buffer = pipe_user_buffer_create(pipe->screen,
                           (void *) ctx->Current.Attrib[mesaAttr], bytes);
            stride = 0;
         }

         vbuffer[attr].buffer_offset = 0;
         velements[attr].src_offset = 0;
      }

      assert(velements[attr].src_offset <= 2048); /* 11-bit field */

      /* common-case setup */
      vbuffer[attr].pitch = stride; /* in bytes */
      vbuffer[attr].max_index = max_index;
      velements[attr].vertex_buffer_index = attr;
      velements[attr].nr_components = arrays[mesaAttr]->Size;
      velements[attr].src_format
         = st_pipe_vertex_format(arrays[mesaAttr]->Type,
                                 arrays[mesaAttr]->Size,
                                 arrays[mesaAttr]->Normalized);
      assert(velements[attr].src_format);
   }
}

void st_destroy_draw

(

struct st_context *

st

)

Definition at line 693 of file st_draw.c.

{
}

void st_draw_vbo	(	GLcontext *	ctx,
		const struct gl_client_array **	arrays,
		const struct _mesa_prim *	prims,
		GLuint	nr_prims,
		const struct _mesa_index_buffer *	ib,
		GLuint	min_index,
		GLuint	max_index
	)

This function gets plugged into the VBO module and is called when we have something to render.

Basically, translate the information into the format expected by gallium.

Definition at line 518 of file st_draw.c.

References assert, pipe_vertex_buffer::buffer, st_buffer_object::buffer, check_uniforms(), pipe_context::draw_arrays, pipe_context::draw_elements, pipe_context::draw_range_elements, is_interleaved_arrays(), mode, pipe_vertex_element::nr_components, st_vertex_program::num_inputs, pf_name(), pipe_buffer_reference(), pipe_user_buffer_create(), pipe_context::screen, pipe_context::set_vertex_buffers, pipe_context::set_vertex_elements, setup_edgeflags(), setup_interleaved_attribs(), setup_non_interleaved_attribs(), pipe_vertex_element::src_format, pipe_vertex_element::src_offset, st_buffer_object(), st_validate_state(), and pipe_vertex_element::vertex_buffer_index.

{
   struct pipe_context *pipe = ctx->st->pipe;
   const struct st_vertex_program *vp;
   const struct pipe_shader_state *vs;
   struct pipe_vertex_buffer vbuffer[PIPE_MAX_SHADER_INPUTS];
   GLuint attr;
   struct pipe_vertex_element velements[PIPE_MAX_ATTRIBS];
   unsigned num_vbuffers, num_velements;
   GLboolean userSpace;

   /* sanity check for pointer arithmetic below */
   assert(sizeof(arrays[0]->Ptr[0]) == 1);

   st_validate_state(ctx->st);

   /* must get these after state validation! */
   vp = ctx->st->vp;
   vs = &ctx->st->vp->state;

   if (MESA_VERBOSE & VERBOSE_GLSL) {
      check_uniforms(ctx);
   }

   /*
    * Setup the vbuffer[] and velements[] arrays.
    */
   if (is_interleaved_arrays(vp, arrays, &userSpace)) {
      /*printf("Draw interleaved\n");*/
      setup_interleaved_attribs(ctx, vp, arrays, max_index, userSpace,
                                vbuffer, velements);
      num_vbuffers = 1;
      num_velements = vp->num_inputs;
      if (num_velements == 0)
         num_vbuffers = 0;
   }
   else {
      /*printf("Draw non-interleaved\n");*/
      setup_non_interleaved_attribs(ctx, vp, arrays, max_index,
                                    &userSpace, vbuffer, velements);
      num_vbuffers = vp->num_inputs;
      num_velements = vp->num_inputs;
   }

#if 0
   {
      GLuint i;
      for (i = 0; i < num_vbuffers; i++) {
         printf("buffers[%d].pitch = %u\n", i, vbuffer[i].pitch);
         printf("buffers[%d].max_index = %u\n", i, vbuffer[i].max_index);
         printf("buffers[%d].buffer_offset = %u\n", i, vbuffer[i].buffer_offset);
         printf("buffers[%d].buffer = %p\n", i, (void*) vbuffer[i].buffer);
      }
      for (i = 0; i < num_velements; i++) {
         printf("vlements[%d].vbuffer_index = %u\n", i, velements[i].vertex_buffer_index);
         printf("vlements[%d].src_offset = %u\n", i, velements[i].src_offset);
         printf("vlements[%d].nr_comps = %u\n", i, velements[i].nr_components);
         printf("vlements[%d].format = %s\n", i, pf_name(velements[i].src_format));
      }
   }
#endif

   pipe->set_vertex_buffers(pipe, num_vbuffers, vbuffer);
   pipe->set_vertex_elements(pipe, num_velements, velements);

   if (num_vbuffers == 0 || num_velements == 0)
      return;

   /* do actual drawing */
   if (ib) {
      /* indexed primitive */
      struct gl_buffer_object *bufobj = ib->obj;
      struct pipe_buffer *indexBuf = NULL;
      unsigned indexSize, indexOffset, i;

      switch (ib->type) {
      case GL_UNSIGNED_INT:
         indexSize = 4;
         break;
      case GL_UNSIGNED_SHORT:
         indexSize = 2;
         break;
      case GL_UNSIGNED_BYTE:
         indexSize = 1;
         break;
      default:
         assert(0);
         return;
      }

      /* get/create the index buffer object */
      if (bufobj && bufobj->Name) {
         /* elements/indexes are in a real VBO */
         struct st_buffer_object *stobj = st_buffer_object(bufobj);
         pipe_buffer_reference(pipe->screen, &indexBuf, stobj->buffer);
         indexOffset = (unsigned) ib->ptr / indexSize;
      }
      else {
         /* element/indicies are in user space memory */
         indexBuf = pipe_user_buffer_create(pipe->screen, (void *) ib->ptr,
                                            ib->count * indexSize);
         indexOffset = 0;
      }

      /* draw */
      if (nr_prims == 1 && pipe->draw_range_elements != NULL) {
         i = 0;

         /* XXX: exercise temporary path to pass min/max directly
          * through to driver & draw module.  These interfaces still
          * need a bit of work...
          */
         setup_edgeflags(ctx, prims[i].mode,
                         prims[i].start + indexOffset, prims[i].count,
                         arrays[VERT_ATTRIB_EDGEFLAG]);

         pipe->draw_range_elements(pipe, indexBuf, indexSize,
                                   min_index,
                                   max_index,
                                   prims[i].mode,
                                   prims[i].start + indexOffset, prims[i].count);
      }
      else {
         for (i = 0; i < nr_prims; i++) {
            setup_edgeflags(ctx, prims[i].mode,
                            prims[i].start + indexOffset, prims[i].count,
                            arrays[VERT_ATTRIB_EDGEFLAG]);
            
            pipe->draw_elements(pipe, indexBuf, indexSize,
                                prims[i].mode,
                                prims[i].start + indexOffset, prims[i].count);
         }
      }

      pipe_buffer_reference(pipe->screen, &indexBuf, NULL);
   }
   else {
      /* non-indexed */
      GLuint i;
      for (i = 0; i < nr_prims; i++) {
         setup_edgeflags(ctx, prims[i].mode,
                         prims[i].start, prims[i].count,
                         arrays[VERT_ATTRIB_EDGEFLAG]);

         pipe->draw_arrays(pipe, prims[i].mode, prims[i].start, prims[i].count);
      }
   }

   /* unreference buffers (frees wrapped user-space buffer objects) */
   for (attr = 0; attr < num_vbuffers; attr++) {
      pipe_buffer_reference(pipe->screen, &vbuffer[attr].buffer, NULL);
      assert(!vbuffer[attr].buffer);
   }

   if (userSpace) 
   {
      pipe->set_vertex_buffers(pipe, 0, NULL);
   }
}

void st_init_draw

(

struct st_context *

st

)

Definition at line 685 of file st_draw.c.

References st_context::ctx, and st_draw_vbo().

{
   GLcontext *ctx = st->ctx;

   vbo_set_draw_func(ctx, st_draw_vbo);
}

GLuint st_pipe_vertex_format	(	GLenum	type,
		GLuint	size,
		GLboolean	normalized
	)

Return a PIPE_FORMAT_x for the given GL datatype and size.

Definition at line 162 of file st_draw.c.

References assert, byte_types_norm, byte_types_scale, double_types, fixed_types, float_types, int_types_norm, int_types_scale, short_types_norm, short_types_scale, ubyte_types_norm, ubyte_types_scale, uint_types_norm, uint_types_scale, ushort_types_norm, and ushort_types_scale.

{
   assert((type >= GL_BYTE && type <= GL_DOUBLE) ||
          type == GL_FIXED);
   assert(size >= 1);
   assert(size <= 4);

   if (normalized) {
      switch (type) {
      case GL_DOUBLE: return double_types[size-1];
      case GL_FLOAT: return float_types[size-1];
      case GL_INT: return int_types_norm[size-1];
      case GL_SHORT: return short_types_norm[size-1];
      case GL_BYTE: return byte_types_norm[size-1];
      case GL_UNSIGNED_INT: return uint_types_norm[size-1];
      case GL_UNSIGNED_SHORT: return ushort_types_norm[size-1];
      case GL_UNSIGNED_BYTE: return ubyte_types_norm[size-1];
      case GL_FIXED: return fixed_types[size-1];
      default: assert(0); return 0;
      }      
   }
   else {
      switch (type) {
      case GL_DOUBLE: return double_types[size-1];
      case GL_FLOAT: return float_types[size-1];
      case GL_INT: return int_types_scale[size-1];
      case GL_SHORT: return short_types_scale[size-1];
      case GL_BYTE: return byte_types_scale[size-1];
      case GL_UNSIGNED_INT: return uint_types_scale[size-1];
      case GL_UNSIGNED_SHORT: return ushort_types_scale[size-1];
      case GL_UNSIGNED_BYTE: return ubyte_types_scale[size-1];
      case GL_FIXED: return fixed_types[size-1];
      default: assert(0); return 0;
      }      
   }
   return 0; /* silence compiler warning */
}

---

Variable Documentation

GLuint byte_types_norm[4] [static]

Initial value:

 {
   PIPE_FORMAT_R8_SNORM,
   PIPE_FORMAT_R8G8_SNORM,
   PIPE_FORMAT_R8G8B8_SNORM,
   PIPE_FORMAT_R8G8B8A8_SNORM
}

Definition at line 135 of file st_draw.c.

GLuint byte_types_scale[4] [static]

Initial value:

 {
   PIPE_FORMAT_R8_SSCALED,
   PIPE_FORMAT_R8G8_SSCALED,
   PIPE_FORMAT_R8G8B8_SSCALED,
   PIPE_FORMAT_R8G8B8A8_SSCALED
}

Definition at line 142 of file st_draw.c.

GLuint double_types[4] [static]

Initial value:

 {
   PIPE_FORMAT_R64_FLOAT,
   PIPE_FORMAT_R64G64_FLOAT,
   PIPE_FORMAT_R64G64B64_FLOAT,
   PIPE_FORMAT_R64G64B64A64_FLOAT
}

Definition at line 51 of file st_draw.c.

GLuint fixed_types[4] [static]

Initial value:

 {
   PIPE_FORMAT_R32_FIXED,
   PIPE_FORMAT_R32G32_FIXED,
   PIPE_FORMAT_R32G32B32_FIXED,
   PIPE_FORMAT_R32G32B32A32_FIXED
}

Definition at line 149 of file st_draw.c.

GLuint float_types[4] [static]

Initial value:

 {
   PIPE_FORMAT_R32_FLOAT,
   PIPE_FORMAT_R32G32_FLOAT,
   PIPE_FORMAT_R32G32B32_FLOAT,
   PIPE_FORMAT_R32G32B32A32_FLOAT
}

Definition at line 58 of file st_draw.c.

GLuint int_types_norm[4] [static]

Initial value:

 {
   PIPE_FORMAT_R32_SNORM,
   PIPE_FORMAT_R32G32_SNORM,
   PIPE_FORMAT_R32G32B32_SNORM,
   PIPE_FORMAT_R32G32B32A32_SNORM
}

Definition at line 79 of file st_draw.c.

GLuint int_types_scale[4] [static]

Initial value:

 {
   PIPE_FORMAT_R32_SSCALED,
   PIPE_FORMAT_R32G32_SSCALED,
   PIPE_FORMAT_R32G32B32_SSCALED,
   PIPE_FORMAT_R32G32B32A32_SSCALED
}

Definition at line 86 of file st_draw.c.

GLuint short_types_norm[4] [static]

Initial value:

 {
   PIPE_FORMAT_R16_SNORM,
   PIPE_FORMAT_R16G16_SNORM,
   PIPE_FORMAT_R16G16B16_SNORM,
   PIPE_FORMAT_R16G16B16A16_SNORM
}

Definition at line 107 of file st_draw.c.

GLuint short_types_scale[4] [static]

Initial value:

 {
   PIPE_FORMAT_R16_SSCALED,
   PIPE_FORMAT_R16G16_SSCALED,
   PIPE_FORMAT_R16G16B16_SSCALED,
   PIPE_FORMAT_R16G16B16A16_SSCALED
}

Definition at line 114 of file st_draw.c.

GLuint ubyte_types_norm[4] [static]

Initial value:

 {
   PIPE_FORMAT_R8_UNORM,
   PIPE_FORMAT_R8G8_UNORM,
   PIPE_FORMAT_R8G8B8_UNORM,
   PIPE_FORMAT_R8G8B8A8_UNORM
}

Definition at line 121 of file st_draw.c.

GLuint ubyte_types_scale[4] [static]

Initial value:

 {
   PIPE_FORMAT_R8_USCALED,
   PIPE_FORMAT_R8G8_USCALED,
   PIPE_FORMAT_R8G8B8_USCALED,
   PIPE_FORMAT_R8G8B8A8_USCALED
}

Definition at line 128 of file st_draw.c.

GLuint uint_types_norm[4] [static]

Initial value:

 {
   PIPE_FORMAT_R32_UNORM,
   PIPE_FORMAT_R32G32_UNORM,
   PIPE_FORMAT_R32G32B32_UNORM,
   PIPE_FORMAT_R32G32B32A32_UNORM
}

Definition at line 65 of file st_draw.c.

GLuint uint_types_scale[4] [static]

Initial value:

 {
   PIPE_FORMAT_R32_USCALED,
   PIPE_FORMAT_R32G32_USCALED,
   PIPE_FORMAT_R32G32B32_USCALED,
   PIPE_FORMAT_R32G32B32A32_USCALED
}

Definition at line 72 of file st_draw.c.

GLuint ushort_types_norm[4] [static]

Initial value:

 {
   PIPE_FORMAT_R16_UNORM,
   PIPE_FORMAT_R16G16_UNORM,
   PIPE_FORMAT_R16G16B16_UNORM,
   PIPE_FORMAT_R16G16B16A16_UNORM
}

Definition at line 93 of file st_draw.c.

GLuint ushort_types_scale[4] [static]

Initial value:

 {
   PIPE_FORMAT_R16_USCALED,
   PIPE_FORMAT_R16G16_USCALED,
   PIPE_FORMAT_R16G16B16_USCALED,
   PIPE_FORMAT_R16G16B16A16_USCALED
}

Definition at line 100 of file st_draw.c.

---