SCR_WorldEditorToolHelper.c

Go to the documentation of this file.

#ifdef WORKBENCH
class SCR_WorldEditorToolHelper
{
    protected static ref array<IEntity> s_aTempEntities;
 
    protected static const string WEB_PREFIX = "https://enfusionengine.com/api/redirect?to=";
 
    //------------------------------------------------------------------------------------------------
    static ResourceManager GetResourceManager()
    {
        return Workbench.GetModule(ResourceManager);
    }
 
    //------------------------------------------------------------------------------------------------
    static WorldEditor GetWorldEditor()
    {
        return Workbench.GetModule(WorldEditor);
    }
 
    //------------------------------------------------------------------------------------------------
    static WorldEditorAPI GetWorldEditorAPI()
    {
        WorldEditor worldEditor = GetWorldEditor();
        if (!worldEditor)
            return null;
 
        return worldEditor.GetApi();
    }
 
    //------------------------------------------------------------------------------------------------
    static IEntitySource GetPrefabEditModeEntitySource()
    {
        WorldEditor worldEditor = GetWorldEditor();
        if (!worldEditor)
            return null;
 
        if (!worldEditor.IsPrefabEditMode())
            return null;
 
        WorldEditorAPI worldEditorAPI = worldEditor.GetApi();
        if (worldEditorAPI.GetEditorEntityCount() != 2) // world and Entity
            return null;
 
        return worldEditorAPI.GetEditorEntity(1);
    }
 
    //------------------------------------------------------------------------------------------------
    static ResourceName GetPrefabEditModeResourceName()
    {
        IEntitySource entitySource = GetPrefabEditModeEntitySource();
        if (!entitySource)
            return string.Empty;
 
        BaseContainer ancestor = entitySource.GetAncestor();
        if (!ancestor)
            return string.Empty;
 
        return ancestor.GetResourceName();
    }
 
    //------------------------------------------------------------------------------------------------
    static string GetCurrentWorldEditorLink(bool useWebPrefix = false)
    {
        WorldEditorAPI worldEditorAPI = GetWorldEditorAPI();
        if (!worldEditorAPI)
            return string.Empty;
 
        BaseWorld world = worldEditorAPI.GetWorld();
        if (!world)
            return string.Empty;
 
        vector transform[4];
        world.GetCurrentCamera(transform);
 
        return SCR_WorldEditorToolHelper.GetCurrentWorldEditorLink(transform[3], Math3D.MatrixToAngles(transform), useWebPrefix);
    }
 
    //------------------------------------------------------------------------------------------------
    static string GetCurrentWorldEditorLink(vector position, vector angles, bool useWebPrefix = false)
    {
        WorldEditorAPI worldEditorAPI = GetWorldEditorAPI();
        if (!worldEditorAPI)
            return string.Empty;
 
        string fullLink;
        worldEditorAPI.GetWorldPath(fullLink);
 
        if (fullLink.IsEmpty())
            return string.Empty;
 
        string worldPath = fullLink;
        if (worldPath[0] == "$")
            worldPath = "~" + worldPath.Substring(1, worldPath.Length() - 1);
        else
        if (worldPath[0] != "~")
        {
            // if we don't have an exact path (should not happen),
            // fallback to the original solution:
 
            // we want to substring only /worlds/(...)
            // to prevent exposing local folders, etc.
            string fullLinkLC = fullLink;
            fullLinkLC.ToLower();
 
            int begin = fullLinkLC.IndexOf("worlds\\");
            if (begin == -1)
                begin = fullLinkLC.IndexOf("worlds/");
 
            if (begin == -1)
                return string.Empty;
 
            worldPath = fullLink.Substring(begin, fullLink.Length() - begin);
        }
 
        // Have consistent link
        worldPath.Replace("\\", "/");
 
        if (position == vector.Zero && angles == vector.Zero)
            return "enfusion://WorldEditor/" + worldPath;
 
        string result = string.Format(
            "enfusion://WorldEditor/%1;%2,%3,%4;%5,%6,%7",
            worldPath,
            position[0],
            position[1],
            position[2],
            angles[1],
            angles[0],
            angles[2]);
 
        if (useWebPrefix)
            return WEB_PREFIX + result;
        else
            return result;
    }
 
