← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mesa-glw/quantal

« back to all changes in this revision

Viewing changes to src/mesa/drivers/dri/nouveau/nouveau_state.c

  • Committer: Bazaar Package Importer
  • Author(s): Morten Kjeldgaard
  • Date: 2008-05-06 16:19:15 UTC
  • Revision ID: james.westby@ubuntu.com-20080506161915-uynz7nftmfixu6bq
Tags: upstream-7.0.3
Import upstream version 7.0.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mesa/drivers/dri/nouveau/nouveau_state.c
 
1
/**************************************************************************
 
2
 
 
3
Copyright 2006 Jeremy Kolb
 
4
All Rights Reserved.
 
5
 
 
6
Permission is hereby granted, free of charge, to any person obtaining a
 
7
copy of this software and associated documentation files (the "Software"),
 
8
to deal in the Software without restriction, including without limitation
 
9
on the rights to use, copy, modify, merge, publish, distribute, sub
 
10
license, and/or sell copies of the Software, and to permit persons to whom
 
11
the Software is furnished to do so, subject to the following conditions:
 
12
 
 
13
The above copyright notice and this permission notice (including the next
 
14
paragraph) shall be included in all copies or substantial portions of the
 
15
Software.
 
16
 
 
17
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
18
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
19
FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
 
20
ERIC ANHOLT OR SILICON INTEGRATED SYSTEMS CORP BE LIABLE FOR ANY CLAIM,
 
21
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 
22
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 
23
USE OR OTHER DEALINGS IN THE SOFTWARE.
 
24
 
 
25
**************************************************************************/
 
26
 
 
27
#include "nouveau_context.h"
 
28
#include "nouveau_state.h"
 
29
#include "nouveau_swtcl.h"
 
30
#include "nouveau_fifo.h"
 
31
 
 
32
#include "swrast/swrast.h"
 
33
#include "tnl/tnl.h"
 
34
#include "swrast_setup/swrast_setup.h"
 
35
 
 
36
#include "tnl/t_pipeline.h"
 
37
 
 
38
#include "mtypes.h"
 
39
#include "colormac.h"
 
40
 
 
41
static __inline__ GLuint nouveauPackColor(GLuint format,
 
42
                                       GLubyte r, GLubyte g,
 
43
                                       GLubyte b, GLubyte a)
 
44
{
 
45
   switch (format) {
 
46
   case 2:
 
47
      return PACK_COLOR_565( r, g, b );
 
48
   case 4:
 
49
      return PACK_COLOR_8888( r, g, b, a);
 
50
   default:
 
51
      fprintf(stderr, "unknown format %d\n", (int)format);
 
52
      return 0;
 
53
   }
 
54
}
 
55
 
 
56
static void nouveauCalcViewport(GLcontext *ctx)
 
57
{
 
58
    /* Calculate the Viewport Matrix */
 
59
    
 
60
    nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 
61
    const GLfloat *v = ctx->Viewport._WindowMap.m;
 
62
    GLfloat *m = nmesa->viewport.m;
 
63
    GLfloat xoffset = nmesa->drawX, yoffset = nmesa->drawY;
 
64
  
 
65
    nmesa->depth_scale = 1.0 / ctx->DrawBuffer->_DepthMaxF;
 
66
 
 
67
    m[MAT_SX] =   v[MAT_SX];
 
68
    m[MAT_TX] =   v[MAT_TX] + xoffset + SUBPIXEL_X;
 
69
    m[MAT_SY] = - v[MAT_SY];
 
70
    m[MAT_TY] =   v[MAT_TY] + yoffset + SUBPIXEL_Y;
 
71
    m[MAT_SZ] =   v[MAT_SZ] * nmesa->depth_scale;
 
72
    m[MAT_TZ] =   v[MAT_TZ] * nmesa->depth_scale;
 
73
 
 
74
    nmesa->hw_func.WindowMoved(nmesa);
 
75
}
 
76
 
 
77
static void nouveauViewport(GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h)
 
