魔兽3自适应地块贴图算法

最新推荐文章于 2024-08-29 16:37:54 发布
最新推荐文章于 2024-08-29 16:37:54 发布
阅读量1.3k 收藏
点赞数
分类专栏： 3D地形 文章标签： 算法 layer c vector struct qq
 FW: http://www.cnitblog.com/sword/archive/2007/04/21/26000.aspx

整个贴图过程分为4个步骤:
1. 删除地块
2. 拼接地块
3. 排序地块层
4. 更新地块

有2种类型的地形纹理:
o_SimpleTexture.JPG
o_FullTexture.JPG
o_Base.JPG

根据上面这张排好索引的图片,加上效果图可以知道基本地块为:
1 | 2
8 | 16
然后是随机地块,数据如下:
s32 s_pBaseTexIndex_c[] = { 1, 2, 8, 16 };
s32 s_pRandTexIndex_c[] = { 0, 4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 23, 27, 28, 29, 30, 31 };

整个贴图算法都是基于上面这个基本索引而来.4个基本索引相加为27,是一个很特别的索引.

举2个例子:

1 |  2+1           1 | 3

8 | 16+8 =       8 | 24 =
o_Right.JPG

1     | 2                 1 | 2

8+1 | 16+2 =       9 | 18 =
o_Down.JPG
一个格子最多可以贴4个地块,也就是4层地块,下面是基本数据定义.

// 地形顶点数据
struct TeVertex
{
         f32            fHeight;          ///< 地形高度值
         Vector3f v3Normal; ///< 地形顶点法向量
};

// 地形地块纹理数据
struct TeTile
{
         s8 Block[TE_TILE_COUNT]; ///< 纹理中的一块
         u8 Texture[TE_TILE_COUNT]; ///< 纹理ID,255代表空
};

首先初始化一个32*32的地形数据:

m_pVertex = new TeVertex[32*32];
m_pTile = new TeTile[32*32];

for( i = 0; i < 32*32; ++i )
{
       nBlock = s_pRandTexIndex_c[rand() % 18];

       m_pVertex[i].fHeight = 0.0f;

       m_pTile[i].Block[0] = nBlock;
       m_pTile[i].Texture[0] = 0;

       m_pTile[i].Block[1] = 0;
       m_pTile[i].Texture[1] = 255;

       m_pTile[i].Block[2] = 0;
       m_pTile[i].Texture[2] = 255;

       m_pTile[i].Block[3] = 0;
       m_pTile[i].Texture[3] = 255;
}

在拼接之前首先是找出4个要拼接的格子,如图:
o_FindTile.JPG
1. 删除地块
         1-1: 如果当前地块第0层的纹理索引不为0并且Block索引是随机地块的话,格子的数据需要调整, 算法为用27减去除第0层外所有有效层的Block索引,最后的结果赋予第0层的Block.
   
         1-2: 循环直到找出如果4个格子的某一层的Texture索引都相同,并找出所在的层,然后在做以下判断:
              1-2-1: 如果这4个格子的这4层的Block索引都是随机地块索引,并且Texture索引比要贴的Texture索引大的话,则这4个格子的相应Block索引都要变为27减去基本索引. 然后回到2-1.
        
              1-2-2: 1-2-1不成立的话,判断4个格子的Block是否可删除,条件是用当前地块的当前层的Block索引减去基本地块,如果是随机地块索引(除开0和27)则不合法,其余结果是合法的.
        
              1-2-3: 将4个格子的对应层的Block索引都减去一个值.如果是Block索引是随机地块索引，则用27减去基本地块索引.否则用自身的Block索引减去基本索引值,如果减出来的结果是0的话, 则设置这个格子的这一层的Texture索引为255

2. 拼接地块
         首先是找出要拼接纹理对应的层次,这中间涉及到调节层次数据,看下面的代码.接下来就是修改Block索引,主要的操作就是加上基本索引.在这中间涉及到的判断相当的多,还是看代码直接:),值得注意的是当设置的地块Block索引为27的时候需要特殊处理.

3. 排序地块层
         这一步最简单,一共才4层,最简单的冒泡排序就行了:)

4. 更新地块
         把一个地块中所有的地块索引相加,索引为随机地块的不参与,如果最后的结果为27那么需要对这个地块的数据做调整.如果这个格子的Texture索引不是0的话,把这个格子的第0层的Block索引设置为随机地块索引.如果是0的话,则第0层的Texture索引变为第1层的Texture索引,并且把第2层的数据复制到第1层,把第3层的数据复制到第2层,第3层的数据设置为空.
   
         由于网上查不到相关的资料,上面这些都是我通过观察war3的编辑器总结出来的,希望可以给在做类似war3这种地形贴图的朋友一些帮助:),有不明白的地方可以在QQ(76537477)上联系我.

