Cyd
2b8ca921cb
Complete disaster-recovery snapshot: engine/game source, game data assets, VC6 toolchain + DX SDKs, build outputs, deployed game, and _UNUSED archive. Large binaries in Git LFS; text preserved byte-for-byte (core.autocrlf=false, no eol attributes). See RECOVERY.md for the one-clone rebuild procedure.
1052 lines
30 KiB
C++
1052 lines
30 KiB
C++
// ResourceWindow.cpp : implementation file
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "MW4GameEd.h"
|
|
#include "ResourceWindow.h"
|
|
#include "EditorChildWnd.h"
|
|
#include "MW4GameEd.h"
|
|
#include <direct.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <Adept\Map.hpp>
|
|
#include "MoveCommand.h"
|
|
#include "AddCommand.h"
|
|
#include "SprayCommand.h"
|
|
#include <Adept\EntityManager.hpp>
|
|
#include <Adept\Mission.hpp>
|
|
#include <Adept\Connection.hpp>
|
|
#include <Adept\Application.hpp>
|
|
#include <Adept\NameTable.hpp>
|
|
#include <Adept\EntityClassData.hpp>
|
|
#include <MW4\Vehicle.hpp>
|
|
#include <MW4\Building.hpp>
|
|
#include "EditorWaypoint.h"
|
|
#include <MW4\rail_move.hpp>
|
|
#include "MW4\path.hpp"
|
|
#include "DisplayWindow.h"
|
|
#include "OverviewWindow.h"
|
|
#include "InstanceWindow.h"
|
|
#include "Selection.h"
|
|
#include <MW4\MWTool.hpp>
|
|
#include <NavPoint.hpp>
|
|
#include <mw4\Cultural.hpp>
|
|
#include <mw4\noncom.hpp>
|
|
#include <Adept\navpoint.hpp>
|
|
#include "ProgDlg.h"
|
|
|
|
extern CMW4GameEdApp theApp;
|
|
Entity* CreateNewInstanceSimple(char* game_model_name, char* entity_name, char* instance_name);
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// CResourceWindow
|
|
|
|
IMPLEMENT_DYNCREATE(CResourceWindow, CEditorChildWnd)
|
|
|
|
CResourceWindow::CResourceWindow() :
|
|
mechList(NULL),
|
|
buildingList(NULL),
|
|
vehicleList(NULL),
|
|
miscList(NULL),
|
|
tabListIterator(NULL)
|
|
{
|
|
CString title;
|
|
RECT rect;
|
|
|
|
TLDlg = NULL;
|
|
|
|
title.LoadString(IDS_RESOURCEWINDOWTITLE);
|
|
rect.top = 210; rect.left = 650; rect.bottom = 400; rect.right = 900;
|
|
|
|
Create(NULL,title,WS_CHILD | WS_CLIPSIBLINGS | WS_OVERLAPPEDWINDOW | WS_VISIBLE,rect);//,theApp.m_pMainWnd,0);
|
|
|
|
numEntitiesAdded = 0;
|
|
}
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
CResourceWindow::~CResourceWindow()
|
|
{
|
|
objectInformation->IgnoreChanges();
|
|
Unregister_Object(objectInformation);
|
|
delete objectInformation;
|
|
|
|
TabList* current;
|
|
ChainIteratorOf<TabList*> mechIterator(&mechList);
|
|
while((current = mechIterator.GetCurrent()) != NULL)
|
|
{
|
|
mechIterator.Remove();
|
|
mechIterator.First();
|
|
delete current;
|
|
}
|
|
ChainIteratorOf<TabList*> buildingIterator(&buildingList);
|
|
while((current = buildingIterator.GetCurrent()) != NULL)
|
|
{
|
|
buildingIterator.Remove();
|
|
buildingIterator.First();
|
|
delete current;
|
|
}
|
|
ChainIteratorOf<TabList*> vehicleIterator(&vehicleList);
|
|
while((current = vehicleIterator.GetCurrent()) != NULL)
|
|
{
|
|
vehicleIterator.Remove();
|
|
vehicleIterator.First();
|
|
delete current;
|
|
}
|
|
ChainIteratorOf<TabList*> miscIterator(&miscList);
|
|
while((current = miscIterator.GetCurrent()) != NULL)
|
|
{
|
|
miscIterator.Remove();
|
|
miscIterator.First();
|
|
delete current;
|
|
}
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
BEGIN_MESSAGE_MAP(CResourceWindow,CEditorChildWnd)
|
|
//{{AFX_MSG_MAP(CResourceWindow)
|
|
ON_WM_LBUTTONDBLCLK()
|
|
ON_WM_CREATE()
|
|
ON_WM_SIZE()
|
|
ON_WM_PAINT()
|
|
ON_WM_KEYDOWN()
|
|
ON_WM_RBUTTONDBLCLK()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// CResourceWindow message handlers
|
|
|
|
void CResourceWindow::OnLButtonDblClk(UINT nFlags, CPoint point)
|
|
{
|
|
if(Application::Instance->GetApplicationState()
|
|
== ApplicationStateEngine::RunningGameState)
|
|
{
|
|
theApp.m_editorState = CMW4GameEdApp::WaitingToAddState;
|
|
Entity* entity = CreateNewInstance();
|
|
if (entity != NULL)
|
|
{
|
|
if (theApp.m_editorState == CMW4GameEdApp::WaitingToAddState)
|
|
theApp.m_editorState = CMW4GameEdApp::AddingObjectState;
|
|
}
|
|
else
|
|
{
|
|
theApp.m_editorState = CMW4GameEdApp::IdleState;
|
|
|
|
}
|
|
}
|
|
CEditorChildWnd::OnLButtonDblClk(nFlags, point);
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
Entity* CResourceWindow::CreateNewInstance(char* game_model_name, char* entity_name, char* instance_name)
|
|
{
|
|
Entity* entity = NULL;
|
|
|
|
Check_Object(theApp.resourceWindow->objectInformation);
|
|
Page *entity_instance = theApp.resourceWindow->objectInformation->FindPage(instance_name);
|
|
if(!entity_instance)
|
|
{
|
|
PAUSE(("That item does not have an instance in editor.contents"));
|
|
return (NULL);
|
|
}
|
|
else
|
|
{
|
|
FileDependencies dummy;
|
|
FileDependencies *parent = Resource::ParentFileDependencies;
|
|
Resource::ParentFileDependencies = &dummy;
|
|
entity_instance->SetEntry("Model", game_model_name);
|
|
DynamicMemoryStream entity_stream;
|
|
ReplicatorID entity_id = ReplicatorID::Null;
|
|
Entity::CreateMessage* create_message =
|
|
Tool::Instance->ConstructCreateMessage(
|
|
&entity_stream,
|
|
entity_instance,
|
|
&entity_id
|
|
);
|
|
|
|
//
|
|
// set the default alignment based on the editor settings
|
|
//
|
|
create_message->alignment = theApp.GetDefaultAlignmentForPlacedObjects();
|
|
|
|
LinearMatrix4D matrix = LinearMatrix4D::Identity;
|
|
Point3D point;
|
|
point.x = 0.0f;
|
|
point.z = 0.0f;
|
|
point.y = theApp.displayWindow->GetMapPointVertical(point.x,point.z);
|
|
|
|
matrix.BuildTranslation(point);
|
|
|
|
create_message->localToParent = matrix;
|
|
|
|
entity_stream.Rewind();
|
|
Check_Object(Connection::Local);
|
|
entity_id = Connection::Local->GetNextReplicatorID();
|
|
|
|
entity = Entity::CreateEntity(
|
|
&entity_stream,
|
|
&entity_id,
|
|
false
|
|
);
|
|
//
|
|
//--------------------------------------------
|
|
//Make some initial assignments for the entity
|
|
//--------------------------------------------
|
|
//
|
|
Check_Object(entity);
|
|
Check_Object(EntityManager::Instance);
|
|
EntityManager::Instance->GetNameSocket()->Remove(entity);
|
|
entity->instanceName = theApp.resourceWindow->AssignObjectName(entity_name, &theApp.resourceWindow->numEntitiesAdded);
|
|
if (entity->IsDerivedFrom(Vehicle::DefaultData))
|
|
{
|
|
Vehicle* vehicle = Cast_Object(Vehicle*,entity);
|
|
|
|
EntityManager::Instance->RemoveMover(vehicle);
|
|
EntityManager::Instance->AddMover(vehicle);
|
|
}
|
|
EntityManager::Instance->GetNameSocket()->AddValue(entity, entity->instanceName);
|
|
|
|
Check_Object(Map::Instance);
|
|
Map::Instance->AddChild(entity);
|
|
MLRTexturePool::Instance->LoadImages();
|
|
entity->SetPropType(Entity::MissionPropType);
|
|
theApp.displayWindow->SetFocus();
|
|
|
|
entity->SyncMatrices(true);
|
|
Map::Instance->UpdateZone(entity);
|
|
CSelectionList::Instance->AddSelection(entity);
|
|
CSelectionList::Instance->RemoveCollision();
|
|
Resource::ParentFileDependencies = parent;
|
|
}
|
|
return entity;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
Entity* CResourceWindow::CreateNewInstance(Entity* entity)
|
|
{
|
|
static recurseGuard = false;
|
|
|
|
TLDlg->m_ObjList.EnableWindow(FALSE);
|
|
theApp.instanceWindow->TLDlg->m_ObjList.EnableWindow(FALSE);
|
|
|
|
CSelectionList::Instance->ClearSelectionList();
|
|
theApp.m_MultiDrop = true;
|
|
|
|
int item = TLDlg->m_ObjList.GetCurSel();
|
|
|
|
if(Application::Instance->GetApplicationState()
|
|
== ApplicationStateEngine::RunningGameState)
|
|
{
|
|
const char *game_model_name = (char *)TLDlg->m_ObjList.GetItemData(item);
|
|
char entity_name[MAX_PATH];
|
|
int length = TLDlg->m_ObjList.GetText(item,entity_name);
|
|
Verify(length < MAX_PATH);
|
|
char instance_name[MAX_PATH];
|
|
TLDlg->m_ObjList.GetText(item,instance_name);
|
|
entity = CreateNewInstance((char*)game_model_name,entity_name,instance_name);
|
|
if (entity == NULL)
|
|
{
|
|
TLDlg->m_ObjList.EnableWindow(TRUE);
|
|
theApp.instanceWindow->TLDlg->m_ObjList.EnableWindow(TRUE);
|
|
theApp.m_MultiDrop = false;
|
|
return (NULL);
|
|
}
|
|
|
|
if (entity->IsDerivedFrom(EditorLatticeNode::DefaultData))
|
|
{
|
|
Point3D pos;
|
|
pos = entity->GetLocalToWorld();
|
|
MW4AI::CRailNode* railNode;
|
|
SPEW(("scottjan","Hey! set up a default railnode radius"));
|
|
railNode = new MW4AI::CRailNode(pos,50);
|
|
MW4AI::g_MissionGraph->AddNode(railNode);
|
|
|
|
EditorLatticeNode* latticeNode = Cast_Object(EditorLatticeNode*,entity);
|
|
latticeNode->railNode = railNode;
|
|
theApp.CreateLatticeNodeRadius(latticeNode);
|
|
|
|
theApp.m_showLattice = false;
|
|
theApp.OnToolsMovementlattice();
|
|
// theApp.m_showLatticeLinks = false;
|
|
// theApp.OnToolsMovmentlayerShowlatticelinks();
|
|
}
|
|
else if (entity->IsDerivedFrom(EditorMovementPath::DefaultData))
|
|
{
|
|
if (theApp.m_CurPath == NULL)
|
|
{
|
|
EditorMovementPath* path;
|
|
path = Cast_Object(EditorMovementPath*, entity);
|
|
path->pathSlot.Remove();
|
|
path->pathSlot.Add(CreateMovementPath());
|
|
theApp.m_CurPath = path;
|
|
theApp.m_CurPathNodeCount = 0;
|
|
theApp.m_LastPathNode = NULL;
|
|
|
|
path->instanceName = path->pathSlot.GetCurrent()->instanceName;
|
|
// path->GetElement()->SetAlwaysCullMode();
|
|
path->GetElement()->Sync();
|
|
|
|
theApp.instanceWindow->ResetInstanceLists();
|
|
}
|
|
else // quick hack, if we are appending to a path we need to destroy the new one we just created
|
|
{
|
|
entity->SentenceToDeathRow();
|
|
}
|
|
|
|
entity = CreateNewInstance("Content\\Editor\\Reserved\\PathNode\\PathNode.data",
|
|
"PathNode","PathNode");
|
|
|
|
CSelectionList::Instance->ClearSelectionList();
|
|
CSelectionList::Instance->AddSelection(entity);
|
|
CSelectionList::Instance->RemoveCollision();
|
|
|
|
Point3D point;
|
|
point = entity->GetLocalToWorld();
|
|
theApp.m_CurPath->pathSlot.GetCurrent()->pathPoints.push_back(point);
|
|
|
|
EditorPathNode* pathNode;
|
|
pathNode = Cast_Object(EditorPathNode*,entity);
|
|
|
|
pathNode->pathSlot.Remove();
|
|
pathNode->pathSlot.Add(theApp.m_CurPath);
|
|
theApp.m_CurPath->pathNodes.Add(pathNode);
|
|
pathNode->index = theApp.m_CurPathNodeCount++;
|
|
pathNode->nextnode = NULL;
|
|
pathNode->prevnode = theApp.m_LastPathNode;
|
|
if (theApp.m_LastPathNode)
|
|
theApp.m_LastPathNode->nextnode = pathNode;
|
|
|
|
pathNode->CreateLink();
|
|
theApp.m_LastPathNode = pathNode;
|
|
theApp.m_showPaths = false;
|
|
theApp.OnToolsMovmentlayerShowpaths();
|
|
}
|
|
else if (entity->IsDerivedFrom(EditorDropNode::DefaultData))
|
|
{
|
|
EditorDropNode* node;
|
|
node = Cast_Object(EditorDropNode*,entity);
|
|
node->SetDropZone(NULL); // will create a new Adept::DropZone and attach it to EditorDropNode
|
|
theApp.m_showDropZones = false;
|
|
theApp.OnToolsMovmentlayerShowdropzones();
|
|
}
|
|
else if (entity->IsDerivedFrom(EditorObjectiveMarker::DefaultData))
|
|
{
|
|
EditorObjectiveMarker* node;
|
|
node = Cast_Object(EditorObjectiveMarker*,entity);
|
|
node->SetObjective(NULL); // will create a new MechWarrior4::Objective and attach it to EditorDropNode
|
|
theApp.m_showAI = false;
|
|
theApp.OnToolsMovmentlayerShowobjectives();
|
|
}
|
|
else if (entity->IsDerivedFrom(NavPoint::DefaultData))
|
|
{
|
|
NavPoint* node;
|
|
node = Cast_Object(NavPoint*,entity);
|
|
node->SetToDisplay();
|
|
}
|
|
else if (entity->IsDerivedFrom(EditorLight::DefaultData))
|
|
{
|
|
EditorLight* editorLight;
|
|
editorLight = Cast_Object(EditorLight*,entity);
|
|
editorLight->SetLight();
|
|
}
|
|
else if (entity->IsDerivedFrom(EditorCameraShip::DefaultData))
|
|
{
|
|
EditorCameraShip* node;
|
|
node = Cast_Object(EditorCameraShip*,entity);
|
|
node->SetCameraShip(NULL); // will create a new CameraShip and attach it to EditorDropNode
|
|
|
|
}
|
|
#if 0
|
|
if (theApp.m_editorState == CMW4GameEdApp::AddingObjectState)
|
|
{
|
|
theApp.currentCommand = new AddCommand(entity);
|
|
Register_Object(theApp.currentCommand);
|
|
}
|
|
else if (!recurseGuard && entity->IsDerivedFrom(Building::DefaultData))
|
|
{
|
|
recurseGuard = true;
|
|
theApp.currentCommand = new SprayCommand(entity);
|
|
Register_Object(theApp.currentCommand);
|
|
recurseGuard = false;
|
|
}
|
|
#endif
|
|
|
|
if ((!recurseGuard && entity->IsDerivedFrom(Building::DefaultData)) &&
|
|
(theApp.m_editorState == CMW4GameEdApp::WaitingToSprayState))
|
|
{
|
|
recurseGuard = true;
|
|
theApp.currentCommand = new SprayCommand(entity);
|
|
Register_Object(theApp.currentCommand);
|
|
recurseGuard = false;
|
|
theApp.m_editorState = CMW4GameEdApp::SprayingState;
|
|
}
|
|
else if(theApp.m_editorState == CMW4GameEdApp::WaitingToAddState)
|
|
{
|
|
theApp.currentCommand = new AddCommand(entity);
|
|
Register_Object(theApp.currentCommand);
|
|
theApp.m_editorState = CMW4GameEdApp::AddingObjectState;
|
|
if (entity->IsDerivedFrom(EditorAmbientLight::DefaultData) ||
|
|
entity->IsDerivedFrom(EditorInfiniteLight::DefaultData) ||
|
|
entity->IsDerivedFrom(EditorObjectiveMarker::DefaultData))
|
|
{
|
|
entity->GetElement()->SetAlwaysCullMode();
|
|
CSelectionList::Instance->ClearSelectionList();
|
|
theApp.m_editorState = CMW4GameEdApp::SelectingObjectState;
|
|
theApp.m_MultiDrop = false;
|
|
theApp.resourceWindow->TLDlg->m_ObjList.EnableWindow();
|
|
theApp.instanceWindow->TLDlg->m_ObjList.EnableWindow();
|
|
// theApp.instanceWindow->AddInstance(entity);
|
|
}
|
|
}
|
|
|
|
}
|
|
theApp.displayWindow->SetFocus(); // rqr'd for multi instace add
|
|
return entity;
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
int CResourceWindow::OnCreate(LPCREATESTRUCT lpCreateStruct)
|
|
{
|
|
if (CEditorChildWnd::OnCreate(lpCreateStruct) == -1)
|
|
return -1;
|
|
|
|
TLDlg = new CObjWindow;
|
|
|
|
TLDlg->Create(CObjWindow::IDD,this);
|
|
|
|
RECT r;
|
|
memset(&r,0,sizeof(r));
|
|
TLDlg->m_ObjList.Create(WS_VISIBLE | WS_CHILD | LBS_NOINTEGRALHEIGHT | LBS_STANDARD,r,TLDlg,0);
|
|
|
|
TLDlg->GetDlgItem(IDC_INSTANCEALINGMENTBTN)->ShowWindow(SW_HIDE);
|
|
TLDlg->GetDlgItem(IDC_INSTANCETYPEBTN)->ShowWindow(SW_HIDE);
|
|
TLDlg->ShowWindow(SW_SHOW);
|
|
|
|
//
|
|
//----------------------------------------
|
|
//Initialize the Instance Information File
|
|
//----------------------------------------
|
|
//
|
|
objectInformation = new NotationFile("Content\\Editor\\editor.contents");
|
|
Register_Object(objectInformation);
|
|
|
|
{
|
|
MString vehicle_path = Working_Directory;
|
|
vehicle_path += "\\Content\\Mechs\\*.*";
|
|
Directory *vehicle_directory;
|
|
vehicle_directory = new Directory(vehicle_path, true);
|
|
Register_Object(vehicle_directory);
|
|
|
|
TLDlg->m_TabCtrl.InsertItem(0,TLDlg->mechTab);
|
|
|
|
vehicle_path.IsolateDirectory();
|
|
|
|
MakeDirectoryList(
|
|
vehicle_directory,
|
|
MECH_TAB,
|
|
vehicle_path
|
|
);
|
|
|
|
Unregister_Object(vehicle_directory);
|
|
delete vehicle_directory;
|
|
}
|
|
//
|
|
//-----------------------------------------
|
|
//Initialize the Building Folder in Content
|
|
//-----------------------------------------
|
|
//
|
|
{
|
|
MString prop_path = Working_Directory;
|
|
prop_path += "\\Content\\Buildings\\*.*";
|
|
Directory *prop_directory;
|
|
prop_directory = new Directory(prop_path, true);
|
|
Check_Object(prop_directory);
|
|
Register_Object(prop_directory);
|
|
|
|
TLDlg->m_TabCtrl.InsertItem(1,TLDlg->buildingTab);
|
|
|
|
prop_path.IsolateDirectory();
|
|
|
|
MakeDirectoryList(
|
|
prop_directory,
|
|
BUILDING_TAB,
|
|
prop_path
|
|
);
|
|
|
|
Unregister_Object(prop_directory);
|
|
delete prop_directory;
|
|
}
|
|
//
|
|
//-----------------------------------------
|
|
//Initialize the Vehicles Folder in Content
|
|
//-----------------------------------------
|
|
//
|
|
|
|
{
|
|
MString vehicle_path = Working_Directory;
|
|
vehicle_path += "\\Content\\Vehicles\\*.*";
|
|
Directory *vehicle_directory;
|
|
vehicle_directory = new Directory(vehicle_path, true);
|
|
Register_Object(vehicle_directory);
|
|
|
|
TLDlg->m_TabCtrl.InsertItem(2,TLDlg->vehicleTab);
|
|
|
|
vehicle_path.IsolateDirectory();
|
|
|
|
MakeDirectoryList(
|
|
vehicle_directory,
|
|
VEHICLE_TAB,
|
|
vehicle_path
|
|
);
|
|
|
|
Unregister_Object(vehicle_directory);
|
|
delete vehicle_directory;
|
|
}
|
|
|
|
{
|
|
/*
|
|
MString prop_path = Working_Directory;
|
|
prop_path += "\\Content\\DropZones\\*.*";
|
|
Directory *prop_directory;
|
|
prop_directory = new Directory(prop_path, true);
|
|
Check_Object(prop_directory);
|
|
Register_Object(prop_directory);
|
|
|
|
Stuff::IsolateDirectory(&prop_path);
|
|
|
|
MakeDirectoryList(
|
|
prop_directory,
|
|
MISC_TAB,
|
|
prop_path
|
|
);
|
|
|
|
Unregister_Object(prop_directory);
|
|
delete prop_directory;
|
|
*/
|
|
TLDlg->m_TabCtrl.InsertItem(3,TLDlg->miscTab);
|
|
|
|
MString prop_path = Working_Directory;
|
|
prop_path += "\\Content\\Editor\\Waypoints\\*.*";
|
|
Directory *prop_directory = new Directory(prop_path, true);
|
|
Check_Object(prop_directory);
|
|
Register_Object(prop_directory);
|
|
|
|
prop_path.IsolateDirectory();
|
|
|
|
MakeDirectoryList(
|
|
prop_directory,
|
|
MISC_TAB,
|
|
prop_path
|
|
);
|
|
|
|
Unregister_Object(prop_directory);
|
|
delete prop_directory;
|
|
}
|
|
TLDlg->m_TabCtrl.SetCurSel(0);
|
|
FillTabBox(0);
|
|
|
|
return 0;
|
|
}
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void CResourceWindow::OnSize(UINT nType, int cx, int cy)
|
|
{
|
|
CEditorChildWnd::OnSize(nType, cx, cy);
|
|
|
|
if(TLDlg)
|
|
{
|
|
TLDlg->SetWindowPos(NULL,0,0,cx,cy,SWP_NOZORDER);
|
|
TLDlg->m_TabCtrl.SetWindowPos(NULL,0,0,cx,cy,SWP_NOZORDER);
|
|
RECT r,l;
|
|
TLDlg->m_TabCtrl.GetClientRect(&r);
|
|
TLDlg->m_TabCtrl.GetItemRect(0,&l);
|
|
TLDlg->m_ObjList.SetWindowPos(NULL,3,l.bottom + 3,r.right - 7,r.bottom - l.bottom - 7,SWP_NOZORDER);
|
|
}
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void CResourceWindow::OnPaint()
|
|
{
|
|
CPaintDC dc(this); // device context for painting
|
|
}
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
MString
|
|
CResourceWindow::AssignObjectName(MString name, int *num)
|
|
{
|
|
MString object_name;
|
|
char number[256];
|
|
|
|
//
|
|
// Make the object name
|
|
//
|
|
sprintf(number, "%i", *num);
|
|
(*num)++;
|
|
object_name = name;
|
|
object_name += "_";
|
|
object_name += number;
|
|
|
|
while (CheckObjectName(object_name))
|
|
{
|
|
sprintf(number, "%i", *num);
|
|
(*num)++;
|
|
object_name = name;
|
|
object_name += "_";
|
|
object_name += number;
|
|
}
|
|
return object_name;
|
|
}
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
void
|
|
CResourceWindow::MakeDirectoryList(
|
|
Directory *current_directory,
|
|
int tabNumber,
|
|
MString directory_name
|
|
)
|
|
{
|
|
static int recursionDepth = 0;
|
|
|
|
Check_Pointer (this);
|
|
Check_Pointer(current_directory);
|
|
|
|
MString file_directory_name;
|
|
file_directory_name = directory_name;
|
|
file_directory_name.StripExtension();
|
|
file_directory_name += "*.data";
|
|
Directory *file_directory = new Directory(file_directory_name, false);
|
|
Register_Object(file_directory);
|
|
|
|
MString file_name;
|
|
while((char *)(file_name = file_directory->GetCurrentFileName()) != NULL)
|
|
{
|
|
file_name.StripExtension();
|
|
|
|
file_name.ToLower();
|
|
if (file_name == "basic")
|
|
{
|
|
file_directory->AdvanceCurrentFile();
|
|
continue;
|
|
}
|
|
|
|
TabList* newNode = new TabList;
|
|
|
|
newNode->itemString = file_name;
|
|
newNode->itemPath = directory_name;
|
|
newNode->itemPath += file_name;
|
|
newNode->itemPath += ".data";
|
|
|
|
char appended_data[MAX_PATH];
|
|
strcpy(appended_data, strstr(newNode->itemPath.GetBuffer(MAX_PATH - 1), "Content"));
|
|
newNode->itemPath = appended_data;
|
|
|
|
if (file_name == "navpoint")
|
|
{
|
|
miscList.Add(newNode);
|
|
}
|
|
else
|
|
{
|
|
switch (tabNumber)
|
|
{
|
|
case MECH_TAB:
|
|
mechList.Add(newNode);
|
|
break;
|
|
case BUILDING_TAB:
|
|
buildingList.Add(newNode);
|
|
break;
|
|
case VEHICLE_TAB:
|
|
vehicleList.Add(newNode);
|
|
break;
|
|
case MISC_TAB:
|
|
miscList.Add(newNode);
|
|
break;
|
|
}
|
|
}
|
|
file_directory->AdvanceCurrentFile();
|
|
}
|
|
Unregister_Object(file_directory);
|
|
delete file_directory;
|
|
|
|
if (recursionDepth > 0)
|
|
{
|
|
recursionDepth--;
|
|
return;
|
|
}
|
|
|
|
MString folder_name;
|
|
while((char *)(folder_name = current_directory->GetCurrentFolderName()) != NULL)
|
|
{
|
|
MString new_directory_name = directory_name;
|
|
new_directory_name += folder_name;
|
|
new_directory_name += "\\*.*";
|
|
Directory *new_directory = new Directory(new_directory_name, true);
|
|
Register_Object(new_directory);
|
|
new_directory_name.IsolateDirectory();
|
|
recursionDepth++;
|
|
MakeDirectoryList(
|
|
new_directory,
|
|
tabNumber,
|
|
new_directory_name
|
|
);
|
|
Unregister_Object(new_directory);
|
|
delete new_directory;
|
|
|
|
current_directory->AdvanceCurrentFolder();
|
|
}
|
|
}
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
bool
|
|
CResourceWindow::CheckObjectName(MString name)
|
|
{
|
|
Check_Object(EntityManager::Instance);
|
|
|
|
if(EntityManager::Instance->GetNameSocket()->Find(name))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CResourceWindow::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
|
|
{
|
|
// if (theApp.m_editorState != CMW4GameEdApp::AddingObjectState)
|
|
CEditorChildWnd::OnKeyDown(nChar, nRepCnt, nFlags);
|
|
// else if (nChar == VK_ESCAPE)
|
|
// theApp.StopMultiPlace();
|
|
}
|
|
|
|
void CResourceWindow::FillTabBox(int tabNumber)
|
|
{
|
|
switch (tabNumber)
|
|
{
|
|
case MECH_TAB:
|
|
{
|
|
ChainIteratorOf<TabList*> iterator(&mechList);
|
|
FillTabBox(iterator);
|
|
break;
|
|
}
|
|
case BUILDING_TAB:
|
|
{
|
|
ChainIteratorOf<TabList*> iterator(&buildingList);
|
|
FillTabBox(iterator);
|
|
break;
|
|
}
|
|
case VEHICLE_TAB:
|
|
{
|
|
ChainIteratorOf<TabList*> iterator(&vehicleList);
|
|
FillTabBox(iterator);
|
|
break;
|
|
}
|
|
case MISC_TAB:
|
|
{
|
|
ChainIteratorOf<TabList*> iterator(&miscList);
|
|
FillTabBox(iterator);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CResourceWindow::FillTabBox(ChainIteratorOf<TabList*> &iterator)
|
|
{
|
|
TLDlg->m_ObjList.ResetContent();
|
|
|
|
TabList* item;
|
|
|
|
while ((item = iterator.ReadAndNext()) != NULL)
|
|
{
|
|
int index = TLDlg->m_ObjList.AddString(item->itemString);
|
|
TLDlg->m_ObjList.SetItemDataPtr(index,(void*)LPCTSTR(item->itemPath));
|
|
}
|
|
}
|
|
|
|
BOOL CResourceWindow::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult)
|
|
{
|
|
if (UINT(wParam) == IDC_OBJECTTAB)
|
|
FillTabBox(((NMHDR*)(lParam))->code);
|
|
|
|
*pResult = 0;
|
|
|
|
return CEditorChildWnd::OnNotify(wParam, lParam, pResult);
|
|
}
|
|
|
|
MechWarrior4::Path* CResourceWindow::CreateMovementPath()
|
|
{
|
|
Resource model_resource;
|
|
SPEW(("scottjan","Get rid of the hard coded data file"));
|
|
NotationFile path_file("Content\\Misc\\Path.data");
|
|
Tool::Instance->ConstructDataList(&model_resource, &path_file);
|
|
Check_Object(&model_resource);
|
|
Verify(model_resource.DoesResourceExist());
|
|
|
|
Entity::ClassID class_ID;
|
|
class_ID = Entity::GetClassIDFromDataListID(model_resource.GetResourceID());
|
|
Verify(class_ID != NullClassID);
|
|
|
|
LinearMatrix4D matrix = LinearMatrix4D::Identity;
|
|
|
|
MechWarrior4::Path::CreateMessage Path_Create_Message(
|
|
sizeof(MechWarrior4::Path::CreateMessage),
|
|
DefaultEventPriority,
|
|
MechWarrior4::Path::CreateMessage::DefaultFlags,
|
|
class_ID,
|
|
MechWarrior4::Path::DefaultFlags,
|
|
model_resource.GetResourceID(),
|
|
matrix,
|
|
0.0f,
|
|
Entity__ExecutionStateEngine::AlwaysExecuteState,
|
|
NameTable::NullObjectID,
|
|
Entity::DefaultAlignment,
|
|
ResourceID::Null
|
|
);
|
|
|
|
MemoryStream stream(&Path_Create_Message, Path_Create_Message.messageLength);
|
|
|
|
ReplicatorID Path_id = Connection::Local->GetNextReplicatorID();
|
|
Entity* entity;
|
|
entity = Entity::CreateEntity(&stream, &Path_id, false);
|
|
Check_Object(entity);
|
|
Verify(entity->IsDerivedFrom(Path::DefaultData));
|
|
|
|
Check_Object(EntityManager::Instance);
|
|
EntityManager::Instance->GetNameSocket()->Remove(entity);
|
|
entity->instanceName = theApp.resourceWindow->AssignObjectName("Path", &theApp.resourceWindow->numEntitiesAdded);
|
|
EntityManager::Instance->GetNameSocket()->AddValue(entity, entity->instanceName);
|
|
Check_Object(Map::Instance);
|
|
Map::Instance->AddChild(entity);
|
|
|
|
MLRTexturePool::Instance->LoadImages();
|
|
CSelectionList::Instance->RemoveCollision();
|
|
entity->SetPropType(Entity::MissionPropType);
|
|
entity->SyncMatrices(true);
|
|
|
|
Verify(entity->IsDerivedFrom(Path::DefaultData));
|
|
NameTable::Instance->AddEntry(entity, NameTable::PathArray);
|
|
NameTable::Instance->IsValid();
|
|
|
|
MechWarrior4::Path* path;
|
|
path = Cast_Object(MechWarrior4::Path*, entity);
|
|
|
|
return (path);
|
|
}
|
|
|
|
|
|
void CResourceWindow::OnRButtonDblClk(UINT nFlags, CPoint point)
|
|
{
|
|
if(Application::Instance->GetApplicationState()
|
|
== ApplicationStateEngine::RunningGameState)
|
|
{
|
|
if (TLDlg->m_TabCtrl.GetCurSel() == BUILDING_TAB)
|
|
{
|
|
theApp.m_editorState = CMW4GameEdApp::WaitingToSprayState;
|
|
Entity* entity = CreateNewInstance();
|
|
if (entity != NULL)
|
|
{
|
|
theApp.m_editorState = CMW4GameEdApp::SprayingState;
|
|
}
|
|
else
|
|
{
|
|
theApp.m_editorState = CMW4GameEdApp::IdleState;
|
|
}
|
|
|
|
}
|
|
}
|
|
CEditorChildWnd::OnRButtonDblClk(nFlags, point);
|
|
}
|
|
|
|
void CResourceWindow::DisperseWithBitmap(bool cultural_flag)
|
|
{
|
|
CFileDialog fdlg(TRUE,NULL,NULL,NULL,"Bitmap Images (*.tif,*.gif,*.tga)|*.tif;*.gif;*.tga||",NULL);
|
|
|
|
if(fdlg.DoModal()==IDOK)
|
|
{
|
|
Image img;
|
|
img.Load((char *)(LPCSTR)fdlg.GetPathName());
|
|
img.Rotate180();
|
|
SetCurrentDirectory(Working_Directory);
|
|
BYTE *dat=img.Lock();
|
|
int x,y;
|
|
|
|
Scalar minz,maxz,minx,maxx,xsize,zsize;
|
|
float gridxsize,gridzsize;
|
|
|
|
Map::Instance->GetMapExtents(&minz,&maxz,&minx,&maxx);
|
|
xsize=maxx-minx;
|
|
zsize=maxz-minz;
|
|
|
|
int total=img.GetHeight()*img.GetWidth();
|
|
int current=0;
|
|
|
|
CProgressDlg *ProgressDlg;
|
|
ProgressDlg = new CProgressDlg(IDS_DISPERSE);
|
|
ProgressDlg->Create();
|
|
ProgressDlg->ShowWindow(SW_SHOW);
|
|
|
|
ProgressDlg->SetRange(0,total);
|
|
ProgressDlg->SetStep(50);
|
|
ProgressDlg->SetPos(0);
|
|
|
|
gridxsize=xsize/img.GetWidth();
|
|
gridzsize=zsize/img.GetHeight();
|
|
|
|
int item = TLDlg->m_ObjList.GetCurSel();
|
|
const char *game_model_name = (char *)TLDlg->m_ObjList.GetItemData(item);
|
|
char entity_name[MAX_PATH];
|
|
int length = TLDlg->m_ObjList.GetText(item,entity_name);
|
|
Verify(length < MAX_PATH);
|
|
char instance_name[MAX_PATH];
|
|
TLDlg->m_ObjList.GetText(item,instance_name);
|
|
|
|
CSelectionList::Instance->ClearSelectionList();
|
|
for(y=0;y<img.GetHeight();y++)
|
|
for(x=0;x<img.GetWidth();x++)
|
|
{
|
|
current++;
|
|
if((current%50 || current==total)) ProgressDlg->SetPos(current);
|
|
if(dat[x+img.GetPitch()*y])
|
|
{
|
|
Entity *entity = NULL;
|
|
entity = CreateNewInstanceSimple((char*)game_model_name,entity_name,instance_name);
|
|
|
|
Point3D pos;
|
|
YawPitchRoll rot;
|
|
Stuff::LinearMatrix4D mat;
|
|
|
|
do
|
|
{
|
|
rot.yaw=Stuff::Random::GetFraction()*Two_Pi;
|
|
rot.pitch=0.0f;
|
|
rot.roll=0.0f;
|
|
|
|
pos.x=x*gridxsize+Stuff::Random::GetFraction()*gridxsize;
|
|
pos.z=y*gridzsize+Stuff::Random::GetFraction()*gridzsize;
|
|
pos.y=theApp.displayWindow->GetMapPointVertical(pos.x,pos.z);
|
|
mat.BuildRotation(rot);
|
|
mat.BuildTranslation(pos);
|
|
|
|
|
|
Map::Instance->AddChild(entity);
|
|
entity->SetNewLocalToParent(mat);
|
|
entity->SyncMatrices(true);
|
|
Map::Instance->UpdateZone(entity);
|
|
|
|
}
|
|
while(entity->IsMultiZone());
|
|
|
|
|
|
if ( entity->IsMultiTile())
|
|
{
|
|
Map::Instance->RemoveChild(entity);
|
|
NameTable::Instance->RemoveEntry(entity->objectID);
|
|
NameTable::Instance->IsValid();
|
|
delete Cast_Object(Stuff::Plug *, entity);
|
|
}
|
|
else
|
|
{
|
|
Check_Object(NameTable::Instance);
|
|
entity->BindToTile();
|
|
if(entity->IsDerivedFrom(Vehicle::DefaultData))
|
|
NameTable::Instance->AddEntry(entity, NameTable::VehicleArray);
|
|
else if(entity->IsDerivedFrom(Building::DefaultData) || entity->IsDerivedFrom(Cultural::DefaultData))
|
|
NameTable::Instance->AddEntry(entity, NameTable::BuildingArray);
|
|
else if(entity->IsDerivedFrom(NavPoint::DefaultData))
|
|
NameTable::Instance->AddEntry(entity, NameTable::NavArray);
|
|
else if(entity->IsDerivedFrom(NonCom::DefaultData))
|
|
NameTable::Instance->AddEntry(entity, NameTable::BuildingArray);
|
|
else if(entity->IsDerivedFrom(AI::DefaultData))
|
|
NameTable::Instance->AddEntry(entity, NameTable::AIArray);
|
|
NameTable::Instance->IsValid();
|
|
|
|
if(cultural_flag) theApp.culturalList.Add(entity);
|
|
}
|
|
|
|
|
|
|
|
}
|
|
}
|
|
delete ProgressDlg;
|
|
img.UnLock();
|
|
|
|
|
|
}
|
|
theApp.instanceWindow->ResetInstanceLists();
|
|
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
Entity* CreateNewInstanceSimple(char* game_model_name, char* entity_name, char* instance_name)
|
|
{
|
|
Entity* entity = NULL;
|
|
|
|
Check_Object(theApp.resourceWindow->objectInformation);
|
|
Page *entity_instance = theApp.resourceWindow->objectInformation->FindPage(instance_name);
|
|
if(!entity_instance)
|
|
{
|
|
PAUSE(("That item does not have an instance in editor.contents"));
|
|
}
|
|
else
|
|
{
|
|
FileDependencies dummy;
|
|
FileDependencies *parent = Resource::ParentFileDependencies;
|
|
Resource::ParentFileDependencies = &dummy;
|
|
entity_instance->SetEntry("Model", game_model_name);
|
|
DynamicMemoryStream entity_stream;
|
|
ReplicatorID entity_id = ReplicatorID::Null;
|
|
Entity::CreateMessage* create_message =
|
|
Tool::Instance->ConstructCreateMessage(
|
|
&entity_stream,
|
|
entity_instance,
|
|
&entity_id
|
|
);
|
|
|
|
//
|
|
// set the default alignment based on the editor settings
|
|
//
|
|
create_message->alignment = theApp.GetDefaultAlignmentForPlacedObjects();
|
|
|
|
LinearMatrix4D matrix = LinearMatrix4D::Identity;
|
|
|
|
create_message->localToParent = matrix;
|
|
|
|
entity_stream.Rewind();
|
|
Check_Object(Connection::Local);
|
|
entity_id = Connection::Local->GetNextReplicatorID();
|
|
|
|
entity = Entity::CreateEntity(
|
|
&entity_stream,
|
|
&entity_id,
|
|
false
|
|
);
|
|
//
|
|
//--------------------------------------------
|
|
//Make some initial assignments for the entity
|
|
//--------------------------------------------
|
|
//
|
|
Check_Object(entity);
|
|
Check_Object(EntityManager::Instance);
|
|
EntityManager::Instance->GetNameSocket()->Remove(entity);
|
|
entity->instanceName = theApp.resourceWindow->AssignObjectName(entity_name, &theApp.resourceWindow->numEntitiesAdded);
|
|
if (entity->IsDerivedFrom(Vehicle::DefaultData))
|
|
{
|
|
Vehicle* vehicle = Cast_Object(Vehicle*,entity);
|
|
|
|
EntityManager::Instance->RemoveMover(vehicle);
|
|
EntityManager::Instance->AddMover(vehicle);
|
|
}
|
|
EntityManager::Instance->GetNameSocket()->AddValue(entity, entity->instanceName);
|
|
|
|
entity->SetPropType(Entity::MissionPropType);
|
|
Resource::ParentFileDependencies = parent;
|
|
}
|
|
return entity;
|
|
}
|
|
|