Code/EditorPlugins/AngelScript/EditorPluginAngelScript/AngelScriptAsset/AngelScriptAsset.cpp - dev - redgpu/ezEngine

Code/EditorPlugins/AngelScript/EditorPluginAngelScript/AngelScriptAsset/AngelScriptAsset.cpp
300 строк10 KB
C-Core
Array usage cleanup (#1864)
11 мар 2026, 23:44
11 мар 2026, 23:44f7cb730
#include <EditorPluginAssets/EditorPluginAssetsPCH.h>

#include <EditorFramework/GUI/ExposedParameters.h>
#include <EditorPluginAngelScript/AngelScriptAsset/AngelScriptAsset.h>
#include <Foundation/CodeUtils/Preprocessor.h>
#include <GuiFoundation/PropertyGrid/PropertyMetaState.h>
#include <GuiFoundation/VisualGraph/Scene.moc.h>
#include <ToolsFoundation/Serialization/DocumentObjectConverter.h>
#include <ToolsFoundation/VisualGraph/VisualGraphCommandAccessor.h>

// clang-format off
EZ_BEGIN_STATIC_REFLECTED_ENUM(ezAngelScriptCodeMode, 1)
  EZ_ENUM_CONSTANTS(ezAngelScriptCodeMode::Inline, ezAngelScriptCodeMode::FromFile)
EZ_END_STATIC_REFLECTED_ENUM;

EZ_BEGIN_DYNAMIC_REFLECTED_TYPE(ezAngelScriptParameter, 1, ezRTTIDefaultAllocator<ezAngelScriptParameter>)
{
  EZ_BEGIN_PROPERTIES
  {
    EZ_MEMBER_PROPERTY("Name", m_sName)->AddAttributes(new ezReadOnlyAttribute()),
    EZ_MEMBER_PROPERTY("Declaration", m_sDeclaration)->AddAttributes(new ezReadOnlyAttribute()),
    EZ_MEMBER_PROPERTY("DefaultValue", m_DefaultValue)->AddAttributes(new ezHiddenAttribute()),
    EZ_MEMBER_PROPERTY("Expose", m_bExpose),
  }
  EZ_END_PROPERTIES;
}
EZ_END_DYNAMIC_REFLECTED_TYPE;

EZ_BEGIN_DYNAMIC_REFLECTED_TYPE(ezAngelScriptAssetProperties, 1, ezRTTIDefaultAllocator<ezAngelScriptAssetProperties>)
{
  EZ_BEGIN_PROPERTIES
  {
    EZ_ENUM_MEMBER_PROPERTY("Source", ezAngelScriptCodeMode, m_CodeMode),
    EZ_MEMBER_PROPERTY("SourceFile", m_sScriptFile)->AddAttributes(new ezFileBrowserAttribute("Select Script", "*.as", {}, "AngelScript")),
    EZ_MEMBER_PROPERTY("ClassName", m_sClassName)->AddAttributes(new ezDefaultValueAttribute("ScriptObject")),
    EZ_ARRAY_MEMBER_PROPERTY("Parameters", m_Parameters)->AddAttributes(new ezContainerAttribute(false, false, false)),
    EZ_ARRAY_MEMBER_PROPERTY("Dependencies", m_Dependencies)->AddAttributes(new ezContainerAttribute(false, false, false), new ezReadOnlyAttribute()),
    EZ_MEMBER_PROPERTY("Code", m_sCode)->AddAttributes(new ezHiddenAttribute(), new ezDefaultValueAttribute("class ScriptObject : ezAngelScriptClass\n\
{\n\t// int PublicIntVar = 0;\n\n\tvoid OnSimulationStarted()\n\t{\n\t\t// ezLog::Info(\"Simulation Started\");\n\t}\n\n\t// void Update() { }\n\n\t// void OnMsgTriggerTriggered(ezMsgTriggerTriggered@ msg) { }\n}")),
  }
  EZ_END_PROPERTIES;
}
EZ_END_DYNAMIC_REFLECTED_TYPE;

EZ_BEGIN_DYNAMIC_REFLECTED_TYPE(ezAngelScriptAssetDocument, 3, ezRTTINoAllocator)
EZ_END_DYNAMIC_REFLECTED_TYPE;
// clang-format on

ezAngelScriptAssetDocument::ezAngelScriptAssetDocument(ezStringView sDocumentPath)
  : ezSimpleAssetDocument<ezAngelScriptAssetProperties>(sDocumentPath, ezAssetDocEngineConnection::Simple)
{
}

ezTransformStatus ezAngelScriptAssetDocument::InternalTransformAsset(ezStreamWriter& stream, ezStringView sOutputTag, const ezPlatformProfile* pAssetProfile, const ezAssetFileHeader& AssetHeader, ezBitflags<ezTransformFlags> transformFlags)
{
  EZ_ASSERT_NOT_IMPLEMENTED;
  return ezTransformStatus("");
}

class ezAsPreprocessor2
{
public:
  ezStringBuilder m_sRefFilePath;
  ezStringBuilder m_sMainCode;
  ezSet<ezString> m_Dependencies;

  ezAsPreprocessor2()
  {
    m_Processor.SetFileOpenFunction(ezMakeDelegate(&ezAsPreprocessor2::PreProc_OpenFile, this));
    m_Processor.SetImplicitPragmaOnce(true);
  }

  ezResult Process()
  {
    ezStringBuilder sResult;
    return m_Processor.Process(m_sRefFilePath, sResult, false);
  };

private:
  ezResult PreProc_OpenFile(ezStringView sAbsFile, ezDynamicArray<ezUInt8>& out_Content, ezTimestamp& out_FileModification)
  {
    if (sAbsFile == m_sRefFilePath)
    {
      out_Content.SetCount(m_sMainCode.GetElementCount());
      ezMemoryUtils::RawByteCopy(out_Content.GetData(), m_sMainCode.GetData(), m_sMainCode.GetElementCount());
      return EZ_SUCCESS;
    }

    ezFileReader file;
    if (file.Open(sAbsFile).Failed())
      return EZ_FAILURE;

    m_Dependencies.Insert(sAbsFile);

    out_Content.SetCountUninitialized((ezUInt32)file.GetFileSize());
    file.ReadBytes(out_Content.GetData(), out_Content.GetCount());
    return EZ_SUCCESS;
  }

  ezPreprocessor m_Processor;
};

ezTransformStatus ezAngelScriptAssetDocument::InternalTransformAsset(const char* szTargetFile, ezStringView sOutputTag, const ezPlatformProfile* pAssetProfile, const ezAssetFileHeader& AssetHeader, ezBitflags<ezTransformFlags> transformFlags)
{
  SyncInfos();

  const bool bCanModify = !transformFlags.IsSet(ezTransformFlags::BackgroundProcessing);

  auto pProps = GetProperties();

  ezAsPreprocessor2 preProc;

  if (pProps->m_CodeMode == ezAngelScriptCodeMode::Inline)
  {
    preProc.m_sRefFilePath = GetDocumentPath();
    preProc.m_sMainCode = pProps->m_sCode;

    ezQtEditorApp::GetSingleton()->MakePathDataDirectoryRelative(preProc.m_sRefFilePath);
  }
  else
  {
    preProc.m_sRefFilePath = pProps->m_sScriptFile;

    ezFileReader file;
    if (file.Open(pProps->m_sScriptFile).Succeeded())
    {
      preProc.m_sMainCode.ReadAll(file);
    }
  }

  if (preProc.Process().Succeeded())
  {
    ezTempHybridArray<ezString, 16> newDeps;
    for (const auto& str : preProc.m_Dependencies)
    {
      newDeps.PushBack(str);
    }

    if (pProps->m_Dependencies != newDeps)
    {
      if (!bCanModify)
        return ezTransformResult::NeedsImport;

      auto pPropObj = GetPropertyObject();

      ezCommandHistory* history = GetCommandHistory();
      ezObjectCommandAccessor accessor(history);

      accessor.StartTransaction("Update Dependencies");

      // clear the entire array
      accessor.ClearByName(pPropObj, "Dependencies").AssertSuccess();

      const ezAbstractProperty* pPropDeps = pPropObj->GetType()->FindPropertyByName("Dependencies");

      // and fill it again
      for (ezUInt32 clip = 0; clip < newDeps.GetCount(); ++clip)
      {
        accessor.InsertValue(pPropObj, pPropDeps, newDeps[clip], -1).AssertSuccess();
      }

      accessor.FinishTransaction();
    }
  }

  return ezAssetDocument::RemoteExport(AssetHeader, szTargetFile);
}

void ezAngelScriptAssetDocument::SyncInfos()
{
  auto pProps = GetProperties();

  if (pProps->m_CodeMode == ezAngelScriptCodeMode::FromFile)
  {
    ezDocumentConfigMsgToEngine cfg;
    cfg.m_sWhatToDo = "InputFile";
    cfg.m_sValue = pProps->m_sScriptFile;
    GetEditorEngineConnection()->SendMessage(&cfg);
  }
  else
  {
    {
      ezStringBuilder sStartFile = GetDocumentPath();
      ezQtEditorApp::GetSingleton()->MakePathDataDirectoryRelative(sStartFile);
      sStartFile.Prepend(":inline:");

      ezDocumentConfigMsgToEngine cfg;
      cfg.m_sWhatToDo = "InputFile";
      cfg.m_sValue = sStartFile;
      GetEditorEngineConnection()->SendMessage(&cfg);
    }

    {
      ezDocumentConfigMsgToEngine cfg;
      cfg.m_sWhatToDo = "Code";
      cfg.m_sValue = pProps->m_sCode;
      GetEditorEngineConnection()->SendMessage(&cfg);
    }
  }

  {
    ezDocumentConfigMsgToEngine cfg;
    cfg.m_sWhatToDo = "Class";
    cfg.m_sValue = pProps->m_sClassName;
    GetEditorEngineConnection()->SendMessage(&cfg);
  }
}

void ezAngelScriptAssetDocument::UpdateAssetDocumentInfo(ezAssetDocumentInfo* pInfo) const
{
  SUPER::UpdateAssetDocumentInfo(pInfo);

  ezExposedParameters* pExposedParams = EZ_DEFAULT_NEW(ezExposedParameters);

  for (const auto& p : GetProperties()->m_Parameters)
  {
    if (p.m_bExpose == false || p.m_sName.IsEmpty() || !p.m_DefaultValue.IsValid())
      continue;

    ezExposedParameter* param = EZ_DEFAULT_NEW(ezExposedParameter);
    param->m_sName = p.m_sName;
    param->m_DefaultValue = p.m_DefaultValue;

    // TODO AngelScript: support resource handles and pass through the necessary attributes
    //
    // if (p.m_DefaultValue.IsA<ezString>())
    //{
    //   param->m_Attributes.PushBack(new ezAssetBrowserAttribute("CompatibleAsset_Material"));
    // }

    pExposedParams->m_Parameters.PushBack(param);
  }

  for (const auto& p : GetProperties()->m_Dependencies)
  {
    pInfo->m_TransformDependencies.Insert(p);
  }

  // Info takes ownership of meta data.
  pInfo->m_MetaInfo.PushBack(pExposedParams);
}

void ezAngelScriptAssetDocument::OpenExternalEditor()
{
  ezStringBuilder sScriptFile(GetProperties()->m_sScriptFile);

  if (GetProperties()->m_CodeMode != ezAngelScriptCodeMode::FromFile)
  {
    ezQtUiServices::GetSingleton()->MessageBoxInformation("The source for this asset is 'inline'. To be able to view it in an external program, it has to be moved into a dedicated file.");

    ShowDocumentStatus("Can't open script file, source code is 'inline'.");
    return;
  }

  if (!ezFileSystem::ExistsFile(sScriptFile))
  {
    ezQtUiServices::GetSingleton()->MessageBoxInformation(ezFmt("Can't find the file '{}'.\nTo create a script file click the button next to 'SourceFile'.", sScriptFile));

    ShowDocumentStatus("Script file doesn't exist.");
    return;
  }

  ezStringBuilder sScriptFileAbs;
  if (ezFileSystem::ResolvePath(sScriptFile, &sScriptFileAbs, nullptr).Failed())
    return;

  {
    QStringList args;

    args.append(ezMakeQString(ezToolsProject::GetSingleton()->GetProjectDirectory()));
    args.append(sScriptFileAbs.GetData());

    if (ezQtUiServices::OpenInVsCode(args).Failed())
    {
      // try again with a different program
      ezQtUiServices::OpenFileInDefaultProgram(sScriptFileAbs).IgnoreResult();
    }
  }
}

void ezAngelScriptAssetDocument::SyncExposedParameters()
{
  SyncInfos();

  ezDocumentConfigMsgToEngine cfg;
  cfg.m_sWhatToDo = "SyncExposedParams";
  GetEditorEngineConnection()->SendMessage(&cfg);
}

void ezAngelScriptAssetDocument::PropertyMetaStateEventHandler(ezPropertyMetaStateEvent& e)
{
  if (e.m_pObject->GetTypeAccessor().GetType() == ezGetStaticRTTI<ezAngelScriptAssetProperties>())
  {
    const ezInt64 sourceMode = e.m_pObject->GetTypeAccessor().GetValue("Source").ConvertTo<ezInt64>();

    auto& props = *e.m_pPropertyStates;

    props["SourceFile"].m_Visibility = (sourceMode == ezAngelScriptCodeMode::Inline) ? ezPropertyUiState::Invisible : ezPropertyUiState::Default;
  }
}