最后贴上我的效果图和核心代码:
o_Terrain.JPG

算法的基本代码(为了简单明了,下面的代码是简化了的, 这里实在是不知道怎么排版啊)

 

#define  TE_TILE_COUNT     4
#define  TE_INVALID_TILE   255
#define  TE_TILE_LEN       2.0f
#define  TE_TEX_BASE       4  //  地形纹理基本变换数
#define  TE_MAX_TEX        8  //  地形最多支持8种不同的纹理
#define  TE_TEX_RAND_S     2  //  256的地形纹理最大变换数
#define  TE_TEX_RAND_C     18  //  512的地形纹理最大变换数
#define  TE_TEX_COUNT_S    16  //  Simple
#define  TE_TEX_COUNT_C    32  //  Complex//-------------&-------------
// ---------------------------&-------------------------
void  SetTile(  const  Vector3f  & v3Pos )
 {
 if ( m_nSelectTexture  <   0   ||  m_nSelectTexture  >=  m_vecTexture.Size() )
      return ;
f32 fDis  =  TE_TILE_LEN  /   2.0f ;
s32 nLDTile  =  (s32)((v3Pos.y  -  fDis)  /  TE_TILE_LEN)  *  m_nTileWid  +  (s32)((v3Pos.x  -  fDis)  /  TE_TILE_LEN);
s32 nRDTile  =  (s32)((v3Pos.y  -  fDis)  /  TE_TILE_LEN)  *  m_nTileWid  +  (s32)((v3Pos.x  +  fDis)  /  TE_TILE_LEN);
s32 nRUTile  =  (s32)((v3Pos.y  +  fDis)  /  TE_TILE_LEN)  *  m_nTileWid  +  (s32)((v3Pos.x  +  fDis)  /  TE_TILE_LEN);
s32 nLUTile  =  (s32)((v3Pos.y  +  fDis)  /  TE_TILE_LEN)  *  m_nTileWid  +  (s32)((v3Pos.x  -  fDis)  /  TE_TILE_LEN);

s32 i  =   0 , nLDLayer  =   0 , nRDLayer  =   0 , nRULayer  =   0 , nLULayer  =   0 ;
s32 nLDBlock, nRDBlock, nRUBlock, nLUBlock;
BOOL bLDCheck  =  FALSE, bRDCheck  =  FALSE, bRUCheck  =  FALSE, bLUCheck  =  FALSE; //  更新当前周围的地块属性

UpdateTileAttribute( nLDTile, nRDTile, nRUTile, nLUTile );  //  找出对应的层
for ( i  =   0 ; i  <  TE_LAYERS;  ++ i )
 {
      if ( m_pTile[nLDTile].Texture[i]  ==  m_nSelectTexture )
      {
      nLDLayer  =  i;
      bLDCheck  =  TRUE;
     }
      else   if (  ! bLDCheck  &&  m_pTile[nLDTile].Texture[i]  !=  TE_INVALID_TILE )
      {
       ++ nLDLayer;
     }      
      if ( m_pTile[nRDTile].Texture[i]  ==  m_nSelectTexture )
      {
      nRDLayer  =  i;
      bRDCheck  =  TRUE;
     }
      else   if (  ! bRDCheck  &&  m_pTile[nRDTile].Texture[i]  !=  TE_INVALID_TILE )
      {
       ++ nRDLayer;
     }      
      if ( m_pTile[nRUTile].Texture[i]  ==  m_nSelectTexture )
      {
      nRULayer  =  i;
      bRUCheck  =  TRUE;
     }
      else   if (  ! bRUCheck  &&  m_pTile[nRUTile].Texture[i]  !=  TE_INVALID_TILE )
      {
       ++ nRULayer;
     }      
      if ( m_pTile[nLUTile].Texture[i]  ==  m_nSelectTexture )
      {
      nLULayer  =  i;
      bLUCheck  =  TRUE;
     }
      else   if (  ! bLUCheck  &&  m_pTile[nLUTile].Texture[i]  !=  TE_INVALID_TILE )
      {
       ++ nLULayer;
     }
}
      if (  ! bLDCheck )
     nLDLayer  =  AdjustTileLayer( nLDTile,  2  );
      if (  ! bRDCheck )
     nRDLayer  =  AdjustTileLayer( nRDTile,  3  );
      if (  ! bRUCheck )
     nRULayer  =  AdjustTileLayer( nRUTile,  1  );
      if (  ! bLUCheck )
     nLULayer  =  AdjustTileLayer( nLUTile,  0  );
s32 nLDTexture  =  m_pTile[nLDTile].Texture[nLDLayer];
 if ( nLDTexture  !=  TE_INVALID_TILE )
 {
     s32 nRDTexture  =  m_pTile[nRDTile].Texture[nRDLayer];
     s32 nRUTexture  =  m_pTile[nRUTile].Texture[nRULayer];
     s32 nLUTexture  =  m_pTile[nLUTile].Texture[nLULayer]; 
     if ( nLDTexture  ==  nRDTexture  &&  nLDTexture  ==  nRUTexture  &&  nLDTexture  ==  nLUTexture )
      {
       if ( (m_pTile[nLDTile].Texture[TE_LAYERS - 1 ]  !=  TE_INVALID_TILE  ||  
          m_pTile[nRDTile].Texture[TE_LAYERS - 1 ]  !=  TE_INVALID_TILE  ||
          m_pTile[nRUTile].Texture[TE_LAYERS - 1 ]  !=  TE_INVALID_TILE  ||
          m_pTile[nLUTile].Texture[TE_LAYERS - 1 ]  !=  TE_INVALID_TILE) )
       {
        if ( (nLDTexture  ==  m_nSelectTexture)  &&  
           (m_pTile[nLDTile].Block[nLDLayer]  ==  s_pBaseTexIndex_c[ 2 ]  ||
            m_pTile[nRDTile].Block[nRDLayer]  ==  s_pBaseTexIndex_c[ 3 ]  ||  
            m_pTile[nRUTile].Block[nRULayer]  ==  s_pBaseTexIndex_c[ 1 ]  ||  
            m_pTile[nLUTile].Block[nLULayer]  ==  s_pBaseTexIndex_c[ 0 ] ) )
        {
         goto  _SORT_LAYER;
       }        nLDBlock  =  m_pTile[nLDTile].Block[nLDLayer];
        if ( m_pTile[nLDTile].Texture[nLDLayer]  !=   0   &&  (nLDBlock  ==   0   ||   ! IsValidRandBlock(nLDBlock)) )
        nLDBlock  =  m_pTile[nLDTile].Block[nLDLayer]  +  s_pBaseTexIndex_c[ 2 ];       nRDBlock  =  m_pTile[nRDTile].Block[nRDLayer];
        if ( m_pTile[nRDTile].Texture[nRDLayer]  !=   0   &&  (nRDBlock  ==   0   ||   ! IsValidRandBlock(nRDBlock)) )
        nRDBlock  =  m_pTile[nRDTile].Block[nRDLayer]  +  s_pBaseTexIndex_c[ 3 ];       nRUBlock  =  m_pTile[nRUTile].Block[nRULayer];
        if ( m_pTile[nRUTile].Texture[nRULayer]  !=   0   &&  (nRUBlock  ==   0   ||   ! IsValidRandBlock(nRUBlock)) )
        nRUBlock  =  m_pTile[nRUTile].Block[nRULayer]  +  s_pBaseTexIndex_c[ 1 ];       nLUBlock  =  m_pTile[nLUTile].Block[nLULayer];
        if ( m_pTile[nLUTile].Texture[nLULayer]  !=   0   &&  (nLUBlock  ==   0   ||   ! IsValidRandBlock(nLUBlock)) )
        nLUBlock  =  m_pTile[nLUTile].Block[nLULayer]  +  s_pBaseTexIndex_c[ 0 ];        if ( IsValidBlock(nLDBlock)  &&  IsValidTileBlock( nLDBlock ) )
        SetTileAttribute( nLDTile, nLDLayer, nLDBlock );
    
        if ( IsValidBlock(nRDBlock)  &&  IsValidTileBlock( nRDBlock ) )
        SetTileAttribute( nRDTile, nRDLayer, nRDBlock );
    
        if ( IsValidBlock(nRUBlock)  &&  IsValidTileBlock( nRUBlock ) )
        SetTileAttribute( nRUTile, nRULayer, nRUBlock );
    
        if ( IsValidBlock(nLUBlock)  &&  IsValidTileBlock( nLUBlock ) )
        SetTileAttribute( nLUTile, nLULayer, nLUBlock );        goto  _SORT_LAYER;
      }
       else   if ( m_pTile[nLDTile].Block[nLDLayer]  +  s_pBaseTexIndex_c[ 2 ]  >=  TE_TEX_COUNT_C  ||
        m_pTile[nRDTile].Block[nRDLayer]  +  s_pBaseTexIndex_c[ 3 ]  >=  TE_TEX_COUNT_C  ||
        m_pTile[nRUTile].Block[nRULayer]  +  s_pBaseTexIndex_c[ 1 ]  >=  TE_TEX_COUNT_C  ||
        m_pTile[nLUTile].Block[nLULayer]  +  s_pBaseTexIndex_c[ 0 ]  >=  TE_TEX_COUNT_C )
       {
        goto  _SORT_LAYER;
      }
     }
}
    nLDBlock  =  m_pTile[nLDTile].Block[nLDLayer]  +  s_pBaseTexIndex_c[ 2 ];
nRDBlock  =  m_pTile[nRDTile].Block[nRDLayer]  +  s_pBaseTexIndex_c[ 3 ];
nRUBlock  =  m_pTile[nRUTile].Block[nRULayer]  +  s_pBaseTexIndex_c[ 1 ];
nLUBlock  =  m_pTile[nLUTile].Block[nLULayer]  +  s_pBaseTexIndex_c[ 0 ]; if (  ! IsValidTileBlock( nLDBlock ) )
      goto  _SORT_LAYER; if (  ! IsValidTileBlock( nRDBlock ) )
      goto  _SORT_LAYER; if (  ! IsValidTileBlock( nRUBlock ) )
      goto  _SORT_LAYER; if (  ! IsValidTileBlock( nLUBlock ) )
      goto  _SORT_LAYER;SetTileAttribute( nLDTile, nLDLayer, nLDBlock );
SetTileAttribute( nRDTile, nRDLayer, nRDBlock );
SetTileAttribute( nRUTile, nRULayer, nRUBlock );
SetTileAttribute( nLUTile, nLULayer, nLUBlock );_SORT_LAYER:
SortLayerTile( nLDTile );
SortLayerTile( nRDTile );
SortLayerTile( nRUTile );
SortLayerTile( nLUTile );
} // -------------&-------------
 // ---------------------------&-------------------------
