SaveGame serialization. Override to specify what to serialize in a saved game.

Parameters

ser	Serializing stream. Use IsReading() to decide read/write phase. Use Value() to read/write a property.

Return ClassDesc for this component Class description is storing runtime C++ class reflection information It contain information about member variables of the component and how to serialize them, information how to create an instance of class and all relevant additional information to handle this class.

Return bit mask of the EEntityEvent flags that we want to receive in ProcessEvent (ex: BIT64(ENTITY_EVENT_HIDE) | BIT64(ENTITY_EVENT_UNHIDE)) Only events matching the returned bit mask will be sent to the ProcessEvent method

#include 

class CMyEventComponent final : public IEntityComponent
{
public:
    // Provide a virtual destructor, ensuring correct destruction of IEntityComponent members
    virtual ~CMyEventComponent() = default;

    static void ReflectType(Schematyc::CTypeDesc& desc) { /* Reflect the component GUID in here. */}

    // Override the ProcessEvent function to receive the callback whenever an event specified in GetEventMask is triggered
    virtual void ProcessEvent(const SEntityEvent& event) override
    {
        // Check if this is the update event
        if (event.event == ENTITY_EVENT_UPDATE)
        {
            // The Update event provides delta time as the first floating-point parameter
            const float frameTime = event.fParam[0];

            /* Handle update logic here */
        }
    }

    // As an optimization, components have to specify a bitmask of the events that they want to handle
    // This is called once at component creation, and then only if IEntity::UpdateComponentEventMask is called, to support dynamic change of desired events (useful for disabling update when you don't need it)
    virtual uint64 GetEventMask() const override { return BIT64(ENTITY_EVENT_UPDATE); }
};

Return GUID of this component. This GUID is only guaranteed to be unique within the host entity, different entities can have components with equal GUIDs. Each component in the entity have type guid (GetClassDesc().GetGUID()) (ex: identify EntityLightComponent class) and a unique instance guid IEntityComponent::GetGUID() (ex: identify Light01,Light02,etc.. component)

Network serialization. Override to provide a mask of active network aspects used by this component. Called once during binding to network.

#include 

class CMyNetSerializedComponent final : public IEntityComponent
{
public:
    // Provide a virtual destructor, ensuring correct destruction of IEntityComponent members
    virtual ~CMyNetSerializedComponent() = default;

    static void ReflectType(Schematyc::CTypeDesc& desc) { /* Reflect the component GUID in here. */}

    // Define the aspect / stream to use for this aspect, in our case we want a server stream since only the server can change health
    static constexpr EEntityAspects HealthAspect = eEA_GameServerA;
    // Override GetNetSerializeAspectMask to specify that we will handle HealthAspect
    virtual NetworkAspectType GetNetSerializeAspectMask() const override { return HealthAspect; }

    // Override NetSerialize, called on the server when the aspect has been marked dirty, and then on the client to read the data
    virtual bool NetSerialize(TSerialize ser, EEntityAspects aspect, uint8 profile, int flags) override
    {
        // Check that we are processing the desired aspect
        if (aspect == HealthAspect)
        {
            // Serialize health, either to network (on the server) or from network (on a client)
            ser.Value("health", m_health);
        }
    }

    // Helper utility that game code should call to set the health of this component
    void SetHealth(float newHealth)
    {
        CRY_ASSERT_MESSAGE(gEnv->bServer, "Health can only be modified on the server!");
        // Update the local state
        m_health = newHealth;
        // Notify the network that the health aspect has changed
        // This will result in NetSerialize being called to serialize data over the network
        NetMarkAspectsDirty(HealthAspect);
    }

protected:
    float m_health = 100.f;
};

Return optional EntitySlot id used by this Component If slot id is not allocated, new slotid will be allocated and returned

Return Parent component, only used by Schematyc components Initialized by the PreInit call

Override this to return preview render interface for the component. Multiple component instances can usually share the same previewer class instance.

See also

IEntityComponentPreviewer

Optionally serialize component to/from XML. For user-facing properties, see GetProperties.

SaveGame serialization. Override to enable serialization for the component.

Returns

true If component needs to be serialized to/from a saved game.

Call this to trigger aspect synchronization over the network. A shortcut.

See also

INetEntity::MarkAspectsDirty()

#include 

class CMyNetSerializedComponent final : public IEntityComponent
{
public:
    // Provide a virtual destructor, ensuring correct destruction of IEntityComponent members
    virtual ~CMyNetSerializedComponent() = default;

    static void ReflectType(Schematyc::CTypeDesc& desc) { /* Reflect the component GUID in here. */}

    // Define the aspect / stream to use for this aspect, in our case we want a server stream since only the server can change health
    static constexpr EEntityAspects HealthAspect = eEA_GameServerA;
    // Override GetNetSerializeAspectMask to specify that we will handle HealthAspect
    virtual NetworkAspectType GetNetSerializeAspectMask() const override { return HealthAspect; }

    // Override NetSerialize, called on the server when the aspect has been marked dirty, and then on the client to read the data
    virtual bool NetSerialize(TSerialize ser, EEntityAspects aspect, uint8 profile, int flags) override
    {
        // Check that we are processing the desired aspect
        if (aspect == HealthAspect)
        {
            // Serialize health, either to network (on the server) or from network (on a client)
            ser.Value("health", m_health);
        }
    }

