|
| | ParticleGenerator () |
| | ParticleGenerator (const ParticleGenerator &) |
| auto | operator= (const ParticleGenerator &) -> ParticleGenerator &=default |
| | ~ParticleGenerator () override=default |
| | ParticleGenerator (ParticleGenerator &&other) noexcept=default |
| auto | operator= (ParticleGenerator &&other) noexcept -> ParticleGenerator &=default |
| auto | clone () const -> std::unique_ptr< GameObject > override |
| | makes a copy a GameObject even if it's held polymorphically
|
| auto | componentShowMenu () -> void override |
| auto | onUpdate (float dt) -> void override |
| | called once every frame.
|
| auto | endWindow () -> void override |
| | currently unused, but intended to but was assumed to be necessary for a proper ImGui editor
|
| auto | onRender () -> void override |
| | called every frame after update has been called for every object.
|
| auto | load (const Stream &stream) -> void override |
| | Implementations will load the state of a GameObject from a th::Json Object.
|
| auto | save (Stream &stream) const -> void override |
| | Implementations will load the state of a GameObject to a th::Json object.
|
| auto | onEnterEngine () -> void override |
| | hook that is called when a GameObject enters the Engine tree.
|
| auto | addEmitter () -> void |
| | Creates a new, default constructed Particle Emitter.
|
| auto | activate () -> void |
| | Activates the particle generator, and all it's emitters If the particle generator is set to repeat, then this will turn on the particles ( and they will emit continuously) If the Particle generator is not set to repeat, then this will spawn a burst of particles, from all the emitters.
|
| auto | deactivate () -> void |
| | deactivates the particle generator, and all of it's emitters If the particle generator is set to repeat, this turns it off, and it will no longer produce particles.
|
| auto | linkMessages () -> void |
| auto | getType () const -> ComponentTypeEnum |
| auto | getKey () const -> Key override |
| | Generates a unique Key that corresponds to the GameObject.
|
| auto | showMenu () -> void override |
| | Called before update each frame, for calling ImGui editor code relevant to the gameObject.
|
| auto | getEntityParent () const -> Entity * |
| | gets the parent as an Entity.
|
| | GameObject (std::string typeName, gobj::Type parentType, gobj::Type type) |
| | constructor for gameobject.
|
| virtual | ~GameObject () |
| | destructor for GameObject.
|
| | GameObject (const GameObject &other) |
| | Copy Constructor.
|
| auto | operator= (const GameObject &other) -> GameObject & |
| | copy assignment operator
|
| | GameObject (GameObject &&other) noexcept |
| | Move constructor.
|
| auto | operator= (GameObject &&other) noexcept -> GameObject & |
| | Move assignment operator.
|
| virtual auto | update (float dt) -> void |
| | called once every frame.
|
| virtual auto | render () -> void |
| | called every frame after update has been called for every object.
|
| virtual auto | destroy () -> void |
| | Marks an GameObject to be destroyed.
|
| virtual auto | onSceneStart (const std::string &sceneName) -> void |
| | Hook that is called before the first frame a scene is run, but after the entire scene is loaded into the engine To receive the hook, simply override the function in your class.
|
| virtual auto | onSceneExit (const std::string &sceneName) -> void |
| | Hook that is called right before a scene is unloaded To receive the hook, simply override the function in your class.
|
| virtual auto | for_each (std::function< void(GameObject &)> func) -> void |
| | applies a function to every child.
|
| virtual auto | for_each (std::function< void(const GameObject &)> func) const -> void |
| | applies a const function to every child.
|
| virtual auto | getParent () const -> GameObject * |
| | Gets the parent of a GameObject.
|
| virtual auto | parentTo (GameObject *newParent) -> bool |
| | Sets the GameObject as a child of another GameObject.
|
| auto | getInternalParent () const -> GameObject * |
| | returns the actual owning parent of the GameObject
|
| virtual auto | addChild (std::unique_ptr< GameObject > newChild) -> bool |
| | Adds a child to a GameObject.
|
| auto | destroyed () const -> bool |
| auto | getUUID () const -> gobj::UUID |
| auto | isUUID (gobj::UUID compareUUID) const -> bool |
| auto | getName () const -> const std::string & |
| | Gets the type of the object as a string.
|
| auto | getNickname () const -> const std::string & |
| | Gets the nickname (custom, writable name) of a GameObject.
|
| auto | getFormattedName () const -> const std::string & |
| | combines a GameObjects Type, Nickname, and UUID into one string, for use with logging.
|
| auto | nameEquals (const std::string &compareString) const -> bool |
| | check whether a GameObjects typeName is equivilent to a given string.
|
| auto | isType (gobj::Type otherType) const -> bool |
| | check whether the GameObject is the same as a given type.
|
| auto | getObjectType () const -> gobj::Type |
| | gets the internal type of the GameObject, as an enum
|
| auto | setNickname (const std::string &newNickname) -> void |
| | sets the GameObjects nickname.
|
| auto | updates () const -> bool |
| auto | renders () const -> bool |
| auto | receivesMessages () const -> bool |
| auto | isActive () const -> bool |
| virtual auto | setShouldUpdate (bool _shouldUpdate) -> void |
| | set whether the GameObject should update every frame, and whether all of it's children should update every frame
|
| virtual auto | setShouldRender (bool _shouldRender) -> void |
| | set whether the GameObject should render every frame, and whether all of it's children should render every frame
|
| virtual auto | setShouldReceiveMessages (bool _shouldReceiveMessages) -> void |
| | set whether the GameObject should Receive Messags, and whether all of it's children should receive messages
|
| auto | setActive (bool shouldBeActive) -> void |
| | set the GameObject should update, render, and receive messages
|
|
| enum | ComponentTypeEnum : unsigned short {
cErrorType = 0
, cPhysics = 100
, cAnimation = 200
, cTransform = 300
,
cCollider = 400
, cSprite = 500
, cBehavior = 600
, cTable = 650
,
cCard = 700
, cDeck = 750
, cPlayer = 800
, cBoard = 850
,
cScene = 900
, cPauseScene = 915
, cMainScene = 920
, cMainMenuScene = 925
,
cConfirmDestructiveActionScene = 930
, cOptionsScene = 935
, cCreditsScene = 940
, cTutorialScene = 945
,
cBackground = 950
, cSplashScreenScene = 955
, cWinScreenScene = 960
, cPlayerCountScene = 965
,
cPlayerJoinScene = 970
, cFlags = 1000
, cSelectable = 1100
, cMenu = 1200
,
cActionList = 1300
, cEntityMover = 1400
, cMenuItem = 1500
, cMenuPosition = 1525
,
cSelector = 1600
, cButton = 1700
, cParticleGenerator = 2500
} |
| | This enum lists out every type of component we have. More...
|
| friend | Entity |
| friend | Node |
| friend | ChildrenHandeler |
| friend | Engine |
| | Component (ComponentTypeEnum type, const char *typeName) |
| auto | getComponentJson () const -> json |
| auto | getChildren () const -> std::shared_ptr< std::vector< GameObject * > > override |
| | override for component to return a vector of no children
|
| auto | setInternalParent (GameObject *parent) -> bool |
| | sets the internal parent of a GameObject directly, avoiding abstractions provided by ParentTo().
|
| auto | getGameObjectJson () const -> json |
| | Used for serializing GameObjects.
|
| auto | setGameObjectJson (const json &stream) -> void |
| | used for deserializing GameObjects
|
| auto | checkAddToSceneHook () -> void |
| | Determine if the GameObject was recently added to the engine, and if it was, call onEngineEnter.
|
A Component that generates several types of particles, by holding several ParticleEmitters.
To use, simply add a ParticleGenerator to an Entity, and hit the addEmitter button in ImGui
Modes
ParticleGenerator have two main modes, repeating, or non-repeating.
Repeating mode
In repeating mode, all particle emitters emit particles continuously. This is useful for environment effects, auras, etc. The particles can be toggled on or off with activate() and deactivate().
non-repeating mode
in non-repeating mode, particle emitters only emit when activate is called on them. This is useful for bursts, feedback to player input, and any other particle effect that has a beginning, middle, and end.
Some tips for making particles
- Save often!
- A good (non-repeating) particle effect has 3 parts
Anticipation
Climax
Settle
- 1. Anticipation
- The lead in to the effect, shows the player that something cool (or otherwise) is going to happen.
- like all things in effects, this should be exactly as grand as the effect calls for. A large impact should have a large lead up. simply playing a card should have little lead up
- 2. Climax
- The oomph of an effect. this is the real body of the effect, and the thing that defines it
- Don't drag this out. if an effect needs more impact, go bigger, not longer.
- all of these parts should be multiple emitters, but this especially is where you should think about not just one particle at a time, but maybe a couple layer over each other
- 3. Settle
- This is the conclusion, and shows the impact of the effect, even after it's done. for explosions, this would be the damage left. other effects can call for drifting particles, a little bit of shine or glimmer, simply the particles from the climax left unmoving.