s32 AdjustTileLayer( s32 nTile, s32 nIndex )
 {
BOOL bCheck  =  FALSE, bFindLayer  =  FALSE;
s32 i, nMinLayer, nRetLayer  =   0 ;
 for ( i  =   0 ; i  <  TE_LAYERS;  ++ i )
 {
      if ( m_pTile[nTile].Texture[i]  ==  TE_INVALID_TILE )
      {
      bCheck  =  TRUE;
      m_pTile[nTile].Texture[i]  =  m_nSelectTexture;
       if ( m_nSelectTexture  ==   0  )
       m_pTile[nTile].Block[i]  =   27 ;
       break ;
     }
}
if (  ! bCheck )
 {
     nMinLayer  =   0 ;      for ( i  =   0 ; i  <  TE_LAYERS;  ++ i )
      {
       if ( m_pTile[nTile].Texture[i]  ==  m_nSelectTexture )
       {
       bFindLayer  =  TRUE;
       m_pTile[nTile].Texture[i]  =  m_nSelectTexture;
        break ;
      }
     }
      if (  ! bFindLayer )
      {
       for ( i  =   0 ; i  <  TE_LAYERS  -   1 ;  ++ i )
       {
       m_pTile[nTile].Texture[i]  =  m_pTile[nTile].Texture[i + 1 ];
       m_pTile[nTile].Block[i]  =  m_pTile[nTile].Block[i + 1 ];
      }      
            for ( i  =   0 ; i  <  TE_LAYERS  -   1 ;  ++ i )
       {
        if ( m_pTile[nTile].Texture[i]  ==  m_nSelectTexture )
        {
        m_pTile[nTile].Texture[TE_LAYERS - 1 ]  =   0 ;
        m_pTile[nTile].Block[TE_LAYERS - 1 ]  =  s_pRandTexIndex_c[rand() % TE_TEX_RAND_C];         goto  _SPECIAL_LAYER;
       }
      }       m_pTile[nTile].Texture[TE_LAYERS - 1 ]  =  m_nSelectTexture;
      m_pTile[nTile].Block[TE_LAYERS - 1 ]  =   0 ;
     }
} _SPECIAL_LAYER:
 //  for( i = 0; i < TE_LAYERS; ++i )
 //  {
 //      if( m_pTile[nTile].Texture[i] < m_pTile[nTile].Texture[nMinLayer] )
 //      {
 //       nMinLayer = i;
 //      }
 //  }for( i = 0; i < TE_LAYERS; ++i )
{
      if ( m_pTile[nTile].Texture[i]  ==  m_nSelectTexture )
      {
      nRetLayer  =  i;
       goto  _LAYER_RETURN;
     }
}
for ( i  =   0 ; i  <  TE_LAYERS;  ++ i )
 {
      if ( m_pTile[nTile].Texture[i]  ==  TE_INVALID_TILE )
      {
      nRetLayer  =  i;
       goto  _LAYER_RETURN;
     }
} nRetLayer  =  TE_LAYERS  -   1 ;_LAYER_RETURN: return  nRetLayer;
} // +-------------&-------------
 // +---------------------------&-------------------------
