Code/CryEngine/CrySchematyc2/BaseEnv/Components/BaseEnv_EntityLightComponent.cpp

   1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "BaseEnv/Components/BaseEnv_EntityLightComponent.h"
   5
   6 #include <CryRenderer/IRenderAuxGeom.h>
   7 #include <CryRenderer/IRenderer.h>
   8
   9 #include "BaseEnv/BaseEnv_AutoRegistrar.h"
  10
  11 namespace SchematycBaseEnv
  12 {
  13         namespace EntityLightComponentUtils
  14         {
  15                 struct SPreviewProperties : public Schematyc2::IComponentPreviewProperties
  16                 {
  17                         SPreviewProperties()
  18                                 : bShowGizmos(false)
  19                                 , gizmoLength(1.0f)
  20                         {}
  21
  22                         // Schematyc2::IComponentPreviewProperties
  23
  24                         virtual void Serialize(Serialization::IArchive& archive) override
  25                         {
  26                                 archive(bShowGizmos, "bShowGizmos", "Show Gizmos");
  27                                 archive(gizmoLength, "gizmoLength", "Gizmo Length");
  28                         }
  29
  30                         // ~Schematyc2::IComponentPreviewProperties
  31
  32                         bool  bShowGizmos;
  33                         float gizmoLength;
  34                 };
  35         }
  36
  37         const Schematyc2::SGUID CEntityLightComponent::s_componentGUID = "ed123a98-462f-49a0-8d1b-362d6449d81a";
  38
  39         CEntityLightComponent::SProperties::SProperties()
  40                 : bOn(true)
  41                 , color(Col_White)
  42                 , diffuseMultiplier(1.0f)
  43                 , specularMultiplier(1.0f)
  44                 , hdrDynamicMultiplier(1.0f)
  45                 , radius(10.0f)
  46                 , frustumAngle(45.0f)
  47                 , attenuationBulbSize(0.05f)
  48         {}
  49
  50         void CEntityLightComponent::SProperties::Serialize(Serialization::IArchive& archive)
  51         {
  52                 archive(bOn, "on", "On");
  53                 archive.doc("Initial on/off state");
  54
  55                 archive(color, "color", "Color");
  56                 archive.doc("Color");
  57
  58                 archive(Serialization::Range(diffuseMultiplier, 0.01f, 10.0f), "diffuseMultiplier", "Diffuse Multiplier");
  59                 archive.doc("Diffuse Multiplier");
  60
  61                 archive(Serialization::Range(specularMultiplier, 0.01f, 10.0f), "specularMultiplier", "Specular Multiplier");
  62                 archive.doc("Specular Multiplier");
  63
  64                 archive(Serialization::Range(hdrDynamicMultiplier, 0.01f, 10.0f), "hdrDynamicMultiplier", "HDR Dynamic Multiplier");
  65                 archive.doc("HDR Dynamic Multiplier");
  66
  67                 archive(Serialization::Range(radius, 0.01f, 50.0f), "radius", "Radius");
  68                 archive.doc("Radius");
  69
  70                 archive(Serialization::Range(frustumAngle, 0.01f, 90.0f), "frustumAngle", "Frustum Angle");
  71                 archive.doc("Frustum Angle");
  72
  73                 archive(Serialization::Range(attenuationBulbSize, 0.01f, 5.0f), "attenuationBulbSize", "Attenuation Bulb Size");
  74                 archive.doc("Attenuation Bulb Size");
  75
  76                 archive(TransformDecorator<ETransformComponent::PositionAndRotation>(transform), "transform", "Transform");
  77                 archive.doc("Transform relative to parent/entity");
  78         }
  79
  80         Schematyc2::SEnvFunctionResult CEntityLightComponent::SProperties::SetTransform(const Schematyc2::SEnvFunctionContext& context, const STransform& _transform)
  81         {
  82                 transform = _transform;
  83                 return Schematyc2::SEnvFunctionResult();
  84         }
  85
  86         CEntityLightComponent::CEntityLightComponent()
  87                 : m_pProperties(nullptr)
  88                 , m_bOn(false)
  89         {}
  90
  91         bool CEntityLightComponent::Init(const Schematyc2::SComponentParams& params)
  92         {
  93                 if(!CEntityTransformComponentBase::Init(params))
  94                 {
  95                         return false;
  96                 }
  97                 m_pProperties = params.properties.ToPtr<SProperties>();
  98                 return true;
  99         }
 100
 101         void CEntityLightComponent::Run(Schematyc2::ESimulationMode simulationMode)
 102         {
 103                 if(m_pProperties->bOn)
 104                 {
 105                         SwitchOn();
 106                 }
 107         }
 108
 109         Schematyc2::IComponentPreviewPropertiesPtr CEntityLightComponent::GetPreviewProperties() const
 110         {
 111                 return std::make_shared<EntityLightComponentUtils::SPreviewProperties>();
 112         }
 113
 114         void CEntityLightComponent::Preview(const SRendParams& params, const SRenderingPassInfo& passInfo, const Schematyc2::IComponentPreviewProperties& previewProperties) const
 115         {
 116                 const EntityLightComponentUtils::SPreviewProperties& previewPropertiesImpl = static_cast<const EntityLightComponentUtils::SPreviewProperties&>(previewProperties);
 117                 if(previewPropertiesImpl.bShowGizmos)
 118                 {
 119                         if(CEntityTransformComponentBase::SlotIsValid())
 120                         {
 121                                 IRenderAuxGeom& renderAuxGeom = *gEnv->pRenderer->GetIRenderAuxGeom();
 122                                 const Matrix34  worldTM = CEntityTransformComponentBase::GetWorldTM();
 123                                 const float     lineThickness = 4.0f;
 124
 125                                 renderAuxGeom.DrawLine(worldTM.GetTranslation(), ColorB(255, 0, 0, 255), worldTM.GetTranslation() + (worldTM.GetColumn0().GetNormalized() * previewPropertiesImpl.gizmoLength), ColorB(255, 0, 0, 255), lineThickness);
 126                                 renderAuxGeom.DrawLine(worldTM.GetTranslation(), ColorB(0, 255, 0, 255), worldTM.GetTranslation() + (worldTM.GetColumn1().GetNormalized() * previewPropertiesImpl.gizmoLength), ColorB(0, 255, 0, 255), lineThickness);
 127                                 renderAuxGeom.DrawLine(worldTM.GetTranslation(), ColorB(0, 0, 255, 255), worldTM.GetTranslation() + (worldTM.GetColumn2().GetNormalized() * previewPropertiesImpl.gizmoLength), ColorB(0, 0, 255, 255), lineThickness);
 128                         }
 129                 }
 130         }
 131
 132         void CEntityLightComponent::Shutdown()
 133         {
 134                 CEntityTransformComponentBase::Shutdown();
 135         }
 136
 137         Schematyc2::INetworkSpawnParamsPtr CEntityLightComponent::GetNetworkSpawnParams() const
 138         {
 139                 return Schematyc2::INetworkSpawnParamsPtr();
 140         }
 141
 142         void CEntityLightComponent::Register()
 143         {
 144                 Schematyc2::IEnvRegistry& envRegistry = gEnv->pSchematyc2->GetEnvRegistry();
 145
 146                 {
 147                         Schematyc2::IComponentFactoryPtr pComponentFactory = SCHEMATYC2_MAKE_COMPONENT_FACTORY_SHARED(CEntityLightComponent, SProperties, s_componentGUID);
 148                         pComponentFactory->SetName("Light");
 149                         pComponentFactory->SetNamespace("Base");
 150                         pComponentFactory->SetAuthor("Crytek");
 151                         pComponentFactory->SetDescription("Entity light component");
 152                         pComponentFactory->SetFlags(Schematyc2::EComponentFlags::CreatePropertyGraph);
 153                         pComponentFactory->SetAttachmentType(Schematyc2::EComponentSocket::Parent, g_tranformAttachmentGUID);
 154                         pComponentFactory->SetAttachmentType(Schematyc2::EComponentSocket::Child, g_tranformAttachmentGUID);
 155                         envRegistry.RegisterComponentFactory(pComponentFactory);
 156                 }
 157
 158                 // Functions
 159
 160                 {
 161                         Schematyc2::CEnvFunctionDescriptorPtr pFunctionDescriptor = Schematyc2::MakeEnvFunctionDescriptorShared(&CEntityLightComponent::SProperties::SetTransform);
 162                         pFunctionDescriptor->SetGUID("729721c4-a09e-4903-a8a6-fa69388acfc6");
 163                         pFunctionDescriptor->SetName("SetTransform");
 164                         pFunctionDescriptor->BindInput(0, 0, "Transform", "Transform");
 165                         envRegistry.RegisterFunction(pFunctionDescriptor);
 166                 }
 167         }
 168
 169         bool CEntityLightComponent::Switch(bool bOn)
 170         {
 171                 const bool bPrevOn = m_bOn;
 172                 if(bOn != bPrevOn)
 173                 {
 174                         if(bOn)
 175                         {
 176                                 SwitchOn();
 177                         }
 178                         else
 179                         {
 180                                 SwitchOff();
 181                         }
 182                 }
 183                 return bPrevOn;
 184         }
 185
 186         void CEntityLightComponent::SwitchOn()
 187         {
 188                 ColorF color = m_pProperties->color;
 189                 color.r *= m_pProperties->diffuseMultiplier;
 190                 color.g *= m_pProperties->diffuseMultiplier;
 191                 color.b *= m_pProperties->diffuseMultiplier;
 192
 193                 SRenderLight light;
 194                 light.m_Flags                = 0; //TODO [andriy 25.05.16]: double check that. was ' = DLF_ALLOW_LPV' (see CL 1380778)
 195                 light.SetLightColor(color);
 196                 light.SetSpecularMult(m_pProperties->specularMultiplier);
 197                 light.SetRadius(m_pProperties->radius, m_pProperties->attenuationBulbSize);
 198                 light.m_fHDRDynamic          = m_pProperties->hdrDynamicMultiplier;
 199                 light.m_fLightFrustumAngle   = m_pProperties->frustumAngle;
 200
 201                 const int slot = CEntityComponentBase::GetEntity().LoadLight(g_emptySlot, &light);
 202                 CEntityTransformComponentBase::SetSlot(slot, m_pProperties->transform);
 203
 204                 m_bOn = true;
 205         }
 206
 207         void CEntityLightComponent::SwitchOff()
 208         {
 209                 CEntityTransformComponentBase::FreeSlot();
 210
 211                 m_bOn = false;
 212         }
 213 }
 214
 215 SCHEMATYC2_GAME_ENV_AUTO_REGISTER(&SchematycBaseEnv::CEntityLightComponent::Register)