78
{
 
79
    /* 
 
80
     * Need to send (at least on an nv35 the following:
 
81
     * cons = 4 (this may be bytes per pixel)
 
82
     *
 
83
     * The viewport:
 
84
     * 445   0x0000bee0   {size: 0x0   channel: 0x1   cmd: 0x00009ee0} <-- VIEWPORT_SETUP/HEADER ?
 
85
     * 446   0x00000000   {size: 0x0   channel: 0x0   cmd: 0x00000000} <-- x * cons
 
86
     * 447   0x00000c80   {size: 0x0   channel: 0x0   cmd: 0x00000c80} <-- (height + x) * cons
 
87
     * 448   0x00000000   {size: 0x0   channel: 0x0   cmd: 0x00000000} <-- y * cons
 
88
     * 449   0x00000960   {size: 0x0   channel: 0x0   cmd: 0x00000960} <-- (width + y) * cons
 
89
     * 44a   0x00082a00   {size: 0x2   channel: 0x1   cmd: 0x00000a00} <-- VIEWPORT_DIMS
 
90
     * 44b   0x04000000  <-- (Width_from_glViewport << 16) | x
 
91
     * 44c   0x03000000  <-- (Height_from_glViewport << 16) | (win_height - height - y)
 
92
     *
 
93
     */
 
94
    
 
95
    nouveauCalcViewport(ctx);
 
96
}
 
97
 
 
98
static void nouveauDepthRange(GLcontext *ctx, GLclampd near, GLclampd far)
 
99
{
 
100
    nouveauCalcViewport(ctx);
 
101
}
 
102
 
 
103
static void nouveauDDUpdateHWState(GLcontext *ctx)
 
104
{
 
105
    nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
 
106
    int new_state = nmesa->new_state;
 
107
 
 
108
    if ( new_state || nmesa->new_render_state & _NEW_TEXTURE )
 
109
    {
 
110
        nmesa->new_state = 0;
 
111
 
 
112
        /* Update the various parts of the context's state.
 
113
        */
 
114
        /*
 
115
        if ( new_state & NOUVEAU_NEW_ALPHA )
 
116
            nouveauUpdateAlphaMode( ctx );
 
117
 
 
118
        if ( new_state & NOUVEAU_NEW_DEPTH )
 
119
            nouveauUpdateZMode( ctx );
 
120
 
 
121
        if ( new_state & NOUVEAU_NEW_FOG )
 
122
            nouveauUpdateFogAttrib( ctx );
 
123
 
 
124
        if ( new_state & NOUVEAU_NEW_CLIP )
 
125
            nouveauUpdateClipping( ctx );
 
126
 
 
127
        if ( new_state & NOUVEAU_NEW_CULL )
 
128
            nouveauUpdateCull( ctx );
 
129
 
 
130
        if ( new_state & NOUVEAU_NEW_MASKS )
 
131
            nouveauUpdateMasks( ctx );
 
132
 
 
133
        if ( new_state & NOUVEAU_NEW_WINDOW )
 
134
            nouveauUpdateWindow( ctx );
 
135
 
 
136
        if ( nmesa->new_render_state & _NEW_TEXTURE ) {
 
137
            nouveauUpdateTextureState( ctx );
 
138
        }*/
 
139
    }
 
140
}
 
141
 
 
142
static void nouveauDDInvalidateState(GLcontext *ctx, GLuint new_state)
 
143
{
 
144
    _swrast_InvalidateState( ctx, new_state );
 
145
    _swsetup_InvalidateState( ctx, new_state );
 
146
    _vbo_InvalidateState( ctx, new_state );
 
147
    _tnl_InvalidateState( ctx, new_state );
 
148
    NOUVEAU_CONTEXT(ctx)->new_render_state |= new_state;
 
149
}
 
150
 
 
151
/* Initialize the context's hardware state. */
 
152
void nouveauDDInitState(nouveauContextPtr nmesa)
 
153
{
 
154
    uint32_t type = nmesa->screen->card->type;
 
155
    switch(type)
 
156
    {
 
157
        case NV_03:
 
158
            /* Unimplemented */
 
159
            break;
 
160
        case NV_04:
 
161
        case NV_05:
 
162
            nv04InitStateFuncs(nmesa->glCtx, &nmesa->glCtx->Driver);
 
163
            break;
 
164
        case NV_10:
 
165
            nv10InitStateFuncs(nmesa->glCtx, &nmesa->glCtx->Driver);
 
166
            break;
 
167
        case NV_20:
 
168
            nv20InitStateFuncs(nmesa->glCtx, &nmesa->glCtx->Driver);
 
169
            break;
 
170
        case NV_30:
 
171
        case NV_40:
 
172
        case NV_44:
 
173
            nv30InitStateFuncs(nmesa->glCtx, &nmesa->glCtx->Driver);
 
174
            break;
 
175
        case NV_50:
 
176
            nv50InitStateFuncs(nmesa->glCtx, &nmesa->glCtx->Driver);
 
177
            break;
 
178
        default:
 
179
            break;
 
180
    }
 
181
    nouveau_state_cache_init(nmesa);
 
182
}
 