void  SortLayerTile( s32 nTile )
 {
BOOL bBaseLayer  =  FALSE;
s32 nBaseLayer  =   - 1 ;
s32 i, j, nTex, nBlock; for ( i  =   0 ; i  <  TE_LAYERS;  ++ i )
 {
      for ( j  =  i  +   1 ; j  <  TE_LAYERS;  ++ j )
      {
       if ( m_pTile[nTile].Texture[i]  >  m_pTile[nTile].Texture[j] )
       {
       nTex  =  m_pTile[nTile].Texture[i];
       nBlock  =  m_pTile[nTile].Block[i];       m_pTile[nTile].Texture[i]  =  m_pTile[nTile].Texture[j];
       m_pTile[nTile].Block[i]  =  m_pTile[nTile].Block[j];       m_pTile[nTile].Texture[j]  =  nTex;
       m_pTile[nTile].Block[j]  =  nBlock;
      }      }
} nBlock  =   0 ;
 for ( i  =   0 ; i  <  TE_LAYERS;  ++ i )
 {
      if (  ! IsValidRandBlock( m_pTile[nTile].Block[i] ) )
      {
      nBlock  +=  m_pTile[nTile].Block[i];
     }
} if ( nBlock  ==   27  )
 {
      if ( m_pTile[nTile].Texture[ 0 ]  ==   0  )
      {
      m_pTile[nTile].Texture[ 0 ]  =  m_pTile[nTile].Texture[ 1 ];
      m_pTile[nTile].Block[ 0 ]  =   27 ;       for ( i  =   1 ; i  <  TE_LAYERS  -   1 ;  ++ i )
       {
       m_pTile[nTile].Texture[i]  =  m_pTile[nTile].Texture[i + 1 ];
       m_pTile[nTile].Block[i]  =  m_pTile[nTile].Block[i + 1 ];
      }       m_pTile[nTile].Texture[TE_LAYERS - 1 ]  =  TE_INVALID_TILE;
      m_pTile[nTile].Block[TE_LAYERS - 1 ]  =   0 ;
     }
      else
      {
      m_pTile[nTile].Block[ 0 ]  =   27 ;
     }
}
} // -------------&-------------
 // ---------------------------&-------------------------
