tsmesh.cc

五行MMORPG引擎系统V1.0

      glDisableClientState(GL_TEXTURE_COORD_ARRAY);
      glClientActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.baseTE);
   }

   // restore gl state changes made for emap
   if (TSShapeInstance::smRenderData.environmentMapMethod==TSShapeInstance::ENVIRONMENT_MAP_MULTI_1)
   {
      // set second texure unit (TE #1)
      glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.environmentMapTE);
      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
      glDisable(GL_TEXTURE_2D);
      glDisable(GL_TEXTURE_GEN_S);
      glDisable(GL_TEXTURE_GEN_T);
   }
   else if (TSShapeInstance::smRenderData.environmentMapMethod==TSShapeInstance::ENVIRONMENT_MAP_MULTI_3)
   {
      // set second texure unit (TE #1)
      glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.environmentMapTE);
      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
      glDisable(GL_TEXTURE_2D);

      // set third texure unit (TE #2)
      glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.environmentMapTE + 1);
      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
      glDisable(GL_TEXTURE_2D);
      glDisable(GL_TEXTURE_GEN_S);
      glDisable(GL_TEXTURE_GEN_T);

      // set fourth texure unit (TE #3)
      glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.environmentMapTE + 2);
      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
      glDisable(GL_TEXTURE_2D);
   }

   if (TSShapeInstance::smRenderData.fogMethod == TSShapeInstance::FOG_MULTI_1 || TSShapeInstance::smRenderData.fogMethod == TSShapeInstance::FOG_MULTI_1_TEXGEN)
   {
      glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.fogTE);
      glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
      glDisable(GL_TEXTURE_GEN_S);
      glDisable(GL_TEXTURE_GEN_T);
      glDisable(GL_TEXTURE_2D);
   }

   // restore gl state changes made for base texture
   if (dglDoesSupportARBMultitexture())
      glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.baseTE);

   glDisableClientState(GL_VERTEX_ARRAY);
   glDisableClientState(GL_NORMAL_ARRAY);
   glDisableClientState(GL_TEXTURE_COORD_ARRAY);

   glDisable(GL_TEXTURE_2D);
   glDisable(GL_BLEND);
   glDepthMask(GL_TRUE);

   // don't cull by default...
   glDisable(GL_CULL_FACE);

   // if lights were on when we started, make sure they're on when we leave
   if (TSShapeInstance::smRenderData.lightingOn && !glIsEnabled(GL_LIGHTING))
      glEnable(GL_LIGHTING);

   // baseTE != 0?
   if (TSShapeInstance::smRenderData.baseTE!=0)
   {
      glActiveTextureARB(GL_TEXTURE0_ARB);
      glClientActiveTextureARB(GL_TEXTURE0_ARB);
   }

   // restore cloak shifting
   if (TSShapeInstance::smRenderData.textureMatrixPushed)
   {
      glMatrixMode(GL_TEXTURE);
      glPopMatrix();
      glMatrixMode(GL_MODELVIEW);
      TSShapeInstance::smRenderData.textureMatrixPushed = false;
   }
}

