via_state.c

Mesa is an open-source implementation of the OpenGL specification - a system for rendering interacti

/*
 * Copyright 1998-2003 VIA Technologies, Inc. All Rights Reserved.
 * Copyright 2001-2003 S3 Graphics, Inc. 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
 * VIA, S3 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.
 */

#include <stdio.h>

#include "glheader.h"
#include "context.h"
#include "macros.h"
#include "colormac.h"
#include "enums.h"
#include "dd.h"

#include "mm.h"
#include "via_context.h"
#include "via_state.h"
#include "via_tex.h"
#include "via_tris.h"
#include "via_ioctl.h"
#include "via_3d_reg.h"

#include "swrast/swrast.h"
#include "vbo/vbo.h"
#include "tnl/tnl.h"
#include "swrast_setup/swrast_setup.h"

#include "tnl/t_pipeline.h"


static GLuint ROP[16] = {
    HC_HROP_BLACK,    /* GL_CLEAR           0                      	*/
    HC_HROP_DPa,      /* GL_AND             s & d                  	*/
    HC_HROP_PDna,     /* GL_AND_REVERSE     s & ~d  			*/
    HC_HROP_P,        /* GL_COPY            s                       	*/
    HC_HROP_DPna,     /* GL_AND_INVERTED    ~s & d                      */
    HC_HROP_D,        /* GL_NOOP            d  		                */
    HC_HROP_DPx,      /* GL_XOR             s ^ d                       */
    HC_HROP_DPo,      /* GL_OR              s | d                       */
    HC_HROP_DPon,     /* GL_NOR             ~(s | d)                    */
    HC_HROP_DPxn,     /* GL_EQUIV           ~(s ^ d)                    */
    HC_HROP_Dn,       /* GL_INVERT          ~d                       	*/
    HC_HROP_PDno,     /* GL_OR_REVERSE      s | ~d                      */
    HC_HROP_Pn,       /* GL_COPY_INVERTED   ~s                       	*/
    HC_HROP_DPno,     /* GL_OR_INVERTED     ~s | d                      */
    HC_HROP_DPan,     /* GL_NAND            ~(s & d)                    */
    HC_HROP_WHITE     /* GL_SET             1                       	*/
};

/*
 * Compute the 'S5.5' lod bias factor from the floating point OpenGL bias.
 */
static GLuint viaComputeLodBias(GLfloat bias)
{
   int b = (int) (bias * 32.0);
   if (b > 511)
      b = 511;
   else if (b < -512)
      b = -512;
   return (GLuint) b;
}

