src/game/editor/editor.h

   1 /* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
   2 /* If you are missing that file, acquire a complete release at teeworlds.com.                */
   3 #ifndef GAME_EDITOR_EDITOR_H
   4 #define GAME_EDITOR_EDITOR_H
   5
   6 #include <math.h>
   7
   8 #include <base/math.h>
   9 #include <base/system.h>
  10
  11 #include <base/tl/algorithm.h>
  12 #include <base/tl/array.h>
  13 #include <base/tl/sorted_array.h>
  14 #include <base/tl/string.h>
  15
  16 #include <game/client/ui.h>
  17 #include <game/mapitems.h>
  18 #include <game/client/render.h>
  19
  20 #include <engine/shared/config.h>
  21 #include <engine/shared/datafile.h>
  22 #include <engine/editor.h>
  23 #include <engine/graphics.h>
  24
  25 #include "auto_map.h"
  26
  27 typedef void (*INDEX_MODIFY_FUNC)(int *pIndex);
  28
  29 //CRenderTools m_RenderTools;
  30
  31 // CEditor SPECIFIC
  32 enum
  33 {
  34         MODE_LAYERS=0,
  35         MODE_IMAGES,
  36
  37         DIALOG_NONE=0,
  38         DIALOG_FILE,
  39 };
  40
  41 struct CEntity
  42 {
  43         CPoint m_Position;
  44         int m_Type;
  45 };
  46
  47 class CEnvelope
  48 {
  49 public:
  50         int m_Channels;
  51         array<CEnvPoint> m_lPoints;
  52         char m_aName[32];
  53         float m_Bottom, m_Top;
  54
  55         CEnvelope(int Chan)
  56         {
  57                 m_Channels = Chan;
  58                 m_aName[0] = 0;
  59                 m_Bottom = 0;
  60                 m_Top = 0;
  61         }
  62
  63         void Resort()
  64         {
  65                 sort(m_lPoints.all());
  66                 FindTopBottom(0xf);
  67         }
  68
  69         void FindTopBottom(int ChannelMask)
  70         {
  71                 m_Top = -1000000000.0f;
  72                 m_Bottom = 1000000000.0f;
  73                 for(int i = 0; i < m_lPoints.size(); i++)
  74                 {
  75                         for(int c = 0; c < m_Channels; c++)
  76                         {
  77                                 if(ChannelMask&(1<<c))
  78                                 {
  79                                         float v = fx2f(m_lPoints[i].m_aValues[c]);
  80                                         if(v > m_Top) m_Top = v;
  81                                         if(v < m_Bottom) m_Bottom = v;
  82                                 }
  83                         }
  84                 }
  85         }
  86
  87         int Eval(float Time, float *pResult)
  88         {
  89                 CRenderTools::RenderEvalEnvelope(m_lPoints.base_ptr(), m_lPoints.size(), m_Channels, Time, pResult);
  90                 return m_Channels;
  91         }
  92
  93         void AddPoint(int Time, int v0, int v1=0, int v2=0, int v3=0)
  94         {
  95                 CEnvPoint p;
  96                 p.m_Time = Time;
  97                 p.m_aValues[0] = v0;
  98                 p.m_aValues[1] = v1;
  99                 p.m_aValues[2] = v2;
 100                 p.m_aValues[3] = v3;
 101                 p.m_Curvetype = CURVETYPE_LINEAR;
 102                 m_lPoints.add(p);
 103                 Resort();
 104         }
 105
 106         float EndTime()
 107         {
 108                 if(m_lPoints.size())
 109                         return m_lPoints[m_lPoints.size()-1].m_Time*(1.0f/1000.0f);
 110                 return 0;
 111         }
 112 };
 113
 114
 115 class CLayer;
 116 class CLayerGroup;
 117 class CEditorMap;
 118
 119 class CLayer
 120 {
 121 public:
 122         class CEditor *m_pEditor;
 123         class IGraphics *Graphics();
 124         class ITextRender *TextRender();
 125
 126         CLayer()
 127         {
 128                 m_Type = LAYERTYPE_INVALID;
 129                 str_copy(m_aName, "(invalid)", sizeof(m_aName));
 130                 m_Visible = true;
 131                 m_Readonly = false;
 132                 m_SaveToMap = true;
 133                 m_Flags = 0;
 134                 m_pEditor = 0;
 135         }
 136
 137         virtual ~CLayer()
 138         {
 139         }
 140
 141
 142         virtual void BrushSelecting(CUIRect Rect) {}
 143         virtual int BrushGrab(CLayerGroup *pBrush, CUIRect Rect) { return 0; }
 144         virtual void FillSelection(bool Empty, CLayer *pBrush, CUIRect Rect) {}
 145         virtual void BrushDraw(CLayer *pBrush, float x, float y) {}
 146         virtual void BrushPlace(CLayer *pBrush, float x, float y) {}
 147         virtual void BrushFlipX() {}
 148         virtual void BrushFlipY() {}
 149         virtual void BrushRotate(float Amount) {}
 150
 151         virtual void Render() {}
 152         virtual int RenderProperties(CUIRect *pToolbox) { return 0; }
 153
 154         virtual void ModifyImageIndex(INDEX_MODIFY_FUNC pfnFunc) {}
 155         virtual void ModifyEnvelopeIndex(INDEX_MODIFY_FUNC pfnFunc) {}
 156
 157         virtual void GetSize(float *w, float *h) { *w = 0; *h = 0;}
 158
 159         char m_aName[12];
 160         int m_Type;
 161         int m_Flags;
 162
 163         bool m_Readonly;
 164         bool m_Visible;
 165         bool m_SaveToMap;
 166 };
 167
 168 class CLayerGroup
 169 {
 170 public:
 171         class CEditorMap *m_pMap;
 172
 173         array<CLayer*> m_lLayers;
 174
 175         int m_OffsetX;
 176         int m_OffsetY;
 177
 178         int m_ParallaxX;
 179         int m_ParallaxY;
 180
 181         int m_UseClipping;
 182         int m_ClipX;
 183         int m_ClipY;
 184         int m_ClipW;
 185         int m_ClipH;
 186
 187         char m_aName[12];
 188         bool m_GameGroup;
 189         bool m_Visible;
 190         bool m_SaveToMap;
 191         bool m_Collapse;
 192
 193         CLayerGroup();
 194         ~CLayerGroup();
 195
 196         void Convert(CUIRect *pRect);
 197         void Render();
 198         void MapScreen();
 199         void Mapping(float *pPoints);
 200
 201         void GetSize(float *w, float *h);
 202
 203         void DeleteLayer(int Index);
 204         int SwapLayers(int Index0, int Index1);
 205
 206         bool IsEmpty() const
 207         {
 208                 return m_lLayers.size() == 0;
 209         }
 210
 211         void Clear()
 212         {
 213                 m_lLayers.delete_all();
 214         }
 215
 216         void AddLayer(CLayer *l);
 217
 218         void ModifyImageIndex(INDEX_MODIFY_FUNC Func)
 219         {
 220                 for(int i = 0; i < m_lLayers.size(); i++)
 221                         m_lLayers[i]->ModifyImageIndex(Func);
 222         }
 223
 224         void ModifyEnvelopeIndex(INDEX_MODIFY_FUNC Func)
 225         {
 226                 for(int i = 0; i < m_lLayers.size(); i++)
 227                         m_lLayers[i]->ModifyEnvelopeIndex(Func);
 228         }
 229 };
 230
 231 class CEditorImage : public CImageInfo
 232 {
 233 public:
 234         CEditor *m_pEditor;
 235
 236         CEditorImage(CEditor *pEditor)
 237         : m_AutoMapper(pEditor)
 238         {
 239                 m_pEditor = pEditor;
 240                 m_TexID = -1;
 241                 m_aName[0] = 0;
 242                 m_External = 0;
 243                 m_Width = 0;
 244                 m_Height = 0;
 245                 m_pData = 0;
 246                 m_Format = 0;
 247         }
 248
 249         ~CEditorImage();
 250
 251         void AnalyseTileFlags();
 252
 253         int m_TexID;
 254         int m_External;
 255         char m_aName[128];
 256         unsigned char m_aTileFlags[256];
 257         class CAutoMapper m_AutoMapper;
 258 };
 259
 260 class CEditorMap
 261 {
 262         void MakeGameGroup(CLayerGroup *pGroup);
 263         void MakeGameLayer(CLayer *pLayer);
 264 public:
 265         CEditor *m_pEditor;
 266         bool m_Modified;
 267
 268         CEditorMap()
 269         {
 270                 Clean();
 271         }
 272
 273         array<CLayerGroup*> m_lGroups;
 274         array<CEditorImage*> m_lImages;
 275         array<CEnvelope*> m_lEnvelopes;
 276
 277         class CLayerGame *m_pGameLayer;
 278         CLayerGroup *m_pGameGroup;
 279
 280         CEnvelope *NewEnvelope(int Channels)
 281         {
 282                 m_Modified = true;
 283                 CEnvelope *e = new CEnvelope(Channels);
 284                 m_lEnvelopes.add(e);
 285                 return e;
 286         }
 287
 288         void DeleteEnvelope(int Index);
 289
 290         CLayerGroup *NewGroup()
 291         {
 292                 m_Modified = true;
 293                 CLayerGroup *g = new CLayerGroup;
 294                 g->m_pMap = this;
 295                 m_lGroups.add(g);
 296                 return g;
 297         }
 298
 299         int SwapGroups(int Index0, int Index1)
 300         {
 301                 if(Index0 < 0 || Index0 >= m_lGroups.size()) return Index0;
 302                 if(Index1 < 0 || Index1 >= m_lGroups.size()) return Index0;
 303                 if(Index0 == Index1) return Index0;
 304                 m_Modified = true;
 305                 swap(m_lGroups[Index0], m_lGroups[Index1]);
 306                 return Index1;
 307         }
 308
 309         void DeleteGroup(int Index)
 310         {
 311                 if(Index < 0 || Index >= m_lGroups.size()) return;
 312                 m_Modified = true;
 313                 delete m_lGroups[Index];
 314                 m_lGroups.remove_index(Index);
 315         }
 316
 317         void ModifyImageIndex(INDEX_MODIFY_FUNC pfnFunc)
 318         {
 319                 m_Modified = true;
 320                 for(int i = 0; i < m_lGroups.size(); i++)
 321                         m_lGroups[i]->ModifyImageIndex(pfnFunc);
 322         }
 323
 324         void ModifyEnvelopeIndex(INDEX_MODIFY_FUNC pfnFunc)
 325         {
 326                 m_Modified = true;
 327                 for(int i = 0; i < m_lGroups.size(); i++)
 328                         m_lGroups[i]->ModifyEnvelopeIndex(pfnFunc);
 329         }
 330
 331         void Clean();
 332         void CreateDefault(int EntitiesTexture);
 333
 334         // io
 335         int Save(class IStorage *pStorage, const char *pFilename);
 336         int Load(class IStorage *pStorage, const char *pFilename, int StorageType);
 337 };
 338
 339
 340 struct CProperty
 341 {
 342         const char *m_pName;
 343         int m_Value;
 344         int m_Type;
 345         int m_Min;
 346         int m_Max;
 347 };
 348
 349 enum
 350 {
 351         PROPTYPE_NULL=0,
 352         PROPTYPE_BOOL,
 353         PROPTYPE_INT_STEP,
 354         PROPTYPE_INT_SCROLL,
 355         PROPTYPE_COLOR,
 356         PROPTYPE_IMAGE,
 357         PROPTYPE_ENVELOPE,
 358         PROPTYPE_SHIFT,
 359 };
 360
 361 typedef struct
 362 {
 363         int x, y;
 364         int w, h;
 365 } RECTi;
 366
 367 class CLayerTiles : public CLayer
 368 {
 369 public:
 370         CLayerTiles(int w, int h);
 371         ~CLayerTiles();
 372
 373         void Resize(int NewW, int NewH);
 374         void Shift(int Direction);
 375
 376         void MakePalette();
 377         virtual void Render();
 378
 379         int ConvertX(float x) const;
 380         int ConvertY(float y) const;
 381         void Convert(CUIRect Rect, RECTi *pOut);
 382         void Snap(CUIRect *pRect);
 383         void Clamp(RECTi *pRect);
 384
 385         virtual void BrushSelecting(CUIRect Rect);
 386         virtual int BrushGrab(CLayerGroup *pBrush, CUIRect Rect);
 387         virtual void FillSelection(bool Empty, CLayer *pBrush, CUIRect Rect);
 388         virtual void BrushDraw(CLayer *pBrush, float wx, float wy);
 389         virtual void BrushFlipX();
 390         virtual void BrushFlipY();
 391         virtual void BrushRotate(float Amount);
 392
 393         virtual void ShowInfo();
 394         virtual int RenderProperties(CUIRect *pToolbox);
 395
 396         virtual void ModifyImageIndex(INDEX_MODIFY_FUNC pfnFunc);
 397         virtual void ModifyEnvelopeIndex(INDEX_MODIFY_FUNC pfnFunc);
 398
 399         void PrepareForSave();
 400
 401         void GetSize(float *w, float *h) { *w = m_Width*32.0f; *h = m_Height*32.0f; }
 402
 403         int m_TexID;
 404         int m_Game;
 405         int m_Image;
 406         int m_Width;
 407         int m_Height;
 408         CColor m_Color;
 409         int m_ColorEnv;
 410         int m_ColorEnvOffset;
 411         CTile *m_pTiles;
 412 };
 413
 414 class CLayerQuads : public CLayer
 415 {
 416 public:
 417         CLayerQuads();
 418         ~CLayerQuads();
 419
 420         virtual void Render();
 421         CQuad *NewQuad();
 422
 423         virtual void BrushSelecting(CUIRect Rect);
 424         virtual int BrushGrab(CLayerGroup *pBrush, CUIRect Rect);
 425         virtual void BrushPlace(CLayer *pBrush, float wx, float wy);
 426         virtual void BrushFlipX();
 427         virtual void BrushFlipY();
 428         virtual void BrushRotate(float Amount);
 429
 430         virtual int RenderProperties(CUIRect *pToolbox);
 431
 432         virtual void ModifyImageIndex(INDEX_MODIFY_FUNC pfnFunc);
 433         virtual void ModifyEnvelopeIndex(INDEX_MODIFY_FUNC pfnFunc);
 434
 435         void GetSize(float *w, float *h);
 436
 437         int m_Image;
 438         array<CQuad> m_lQuads;
 439 };
 440
 441 class CLayerGame : public CLayerTiles
 442 {
 443 public:
 444         CLayerGame(int w, int h);
 445         ~CLayerGame();
 446
 447         virtual int RenderProperties(CUIRect *pToolbox);
 448 };
 449
 450 class CEditor : public IEditor
 451 {
 452         class IInput *m_pInput;
 453         class IClient *m_pClient;
 454         class IConsole *m_pConsole;
 455         class IGraphics *m_pGraphics;
 456         class ITextRender *m_pTextRender;
 457         class IStorage *m_pStorage;
 458         CRenderTools m_RenderTools;
 459         CUI m_UI;
 460 public:
 461         class IInput *Input() { return m_pInput; };
 462         class IClient *Client() { return m_pClient; };
 463         class IConsole *Console() { return m_pConsole; };
 464         class IGraphics *Graphics() { return m_pGraphics; };
 465         class ITextRender *TextRender() { return m_pTextRender; };
 466         class IStorage *Storage() { return m_pStorage; };
 467         CUI *UI() { return &m_UI; }
 468         CRenderTools *RenderTools() { return &m_RenderTools; }
 469
 470         CEditor() : m_TilesetPicker(16, 16)
 471         {
 472                 m_pInput = 0;
 473                 m_pClient = 0;
 474                 m_pGraphics = 0;
 475                 m_pTextRender = 0;
 476
 477                 m_Mode = MODE_LAYERS;
 478                 m_Dialog = 0;
 479                 m_pTooltip = 0;
 480
 481                 m_GridActive = false;
 482                 m_GridFactor = 1;
 483
 484                 m_aFileName[0] = 0;
 485                 m_aFileSaveName[0] = 0;
 486                 m_ValidSaveFilename = false;
 487
 488                 m_PopupEventActivated = false;
 489
 490                 m_FileDialogStorageType = 0;
 491                 m_pFileDialogTitle = 0;
 492                 m_pFileDialogButtonText = 0;
 493                 m_pFileDialogUser = 0;
 494                 m_aFileDialogFileName[0] = 0;
 495                 m_aFileDialogCurrentFolder[0] = 0;
 496                 m_aFileDialogCurrentLink[0] = 0;
 497                 m_pFileDialogPath = m_aFileDialogCurrentFolder;
 498                 m_aFileDialogActivate = false;
 499                 m_FileDialogScrollValue = 0.0f;
 500                 m_FilesSelectedIndex = -1;
 501                 m_FilesStartAt = 0;
 502                 m_FilesCur = 0;
 503                 m_FilesStopAt = 999;
 504
 505                 m_WorldOffsetX = 0;
 506                 m_WorldOffsetY = 0;
 507                 m_EditorOffsetX = 0.0f;
 508                 m_EditorOffsetY = 0.0f;
 509
 510                 m_WorldZoom = 1.0f;
 511                 m_ZoomLevel = 200;
 512                 m_LockMouse = false;
 513                 m_ShowMousePointer = true;
 514                 m_MouseDeltaX = 0;
 515                 m_MouseDeltaY = 0;
 516                 m_MouseDeltaWx = 0;
 517                 m_MouseDeltaWy = 0;
 518
 519                 m_GuiActive = true;
 520                 m_ProofBorders = false;
 521
 522                 m_ShowTileInfo = false;
 523                 m_ShowDetail = true;
 524                 m_Animate = false;
 525                 m_AnimateStart = 0;
 526                 m_AnimateTime = 0;
 527                 m_AnimateSpeed = 1;
 528
 529                 m_ShowEnvelopeEditor = 0;
 530
 531                 ms_CheckerTexture = 0;
 532                 ms_BackgroundTexture = 0;
 533                 ms_CursorTexture = 0;
 534                 ms_EntitiesTexture = 0;
 535
 536                 ms_pUiGotContext = 0;
 537         }
 538
 539         virtual void Init();
 540         virtual void UpdateAndRender();
 541         virtual bool HasUnsavedData() { return m_Map.m_Modified; }
 542
 543         void FilelistPopulate(int StorageType);
 544         void InvokeFileDialog(int StorageType, int FileType, const char *pTitle, const char *pButtonText,
 545                 const char *pBasepath, const char *pDefaultName,
 546                 void (*pfnFunc)(const char *pFilename, int StorageType, void *pUser), void *pUser);
 547
 548         void Reset(bool CreateDefault=true);
 549         int Save(const char *pFilename);
 550         int Load(const char *pFilename, int StorageType);
 551         int Append(const char *pFilename, int StorageType);
 552         void Render();
 553
 554         CQuad *GetSelectedQuad();
 555         CLayer *GetSelectedLayerType(int Index, int Type);
 556         CLayer *GetSelectedLayer(int Index);
 557         CLayerGroup *GetSelectedGroup();
 558
 559         int DoProperties(CUIRect *pToolbox, CProperty *pProps, int *pIDs, int *pNewVal);
 560
 561         int m_Mode;
 562         int m_Dialog;
 563         const char *m_pTooltip;
 564
 565         bool m_GridActive;
 566         int m_GridFactor;
 567
 568         char m_aFileName[512];
 569         char m_aFileSaveName[512];
 570         bool m_ValidSaveFilename;
 571
 572         enum
 573         {
 574                 POPEVENT_EXIT=0,
 575                 POPEVENT_LOAD,
 576                 POPEVENT_NEW,
 577                 POPEVENT_SAVE,
 578         };
 579
 580         int m_PopupEventType;
 581         int m_PopupEventActivated;
 582
 583         enum
 584         {
 585                 FILETYPE_MAP,
 586                 FILETYPE_IMG,
 587
 588                 MAX_PATH_LENGTH = 512
 589         };
 590
 591         int m_FileDialogStorageType;
 592         const char *m_pFileDialogTitle;
 593         const char *m_pFileDialogButtonText;
 594         void (*m_pfnFileDialogFunc)(const char *pFileName, int StorageType, void *pUser);
 595         void *m_pFileDialogUser;
 596         char m_aFileDialogFileName[MAX_PATH_LENGTH];
 597         char m_aFileDialogCurrentFolder[MAX_PATH_LENGTH];
 598         char m_aFileDialogCurrentLink[MAX_PATH_LENGTH];
 599         char *m_pFileDialogPath;
 600         bool m_aFileDialogActivate;
 601         int m_FileDialogFileType;
 602         float m_FileDialogScrollValue;
 603         int m_FilesSelectedIndex;
 604         char m_FileDialogNewFolderName[64];
 605         char m_FileDialogErrString[64];
 606
 607         struct CFilelistItem
 608         {
 609                 char m_aFilename[128];
 610                 char m_aName[128];
 611                 bool m_IsDir;
 612                 bool m_IsLink;
 613                 int m_StorageType;
 614
 615                 bool operator<(const CFilelistItem &Other) { return !str_comp(m_aFilename, "..") ? true : !str_comp(Other.m_aFilename, "..") ? false :
 616                                                                                                                 m_IsDir && !Other.m_IsDir ? true : !m_IsDir && Other.m_IsDir ? false :
 617                                                                                                                 str_comp_filenames(m_aFilename, Other.m_aFilename) < 0; }
 618         };
 619         sorted_array<CFilelistItem> m_FileList;
 620         int m_FilesStartAt;
 621         int m_FilesCur;
 622         int m_FilesStopAt;
 623
 624         float m_WorldOffsetX;
 625         float m_WorldOffsetY;
 626         float m_EditorOffsetX;
 627         float m_EditorOffsetY;
 628         float m_WorldZoom;
 629         int m_ZoomLevel;
 630         bool m_LockMouse;
 631         bool m_ShowMousePointer;
 632         bool m_GuiActive;
 633         bool m_ProofBorders;
 634         float m_MouseDeltaX;
 635         float m_MouseDeltaY;
 636         float m_MouseDeltaWx;
 637         float m_MouseDeltaWy;
 638
 639         bool m_ShowTileInfo;
 640         bool m_ShowDetail;
 641         bool m_Animate;
 642         int64 m_AnimateStart;
 643         float m_AnimateTime;
 644         float m_AnimateSpeed;
 645
 646         int m_ShowEnvelopeEditor;
 647         bool m_ShowPicker;
 648
 649         int m_SelectedLayer;
 650         int m_SelectedGroup;
 651         int m_SelectedQuad;
 652         int m_SelectedPoints;
 653         int m_SelectedEnvelope;
 654         int m_SelectedImage;
 655
 656         static int ms_CheckerTexture;
 657         static int ms_BackgroundTexture;
 658         static int ms_CursorTexture;
 659         static int ms_EntitiesTexture;
 660
 661         CLayerGroup m_Brush;
 662         CLayerTiles m_TilesetPicker;
 663
 664         static const void *ms_pUiGotContext;
 665
 666         CEditorMap m_Map;
 667
 668         static void EnvelopeEval(float TimeOffset, int Env, float *pChannels, void *pUser);
 669
 670         void DoMapBorder();
 671         int DoButton_Editor_Common(const void *pID, const char *pText, int Checked, const CUIRect *pRect, int Flags, const char *pToolTip);
 672         int DoButton_Editor(const void *pID, const char *pText, int Checked, const CUIRect *pRect, int Flags, const char *pToolTip);
 673
 674         int DoButton_Tab(const void *pID, const char *pText, int Checked, const CUIRect *pRect, int Flags, const char *pToolTip);
 675         int DoButton_Ex(const void *pID, const char *pText, int Checked, const CUIRect *pRect, int Flags, const char *pToolTip, int Corners, float FontSize=10.0f);
 676         int DoButton_ButtonDec(const void *pID, const char *pText, int Checked, const CUIRect *pRect, int Flags, const char *pToolTip);
 677         int DoButton_ButtonInc(const void *pID, const char *pText, int Checked, const CUIRect *pRect, int Flags, const char *pToolTip);
 678
 679         int DoButton_File(const void *pID, const char *pText, int Checked, const CUIRect *pRect, int Flags, const char *pToolTip);
 680
 681         int DoButton_Menu(const void *pID, const char *pText, int Checked, const CUIRect *pRect, int Flags, const char *pToolTip);
 682         int DoButton_MenuItem(const void *pID, const char *pText, int Checked, const CUIRect *pRect, int Flags=0, const char *pToolTip=0);
 683
 684         int DoEditBox(void *pID, const CUIRect *pRect, char *pStr, unsigned StrSize, float FontSize, float *Offset, bool Hidden=false, int Corners=CUI::CORNER_ALL);
 685
 686         void RenderBackground(CUIRect View, int Texture, float Size, float Brightness);
 687
 688         void RenderGrid(CLayerGroup *pGroup);
 689
 690         void UiInvokePopupMenu(void *pID, int Flags, float X, float Y, float W, float H, int (*pfnFunc)(CEditor *pEditor, CUIRect Rect), void *pExtra=0);
 691         void UiDoPopupMenu();
 692
 693         int UiDoValueSelector(void *pID, CUIRect *pRect, const char *pLabel, int Current, int Min, int Max, int Step, float Scale, const char *pToolTip);
 694
 695         static int PopupGroup(CEditor *pEditor, CUIRect View);
 696         static int PopupLayer(CEditor *pEditor, CUIRect View);
 697         static int PopupQuad(CEditor *pEditor, CUIRect View);
 698         static int PopupPoint(CEditor *pEditor, CUIRect View);
 699         static int PopupNewFolder(CEditor *pEditor, CUIRect View);
 700         static int PopupEvent(CEditor *pEditor, CUIRect View);
 701         static int PopupSelectImage(CEditor *pEditor, CUIRect View);
 702         static int PopupSelectGametileOp(CEditor *pEditor, CUIRect View);
 703         static int PopupImage(CEditor *pEditor, CUIRect View);
 704         static int PopupMenuFile(CEditor *pEditor, CUIRect View);
 705         static int PopupSelectConfigAutoMap(CEditor *pEditor, CUIRect View);
 706
 707         static void CallbackOpenMap(const char *pFileName, int StorageType, void *pUser);
 708         static void CallbackAppendMap(const char *pFileName, int StorageType, void *pUser);
 709         static void CallbackSaveMap(const char *pFileName, int StorageType, void *pUser);
 710
 711         void PopupSelectImageInvoke(int Current, float x, float y);
 712         int PopupSelectImageResult();
 713
 714         void PopupSelectGametileOpInvoke(float x, float y);
 715         int PopupSelectGameTileOpResult();
 716
 717         void PopupSelectConfigAutoMapInvoke(float x, float y);
 718         int PopupSelectConfigAutoMapResult();
 719
 720         vec4 ButtonColorMul(const void *pID);
 721
 722         void DoQuadPoint(CQuad *pQuad, int QuadIndex, int v);
 723         void DoMapEditor(CUIRect View, CUIRect Toolbar);
 724         void DoToolbar(CUIRect Toolbar);
 725         void DoQuad(CQuad *pQuad, int Index);
 726         float UiDoScrollbarV(const void *pID, const CUIRect *pRect, float Current);
 727         vec4 GetButtonColor(const void *pID, int Checked);
 728
 729         static void ReplaceImage(const char *pFilename, int StorageType, void *pUser);
 730         static void AddImage(const char *pFilename, int StorageType, void *pUser);
 731
 732         void RenderImages(CUIRect Toolbox, CUIRect Toolbar, CUIRect View);
 733         void RenderLayers(CUIRect Toolbox, CUIRect Toolbar, CUIRect View);
 734         void RenderModebar(CUIRect View);
 735         void RenderStatusbar(CUIRect View);
 736         void RenderEnvelopeEditor(CUIRect View);
 737
 738         void RenderMenubar(CUIRect Menubar);
 739         void RenderFileDialog();
 740
 741         void AddFileDialogEntry(int Index, CUIRect *pView);
 742         void SortImages();
 743         static void ExtractName(const char *pFileName, char *pName, int BufferSize)
 744         {
 745                 const char *pExtractedName = pFileName;
 746                 const char *pEnd = 0;
 747                 for(; *pFileName; ++pFileName)
 748                 {
 749                         if(*pFileName == '/' || *pFileName == '\\')
 750                                 pExtractedName = pFileName+1;
 751                         else if(*pFileName == '.')
 752                                 pEnd = pFileName;
 753                 }
 754
 755                 int Length = pEnd > pExtractedName ? min(BufferSize, (int)(pEnd-pExtractedName+1)) : BufferSize;
 756                 str_copy(pName, pExtractedName, Length);
 757         }
 758
 759         int GetLineDistance();
 760 };
 761
 762 // make sure to inline this function
 763 inline class IGraphics *CLayer::Graphics() { return m_pEditor->Graphics(); }
 764 inline class ITextRender *CLayer::TextRender() { return m_pEditor->TextRender(); }
 765
 766 #endif