LCOV - code coverage report
Current view: top level - source/tools/atlas/GameInterface - Messages.h (source / functions) Hit Total Coverage
Test: 0 A.D. test coverage report Lines: 0 120 0.0 %
Date: 2023-01-19 00:18:29 Functions: 0 55 0.0 %

          Line data    Source code
       1             : /* Copyright (C) 2022 Wildfire Games.
       2             :  * This file is part of 0 A.D.
       3             :  *
       4             :  * 0 A.D. is free software: you can redistribute it and/or modify
       5             :  * it under the terms of the GNU General Public License as published by
       6             :  * the Free Software Foundation, either version 2 of the License, or
       7             :  * (at your option) any later version.
       8             :  *
       9             :  * 0 A.D. is distributed in the hope that it will be useful,
      10             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      12             :  * GNU General Public License for more details.
      13             :  *
      14             :  * You should have received a copy of the GNU General Public License
      15             :  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
      16             :  */
      17             : 
      18             : #ifndef INCLUDED_MESSAGES
      19             : #define INCLUDED_MESSAGES
      20             : 
      21             : #ifndef MESSAGES_SKIP_SETUP
      22             : #include "MessagesSetup.h"
      23             : #endif
      24             : 
      25             : #include <vector>
      26             : #include <string>
      27             : 
      28             : // TODO: organisation, documentation, etc
      29             : 
      30             : #ifdef _MSC_VER // (can't use MSC_VERSION here since this file is included by Atlas too)
      31             : #pragma warning(push)
      32             : #pragma warning(disable: 4003)
      33             : #endif
      34             : 
      35             : //////////////////////////////////////////////////////////////////////////
      36             : 
      37             : // Initialise some engine code. Must be called before anything else.
      38           0 : MESSAGE(Init, );
      39             : 
      40           0 : MESSAGE(InitAppWindow,
      41             :         ((void*, handle)) // Atlas Window handle.
      42             :         );
      43             : 
      44             : // Initialise SDL-related code. Must be called before SetCanvas and InitGraphics.
      45           0 : MESSAGE(InitSDL, );
      46             : 
      47             : // Initialise graphics-related code. Must be called after the first SetCanvas,
      48             : // and before much else.
      49           0 : MESSAGE(InitGraphics, );
      50             : 
      51             : // Shut down engine/graphics code.
      52           0 : MESSAGE(Shutdown, );
      53             : 
      54             : struct eRenderView { enum renderViews { NONE, GAME, ACTOR }; };
      55             : 
      56           0 : MESSAGE(RenderEnable,
      57             :         ((int, view)) // eRenderView
      58             :         );
      59             : 
      60             : // SetViewParam: used for hints to the renderer, e.g. to set wireframe mode;
      61             : // unrecognised param names are ignored
      62           0 : MESSAGE(SetViewParamB,
      63             :         ((int, view)) // eRenderView
      64             :         ((std::wstring, name))
      65             :         ((bool, value))
      66             :         );
      67           0 : MESSAGE(SetViewParamI,
      68             :         ((int, view)) // eRenderView
      69             :         ((std::wstring, name))
      70             :         ((int, value))
      71             :         );
      72           0 : MESSAGE(SetViewParamC,
      73             :         ((int, view)) // eRenderView
      74             :         ((std::wstring, name))
      75             :         ((Color, value))
      76             :         );
      77           0 : MESSAGE(SetViewParamS,
      78             :         ((int, view)) // eRenderView
      79             :         ((std::wstring, name))
      80             :         ((std::wstring, value))
      81             :         );
      82             : 
      83           0 : MESSAGE(JavaScript,
      84             :         ((std::string, command))
      85             :         );
      86             : 
      87             : //////////////////////////////////////////////////////////////////////////
      88             : 
      89           0 : MESSAGE(GuiSwitchPage,
      90             :         ((std::wstring, page))
      91             :         );
      92             : 
      93           0 : MESSAGE(GuiMouseButtonEvent,
      94             :         ((int, button))
      95             :         ((bool, pressed))
      96             :         ((Position, pos))
      97             :         ((int, clicks))
      98             :         );
      99             : 
     100           0 : MESSAGE(GuiMouseMotionEvent,
     101             :         ((Position, pos))
     102             :         );
     103             : 
     104           0 : MESSAGE(GuiKeyEvent,
     105             :         ((int, sdlkey)) // SDLKey code
     106             :         ((int, unichar)) // Unicode character
     107             :         ((bool, pressed))
     108             :         );
     109             : 
     110           0 : MESSAGE(GuiCharEvent,
     111             :         ((int, sdlkey))
     112             :         ((int, unichar))
     113             :         );
     114             : 
     115             : //////////////////////////////////////////////////////////////////////////
     116             : 
     117           0 : MESSAGE(SimStopMusic, );
     118             : 
     119           0 : MESSAGE(SimStateSave,
     120             :         ((std::wstring, label)) // named slot to store saved data
     121             :         );
     122             : 
     123           0 : MESSAGE(SimStateRestore,
     124             :         ((std::wstring, label)) // named slot to find saved data
     125             :         );
     126             : 
     127           0 : QUERY(SimStateDebugDump,
     128             :         ((bool, binary))
     129             :         ,
     130             :         ((std::wstring, dump))
     131             :         );
     132             : 
     133           0 : MESSAGE(SimPlay,
     134             :         ((float, speed)) // 0 for pause, 1 for normal speed
     135             :         ((bool, simTest)) // true if we're in simulation test mode, false otherwise
     136             :         );
     137             : 
     138             : //////////////////////////////////////////////////////////////////////////
     139             : 
     140           0 : QUERY(Ping, , );
     141             : 
     142             : //////////////////////////////////////////////////////////////////////////
     143             : 
     144           0 : MESSAGE(SetCanvas,
     145             :         ((void*, canvas))
     146             :         ((int, width))
     147             :         ((int, height))
     148             :         );
     149             : 
     150           0 : MESSAGE(ResizeScreen,
     151             :         ((int, width))
     152             :         ((int, height))
     153             :         );
     154             : 
     155           0 : QUERY(RenderLoop, ,
     156             :       ((bool, wantHighFPS))
     157             :       ((double, timeSinceActivity))
     158             :       );
     159             : 
     160             : //////////////////////////////////////////////////////////////////////////
     161             : // Messages for map panel
     162             : 
     163           0 : QUERY(GenerateMap,
     164             :         ((std::wstring, filename))              // random map script filename
     165             :         ((std::string, settings))               // map settings as JSON string
     166             :         ,
     167             :         ((int, status))
     168             :         );
     169             : 
     170           0 : MESSAGE(ImportHeightmap,
     171             :         ((std::wstring, filename))
     172             :         );
     173             : 
     174           0 : MESSAGE(LoadMap,
     175             :         ((std::wstring, filename))
     176             :         );
     177             : 
     178           0 : MESSAGE(SaveMap,
     179             :         ((std::wstring, filename))
     180             :         );
     181             : 
     182           0 : QUERY(GetMapList,
     183             :         ,
     184             :         ((std::vector<std::wstring>, scenarioFilenames))
     185             :         ((std::vector<std::wstring>, skirmishFilenames))
     186             :         ((std::vector<std::wstring>, tutorialFilenames))
     187             :         );
     188             : 
     189           0 : QUERY(GetMapSettings,
     190             :         ,
     191             :         ((std::string, settings))
     192             :         );
     193             : 
     194           0 : COMMAND(SetMapSettings, MERGE,
     195             :         ((std::string, settings))
     196             :         );
     197             : 
     198           0 : MESSAGE(LoadPlayerSettings,
     199             :         ((bool, newplayers))
     200             :         );
     201             : 
     202           0 : QUERY(GetMapSizes,
     203             :         ,
     204             :         ((std::string, sizes))
     205             :         );
     206             : 
     207           0 : QUERY(GetCurrentMapSize,
     208             :         ,
     209             :         ((int, size))
     210             :         );
     211             : 
     212           0 : QUERY(RasterizeMinimap,
     213             :         ,
     214             :         ((int, dimension))
     215             :         ((std::vector<uint8_t>, imageBytes))
     216             :         );
     217             : 
     218           0 : QUERY(GetRMSData,
     219             :         ,
     220             :         ((std::vector<std::string>, data))
     221             :         );
     222             : 
     223           0 : COMMAND(ResizeMap, NOMERGE,
     224             :         ((int, tiles))
     225             :         ((int, offsetX))
     226             :         ((int, offsetY))
     227             :         );
     228             : 
     229           0 : QUERY(VFSFileExists,
     230             :         ((std::wstring, path))
     231             :         ,
     232             :         ((bool, exists))
     233             :         );
     234             : 
     235           0 : QUERY(VFSFileRealPath,
     236             :         ((std::wstring, path))
     237             :         ,
     238             :         ((std::wstring, realPath))
     239             :         );
     240             : 
     241             : //////////////////////////////////////////////////////////////////////////
     242             : // Messages for player panel
     243             : 
     244           0 : QUERY(GetCivData,
     245             :         ,
     246             :         ((std::vector<std::vector<std::wstring>>, data))
     247             :         );
     248             : 
     249           0 : QUERY(GetVictoryConditionData,
     250             :         ,
     251             :         ((std::vector<std::string>, data))
     252             :         );
     253             : 
     254           0 : QUERY(GetPlayerDefaults,
     255             :         ,
     256             :         ((std::string, defaults))
     257             :         );
     258             : 
     259           0 : QUERY(GetAIData,
     260             :         ,
     261             :         ((std::string, data))
     262             :         );
     263             : 
     264             : //////////////////////////////////////////////////////////////////////////
     265             : 
     266           0 : MESSAGE(RenderStyle,
     267             :         ((bool, wireframe))
     268             :         );
     269             : 
     270           0 : MESSAGE(MessageTrace,
     271             :         ((bool, enable))
     272             :         );
     273             : 
     274           0 : MESSAGE(Screenshot,
     275             :         ((bool, big))
     276             :         );
     277             : 
     278             : //////////////////////////////////////////////////////////////////////////
     279             : 
     280           0 : MESSAGE(Brush,
     281             :         ((int, width)) // number of vertices
     282             :         ((int, height))
     283             :         ((std::vector<float>, data)) // width*height array
     284             :         );
     285             : 
     286           0 : MESSAGE(BrushPreview,
     287             :         ((bool, enable))
     288             :         ((Position, pos)) // only used if enable==true
     289             :         );
     290             : 
     291             : //////////////////////////////////////////////////////////////////////////
     292             : //////////////////////////////////////////////////////////////////////////
     293             : 
     294           0 : QUERY(GetTerrainGroups,
     295             :       , // no inputs
     296             :       ((std::vector<std::wstring>, groupNames))
     297             :       );
     298             : 
     299           0 : QUERY(GetTerrainGroupTextures,
     300             :       ((std::wstring, groupName)),
     301             :       ((std::vector<std::wstring>, names))
     302             :       );
     303             : 
     304             : #ifndef MESSAGES_SKIP_STRUCTS
     305           0 : struct sTerrainTexturePreview
     306             : {
     307             :     Shareable<std::wstring> name;
     308             :     Shareable<bool> loaded;
     309             :     Shareable<int> imageWidth;
     310             :     Shareable<int> imageHeight;
     311             :     Shareable<std::vector<unsigned char>> imageData; // RGB*width*height
     312             : };
     313           0 : SHAREABLE_STRUCT(sTerrainTexturePreview);
     314             : #endif
     315             : 
     316           0 : QUERY(GetTerrainGroupPreviews,
     317             :       ((std::wstring, groupName))
     318             :       ((int, imageWidth))
     319             :       ((int, imageHeight))
     320             :       ,
     321             :       ((std::vector<sTerrainTexturePreview>, previews))
     322             :       );
     323             : 
     324           0 : QUERY(GetTerrainPassabilityClasses,
     325             :       , // no inputs
     326             :       ((std::vector<std::wstring>, classNames))
     327             :       );
     328             : 
     329           0 : QUERY(GetTerrainTexturePreview,
     330             :         ((std::wstring, name))
     331             :         ((int, imageWidth))
     332             :         ((int, imageHeight))
     333             :         ,
     334             :         ((sTerrainTexturePreview, preview))
     335             :         );
     336             : 
     337             : //////////////////////////////////////////////////////////////////////////
     338             : 
     339             : #ifndef MESSAGES_SKIP_STRUCTS
     340           0 : struct sObjectsListItem
     341             : {
     342             :     Shareable<std::wstring> id;
     343             :     Shareable<std::wstring> name;
     344             :     Shareable<int> type; // 0 = entity, 1 = actor
     345             : };
     346           0 : SHAREABLE_STRUCT(sObjectsListItem);
     347             : #endif
     348             : 
     349           0 : QUERY(GetObjectsList,
     350             :       , // no inputs
     351             :       ((std::vector<sObjectsListItem>, objects)) // sorted by .name
     352             :       );
     353             : 
     354             : #ifndef MESSAGES_SKIP_STRUCTS
     355           0 : struct sObjectSettings
     356             : {
     357             :     Shareable<int> player;
     358             :     Shareable<std::vector<std::wstring> > selections;
     359             : 
     360             :     // Some settings are immutable and therefore are ignored (and should be left
     361             :     // empty) when passed from the editor to the game:
     362             : 
     363             :     Shareable<std::vector<std::vector<std::wstring> > > variantGroups;
     364             : };
     365           0 : SHAREABLE_STRUCT(sObjectSettings);
     366             : #endif
     367             : 
     368             : // transform de local entity to a real entity
     369           0 : MESSAGE(ObjectPreviewToEntity,);
     370             : 
     371             : //Query for get selected objects
     372           0 : QUERY(GetCurrentSelection,
     373             :     , //No inputs
     374             :     ((std::vector<ObjectID>, ids))
     375             :     );
     376             : 
     377             : // Moving Preview(s) object together, default is using the firs element in vector
     378           0 : MESSAGE(MoveObjectPreview,
     379             :         ((Position,pos))
     380             :         );
     381             : 
     382             : // Preview object in the game world - creates a temporary unit at the given
     383             : // position, and removes it when the preview is next changed
     384           0 : MESSAGE(ObjectPreview,
     385             :         ((std::wstring, id)) // or empty string => disable
     386             :         ((sObjectSettings, settings))
     387             :         ((Position, pos))
     388             :         ((bool, usetarget)) // true => use 'target' for orientation; false => use 'angle'
     389             :         ((Position, target))
     390             :         ((float, angle))
     391             :         ((unsigned int, actorseed))
     392             :         ((bool, cleanObjectPreviews))
     393             :         );
     394             : 
     395           0 : COMMAND(CreateObject, NOMERGE,
     396             :         ((std::wstring, id))
     397             :         ((sObjectSettings, settings))
     398             :         ((Position, pos))
     399             :         ((bool, usetarget)) // true => use 'target' for orientation; false => use 'angle'
     400             :         ((Position, target))
     401             :         ((float, angle))
     402             :         ((unsigned int, actorseed))
     403             :         );
     404             : 
     405             : // Set an actor to be previewed on its own (i.e. without the game world).
     406             : // (Use RenderEnable to make it visible.)
     407           0 : MESSAGE(SetActorViewer,
     408             :         ((std::wstring, id))
     409             :         ((std::string, animation))
     410             :         ((int, playerID))
     411             :         ((float, speed))
     412             :         ((bool, flushcache)) // true => unload all actor files before starting the preview (because we don't have proper hotloading yet)
     413             :         );
     414             : 
     415             : //////////////////////////////////////////////////////////////////////////
     416             : 
     417           0 : QUERY(Exit,,); // no inputs nor outputs
     418             : 
     419             : //////////////////////////////////////////////////////////////////////////
     420             : //////////////////////////////////////////////////////////////////////////
     421             : 
     422             : struct eScrollConstantDir { enum { FORWARDS, BACKWARDS, LEFT, RIGHT, CLOCKWISE, ANTICLOCKWISE }; };
     423           0 : MESSAGE(ScrollConstant, // set a constant scrolling(/rotation) rate
     424             :         ((int, view)) // eRenderView
     425             :         ((int, dir)) // eScrollConstantDir
     426             :         ((float, speed)) // set speed 0.0f to stop scrolling
     427             :         );
     428             : 
     429             : struct eScrollType { enum { FROM, TO }; };
     430           0 : MESSAGE(Scroll, // for scrolling by dragging the mouse FROM somewhere TO elsewhere
     431             :         ((int, view)) // eRenderView
     432             :         ((int, type)) // eScrollType
     433             :         ((Position, pos))
     434             :         );
     435             : 
     436           0 : MESSAGE(SmoothZoom,
     437             :         ((int, view)) // eRenderView
     438             :         ((float, amount))
     439             :         );
     440             : 
     441             : struct eRotateAroundType { enum { FROM, TO }; };
     442           0 : MESSAGE(RotateAround,
     443             :         ((int, view)) // eRenderView
     444             :         ((int, type)) // eRotateAroundType
     445             :         ((Position, pos))
     446             :         );
     447             : 
     448           0 : MESSAGE(LookAt,
     449             :         ((int, view)) // eRenderView
     450             :         ((Position, pos))
     451             :         ((Position, target))
     452             :         );
     453             : 
     454           0 : MESSAGE(CameraReset, );
     455             : 
     456           0 : QUERY(GetView,
     457             :         ,
     458             :         ((sCameraInfo, info))
     459             :         );
     460             : 
     461           0 : MESSAGE(SetView,
     462             :         ((sCameraInfo, info))
     463             :         );
     464             : 
     465             : //////////////////////////////////////////////////////////////////////////
     466             : 
     467             : #ifndef MESSAGES_SKIP_STRUCTS
     468           0 : struct sEnvironmentSettings
     469             : {
     470             :     Shareable<std::wstring> watertype; // range 0..1 corresponds to min..max terrain height; out-of-bounds values allowed
     471             :     Shareable<float> waterheight; // range 0..1 corresponds to min..max terrain height; out-of-bounds values allowed
     472             :     Shareable<float> waterwaviness; // range ???
     473             :     Shareable<float> watermurkiness; // range ???
     474             :     Shareable<float> windangle;
     475             : 
     476             :     Shareable<Color> watercolor;
     477             :     Shareable<Color> watertint;
     478             : 
     479             :     Shareable<float> sunrotation; // range -pi..+pi
     480             :     Shareable<float> sunelevation; // range -pi/2 .. +pi/2
     481             : 
     482             :     // emulate 'HDR' by allowing overly bright suncolor. this is
     483             :     // multiplied on to suncolor after converting to float
     484             :     // (struct Color stores as normal u8, 0..255)
     485             :     Shareable<float> sunoverbrightness; // range 1..3
     486             : 
     487             :     // support different lighting models ("old" for the version compatible with old scenarios,
     488             :     // "standard" for the new normal model that supports much brighter lighting)
     489             :     Shareable<std::wstring> posteffect;
     490             : 
     491             :     Shareable<std::wstring> skyset;
     492             : 
     493             :     Shareable<Color> suncolor;
     494             :     Shareable<Color> ambientcolor;
     495             :     Shareable<Color> fogcolor;
     496             : 
     497             :     Shareable<float> fogfactor;
     498             :     Shareable<float> fogmax;
     499             : 
     500             :     Shareable<float> brightness;
     501             :     Shareable<float> contrast;
     502             :     Shareable<float> saturation;
     503             :     Shareable<float> bloom;
     504             : };
     505           0 : SHAREABLE_STRUCT(sEnvironmentSettings);
     506             : #endif
     507             : 
     508           0 : QUERY(GetEnvironmentSettings,
     509             :       // no inputs
     510             :       ,
     511             :       ((sEnvironmentSettings, settings))
     512             :       );
     513             : 
     514           0 : COMMAND(SetEnvironmentSettings, MERGE,  // merge lots of small changes into one undoable command
     515             :         ((sEnvironmentSettings, settings))
     516             :         );
     517             : 
     518           0 : COMMAND(RecalculateWaterData, NOMERGE, ((float, unused)));
     519             : 
     520           0 : COMMAND(PickWaterHeight, NOMERGE, ((Position, screenPos)));
     521             : 
     522           0 : QUERY(GetSkySets,
     523             :       // no inputs
     524             :       ,
     525             :       ((std::vector<std::wstring>, skysets))
     526             :       );
     527             : 
     528           0 : QUERY(GetPostEffects,
     529             :       // no inputs
     530             :       ,
     531             :       ((std::vector<std::wstring>, posteffects))
     532             :       );
     533             : 
     534             : 
     535             : //////////////////////////////////////////////////////////////////////////
     536             : //////////////////////////////////////////////////////////////////////////
     537             : 
     538           0 : COMMAND(AlterElevation, MERGE,
     539             :         ((Position, pos))
     540             :         ((float, amount))
     541             :         );
     542             : 
     543           0 : COMMAND(SmoothElevation, MERGE,
     544             :         ((Position, pos))
     545             :         ((float, amount))
     546             :         );
     547             : 
     548           0 : COMMAND(FlattenElevation, MERGE,
     549             :         ((Position, pos))
     550             :         ((float, amount))
     551             :         );
     552             : 
     553           0 : COMMAND(PikeElevation, MERGE,
     554             :         ((Position, pos))
     555             :         ((float, amount))
     556             :         );
     557             : 
     558             : struct ePaintTerrainPriority { enum { HIGH, LOW }; };
     559           0 : COMMAND(PaintTerrain, MERGE,
     560             :         ((Position, pos))
     561             :         ((std::wstring, texture))
     562             :         ((int, priority)) // ePaintTerrainPriority
     563             :         );
     564             : 
     565           0 : COMMAND(ReplaceTerrain, NOMERGE,
     566             :         ((Position, pos))
     567             :         ((std::wstring, texture))
     568             :         );
     569             : 
     570           0 : COMMAND(FillTerrain, NOMERGE,
     571             :         ((Position, pos))
     572             :         ((std::wstring, texture))
     573             :         );
     574             : 
     575           0 : QUERY(GetTerrainTexture,
     576             :         ((Position, pos))
     577             :         ,
     578             :         ((std::wstring, texture))
     579             :         );
     580             : 
     581             : //////////////////////////////////////////////////////////////////////////
     582             : 
     583           0 : QUERY(PickObject,
     584             :         ((Position, pos))
     585             :         ((bool, selectActors))
     586             :         ,
     587             :         ((ObjectID, id))
     588             :         ((int, offsetx))  // offset of object centre from input position
     589             :         ((int, offsety)) //
     590             :         );
     591             : 
     592           0 : QUERY(PickObjectsInRect,
     593             :         ((Position, start))
     594             :         ((Position, end))
     595             :         ((bool, selectActors))
     596             :         ,
     597             :         ((std::vector<ObjectID>, ids))
     598             :         );
     599             : 
     600           0 : QUERY(PickSimilarObjects,
     601             :         ((ObjectID, id))
     602             :         ,
     603             :         ((std::vector<ObjectID>, ids))
     604             :         );
     605             : 
     606           0 : MESSAGE(ResetSelectionColor, );
     607             : 
     608           0 : COMMAND(MoveObjects, MERGE,
     609             :         ((std::vector<ObjectID>, ids))
     610             :         ((ObjectID, pivot))
     611             :         ((Position, pos))
     612             :         );
     613             : 
     614           0 : COMMAND(RotateObjectsFromCenterPoint, MERGE,
     615             :         ((std::vector<ObjectID>, ids))
     616             :         ((Position, target))
     617             :         ((bool, rotateObject))
     618             :         );
     619             : 
     620           0 : COMMAND(RotateObject, MERGE,
     621             :         ((std::vector<ObjectID>, ids))
     622             :         ((Position, target))
     623             :         );
     624             : 
     625           0 : COMMAND(DeleteObjects, NOMERGE,
     626             :         ((std::vector<ObjectID>, ids))
     627             :         );
     628             : 
     629           0 : MESSAGE(SetSelectionPreview,
     630             :         ((std::vector<ObjectID>, ids))
     631             :         );
     632             : 
     633           0 : QUERY(GetObjectSettings,
     634             :         ((int, view)) // eRenderView
     635             :         ((ObjectID, id))
     636             :         ,
     637             :         ((sObjectSettings, settings))
     638             :         );
     639             : 
     640           0 : COMMAND(SetObjectSettings, NOMERGE,
     641             :         ((int, view)) // eRenderView
     642             :         ((ObjectID, id))
     643             :         ((sObjectSettings, settings))
     644             :         );
     645             : 
     646           0 : QUERY(GetObjectMapSettings,
     647             :         ((std::vector<ObjectID>, ids))
     648             :         ,
     649             :         ((std::wstring, xmldata))
     650             :         );
     651             : 
     652             : 
     653           0 : QUERY(GetPlayerObjects,
     654             :         ((int, player))
     655             :         ,
     656             :         ((std::vector<ObjectID>, ids))
     657             :         );
     658             : 
     659           0 : MESSAGE(SetBandbox,
     660             :         ((bool, show))
     661             :         ((int, sx0))
     662             :         ((int, sy0))
     663             :         ((int, sx1))
     664             :         ((int, sy1))
     665             :         );
     666             : 
     667             : //////////////////////////////////////////////////////////////////////////
     668             : 
     669           0 : QUERY(GetCinemaPaths,
     670             :       , // no inputs
     671             :       ((std::vector<AtlasMessage::sCinemaPath> , paths))
     672             :       );
     673             : 
     674           0 : QUERY(GetCameraInfo,
     675             :       ,
     676             :       ((AtlasMessage::sCameraInfo, info))
     677             :       );
     678             : 
     679           0 : QUERY(PickPathNode,
     680             :     ((Position, pos))
     681             :     ,
     682             :     ((AtlasMessage::sCinemaPathNode, node))
     683             :     );
     684             : 
     685           0 : QUERY(PickAxis,
     686             :     ((AtlasMessage::sCinemaPathNode, node))
     687             :     ((Position, pos))
     688             :     ,
     689             :     ((int, axis))
     690             :     );
     691             : 
     692           0 : COMMAND(AddPathNode, NOMERGE,
     693             :     ((AtlasMessage::sCinemaPathNode, node))
     694             :     );
     695             : 
     696           0 : COMMAND(DeletePathNode, NOMERGE,
     697             :     ((AtlasMessage::sCinemaPathNode, node))
     698             :     );
     699             : 
     700           0 : COMMAND(MovePathNode, NOMERGE,
     701             :     ((AtlasMessage::sCinemaPathNode, node))
     702             :     ((int, axis))
     703             :     ((Position, from))
     704             :     ((Position, to))
     705             :     );
     706             : 
     707           0 : COMMAND(AddCinemaPath, NOMERGE, ((std::wstring, pathName)));
     708             : 
     709           0 : COMMAND(DeleteCinemaPath, NOMERGE, ((std::wstring, pathName)));
     710             : 
     711           0 : COMMAND(SetCinemaPaths, NOMERGE,
     712             :         ((std::vector<AtlasMessage::sCinemaPath>, paths))
     713             :         );
     714             : 
     715           0 : COMMAND(SetCinemaPathsDrawing, NOMERGE, ((bool, drawPaths)));
     716             : 
     717           0 : MESSAGE(CinemaEvent,
     718             :         ((std::wstring, path))
     719             :         ((int, mode))
     720             :         ((float, t))
     721             :         ((bool, drawCurrent))
     722             :         ((bool, lines))
     723             :         );
     724             : 
     725           0 : MESSAGE(ClearPathNodePreview,);
     726             : 
     727             : //////////////////////////////////////////////////////////////////////////
     728             : 
     729           0 : QUERY(GetSelectedObjectsTemplateNames,
     730             :         ((std::vector<ObjectID>, ids))
     731             :         ,
     732             :         ((std::vector<std::string>, names))
     733             :         );
     734             : 
     735             : 
     736             : #ifdef _MSC_VER
     737             : #pragma warning(pop)
     738             : #endif
     739             : 
     740             : 
     741             : #ifndef MESSAGES_SKIP_SETUP
     742             : #include "MessagesSetup.h"
     743             : #endif
     744             : 
     745             : #endif // INCLUDED_MESSAGES

Generated by: LCOV version 1.13