util.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/>.
*/
 
/* $Header: /Commando/Code/Tools/max2w3d/util.cpp 28    10/27/00 4:12p Greg_h $ */
/*********************************************************************************************** 
 ***                            Confidential - Westwood Studios                              *** 
 *********************************************************************************************** 
 *                                                                                             * 
 *                 Project Name : Commando Tools - W3D export                                  * 
 *                                                                                             * 
 *                     $Archive:: /Commando/Code/Tools/max2w3d/util.cpp                       $* 
 *                                                                                             * 
 *                      $Author:: Greg_h                                                      $* 
 *                                                                                             * 
 *                     $Modtime:: 10/27/00 1:13p                                              $* 
 *                                                                                             * 
 *                    $Revision:: 28                                                          $* 
 *                                                                                             * 
 *---------------------------------------------------------------------------------------------* 
 * Functions:                                                                                  * 
 *   Cleanup_Orthogonal_Matrix -- removes very small numbers from the matrix                   * 
 *   Set_W3D_Name -- set a W3D name                                                            * 
 *   Split_Node_Name -- break a node name into the base and extension                          * 
 *   Is_Max_Tri_Mesh -- Is this node a triangle mesh?                                          *
 *    -- checks if the node is the origin of a model                                           *
 *    -- Checks if the node is the origin for the base obect (non-LOD'd).                      *
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
#include "util.h"
#include "w3dutil.h"
#include "skin.h"
#include "skindata.h"
#include "modstack.h"
 
 
#define MAX_NODE_NAME_LEN 256       // max name size we can handle
 
const float EPSILON = 0.00001f;
static char _string[256];
 
 
 
static int get_geometry_type(INode * node)
{
    assert(node != NULL);
    return W3DAppData2Struct::Get_App_Data(node)->Get_Geometry_Type();
 
    //return (get_w3d_bits(node) & GEO_TYPE_MASK);
}
 
 
/*********************************************************************************************** 
 * Cleanup_Orthogonal_Matrix -- removes very small numbers from the matrix                     * 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 *                                                                                             * 
 * OUTPUT:                                                                                     * 
 *                                                                                             * 
 * WARNINGS:                                                                                   * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   10/26/1997 GH  : Created.                                                                 * 
 *=============================================================================================*/
Matrix3  Cleanup_Orthogonal_Matrix(Matrix3 & mat)
{
    Matrix3 newmat = mat;
 
    for (int j=0; j<3; j++) {
        Point3 row = newmat.GetRow(j);
    
        if (fabs(row.x) < EPSILON) row.x = 0.0f;
        if (fabs(row.y) < EPSILON) row.y = 0.0f;
        if (fabs(row.z) < EPSILON) row.z = 0.0f;
 
        row = Normalize(row);
 
        newmat.SetRow(j,row);
    }
 
    return newmat;
}
 
/*********************************************************************************************** 
 * Set_W3D_Name -- set a W3D name                                                              * 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 *                                                                                             * 
 * OUTPUT:                                                                                     * 
 *                                                                                             * 
 * WARNINGS:                                                                                   * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   10/26/1997 GH  : Created.                                                                 * 
 *   9/13/1999  AJA : Strip off the trailing ".digits" since this is a convention we've set in *
 *                    MAX to help artists manage LODs.                                         *
 *=============================================================================================*/
void Set_W3D_Name(char * set_name,const char * src)
{
    memset(set_name,0,W3D_NAME_LEN);
    strncpy(set_name,src,W3D_NAME_LEN-1);
    char *dot = strrchr(set_name, '.');
    if (dot)
    {
        // If a number comes after the dot, strip it off
        int value;
        if (sscanf(dot+1, "%d", &value) == 1)
            *dot = 0;
        // If nothing comes after the dot, strip it off
        else if (*(dot+1) == 0)
            *dot = 0;
    }
    strupr(set_name);
}
 
/*********************************************************************************************** 
 * Split_Node_Name -- break a node name into the base and extension                            * 
 *                                                                                             * 
 * INPUT:                                                                                      * 
 *                                                                                             * 
 * OUTPUT:                                                                                     * 
 *                                                                                             * 
 * WARNINGS:                                                                                   * 
 *                                                                                             * 
 * HISTORY:                                                                                    * 
 *   10/26/1997 GH  : Created.                                                                 * 
 *=============================================================================================*/
