1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
/* Copyright (C) 2010 Wildfire Games.
* This file is part of 0 A.D.
*
* 0 A.D. is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* 0 A.D. is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef INCLUDED_ICMPVISUAL
#define INCLUDED_ICMPVISUAL
#include "simulation2/system/Interface.h"
#include "ps/CStr.h"
#include "maths/BoundingBoxOriented.h"
#include "maths/BoundingBoxAligned.h"
#include "maths/Fixed.h"
#include "lib/file/vfs/vfs_path.h"
class CUnit;
/**
* The visual representation of an entity (typically an actor).
*/
class ICmpVisual : public IComponent
{
public:
/**
* Get the world-space bounding box of the object's visual representation.
* (Not safe for use in simulation code.)
*/
virtual CBoundingBoxAligned GetBounds() = 0;
/**
* Get the oriented world-space bounding box of the object's visual representation, clipped at the Y=0 plane in object space
* to prevent it from extending into the terrain. The primary difference with GetBounds is that this bounding box is not aligned
* to the world axes, but arbitrarily rotated according to the model transform.
*/
virtual CBoundingBoxOriented GetSelectionBox() = 0;
/**
* Get the world-space position of the base point of the object's visual representation.
* (Not safe for use in simulation code.)
*/
virtual CVector3D GetPosition() = 0;
/**
* Return the short name of the actor that's being displayed, or the empty string on error.
* (Not safe for use in simulation code.)
*/
virtual std::wstring GetActorShortName() = 0;
/**
* Return the filename of the actor to be used for projectiles from this unit, or the empty string if none.
* (Not safe for use in simulation code.)
*/
virtual std::wstring GetProjectileActor() = 0;
/**
* Return the exact position where a projectile should be launched from (based on the actor's
* ammo prop points).
* Returns (0,0,0) if no point can be found.
*/
virtual CVector3D GetProjectileLaunchPoint() = 0;
/**
* Returns the underlying unit of this visual actor. May return NULL to indicate that no unit exists (e.g. may happen if the
* game is started without graphics rendering).
* Originally intended for introspection purposes in Atlas; for other purposes, consider using a specialized getter first.
*/
virtual CUnit* GetUnit() = 0;
/**
* Start playing the given animation. If there are multiple possible animations then it will
* pick one at random (not network-synchronised).
* If @p soundgroup is specified, then the sound will be played at each 'event' point in the
* animation cycle.
* @param name animation name (e.g. "idle", "walk", "melee"; the names are determined by actor XML files)
* @param once if true then the animation will play once and freeze at the final frame, else it will loop
* @param speed animation speed multiplier (typically 1.0 for the default speed)
* @param soundgroup VFS path of sound group .xml, relative to audio/, or empty string for none
*/
virtual void SelectAnimation(std::string name, bool once, fixed speed, std::wstring soundgroup) = 0;
/**
* Sets the specified entity selection on the underlying unit.
*/
virtual void SetUnitEntitySelection(const CStr& selection) = 0;
/**
* Start playing the walk/run animations, scaled to the unit's movement speed.
* @param runThreshold movement speed at which to switch to the run animation
*/
virtual void SelectMovementAnimation(fixed runThreshold) = 0;
/**
* Adjust the speed of the current animation, so it can match simulation events.
* @param repeattime time for complete loop of animation, in msec
*/
virtual void SetAnimationSyncRepeat(fixed repeattime) = 0;
/**
* Adjust the offset of the current animation, so it can match simulation events.
* @param actiontime time between now and when the 'action' event should occur, in msec
*/
virtual void SetAnimationSyncOffset(fixed actiontime) = 0;
/**
* Set the shading colour that will be modulated with the model's textures.
* Default shading is (1, 1, 1, 1).
* Alpha should probably be 1 else it's unlikely to work properly.
* @param r red component, expected range [0, 1]
* @param g green component, expected range [0, 1]
* @param b blue component, expected range [0, 1]
* @param a alpha component, expected range [0, 1]
*/
virtual void SetShadingColour(fixed r, fixed g, fixed b, fixed a) = 0;
/**
* Set an arbitrarily-named variable that the model may use to alter its appearance
* (e.g. in particle emitter parameter computations).
*/
virtual void SetVariable(std::string name, float value) = 0;
/**
* Called when an actor file has been modified and reloaded dynamically.
* If this component uses the named actor file, it should regenerate its actor
* to pick up the new definitions.
*/
virtual void Hotload(const VfsPath& name) = 0;
DECLARE_INTERFACE_TYPE(Visual)
};
// TODO: rename this to VisualActor, because the interface is actor-specific, maybe?
#endif // INCLUDED_ICMPVISUAL
|