BOOL IsValidTileBlock( s32 nBlock )  const
{
s32 i  =   0 ; if ( nBlock  ==   0   ||  nBlock  ==   27  )
      return  TRUE; for ( ; i  <  TE_TEX_RAND_C;  ++ i )
 {
      if ( nBlock  ==  s_pRandTexIndex_c[i] )
       return  FALSE;
} return  TRUE;
} // -------------&-------------
 // ---------------------------&-------------------------
BOOL IsValidRandBlock( s32 nBlock )  const
{
s32 i  =   0 ;
 for ( ; i  <  TE_TEX_RAND_C;  ++ i )
 {
      if ( nBlock  ==  s_pRandTexIndex_c[i] )
       return  TRUE;
} return  FALSE;
} // +-------------&-------------
 // +---------------------------&-------------------------
s32 CheckLayerTile( s32 nTile, s32 nTexture )
 {
s32 i; for ( i  =   0 ; i  <  TE_TILE_COUNT;  ++ i )
 {
      if ( m_pTile[nTile].Texture[i]  !=  TE_INVALID_TILE  &&  m_pTile[nTile].Texture[i]  ==  nTexture )
       return  i;
} return   - 1 ;
} // +-------------&-------------
 // +---------------------------&-------------------------
void  UpdateTileAttribute( s32 nLDTile, s32 nRDTile, s32 nRUTile, s32 nLUTile )
 {
s32 i, nBlock, nLDTexture;
s32 nLDLayer, nRDLayer, nRULayer, nLULayer; if ( IsValidRandBlock(m_pTile[nLDTile].Block[ 0 ])  &&  m_pTile[nLDTile].Texture[ 0 ]  !=   0  )
 {
     nBlock  =   27 ;
      for ( i  =   1 ; i  <  TE_LAYERS;  ++ i )
      {
       if ( m_pTile[nLDTile].Texture[i]  !=  TE_INVALID_TILE )
       {
       nBlock  -=  m_pTile[nLDTile].Block[i];
      }
     }      m_pTile[nLDTile].Block[ 0 ]  =  nBlock;
} if ( IsValidRandBlock(m_pTile[nRDTile].Block[ 0 ])  &&  m_pTile[nRDTile].Texture[ 0 ]  !=   0  )
 {
     nBlock  =   27 ;
      for ( i  =   1 ; i  <  TE_LAYERS;  ++ i )
      {
       if ( m_pTile[nRDTile].Texture[i]  !=  TE_INVALID_TILE )
       {
       nBlock  -=  m_pTile[nRDTile].Block[i];
      }
     }      m_pTile[nRDTile].Block[ 0 ]  =  nBlock;
} if ( IsValidRandBlock(m_pTile[nRUTile].Block[ 0 ])  &&  m_pTile[nRUTile].Texture[ 0 ]  !=   0  )
 {
     nBlock  =   27 ;
      for ( i  =   1 ; i  <  TE_LAYERS;  ++ i )
      {
       if ( m_pTile[nRUTile].Texture[i]  !=  TE_INVALID_TILE )
       {
       nBlock  -=  m_pTile[nRUTile].Block[i];
      }
     }      m_pTile[nRUTile].Block[ 0 ]  =  nBlock;
} if ( IsValidRandBlock(m_pTile[nLUTile].Block[ 0 ])  &&  m_pTile[nLUTile].Texture[ 0 ]  !=   0  )
 {
     nBlock  =   27 ;
      for ( i  =   1 ; i  <  TE_LAYERS;  ++ i )
      {
       if ( m_pTile[nLUTile].Texture[i]  !=  TE_INVALID_TILE )
       {
       nBlock  -=  m_pTile[nLUTile].Block[i];
      }
     }      m_pTile[nLUTile].Block[ 0 ]  =  nBlock;
} //  找出对应的层
for ( i  =   0 ; i  <  TE_TILE_COUNT;  ++ i )
 {
     nLDLayer  =  i;
     nLDTexture  =  m_pTile[nLDTile].Texture[i];      if ( nLDTexture  ==  m_nSelectTexture )
       continue ;     nRDLayer  =  CheckLayerTile( nRDTile, nLDTexture );
      if ( nRDLayer  ==   - 1  )
       continue ;     nRULayer  =  CheckLayerTile( nRUTile, nLDTexture );
      if ( nRULayer  ==   - 1  )
       continue ;     nLULayer  =  CheckLayerTile( nLUTile, nLDTexture );
      if ( nLULayer  ==   - 1  )
       continue ;      if ( IsValidRandBlock( m_pTile[nLDTile].Block[nLDLayer] )  &&
         IsValidRandBlock( m_pTile[nRDTile].Block[nRDLayer] )  &&  
         IsValidRandBlock( m_pTile[nRUTile].Block[nRULayer] )  &&  
         IsValidRandBlock( m_pTile[nLUTile].Block[nLULayer] ) )
      {
       if ( m_nSelectTexture  <  nLDTexture )
       {
       m_pTile[nLDTile].Block[nLDLayer]  =   27   -  s_pBaseTexIndex_c[ 2 ];
       m_pTile[nRDTile].Block[nRDLayer]  =   27   -  s_pBaseTexIndex_c[ 3 ];
       m_pTile[nRUTile].Block[nRULayer]  =   27   -  s_pBaseTexIndex_c[ 1 ];
       m_pTile[nLUTile].Block[nLULayer]  =   27   -  s_pBaseTexIndex_c[ 0 ];
      }
       continue ;
     }       if (  ! IsValidSubBlock( nLDTile, nLDLayer,  2  )  ||  
          ! IsValidSubBlock( nRDTile, nRDLayer,  3  )  ||  
          ! IsValidSubBlock( nRUTile, nRULayer,  1  )  ||  
          ! IsValidSubBlock( nLUTile, nLULayer,  0  ) )
      {
       continue ;
     }      ChangeBlock( nLDTile, nLDLayer,  2  );
     ChangeBlock( nRDTile, nRDLayer,  3  );
     ChangeBlock( nRUTile, nRULayer,  1  );
     ChangeBlock( nLUTile, nLULayer,  0  );
}
} // +-------------&-------------
 // +---------------------------&-------------------------