183
 
 
184
/* Initialize the driver's state functions */
 
185
void nouveauDDInitStateFuncs(GLcontext *ctx)
 
186
{
 
187
   ctx->Driver.UpdateState              = nouveauDDInvalidateState;
 
188
 
 
189
   ctx->Driver.ClearIndex               = NULL;
 
190
   ctx->Driver.ClearColor               = NULL; //nouveauDDClearColor;
 
191
   ctx->Driver.ClearStencil             = NULL; //nouveauDDClearStencil;
 
192
   ctx->Driver.DrawBuffer               = NULL; //nouveauDDDrawBuffer;
 
193
   ctx->Driver.ReadBuffer               = NULL; //nouveauDDReadBuffer;
 
194
 
 
195
   ctx->Driver.IndexMask                = NULL;
 
196
   ctx->Driver.ColorMask                = NULL; //nouveauDDColorMask;
 
197
   ctx->Driver.AlphaFunc                = NULL; //nouveauDDAlphaFunc;
 
198
   ctx->Driver.BlendEquationSeparate    = NULL; //nouveauDDBlendEquationSeparate;
 
199
   ctx->Driver.BlendFuncSeparate        = NULL; //nouveauDDBlendFuncSeparate;
 
200
   ctx->Driver.ClearDepth               = NULL; //nouveauDDClearDepth;
 
201
   ctx->Driver.CullFace                 = NULL; //nouveauDDCullFace;
 
202
   ctx->Driver.FrontFace                = NULL; //nouveauDDFrontFace;
 
203
   ctx->Driver.DepthFunc                = NULL; //nouveauDDDepthFunc;
 
204
   ctx->Driver.DepthMask                = NULL; //nouveauDDDepthMask;
 
205
   ctx->Driver.Enable                   = NULL; //nouveauDDEnable;
 
206
   ctx->Driver.Fogfv                    = NULL; //nouveauDDFogfv;
 
207
   ctx->Driver.Hint                     = NULL;
 
208
   ctx->Driver.Lightfv                  = NULL;
 
209
   ctx->Driver.LightModelfv             = NULL; //nouveauDDLightModelfv;
 
210
   ctx->Driver.LogicOpcode              = NULL; //nouveauDDLogicOpCode;
 
211
   ctx->Driver.PolygonMode              = NULL;
 
212
   ctx->Driver.PolygonStipple           = NULL; //nouveauDDPolygonStipple;
 
213
   ctx->Driver.RenderMode               = NULL; //nouveauDDRenderMode;
 
214
   ctx->Driver.Scissor                  = NULL; //nouveauDDScissor;
 
215
   ctx->Driver.ShadeModel               = NULL; //nouveauDDShadeModel;
 
216
   ctx->Driver.StencilFuncSeparate      = NULL; //nouveauDDStencilFuncSeparate;
 
217
   ctx->Driver.StencilMaskSeparate      = NULL; //nouveauDDStencilMaskSeparate;
 
218
   ctx->Driver.StencilOpSeparate        = NULL; //nouveauDDStencilOpSeparate;
 
219
 
 
220
   ctx->Driver.DepthRange               = nouveauDepthRange;
 
221
   ctx->Driver.Viewport                 = nouveauViewport;
 
222
 
 
223
   /* Pixel path fallbacks.
 
224
    */
 
225
   ctx->Driver.Accum = _swrast_Accum;
 
226
   ctx->Driver.Bitmap = _swrast_Bitmap;
 
227
   ctx->Driver.CopyPixels = _swrast_CopyPixels;
 
228
   ctx->Driver.DrawPixels = _swrast_DrawPixels;
 
229
   ctx->Driver.ReadPixels = _swrast_ReadPixels;
 
230
 
 
231
   /* Swrast hooks for imaging extensions:
 
232
    */
 
233
   ctx->Driver.CopyColorTable = _swrast_CopyColorTable;
 
234
   ctx->Driver.CopyColorSubTable = _swrast_CopyColorSubTable;
 
235
   ctx->Driver.CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D;
 
236
   ctx->Driver.CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D;
 
237
}
 
