summaryrefslogtreecommitdiffstats
path: root/src/mesa/pipe/p_state.h
blob: e51b9c460f2522fd43f342ed89c3e1c06ca8d628 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
/**************************************************************************
 * 
 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
 * All Rights Reserved.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sub license, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 * 
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial portions
 * of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 * 
 **************************************************************************/


/**
 * Abstract graphics pipe state objects.
 *
 * Basic notes:
 *   1. Want compact representations, so we use bitfields.
 *   2. Put bitfields before other (GLfloat) fields.
 */


#ifndef PIPE_STATE_H
#define PIPE_STATE_H

#include "mtypes.h"



/**
 * Implementation limits
 */
#define PIPE_MAX_SAMPLERS     8
#define PIPE_MAX_CLIP_PLANES  6
#define PIPE_MAX_CONSTANT    32
#define PIPE_ATTRIB_MAX      32
#define PIPE_MAX_COLOR_BUFS   8


/* fwd decl */
struct pipe_surface;


/***
 *** State objects
 ***/


/**
 * Primitive (point/line/tri) setup info
 */
struct pipe_setup_state
{
   GLuint flatshade:1;
   GLuint light_twoside:1;

   GLuint front_winding:2;  /**< PIPE_WINDING_x */

   GLuint cull_mode:2;      /**< PIPE_WINDING_x */

   GLuint fill_cw:2;        /**< PIPE_POLYGON_MODE_x */
   GLuint fill_ccw:2;       /**< PIPE_POLYGON_MODE_x */

   GLuint offset_cw:1;
   GLuint offset_ccw:1;

   GLuint scissor:1;

   GLuint poly_smooth:1;
   GLuint poly_stipple_enable:1;

   GLuint line_smooth:1;
   GLuint line_stipple_enable:1;

   GLuint point_smooth:1;

   GLuint multisample:1;         /* XXX maybe more ms state in future */

   GLubyte line_stipple_factor;  /**< [1..256] actually */
   GLushort line_stipple_pattern;
   GLfloat line_width;
   GLfloat point_size;           /**< used when no per-vertex size */
   GLfloat offset_units;
   GLfloat offset_scale;
};

struct pipe_poly_stipple {
   GLuint stipple[32];
};


struct pipe_viewport_state {
   GLfloat scale[4];
   GLfloat translate[4];
};

struct pipe_scissor_state {
   GLshort minx;
   GLshort miny;
   GLshort maxx;
   GLshort maxy;
};

struct pipe_clip_state {
   GLfloat ucp[PIPE_MAX_CLIP_PLANES][4];
   GLuint nr;
};


struct pipe_constant_buffer {
   GLfloat constant[PIPE_MAX_CONSTANT][4];
   GLuint nr_constants;
};


struct pipe_fs_state {
   GLbitfield inputs_read;		/* FRAG_ATTRIB_* */
   const struct tgsi_token *tokens;
   struct pipe_constant_buffer *constants; /* XXX temporary? */
};

struct pipe_depth_state
{
   GLuint enabled:1;   /**< depth test enabled? */
   GLuint writemask:1; /**< allow depth buffer writes? */
   GLuint func:3;      /**< depth test func (PIPE_FUNC_x) */
   GLuint occlusion_count:1; /**< XXX move this elsewhere? */
   GLfloat clear;      /**< Clear value in [0,1] (XXX correct place?) */
};

struct pipe_alpha_test_state {
   GLuint enabled:1;
   GLuint func:3;    /**< PIPE_FUNC_x */
   GLfloat ref;      /**< reference value */
};

struct pipe_blend_state {
   GLuint blend_enable:1;

   GLuint rgb_func:3;          /**< PIPE_BLEND_x */
   GLuint rgb_src_factor:5;    /**< PIPE_BLENDFACTOR_x */
   GLuint rgb_dst_factor:5;    /**< PIPE_BLENDFACTOR_x */

   GLuint alpha_func:3;        /**< PIPE_BLEND_x */
   GLuint alpha_src_factor:5;  /**< PIPE_BLENDFACTOR_x */
   GLuint alpha_dst_factor:5;  /**< PIPE_BLENDFACTOR_x */

   GLuint logicop_enable:1;
   GLuint logicop_func:4;      /**< PIPE_LOGICOP_x */

   GLuint colormask:4;         /**< bitmask of PIPE_MASK_R/G/B/A */
   GLuint dither:1;
};

struct pipe_blend_color {
   GLfloat color[4];
};

struct pipe_clear_color_state
{
   GLfloat color[4];
};

struct pipe_stencil_state {
   GLuint front_enabled:1;
   GLuint front_func:3;     /**< PIPE_FUNC_x */
   GLuint front_fail_op:3;  /**< PIPE_STENCIL_OP_x */
   GLuint front_zpass_op:3; /**< PIPE_STENCIL_OP_x */
   GLuint front_zfail_op:3; /**< PIPE_STENCIL_OP_x */
   GLuint back_enabled:1;
   GLuint back_func:3;      /**< PIPE_FUNC_x */
   GLuint back_fail_op:3;   /**< PIPE_STENCIL_OP_x */
   GLuint back_zpass_op:3;  /**< PIPE_STENCIL_OP_x */
   GLuint back_zfail_op:3;  /**< PIPE_STENCIL_OP_x */
   GLubyte ref_value[2];    /**< [0] = front, [1] = back */
   GLubyte value_mask[2];
   GLubyte write_mask[2];
   GLubyte clear_value;
};