BOOL IsValidSubBlock( s32 nTile, s32 nLayer, s32 nIndex )
 {
s32 nBlock  =  m_pTile[nTile].Block[nLayer]  -  s_pBaseTexIndex_c[nIndex]; if (  ! IsValidBlock( nBlock ) )
      return  FALSE; if ( nBlock  ==   0   ||   ! IsValidRandBlock( nBlock ) )
      return  TRUE; return  TRUE;
} // +-------------&-------------
 // +---------------------------&-------------------------
void  ChangeBlock( s32 nTile, s32 nLayer, s32 nIndex )
 {
s32 nBlock  =  m_pTile[nTile].Block[nLayer]; if (  ! IsValidRandBlock( nBlock ) )
 {
     nBlock  =  nBlock  -  s_pBaseTexIndex_c[nIndex];
     m_pTile[nTile].Block[nLayer]  =  nBlock;      if ( nBlock  ==   0  )
      {
      m_pTile[nTile].Block[nLayer]  =   0 ;
      m_pTile[nTile].Texture[nLayer]  =  TE_INVALID_TILE;
     }
}
else
{
     m_pTile[nTile].Block[nLayer]  =   27   -  s_pBaseTexIndex_c[nIndex];
}
} // -------------&-------------
 // ---------------------------&-------------------------