238
 
 
239
#define STATE_INIT(a) if (ctx->Driver.a) ctx->Driver.a
 
240
 
 
241
void nouveauInitState(GLcontext *ctx)
 
242
{
 
243
    /*
 
244
     * Mesa should do this for us:
 
245
     */
 
246
 
 
247
    STATE_INIT(AlphaFunc)( ctx, 
 
248
            ctx->Color.AlphaFunc,
 
249
            ctx->Color.AlphaRef);
 
250
 
 
251
    STATE_INIT(BlendColor)( ctx,
 
252
            ctx->Color.BlendColor );
 
253
 
 
254
    STATE_INIT(BlendEquationSeparate)( ctx, 
 
255
            ctx->Color.BlendEquationRGB,
 
256
            ctx->Color.BlendEquationA);
 
257
 
 
258
    STATE_INIT(BlendFuncSeparate)( ctx,
 
259
            ctx->Color.BlendSrcRGB,
 
260
            ctx->Color.BlendDstRGB,
 
261
            ctx->Color.BlendSrcA,
 
262
            ctx->Color.BlendDstA);
 
263
 
 
264
    STATE_INIT(ClearColor)( ctx, ctx->Color.ClearColor);
 
265
    STATE_INIT(ClearDepth)( ctx, ctx->Depth.Clear);
 
266
    STATE_INIT(ClearStencil)( ctx, ctx->Stencil.Clear);
 
267
 
 
268
    STATE_INIT(ColorMask)( ctx, 
 
269
            ctx->Color.ColorMask[RCOMP],
 
270
            ctx->Color.ColorMask[GCOMP],
 
271
            ctx->Color.ColorMask[BCOMP],
 
272
            ctx->Color.ColorMask[ACOMP]);
 
273
 
 
274
    STATE_INIT(CullFace)( ctx, ctx->Polygon.CullFaceMode );
 
275
    STATE_INIT(DepthFunc)( ctx, ctx->Depth.Func );
 
276
    STATE_INIT(DepthMask)( ctx, ctx->Depth.Mask );
 
277
 
 
278
    STATE_INIT(Enable)( ctx, GL_ALPHA_TEST, ctx->Color.AlphaEnabled );
 
279
    STATE_INIT(Enable)( ctx, GL_BLEND, ctx->Color.BlendEnabled );
 
280
    STATE_INIT(Enable)( ctx, GL_COLOR_LOGIC_OP, ctx->Color.ColorLogicOpEnabled );
 
281
    STATE_INIT(Enable)( ctx, GL_COLOR_SUM, ctx->Fog.ColorSumEnabled );
 
282
    STATE_INIT(Enable)( ctx, GL_CULL_FACE, ctx->Polygon.CullFlag );
 
283
    STATE_INIT(Enable)( ctx, GL_DEPTH_TEST, ctx->Depth.Test );
 
284
    STATE_INIT(Enable)( ctx, GL_DITHER, ctx->Color.DitherFlag );
 
285
    STATE_INIT(Enable)( ctx, GL_FOG, ctx->Fog.Enabled );
 
286
    STATE_INIT(Enable)( ctx, GL_LIGHTING, ctx->Light.Enabled );
 
287
    STATE_INIT(Enable)( ctx, GL_LINE_SMOOTH, ctx->Line.SmoothFlag );
 
288
    STATE_INIT(Enable)( ctx, GL_LINE_STIPPLE, ctx->Line.StippleFlag );
 
289
    STATE_INIT(Enable)( ctx, GL_POINT_SMOOTH, ctx->Point.SmoothFlag );
 
290
    STATE_INIT(Enable)( ctx, GL_POLYGON_OFFSET_FILL, ctx->Polygon.OffsetFill);
 
291
    STATE_INIT(Enable)( ctx, GL_POLYGON_OFFSET_LINE, ctx->Polygon.OffsetLine);
 
292
    STATE_INIT(Enable)( ctx, GL_POLYGON_OFFSET_POINT, ctx->Polygon.OffsetPoint);
 
293
    STATE_INIT(Enable)( ctx, GL_POLYGON_SMOOTH, ctx->Polygon.SmoothFlag );
 
294
    STATE_INIT(Enable)( ctx, GL_POLYGON_STIPPLE, ctx->Polygon.StippleFlag );
 
295
    STATE_INIT(Enable)( ctx, GL_SCISSOR_TEST, ctx->Scissor.Enabled );
 
296
    STATE_INIT(Enable)( ctx, GL_STENCIL_TEST, ctx->Stencil.Enabled );
 
297
    STATE_INIT(Enable)( ctx, GL_TEXTURE_1D, GL_FALSE );
 
298
    STATE_INIT(Enable)( ctx, GL_TEXTURE_2D, GL_FALSE );
 
299
    STATE_INIT(Enable)( ctx, GL_TEXTURE_RECTANGLE_NV, GL_FALSE );
 
300
    STATE_INIT(Enable)( ctx, GL_TEXTURE_3D, GL_FALSE );
 
301
    STATE_INIT(Enable)( ctx, GL_TEXTURE_CUBE_MAP, GL_FALSE );
 
302
 
 
303
    STATE_INIT(Fogfv)( ctx, GL_FOG_COLOR, ctx->Fog.Color );
 
304
    STATE_INIT(Fogfv)( ctx, GL_FOG_MODE, 0 );
 
305
    STATE_INIT(Fogfv)( ctx, GL_FOG_DENSITY, &ctx->Fog.Density );
 
306
    STATE_INIT(Fogfv)( ctx, GL_FOG_START, &ctx->Fog.Start );
 
307
    STATE_INIT(Fogfv)( ctx, GL_FOG_END, &ctx->Fog.End );
 
308
 
 
309
    STATE_INIT(FrontFace)( ctx, ctx->Polygon.FrontFace );
 
310
 
 
311
    {
 
312
        GLfloat f = (GLfloat)ctx->Light.Model.ColorControl;
 
313
        STATE_INIT(LightModelfv)( ctx, GL_LIGHT_MODEL_COLOR_CONTROL, &f );
 
314
    }
 
315
 
 
316
    STATE_INIT(LineStipple)( ctx, ctx->Line.StippleFactor, ctx->Line.StipplePattern );
 
317
    STATE_INIT(LineWidth)( ctx, ctx->Line.Width );
 
318
    STATE_INIT(LogicOpcode)( ctx, ctx->Color.LogicOp );
 
319
    STATE_INIT(PointSize)( ctx, ctx->Point.Size );
 
320
    STATE_INIT(PolygonMode)( ctx, GL_FRONT, ctx->Polygon.FrontMode );
 
321
    STATE_INIT(PolygonMode)( ctx, GL_BACK, ctx->Polygon.BackMode );
 
322
    STATE_INIT(PolygonOffset)( ctx,
 
323
            ctx->Polygon.OffsetFactor,
 
324
            ctx->Polygon.OffsetUnits );
 
325
    STATE_INIT(PolygonStipple)( ctx, (const GLubyte *)ctx->PolygonStipple );
 
326
    STATE_INIT(ShadeModel)( ctx, ctx->Light.ShadeModel );
 
327
    STATE_INIT(StencilFuncSeparate)( ctx, GL_FRONT,
 
328
            ctx->Stencil.Function[0],
 
329
            ctx->Stencil.Ref[0],
 
330
            ctx->Stencil.ValueMask[0] );
 
331
    STATE_INIT(StencilFuncSeparate)( ctx, GL_BACK,
 
332
            ctx->Stencil.Function[1],
 
333
            ctx->Stencil.Ref[1],
 
334
            ctx->Stencil.ValueMask[1] );
 
335
    STATE_INIT(StencilMaskSeparate)( ctx, GL_FRONT, ctx->Stencil.WriteMask[0] );
 
336
    STATE_INIT(StencilMaskSeparate)( ctx, GL_BACK, ctx->Stencil.WriteMask[1] );
 
337
    STATE_INIT(StencilOpSeparate)( ctx, GL_FRONT,
 
338
            ctx->Stencil.FailFunc[0],
 
339
            ctx->Stencil.ZFailFunc[0],
 
340
            ctx->Stencil.ZPassFunc[0]);
 
341
    STATE_INIT(StencilOpSeparate)( ctx, GL_BACK,
 
342
            ctx->Stencil.FailFunc[1],
 
343
            ctx->Stencil.ZFailFunc[1],
 
344
            ctx->Stencil.ZPassFunc[1]);
 
345
}