bmp2d.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 : Commando/G                               * 
 *                                                                         * 
 *                     $Archive:: /Commando/Code/ww3d2/bmp2d.cpp          $* 
 *                                                                         * 
 *                  $Org Author:: Jani_p                                  $* 
 *                                                                         * 
 *                      $Author:: Kenny_m                                  $* 
 *                                                                         * 
 *                     $Modtime:: 08/05/02 10:44a                          $* 
 *                                                                         * 
 *                    $Revision:: 12                                      $* 
 *                                                                         * 
 * 08/05/02 KM Texture class redesign
 *-------------------------------------------------------------------------* 
 * Functions:                                                              * 
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
#include "bmp2d.h"
#include "pot.h"
#include "ww3d.h"
#include "texture.h"
#include "surfaceclass.h"
#include "assetmgr.h"
#include "textureloader.h"
#include "ww3dformat.h"
 
Bitmap2DObjClass::Bitmap2DObjClass
(
    const char *filename,
    float screen_x,
    float screen_y,
    bool center,
    bool additive,
    bool colorizable,
    int usable_width,
    int usable_height,
    bool ignore_alpha
)
    :   DynamicScreenMeshClass(2, 4)
{
    
    int resw, resh, resbits;
    bool windowed;
    
    // find the resolution (for centering and pixel to pixel translation)
    WW3D::Get_Device_Resolution(resw, resh, resbits, windowed);
    // This should be the correct way to do things
    // but other code expects an aspect ratio of 1.0
    // Hector Yee 2/22/01
    // Set_Aspect(resh/(float)resw);
    
 
    // load up the surfaces file name
    TextureClass *tex = WW3DAssetManager::Get_Instance()->Get_Texture(filename, MIP_LEVELS_1);
    if (!tex->Is_Initialized())   
        TextureLoader::Request_Foreground_Loading(tex);
 
    SurfaceClass *surface = tex->Get_Surface_Level(0);
 
    if (!surface) {
        surface = NEW_REF(SurfaceClass, (32, 32, Get_Valid_Texture_Format(WW3D_FORMAT_R8G8B8,true)));
    }
 
    SurfaceClass::SurfaceDescription sd;
    surface->Get_Description(sd);
 
    if (usable_width == -1)
        usable_width = sd.Width;
    if (usable_height == -1)
        usable_height = sd.Height;
 
    // if we requested the image to be centered around a point adjust the
    // coordinates accordingly.
    if (center) {
        screen_x -= ((float)usable_width  / resw) / 2;
        screen_y -= ((float)usable_height / resh) / 2;
    }
 
    // The image will be broken down into square textures. The size of these
    // textures will be the smallest POT (power of two) which is equal or
    // greater than the smaller dimension of the image. Also, the pieces can
    // never be larger than 256 texels because some rendering devices don't
    // support textures larger than that.
    int surf_w = usable_width;
    int surf_h = usable_height;
    int piece = Find_POT(MIN(surf_w, surf_h));
    piece = MIN(piece, 256);
 
    // now take the image in question and break it down into
    // "piece"x"piece"-pixel polygons and calculate the number of textures
    // based from those calculations.
    int mw = (surf_w & (piece - 1)) ? (surf_w / piece)+1 : (surf_w /piece);
    int mh = (surf_h & (piece - 1)) ? (surf_h / piece)+1 : (surf_h /piece);
    
    // for every square texture it takes four vertexes to express the two
    // polygons.
    Resize(mw * mh *2, mw * mh * 4);
 
    // Set shader to additive if requested, else alpha or opaque depending on
    // whether the texture has an alpha channel. Sorting is always set so that
    // sortbias can be used to determine occlusion between the various 2D
    // elements.
    ShaderClass shader;
 
    if (additive) {
        shader = ShaderClass::_PresetAdditive2DShader;
    } else {
        if (ignore_alpha == false && Has_Alpha(sd.Format)) {
            shader = ShaderClass::_PresetAlpha2DShader;
        } else {
            shader = ShaderClass::_PresetOpaque2DShader;
        }
    }
 
    Enable_Sort();
 
 
    // If we want to be able to colorize this bitmap later (by setting
    // emissive color for the vertex material, or via a vertex emissive color
    // array) we need to enable the primary gradient in the shader (it is
    // disabled in the 2D presets), and set an appropriate vertex material.
    if (colorizable) {
        shader.Set_Primary_Gradient(ShaderClass::GRADIENT_MODULATE);
        VertexMaterialClass *vertex_material = NEW_REF( VertexMaterialClass, ());
        vertex_material->Set_Ambient(0.0f, 0.0f, 0.0f);
        vertex_material->Set_Diffuse(0.0f, 0.0f, 0.0f);
        vertex_material->Set_Specular(0.0f, 0.0f, 0.0f);
        vertex_material->Set_Emissive(1.0f, 1.0f, 1.0f);
        Set_Vertex_Material(vertex_material, true);
        vertex_material->Release_Ref();
    }
 
    // Set desired shader.
    Set_Shader(shader);
 
    // loop through the rows and columns of the image and make valid
    // textures from the pieces.
    for (int lpy = 0, tlpy=0; lpy < mh; lpy++, tlpy += piece) {
        for (int lpx = 0, tlpx = 0; lpx < mw; lpx++, tlpx += piece) {
 
            // figure the desired width and height of the texture (max "piece")
            int iw              = MIN(piece, usable_width - (tlpx));
            int ih              = MIN(piece, usable_height - (tlpy));
            int pot             = MAX(Find_POT(iw), Find_POT(ih));
 
            // create the texture and turn MIP-mapping off.
            SurfaceClass *piece_surface=NEW_REF(SurfaceClass,(pot,pot,sd.Format));         
            piece_surface->Copy(0,0,tlpx,tlpy,pot,pot,surface);
            TextureClass *piece_texture =NEW_REF(TextureClass,(piece_surface,MIP_LEVELS_1));         
            piece_texture->Get_Filter().Set_U_Addr_Mode(TextureFilterClass::TEXTURE_ADDRESS_CLAMP);
            piece_texture->Get_Filter().Set_V_Addr_Mode(TextureFilterClass::TEXTURE_ADDRESS_CLAMP);
            REF_PTR_RELEASE(piece_surface);          
 
            // calculate our actual texture coordinates based on the difference between
            // the width and height of the texture and the width and height the font
            // occupys.
            float tw = (float)iw / (float)pot;
            float th = (float)ih / (float)pot;
 
            // convert image width and image height to normalized values
            float vw = (float)iw / (float)resw;
            float vh = (float)ih / (float)resh;
 
            // figure out the screen space x and y positions of the object in question.
            float x = screen_x + (((float)tlpx) / (float)resw);
            float y = screen_y + (((float)tlpy) / (float)resh);
            
            Set_Texture(piece_texture);
            Begin_Tri_Strip();
                Vertex( x,            y,      0,  0,  0);
                Vertex( x + vw,   y,      0,  tw,     0);
                Vertex( x,            y + vh,     0,  0,  th);
                Vertex( x + vw,   y + vh,     0,  tw,     th);
            End_Tri_Strip();
 
            // release our reference to the texture
            REF_PTR_RELEASE(piece_texture);          
        }
    }
    REF_PTR_RELEASE(tex);
    REF_PTR_RELEASE(surface);    
 
    Set_Dirty();
}
 