void  SetTileAttribute( s32 nTile, s32 nLayer, s32 nBlock )
 {
 if ( nBlock  ==   27  )
 {
      //  nBlock = s_pRandTexIndex_c[rand() % TE_TEX_RAND_C];     s32 i = 0;
      for ( ; i  <  TE_TILE_COUNT;  ++ i )
      {
       if ( m_pTile[nTile].Texture[i]  <  m_nSelectTexture )
       {
       m_pTile[nTile].Block[i]  =   0 ;
       m_pTile[nTile].Texture[i]  =  TE_INVALID_TILE;
      }
     }      m_pTile[nTile].Texture[nLayer]  =  m_nSelectTexture;
} if (  ! IsValidBlock( nBlock ) )
 {
     nBlock  =   0 ;
} if ( nBlock  >=   32  )
 {
     nBlock  =   27 ;
} m_pTile[nTile].Block[nLayer]  =  nBlock;
}
xueyong1203
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RD算法（一）初出茅庐 —— 算法原理
lightninghenry的博客
08-13 3734
在《SAR成像概述》的第4节已经对各种SAR成像算法进行了一个简要的概述，本文就直接从RD算法讲起了。
魔兽争霸地图加密-算法辅助计算工具1.1.zip
02-14
魔兽争霸地图加密，魔兽争霸地图算法加密辅助工具，亲测好用，欢迎看魔兽争霸地图加密教程
魔兽纹理的一图两用
Dev in Nightmare
10-04 2229
    近来尝试导入魔兽世界的模型，遇到了不少意料之外的事情。比如.m2的顶点竟然是预乘了bone offset矩阵的，让我花了不少时间在找这个矩阵上，结果它根本没有，不需要。最大的意料之外是它一张纹理两种用途，它在纹理的全透明部分又放置了其它纹理内容。原理上很好理解，反正RGBA四个通道是独立的，当A等于0时，也就是完全透明时，RGB的值就没意义了；所以这些RGB完全可以用来存些别的值，只要忽略