void viaEmitState(struct via_context *vmesa)
{
   GLcontext *ctx = vmesa->glCtx;
   GLuint i = 0;
   GLuint j = 0;
   RING_VARS;

   viaCheckDma(vmesa, 0x110);
    
   BEGIN_RING(5);
   OUT_RING( HC_HEADER2 );
   OUT_RING( (HC_ParaType_NotTex << 16) );
   OUT_RING( ((HC_SubA_HEnable << 24) | vmesa->regEnable) );
   OUT_RING( ((HC_SubA_HFBBMSKL << 24) | vmesa->regHFBBMSKL) );    
   OUT_RING( ((HC_SubA_HROP << 24) | vmesa->regHROP) );        
   ADVANCE_RING();
    
   if (vmesa->have_hw_stencil) {
      GLuint pitch, format, offset;
	
      format = HC_HZWBFM_24;	    	
      offset = vmesa->depth.offset;
      pitch = vmesa->depth.pitch;
	
      BEGIN_RING(6);
      OUT_RING( (HC_SubA_HZWBBasL << 24) | (offset & 0xFFFFFF) );
      OUT_RING( (HC_SubA_HZWBBasH << 24) | ((offset & 0xFF000000) >> 24) );	
      OUT_RING( (HC_SubA_HZWBType << 24) | HC_HDBLoc_Local | HC_HZONEasFF_MASK |
	         format | pitch );            
      OUT_RING( (HC_SubA_HZWTMD << 24) | vmesa->regHZWTMD );
      OUT_RING( (HC_SubA_HSTREF << 24) | vmesa->regHSTREF );
      OUT_RING( (HC_SubA_HSTMD << 24) | vmesa->regHSTMD );
      ADVANCE_RING();
   }
   else if (vmesa->hasDepth) {
      GLuint pitch, format, offset;
	
      if (vmesa->depthBits == 16) {
	 format = HC_HZWBFM_16;
      }	    
      else {
	 format = HC_HZWBFM_32;
      }
	    
	    
      offset = vmesa->depth.offset;
      pitch = vmesa->depth.pitch;
	
      BEGIN_RING(4);
      OUT_RING( (HC_SubA_HZWBBasL << 24) | (offset & 0xFFFFFF) );
      OUT_RING( (HC_SubA_HZWBBasH << 24) | ((offset & 0xFF000000) >> 24) );
      OUT_RING( (HC_SubA_HZWBType << 24) | HC_HDBLoc_Local | HC_HZONEasFF_MASK |
	         format | pitch );
      OUT_RING( (HC_SubA_HZWTMD << 24) | vmesa->regHZWTMD );
      ADVANCE_RING();
   }
    
   if (ctx->Color.AlphaEnabled) {
      BEGIN_RING(1);
      OUT_RING( (HC_SubA_HATMD << 24) | vmesa->regHATMD );
      ADVANCE_RING();
      i++;
   }   

   if (ctx->Color.BlendEnabled) {
      BEGIN_RING(11);
      OUT_RING( (HC_SubA_HABLCsat << 24) | vmesa->regHABLCsat );
      OUT_RING( (HC_SubA_HABLCop  << 24) | vmesa->regHABLCop ); 
      OUT_RING( (HC_SubA_HABLAsat << 24) | vmesa->regHABLAsat );        
      OUT_RING( (HC_SubA_HABLAop  << 24) | vmesa->regHABLAop ); 
      OUT_RING( (HC_SubA_HABLRCa  << 24) | vmesa->regHABLRCa ); 
      OUT_RING( (HC_SubA_HABLRFCa << 24) | vmesa->regHABLRFCa );        
      OUT_RING( (HC_SubA_HABLRCbias << 24) | vmesa->regHABLRCbias ); 
      OUT_RING( (HC_SubA_HABLRCb  << 24) | vmesa->regHABLRCb ); 
      OUT_RING( (HC_SubA_HABLRFCb << 24) | vmesa->regHABLRFCb );        
      OUT_RING( (HC_SubA_HABLRAa  << 24) | vmesa->regHABLRAa ); 
      OUT_RING( (HC_SubA_HABLRAb  << 24) | vmesa->regHABLRAb ); 
      ADVANCE_RING();
   }
    
   if (ctx->Fog.Enabled) {
      BEGIN_RING(3);
      OUT_RING( (HC_SubA_HFogLF << 24) | vmesa->regHFogLF ); 
      OUT_RING( (HC_SubA_HFogCL << 24) | vmesa->regHFogCL ); 
      OUT_RING( (HC_SubA_HFogCH << 24) | vmesa->regHFogCH ); 
      ADVANCE_RING();
   }
    
   if (ctx->Line.StippleFlag) {
      BEGIN_RING(2);
      OUT_RING( (HC_SubA_HLP << 24) | ctx->Line.StipplePattern ); 
      OUT_RING( (HC_SubA_HLPRF << 24) | ctx->Line.StippleFactor );
      ADVANCE_RING();
   }

   BEGIN_RING(1);
   OUT_RING( (HC_SubA_HPixGC << 24) | 0x0 ); 
   ADVANCE_RING();
    
   QWORD_PAD_RING();


   if (ctx->Texture._EnabledUnits) {
    
      struct gl_texture_unit *texUnit0 = &ctx->Texture.Unit[0];
      struct gl_texture_unit *texUnit1 = &ctx->Texture.Unit[1];

      {
	 GLuint nDummyValue = 0;

	 BEGIN_RING( 8 );
	 OUT_RING( HC_HEADER2 );
	 OUT_RING( (HC_ParaType_Tex << 16) | (HC_SubType_TexGeneral << 24) );

	 if (texUnit0->Enabled && texUnit1->Enabled) {
	    nDummyValue = (HC_SubA_HTXSMD << 24) | (1 << 3);                
	 }
	 else {
	    nDummyValue = (HC_SubA_HTXSMD << 24) | 0;
	 }

	 if (vmesa->clearTexCache) {
	    vmesa->clearTexCache = 0;
	    OUT_RING( nDummyValue | HC_HTXCHCLR_MASK );
	    OUT_RING( nDummyValue );
	 }
	 else {
	    OUT_RING( nDummyValue );
	    OUT_RING( nDummyValue );
	 }

	 OUT_RING( HC_HEADER2 );
	 OUT_RING( HC_ParaType_NotTex << 16 );
	 OUT_RING( (HC_SubA_HEnable << 24) | vmesa->regEnable );
	 OUT_RING( (HC_SubA_HEnable << 24) | vmesa->regEnable );
	 ADVANCE_RING();
      }

      if (texUnit0->Enabled) {
	 struct gl_texture_object *texObj = texUnit0->_Current;
	 struct via_texture_object *t = (struct via_texture_object *)texObj;
	 GLuint numLevels = t->lastLevel - t->firstLevel + 1;
	 if (VIA_DEBUG & DEBUG_STATE) {
	    fprintf(stderr, "texture0 enabled\n");
	 }		
	 if (numLevels == 8) {
	    BEGIN_RING(27);
	    OUT_RING( HC_HEADER2 );
	    OUT_RING( (HC_ParaType_Tex << 16) |  (0 << 24) );
	    OUT_RING( t->regTexFM );
	    OUT_RING( (HC_SubA_HTXnL0OS << 24) |
	       ((t->lastLevel) << HC_HTXnLVmax_SHIFT) | t->firstLevel );
	    OUT_RING( t->regTexWidthLog2[0] );
	    OUT_RING( t->regTexWidthLog2[1] );
	    OUT_RING( t->regTexHeightLog2[0] );
	    OUT_RING( t->regTexHeightLog2[1] );
	    OUT_RING( t->regTexBaseH[0] );
	    OUT_RING( t->regTexBaseH[1] );
	    OUT_RING( t->regTexBaseH[2] );
	    OUT_RING( t->regTexBaseAndPitch[0].baseL );
	    OUT_RING( t->regTexBaseAndPitch[0].pitchLog2 );
	    OUT_RING( t->regTexBaseAndPitch[1].baseL );
	    OUT_RING( t->regTexBaseAndPitch[1].pitchLog2 );
	    OUT_RING( t->regTexBaseAndPitch[2].baseL );
	    OUT_RING( t->regTexBaseAndPitch[2].pitchLog2 );
	    OUT_RING( t->regTexBaseAndPitch[3].baseL );
	    OUT_RING( t->regTexBaseAndPitch[3].pitchLog2 );
	    OUT_RING( t->regTexBaseAndPitch[4].baseL );
	    OUT_RING( t->regTexBaseAndPitch[4].pitchLog2 );
	    OUT_RING( t->regTexBaseAndPitch[5].baseL );
	    OUT_RING( t->regTexBaseAndPitch[5].pitchLog2 );
	    OUT_RING( t->regTexBaseAndPitch[6].baseL );
	    OUT_RING( t->regTexBaseAndPitch[6].pitchLog2 );
	    OUT_RING( t->regTexBaseAndPitch[7].baseL );
	    OUT_RING( t->regTexBaseAndPitch[7].pitchLog2 );
	    ADVANCE_RING();
	 }
	 else if (numLevels > 1) {

	    BEGIN_RING(12 + numLevels * 2);
	    OUT_RING( HC_HEADER2 );
	    OUT_RING( (HC_ParaType_Tex << 16) |  (0 << 24) );
	    OUT_RING( t->regTexFM );
	    OUT_RING( (HC_SubA_HTXnL0OS << 24) |
	       ((t->lastLevel) << HC_HTXnLVmax_SHIFT) | t->firstLevel );
	    OUT_RING( t->regTexWidthLog2[0] );
	    OUT_RING( t->regTexHeightLog2[0] );
		
	    if (numLevels > 6) {
	       OUT_RING( t->regTexWidthLog2[1] );
	       OUT_RING( t->regTexHeightLog2[1] );
	    }
                
	    OUT_RING( t->regTexBaseH[0] );
		
	    if (numLevels > 3) {
	       OUT_RING( t->regTexBaseH[1] );
	    }
	    if (numLevels > 6) {
	       OUT_RING( t->regTexBaseH[2] );
	    }
	    if (numLevels > 9)  {
	       OUT_RING( t->regTexBaseH[3] );
	    }

	    for (j = 0; j < numLevels; j++) {
	       OUT_RING( t->regTexBaseAndPitch[j].baseL );
	       OUT_RING( t->regTexBaseAndPitch[j].pitchLog2 );
	    }

	    ADVANCE_RING_VARIABLE();
	 }
	 else {

	    BEGIN_RING(9);
	    OUT_RING( HC_HEADER2 );
	    OUT_RING( (HC_ParaType_Tex << 16) |  (0 << 24) );
	    OUT_RING( t->regTexFM );
	    OUT_RING( (HC_SubA_HTXnL0OS << 24) |
	       ((t->lastLevel) << HC_HTXnLVmax_SHIFT) | t->firstLevel );
	    OUT_RING( t->regTexWidthLog2[0] );
	    OUT_RING( t->regTexHeightLog2[0] );
	    OUT_RING( t->regTexBaseH[0] );
	    OUT_RING( t->regTexBaseAndPitch[0].baseL );
	    OUT_RING( t->regTexBaseAndPitch[0].pitchLog2 );
	    ADVANCE_RING();
	 }

	 BEGIN_RING(14);
	 OUT_RING( (HC_SubA_HTXnTB << 24) | vmesa->regHTXnTB[0] );
	 OUT_RING( (HC_SubA_HTXnMPMD << 24) | vmesa->regHTXnMPMD[0] );
	 OUT_RING( (HC_SubA_HTXnTBLCsat << 24) | vmesa->regHTXnTBLCsat[0] );
	 OUT_RING( (HC_SubA_HTXnTBLCop << 24) | vmesa->regHTXnTBLCop[0] );
	 OUT_RING( (HC_SubA_HTXnTBLMPfog << 24) | vmesa->regHTXnTBLMPfog[0] );
	 OUT_RING( (HC_SubA_HTXnTBLAsat << 24) | vmesa->regHTXnTBLAsat[0] );
	 OUT_RING( (HC_SubA_HTXnTBLRCb << 24) | vmesa->regHTXnTBLRCb[0] );
	 OUT_RING( (HC_SubA_HTXnTBLRAa << 24) | vmesa->regHTXnTBLRAa[0] );
	 OUT_RING( (HC_SubA_HTXnTBLRFog << 24) | vmesa->regHTXnTBLRFog[0] );
	 OUT_RING( (HC_SubA_HTXnTBLRCa << 24) | vmesa->regHTXnTBLRCa[0] );
	 OUT_RING( (HC_SubA_HTXnTBLRCc << 24) | vmesa->regHTXnTBLRCc[0] );
	 OUT_RING( (HC_SubA_HTXnTBLRCbias << 24) | vmesa->regHTXnTBLRCbias[0] );
	 OUT_RING( (HC_SubA_HTXnTBC << 24) | vmesa->regHTXnTBC[0] );
	 OUT_RING( (HC_SubA_HTXnTRAH << 24) | vmesa->regHTXnTRAH[0] );
/* 	 OUT_RING( (HC_SubA_HTXnCLODu << 24) | vmesa->regHTXnCLOD[0] ); */
	 ADVANCE_RING();

	 /* KW:  This test never succeeds:
	  */
	 if (t->regTexFM == HC_HTXnFM_Index8) {
	    const struct gl_color_table *table = &texObj->Palette;
	    const GLfloat *tableF = table->TableF;

	    BEGIN_RING(2 + table->Size);
	    OUT_RING( HC_HEADER2 );
	    OUT_RING( (HC_ParaType_Palette << 16) | (0 << 24) );
	    for (j = 0; j < table->Size; j++) 
	       OUT_RING( tableF[j] );
	    ADVANCE_RING();
	       
	 }

	 QWORD_PAD_RING();
      }
	
      if (texUnit1->Enabled) {
	 struct gl_texture_object *texObj = texUnit1->_Current;
	 struct via_texture_object *t = (struct via_texture_object *)texObj;
	 GLuint numLevels = t->lastLevel - t->firstLevel + 1;
	 int texunit = (texUnit0->Enabled ? 1 : 0);
	 if (VIA_DEBUG & DEBUG_STATE) {
	    fprintf(stderr, "texture1 enabled\n");
	 }		
	 if (numLevels == 8) {
	    BEGIN_RING(27);
	    OUT_RING( HC_HEADER2 );
	    OUT_RING( (HC_ParaType_Tex << 16) |  (texunit << 24) );
	    OUT_RING( t->regTexFM );
	    OUT_RING( (HC_SubA_HTXnL0OS << 24) |
	       ((t->lastLevel) << HC_HTXnLVmax_SHIFT) | t->firstLevel );
	    OUT_RING( t->regTexWidthLog2[0] );
	    OUT_RING( t->regTexWidthLog2[1] );
	    OUT_RING( t->regTexHeightLog2[0] );
	    OUT_RING( t->regTexHeightLog2[1] );
	    OUT_RING( t->regTexBaseH[0] );
	    OUT_RING( t->regTexBaseH[1] );
	    OUT_RING( t->regTexBaseH[2] );
	    OUT_RING( t->regTexBaseAndPitch[0].baseL );
	    OUT_RING( t->regTexBaseAndPitch[0].pitchLog2 );
	    OUT_RING( t->regTexBaseAndPitch[1].baseL );
	    OUT_RING( t->regTexBaseAndPitch[1].pitchLog2 );
	    OUT_RING( t->regTexBaseAndPitch[2].baseL );
	    OUT_RING( t->regTexBaseAndPitch[2].pitchLog2 );
	    OUT_RING( t->regTexBaseAndPitch[3].baseL );
	    OUT_RING( t->regTexBaseAndPitch[3].pitchLog2 );
	    OUT_RING( t->regTexBaseAndPitch[4].baseL );
	    OUT_RING( t->regTexBaseAndPitch[4].pitchLog2 );
	    OUT_RING( t->regTexBaseAndPitch[5].baseL );
	    OUT_RING( t->regTexBaseAndPitch[5].pitchLog2 );
	    OUT_RING( t->regTexBaseAndPitch[6].baseL );
	    OUT_RING( t->regTexBaseAndPitch[6].pitchLog2 );
	    OUT_RING( t->regTexBaseAndPitch[7].baseL );
	    OUT_RING( t->regTexBaseAndPitch[7].pitchLog2 );
	    ADVANCE_RING();