Bitmap2DObjClass::Bitmap2DObjClass
(
    TextureClass *texture,
    float screen_x,
    float screen_y,
    bool center,
    bool additive,
    bool colorizable,
    bool ignore_alpha
)
    :   DynamicScreenMeshClass(2, 4)
{
    int resw, resh, resbits;
    bool windowed;
 
    // find the resolution (for centering and pixel to pixel translation)
    WW3D::Get_Device_Resolution(resw, resh, resbits, windowed);
    // This should be the correct way to do things
    // but other code expects an aspect ratio of 1.0
    // Hector Yee 2/22/01
    //Set_Aspect(resh/(float)resw);
 
    // Find the dimensions of the texture:
//  SurfaceClass::SurfaceDescription sd;
//  texture->Get_Level_Description(sd);
 
    if (!texture->Is_Initialized())   
        TextureLoader::Request_Foreground_Loading(texture);
        
    // convert image width and image height to normalized values
    float vw = (float) texture->Get_Width() / (float)resw;
    float vh = (float) texture->Get_Height() / (float)resh;
 
    // if we requested the image to be centered around a point adjust the
    // coordinates accordingly.
    if (center) {
        screen_x -= vw / 2;
        screen_y -= vh / 2;
    }
 
    // Set shader to additive if requested, else alpha or opaque depending on whether the texture
    // has an alpha channel. Sorting is never set - if you wish to sort these types of objects you
    // should use static sort levels (note that static sort levels are not implemented for these
    // objects yet, but it should be very simple to do).
    ShaderClass shader;
 
    if (additive) {
        shader = ShaderClass::_PresetAdditive2DShader;
    } else {
        if (ignore_alpha == false && Has_Alpha(texture->Get_Texture_Format())) {
            shader = ShaderClass::_PresetAlpha2DShader;
        } else {
            shader = ShaderClass::_PresetOpaque2DShader;
        }
    }
    Disable_Sort();
 
    // If we want to be able to colorize this bitmap later (by setting
    // emissive color for the vertex material, or via a vertex emissive color
    // array) we need to enable the primary gradient in the shader (it is
    // disabled in the 2D presets), and set an appropriate vertex material.
    if (colorizable) {
        shader.Set_Primary_Gradient(ShaderClass::GRADIENT_MODULATE);
        VertexMaterialClass *vertex_material = NEW_REF( VertexMaterialClass, ());
        vertex_material->Set_Ambient(0.0f, 0.0f, 0.0f);
        vertex_material->Set_Diffuse(0.0f, 0.0f, 0.0f);
        vertex_material->Set_Specular(0.0f, 0.0f, 0.0f);
        vertex_material->Set_Emissive(1.0f, 1.0f, 1.0f);
        Set_Vertex_Material(vertex_material, true);
        vertex_material->Release_Ref();
    }
 
    // Set desired shader.
    Set_Shader(shader);
 
    // Set texture to requested texture:
    Set_Texture(texture);
 
    Begin_Tri_Strip();
        Vertex( screen_x,         screen_y,       0,  0,      0);
        Vertex( screen_x + vw,    screen_y,       0,  1.0,    0);
        Vertex( screen_x,         screen_y + vh,  0,  0,      1.0);
        Vertex( screen_x + vw,    screen_y + vh,  0,  1.0,    1.0);
    End_Tri_Strip();
 
    Set_Dirty();
}
 
RenderObjClass * Bitmap2DObjClass::Clone(void) const
{
    return NEW_REF( Bitmap2DObjClass, (*this));
}