void Split_Node_Name(const char * name,char * set_base,char * set_exten,int * set_exten_index)
{
    // Nodes are assumed to be named in the following way:
    // <name>.<exten character><exten digits>
    // for example: mesh.d1
 
    char buf[MAX_NODE_NAME_LEN];
    char * ptr;
 
    assert(strlen(name) < MAX_NODE_NAME_LEN);
 
    // Initialize
    if (set_base != NULL) set_base[0] = 0;
    if (set_exten != NULL) set_exten[0] = 0;
    if (set_exten_index != NULL) *set_exten_index = 0;
        
    // Get the base name
    strncpy(buf,name,MAX_NODE_NAME_LEN);
    ptr = buf;
    while ((*ptr != 0) && (*ptr != '.')) {
        ptr++;
    }
 
    if (*ptr == '.') {
 
        // copy what we have so far into set_base
        *ptr = 0;
        if (set_base != NULL) strncpy(set_base,buf,MAX_NODE_NAME_LEN); 
 
        // copy the rest back into the extension
        ptr++;
        if (set_exten != NULL) strncpy(set_exten,ptr,MAX_NODE_NAME_LEN);
 
        // now get the extension index
        ptr++;
        if (set_exten_index != NULL) *set_exten_index = atoi(ptr);
 
    } else {
 
        // no extension, just copy the base name
        if (set_base != NULL) strncpy(set_base,buf,MAX_NODE_NAME_LEN);
        return;
    }
}
 
 
bool Append_Lod_Character (char *meshname, int lod_level, INodeListClass *origin_list)
{
    if (meshname == NULL || lod_level < 0)
        return false;
 
    if (!origin_list)
        return false;
 
    int num_lods = origin_list->Num_Nodes();
 
    /*
    ** Search the other LODs to see if there is a mesh with the same name.
    ** If there is, we will append the current LOD level digit to the name.
    ** If there is not, the name will not be modified.
    */
    INode *conflict = NULL, *cur_origin = NULL;
    int i, lod;
    for (i = 0; i < num_lods; i++)
    {
        // Don't bother searching the current LOD.
        lod = Get_Lod_Level((*origin_list)[i]);
        if (lod == lod_level)
            continue;
 
        // Search this lod for a node of the same name.
        conflict = Find_Named_Node(meshname, (*origin_list)[i]);
        if (conflict)
        {
            // Name length is a worry here, because the name plus the number
            // must be less than W3D_NAME_LEN (which is fairly small!).
            int length = strlen(meshname);
            if ( (lod_level < 10)  && (length < W3D_NAME_LEN - 1) )
            {
                // Append a number corresponding to the LOD level to the mesh name.
                // Highest-detail LOD is '0' (convention).
                char *insert = meshname + length;
                *insert++ = '0' + lod_level;
                *insert = '\0';
            }
            else if ( (lod_level < 100) && (length < W3D_NAME_LEN - 2) )
            {
                // Append a number corresponding to the LOD level to the mesh name.
                // Highest-detail LOD is '0' (convention).
                char buf[3];
                sprintf(buf, "%d", lod_level);
                strcat(meshname, buf);
            }
            else
            {
                // Replace the last character of the mesh name with the lod character (as above).
                meshname[W3D_NAME_LEN-2] = '0' + lod_level;
            }
 
            // Name mangling finished (conflict with other LODs is solved on their pass).
            break;
        }
    }
 
    return true;
}
 
 
 
void Create_Full_Path(char *full_path, const char *curr, const char *rel_path)
{
    // Copy current dir to full path. If it doesn't end with a slash, add one.
    strcpy(full_path, curr);
    int curr_len = strlen(curr);
    char *full_p = full_path + curr_len;    // Point at the terminating NULL
    if (curr_len == 0 ||(*(full_p - 1) != '/' && *(full_p - 1) != '\\')) {
        *full_p = '\\';
        *(++full_p) = '\000';   // Point at the terminating NULL
    }
 
    // Scan "..\"s at the beginning of the rel path, scan backwards on the
    // full path (current dir):
    const char *rel_p;
    for (   rel_p = rel_path;
            *rel_p == '.' && *(rel_p+1) == '.' && ( *(rel_p+2) == '/' || *(rel_p+2) == '\\' );
            rel_p += 3)
    {
        full_p--;
        for (; full_p > full_path && *(full_p-1) != '/' && *(full_p-1) != '\\'; full_p--);
        *full_p = '\000';
    }
 
    // Copy the remainder of the relative path to the full path:
    strcpy(full_p, rel_p);
}
 
// This enum is used inside Create_Relative_Path:
enum PathCharType {
    NULL_CHAR,
    SLASH_CHAR,
    PLAIN_CHAR
};
 