    //------------------------------------------------------------------------------------------------
    static string GetWorldName()
    {
        string result = FilePath.StripExtension(FilePath.StripPath(GetWorldPath()));
        if (!result) // .IsEmpty()
            return "Unknown";
 
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    static string GetWorldPath()
    {
        WorldEditorAPI worldEditorAPI = GetWorldEditorAPI();
        if (!worldEditorAPI)
            return string.Empty;
 
        string result;
        worldEditorAPI.GetWorldPath(result);
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    static bool IsWorldLoaded()
    {
        WorldEditor worldEditor = Workbench.GetModule(WorldEditor);
        if (!worldEditor)
            return false;
 
        if (worldEditor.IsPrefabEditMode())
            return false;
 
        WorldEditorAPI worldEditorAPI = worldEditor.GetApi();
        if (!worldEditorAPI)
            return false;
 
        string worldPath;
        worldEditorAPI.GetWorldPath(worldPath);
        return worldPath && worldEditorAPI.GetWorld() != null; // !.IsEmpty()
    }
 
    //------------------------------------------------------------------------------------------------
    static bool HasTerrainMesh()
    {
        WorldEditor worldEditor = Workbench.GetModule(WorldEditor);
        if (!worldEditor)
            return false;
 
        vector min, max;
        worldEditor.GetTerrainBounds(min, max);
        return max != vector.Zero || min != vector.Zero;
    }
 
    //------------------------------------------------------------------------------------------------
    static IEntitySource GetTerrainEntitySource()
    {
        WorldEditor worldEditor = GetWorldEditor();
        if (!worldEditor)
            return null;
 
        if (worldEditor.IsPrefabEditMode())
            return null;
 
        WorldEditorAPI worldEditorAPI = worldEditor.GetApi();
        if (worldEditorAPI.GetEditorEntityCount() < 2) // world and Entity
            return null;
 
        IEntitySource entitySource;
        for (int i, entitiesCount = worldEditorAPI.GetEditorEntityCount(); i < entitiesCount; ++i)
        {
            entitySource = worldEditorAPI.GetEditorEntity(i);
            if (entitySource && entitySource.GetClassName().ToType() && entitySource.GetClassName().ToType().IsInherited(GenericTerrainEntity))
                return entitySource;
        }
 
        return null;
    }
 
    //------------------------------------------------------------------------------------------------
    static vector GetTerrainDimensions()
    {
        WorldEditor worldEditor = Workbench.GetModule(WorldEditor);
        vector min, max;
        worldEditor.GetTerrainBounds(min, max);
        return max - min;
    }
 
    //------------------------------------------------------------------------------------------------
    static void GetTerrainMinMaxY(out float minY, out float maxY)
    {
        WorldEditor worldEditor = Workbench.GetModule(WorldEditor);
        vector min, max;
        worldEditor.GetTerrainBounds(min, max);
 
        minY = min[1];
        maxY = max[1];
    }
 
    //------------------------------------------------------------------------------------------------
    static bool GetTerrainMinMaxElevationPositions(out vector min, out vector max)
    {
        WorldEditorAPI worldEditorAPI = GetWorldEditorAPI();
        if (!HasTerrainMesh())
            return false;
 
        float minY, maxY;
        GetTerrainMinMaxY(minY, maxY);
 
        vector terrainPosition = GetTerrainPosition();
        float minX = terrainPosition[0];
        float minZ = terrainPosition[2];
 
        vector terrainDimensions = GetTerrainDimensions();
        float maxX = minX + terrainDimensions[0];
        float maxZ = minZ + terrainDimensions[2];
 
        float step = worldEditorAPI.GetTerrainUnitScale();
 
        bool hasMinY, hasMaxY;
 
        float y;
        for (float z = minZ, limitZ = maxZ; z <= limitZ; z += step)
        {
            for (float x = minX, limitX = maxX; x <= limitX; x += step)
            {
                if (!worldEditorAPI.TryGetTerrainSurfaceY(x, z, y))
                    continue;
 
                if (!hasMaxY && y == maxY)
                {
                    max = { x, y, z };
                    hasMaxY = true;
                }
                else
                if (!hasMinY && y == minY)
                {
                    min = { x, y, z };
                    hasMinY = true;
                }
 
                if (hasMinY && hasMaxY)
                    return true;
            }
        }
 
        return hasMinY && hasMaxY;
    }
 
    //------------------------------------------------------------------------------------------------
    static float GetTerrainLandArea(int terrainIndex = 0)
    {
        if (terrainIndex < 0)
            return -1;
 
        WorldEditorAPI worldEditorAPI = SCR_WorldEditorToolHelper.GetWorldEditorAPI();
 
        BaseWorld world = worldEditorAPI.GetWorld();
        if (!world)
            return -1;
 
        const float cellSideSize = worldEditorAPI.GetTerrainUnitScale(terrainIndex);
        if (cellSideSize <= 0)
            return -1; // wrong terrain index or no terrain loaded
 
        const float cellSideSizeSq = cellSideSize * cellSideSize;
 
        if (!world.IsOcean()) // no ocean = everything is land
        {
            return cellSideSizeSq
                * (worldEditorAPI.GetTerrainResolutionX(terrainIndex) - 1)
                * (worldEditorAPI.GetTerrainResolutionY(terrainIndex) - 1);
        }
 
        const float oceanLevel = worldEditorAPI.GetWorld().GetOceanBaseHeight();
        if (oceanLevel == -float.MAX) // just some safety, most likely not needed
        {
            return cellSideSizeSq
                * (worldEditorAPI.GetTerrainResolutionX(terrainIndex) - 1)
                * (worldEditorAPI.GetTerrainResolutionY(terrainIndex) - 1);
        }
 
        const int tileXCount = worldEditorAPI.GetTerrainTilesX(terrainIndex);
        const int tileYCount = worldEditorAPI.GetTerrainTilesY(terrainIndex);
 
        const int tileSideSizeX = (worldEditorAPI.GetTerrainResolutionX(terrainIndex) - 1) / tileXCount;
        const int tileSideSizeY = (worldEditorAPI.GetTerrainResolutionY(terrainIndex) - 1) / tileYCount;
 
        const int tileArea = tileSideSizeX * tileSideSizeY;
        const int tileValuesCount = (tileSideSizeX + 1) * (tileSideSizeY + 1); // +1 - e.g 32×32 cells = 33×33 vertices
        array<float> tileYs = {};
        tileYs.Resize(tileValuesCount);
 
        float result;
 
        int bottomLeftIndex, bottomRightIndex;
        float topLeftY, bottomLeftY, topRightY, bottomRightY;
        bool aboveZeroTL, aboveZeroTR, aboveZeroBL, aboveZeroBR;
        bool tileHasAboveZeroArea, tileHasBelowZeroArea;
        for (int tileY; tileY < tileYCount; ++tileY)
        {
            for (int tileX; tileX < tileXCount; ++tileX)
            {
                if (!worldEditorAPI.GetTerrainSurfaceTile(terrainIndex, tileX, tileY, tileYs))
                {
                    PrintFormat("Invalid tile %1:%2", tileX, tileY, level: LogLevel.ERROR);
                    return -1;
                }
 
                tileHasAboveZeroArea = false;
                tileHasBelowZeroArea = false;
                foreach (float yValue : tileYs)
                {
                    if (yValue >= oceanLevel)
                    {
                        tileHasAboveZeroArea = true;
                        if (tileHasBelowZeroArea)
                            break;
                    }
                    else
                    {
                        tileHasBelowZeroArea = true;
                        if (tileHasAboveZeroArea)
                            break;
                    }
                }
 
                if (!tileHasAboveZeroArea) // full underwater
                    continue;
 
                if (!tileHasBelowZeroArea) // full above water
                {
                    result += tileArea * cellSideSizeSq;
                    continue;
                }
 
                float tileSurface; // intermediate variable needed for big terrains (e.g Balta) due to float precision
                for (int tileValueY = 1; tileValueY <= tileSideSizeY; ++tileValueY)
                {
                    for (int tileValueX = 1; tileValueX <= tileSideSizeX; ++tileValueX)
                    {
                        if (tileValueX == 1)
                        {
                            bottomLeftIndex = tileValueX - 1 + tileSideSizeY * (tileValueY - 1);
                            topLeftY = tileYs[bottomLeftIndex + tileSideSizeY];
                            bottomLeftY = tileYs[bottomLeftIndex];
                        }
                        else
                        {
                            bottomLeftIndex = bottomRightIndex;
                            topLeftY = topRightY;
                            bottomLeftY = bottomRightY;
                        }
 
                        bottomRightIndex = bottomLeftIndex + 1;
                        topRightY = tileYs[bottomLeftIndex + tileSideSizeY + 1];
                        bottomRightY = tileYs[bottomRightIndex];
 
                        aboveZeroTL = topLeftY >= 0;
                        aboveZeroTR = topRightY >= 0;
                        aboveZeroBL = bottomLeftY >= 0;
                        aboveZeroBR = bottomRightY >= 0;
                        if (aboveZeroTL == aboveZeroTR && aboveZeroTL == aboveZeroBL && aboveZeroTL == aboveZeroBR) // everything equal
                        {
                            if (aboveZeroTL) // all points are >= 0
                                tileSurface += 1; // one full cell
 
                            continue;
                        }
 
                        // top-right triangle
                        if (aboveZeroTL == aboveZeroTR && aboveZeroTL == aboveZeroBR)
                        {
                            if (aboveZeroTL)
                                tileSurface += 0.5;
                        }
                        else
                        {
                            tileSurface += GetTriangle2DAreaAboveOceanLevel(topLeftY, topRightY, bottomRightY, oceanLevel);
                        }
 
                        // bottom-left triangle
                        if (aboveZeroTL == aboveZeroBL && aboveZeroTL == aboveZeroBR)
                        {
                            if (aboveZeroTL)
                                tileSurface += 0.5;
                        }
                        else
                        {
                            tileSurface += GetTriangle2DAreaAboveOceanLevel(topLeftY, bottomLeftY, bottomRightY, oceanLevel);
                        }
                    }
                }
 
                result += tileSurface * cellSideSizeSq;
            }
        }
 
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    protected static float GetTriangle2DAreaAboveOceanLevel(float a, float b, float c, float oceanLevel = 0)
    {
        array<float> heights = { a - oceanLevel, b - oceanLevel, c - oceanLevel };
        heights.Sort();
 
        if (heights[2] < 0)
            return 0;
 
        const float area = 0.5;
 
        // all above zero
        if (heights[0] >= 0)
            return area;
 
        // only heights[2] is above zero → small positive triangle near heights[2]
        if (heights[1] < 0)
        {
            float r1 = heights[2] / (heights[2] - heights[0]);
            float r2 = heights[2] / (heights[2] - heights[1]);
            return area * r1 * r2 * heights[2] / 3;
        }
 
        // heights[0] < 0, heights[1] >= 0, heights[2] > 0 → cut away negative triangle near heights[0]
        float s1 = -heights[0] / (heights[1] - heights[0]);
        float s2 = -heights[0] / (heights[2] - heights[0]);
        float negSubArea = area * s1 * s2;
        // negative sub-triangle has heights (heights[0], 0, 0), volume = negSubArea * heights[0] / 3
        // total = full volume - negative sub volume
        return area * (heights[0] + heights[1] + heights[2]) / 3 - negSubArea * heights[0] / 3;
    }
 
    //------------------------------------------------------------------------------------------------
    static vector GetTerrainPosition()
    {
        IEntitySource terrainEntitySource = GetTerrainEntitySource();
        if (!terrainEntitySource)
            return vector.Zero;
 
        vector result;
        terrainEntitySource.Get("coords", result);
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    static IEntitySource GetTimeAndWeatherManagerEntitySource()
    {
        WorldEditor worldEditor = GetWorldEditor();
        if (!worldEditor)
            return null;
 
        if (worldEditor.IsPrefabEditMode())
            return null;
 
        WorldEditorAPI worldEditorAPI = worldEditor.GetApi();
        if (worldEditorAPI.GetEditorEntityCount() < 2) // world and Entity
            return null;
 
        IEntitySource entitySource;
        for (int i, entitiesCount = worldEditorAPI.GetEditorEntityCount(); i < entitiesCount; ++i)
        {
            entitySource = worldEditorAPI.GetEditorEntity(i);
            if (entitySource && entitySource.GetClassName().ToType() && entitySource.GetClassName().ToType().IsInherited(TimeAndWeatherManagerEntity))
                return entitySource;
        }
 
        return null;
    }
 
    //------------------------------------------------------------------------------------------------
    static vector GetWorldEditorCameraPosition(out vector direction = vector.Zero)
    {
        WorldEditorAPI worldEditorAPI = GetWorldEditorAPI();
        if (!worldEditorAPI)
            return vector.Zero;
 
        vector result, traceEnd;
        worldEditorAPI.TraceWorldPos(0, 0, 0, result, traceEnd, direction);
 
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    static ResourceName GetResourceNameFromFile(string absoluteFilePath)
    {
        MetaFile metaFile = GetResourceManager().GetMetaFile(absoluteFilePath);
        if (!metaFile)
            return string.Empty;
 
        return metaFile.GetResourceID();
    }
 
    //------------------------------------------------------------------------------------------------
    static array<ResourceName> GetSelectedDirectories()
    {
        array<ResourceName> result = GetSelectedResources(true);
        if (!result)
            return null;
 
        for (int i = result.Count() - 1; i >= 0; i--)
        {
            ResourceName selectedResource = result[i];
            if (FilePath.StripExtension(selectedResource) != selectedResource)
                result.RemoveOrdered(i);
        }
 
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    static array<ResourceName> GetSelectedOrOpenedResources(string wantedExtension, array<string> keywords = null)
    {
        return GetSelectedOrOpenedResources({ wantedExtension }, keywords);
    }
 
    //------------------------------------------------------------------------------------------------
    static array<IEntitySource> GetSelectedWorldEntitySources()
    {
        WorldEditorAPI worldEditorAPI = GetWorldEditorAPI();
        if (!worldEditorAPI)
            return null;
 
        array<IEntitySource> result = {};
        IEntitySource entitySource;
        for (int i, count = worldEditorAPI.GetSelectedEntitiesCount(); i < count; ++i)
        {
            entitySource = worldEditorAPI.GetSelectedEntity(i);
            if (entitySource)
                result.Insert(entitySource);
        }
 
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    static array<ResourceName> GetSelectedOrOpenedResources(array<string> acceptedExtensions = null, array<string> keywords = null)
    {
        array<ResourceName> tempResult = GetSelectedResources(true);
        if (tempResult.IsEmpty())
        {
            ResourceName openedResource = GetPrefabEditModeResourceName();
            if (!openedResource.IsEmpty())
                tempResult.Insert(openedResource);
        }
 
        if (tempResult.IsEmpty())
            return tempResult;
 
        if (acceptedExtensions && acceptedExtensions.IsEmpty())
            acceptedExtensions = null;
 
        if (acceptedExtensions)
        {
            foreach (int i, string wantedExtension : acceptedExtensions)
            {
                wantedExtension.ToLower();
                acceptedExtensions[i] = wantedExtension;
            }
        }
 
        array<string> keywordsLC;
        if (keywords && !keywords.IsEmpty())
        {
            keywordsLC = {};
            foreach (string keyword : keywords)
            {
                if (keyword.IsEmpty())
                    continue;
 
                keyword.ToLower();
                keywordsLC.Insert(keyword);
            }
        }
 
        array<ResourceName> result = {};
 
        foreach (ResourceName resourceName : tempResult)
        {
            string resourceNameLC = resourceName;
            resourceNameLC.ToLower();
 
            string extensionLC;
            resourceNameLC = FilePath.StripExtension(resourceName, extensionLC);
            extensionLC.ToLower();
 
            if (acceptedExtensions && !acceptedExtensions.Contains(extensionLC))
                continue;
 
            resourceNameLC = FilePath.StripPath(resourceNameLC);
 
            if (!keywordsLC || SCR_StringHelper.ContainsEvery(resourceNameLC, keywordsLC))
                result.Insert(resourceName);
        }
 
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    static array<ResourceName> GetSelectedResources(bool recursive = true)
    {
        WorldEditor worldEditor = GetWorldEditor();
        if (!worldEditor)
            return null;
 
        array<ResourceName> result = {};
        worldEditor.GetResourceBrowserSelection(result.Insert, recursive);
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    [Obsolete("Use SCR_WorkbenchHelper.SearchWorkbenchResources instead")] // obsolete since 2025-03-03
    static array<ResourceName> SearchWorkbenchResources(array<string> fileExtensions = null, array<string> searchStrArray = null, string rootPath = "", bool recursive = true)
    {
        return SCR_WorkbenchHelper.SearchWorkbenchResources(fileExtensions, searchStrArray, rootPath, recursive);
    }
 
    //------------------------------------------------------------------------------------------------
    static void DeleteEntityFromSource(IEntitySource entitySource)
    {
        if (!entitySource)
            return;
 
        WorldEditorAPI worldEditorAPI = GetWorldEditorAPI();
        if (!worldEditorAPI)
        {
            Print("WorldEditorAPI is not available", LogLevel.ERROR);
            return;
        }
 
        bool manageEditAction = BeginEntityAction();
 
        worldEditorAPI.DeleteEntity(entitySource);
 
        EndEntityAction(manageEditAction);
    }
 
    //------------------------------------------------------------------------------------------------
    static bool BeginEntityAction()
    {
        WorldEditorAPI worldEditorAPI = GetWorldEditorAPI();
        if (!worldEditorAPI)
        {
            Print("WorldEditorAPI is not available", LogLevel.ERROR);
            return false;
        }
 
        if (worldEditorAPI.IsDoingEditAction())
            return false;
 
        return worldEditorAPI.BeginEntityAction();
    }
 
    //------------------------------------------------------------------------------------------------
    static void EndEntityAction(bool manageEditAction)
    {
        WorldEditorAPI worldEditorAPI = GetWorldEditorAPI();
        if (!worldEditorAPI)
        {
            Print("WorldEditorAPI is not available", LogLevel.ERROR);
            return;
        }
 
        if (manageEditAction)
            worldEditorAPI.EndEntityAction();
    }
 
    //------------------------------------------------------------------------------------------------
    static array<IEntity> QueryEntitiesByAABB(notnull World world, vector mins, vector maxs, EQueryEntitiesFlags queryFlags = EQueryEntitiesFlags.ALL)
    {
        s_aTempEntities = {};
        if (!world.QueryEntitiesByAABB(mins, maxs, QueryEntitiesCallbackMethod, null, queryFlags))
            return null;
 
        array<IEntity> result = {};
        result.Copy(s_aTempEntities);
        s_aTempEntities = null;
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    static array<IEntity> QueryEntitiesBySphere(notnull World world, vector worldPos, float radius, EQueryEntitiesFlags queryFlags = EQueryEntitiesFlags.ALL)
    {
        array<IEntity> result = {};
        s_aTempEntities = {};
        world.QueryEntitiesBySphere(worldPos, radius, QueryEntitiesCallbackMethod, null, queryFlags);
        result.Copy(s_aTempEntities);
        s_aTempEntities = null;
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    static array<IEntity> TraceMoveEntitiesBySphere(notnull World world, notnull TraceSphere traceSphere)
    {
        array<IEntity> result = {};
 
        s_aTempEntities = {};
        world.TraceMove(traceSphere, TraceCallbackMethod);
 
        result.Copy(s_aTempEntities);
        s_aTempEntities = null;
 
        return result;
    }
 
    //------------------------------------------------------------------------------------------------
    static array<IEntity> TracePositionEntitiesBySphere(notnull World world, notnull TraceSphere traceSphere)
    {
        array<IEntity> result = {};
 
        s_aTempEntities = {};
        world.TracePosition(traceSphere, TraceCallbackMethod);
 
        result.Copy(s_aTempEntities);
        s_aTempEntities = null;
 
        return result;
    }
 
    //
    // Callbacks
    //
 
    //------------------------------------------------------------------------------------------------
    protected static bool QueryEntitiesCallbackMethod(IEntity e)
    {
        s_aTempEntities.Insert(e);
        return true;
    }
 
    //------------------------------------------------------------------------------------------------
    protected static bool TraceCallbackMethod(notnull IEntity e, vector start = "0 0 0", vector dir = "0 0 0")
    {
        s_aTempEntities.Insert(e);
        return true;
    }
}
#endif // WORKBENCH