struct pipe_framebuffer_state
{
   /** multiple colorbuffers for multiple render targets */
   GLuint num_cbufs;
   struct pipe_surface *cbufs[PIPE_MAX_COLOR_BUFS];

   struct pipe_surface *zbuf;      /**< Z buffer */
   struct pipe_surface *sbuf;      /**< Stencil buffer */
};


/**
 * Texture sampler state.
 */
struct pipe_sampler_state
{
   GLuint wrap_s:3;        /**< PIPE_TEX_WRAP_x */
   GLuint wrap_t:3;        /**< PIPE_TEX_WRAP_x */
   GLuint wrap_r:3;        /**< PIPE_TEX_WRAP_x */
   GLuint min_filter:3;    /**< PIPE_TEX_FILTER_x */
   GLuint mag_filter:1;    /**< PIPE_TEX_FILTER_LINEAR or _NEAREST */
   GLuint compare:1;       /**< shadow/depth compare enabled? */
   GLenum compare_mode:1;  /**< PIPE_TEX_COMPARE_x */
   GLenum compare_func:3;  /**< PIPE_FUNC_x */
   GLfloat shadow_ambient; /**< shadow test fail color/intensity */
   GLfloat min_lod;
   GLfloat max_lod;
   GLfloat lod_bias;
#if 0 /* need these? */
   GLint BaseLevel;     /**< min mipmap level, OpenGL 1.2 */
   GLint MaxLevel;      /**< max mipmap level, OpenGL 1.2 */
   GLfloat border_color[4];
#endif
   GLfloat max_anisotropy;
};


/***
 *** Resource Objects
 ***/

struct pipe_region
{
   void *buffer;    /**< driver private buffer handle */

   GLuint refcount; /**< Reference count for region */
   GLuint cpp;      /**< bytes per pixel */
   GLuint pitch;    /**< in pixels */
   GLuint height;   /**< in pixels */
   GLubyte *map;    /**< only non-NULL when region is actually mapped */
   GLuint map_refcount;  /**< Reference count for mapping */
};


/**
 * 2D surface.  This is basically a view into a pipe_region (memory buffer).
 * May be a renderbuffer, texture mipmap level, etc.
 */
struct pipe_surface
{
   struct pipe_region *region;
   GLuint format:5;            /**< PIPE_FORMAT_x */
   GLuint width, height;
   GLuint offset;              /**< offset from start of region, in bytes */
   GLint refcount;

   void *rb;  /**< Ptr back to renderbuffer (temporary?) */

   /** get block/tile of pixels from surface */
   void (*get_tile)(struct pipe_surface *ps,
                    GLuint x, GLuint y, GLuint w, GLuint h, GLfloat *p);

   /** put block/tile of pixels into surface */
   void (*put_tile)(struct pipe_surface *ps,
                    GLuint x, GLuint y, GLuint w, GLuint h, const GLfloat *p);
};


/**
 * surface sampler object
 * XXX prototype
 */
struct pipe_surface_sampler
{
   struct pipe_sampler_state state;
   struct pipe_mipmap_tree *texture;
   void (*get_sample)(struct pipe_surface_sampler *sampler,
                      const GLfloat strq[4], GLfloat rgba[4]);
};


/**
 * Describes the location of each texture image within a texture region.
 */
struct pipe_mipmap_level
{
   GLuint level_offset;
   GLuint width;
   GLuint height;
   GLuint depth;
   GLuint nr_images;

   /* Explicitly store the offset of each image for each cube face or
    * depth value.  Pretty much have to accept that hardware formats
    * are going to be so diverse that there is no unified way to
    * compute the offsets of depth/cube images within a mipmap level,
    * so have to store them as a lookup table:
    */
   GLuint *image_offset;   /**< array [depth] of offsets */
};

struct pipe_mipmap_tree
{
   /* Effectively the key:
    */
   GLenum target;            /* XXX convert to PIPE_TEXTURE_x */
   GLenum internal_format;   /* XXX convert to PIPE_FORMAT_x */

   GLuint first_level;
   GLuint last_level;

   GLuint width0, height0, depth0; /**< Level zero image dimensions */
   GLuint cpp;
   GLboolean compressed;

   /* Derived from the above:
    */
   GLuint pitch;
   GLuint depth_pitch;          /* per-image on i945? */
   GLuint total_height;

   /* Includes image offset tables:
    */
   struct pipe_mipmap_level level[MAX_TEXTURE_LEVELS];

   /* The data is held here:
    */
   struct pipe_region *region;

   /* These are also refcounted:
    */
   GLuint refcount;
};



struct pipe_buffer_handle;

#define PIPE_BUFFER_FLAG_READ    0x1
#define PIPE_BUFFER_FLAG_WRITE   0x2

#define PIPE_BUFFER_USE_TEXTURE         0x1
#define PIPE_BUFFER_USE_VERTEX_BUFFER   0x2
#define PIPE_BUFFER_USE_INDEX_BUFFER    0x4
#define PIPE_BUFFER_USE_RENDER_TARGET   0x8




#endif