void Create_Relative_Path(char *rel_path,   const char *curr, const char *full_path)
{
    // Copy both constant strings and convert them to uppercase:
    int curr_len = strlen(curr);
    char *up_curr = (char *)malloc(curr_len + 1);
    strcpy(up_curr, curr);
    _strupr(up_curr);
 
    int full_len = strlen(full_path);
    char *up_full = (char *)malloc(full_len + 1);
    strcpy(up_full, full_path);
    _strupr(up_full);
 
    char *rel_p = rel_path;
 
    // Find shared prefix of curr and full path
    const char *full_p = up_full;
    const char *curr_p = up_curr;
    for (   ;
            *full_p && *full_p == *curr_p || (*full_p == '/' && *curr_p == '\\') || (*full_p == '\\' && *curr_p == '/');
            full_p++, curr_p++
    );
 
    // If no shared prefix at this point set the relative path to 0
    // This will force the code to use the absolute path.
    if (full_p == up_full) {
        rel_path[0] = 0;
        goto end;
    }
 
    // The first different character for each string can be: a NULL, a slash,
    // or an ordinary character.
    PathCharType full_type, curr_type;
    if (*full_p == '\000') {
        full_type = NULL_CHAR;
    } else {
        if (*full_p == '/' || *full_p == '\\') {
            full_type = SLASH_CHAR;
        } else {
            full_type = PLAIN_CHAR;
        }
    }
    if (*curr_p == '\000') {
        curr_type = NULL_CHAR;
    } else {
        if (*curr_p == '/' || *curr_p == '\\') {
            curr_type = SLASH_CHAR;
        } else {
            curr_type = PLAIN_CHAR;
        }
    }
    // If the last fullpath char is a NULL or both are slashes, we have an
    // error - return full path
    if (full_type == NULL_CHAR || (full_type == SLASH_CHAR && curr_type == SLASH_CHAR)) {
        strcpy(rel_path, up_full);
        goto end;
    }
 
    // If the current path has ended (last char is a NULL) and the full path's
    // last char is a slash, then just copy the remainder of the full path
    // (w/o the slash) to the relative path, and exit.
    if (curr_type == NULL_CHAR && full_type == SLASH_CHAR) {
        full_p++;   // skip slash
        strcpy(rel_path, full_p);
        goto end;
    }
 
    // If one of following holds:
    // 1) One of the last chars is a slash and the other is a plain char
    // 2) The current path has ended (last char is NULL) and the last char
    //    of the full path is a plain char
    // 3) The last char of both are plain chars and the previous char is not a
    //    slash
    // Then we must backtrack both pointers until the characters before them
    // are slashes. If there are no previous slashes, we have an error.
    if (    (full_type == SLASH_CHAR && curr_type == PLAIN_CHAR) ||
            (curr_type == SLASH_CHAR && full_type == PLAIN_CHAR) ||
            (curr_type == NULL_CHAR && full_type == PLAIN_CHAR) ||
            (curr_type == PLAIN_CHAR && full_type == PLAIN_CHAR &&
                *(full_p-1) != '/' && *(full_p-1) != '\\')  )
    {
        for (;
            full_p > up_full &&
                (   (*(full_p - 1) != '/' && *(full_p - 1) != '\\') ||
                    (*(curr_p - 1) != '/' && *(curr_p - 1) != '\\') );
            full_p--, curr_p--);
    }
 
    // If no shared prefix at this point (not even a drive letter) return the
    // full path
    if (full_p == up_full) {
        strcpy(rel_path, up_full);
        goto end;
    }
 
    // Scan all directories levels in current path from shared point to end -
    // for each one add a "../" to the relative path. Note that at this point
    // we know we have to add at least one.
    *rel_p++ = '.';
    *rel_p++ = '.';
    *rel_p++ = '\\';
    // Go over remaining current path, for each slash we find add one "../" to
    // the relative path
    for (; *curr_p; curr_p++) {
        if (*curr_p == '/' || *curr_p == '\\') {
            *rel_p++ = '.';
            *rel_p++ = '.';
            *rel_p++ = '\\';
        }
    }
 
    // If the last char of the current path is a slash remove a "../" from the
    // relative path.
    if (*(curr_p - 1) == '/' || *(curr_p - 1) == '\\') {
        rel_p -= 3;
    }
 
    // Copy remaining full path (from shared point to end) to relative path
    strcpy(rel_p, full_p);
 
end:
    free(up_curr);
    free(up_full);
}
 
bool Is_Full_Path(char * path)
{
    // first scan for a drive letter (scan for a colon)
    if (strchr(path,':') != NULL) {
        return true;
    }
 
    // now scan for a "network" path (starts with "//")
    if ((path[0] == '/') && (path[1] == '/')) {
        return true;
    }
    if ((path[0] == '\\') && (path[1] == '\\')) {
        return true;
    }
 
    return false;
}
 
 
/***********************************************************************************************
 * Is_Max_Tri_Mesh -- Is this node a triangle mesh?                                            *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   2/2/98     GTH : Created.                                                                 *
 *=============================================================================================*/
bool Is_Max_Tri_Mesh(INode * node) 
{
    Object *obj = node->EvalWorldState(0).obj;
    
    if (obj && obj->CanConvertToType(Class_ID(TRIOBJ_CLASS_ID, 0))) {
        return true;    
    }
    return false;
}
 
 
 