// set up materials for mesh rendering
// keeps track of flags via TSShapeInstance::smRenderData.materialFlags and only changes what needs to be changed
// keeps track of material index via TSShapeInstance::smRenderData.materialIndex
void TSMesh::setMaterial(S32 matIndex, TSMaterialList* materials)
{
   if ((matIndex|TSShapeInstance::smRenderData.materialIndex) & TSDrawPrimitive::NoMaterial)
   {
      if (matIndex & TSDrawPrimitive::NoMaterial)
      {
         glDisable(GL_TEXTURE_2D);
         glDisable(GL_BLEND);
         glDepthMask(GL_TRUE);
         TSShapeInstance::smRenderData.materialIndex = matIndex;
         TSShapeInstance::smRenderData.materialFlags &= ~TSMaterialList::Translucent;
         return;
      }
      glEnable(GL_TEXTURE_2D);
   }

   matIndex &= TSDrawPrimitive::MaterialMask;

   U32 flags     = materials->getFlags(matIndex);
   U32 bareFlags = flags;
   if (TSShapeInstance::smRenderData.alwaysAlpha || TSShapeInstance::smRenderData.fadeSet)
      flags |= TSMaterialList::Translucent;
   U32 deltaFlags = flags ^ TSShapeInstance::smRenderData.materialFlags;
   if (TSShapeInstance::smRenderData.environmentMapMethod!=TSShapeInstance::ENVIRONMENT_MAP_MULTI_1)
      deltaFlags &= ~TSMaterialList::NeverEnvMap;

   // update flags and material index...
   TSShapeInstance::smRenderData.materialFlags = flags;
   TSShapeInstance::smRenderData.materialIndex = matIndex;

   if (TSShapeInstance::smRenderData.useOverride == false || bareFlags & TSMaterialList::Translucent)
   {
      TextureHandle & tex = materials->getMaterial(matIndex);
      glBindTexture(GL_TEXTURE_2D, tex.getGLName());
   }
   else
      glBindTexture(GL_TEXTURE_2D, TSShapeInstance::smRenderData.override.getGLName());

   // anything change...?
   if (deltaFlags)
   {
      if (deltaFlags & TSMaterialList::NeverEnvMap && !TSShapeInstance::smRenderData.useOverride )
      {
         glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.environmentMapTE);
         if (bareFlags & TSMaterialList::NeverEnvMap)
            glDisable(GL_TEXTURE_2D);
         else
            glEnable(GL_TEXTURE_2D);
         glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.baseTE);
      }
      if (flags & TSMaterialList::Translucent)
      {
         if (TSShapeInstance::smRenderData.fogMethod == TSShapeInstance::FOG_TWO_PASS || TSShapeInstance::smRenderData.fogMethod == TSShapeInstance::FOG_TWO_PASS_TEXGEN)
         {
            TSShapeInstance::smRenderData.vertexAlpha.fog = 1.0f - TSShapeInstance::smRenderData.fogColor.w;
         }
         else if ((TSShapeInstance::smRenderData.fogMethod == TSShapeInstance::FOG_MULTI_1 ||
                  TSShapeInstance::smRenderData.fogMethod == TSShapeInstance::FOG_MULTI_1_TEXGEN) &&
                  flags & (TSMaterialList::Additive|TSMaterialList::Subtractive))
         {
            glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.fogTE);
            glDisable(GL_TEXTURE_2D);
            glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.baseTE);
            TSShapeInstance::smRenderData.vertexAlpha.fog = 1.0f - TSShapeInstance::smRenderData.fogColor.w;
         }
         glEnable(GL_BLEND);
         glDepthMask(GL_FALSE);
      }
      else
      {
         if (TSShapeInstance::smRenderData.fogMethod == TSShapeInstance::FOG_TWO_PASS || TSShapeInstance::smRenderData.fogMethod == TSShapeInstance::FOG_TWO_PASS_TEXGEN)
         {
            TSShapeInstance::smRenderData.vertexAlpha.fog = 1.0f;
         }
         else if ((TSShapeInstance::smRenderData.fogMethod == TSShapeInstance::FOG_MULTI_1 ||
                  TSShapeInstance::smRenderData.fogMethod == TSShapeInstance::FOG_MULTI_1_TEXGEN) &&
                  flags & (TSMaterialList::Additive|TSMaterialList::Subtractive))
         {
            glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.fogTE);
            glEnable(GL_TEXTURE_2D);
            glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.baseTE);
            TSShapeInstance::smRenderData.vertexAlpha.fog = 1.0f;
         }
         glDisable(GL_BLEND);
         glDepthMask(GL_TRUE);
      }
      if (deltaFlags & (TSMaterialList::Additive|TSMaterialList::Subtractive))
      {
         if (flags & TSMaterialList::Additive)
            glBlendFunc(GL_SRC_ALPHA, GL_ONE);
         else if (flags & TSMaterialList::Subtractive)
            glBlendFunc(GL_ZERO,GL_ONE_MINUS_SRC_COLOR);
         else
            glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
      }
      if (deltaFlags & TSMaterialList::SelfIlluminating)
      {
         if (TSShapeInstance::smRenderData.detailMapMethod==TSShapeInstance::DETAIL_MAP_MULTI_2)
         {
            // special case:  lighting done on different TE than texture...
            glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.baseTE + 1);
            if (flags & TSMaterialList::SelfIlluminating)
            {
               // modulate...
               glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
            }
            else
            {
               // we need to use the combine extension...we modulate by primary color rather than fragment color
               glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_COMBINE);
               glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_RGB,GL_MODULATE);
               glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE0_RGB,GL_PREVIOUS);
               glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND0_RGB,GL_SRC_COLOR);
               glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE1_RGB,GL_PRIMARY_COLOR);
               glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND1_RGB,GL_SRC_COLOR);
               glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_ALPHA,GL_MODULATE);
               glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE0_ALPHA,GL_PREVIOUS);
               glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND0_ALPHA,GL_SRC_ALPHA);
               glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE1_ALPHA,GL_PRIMARY_COLOR);
               glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND1_ALPHA,GL_SRC_ALPHA);
            }
            glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.baseTE);
         }
         // turn off lights if self-illuminating (or back on if not)
         if (flags & TSMaterialList::SelfIlluminating || !TSShapeInstance::smRenderData.lightingOn)
            glDisable(GL_LIGHTING);
         else
            glEnable(GL_LIGHTING);
      }
   }

   // gotta set these every time since present value depends on texture not gl state
   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,flags & TSMaterialList::S_Wrap ? GL_REPEAT : GL_CLAMP);
   glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,flags & TSMaterialList::T_Wrap ? GL_REPEAT : GL_CLAMP);

   // emap texture...
   if (TSShapeInstance::smRenderData.environmentMapMethod==TSShapeInstance::ENVIRONMENT_MAP_MULTI_3)
   {
      // set emap's texture unit...
      glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.environmentMapTE + 2);

      if (TSShapeInstance::smRenderData.useOverride == false || flags & TSMaterialList::Translucent)
      {
         TextureHandle & tex = materials->getMaterial(matIndex);
         glBindTexture(GL_TEXTURE_2D, tex.getGLName());
      }
      else
         glBindTexture(GL_TEXTURE_2D, TSShapeInstance::smRenderData.override.getGLName());
      glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.environmentMapTE);
      glBindTexture(GL_TEXTURE_2D, materials->getReflectionMap(matIndex)->getGLName());

      // set default texture unit...
      glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.baseTE);
   }

   // dmap texture...
   if (TSShapeInstance::smRenderData.detailMapMethod==TSShapeInstance::DETAIL_MAP_MULTI_1 ||
       TSShapeInstance::smRenderData.detailMapMethod==TSShapeInstance::DETAIL_MAP_MULTI_2)
   {
      // set detail map's texture unit...
      glActiveTextureARB(GL_TEXTURE0_ARB+TSShapeInstance::smRenderData.detailMapTE);

      TextureHandle * detailMap = materials->getDetailMap(matIndex);
      if (detailMap)
      {
         glEnable(GL_TEXTURE_2D);
         glBindTexture(GL_TEXTURE_2D,detailMap->getGLName());

         // has texture scale changed?
         F32 tscale = materials->getDetailMapScale(matIndex);
         if (mFabs(tscale-TSShapeInstance::smRenderData.detailTextureScale) > 0.001f)
         {
            // yes, update scale
            TSShapeInstance::smRenderData.detailTextureScale = tscale;
            glMatrixMode(GL_TEXTURE);
            MatrixF scaleMat;
            scaleMat.identity();
            for (S32 i=0; i<15; i++)
               ((F32*)scaleMat)[i] *= tscale;
            dglLoadMatrix(&scaleMat);
            glMatrixMode(GL_MODELVIEW);
         }
      }
      else
         glDisable(GL_TEXTURE_2D);

      // set default texture unit...
      glActiveTextureARB(GL_TEXTURE0_ARB + TSShapeInstance::smRenderData.baseTE);
   }

   // translucent materials shouldn't get cloak shifting
   // 1: pushed -> pushed
   // 2: pushed -> not pushed
   // 3: not pushed -> pushed
   // 4: not pushed -> not pushed
   if (TSShapeInstance::smRenderData.textureMatrixPushed)
   {
      if (TSShapeInstance::smRenderData.useOverride && bareFlags & TSMaterialList::Translucent)
      {
         // Leave it alone
      }
      else
      {
         // Pop it off
         glMatrixMode(GL_TEXTURE);
         glPopMatrix();
         glMatrixMode(GL_MODELVIEW);
         TSShapeInstance::smRenderData.textureMatrixPushed = false;
      }
   }
   else
   {
      if (TSShapeInstance::smRenderData.useOverride && bareFlags & TSMaterialList::Translucent)
      {
         // Push it up
         glMatrixMode(GL_TEXTURE);
         glPushMatrix();
         glLoadIdentity();
         glMatrixMode(GL_MODELVIEW);
         TSShapeInstance::smRenderData.textureMatrixPushed = true;
      }
      else
      {
         // leave it alone
      }
   }

   // handle environment map
   if (flags & TSMaterialList::NeverEnvMap)
      TSShapeInstance::smRenderData.vertexAlpha.emap = 1.0f;
   else
      TSShapeInstance::smRenderData.vertexAlpha.emap = TSShapeInstance::smRenderData.environmentMapAlpha * materials->getReflectionAmount(matIndex);
   // handle vertex alpha
   if (TSShapeInstance::smRenderData.vertexAlpha.set())
   {
      Point4F v(1,1,1,TSShapeInstance::smRenderData.vertexAlpha.current);
      glColor4fv(v);
      glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,v);
   }

   // set up fade
   if( overrideFadeVal < 1.0f && dglDoesSupportTextureEnvCombine() )
   {
      S32 & emapTE     = TSShapeInstance::smRenderData.environmentMapTE;
      S32 & baseTE     = TSShapeInstance::smRenderData.baseTE;

      if( TSShapeInstance::smRenderData.environmentMapMethod == TSShapeInstance::ENVIRONMENT_MAP_MULTI_1 )
      {
         glActiveTextureARB(GL_TEXTURE0_ARB + emapTE);
         glDisable(GL_TEXTURE_2D);
      }

      glActiveTextureARB(GL_TEXTURE0_ARB + baseTE);

      glEnable( GL_BLEND );

      if( TSShapeInstance::smRenderData.materialFlags & TSMaterialList::Translucent )