home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / mesa5.zip / mesa5src.zip / tnl / t_pipeline.cpp < prev    next >
C/C++ Source or Header  |  2002-10-29  |  7KB  |  212 lines
  1. /* $Id: t_pipeline.c,v 1.25 2002/10/29 20:29:03 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  3.5
  6.  *
  7.  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
  8.  *
  9.  * Permission is hereby granted, free of charge, to any person obtaining a
  10.  * copy of this software and associated documentation files (the "Software"),
  11.  * to deal in the Software without restriction, including without limitation
  12.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13.  * and/or sell copies of the Software, and to permit persons to whom the
  14.  * Software is furnished to do so, subject to the following conditions:
  15.  *
  16.  * The above copyright notice and this permission notice shall be included
  17.  * in all copies or substantial portions of the Software.
  18.  *
  19.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22.  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23.  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24.  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25.  *
  26.  * Authors:
  27.  *    Keith Whitwell <keith@tungstengraphics.com>
  28.  */
  29.  
  30. #include "glheader.h"
  31. #include "context.h"
  32. #include "imports.h"
  33. #include "mmath.h"
  34. #include "state.h"
  35. #include "mtypes.h"
  36.  
  37. #include "math/m_translate.h"
  38. #include "math/m_xform.h"
  39.  
  40. #include "t_context.h"
  41. #include "t_pipeline.h"
  42.  
  43.  
  44. void _tnl_install_pipeline( GLcontext *ctx,
  45.                 const struct gl_pipeline_stage **stages )
  46. {
  47.    TNLcontext *tnl = TNL_CONTEXT(ctx);
  48.    struct gl_pipeline *pipe = &tnl->pipeline;
  49.    GLuint i;
  50.  
  51.    ASSERT(pipe->nr_stages == 0);
  52.  
  53.    pipe->run_state_changes = ~0;
  54.    pipe->run_input_changes = ~0;
  55.    pipe->build_state_changes = ~0;
  56.    pipe->build_state_trigger = 0;
  57.    pipe->inputs = 0;
  58.  
  59.    /* Create a writeable copy of each stage.
  60.     */
  61.    for (i = 0 ; i < MAX_PIPELINE_STAGES && stages[i] ; i++) {
  62.       MEMCPY( &pipe->stages[i], stages[i], sizeof( **stages ));
  63.       pipe->build_state_trigger |= pipe->stages[i].check_state;
  64.    }
  65.  
  66.    MEMSET( &pipe->stages[i], 0, sizeof( **stages ));
  67.  
  68.    pipe->nr_stages = i;
  69. }
  70.  
  71. void _tnl_destroy_pipeline( GLcontext *ctx )
  72. {
  73.    TNLcontext *tnl = TNL_CONTEXT(ctx);
  74.    GLuint i;
  75.  
  76.    for (i = 0 ; i < tnl->pipeline.nr_stages ; i++)
  77.       tnl->pipeline.stages[i].destroy( &tnl->pipeline.stages[i] );
  78.  
  79.    tnl->pipeline.nr_stages = 0;
  80. }
  81.  
  82. /* TODO: merge validate with run.
  83.  */
  84. void _tnl_validate_pipeline( GLcontext *ctx )
  85. {
  86.    TNLcontext *tnl = TNL_CONTEXT(ctx);
  87.    struct gl_pipeline *pipe = &tnl->pipeline;
  88.    struct gl_pipeline_stage *s = pipe->stages;
  89.    GLuint newstate = pipe->build_state_changes;
  90.    GLuint generated = 0;
  91.    GLuint changed_inputs = 0;
  92.  
  93.    pipe->inputs = 0;
  94.    pipe->build_state_changes = 0;
  95.  
  96.    for ( ; s->check ; s++) {
  97.  
  98.       s->changed_inputs |= s->inputs & changed_inputs;
  99.  
  100.       if (s->check_state & newstate) {
  101.      if (s->active) {
  102.         GLuint old_outputs = s->outputs;
  103.         s->check(ctx, s);
  104.         if (!s->active)
  105.            changed_inputs |= old_outputs;
  106.      }
  107.      else
  108.         s->check(ctx, s);
  109.       }
  110.  
  111.       if (s->active) {
  112.      pipe->inputs |= s->inputs & ~generated;
  113.      generated |= s->outputs;
  114.       }
  115.    }
  116. }
  117.  
  118.  
  119.  
  120. void _tnl_run_pipeline( GLcontext *ctx )
  121. {
  122.    TNLcontext *tnl = TNL_CONTEXT(ctx);
  123.    struct vertex_buffer *VB = &tnl->vb;
  124.    struct gl_pipeline *pipe = &tnl->pipeline;
  125.    struct gl_pipeline_stage *s = pipe->stages;
  126.    GLuint changed_state = pipe->run_state_changes;
  127.    GLuint changed_inputs = pipe->run_input_changes;
  128.    GLboolean running = GL_TRUE;
  129.    unsigned short __tmp;
  130.  
  131.    pipe->run_state_changes = 0;
  132.    pipe->run_input_changes = 0;
  133.  
  134.    /* Done elsewhere.
  135.     */
  136.    ASSERT(pipe->build_state_changes == 0);
  137.  
  138.    START_FAST_MATH(__tmp);
  139.  
  140.    /* If something changes in the pipeline, tag all subsequent stages
  141.     * using this value for recalculation.  Inactive stages have their
  142.     * state and inputs examined to try to keep cached data alive over
  143.     * state-changes.
  144.     */
  145.    for ( ; s->run ; s++) {
  146.       s->changed_inputs |= s->inputs & changed_inputs;
  147.  
  148.       if (s->run_state & changed_state)
  149.      s->changed_inputs = s->inputs;
  150.  
  151.       if (s->active && running) {
  152.      if (s->changed_inputs)
  153.         changed_inputs |= s->outputs;
  154.  
  155.      running = s->run( ctx, s );
  156.  
  157.      s->changed_inputs = 0;
  158.      VB->importable_data &= ~s->outputs;
  159.       }
  160.    }
  161.  
  162.    END_FAST_MATH(__tmp);
  163. }
  164.  
  165.  
  166.  
  167. /* The default pipeline.  This is useful for software rasterizers, and
  168.  * simple hardware rasterizers.  For customization, I don't recommend
  169.  * tampering with the internals of these stages in the way that
  170.  * drivers did in Mesa 3.4.  These stages are basically black boxes,
  171.  * and should be left intact.
  172.  *
  173.  * To customize the pipeline, consider:
  174.  *
  175.  * - removing redundant stages (making sure that the software rasterizer
  176.  *   can cope with this on fallback paths).  An example is fog
  177.  *   coordinate generation, which is not required in the FX driver.
  178.  *
  179.  * - replacing general-purpose machine-independent stages with
  180.  *   general-purpose machine-specific stages.  There is no example of
  181.  *   this to date, though it must be borne in mind that all subsequent
  182.  *   stages that reference the output of the new stage must cope with
  183.  *   any machine-specific data introduced.  This may not be easy
  184.  *   unless there are no such stages (ie the new stage is the last in
  185.  *   the pipe).
  186.  *
  187.  * - inserting optimized (but specialized) stages ahead of the
  188.  *   general-purpose fallback implementation.  For example, the old
  189.  *   fastpath mechanism, which only works when the VERT_BIT_ELT input is
  190.  *   available, can be duplicated by placing the fastpath stage at the
  191.  *   head of this pipeline.  Such specialized stages are currently
  192.  *   constrained to have no outputs (ie. they must either finish the *
  193.  *   pipeline by returning GL_FALSE from run(), or do nothing).
  194.  *
  195.  * Some work can be done to lift some of the restrictions in the final
  196.  * case, if it becomes necessary to do so.
  197.  */
  198. const struct gl_pipeline_stage *_tnl_default_pipeline[] = {
  199.    &_tnl_vertex_transform_stage,
  200.    &_tnl_normal_transform_stage,
  201.    &_tnl_lighting_stage,
  202.    &_tnl_fog_coordinate_stage,
  203.    &_tnl_texgen_stage,
  204.    &_tnl_texture_transform_stage,
  205.    &_tnl_point_attenuation_stage,
  206. #if FEATURE_NV_vertex_program
  207.    &_tnl_vertex_program_stage,
  208. #endif
  209.    &_tnl_render_stage,
  210.    0
  211. };
  212.