bool Is_Damage_Root(INode *node)
{
    if (node == NULL)
        return false;
 
    // Is the node's parent the scene root?
    INode *parent = node->GetParentNode();
    if (!parent || !parent->IsRootNode())
        return false;
 
    // Is the node's name in the form "damage.*"?
    char *name = node->GetName();
    if (strnicmp(name, "damage.", strlen("damage.")) != 0)
        return false;
 
/* This won't pick up references to a dummy object for some reason.
    // Does the node point to a dummy object?
    Object *obj = node->GetObjectRef();
    if (!obj || !obj->CanConvertToType(Class_ID(DUMMY_CLASS_ID, 0)))
        return false;
*/
 
    return true;
}
 
 
/***********************************************************************************************
 * Is_Origin -- checks if the node is the origin of a model                                    *
 *                                                                                             *
 *  A node is an origin if its parent is the scene root, it is a dummy object, and its name    *
 * is of the form "origin.*" (case insensitive). All descendants of the origin will be        *
 * expressed in coordinates relative to the origin object.                                     *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/13/99    AJA : Created.
 *=============================================================================================*/
bool Is_Origin(INode * node)
{
    if (!node) return false;
    if (node->IsRootNode()) return true;
    if (node->IsHidden()) return false;
 
    // Is the node's parent the scene root?
    INode *parent = node->GetParentNode();
    if (!parent || !parent->IsRootNode())
        return false;
 
    // Is the node's name in the form "origin.*"?
    char *name = node->GetName();
    if (strnicmp(name, "origin.", strlen("origin.")) != 0)
        return false;
 
/* This won't pick up references to a dummy object for some reason.
    // Does the node point to a dummy object?
    Object *obj = node->GetObjectRef();
    if (!obj || !obj->CanConvertToType(Class_ID(DUMMY_CLASS_ID, 0)))
        return false;
*/
 
    // This is an origin.
    return true;
}
 
 
/***********************************************************************************************
 * Is_Base_Origin -- Checks if the node is the origin for the base obect (non-LOD'd).          *
 *                                                                                             *
 * INPUT:                                                                                      *
 *                                                                                             *
 * OUTPUT:                                                                                     *
 *                                                                                             *
 * WARNINGS:                                                                                   *
 *                                                                                             *
 * HISTORY:                                                                                    *
 *   9/13/1999  AJA : Created.                                                                 *
 *=============================================================================================*/
bool Is_Base_Origin(INode * node)
{
    if (!node) return false;
 
    if (node->IsRootNode()) return true;
 
    if (!Is_Origin(node)) return false;
 
    // An origin is the base object origin if it's name is "origin." or
    // "origin.0" (a numeric value evaluating to zero as scanned by sscanf
    // which would include "origin.00" "origin.000", etc.).
    bool is_base_origin = false;
    char *name = node->GetName();
    if (stricmp(name, "origin.") == 0)
        is_base_origin = true;
    else if (strlen(name) > strlen("origin."))
    {
        // We know the first 7 characters are "origin." because that
        // was tested in Is_Origin(). Is it "origin.0"?
        int idx;
        if ((sscanf(name+strlen("origin."), "%d", &idx) == 1) && (idx == 0))
            is_base_origin = true;
    }
 
    return is_base_origin;
}
 
 
int Get_Lod_Level(INode *node)
{
    if (node->IsRootNode()) return 0;
    if (!Is_Origin(node)) return -1;
 
    char *name = node->GetName();
    char *dot = strrchr(name, '.');
    assert(dot);
    return atoi(dot+1);
}
 
int Get_Damage_State(INode *node)
{
    if (!Is_Damage_Root(node)) return -1;
 
    char *name = node->GetName();
    char *dot = strrchr(name, '.');
    assert(dot);
    return atoi(dot+1);
}
 
INode *Find_Named_Node(char *nodename, INode *root)
{
    if (!root || !nodename)
        return NULL;
 
    // Perform a breadth-first search of the tree for a node
    // of the given name.
    INode   *child = NULL;
    int i;
    char    cur_name[W3D_NAME_LEN];
 
    // Is this the node we're looking for?
    Set_W3D_Name(cur_name, root->GetName());
    if (strcmp(cur_name, nodename) == 0)
        return root;
 
    // Check the children against the given name.
    for (i = 0; i < root->NumChildren(); i++)
    {
        // Is it this child?
        child = root->GetChildNode(i);
        Set_W3D_Name(cur_name, child->GetName());
        if (strcmp(nodename, cur_name) == 0)
            return child;
    }
 
    // Wasn't any children. Check each child's descendants.
    for (i = 0; i < root->NumChildren(); i++)
    {
        child = root->GetChildNode(i);
        INode *found = Find_Named_Node(nodename, child);
        if (found)
            return found;
    }
 
    // Didn't find the node anywhere.
    return NULL;
}