    // Helper utility that game code should call to set the health of this component
    void SetHealth(float newHealth)
    {
        CRY_ASSERT_MESSAGE(gEnv->bServer, "Health can only be modified on the server!");
        // Update the local state
        m_health = newHealth;
        // Notify the network that the health aspect has changed
        // This will result in NetSerialize being called to serialize data over the network
        NetMarkAspectsDirty(HealthAspect);
    }

protected:
    float m_health = 100.f;
};

Used to match an entity's state when it is replicated onto a remote machine. This is called once when spawning an entity, in order to serialize its data - and once again on the remote client to deserialize the state. Deserialization will always occur before IEntityComponent::Initialize is called.

Parameters

[in,out]

ser

Serializer for reading / writing values.

See also

ISerialize::Value()

#include 

class CMyReplicatedComponent final : public IEntityComponent
{
public:
    static void ReflectType(Schematyc::CTypeDesc& desc) { /* Reflect the component GUID in here. */}

    // Implement NetReplicateSerialize, called on the server when an entity with the component is spawned
    virtual void NetReplicateSerialize(TSerialize ser) override 
    {
        ser.Value("health", m_health);
    }

    void SetHealth(float health) { m_health = health; }

protected:
    float m_health = 100.f;
};

void SpawnEntityOnAllClients()
{
    CRY_ASSERT(gEnv->bServer);

    // Spawn a new entity, but do *not* automatically initialize it
    // This is delayed as want to add our component before network replication occurs
    if (IEntity* pEntity = gEnv->pEntitySystem->SpawnEntity(SEntitySpawnParams(), false))
    {
        // Create an instance of our component and attach it to the entity
        CMyReplicatedComponent* pComponent = pEntity->CreateComponentClass();
        // Change the initial health, as an example of replication a new state on the remote clients
        pComponent->SetHealth(0.f);

        // Now initialize the entity, resulting in CMyComponent::NetReplicateSerialize first being called on the server (this instance) to write the data to network, and then on all clients to deserialize.
        gEnv->pEntitySystem->InitEntity(pEntity, SEntitySpawnParams());
    }
}

Network serialization. Will be called for each active aspect for both reading and writing.

Parameters

[in,out]	ser	Serializer for reading/writing values.
[in]	aspect	The number of the aspect being serialized.
[in]	profile	Can be ignored, used by CryPhysics only.
[in]	flags	Can be ignored, used by CryPhysics only.

See also

ISerialize::Value()

#include 

class CMyNetSerializedComponent final : public IEntityComponent
{
public:
    // Provide a virtual destructor, ensuring correct destruction of IEntityComponent members
    virtual ~CMyNetSerializedComponent() = default;

    static void ReflectType(Schematyc::CTypeDesc& desc) { /* Reflect the component GUID in here. */}

    // Define the aspect / stream to use for this aspect, in our case we want a server stream since only the server can change health
    static constexpr EEntityAspects HealthAspect = eEA_GameServerA;
    // Override GetNetSerializeAspectMask to specify that we will handle HealthAspect
    virtual NetworkAspectType GetNetSerializeAspectMask() const override { return HealthAspect; }

    // Override NetSerialize, called on the server when the aspect has been marked dirty, and then on the client to read the data
    virtual bool NetSerialize(TSerialize ser, EEntityAspects aspect, uint8 profile, int flags) override
    {
        // Check that we are processing the desired aspect
        if (aspect == HealthAspect)
        {
            // Serialize health, either to network (on the server) or from network (on a client)
            ser.Value("health", m_health);
        }
    }

    // Helper utility that game code should call to set the health of this component
    void SetHealth(float newHealth)
    {
        CRY_ASSERT_MESSAGE(gEnv->bServer, "Health can only be modified on the server!");
        // Update the local state
        m_health = newHealth;
        // Notify the network that the health aspect has changed
        // This will result in NetSerialize being called to serialize data over the network
        NetMarkAspectsDirty(HealthAspect);
    }

protected:
    float m_health = 100.f;
};

Only called by system classes to initalize component. Users must not call this method directly

By overriding this function component will be able to handle events sent from the host Entity. Requires returning the desired event flag in GetEventMask.

Parameters

event

Event structure, contains event id and parameters.

#include 

class CMyEventComponent final : public IEntityComponent
{
public:
    // Provide a virtual destructor, ensuring correct destruction of IEntityComponent members
    virtual ~CMyEventComponent() = default;

    static void ReflectType(Schematyc::CTypeDesc& desc) { /* Reflect the component GUID in here. */}

    // Override the ProcessEvent function to receive the callback whenever an event specified in GetEventMask is triggered
    virtual void ProcessEvent(const SEntityEvent& event) override
    {
        // Check if this is the update event
        if (event.event == ENTITY_EVENT_UPDATE)
        {
            // The Update event provides delta time as the first floating-point parameter
            const float frameTime = event.fParam[0];

            /* Handle update logic here */
        }
    }

    // As an optimization, components have to specify a bitmask of the events that they want to handle
    // This is called once at component creation, and then only if IEntity::UpdateComponentEventMask is called, to support dynamic change of desired events (useful for disabling update when you don't need it)
    virtual uint64 GetEventMask() const override { return BIT64(ENTITY_EVENT_UPDATE); }
};

Send event to this specific component, first checking if the component is interested in the event

Parameters

event	description
receiving	component

END IEntityComponent virtual interface.

Set flags for this component

Set a new name for this component Names of the components must not be unique

Reflected type description for this component Contain description of the reflected member variables