war3 魔兽争霸悬崖地形算法
twopointfive的专栏
03-01 1628
war3 魔兽争霸悬崖地形算法
平滑过渡的战争迷雾(一) 原理：Warcraft3地形拼接算法
yingtan360的博客
08-17 5710
转载自：http://blog.csdn.net/u011371356/article/details/9611887       在上一节中，雾央讲解了一种战争迷雾的实现方法，思想很简单，实现出来的效果里锯齿感也很强，当然如果网格能比较小，看起来也还算凑合，不过用在游戏中就显得不是很合适了。今天雾央将讲解一种新的算法，可以用来实现平滑过渡的战争迷雾，由于内容比较多，所以雾央会分几节笔记来讲解，
《魔兽争霸3》魔兽攻防算法
痞子龙3D编程
05-29 2643
攻击/防御类型   　　魔兽三类似于星际 每个兵种都有特定的攻击/防御类型。但是种类要多一些。 　　攻击类型一共有5种 　　普通/穿刺/攻城/魔法/chaos 　　防御类型也有5种 　　轻型/中形/重形/英雄/建筑 　　＃普通伤害(normal) :普通伤害 对轻型盔甲造成150% 的伤害，对中形/重形/英雄3种类型造成100%伤害. 对建筑造成50%的伤害。 　　大多
[War3]Fdf文件详解，简单的UI教程演示 - 魔兽争霸3
热门推荐
Carlos
04-22 2万+
[UI]背景模板 Frame "BACKDROP" "Powerbak"{ Width 0.055, //宽度 Height 0.055, //高度 BackdropTileBackground, //背景平铺 BackdropBackground "UI\Widgets\Console\Human\human-inventory-slotfiller.blp", //背景路径 Bac...
魔兽3无法启动此程序因为计算机中丢失,魔兽争霸3没法启动 总提示directx没法初始化...
weixin_34611130的博客
07-04 1889
出现这种错误的原因主要有三种：1.DirectX版本过低，运行魔兽争霸需要DirectX8.1或者更高版本；(WIN7系统可以忽视)2.DirectDraw加速、Dierct3D加速、AGP纹理加速三项没有开启；3.显卡驱动程序不是最新的。DirectX版本过低，运行魔兽争霸需要DirectX8.1或者更高版本：下载并安装新版本的DirectX，这里是微软DirectX9.0c的官方下载地址：ht...
如何将经典算法与人工智能结合？NeurIPS 2021
zero的博客
11-11 3302
点击下方“AI算法与图像处理”，一起进步！ 重磅干货，第一时间送达目前的监督学习模型是基于label作为学习目标，那么是否可以添加经典算法（如排序）来作为约束？深度学习可以不断优化，很重...
war3 魔兽争霸3 双开 多开 联机 补丁 工具
Smile_qiqi的专栏
07-19 1万+
补丁下载地址：http://download.csdn.net/detail/smile_qiqi/7531895
魔兽世界三(开战)-北京大学-C++程序设计与算法
02-11
该资源是中国大学MOOC网站上北京大学开设的《C++程序设计与算法-3》的最终大作业，博主在倍速看完后，使用QT完全由自己编写而成。由于考虑到程序的整体架构清晰明白，分了好几个类文件，后来看了网上其他同学的代码...
魔兽3字体及转换器.zip
03-15
本文将详细介绍《魔兽3字体及转换器.zip》这一资源包，包括其中的字体资源和转换工具，以及如何使用它们来改善游戏内的文字显示效果。 首先，此压缩包提供的“魔兽3字体”是一套专为魔兽争霸3设计的自用字体。这套...
魔兽争霸3模型查看器.zip
10-10
《魔兽争霸3模型查看器》是一款专为《魔兽争霸3》玩家和地图编辑者设计的实用工具，它允许用户在不启动游戏的情况下查看、研究和分析游戏中的模型资源。这款软件对于想要深入了解游戏美术设计或者进行自定义地图开发...
我分享个魔兽内存修改器
05-21
内存修改器单机玩支持版本 ...* 1.24d（1.24.3.6384） * 1.24e（1.24.4.6387） * 1.25b（1.25.1.6397） * 1.26（1.26.0.6401） * 1.27a（1.27.0.52240） * 1.28（1.28.0.7205） * 1.28f（1.28.5.7680）
Leetcode42接雨水（单调栈）
AGNING的博客
08-28 397
维护一个栈，满足从栈底到栈顶元素大小递减。如果当前元素高于栈顶，且栈内有至少2个元素，则形成了一个凹槽，及一个图中横着的红色矩形，将它的面积累加即可，第一次写难在维护单调栈中计算面积和。求出前缀最大和后缀最大，用两者较小值减去当前高度，累加即可，这个思路容易想到，这里不赘述。
递归、搜索与回溯算法
最新发布
无聊_人的博客
08-29 4134
所谓的递归其实就是函数自己调用自己的情况。
代码随想录算法训练营第62天|Floyd 算法精讲、A * 算法精讲 （A star算法）
Yinems的博客
08-28 1266
分两种情况，一种是节点 i 到节点 j 的最短路径经过节点 k，grid[i][j][k] = grid[i][k][k-1] + grid[k][j][k-1]；另一种情况，节点 i 到节点 j 的最短路径不经过节点 k，grid[i][j][k] = grip[i][j][k-1]；刚开始初始化 k 是不确定的，如果赋值为1，那么不能知道节点 i 到节点 j 经过1个节点的最短距离，所以只能把 k 赋值为0，本题中节点0是无意义的，节点是从1到n。本题求的是最小值，所以其余值初始化为最大值。
57. 插入区间【 力扣(LeetCode) 】
yyh520025的博客
08-29 4515
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
魔兽世界与传奇：游戏平衡算法解析
"魔兽世界基本计算公式涉及到各个职业的攻击力计算方法以及游戏中平衡算法的探讨，包括了加减法和乘除法两种不同的计算模式。" 在魔兽世界中，角色的攻击力是由不同的计算公式决定的，这直接影响了游戏的平衡性。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值