zydronium/SBSPSS
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Browse source
This commit is contained in:
Daveo 2001-02-01 22:48:22 +00:00
parent 81bc8b99ba
commit 6662d783ce
21 changed files with 435 additions and 236 deletions
Download patch file Download diff file Expand all files Collapse all files

29
Utils/MapEdit/Core.cpp
View file

@ -23,8 +23,7 @@
#include "LayerCollision.h"
#include "utils.h"
#include "ExportAGB.h"
#include "ExportPSX.h"
#include "Export.h"
/*****************************************************************************/
@ -53,7 +52,7 @@ int ListSize=Layer.size();
/*****************************************************************************/
void CCore::Init()
{
UpdateParamBar();
// UpdateParamBar();
// UpdateAll(NULL);
}
@ -802,33 +801,15 @@ Vector3 ThisCam=Cam;
}
/*****************************************************************************/
void CCore::ExportAGB(char *Filename)
{
int LayerCount=Layer.size();
char ExportName[256];
SetFileExt(Filename,ExportName,"c");
CExportAGB Exp(ExportName);
for (int i=0;i<LayerCount;i++)
{
Layer[i]->Export(this,Exp);
}
Exp.ExportTiles(this);
Exp.ExportPalette();
}
/*****************************************************************************/
void CCore::ExportPSX(char *Filename)
void CCore::Export(char *Filename)
{
int LayerCount=Layer.size();
char ExportName[256];
SetFileExt(Filename,ExportName,"PME");
SetFileExt(Filename,ExportName,"MEX");
CExportPSX Exp(ExportName,LayerCount);
CExport Exp(ExportName,LayerCount);
for (int i=0;i<LayerCount;i++)
{

3
Utils/MapEdit/Core.h
View file

@ -33,8 +33,7 @@ public:
void Render(CMapEditView *View,BOOL ForceRender=FALSE);
void RenderLayers(CMapEditView *View);
void RenderTileView(CMapEditView *View);
void ExportAGB(char *Filename);
void ExportPSX(char *Filename);
void Export(char *Filename);
// Control

260
Utils/MapEdit/Export.cpp
View file

@ -5,48 +5,268 @@
#include "stdafx.h"
#include <Vector>
#include "Core.h"
#include "TileSet.h"
#include "LayerTile.h"
#include "Map.h"
#include "Export.h"
#include "utils.h"
#include "Core.h"
#include "TexCache.h"
#include "TileSet.h"
#include "Tile.h"
#include "Layer.h"
#include "LayerTile.h"
#include "Export.h"
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
CExport::CExport(char *_Filename)
CExport::CExport(char *Filename,int _LayerCount)
{
Filename=_Filename;
LayerCount=_LayerCount;
File=fopen(Filename,"wb");
// Write Dummy File Header
fwrite(&FileHdr,sizeof(sExpFileHdr),1,File);
for (int i=0;i<LayerCount; i++) fwrite(&LayerCount,sizeof(int),1,File);
}
/*****************************************************************************/
CExport::~CExport()
{
ASSERT(LayerCount==LayerOfs.size());
FileHdr.LayerCount=LayerCount;
// ReWrite Main Header
fseek(File,0,0);
fwrite(&FileHdr,sizeof(sExpFileHdr),1,File);
for (int i=0;i<LayerCount; i++)
{
TRACE1("LayerOfs %i\n",LayerOfs[i]);
fwrite(&LayerOfs[i],sizeof(int),1,File);
}
fclose(File);
}
/*****************************************************************************/
void CExport::BuildColTable(CTile &ThisTile)
/*** Tile Map ****************************************************************/
/*****************************************************************************/
void CExport::ExportLayerTile(CCore *Core,char *LayerName,int SubType,CMap &Map)
{
u8 *RGB=ThisTile.GetGBTexRGB();
int Width=ThisTile.GetGBTexW();
int Height=ThisTile.GetGBTexH();
sExpLayerHdr LayerHdr;
int Width=Map.GetWidth();
int Height=Map.GetHeight();
int ThisFilePos=ftell(File);
sExpMapElem BlankElem={0,0,0};
int X,Y;
ColTable.resize(Width);
TRACE1("LayerTile Ofs %i\n",ThisFilePos);
LayerOfs.push_back(ThisFilePos);
for (X=0; X<Width; X++)
LayerHdr.Type=LAYER_TYPE_TILE;
LayerHdr.SubType=SubType;
LayerHdr.Width=Map.GetWidth();
LayerHdr.Height=Map.GetHeight();
fwrite(&LayerHdr,sizeof(sExpLayerHdr),1,File);
UsedTileList.Add(BlankElem); // Ensure blank tile is present
for (int Y=0; Y<Height; Y++)
{
for (Y=Height; Y ; Y--)
for (int X=0; X<Width; X++)
{
int Ofs=X+((Y-1)*Width);
u8 R=RGB[(Ofs*3)+0];
u8 G=RGB[(Ofs*3)+1];
u8 B=RGB[(Ofs*3)+2];
if (R==255 && G==255 && B==255) break;
sMapElem &MapElem=Map.Get(X,Y);
sExpMapElem TileElem;
TileElem.Tile=MapElem.Tile;
TileElem.Set=MapElem.Set;
TileElem.Flags=MapElem.Flags;
sExpLayerTile OutElem;
OutElem.Tile=UsedTileList.Add(TileElem);
OutElem.Flags=MapElem.Flags;
fwrite(&OutElem,sizeof(sExpLayerTile),1,File);
}
ColTable[X]=Y-1;
}
}
/*****************************************************************************/
/*** Collision Layer *********************************************************/
/*****************************************************************************/
void CExport::ExportLayerCollision(CCore *Core,char *LayerName,int SubType,CMap &Map)
{
sExpLayerHdr LayerHdr;
int Width=Map.GetWidth();
int Height=Map.GetHeight();
int ThisFilePos=ftell(File);
u8 OutElem;
TRACE1("LayerCollision Ofs %i\n",ThisFilePos);
LayerOfs.push_back(ThisFilePos);
LayerHdr.Type=LAYER_TYPE_COLLISION;
LayerHdr.SubType=SubType;
LayerHdr.Width=Map.GetWidth();
LayerHdr.Height=Map.GetHeight();
fwrite(&LayerHdr,sizeof(sExpLayerHdr),1,File);
for (int Y=0; Y<Height; Y++)
{
for (int X=0; X<Width; X++)
{
sMapElem &MapElem=Map.Get(X,Y);
OutElem=0;
if (MapElem.Tile)
{
OutElem=((MapElem.Tile-1)*4)+1;
OutElem+=MapElem.Flags & TILE_FLAG_MIRROR_XY;
}
fwrite(&OutElem,sizeof(u8),1,File);
}
}
}
/*****************************************************************************/
/*** Tiles *******************************************************************/
/*****************************************************************************/
void CExport::ExportTiles(CCore *Core)
{
int ListSize,i;
// Write Tiles
ListSize=UsedTileList.size();
FileHdr.TileCount=ListSize;
FileHdr.TileOfs=ftell(File);
for (i=0; i<ListSize; i++)
{
sExpMapElem &ThisElem=UsedTileList[i];
CTile &ThisTile=Core->GetTile(ThisElem.Set,ThisElem.Tile);
sExpTile OutTile;
OutTile.Flags=ThisElem.Flags;
TRACE3("%i %i %i\n",ThisElem.Set,ThisElem.Tile,ThisElem.Flags);
ExportTile(Core,ThisTile,OutTile);
}
}
// Write Tris
ListSize=TriList.size();
FileHdr.TriCount=ListSize;
FileHdr.TriOfs=ftell(File);
for (i=0; i<ListSize; i++)
{
fwrite(&TriList[i],sizeof(sTriFace),1,File);
}
TRACE1("TriCount=%i\n",ListSize);
}
/*****************************************************************************/
void CExport::ExportTile(CCore *Core,CTile &ThisTile,sExpTile &OutTile)
{
int RGBW=ThisTile.GetPCTexW();
int RGBH=ThisTile.GetPCTexH();
u8 *RGB=ThisTile.GetPCTexRGB();
OutTile.W=RGBW;
OutTile.H=RGBH;
if (ThisTile.IsTile3d())
{
ExportTile3d(Core,ThisTile,OutTile);
}
else
{
ExportTile2d(Core,ThisTile,OutTile);
}
fwrite(&OutTile,sizeof(sExpTile),1,File);
fwrite(RGB,RGBW*RGBH*3,1,File);
}
/*****************************************************************************/
void CExport::ExportTile2d(CCore *Core,CTile &ThisTile,sExpTile &OutTile)
{
CTexCache &TexCache=Core->GetTexCache();
OutTile.TriStart=-1;
OutTile.TriCount=0;
OutTile.XOfs=ThisTile.GetTexXOfs();
OutTile.YOfs=ThisTile.GetTexYOfs();
// Texture
int TexID=ThisTile.GetTexID();
if (TexID==-1) // Blank Tile
{
OutTile.TexId=-1;
}
else
{
sExpTex OutTex;
sTex &ThisTex=TexCache.GetTex(TexID);
OutTex.Filename=ThisTex.Filename;
OutTile.TexId=TexList.Add(OutTex);
}
}
/*****************************************************************************/
void CExport::ExportTile3d(CCore *Core,CTile &ThisTile,sExpTile &OutTile)
{
CTexCache &TexCache=Core->GetTexCache();
std::vector<sTriFace> &TileTriList=ThisTile.GetTriList();
int TriCount=TileTriList.size();
OutTile.TriStart=TriList.size();
OutTile.TriCount=TriCount;
OutTile.XOfs=-1;
OutTile.YOfs=-1;
OutTile.TexId=-1;
for (int T=0; T<TriCount; T++)
{
sTriFace &TileTri=TileTriList[T];
sTriFace OutTri;
sExpTex OutTex;
for (int p=0; p<3; p++)
{
OutTri=TileTri;
// Texture
sTex &TriTex=TexCache.GetTex(TileTri.Mat);
OutTex.Filename=TriTex.Filename;
OutTri.Mat=TexList.Add(OutTex);
}
TriList.push_back(OutTri);
}
// return(TriCount);
}
/*****************************************************************************/
/*** Textures ****************************************************************/
/*****************************************************************************/
void CExport::ExportTexList(CCore *Core)
{
int TexCount=TexList.size();
FileHdr.TexCount=TexCount;
FileHdr.TexOfs=ftell(File);
for (int i=0; i<TexCount; i++)
{
sExpTex &ThisTex=TexList[i];
char TexFilename[256];
MakePathRel2App(ThisTex.Filename,TexFilename);
int Len=strlen(TexFilename);
fwrite(TexFilename,Len+1,1,File);
TRACE2("%i:\t%s\n",i,TexFilename);
}
}
/*****************************************************************************/

41
Utils/MapEdit/Export.h
View file

@ -6,42 +6,51 @@
#define __EXPORT_HEADER__
#include "stdafx.h"
#include <Vector>
#include <GFName.hpp>
#include "mapedit.h"
#include <Vector>
//#include "GinTex.h"
//#include "Tile.h"
#include "Quantize.h"
#include <list.h>
#include <List.h>
#include "ExportHdr.h"
/*****************************************************************************/
/*****************************************************************************/
/*****************************************************************************/
class CCore;
class CMap;
class CTile;
class CExport
{
public:
CExport(char *Filename);
CExport(char *Filename,int LayerCount);
~CExport();
virtual void ExportLayerTile(CCore *Core,char *LayerName,int SubType,CMap &Map)=0;
virtual void ExportLayerCollision(CCore *Core,char *LayerName,int SubType,CMap &Map)=0;
void ExportLayerTile(CCore *Core,char *LayerName,int SubType,CMap &Map);
void ExportLayerCollision(CCore *Core,char *LayerName,int SubType,CMap &Map);
virtual void ExportTiles(CCore *Core)=0;
void ExportTiles(CCore *Core);
void ExportTexList(CCore *Core);
protected:
void BuildColTable(CTile &ThisTile);
void ExportTile(CCore *Core,CTile &ThisTile,sExpTile &OutTile);
void ExportTile3d(CCore *Core,CTile &ThisTile,sExpTile &OutTile);
void ExportTile2d(CCore *Core,CTile &ThisTile,sExpTile &OutTile);
GFName Filename;
sExpFileHdr FileHdr;
int LayerCount;
CList<int> LayerOfs;
CList<sTriFace> TriList;
CList<sExpTex> TexList;
CList<sExpMapElem> UsedTileList;
// GString Filename;
FILE *File;
int Count;
std::vector<int> ColTable;
// int Count;
};

4
Utils/MapEdit/ExportHdr.h
View file

@ -14,9 +14,8 @@
/*****************************************************************************/
struct sExpFileHdr
{
int Version;
int TileCount;
int TileW,TileH;
// int TileW,TileH;
int TileOfs;
int TriCount;
int TriOfs;
@ -35,6 +34,7 @@ struct sExpTile // 2d 3d
int TexId; // n -1
int Flags;
int W,H;
u8 *RGB; // Used in MkLevel
};
/*****************************************************************************/

79
Utils/MapEdit/MapEdit.clw
View file

@ -19,27 +19,27 @@ Class7=CMapEditView
ResourceCount=13
Resource1=IDD_NEW_LAYER
Resource2=IDR_TOOLBAR (English (U.S.))
Resource3=IDD_ABOUTBOX (English (U.S.))
Resource2=IDR_MAPEDITYPE (English (U.S.))
Resource3=IDR_MAINFRAME (English (U.S.))
Resource4=IDD_DIALOGBAR (English (U.S.))
Resource5=IDD_MAPSIZE
Resource5=IDD_LAYER_LIST_DIALOG
Class8=CMultiBar
Resource6=IDD_LAYERTILE_GUI
Resource7=IDD_ADDLAYER
Resource6=IDD_ADDLAYER
Resource7=IDD_NEWMAP
Class9=CLayerList
Class10=CMapSizeDlg
Resource8=IDR_MAINFRAME (English (U.S.))
Resource8=IDD_LAYERTILE_TOOLBAR
Class11=CGfxToolBar
Class12=CLayerTileGUI
Resource9=IDD_LAYER_LIST_DIALOG
Resource10=IDD_NEWMAP
Resource9=IDD_MULTIBAR (English (U.S.))
Resource10=IDD_MAPSIZE
Class13=CNewMapGUI
Class14=CProgressDlg
Resource11=IDD_MULTIBAR (English (U.S.))
Resource11=IDD_ABOUTBOX (English (U.S.))
Class15=CAddLayerDlg
Resource12=IDD_LAYERTILE_TOOLBAR
Resource12=IDD_LAYERTILE_GUI
Class16=CLayerTileToolbar
Resource13=IDR_MAPEDITYPE (English (U.S.))
Resource13=IDR_TOOLBAR (English (U.S.))
[CLS:CChildFrame]
Type=0
@ -91,7 +91,7 @@ Type=0
BaseClass=CGLEnabledView
HeaderFile=MapEditView.h
ImplementationFile=MapEditView.cpp
LastObject=ID_EXPORT_PSX
LastObject=ID_EXPORT
Filter=C
VirtualFilter=VWC
@ -130,34 +130,33 @@ Class=?
Command1=ID_FILE_NEW
Command2=ID_FILE_OPEN
Command3=ID_FILE_CLOSE
Command4=ID_FILE_SAVEx
Command5=ID_FILE_SAVE_ASx
Command6=ID_EXPORT_AGB
Command7=ID_EXPORT_PSX
Command8=ID_FILE_MRU_FILE1
Command9=ID_APP_EXIT
Command10=ID_EDIT_UNDO
Command11=ID_EDIT_CUT
Command12=ID_EDIT_COPY
Command13=ID_EDIT_PASTE
Command14=ID_VIEW_TOOLBAR
Command15=ID_VIEW_STATUS_BAR
Command16=ID_MAP_SETSIZE
Command17=ID_TOGGLE_GRID
Command18=ID_ZOOM_IN
Command19=ID_ZOOM_OUT
Command20=ID_MIRRORX
Command21=ID_MIRRORY
Command22=ID_ACTIVEBRUSH_LEFT
Command23=ID_ACTIVEBRUSH_RIGHT
Command24=ID_TOGGLE_TILEVIEW
Command25=ID_2D_3D_TOGGLE
Command26=ID_WINDOW_NEW
Command27=ID_WINDOW_CASCADE
Command28=ID_WINDOW_TILE_HORZ
Command29=ID_WINDOW_ARRANGE
Command30=ID_APP_ABOUT
CommandCount=30
Command4=ID_FILE_SAVE
Command5=ID_FILE_SAVE_AS
Command6=ID_EXPORT
Command7=ID_FILE_MRU_FILE1
Command8=ID_APP_EXIT
Command9=ID_EDIT_UNDO
Command10=ID_EDIT_CUT
Command11=ID_EDIT_COPY
Command12=ID_EDIT_PASTE
Command13=ID_VIEW_TOOLBAR
Command14=ID_VIEW_STATUS_BAR
Command15=ID_MAP_SETSIZE
Command16=ID_TOGGLE_GRID
Command17=ID_ZOOM_IN
Command18=ID_ZOOM_OUT
Command19=ID_MIRRORX
Command20=ID_MIRRORY
Command21=ID_ACTIVEBRUSH_LEFT
Command22=ID_ACTIVEBRUSH_RIGHT
Command23=ID_TOGGLE_TILEVIEW
Command24=ID_2D_3D_TOGGLE
Command25=ID_WINDOW_NEW
Command26=ID_WINDOW_CASCADE
Command27=ID_WINDOW_TILE_HORZ
Command28=ID_WINDOW_ARRANGE
Command29=ID_APP_ABOUT
CommandCount=29
[ACL:IDR_MAINFRAME (English (U.S.))]
Type=1

26
Utils/MapEdit/MapEdit.dsp
View file

@ -135,31 +135,7 @@ SOURCE=.\Export.h
# End Source File
# Begin Source File
SOURCE=.\ExportAGB.cpp
# End Source File
# Begin Source File
SOURCE=.\ExportAGB.h
# End Source File
# Begin Source File
SOURCE=.\ExportPSX.cpp
# End Source File
# Begin Source File
SOURCE=.\ExportPSX.h
# End Source File
# Begin Source File
SOURCE=.\ExportPSXHdr.h
# End Source File
# Begin Source File
SOURCE=.\Quantize.cpp
# End Source File
# Begin Source File
SOURCE=.\Quantize.h
SOURCE=.\ExportHdr.h
# End Source File
# End Group
# Begin Source File

7
Utils/MapEdit/MapEdit.rc
View file

@ -95,8 +95,7 @@ BEGIN
MENUITEM "&Save\tCtrl+S", ID_FILE_SAVE
MENUITEM "Save &As...", ID_FILE_SAVE_AS
MENUITEM SEPARATOR
MENUITEM "Export AGB", ID_EXPORT_AGB
MENUITEM "Export PSX", ID_EXPORT_PSX
MENUITEM "Export ", ID_EXPORT
MENUITEM SEPARATOR
MENUITEM "Recent File", ID_FILE_MRU_FILE1, GRAYED
MENUITEM SEPARATOR
@ -208,7 +207,7 @@ END
IDD_MULTIBAR DIALOGEX 0, 0, 156, 71
STYLE WS_CHILD
EXSTYLE WS_EX_TOOLWINDOW
FONT 8, "MS Sans Serif"
FONT 8, "MS Sans Serif", 0, 0, 0x1
BEGIN
END
@ -504,7 +503,7 @@ END
IDD_ADDLAYER DIALOGEX 0, 0, 118, 90
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION
CAPTION "Select Layer To Add."
FONT 8, "MS Sans Serif"
FONT 8, "MS Sans Serif", 0, 0, 0x1
BEGIN
DEFPUSHBUTTON "OK",IDOK,60,75,50,14
PUSHBUTTON "Cancel",IDCANCEL,5,75,50,14

26
Utils/MapEdit/MapEditDoc.cpp
View file

@ -21,8 +21,7 @@ IMPLEMENT_DYNCREATE(CMapEditDoc, CDocument)
BEGIN_MESSAGE_MAP(CMapEditDoc, CDocument)
//{{AFX_MSG_MAP(CMapEditDoc)
ON_UPDATE_COMMAND_UI(ID_INDICATOR_CURSORXY, OnStatusCursorXY)
ON_COMMAND(ID_EXPORT_AGB, OnExportAgb)
ON_COMMAND(ID_EXPORT_PSX, OnExportPsx)
ON_COMMAND(ID_EXPORT, OnExport)
ON_COMMAND(ID_ZOOM_IN, OnZoomIn)
ON_COMMAND(ID_ZOOM_OUT, OnZoomOut)
//}}AFX_MSG_MAP
@ -237,32 +236,17 @@ void CMapEditDoc::DeleteLayer(int Layer)
/*********************************************************************************/
/*********************************************************************************/
/*********************************************************************************/
void CMapEditDoc::OnExportAgb()
void CMapEditDoc::OnExport()
{
char BASED_CODE Filter[]= "AGB Data Type (*.c)|*.c|All Files (*.*)|*.*||";
CFileDialog Dlg(FALSE,"*.c",NULL,OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,Filter);
char BASED_CODE Filter[]= "Export Data Type (*.MEX)|*.MEX|All Files (*.*)|*.*||";
CFileDialog Dlg(FALSE,"*.MEX",NULL,OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,Filter);
if (Dlg.DoModal()!=IDOK) return;
char Filename[256];
sprintf(Filename,"%s",Dlg.GetPathName());
Core.ExportAGB(Filename);
}
/*********************************************************************************/
void CMapEditDoc::OnExportPsx()
{
char BASED_CODE Filter[]= "PSX Data Type (*.PME)|*.Pme|All Files (*.*)|*.*||";
CFileDialog Dlg(FALSE,"*.pme",NULL,OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,Filter);
if (Dlg.DoModal()!=IDOK) return;
char Filename[256];
sprintf(Filename,"%s",Dlg.GetPathName());
Core.ExportPSX(Filename);
Core.Export(Filename);
}
/*********************************************************************************/

3
Utils/MapEdit/MapEditDoc.h
View file

@ -79,8 +79,7 @@ protected:
protected:
//{{AFX_MSG(CMapEditDoc)
afx_msg void OnStatusCursorXY(CCmdUI *pCmdUI);
afx_msg void OnExportAgb();
afx_msg void OnExportPsx();
afx_msg void OnExport();
afx_msg void OnZoomIn();
afx_msg void OnZoomOut();
//}}AFX_MSG

2
Utils/MapEdit/TexCache.cpp
View file

@ -24,7 +24,7 @@ sTex Tex;
/*****************************************************************************/
// Checks loaded files for dups, assumes all passed RGB is unique
int CTexCache::ProcessTexture(char *Filename,int Flags,sRGBData *RGBData)
int CTexCache::ProcessTexture(const char *Filename,int Flags,sRGBData *RGBData)
{
int ListSize=TexList.size();

2
Utils/MapEdit/TexCache.h
View file

@ -43,7 +43,7 @@ public:
int GetTexIdx(sTex &Tex) {return(TexList.Find(Tex));}
int GetTexIdx(char *Filename,int Flags);
int ProcessTexture(char *Path,int Flags,sRGBData *RGBData=0);
int ProcessTexture(const char *Filename,int Flags,sRGBData *RGBData=0);
void Purge();
bool LoadBMP(char *Filename,sRGBData &RGBData);

46
Utils/MapEdit/TileSet.cpp
View file

@ -8,7 +8,7 @@
#include <gl\glu.h>
#include "GLEnabledView.h"
#include <Vector>
//#include <direct.h>
#include <GFName.hpp>
#include "Core.h"
@ -23,7 +23,7 @@
#include "LayerTileGui.h"
// Reserve slot 0 for collision :o)
char *ColFName="Collision.bmp";
GString ColFName="Collision.bmp";
/*****************************************************************************/
/*** TileBank ****************************************************************/
@ -124,7 +124,7 @@ GString FilePath;
// New Style rel storage
for (int i=0;i<ListSize;i++)
{
char c=1,FullName[256+64];
char c=1;//,FullName[256+64];
GString RelName;
int Len=0;
while (c)
@ -132,14 +132,14 @@ GString FilePath;
File->Read(&c,1);
RelName.Append(c);
}
RelName.Upper();
// RelName.Upper();
{ // Dodgy arse artist fix
RelName=FixName(RelName);
// RelName=FixName(RelName);
}
RootPath.makeabsolute(FilePath,RelName,FullName);
AddTileSet(FullName);
// RootPath.makeabsolute(FilePath,RelName,FullName);
AddTileSet(RelName);
}
}
@ -398,13 +398,14 @@ BOOL CTileBank::IsTileValid(int Set,int Tile)
}
/*****************************************************************************/
/*
BOOL CTileBank::IsTileValidGB(int Set,int Tile)
{
if (Set<0 || Tile<0) return(FALSE);
return(TileSet[Set].IsTileValidGB(Tile));
}
*/
/*****************************************************************************/
/*****************************************************************************/
/*** TileSet *****************************************************************/
@ -412,7 +413,10 @@ BOOL CTileBank::IsTileValidGB(int Set,int Tile)
/*****************************************************************************/
CTileSet::CTileSet(const char *_Filename,int Idx)
{
Filename=_Filename;
if (_Filename)
{
Filename=_Filename;
}
Loaded=FALSE;
SetNumber=Idx;
@ -450,8 +454,22 @@ GString Ext=Filename.Ext();
void CTileSet::Load2d(CCore *Core)
{
CTexCache &TexCache=Core->GetTexCache();
GString FullFilename;
GString ColTest;
ColTest=Filename.File();
ColTest.Append('.');
ColTest+=Filename.Ext();
int TexID=TexCache.ProcessTexture((char*)Filename.FullName(),0);
if (ColTest==ColFName)
{// Collision thing (sigh!)
FullFilename=Filename.FullName();
}
else
{
MakeFullFilename(Filename.FullName(),FullFilename);
}
int TexID=TexCache.ProcessTexture(FullFilename,0);
sTex &ThisTex=TexCache.GetTex(TexID);
int Width=ThisTex.TexWidth/16;
@ -475,8 +493,11 @@ int Height=ThisTex.TexHeight/16;
void CTileSet::Load3d(CCore *Core)
{
CScene Scene;
GString FullFilename;
Scene.Load(Filename.FullName());
MakeFullFilename(Filename.FullName(),FullFilename);
Scene.Load(FullFilename);
CNode &ThisNode=Scene.GetSceneNode(0);
int ChildCount=ThisNode.GetPruneChildCount();
@ -524,6 +545,7 @@ BOOL CTileSet::IsTileValid(int No)
}
/*****************************************************************************/
/*
BOOL CTileSet::IsTileValidGB(int No)
{
// ASSERT(No<Tile.size());
@ -531,7 +553,7 @@ BOOL CTileSet::IsTileValidGB(int No)
return(Tile[No].IsValidGB());
}
*/
/*****************************************************************************/
void CTileSet::Render(CCore *Core,Vector3 &CamPos,CMap &LBrush,CMap &RBrush,BOOL Render3d)
{

16
Utils/MapEdit/TileSet.h
View file

@ -64,7 +64,7 @@ public:
void UpdateGUI(CCore *Core,BOOL IsTileView);
BOOL IsTileValid(int Set,int Tile);
BOOL IsTileValidGB(int Set,int Tile);
// BOOL IsTileValidGB(int Set,int Tile);
void SetCollision(bool f);
CTileSet &GetSet(int Set) {return(TileSet[Set]);}
@ -109,11 +109,14 @@ public:
void Load2d(CCore *Core);
void Load3d(CCore *Core);
const char *GetDrive() {return(Filename.Drive());}
const char *GetPath() {return(Filename.Dir());}
const char *GetName() {return(Filename.File());}
const char *GetExt() {return(Filename.Ext());}
// const char *GetDrive() {return(Filename.Drive());}
// const char *GetPath() {return(Filename.Dir());}
// const char *GetName() {return(Filename.File());}
// const char *GetExt() {return(Filename.Ext());}
// const char *GetFilename() {return(Filename.FullName());}
const char *GetFilename() {return(Filename.FullName());}
const char *GetName() {return(Filename.File());}
CTile &GetTile(int No) {return(Tile[No]);}
void Purge();
@ -124,7 +127,7 @@ public:
void RenderGrid(Vector3 &CamPos);
int GetTileBrowserWidth() {return(TileBrowserWidth);}
BOOL IsTileValid(int No);
BOOL IsTileValidGB(int No);
// BOOL IsTileValidGB(int No);
private:
@ -132,6 +135,7 @@ private:
CPoint GetTilePos(int ID);
GFName Filename;
int SetNumber;
CList<CTile> Tile;
BOOL Loaded;

3
Utils/MapEdit/resource.h
View file

@ -46,8 +46,7 @@
#define ID_ACTIVEBRUSH_RIGHT 32791
#define ID_MAP_SETSIZE 32792
#define ID_2D_3D_TOGGLE 32794
#define ID_EXPORT_AGB 32795
#define ID_EXPORT_PSX 32796
#define ID_EXPORT 32795
#define ID_ZOOM_IN 32797
#define ID_ZOOM_OUT 32798
#define ID_INDICATOR_CURSORXY 59142

29
Utils/MapEdit/utils.cpp
View file

@ -3,12 +3,17 @@
/*************/
#include "stdafx.h"
#include "MapEdit.h"
#include "MapEditDoc.h"
#include <Vector3.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include "GLEnabledView.h"
#include <Misc.hpp>
#include <GFName.hpp>
#include "Utils.H"
/**************************************************************************************/
@ -249,3 +254,27 @@ char Name[_MAX_FNAME];
sprintf(OutName,"%s%s%s.%s",Drive,Path,Name,Ext);
}
/**************************************************************************************/
void MakeFullFilename(const char* In,GString &Out)
{
GFName FName=theApp.GetCurrent()->GetPathName();
GString Path;
Path=FName.Drive();
Path+=FName.Dir();
Path.Append('\\');
Out=Path;
Out+=In;
}
/**************************************************************************************/
void MakePathRel2App(const char* In,char *Out)
{
GString RootPath=theApp.GetCurrent()->GetPathName();
GFName::makerelative(RootPath,In,Out);
}

4
Utils/MapEdit/utils.h
View file

@ -31,6 +31,7 @@ typedef u32 U32;
//typedef u64 U64;
/**************************************************************************************/
class GString;
void DbgMsg(const char * pszFmt,...);
void BuildGLBox(float XMin,float XMax,float YMin,float YMax,float ZMin,float ZMax);
@ -47,5 +48,8 @@ void SaveBmp(char *Filename,int Width,int Height,RGBQUAD *Pal,u8 *Image);
void BGR2RGB(int W,int H,u8 *Data);
void SetFileExt(char *InName,char *OutName,char *Ext);
void MakeFullFilename(const char *RelName,GString &Out);
void MakePathRel2App(const char* In,char *Out);
#endif