texturefilter.cpp

Go to the documentation of this file.

/*
**  Command & Conquer Generals Zero Hour(tm)
**  Copyright 2025 Electronic Arts Inc.
**
**  This program is free software: you can redistribute it and/or modify
**  it under the terms of the GNU General Public License as published by
**  the Free Software Foundation, either version 3 of the License, or
**  (at your option) any later version.
**
**  This program is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
/***********************************************************************************************
 ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
 ***********************************************************************************************
 *                                                                                             *
 *                 Project Name : WW3D                                                         *
 *                                                                                             *
 *                     $Archive:: ww3d2/texturefilter.cpp                                               $*
 *                                                                                             *
 *                  $Org Author:: Kenny Mitchell                                              $*
 *                                                                                             *
 *                       Author : Kenny Mitchell                                               * 
 *                                                                                             * 
 *                     $Modtime:: 08/05/02 1:27p                                              $*
 *                                                                                             *
 *                    $Revision:: 1                                                          $*
 *                                                                                             *
 * 08/05/02 KM Texture filter class abstraction                                                                         *
 *---------------------------------------------------------------------------------------------*
 * Functions:                                                                                  *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
#include "texturefilter.h"
#include "dx8wrapper.h"
 
unsigned _MinTextureFilters[MAX_TEXTURE_STAGES][TextureFilterClass::FILTER_TYPE_COUNT];
unsigned _MagTextureFilters[MAX_TEXTURE_STAGES][TextureFilterClass::FILTER_TYPE_COUNT];
unsigned _MipMapFilters[MAX_TEXTURE_STAGES][TextureFilterClass::FILTER_TYPE_COUNT];
 
/*************************************************************************
**                             TextureFilterClass
*************************************************************************/
TextureFilterClass::TextureFilterClass(MipCountType mip_level_count=MIP_LEVELS_1)
:   TextureMinFilter(FILTER_TYPE_DEFAULT),
    TextureMagFilter(FILTER_TYPE_DEFAULT),
    UAddressMode(TEXTURE_ADDRESS_REPEAT),
    VAddressMode(TEXTURE_ADDRESS_REPEAT)
{
    if (mip_level_count!=MIP_LEVELS_1)
    {
        MipMapFilter=FILTER_TYPE_DEFAULT;
    }
    else
    {
        MipMapFilter=FILTER_TYPE_NONE;
    }
}
 
//**********************************************************************************************

