nigger/CnC_Generals_Zero_Hour
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
CnC_Generals_Zero_Hour/GeneralsMD/Code/Tools/WW3D/max2w3d/w3dutil.cpp

2048 lines
63 KiB
C++
Raw Permalink Normal View History

Initial commit of Command & Conquer Generals and Command & Conquer Generals Zero Hour source code.
2025-02-27 17:34:39 +00:00
/*
** 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/w3dutil.cpp 45 8/21/01 10:28a Greg_h $ */
/***********************************************************************************************
*** Confidential - Westwood Studios ***
***********************************************************************************************
* *
* Project Name : Commando Tools - W3D export *
* *
* $Archive:: /Commando/Code/Tools/max2w3d/w3dutil.cpp $*
* *
* $Author:: Greg_h $*
* *
* $Modtime:: 8/21/01 9:41a $*
* *
* $Revision:: 45 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "w3dutil.h"
#include "w3ddesc.h"
#include "rcmenu.h"
#include "util.h"
#include "nodelist.h"
#include "tchar.h"
#include "gamemtl.h"
#include "notify.h"
#include "gennamesdialog.h"
#include "genmtlnamesdialog.h"
#include "genlodextensiondialog.h"
#include "floaterdialog.h"
#include <StdMat.h>
#define DAZZLE_SETTINGS_FILENAME "dazzle.ini"
#define DAZZLE_TYPES_SECTION "Dazzles_List"
#define DAZZLE_SECTION_BUFFERSIZE 32767
static BOOL CALLBACK _settings_form_dlg_proc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
static BOOL CALLBACK _w3d_utility_tools_dlg_proc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
static VisibleSelectedINodeFilter _INodeFilter;
/**********************************************************************************************
**
** MaterialReferenceMaker - Class to support Export Utilities in the W3D Tools panel.
**
**********************************************************************************************/
class MaterialReferenceMaker : public ReferenceMaker
{
public:
~MaterialReferenceMaker() {DeleteAllRefs();}
virtual int NumRefs();
virtual RefTargetHandle GetReference (int i);
virtual void SetReference (int i, RefTargetHandle rtarg);
RefResult NotifyRefChanged (Interval changeInt,RefTargetHandle hTarget,PartID& partID, RefMessage message);
Mtl *MaterialPtr;
static int ReferenceCount;
};
int MaterialReferenceMaker::NumRefs()
{
return (ReferenceCount);
}
RefTargetHandle MaterialReferenceMaker::GetReference (int i)
{
assert (i < ReferenceCount);
return (MaterialPtr);
}
void MaterialReferenceMaker::SetReference (int i, RefTargetHandle rtarg)
{
assert (i < ReferenceCount);
MaterialPtr = (Mtl*) rtarg;
}
RefResult MaterialReferenceMaker::NotifyRefChanged(Interval changeInt,RefTargetHandle hTarget,PartID& partID, RefMessage message)
{
return (REF_SUCCEED);
}
int MaterialReferenceMaker::ReferenceCount;
/**********************************************************************************************
**
** SettingsFormClass - code for the W3DUTILITY_SETTINGS_DIALOG. Used in the command panel
** and in the floating settings dialog.
**
**********************************************************************************************/
class SettingsFormClass
{
public:
SettingsFormClass(HWND hwnd);
~SettingsFormClass(void);
bool Dialog_Proc(HWND hWnd,UINT message,WPARAM wParam,LPARAM);
void Selection_Changed(void);
static void Update_All_Instances(void);
private:
void Init(void);
void Destroy(void);
void Disable_Controls(void);
void Update_Controls(INodeListClass * nodelist = NULL);
HWND Hwnd;
ISpinnerControl * RegionSpin;
SettingsFormClass * Next;
static SettingsFormClass * ActiveList;
};
/**********************************************************************************************
**
** W3DUtilityClass - Utility plugin which presents windows controls for setting all of
** the W3D export options for the currently selected nodes
**
**********************************************************************************************/
class W3DUtilityClass : public UtilityObj
{
public:
W3DUtilityClass();
~W3DUtilityClass();
void BeginEditParams(Interface *ip,IUtil *iu);
void EndEditParams(Interface *ip,IUtil *iu);
void SelectionSetChanged(Interface *ip,IUtil *iu);
void DeleteThis() {}
void Select_Hierarchy(void);
void Select_Geometry(void);
void Select_Alpha(void);
void Select_Physical(void);
void Select_Projectile(void);
void Select_Vis(void);
public:
Interface * InterfacePtr;
FloaterDialogClass SettingsFloater;
HWND SettingsPanelHWND;
HWND ToolsPanelHWND;
bool UpdateSpinnerValue;
GenNamesDialogClass::OptionsStruct NameOptions;
GenMtlNamesDialogClass::OptionsStruct MtlNameOptions;
GenLodExtensionDialogClass::OptionsStruct LodExtensionOptions;
int WorkingNameIndex;
enum {
NONE = 0,
HIDE,
SELECT_GEOM,
SELECT_HIER,
SELECT_ALPHA,
SELECT_PHYSICAL,
SELECT_PROJECTILE,
SELECT_VIS,
GENERATE_NAME,
GENERATE_MATERIAL_NAME,
GENERATE_LOD_EXTENSION
};
enum MaterialConversionEnum {
GAME_REFERENCE_COUNT,
GAME_TO_STANDARD,
STANDARD_TO_GAME
};
struct NodeStatesStruct
{
int ExportHierarchy;
int ExportGeometry;
int GeometryTwoSided;
int GeometryHidden;
int GeometryZNormals;
int GeometryVertexAlpha;
int GeometryCastShadow;
int GeometryShatterable;
int GeometryNPatch;
int CollisionPhysical;
int CollisionProjectile;
int CollisionVis;
int CollisionCamera;
int CollisionVehicle;
bool GeometryCameraAligned;
bool GeometryCameraOriented;
bool GeometryNormal;
bool GeometryAABox;
bool GeometryOBBox;
bool GeometryNull;
bool GeometryDazzle;
bool GeometryAggregate;
int DamageRegion;
int DazzleCount;
char DazzleType[128];
};
/*
** Evaluate the status of nodes in the given list
*/
static int eval_tri_state(int totalcount,int oncount);
static void eval_node_states(INodeListClass * node_list,NodeStatesStruct * ns);
/*
** Update the controls in any active settings panels
*/
static void update_settings_controls(INodeListClass * node_list = NULL);
/*
** Modify the state of all selected nodes
*/
static void set_hierarchy_in_all_selected(INodeListClass * list,bool onoff);
static void set_geometry_in_all_selected(INodeListClass * list,bool onoff);
static void enable_hidden_in_all_selected(INodeListClass * list,bool onoff);
static void enable_two_sided_in_all_selected(INodeListClass * list,bool onoff);
static void enable_znormals_in_all_selected(INodeListClass * list,bool onoff);
static void enable_vertex_alpha_in_all_selected(INodeListClass * list,bool onoff);
static void enable_shadow_in_all_selected(INodeListClass * list,bool onoff);
static void enable_shatterable_in_all_selected(INodeListClass * list,bool onoff);
static void enable_npatches_in_all_selected(INodeListClass * list,bool onoff);
static void enable_physical_collision_in_all_selected(INodeListClass * list,bool onoff);
static void enable_projectile_collision_in_all_selected(INodeListClass * list,bool onoff);
static void enable_vis_collision_in_all_selected(INodeListClass * list,bool onoff);
static void enable_camera_collision_in_all_selected(INodeListClass * list,bool onoff);
static void enable_vehicle_collision_in_all_selected(INodeListClass * list,bool onoff);
static void set_geometry_type_in_all_selected(INodeListClass * list,int geotype);
static void set_dazzle_type_in_all_selected(INodeListClass * list,char * dazzletype);
static void set_region_in_all_selected(INodeListClass * list,char region);
/*
** Functions used by the tools rollup in the command panel
*/
void descend_tree(INode * node,int action);
void hide_node(INode * node);
void select_geometry_node(INode * node);
void select_hierarchy_node(INode * node);
void select_alpha_node(INode * node);
void select_physical_node(INode * node);
void select_projectile_node(INode * node);
void select_vis_node(INode * node);
bool is_alpha_material(Mtl * nodemtl);
bool is_alpha_mesh(INode * node,Mtl * nodemtl);
void generate_names(void);
void generate_node_name(INode * node);
void generate_material_names(void);
void generate_material_names_for_node(INode * node);
void generate_material_names(Mtl * mtl);
void generate_lod_extensions(void);
void generate_lod_ext(INode * node);
void create_floater(void);
void export_with_standard_materials();
int convert_materials (MaterialConversionEnum conversion, MaterialReferenceMaker *gamenodematerials);
StdMat * new_standard_material (GameMtl *gamemtl);
static W3DAppData0Struct * get_app_data_0(INode * node);
static W3DAppData1Struct * get_app_data_1(INode * node);
static W3DAppData2Struct * get_app_data_2(INode * node);
static W3DDazzleAppDataStruct * get_dazzle_app_data(INode * node);
};
static W3DUtilityClass TheW3DUtility;
/**********************************************************************************************
**
** W3DUtilityClassDesc - Class Descriptor for the W3D Utility
**
**********************************************************************************************/
class W3DUtilityClassDesc:public ClassDesc
{
public:
int IsPublic() { return 1; }
void * Create(BOOL loading = FALSE) { return &TheW3DUtility; }
const TCHAR * ClassName() { return Get_String(IDS_W3D_UTILITY_CLASS_NAME); }
SClass_ID SuperClassID() { return UTILITY_CLASS_ID; }
Class_ID ClassID() { return W3DUtilityClassID; }
const TCHAR* Category() { return Get_String(IDS_W3DMENU_CATEGORY); }
};
static W3DUtilityClassDesc W3DUtilityDesc;
ClassDesc * Get_W3D_Utility_Desc(void)
{
return &W3DUtilityDesc;
}
/**********************************************************************************************
**
** W3DUtilityClass Implementation
**
**********************************************************************************************/
W3DUtilityClass::W3DUtilityClass(void)
{
InterfacePtr = NULL;
SettingsPanelHWND = NULL;
ToolsPanelHWND = NULL;
UpdateSpinnerValue = true;
}
W3DUtilityClass::~W3DUtilityClass(void)
{
}
void W3DUtilityClass::BeginEditParams(Interface *ip,IUtil *iu)
{
InterfacePtr = ip;
SettingsPanelHWND = InterfacePtr->AddRollupPage(
AppInstance,
MAKEINTRESOURCE(IDD_W3DUTILITY_SETTINGS_DIALOG),
_settings_form_dlg_proc,
Get_String(IDS_W3DUTILITY_SETTINGS),
0);
ToolsPanelHWND = InterfacePtr->AddRollupPage(
AppInstance,
MAKEINTRESOURCE(IDD_W3DUTILITY_TOOLS_DIALOG),
_w3d_utility_tools_dlg_proc,
Get_String(IDS_W3DUTILITY_TOOLS),
0);
// TheRCMenu.Bind(TheW3DUtility.InterfacePtr,&TheW3DUtility);
// RightClickMenuManager *rcm = ip->GetRightClickMenuManager();
// if (TheRCMenu.Installed!=TRUE) {
// rcm->Register(&TheRCMenu);
// }
SettingsFormClass::Update_All_Instances();
}
void W3DUtilityClass::EndEditParams(Interface *ip,IUtil *iu)
{
InterfacePtr = NULL;
ip->DeleteRollupPage(SettingsPanelHWND);
ip->DeleteRollupPage(ToolsPanelHWND);
SettingsPanelHWND = NULL;
ToolsPanelHWND = NULL;
}
void W3DUtilityClass::SelectionSetChanged(Interface *ip,IUtil *iu)
{
// (gth) the settings panels which need to respond to the selection set changing
// are now registered directly with MAX and don't need to be updated here
// update_dialog();
}
int W3DUtilityClass::eval_tri_state(int totalcount,int oncount)
{
if (oncount == 0) {
return 0;
}
if (oncount == totalcount) {
return 1;
}
return 2;
}
void W3DUtilityClass::eval_node_states(INodeListClass * list,NodeStatesStruct * ns)
{
// initialize the counters and booleans
ns->ExportHierarchy = 0;
ns->ExportGeometry = 0;
ns->GeometryHidden = 0;
ns->GeometryTwoSided = 0;
ns->GeometryZNormals = 0;
ns->GeometryVertexAlpha = 0;
ns->GeometryCastShadow = 0;
ns->GeometryShatterable = 0;
ns->GeometryNPatch = 0;
ns->CollisionPhysical = 0;
ns->CollisionProjectile = 0;
ns->CollisionVis = 0;
ns->CollisionCamera = 0;
ns->CollisionVehicle = 0;
ns->GeometryCameraAligned = false;
ns->GeometryCameraOriented = false;
ns->GeometryNormal = false;
ns->GeometryAABox = false;
ns->GeometryOBBox = false;
ns->GeometryNull = false;
ns->GeometryDazzle = false;
ns->GeometryAggregate = false;
/*
** ns->DamageRegion will be MAX_DAMAGE_REGIONS if not all
** of the selected nodes are in the same damage region. If
** they are, then ns->DamageRegion will be the region they
** share.
*/
if (list->Num_Nodes() > 0)
{
// Use the first damage region for comparing to the others.
W3DAppData1Struct *wdata = get_app_data_1((*list)[0]);
ns->DamageRegion = wdata->DamageRegion;
}
else
ns->DamageRegion = MAX_DAMAGE_REGIONS;
/*
** ns->DazzleType will be DEFAULT if not all of the selected
** nodes are the same. If they are the same, it will be the
** dazzle type that they all share
*/
ns->DazzleCount = 0;
if (list->Num_Nodes() > 0) {
W3DDazzleAppDataStruct * dazzledata = get_dazzle_app_data((*list)[0]);
strncpy(ns->DazzleType,dazzledata->DazzleType,sizeof(ns->DazzleType));
} else {
strcpy(ns->DazzleType,"DEFAULT");
}
/*
** evaluate each node
*/
for (unsigned int ni=0; ni<list->Num_Nodes(); ni++) {
W3DAppData2Struct * wdata = get_app_data_2((*list)[ni]);
assert(wdata);
ns->ExportHierarchy += (wdata->Is_Bone() ? 1 : 0);
ns->ExportGeometry += (wdata->Is_Geometry() ? 1 : 0);
ns->GeometryHidden += (wdata->Is_Hidden_Enabled() ? 1 : 0);
ns->GeometryTwoSided += (wdata->Is_Two_Sided_Enabled() ? 1 : 0);
ns->GeometryZNormals += (wdata->Is_ZNormals_Enabled() ? 1 : 0);
ns->GeometryVertexAlpha += (wdata->Is_Vertex_Alpha_Enabled() ? 1 : 0);
ns->GeometryCastShadow += (wdata->Is_Shadow_Enabled() ? 1 : 0);
ns->GeometryShatterable += (wdata->Is_Shatterable_Enabled() ? 1 : 0);
ns->GeometryNPatch += (wdata->Is_NPatchable_Enabled() ? 1 : 0);
ns->CollisionPhysical += (wdata->Is_Physical_Collision_Enabled() ? 1 : 0);
ns->CollisionProjectile += (wdata->Is_Projectile_Collision_Enabled() ? 1 : 0);
ns->CollisionVis += (wdata->Is_Vis_Collision_Enabled() ? 1 : 0);
ns->CollisionCamera += (wdata->Is_Camera_Collision_Enabled() ? 1 : 0);
ns->CollisionVehicle += (wdata->Is_Vehicle_Collision_Enabled() ? 1 : 0);
switch (wdata->Get_Geometry_Type()) {
case W3DAppData2Struct::GEO_TYPE_CAMERA_ALIGNED: ns->GeometryCameraAligned = true; break;
case W3DAppData2Struct::GEO_TYPE_CAMERA_ORIENTED: ns->GeometryCameraOriented = true; break;
case W3DAppData2Struct::GEO_TYPE_NORMAL_MESH: ns->GeometryNormal = true; break;
case W3DAppData2Struct::GEO_TYPE_AABOX: ns->GeometryAABox = true; break;
case W3DAppData2Struct::GEO_TYPE_OBBOX: ns->GeometryOBBox = true; break;
case W3DAppData2Struct::GEO_TYPE_NULL: ns->GeometryNull = true; break;
case W3DAppData2Struct::GEO_TYPE_DAZZLE: ns->GeometryDazzle = true; ns->DazzleCount++; break;
case W3DAppData2Struct::GEO_TYPE_AGGREGATE: ns->GeometryAggregate = true; break;
}
// Compare this damage region to our existing one. If it's not the same,
// use MAX_DAMAGE_REGION (an invalid value) as a sentinel value.
if (ns->DamageRegion != MAX_DAMAGE_REGIONS)
{
W3DAppData1Struct *wdata1 = get_app_data_1((*list)[ni]);
assert(wdata1);
if (wdata1->DamageRegion != ns->DamageRegion)
ns->DamageRegion = MAX_DAMAGE_REGIONS;
}
// compare this objects dazzle type to our existing one. If its not
// the same, use 'DEFAULT'.
W3DDazzleAppDataStruct * dazzledata = get_dazzle_app_data((*list)[ni]);
if (strcmp(ns->DazzleType,dazzledata->DazzleType) != 0) {
strcpy(ns->DazzleType,"DEFAULT");
}
}
// If any of the counters are zero, that means none of the objects had that
// bit set. If any of them are equal to the number of objects, then they
// all had that bit set. Otherwise, there was a mix and we should use the
// third state for the checkbox (greyed out check).
int count = list->Num_Nodes();
ns->ExportHierarchy = eval_tri_state(count, ns->ExportHierarchy);
ns->ExportGeometry = eval_tri_state(count, ns->ExportGeometry);
ns->GeometryHidden = eval_tri_state(count, ns->GeometryHidden);
ns->GeometryTwoSided = eval_tri_state(count, ns->GeometryTwoSided);
ns->GeometryZNormals = eval_tri_state(count, ns->GeometryZNormals);
ns->GeometryVertexAlpha = eval_tri_state(count, ns->GeometryVertexAlpha);
ns->GeometryCastShadow = eval_tri_state(count, ns->GeometryCastShadow);
ns->GeometryShatterable = eval_tri_state(count, ns->GeometryShatterable);
ns->GeometryNPatch = eval_tri_state(count, ns->GeometryNPatch);
ns->CollisionPhysical = eval_tri_state(count, ns->CollisionPhysical);
ns->CollisionProjectile = eval_tri_state(count, ns->CollisionProjectile);
ns->CollisionVis = eval_tri_state(count, ns->CollisionVis);
ns->CollisionCamera = eval_tri_state(count, ns->CollisionCamera);
ns->CollisionVehicle = eval_tri_state(count, ns->CollisionVehicle);
}
void W3DUtilityClass::update_settings_controls(INodeListClass * node_list)
{
SettingsFormClass::Update_All_Instances();
}
void W3DUtilityClass::set_hierarchy_in_all_selected(INodeListClass * node_list,bool onoff)
{
for (unsigned int ni=0; ni<node_list->Num_Nodes(); ni++) {
W3DAppData2Struct * wdata = get_app_data_2((*node_list)[ni]);
wdata->Enable_Export_Transform(onoff);
}
update_settings_controls(node_list);
}
void W3DUtilityClass::set_geometry_in_all_selected(INodeListClass * node_list,bool onoff)
{
for (unsigned int ni=0; ni<node_list->Num_Nodes(); ni++) {
W3DAppData2Struct * wdata = get_app_data_2((*node_list)[ni]);
wdata->Enable_Export_Geometry(onoff);
}
update_settings_controls(node_list);
}
void W3DUtilityClass::enable_hidden_in_all_selected(INodeListClass * node_list,bool onoff)
{
for (unsigned int ni=0; ni<node_list->Num_Nodes(); ni++) {
W3DAppData2Struct * wdata = get_app_data_2((*node_list)[ni]);
wdata->Enable_Hidden(onoff);
}
update_settings_controls(node_list);
}
void W3DUtilityClass::enable_two_sided_in_all_selected(INodeListClass * node_list,bool onoff)
{
for (unsigned int ni=0; ni<node_list->Num_Nodes(); ni++) {
W3DAppData2Struct * wdata = get_app_data_2((*node_list)[ni]);
wdata->Enable_Two_Sided(onoff);
}
update_settings_controls(node_list);
}
void W3DUtilityClass::enable_znormals_in_all_selected(INodeListClass * node_list,bool onoff)
{
for (unsigned int ni=0; ni<node_list->Num_Nodes(); ni++) {
W3DAppData2Struct * wdata = get_app_data_2((*node_list)[ni]);
wdata->Enable_ZNormals(onoff);
}
update_settings_controls(node_list);
}
void W3DUtilityClass::enable_vertex_alpha_in_all_selected(INodeListClass * node_list,bool onoff)
{
for (unsigned int ni=0; ni<node_list->Num_Nodes(); ni++) {
W3DAppData2Struct * wdata = get_app_data_2((*node_list)[ni]);
wdata->Enable_Vertex_Alpha(onoff);
}
update_settings_controls(node_list);
}
void W3DUtilityClass::enable_shadow_in_all_selected(INodeListClass * node_list,bool onoff)
{
for (unsigned int ni=0; ni<node_list->Num_Nodes(); ni++) {
W3DAppData2Struct * wdata = get_app_data_2((*node_list)[ni]);
wdata->Enable_Shadow(onoff);
}
update_settings_controls(node_list);
}
void W3DUtilityClass::enable_shatterable_in_all_selected(INodeListClass * node_list,bool onoff)
{
for (unsigned int ni=0; ni<node_list->Num_Nodes(); ni++) {
W3DAppData2Struct * wdata = get_app_data_2((*node_list)[ni]);
wdata->Enable_Shatterable(onoff);
}
update_settings_controls(node_list);
}
void W3DUtilityClass::enable_npatches_in_all_selected(INodeListClass * node_list,bool onoff)
{
for (unsigned int ni=0; ni<node_list->Num_Nodes(); ni++) {
W3DAppData2Struct * wdata = get_app_data_2((*node_list)[ni]);
wdata->Enable_NPatchable(onoff);
}
update_settings_controls(node_list);
}
void W3DUtilityClass::enable_physical_collision_in_all_selected(INodeListClass * node_list,bool onoff)
{
for (unsigned int ni=0; ni<node_list->Num_Nodes(); ni++) {
W3DAppData2Struct * wdata = get_app_data_2((*node_list)[ni]);
wdata->Enable_Physical_Collision(onoff);
}
update_settings_controls(node_list);
}
void W3DUtilityClass::enable_projectile_collision_in_all_selected(INodeListClass * node_list,bool onoff)
{
for (unsigned int ni=0; ni<node_list->Num_Nodes(); ni++) {
W3DAppData2Struct * wdata = get_app_data_2((*node_list)[ni]);
wdata->Enable_Projectile_Collision(onoff);
}
update_settings_controls(node_list);
}
void W3DUtilityClass::enable_vis_collision_in_all_selected(INodeListClass * node_list,bool onoff)
{
for (unsigned int ni=0; ni<node_list->Num_Nodes(); ni++) {
W3DAppData2Struct * wdata = get_app_data_2((*node_list)[ni]);
wdata->Enable_Vis_Collision(onoff);
}
update_settings_controls(node_list);
}
void W3DUtilityClass::enable_camera_collision_in_all_selected(INodeListClass * node_list,bool onoff)
{
for (unsigned int ni=0; ni<node_list->Num_Nodes(); ni++) {
W3DAppData2Struct * wdata = get_app_data_2((*node_list)[ni]);
wdata->Enable_Camera_Collision(onoff);
}
update_settings_controls(node_list);
}
void W3DUtilityClass::enable_vehicle_collision_in_all_selected(INodeListClass * node_list,bool onoff)
{
for (unsigned int ni=0; ni<node_list->Num_Nodes(); ni++) {
W3DAppData2Struct * wdata = get_app_data_2((*node_list)[ni]);
wdata->Enable_Vehicle_Collision(onoff);
}
update_settings_controls(node_list);
}
void W3DUtilityClass::set_geometry_type_in_all_selected(INodeListClass * node_list,int geotype)
{
for (unsigned int ni=0; ni<node_list->Num_Nodes(); ni++) {
W3DAppData2Struct * wdata = get_app_data_2((*node_list)[ni]);
wdata->Set_Geometry_Type((W3DAppData2Struct::GeometryTypeEnum)geotype);
}
update_settings_controls(node_list);
}
void W3DUtilityClass::set_dazzle_type_in_all_selected(INodeListClass * node_list,char * dazzle_type)
{
for (unsigned int ni=0; ni<node_list->Num_Nodes(); ni++) {
W3DDazzleAppDataStruct * dazzledata = get_dazzle_app_data((*node_list)[ni]);
strncpy(dazzledata->DazzleType,dazzle_type,sizeof(dazzledata->DazzleType) - 1);
}
update_settings_controls(node_list);
}
void W3DUtilityClass::set_region_in_all_selected(INodeListClass * list,char region)
{
if (list->Num_Nodes() == 0) return;
// Damage regions are stored in each node's AppData1.
for (int i = 0; i < list->Num_Nodes(); i++)
{
W3DAppData1Struct *wdata = get_app_data_1((*list)[i]);
wdata->DamageRegion = region;
}
update_settings_controls(list);
}
void W3DUtilityClass::generate_names(void)
{
GenNamesDialogClass dialog(InterfacePtr);
bool retval = dialog.Get_Options(&NameOptions);
WorkingNameIndex = NameOptions.NameIndex;
if (retval) {
descend_tree(InterfacePtr->GetRootNode(),GENERATE_NAME);
}
}
void W3DUtilityClass::generate_material_names(void)
{
GenMtlNamesDialogClass dialog(InterfacePtr);
bool retval = dialog.Get_Options(&MtlNameOptions);
WorkingNameIndex = MtlNameOptions.NameIndex;
if (retval) {
descend_tree(InterfacePtr->GetRootNode(),GENERATE_MATERIAL_NAME);
}
}
void W3DUtilityClass::generate_lod_extensions(void)
{
GenLodExtensionDialogClass dialog(InterfacePtr);
bool retval = dialog.Get_Options(&LodExtensionOptions);
if (retval) {
descend_tree(InterfacePtr->GetRootNode(),GENERATE_LOD_EXTENSION);
}
}
void W3DUtilityClass::generate_lod_ext(INode * node)
{
/*
** Only works on selected nodes.
*/
if (!node->Selected())
return;
/*
** If this node already has an LOD extension, we'll replace it
** with the new LOD index. Otherwise we'll tack it on the end.
** Display a error message if the name is too long to append
** the extension, and skip the node without changing the name.
*/
char msg[256];
char newname[W3D_NAME_LEN];
char *oldname = node->GetName();
char *ext = strrchr(oldname, '.');
int old_lod;
if ( (ext != NULL) && (sscanf(ext, ".%d", &old_lod) == 1) )
{
/*
** An existing LOD index. If it's different than the new
** one, replace it.
*/
if (old_lod == LodExtensionOptions.LodIndex)
return; // same lod index
/*
** Room for the new extension? (2 because when we export, the extension will,
** be replaced by a single character [A..Z] to indicate the LOD level.
** ie. 2==strlen("A")+1)
*/
if (ext - oldname + 2 <= W3D_NAME_LEN)
{
*ext = '\0';
sprintf(newname, "%s.%02d", oldname, LodExtensionOptions.LodIndex);
*ext = '.';
node->SetName(newname);
}
else
{
*ext = '\0';
sprintf(msg, "The maximum W3D object name is %d characters. Adding the LOD "
"extension to \"%s\" will pass this limit! Please shorten its name.",
W3D_NAME_LEN - 1, oldname);
*ext = '.';
MessageBox(NULL, msg, "Error", MB_OK);
}
}
else
{
/*
** Room for the new extension? (2 because when we export, the extension will,
** be replaced by a single character [A..Z] to indicate the LOD level.
** ie. 2==strlen("A")+1)
*/
if (strlen(oldname) + 2 <= W3D_NAME_LEN)
{
sprintf(newname, "%s.%02d", oldname, LodExtensionOptions.LodIndex);
node->SetName(newname);
}
else
{
sprintf(msg, "The maximum W3D object name is %d characters. Adding the LOD "
"extension to \"%s\" will pass this limit! Please shorten its name.",
W3D_NAME_LEN - 1, oldname);
MessageBox(NULL, msg, "Error", MB_OK);
}
}
}
void W3DUtilityClass::create_floater(void)
{
SettingsFloater.Create(InterfacePtr,IDD_W3DUTILITY_SETTINGS_DIALOG,_settings_form_dlg_proc);
SettingsFormClass::Update_All_Instances();
}
void W3DUtilityClass::export_with_standard_materials()
{
char *convertingmessage = "Converting materials...";
// Count the no. of references to game materials.
MaterialReferenceMaker::ReferenceCount = convert_materials (GAME_REFERENCE_COUNT, NULL);
MaterialReferenceMaker *gamenodematerials = NULL;
if (MaterialReferenceMaker::ReferenceCount > 0) {
gamenodematerials = new MaterialReferenceMaker [MaterialReferenceMaker::ReferenceCount];
assert (gamenodematerials != NULL);
}
InterfacePtr->PushPrompt (convertingmessage);
SetCursor (LoadCursor (NULL, IDC_WAIT));
convert_materials (GAME_TO_STANDARD, gamenodematerials);
InterfacePtr->PopPrompt();
InterfacePtr->FileExport();
UpdateWindow (InterfacePtr->GetMAXHWnd());
InterfacePtr->PushPrompt (convertingmessage);
SetCursor (LoadCursor (NULL, IDC_WAIT));
convert_materials (STANDARD_TO_GAME, gamenodematerials);
InterfacePtr->PopPrompt();
// Clean-up.
if (gamenodematerials != NULL) delete [] gamenodematerials;
}
int W3DUtilityClass::convert_materials (MaterialConversionEnum conversion, MaterialReferenceMaker *gamenodematerials)
{
int gamenodematerialindex = 0;
INode *rootnode = InterfacePtr->GetRootNode();
if (rootnode != NULL) {
INodeListClass *meshlist = new INodeListClass (rootnode, 0);
if (meshlist != NULL) {
for (unsigned nodeindex = 0; nodeindex < meshlist->Num_Nodes(); nodeindex++) {
Mtl *nodemtl = ((*meshlist) [nodeindex])->GetMtl();
// Is this a non-null material?
if (nodemtl != NULL) {
// Is this not a multi-material?
if (!nodemtl->IsMultiMtl()) {
switch (conversion) {
case GAME_REFERENCE_COUNT:
if (nodemtl->ClassID() == GameMaterialClassID) {
assert (((GameMtl*) nodemtl)->Substitute_Material() == NULL);
}
break;
case GAME_TO_STANDARD:
if (nodemtl->ClassID() == GameMaterialClassID) {
// Make a reference to the game material to ensure that it is not deleted by the system.
gamenodematerials [gamenodematerialindex].MakeRefByID (FOREVER, gamenodematerialindex, nodemtl);
// Does this material already have an equivalent standard material?
if (((GameMtl*) nodemtl)->Substitute_Material() == NULL) {
((GameMtl*) nodemtl)->Set_Substitute_Material (new_standard_material ((GameMtl*) nodemtl));
}
((*meshlist) [nodeindex])->SetMtl (((GameMtl*) nodemtl)->Substitute_Material());
} else {
gamenodematerials [gamenodematerialindex].MaterialPtr = NULL;
}
break;
case STANDARD_TO_GAME:
// Change materials to game materials if they were previously game materials before being
// converted to standard materials.
if (gamenodematerials [gamenodematerialindex].MaterialPtr != NULL) {
((*meshlist) [nodeindex])->SetMtl (gamenodematerials [gamenodematerialindex].MaterialPtr);
((GameMtl*) gamenodematerials [gamenodematerialindex].MaterialPtr)->Set_Substitute_Material (NULL);
}
break;
}
gamenodematerialindex++;
} else {
// For each sub-material...
for (int materialindex = 0; materialindex < nodemtl->NumSubMtls(); materialindex++) {
Mtl *submaterial = nodemtl->GetSubMtl (materialindex);
// Is this a non-null submaterial?
if (submaterial != NULL) {
switch (conversion) {
case GAME_REFERENCE_COUNT:
if (submaterial->ClassID() == GameMaterialClassID) {
assert (((GameMtl*) submaterial)->Substitute_Material() == NULL);
}
break;
case GAME_TO_STANDARD:
if (submaterial->ClassID() == GameMaterialClassID) {
// Make a reference to the game material to ensure that it is not deleted by the system.
gamenodematerials [gamenodematerialindex].MakeRefByID (FOREVER, gamenodematerialindex, submaterial);
// Does this material already have an equivalent standard material?
if (((GameMtl*) submaterial)->Substitute_Material() == NULL) {
((GameMtl*) submaterial)->Set_Substitute_Material (new_standard_material ((GameMtl*) submaterial));
}
nodemtl->SetSubMtl (materialindex, ((GameMtl*) submaterial)->Substitute_Material());
} else {
gamenodematerials [gamenodematerialindex].MaterialPtr = NULL;
}
break;
case STANDARD_TO_GAME:
// Change materials to game materials if they were previously game materials before being
// converted to standard materials.
if (gamenodematerials [gamenodematerialindex].MaterialPtr != NULL) {
nodemtl->SetSubMtl (materialindex, gamenodematerials [gamenodematerialindex].MaterialPtr);
((GameMtl*) gamenodematerials [gamenodematerialindex].MaterialPtr)->Set_Substitute_Material (NULL);
}
break;
}
gamenodematerialindex++;
}
}
}
}
}
// Clean-up.
delete meshlist;
}
}
return (gamenodematerialindex);
}
StdMat *W3DUtilityClass::new_standard_material (GameMtl *gamemtl)
{
Color emissive;
// Create a new standard material.
StdMat *stdmtl = NewDefaultStdMat();
// Set its properties by translating the supplied game material.
// NOTE 0: Only consider pass 0 in the game material - ignore all other passes.
// NOTE 1: Use defaults for all standard material attributes that cannot be
// converted from the game material in a meaningful way.
stdmtl->SetName (gamemtl->GetName());
stdmtl->SetAmbient (gamemtl->GetAmbient(), 0);
stdmtl->SetDiffuse (gamemtl->GetDiffuse(), 0);
stdmtl->SetSpecular (gamemtl->GetSpecular(), 0);
stdmtl->SetOpacity (gamemtl->Get_Opacity (0, 0), 0);
stdmtl->SetShininess (gamemtl->Get_Shininess (0, 0), 0);
stdmtl->SetShinStr (gamemtl->GetShinStr(), 0);
stdmtl->SetSubTexmap (ID_DI, gamemtl->Get_Texture (0, 0));
emissive = gamemtl->Get_Emissive (0, 0);
stdmtl->SetSelfIllum ((emissive.r + emissive.g + emissive.b) / 3.0f, 0);
return (stdmtl);
}
void W3DUtilityClass::Select_Hierarchy(void)
{
InterfacePtr->SelectNode(NULL);
INode * root = InterfacePtr->GetRootNode();
descend_tree(root,SELECT_HIER);
InterfacePtr->ForceCompleteRedraw();
}
void W3DUtilityClass::Select_Geometry(void)
{
InterfacePtr->SelectNode(NULL);
INode * root = InterfacePtr->GetRootNode();
descend_tree(root,SELECT_GEOM);
InterfacePtr->ForceCompleteRedraw();
}
void W3DUtilityClass::Select_Alpha(void)
{
InterfacePtr->SelectNode(NULL);
INode * root = InterfacePtr->GetRootNode();
descend_tree(root,SELECT_ALPHA);
InterfacePtr->ForceCompleteRedraw();
}
void W3DUtilityClass::Select_Physical(void)
{
InterfacePtr->SelectNode(NULL);
INode * root = InterfacePtr->GetRootNode();
descend_tree(root,SELECT_PHYSICAL);
InterfacePtr->ForceCompleteRedraw();
}
void W3DUtilityClass::Select_Projectile(void)
{
InterfacePtr->SelectNode(NULL);
INode * root = InterfacePtr->GetRootNode();
descend_tree(root,SELECT_PROJECTILE);
InterfacePtr->ForceCompleteRedraw();
}
void W3DUtilityClass::Select_Vis(void)
{
InterfacePtr->SelectNode(NULL);
INode * root = InterfacePtr->GetRootNode();
descend_tree(root,SELECT_VIS);
InterfacePtr->ForceCompleteRedraw();
}
void W3DUtilityClass::descend_tree(INode * node,int func)
{
if (!node) return;
switch (func)
{
case HIDE:
hide_node(node);
break;
case SELECT_GEOM:
select_geometry_node(node);
break;
case SELECT_HIER:
select_hierarchy_node(node);
break;
case SELECT_ALPHA:
select_alpha_node(node);
break;
case SELECT_PHYSICAL:
select_physical_node(node);
break;
case SELECT_PROJECTILE:
select_projectile_node(node);
break;
case SELECT_VIS:
select_vis_node(node);
break;
case GENERATE_NAME:
generate_node_name(node);
break;
case GENERATE_MATERIAL_NAME:
generate_material_names_for_node(node);
break;
case GENERATE_LOD_EXTENSION:
generate_lod_ext(node);
break;
default:
break;
};
for (int i=0; i<node->NumberOfChildren(); i++) {
INode * child = node->GetChildNode(i);
descend_tree(child,func);
}
}
void W3DUtilityClass::hide_node(INode * node)
{
if (!node->IsHidden()) node->Hide(TRUE);
InterfacePtr->NodeInvalidateRect(node);
}
void W3DUtilityClass::select_geometry_node(INode * node)
{
if (Is_Geometry(node) && !node->IsHidden()) {
InterfacePtr->SelectNode(node,0);
}
}
void W3DUtilityClass::select_hierarchy_node(INode * node)
{
if (Is_Bone(node) && !node->IsHidden()) {
InterfacePtr->SelectNode(node,0);
}
}
void W3DUtilityClass::select_alpha_node(INode * node)
{
if (node->IsHidden() || !Is_Geometry(node)) {
return;
}
Mtl * nodemtl = node->GetMtl();
if (is_alpha_material(nodemtl)) {
if (is_alpha_mesh(node,nodemtl)) {
InterfacePtr->SelectNode(node,0);
}
}
}
void W3DUtilityClass::select_physical_node(INode * node)
{
if (!node->IsHidden() && Is_Geometry(node) && Is_Physical_Collision(node)) {
InterfacePtr->SelectNode(node,0);
}
}
void W3DUtilityClass::select_projectile_node(INode * node)
{
if (!node->IsHidden() && Is_Geometry(node) && Is_Projectile_Collision(node)) {
InterfacePtr->SelectNode(node,0);
}
}
void W3DUtilityClass::select_vis_node(INode * node)
{
if (!node->IsHidden() && Is_Geometry(node) && Is_Vis_Collision(node)) {
InterfacePtr->SelectNode(node,0);
}
}
bool W3DUtilityClass::is_alpha_material(Mtl * nodemtl)
{
if (nodemtl == NULL) {
return false;
}
bool is_alpha = false;
if (nodemtl->IsMultiMtl()) {
for (int mi=0; mi<nodemtl->NumSubMtls(); mi++) {
is_alpha |= is_alpha_material(nodemtl->GetSubMtl(mi));
}
} else {
if (nodemtl->ClassID() == GameMaterialClassID) {
GameMtl * gamemtl = (GameMtl *)nodemtl;
if ( (gamemtl->Get_Dest_Blend(0) == W3DSHADER_DESTBLENDFUNC_SRC_ALPHA) ||
(gamemtl->Get_Dest_Blend(0) == W3DSHADER_DESTBLENDFUNC_ONE_MINUS_SRC_ALPHA) ||
(gamemtl->Get_Src_Blend(0) == W3DSHADER_SRCBLENDFUNC_SRC_ALPHA) ||
(gamemtl->Get_Src_Blend(0) == W3DSHADER_SRCBLENDFUNC_ONE_MINUS_SRC_ALPHA) ||
(gamemtl->Get_Alpha_Test(0) == W3DSHADER_ALPHATEST_ENABLE) )
{
is_alpha = true;
}
}
}
return is_alpha;
}
bool W3DUtilityClass::is_alpha_mesh(INode * node,Mtl * nodemtl)
{
Object * obj = node->EvalWorldState(0).obj;
TriObject * tri = (TriObject *)obj->ConvertToType(0, triObjectClassID);
if (tri != NULL) {
Mesh & mesh = tri->mesh;
int face_index;
int mat_index;
if (nodemtl == NULL) {
return false;
} else if (nodemtl->NumSubMtls() <= 1) {
return is_alpha_material(nodemtl);
} else {
int sub_mtl_count = nodemtl->NumSubMtls();
bool * sub_mtl_flags = new bool[sub_mtl_count];
// Initialize each sub-material flag to false (indicates that the material is un-used)
for (mat_index=0; mat_index<sub_mtl_count; mat_index++) {
sub_mtl_flags[mat_index] = false;
}
// Set a true for each material actually referenced by the mesh
for (face_index=0; face_index<mesh.getNumFaces(); face_index++) {
int max_mat_index = mesh.faces[face_index].getMatID();
int mat_index = (max_mat_index % sub_mtl_count);
sub_mtl_flags[mat_index] = true;
}
// Loop over the used materials and return true if any are alpha materials
for (mat_index=0; mat_index<sub_mtl_count; mat_index++) {
if (sub_mtl_flags[mat_index]) {
if (is_alpha_material(nodemtl->GetSubMtl(mat_index))) {
return true;
}
}
}
}
}
return false;
}
void W3DUtilityClass::generate_node_name(INode * node)
{
TCHAR temp_string[256];
if (NameOptions.OnlyAffectSelected && !node->Selected()) {
return;
}
if (!Is_Bone(node) && !Is_Geometry(node)) {
return;
}
if (NameOptions.AssignNames) {
_stprintf(temp_string,"%s%03d",NameOptions.RootName,WorkingNameIndex);
node->SetName(temp_string);
WorkingNameIndex++;
}
if (NameOptions.AssignPrefix) {
_stprintf(temp_string,"%s%s",NameOptions.PrefixName,node->GetName());
node->SetName(temp_string);
}
if (NameOptions.AssignSuffix) {
_stprintf(temp_string,"%s%s",node->GetName(),NameOptions.SuffixName);
node->SetName(temp_string);
}
if (NameOptions.AssignCollisionBits) {
W3DAppData2Struct * wdata = W3DAppData2Struct::Get_App_Data(node);
assert(wdata);
wdata->Enable_Physical_Collision(NameOptions.PhysicalCollision);
wdata->Enable_Projectile_Collision(NameOptions.ProjectileCollision);
wdata->Enable_Vis_Collision(NameOptions.VisCollision);
wdata->Enable_Camera_Collision(NameOptions.CameraCollision);
wdata->Enable_Vehicle_Collision(NameOptions.VehicleCollision);
}
}
void W3DUtilityClass::generate_material_names_for_node(INode * node)
{
if (MtlNameOptions.OnlyAffectSelected && !node->Selected()) {
return;
}
generate_material_names(node->GetMtl());
}
void W3DUtilityClass::generate_material_names(Mtl * mtl)
{
if (mtl == NULL) {
return;
}
// set the name of this material and increment the index
TCHAR newname[GenMtlNamesDialogClass::MAX_MATERIAL_NAME_LEN];
_stprintf(newname,"%s%03d",MtlNameOptions.RootName,WorkingNameIndex);
mtl->SetName(newname);
WorkingNameIndex++;
// recurse into children
if (mtl->IsMultiMtl()) {
for (int mi=0; mi<mtl->NumSubMtls(); mi++) {
generate_material_names(mtl->GetSubMtl(mi));
}
}
}
W3DAppData0Struct * W3DUtilityClass::get_app_data_0(INode * node)
{
/*
** Try to get our AppData which has the export flags
*/
W3DAppData0Struct * wdata = NULL;
AppDataChunk * appdata = node->GetAppDataChunk(W3DUtilityClassID,UTILITY_CLASS_ID,0);
/*
** If there wasn't one, return NULL since this app data chunk is obsolete now.
** If there was one, get the data from it
*/
if (appdata) {
wdata = (W3DAppData0Struct *)(appdata->data);
}
return wdata;
}
W3DAppData1Struct * W3DUtilityClass::get_app_data_1(INode * node)
{
// Try to get our AppData which has the damage region
W3DAppData1Struct * wdata = NULL;
AppDataChunk * appdata = node->GetAppDataChunk(W3DUtilityClassID,UTILITY_CLASS_ID,1);
// If there wasn't one, add one. If there was one, get the data from it
if (appdata) {
wdata = (W3DAppData1Struct *)(appdata->data);
} else {
wdata = new W3DAppData1Struct;
node->AddAppDataChunk(W3DUtilityClassID,UTILITY_CLASS_ID,1,sizeof(W3DAppData1Struct),wdata);
appdata = node->GetAppDataChunk(W3DUtilityClassID,UTILITY_CLASS_ID,1);
assert(appdata);
}
return wdata;
}
W3DAppData2Struct * W3DUtilityClass::get_app_data_2(INode * node)
{
return W3DAppData2Struct::Get_App_Data(node);
}
W3DDazzleAppDataStruct * W3DUtilityClass::get_dazzle_app_data(INode * node)
{
return W3DDazzleAppDataStruct::Get_App_Data(node);
}
/**********************************************************************************************
**
** Dialog procs for the W3DUtilityClass
**
**********************************************************************************************/
static BOOL CALLBACK _w3d_utility_tools_dlg_proc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
case WM_LBUTTONDOWN:
case WM_LBUTTONUP:
case WM_MOUSEMOVE:
TheW3DUtility.InterfacePtr->RollupMouseMessage(hWnd,msg,wParam,lParam);
break;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
/*
** Buttons
*/
case IDC_SELECT_GEOMETRY:
TheW3DUtility.Select_Geometry();
break;
case IDC_SELECT_HIERARCHY:
TheW3DUtility.Select_Hierarchy();
break;
case IDC_SELECT_ALPHA_MESHES:
TheW3DUtility.Select_Alpha();
break;
case IDC_SELECT_PHYSICAL:
TheW3DUtility.Select_Physical();
break;
case IDC_SELECT_PROJECTILE:
TheW3DUtility.Select_Projectile();
break;
case IDC_SELECT_VIS:
TheW3DUtility.Select_Vis();
break;
case IDC_COLLECTION_NAMES_GENERATE:
TheW3DUtility.generate_names();
TheW3DUtility.update_settings_controls();
break;
case IDC_MATERIAL_NAMES_GENERATE:
TheW3DUtility.generate_material_names();
TheW3DUtility.update_settings_controls();
break;
case IDC_LOD_EXTENSION_GENERATE:
TheW3DUtility.generate_lod_extensions();
TheW3DUtility.update_settings_controls();
break;
case IDC_EXPORT_STANDARD_MATERIALS:
TheW3DUtility.export_with_standard_materials();
break;
case IDC_CREATE_SETTINGS_FLOATER:
TheW3DUtility.create_floater();
break;
}
return TRUE;
}
default:
return FALSE;
}
return TRUE;
}
/**********************************************************************************************
**
** SettingsFormClass Implementation
** NOTE: When you use the _settings_form_dlg_proc, a SettingsFormClass will automatically
** be allocated and attached to the dialog. You can cause all of the active forms to
** refresh their status by calling Update_All_Instances. The forms will be destroyed when
** the window is destroyed.
**
**********************************************************************************************/
SettingsFormClass * SettingsFormClass::ActiveList = NULL;
BOOL CALLBACK _settings_form_dlg_proc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
if (msg == WM_INITDIALOG) {
SettingsFormClass * form = new SettingsFormClass(hWnd);
::SetProp(hWnd,"SettingsFormClass",(HANDLE)form);
}
SettingsFormClass * form = (SettingsFormClass *)::GetProp(hWnd,"SettingsFormClass");
if (form) {
return form->Dialog_Proc(hWnd,msg,wParam,lParam);
} else {
return FALSE;
}
}
static void _settings_form_selection_changed_callback(void * param,NotifyInfo * info)
{
((SettingsFormClass*)param)->Selection_Changed();
}
SettingsFormClass::SettingsFormClass(HWND hwnd) :
Hwnd(hwnd),
RegionSpin(NULL)
{
/*
** Link into the active list
*/
Next = ActiveList;
ActiveList = this;
/*
** Register with MAX
*/
::RegisterNotification(_settings_form_selection_changed_callback, this, NOTIFY_SELECTIONSET_CHANGED);
}
SettingsFormClass::~SettingsFormClass(void)
{
/*
** Unregister from MAX
*/
::UnRegisterNotification(_settings_form_selection_changed_callback, this, NOTIFY_SELECTIONSET_CHANGED);
/*
** Unlink from the active list
*/
if (ActiveList == this) {
ActiveList = Next;
} else {
SettingsFormClass * prev = ActiveList;
SettingsFormClass * cur = ActiveList->Next;
while ((cur != this) && (cur != NULL)) {
cur = cur->Next;
prev = prev->Next;
}
assert(cur == this);
if (cur == this) {
prev->Next = cur->Next;
}
}
Hwnd = NULL;
}
void SettingsFormClass::Update_All_Instances(void)
{
if (ActiveList == NULL) {
return;
}
/*
** Build a list of the selected nodes
*/
INodeListClass node_list( ::GetCOREInterface()->GetRootNode(),
::GetCOREInterface()->GetTime(),
&_INodeFilter );
/*
** Update all settings forms
*/
SettingsFormClass * form = ActiveList;
while (form != NULL) {
form->Update_Controls(&node_list);
form = form->Next;
}
}
void SettingsFormClass::Init(void)
{
// Initialize the contents of the dazzle combo
// Reset the dazzle combo
HWND dazzle_combo = GetDlgItem(Hwnd,IDC_DAZZLE_COMBO);
assert(dazzle_combo != NULL);
SendMessage(dazzle_combo,CB_RESETCONTENT,0,0);
// Load the section of Dazzle.INI that defines all of the types. The windows function
// that I'm using here, reads in a NULL-terminated string for each entry in the section. Each
// string is of the form 'key=value'. Based on my testing, it appears that windows removes any white
// space before or after the equal sign as well.
char dllpath[_MAX_PATH];
::GetModuleFileName(AppInstance,dllpath,sizeof(dllpath));
char * last_slash = strrchr(dllpath,'\\');
last_slash++;
strcpy(last_slash,DAZZLE_SETTINGS_FILENAME);
char * dazzle_types_buffer = new char[DAZZLE_SECTION_BUFFERSIZE]; // max size of a section for Win95
::GetPrivateProfileSection( DAZZLE_TYPES_SECTION, dazzle_types_buffer, DAZZLE_SECTION_BUFFERSIZE, dllpath);
// Now we need to handle each string in the section buffer; skipping the 'key=' and adding
// the dazzle type name into the combo box.
char * entry = dazzle_types_buffer;
if (entry != NULL) {
while (*entry != NULL) {
entry = strchr(entry,'=');
if (entry != NULL) {
entry++;
::SendMessage(dazzle_combo,CB_ADDSTRING,0,(LPARAM)entry);
entry += strlen(entry) + 1;
}
}
} else {
::SendMessage(dazzle_combo,CB_ADDSTRING,0,(LPARAM)"Default");
}
::SendMessage(dazzle_combo,CB_SETCURSEL,(WPARAM)0,0);
delete dazzle_types_buffer;
/*
** Setup the damage region spinner control.
*/
RegionSpin = SetupIntSpinner
(
Hwnd,
IDC_DAMREG_INDEX_SPIN,
IDC_DAMREG_INDEX_EDIT,
NO_DAMAGE_REGION, MAX_DAMAGE_REGIONS-1, NO_DAMAGE_REGION
);
}
void SettingsFormClass::Destroy(void)
{
ReleaseISpinner(RegionSpin);
RegionSpin = NULL;
}
bool SettingsFormClass::Dialog_Proc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
{
int check;
switch (message) {
case WM_INITDIALOG:
Init();
break;
case WM_DESTROY:
Destroy();
delete this;
break;
case WM_COMMAND:
{
/*
** handle the tri-state checkboxes.
** MAKE SURE YOU PUT ANY NEW CHECKBOX ID's IN HERE!!!
*/
int control_id = LOWORD(wParam);
if ( (control_id == IDC_HIERARCHY_CHECK) ||
(control_id == IDC_GEOMETRY_CHECK) ||
(control_id == IDC_GEOMETRY_HIDE) ||
(control_id == IDC_GEOMETRY_TWO_SIDED) ||
(control_id == IDC_GEOMETRY_ZNORMALS) ||
(control_id == IDC_GEOMETRY_VERTEX_ALPHA) ||
(control_id == IDC_GEOMETRY_CAST_SHADOW) ||
(control_id == IDC_GEOMETRY_SHATTERABLE) ||
(control_id == IDC_GEOMETRY_NPATCH) ||
(control_id == IDC_COLLISION_PHYSICAL) ||
(control_id == IDC_COLLISION_PROJECTILE) ||
(control_id == IDC_COLLISION_VIS) ||
(control_id == IDC_COLLISION_CAMERA) ||
(control_id == IDC_COLLISION_VEHICLE))
{
check = !SendDlgItemMessage(hWnd,LOWORD(wParam),BM_GETCHECK,0,0L);
SendDlgItemMessage(hWnd,LOWORD(wParam),BM_SETCHECK,check,0L);
}
INodeListClass node_list( ::GetCOREInterface()->GetRootNode(),
::GetCOREInterface()->GetTime(),
&_INodeFilter );
switch (LOWORD(wParam))
{
/*
** Tri-State Checkboxes, make sure that the ID of all checkboxes is present
** in the 'if' statement above!
*/
case IDC_HIERARCHY_CHECK:
W3DUtilityClass::set_hierarchy_in_all_selected(&node_list,check == BST_CHECKED);
break;
case IDC_GEOMETRY_CHECK:
W3DUtilityClass::set_geometry_in_all_selected(&node_list,check == BST_CHECKED);
break;
case IDC_GEOMETRY_HIDE:
W3DUtilityClass::enable_hidden_in_all_selected(&node_list,check == BST_CHECKED);
break;
case IDC_GEOMETRY_TWO_SIDED:
W3DUtilityClass::enable_two_sided_in_all_selected(&node_list,check == BST_CHECKED);
break;
case IDC_GEOMETRY_ZNORMALS:
W3DUtilityClass::enable_znormals_in_all_selected(&node_list,check == BST_CHECKED);
break;
case IDC_GEOMETRY_VERTEX_ALPHA:
W3DUtilityClass::enable_vertex_alpha_in_all_selected(&node_list,check == BST_CHECKED);
break;
case IDC_GEOMETRY_CAST_SHADOW:
W3DUtilityClass::enable_shadow_in_all_selected(&node_list,check == BST_CHECKED);
break;
case IDC_GEOMETRY_SHATTERABLE:
W3DUtilityClass::enable_shatterable_in_all_selected(&node_list,check == BST_CHECKED);
break;
case IDC_GEOMETRY_NPATCH:
W3DUtilityClass::enable_npatches_in_all_selected(&node_list,check == BST_CHECKED);
break;
case IDC_COLLISION_PHYSICAL:
W3DUtilityClass::enable_physical_collision_in_all_selected(&node_list,check == BST_CHECKED);
break;
case IDC_COLLISION_PROJECTILE:
W3DUtilityClass::enable_projectile_collision_in_all_selected(&node_list,check == BST_CHECKED);
break;
case IDC_COLLISION_VIS:
W3DUtilityClass::enable_vis_collision_in_all_selected(&node_list,check == BST_CHECKED);
break;
case IDC_COLLISION_CAMERA:
W3DUtilityClass::enable_camera_collision_in_all_selected(&node_list,check == BST_CHECKED);
break;
case IDC_COLLISION_VEHICLE:
W3DUtilityClass::enable_vehicle_collision_in_all_selected(&node_list,check == BST_CHECKED);
break;
/*
** Radio buttons for the Geometry type
*/
case IDC_GEOMETRY_NORMAL:
W3DUtilityClass::set_geometry_type_in_all_selected(&node_list,W3DAppData2Struct::GEO_TYPE_NORMAL_MESH);
break;
case IDC_GEOMETRY_CAMERA_ALIGNED:
W3DUtilityClass::set_geometry_type_in_all_selected(&node_list,W3DAppData2Struct::GEO_TYPE_CAMERA_ALIGNED);
break;
case IDC_GEOMETRY_CAMERA_ORIENTED:
W3DUtilityClass::set_geometry_type_in_all_selected(&node_list,W3DAppData2Struct::GEO_TYPE_CAMERA_ORIENTED);
break;
case IDC_GEOMETRY_NULL:
W3DUtilityClass::set_geometry_type_in_all_selected(&node_list,W3DAppData2Struct::GEO_TYPE_NULL);
break;
case IDC_GEOMETRY_AABOX:
W3DUtilityClass::set_geometry_type_in_all_selected(&node_list,W3DAppData2Struct::GEO_TYPE_AABOX);
break;
case IDC_GEOMETRY_OBBOX:
W3DUtilityClass::set_geometry_type_in_all_selected(&node_list,W3DAppData2Struct::GEO_TYPE_OBBOX);
break;
case IDC_GEOMETRY_AGGREGATE:
W3DUtilityClass::set_geometry_type_in_all_selected(&node_list,W3DAppData2Struct::GEO_TYPE_AGGREGATE);
break;
case IDC_GEOMETRY_DAZZLE:
W3DUtilityClass::set_geometry_type_in_all_selected(&node_list,W3DAppData2Struct::GEO_TYPE_DAZZLE);
break;
/*
** Dazzle type setting. Whenever the user changes the selected dazzle type, apply
** the new setting to all selected nodes.
*/
case IDC_DAZZLE_COMBO:
if (HIWORD(wParam) == CBN_SELCHANGE) {
HWND dazzle_combo = GetDlgItem(hWnd,IDC_DAZZLE_COMBO);
if (dazzle_combo != NULL) {
char dazzle_type[128];
int cursel = ::SendMessage(dazzle_combo,CB_GETCURSEL,0,0);
int len = ::SendMessage(dazzle_combo,CB_GETLBTEXTLEN,cursel,0);
if (len < 128) {
::SendMessage(dazzle_combo,CB_GETLBTEXT,(WPARAM)cursel,(LPARAM)dazzle_type);
W3DUtilityClass::set_dazzle_type_in_all_selected(&node_list,dazzle_type);
}
}
}
break;
}
return TRUE;
}
/*
** Spinners
*/
case CC_SPINNER_CHANGE:
{
INodeListClass node_list( ::GetCOREInterface()->GetRootNode(),
::GetCOREInterface()->GetTime(),
&_INodeFilter );
W3DUtilityClass::set_region_in_all_selected(&node_list,RegionSpin->GetIVal());
break;
}
/*
** Max Custom Edit boxes
*/
case WM_CUSTEDIT_ENTER:
{
INodeListClass node_list( ::GetCOREInterface()->GetRootNode(),
::GetCOREInterface()->GetTime(),
&_INodeFilter );
ICustEdit * edit_ctrl = GetICustEdit(GetDlgItem(hWnd,wParam));
if (wParam == IDC_OBJ_NAME) {
if (edit_ctrl && node_list.Num_Nodes() == 1) {
char buffer[64];
edit_ctrl->GetText(buffer,sizeof(buffer));
node_list[0]->SetName(buffer);
Update_All_Instances();
}
}
ReleaseICustEdit(edit_ctrl);
break;
}
default:
return FALSE;
}
return TRUE;
}
void SettingsFormClass::Selection_Changed(void)
{
INodeListClass node_list( ::GetCOREInterface()->GetRootNode(),
::GetCOREInterface()->GetTime(),
&_INodeFilter );
Update_Controls(&node_list);
}
void SettingsFormClass::Update_Controls(INodeListClass * node_list)
{
/*
** Update name of currently selected object
** "Multiple" if more than one, "None" if no selected objs...
*/
ICustEdit * edit_ctrl = GetICustEdit(GetDlgItem(Hwnd,IDC_OBJ_NAME));
if (edit_ctrl != NULL) {
if (node_list->Num_Nodes() == 0) {
edit_ctrl->Enable(FALSE);
edit_ctrl->SetText(Get_String(IDS_NO_OBJECT));
} else if (node_list->Num_Nodes() == 1) {
edit_ctrl->Enable(TRUE);
edit_ctrl->SetText((*node_list)[0]->GetName());
} else {
edit_ctrl->Enable(FALSE);
edit_ctrl->SetText(Get_String(IDS_MULTIPLE_OBJECTS));
}
ReleaseICustEdit(edit_ctrl);
}
if (node_list->Num_Nodes() == 0) {
Disable_Controls();
return;
}
W3DUtilityClass::NodeStatesStruct ns;
W3DUtilityClass::eval_node_states(node_list,&ns);
/*
** Enable hierarchy and geometry checks since they are always available
*/
EnableWindow(GetDlgItem(Hwnd,IDC_HIERARCHY_CHECK),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_CHECK),TRUE);
/*
** Enable/Disable the geometry controls
*/
if (ns.ExportGeometry == 1) {
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_CAMERA_ALIGNED),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_CAMERA_ORIENTED),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_NORMAL),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_NULL),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_AABOX),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_OBBOX),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_AGGREGATE),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_DAZZLE),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_HIDE),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_TWO_SIDED),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_ZNORMALS),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_VERTEX_ALPHA),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_CAST_SHADOW),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_SHATTERABLE),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_NPATCH),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_COLLISION_PHYSICAL),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_COLLISION_PROJECTILE),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_COLLISION_VIS),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_COLLISION_CAMERA),TRUE);
EnableWindow(GetDlgItem(Hwnd,IDC_COLLISION_VEHICLE),TRUE);
} else {
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_CAMERA_ALIGNED),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_CAMERA_ORIENTED),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_NORMAL),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_NULL),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_AABOX),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_OBBOX),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_AGGREGATE),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_DAZZLE),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_HIDE),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_TWO_SIDED),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_ZNORMALS),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_VERTEX_ALPHA),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_CAST_SHADOW),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_SHATTERABLE),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_NPATCH),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_COLLISION_PHYSICAL),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_COLLISION_PROJECTILE),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_COLLISION_VIS),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_COLLISION_CAMERA),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_COLLISION_VEHICLE),FALSE);
}
/*
** Set the checks based on the nodes states:
** no check - none of the selected nodes had this setting
** check - all of the selected nodes had this setting
** grey check - some of the selected nodes had this setting
*/
SendDlgItemMessage(Hwnd,IDC_HIERARCHY_CHECK,BM_SETCHECK,ns.ExportHierarchy,0L);
SendDlgItemMessage(Hwnd,IDC_GEOMETRY_CHECK,BM_SETCHECK,ns.ExportGeometry,0L);
SendDlgItemMessage(Hwnd,IDC_GEOMETRY_HIDE,BM_SETCHECK,ns.GeometryHidden,0L);
SendDlgItemMessage(Hwnd,IDC_GEOMETRY_TWO_SIDED,BM_SETCHECK,ns.GeometryTwoSided,0L);
SendDlgItemMessage(Hwnd,IDC_GEOMETRY_ZNORMALS,BM_SETCHECK,ns.GeometryZNormals,0L);
SendDlgItemMessage(Hwnd,IDC_GEOMETRY_VERTEX_ALPHA,BM_SETCHECK,ns.GeometryVertexAlpha,0L);
SendDlgItemMessage(Hwnd,IDC_GEOMETRY_CAST_SHADOW,BM_SETCHECK,ns.GeometryCastShadow,0L);
SendDlgItemMessage(Hwnd,IDC_GEOMETRY_SHATTERABLE,BM_SETCHECK,ns.GeometryShatterable,0L);
SendDlgItemMessage(Hwnd,IDC_GEOMETRY_NPATCH,BM_SETCHECK,ns.GeometryNPatch,0L);
SendDlgItemMessage(Hwnd,IDC_COLLISION_PHYSICAL,BM_SETCHECK,ns.CollisionPhysical,0L);
SendDlgItemMessage(Hwnd,IDC_COLLISION_PROJECTILE,BM_SETCHECK,ns.CollisionProjectile,0L);
SendDlgItemMessage(Hwnd,IDC_COLLISION_VIS,BM_SETCHECK,ns.CollisionVis,0L);
SendDlgItemMessage(Hwnd,IDC_COLLISION_CAMERA,BM_SETCHECK,ns.CollisionCamera,0L);
SendDlgItemMessage(Hwnd,IDC_COLLISION_VEHICLE,BM_SETCHECK,ns.CollisionVehicle,0L);
/*
** The damage region spinner should only be enabled if
** Export Hierarchy is checked for all selected nodes.
*/
BOOL spinner_enable = false;
if (ns.ExportHierarchy == 1)
{
if (ns.DamageRegion != MAX_DAMAGE_REGIONS)
{
// Show the damage region in the spinner.
RegionSpin->SetIndeterminate(FALSE);
RegionSpin->SetValue(ns.DamageRegion, FALSE);
}
else
{
// The selected objects aren't all in the same region.
RegionSpin->SetIndeterminate(TRUE);
}
spinner_enable = true;
}
EnableWindow(GetDlgItem(Hwnd,IDC_DAMREG_INDEX_EDIT),spinner_enable);
EnableWindow(GetDlgItem(Hwnd,IDC_DAMREG_INDEX_SPIN),spinner_enable);
/*
** The dazzle combo box should only be enabled if
** Export Geometry, and geometry type dazzle is set for all
** selected nodes.
*/
bool dazzle_combo_enable = false;
if (ns.ExportGeometry == 1) {
if (ns.DazzleCount == node_list->Num_Nodes()) {
dazzle_combo_enable = true;
}
}
HWND dazzle_combo = GetDlgItem(Hwnd,IDC_DAZZLE_COMBO);
EnableWindow(dazzle_combo,dazzle_combo_enable);
int selindex = ::SendMessage(dazzle_combo,CB_FINDSTRING,(WPARAM)0,(LPARAM)ns.DazzleType);
if (selindex != CB_ERR) {
::SendMessage(dazzle_combo,CB_SETCURSEL,(WPARAM)selindex,(LPARAM)0);
} else {
::SendMessage(dazzle_combo,CB_SETCURSEL,(WPARAM)0,(LPARAM)0);
}
/*
** Set any radio buttons present
*/
CheckDlgButton(Hwnd,IDC_GEOMETRY_CAMERA_ALIGNED,(ns.GeometryCameraAligned ? BST_CHECKED : BST_UNCHECKED));
CheckDlgButton(Hwnd,IDC_GEOMETRY_CAMERA_ORIENTED,(ns.GeometryCameraOriented ? BST_CHECKED : BST_UNCHECKED));
CheckDlgButton(Hwnd,IDC_GEOMETRY_NORMAL,(ns.GeometryNormal ? BST_CHECKED : BST_UNCHECKED));
CheckDlgButton(Hwnd,IDC_GEOMETRY_NULL,(ns.GeometryNull ? BST_CHECKED : BST_UNCHECKED));
CheckDlgButton(Hwnd,IDC_GEOMETRY_AABOX,(ns.GeometryAABox ? BST_CHECKED : BST_UNCHECKED));
CheckDlgButton(Hwnd,IDC_GEOMETRY_OBBOX,(ns.GeometryOBBox ? BST_CHECKED : BST_UNCHECKED));
CheckDlgButton(Hwnd,IDC_GEOMETRY_AGGREGATE,(ns.GeometryAggregate ? BST_CHECKED : BST_UNCHECKED));
CheckDlgButton(Hwnd,IDC_GEOMETRY_DAZZLE,(ns.GeometryDazzle ? BST_CHECKED : BST_UNCHECKED));
}
void SettingsFormClass::Disable_Controls(void)
{
EnableWindow(GetDlgItem(Hwnd,IDC_OBJ_NAME),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_HIERARCHY_CHECK),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_CHECK),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_DAMREG_INDEX_EDIT),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_DAMREG_INDEX_SPIN),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_NORMAL),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_CAMERA_ALIGNED),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_CAMERA_ORIENTED),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_AABOX),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_OBBOX),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_NULL),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_AGGREGATE),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_DAZZLE),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_HIDE),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_TWO_SIDED),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_ZNORMALS),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_VERTEX_ALPHA),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_CAST_SHADOW),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_SHATTERABLE),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_GEOMETRY_NPATCH),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_COLLISION_PHYSICAL),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_COLLISION_PROJECTILE),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_COLLISION_VIS),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_COLLISION_CAMERA),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_COLLISION_VEHICLE),FALSE);
EnableWindow(GetDlgItem(Hwnd,IDC_DAZZLE_COMBO),FALSE);
CheckDlgButton(Hwnd,IDC_HIERARCHY_CHECK,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_GEOMETRY_CHECK,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_GEOMETRY_CAMERA_ALIGNED,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_GEOMETRY_CAMERA_ORIENTED,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_GEOMETRY_NORMAL,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_GEOMETRY_AABOX,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_GEOMETRY_OBBOX,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_GEOMETRY_NULL,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_GEOMETRY_AGGREGATE,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_GEOMETRY_DAZZLE,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_GEOMETRY_HIDE,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_GEOMETRY_TWO_SIDED,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_GEOMETRY_ZNORMALS,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_GEOMETRY_VERTEX_ALPHA,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_GEOMETRY_CAST_SHADOW,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_GEOMETRY_SHATTERABLE,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_GEOMETRY_NPATCH,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_COLLISION_PHYSICAL,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_COLLISION_PROJECTILE,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_COLLISION_VIS,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_COLLISION_CAMERA,BST_UNCHECKED);
CheckDlgButton(Hwnd,IDC_COLLISION_VEHICLE,BST_UNCHECKED);
}
/*
** Functions to access the W3D AppData of any INode.
*/
W3DAppData0Struct * GetW3DAppData0 (INode *node)
{
return TheW3DUtility.get_app_data_0(node);
}
W3DAppData1Struct * GetW3DAppData1 (INode *node)
{
return TheW3DUtility.get_app_data_1(node);
}
W3DAppData2Struct * GetW3DAppData2 (INode *node)
{
return TheW3DUtility.get_app_data_2(node);
}
W3DDazzleAppDataStruct * GetW3DDazzleAppData(INode *node)
{
return TheW3DUtility.get_dazzle_app_data(node);
}
Reference in New Issue Copy Permalink