/* ** Command & Conquer Renegade(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 . */ /*************************************************************************** *** 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 $* * * * $Author:: Jani_p $* * * * $Modtime:: 10/03/01 11:27a $* * * * $Revision:: 11 $* * * *-------------------------------------------------------------------------* * Functions: * * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ #include "bmp2d.h" #include "pot.h" #include "ww3d.h" #include "texture.h" #include "surfaceclass.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 SurfaceClass *surface=NEW_REF(SurfaceClass,(filename)); 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,TextureClass::MIP_LEVELS_1)); piece_texture->Set_U_Addr_Mode(TextureClass::TEXTURE_ADDRESS_CLAMP); piece_texture->Set_V_Addr_Mode(TextureClass::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(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); // 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)); }