void TextureFilterClass::Apply(unsigned int stage)
{
    DX8Wrapper::Set_DX8_Texture_Stage_State(stage,D3DTSS_MINFILTER,_MinTextureFilters[stage][TextureMinFilter]);
    DX8Wrapper::Set_DX8_Texture_Stage_State(stage,D3DTSS_MAGFILTER,_MagTextureFilters[stage][TextureMagFilter]);
    DX8Wrapper::Set_DX8_Texture_Stage_State(stage,D3DTSS_MIPFILTER,_MipMapFilters[stage][MipMapFilter]);
 
    switch (Get_U_Addr_Mode()) 
    {
    case TEXTURE_ADDRESS_REPEAT:
        DX8Wrapper::Set_DX8_Texture_Stage_State(stage, D3DTSS_ADDRESSU, D3DTADDRESS_WRAP);
        break;
 
    case TEXTURE_ADDRESS_CLAMP:
        DX8Wrapper::Set_DX8_Texture_Stage_State(stage, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
        break;
    }
 
    switch (Get_V_Addr_Mode()) 
    {
    case TEXTURE_ADDRESS_REPEAT:
        DX8Wrapper::Set_DX8_Texture_Stage_State(stage, D3DTSS_ADDRESSV, D3DTADDRESS_WRAP);
        break;
 
    case TEXTURE_ADDRESS_CLAMP:
        DX8Wrapper::Set_DX8_Texture_Stage_State(stage, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP);
        break;
    }
}
 
//**********************************************************************************************

void TextureFilterClass::_Init_Filters(TextureFilterMode filter_type)
{
    const D3DCAPS8& dx8caps=DX8Wrapper::Get_Current_Caps()->Get_DX8_Caps();
 
#ifndef _XBOX
    _MinTextureFilters[0][FILTER_TYPE_NONE]=D3DTEXF_POINT;
    _MagTextureFilters[0][FILTER_TYPE_NONE]=D3DTEXF_POINT;
    _MipMapFilters[0][FILTER_TYPE_NONE]=D3DTEXF_NONE;
   
    _MinTextureFilters[0][FILTER_TYPE_FAST]=D3DTEXF_LINEAR;
    _MagTextureFilters[0][FILTER_TYPE_FAST]=D3DTEXF_LINEAR;
    _MipMapFilters[0][FILTER_TYPE_FAST]=D3DTEXF_POINT;
   
    _MagTextureFilters[0][FILTER_TYPE_BEST]=D3DTEXF_POINT;
    _MinTextureFilters[0][FILTER_TYPE_BEST]=D3DTEXF_POINT;
    _MipMapFilters[0][FILTER_TYPE_BEST]=D3DTEXF_POINT;
#else
    _MinTextureFilters[0][FILTER_TYPE_NONE]=D3DTEXF_ANISOTROPIC;
    _MagTextureFilters[0][FILTER_TYPE_NONE]=D3DTEXF_ANISOTROPIC;
    _MipMapFilters[0][FILTER_TYPE_NONE]=D3DTEXF_LINEAR;
 
    _MinTextureFilters[0][FILTER_TYPE_FAST]=D3DTEXF_ANISOTROPIC;
    _MagTextureFilters[0][FILTER_TYPE_FAST]=D3DTEXF_ANISOTROPIC;
    _MipMapFilters[0][FILTER_TYPE_FAST]=D3DTEXF_LINEAR;
 
    _MagTextureFilters[0][FILTER_TYPE_BEST]=D3DTEXF_ANISOTROPIC;
    _MinTextureFilters[0][FILTER_TYPE_BEST]=D3DTEXF_ANISOTROPIC;
    _MipMapFilters[0][FILTER_TYPE_BEST]=D3DTEXF_LINEAR;
#endif
 
#ifndef _XBOX
    if (dx8caps.TextureFilterCaps&D3DPTFILTERCAPS_MAGFLINEAR) _MagTextureFilters[0][FILTER_TYPE_BEST]=D3DTEXF_LINEAR;
    if (dx8caps.TextureFilterCaps&D3DPTFILTERCAPS_MINFLINEAR) _MinTextureFilters[0][FILTER_TYPE_BEST]=D3DTEXF_LINEAR;
 
    // Set anisotropic filtering only if requested and available
    if (filter_type==TEXTURE_FILTER_ANISOTROPIC) {
        if (dx8caps.TextureFilterCaps&D3DPTFILTERCAPS_MAGFANISOTROPIC) _MagTextureFilters[0][FILTER_TYPE_BEST]=D3DTEXF_ANISOTROPIC;
        if (dx8caps.TextureFilterCaps&D3DPTFILTERCAPS_MINFANISOTROPIC) _MinTextureFilters[0][FILTER_TYPE_BEST]=D3DTEXF_ANISOTROPIC;
    }
 
    // Set linear mip filter only if requested trilinear or anisotropic, and linear available
    if (filter_type==TEXTURE_FILTER_ANISOTROPIC || filter_type==TEXTURE_FILTER_TRILINEAR) {
        if (dx8caps.TextureFilterCaps&D3DPTFILTERCAPS_MIPFLINEAR) _MipMapFilters[0][FILTER_TYPE_BEST]=D3DTEXF_LINEAR;
    }
#endif
 
    // For stages above zero, set best filter to the same as the stage zero, except if anisotropic
    for (int i=1;i<MAX_TEXTURE_STAGES;++i) {
/*      _MinTextureFilters[i][FILTER_TYPE_NONE]=D3DTEXF_POINT;
        _MagTextureFilters[i][FILTER_TYPE_NONE]=D3DTEXF_POINT;
        _MipMapFilters[i][FILTER_TYPE_NONE]=D3DTEXF_NONE;
 
        _MinTextureFilters[i][FILTER_TYPE_FAST]=D3DTEXF_LINEAR;
        _MagTextureFilters[i][FILTER_TYPE_FAST]=D3DTEXF_LINEAR;
        _MipMapFilters[i][FILTER_TYPE_FAST]=D3DTEXF_POINT;
 
        _MagTextureFilters[i][FILTER_TYPE_BEST]=D3DTEXF_LINEAR;
        _MinTextureFilters[i][FILTER_TYPE_BEST]=D3DTEXF_LINEAR;
        _MipMapFilters[i][FILTER_TYPE_BEST]=D3DTEXF_POINT;
*/
        _MinTextureFilters[i][FILTER_TYPE_NONE]=_MinTextureFilters[i-1][FILTER_TYPE_NONE];
        _MagTextureFilters[i][FILTER_TYPE_NONE]=_MagTextureFilters[i-1][FILTER_TYPE_NONE];
        _MipMapFilters[i][FILTER_TYPE_NONE]=_MipMapFilters[i-1][FILTER_TYPE_NONE];
 
        _MinTextureFilters[i][FILTER_TYPE_FAST]=_MinTextureFilters[i-1][FILTER_TYPE_FAST];
        _MagTextureFilters[i][FILTER_TYPE_FAST]=_MagTextureFilters[i-1][FILTER_TYPE_FAST];
        _MipMapFilters[i][FILTER_TYPE_FAST]=_MipMapFilters[i-1][FILTER_TYPE_FAST];
 
        if (_MagTextureFilters[i-1][FILTER_TYPE_BEST]==D3DTEXF_ANISOTROPIC) {
            _MagTextureFilters[i][FILTER_TYPE_BEST]=D3DTEXF_LINEAR;
        }
        else {
            _MagTextureFilters[i][FILTER_TYPE_BEST]=_MagTextureFilters[i-1][FILTER_TYPE_BEST];
        }
 
        if (_MinTextureFilters[i-1][FILTER_TYPE_BEST]==D3DTEXF_ANISOTROPIC) {
            _MinTextureFilters[i][FILTER_TYPE_BEST]=D3DTEXF_LINEAR;
        }
        else {
            _MinTextureFilters[i][FILTER_TYPE_BEST]=_MinTextureFilters[i-1][FILTER_TYPE_BEST];
        }
        _MipMapFilters[i][FILTER_TYPE_BEST]=_MipMapFilters[i-1][FILTER_TYPE_BEST];
 
 
    }
 
    // Set default to best. The level of best filter mode is controlled by the input parameter.
    for (i=0;i<MAX_TEXTURE_STAGES;++i) {
        _MinTextureFilters[i][FILTER_TYPE_DEFAULT]=_MinTextureFilters[i][FILTER_TYPE_BEST];
        _MagTextureFilters[i][FILTER_TYPE_DEFAULT]=_MagTextureFilters[i][FILTER_TYPE_BEST];
        _MipMapFilters[i][FILTER_TYPE_DEFAULT]=_MipMapFilters[i][FILTER_TYPE_BEST];
 
        DX8Wrapper::Set_DX8_Texture_Stage_State(i,D3DTSS_MAXANISOTROPY,2);
    }
 
}
 
 
//**********************************************************************************************

void TextureFilterClass::Set_Mip_Mapping(FilterType mipmap)
{
//  if (mipmap != FILTER_TYPE_NONE && Get_Mip_Level_Count() <= 1 && Is_Initialized()) 
//  {
//      WWASSERT_PRINT(0, "Trying to enable MipMapping on texture w/o Mip levels!\n");
//      return;
//  }
    MipMapFilter=mipmap;
}
 
//**********************************************************************************************

void TextureFilterClass::_Set_Default_Min_Filter(FilterType filter)
{
    for (int i=0;i<MAX_TEXTURE_STAGES;++i) 
    {
        _MinTextureFilters[i][FILTER_TYPE_DEFAULT]=_MinTextureFilters[i][filter];
    }
}
 
 
//**********************************************************************************************

void TextureFilterClass::_Set_Default_Mag_Filter(FilterType filter)
{
    for (int i=0;i<MAX_TEXTURE_STAGES;++i) 
    {
        _MagTextureFilters[i][FILTER_TYPE_DEFAULT]=_MagTextureFilters[i][filter];
    }
}
 
//**********************************************************************************************

void TextureFilterClass::_Set_Default_Mip_Filter(FilterType filter)
{
    for (int i=0;i<MAX_TEXTURE_STAGES;++i) 
    {
        _MipMapFilters[i][FILTER_TYPE_DEFAULT]=_MipMapFilters[i][filter];
    }
}