LightingTarget.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editing/EditableTarget.h"
#include "editing/EditingAuthority.h"
#include "editing/EditingProperty.h"
 
#include <map>
#include <string>
#include <vector>
 
namespace eve::graphics {
class Light3D;
}
namespace eve::daynight {
class DayNight;
}
namespace eve::weather {
class Weather;
}
 
namespace eve::lighting_editing {
 
using CapabilityId       = editing::CapabilityId;
using DiagnosticSeverity = editing::DiagnosticSeverity;
using DomainOperation    = editing::DomainOperation;
using EditRegion         = editing::EditRegion;
using EditorDiagnostic   = editing::Diagnostic;
using editing::Result;
using EditorStatus             = editing::Status;
using EditorValue              = editing::Value;
using IDomainOperationTarget   = editing::IDomainOperationTarget;
using IEditableTarget          = editing::IEditableTarget;
using IPropertyProvider        = editing::IPropertyProvider;
using PropertyDescriptor       = editing::PropertyDescriptor;
using PropertyDescriptorLookup = editing::PropertyDescriptorLookup;
using PropertyFlag             = editing::PropertyFlag;
using PropertyPath             = editing::PropertyPath;
using PropertyReadResult       = editing::PropertyReadResult;
using PropertyReadState        = editing::PropertyReadState;
using PropertySchema           = editing::PropertySchema;
using PropertySetMode          = editing::PropertySetMode;
using PropertyType             = editing::PropertyType;
using Revision                 = editing::Revision;
using RuleId                   = editing::RuleId;
using SelectionSnapshot        = editing::SelectionSnapshot;
using TargetDescriptor         = editing::TargetDescriptor;
using TargetId                 = editing::TargetId;
using editing::validatePropertyValue;
 
class EVENGINE_API_ORCHESTRATION LightingPropertyTargetBase : public ::eve::editing::EditableTargetState,
                                                              public virtual IEditableTarget,
                                                              public IDomainOperationTarget,
                                                              public IPropertyProvider {
public:
    TargetId         targetId() const override { return TargetId(id_); }
    TargetDescriptor describe() const override;
    void*                         queryCapability(const CapabilityId& capability) override;
    Result<void>            applyDomainOperation(const DomainOperation& operation) override;
    eve::Result<eve::Revision>    currentRevision(const SelectionSnapshot& selection) const override;
    PropertySchema                schema(const SelectionSnapshot& selection) const override;
    PropertyReadResult            read(const SelectionSnapshot& selection, const PropertyPath& path) const override;
    Result<DomainOperation> makeSet(const SelectionSnapshot& selection, const PropertyPath& path,
                                          const EditorValue& value, PropertySetMode mode) const override;
    Result<DomainOperation> makeReset(const SelectionSnapshot& selection,
                                            const PropertyPath&      path) const override;
    EditorValue snapshotValue() const;
    Result<void> loadSnapshot(const EditorValue& snapshot);
    const EditorValue* value(const std::string& path) const;
 
protected:
    LightingPropertyTargetBase(std::string id, std::string targetType, PropertySchema schema);
 
private:
    bool                               selectionMatches(const SelectionSnapshot& selection) const;
    std::string                        id_;
    std::string                        targetType_;
    PropertySchema                     schema_;
    std::map<std::string, EditorValue> values_;
};
 
class EVENGINE_API_ORCHESTRATION Light3DDocumentTarget final : public LightingPropertyTargetBase {
public:
    explicit Light3DDocumentTarget(std::string id);
    std::vector<EditorDiagnostic> validate() const;
};
 
class EVENGINE_API_ORCHESTRATION EnvironmentDocumentTarget final : public LightingPropertyTargetBase {
public:
    explicit EnvironmentDocumentTarget(std::string id);
    std::vector<EditorDiagnostic> validate() const;
};
 
class EVENGINE_API_ORCHESTRATION Light3DRuntimeApplier {
public:
    Result<void> apply(const Light3DDocumentTarget& document, graphics::Light3D* light) const;
};
 
class EVENGINE_API_ORCHESTRATION EnvironmentRuntimeApplier {
public:
    Result<void> applyDayNight(const EnvironmentDocumentTarget& document, daynight::DayNight* environment) const;
    Result<void> applyWeather(const EnvironmentDocumentTarget& document, weather::Weather* environment) const;
};
 
}  // namespace eve::lighting_editing