public static void StartScenePublish(SceneMetricsModel sceneLimits)
{
Dictionary <string, string> events = new Dictionary <string, string>();
events.Add("scene_limits", JsonConvert.SerializeObject(ConvertSceneMetricsModelToDictionary(sceneLimits)));
SendEditorEvent("start_publish_of_the_scene", events);
}
public void UpdateInfo()
{
if (currentParcelScene == null)
{
return;
}
if (IsParcelSceneSquare(currentParcelScene))
{
int size = (int)Math.Sqrt(currentParcelScene.sceneData.parcels.Length);
int meters = size * 16;
sceneLimitsView.SetTitleText($"{size}x{size} LAND <color=#959696>{meters}x{meters}m");
}
else
{
sceneLimitsView.SetTitleText(BIWSettings.CUSTOM_LAND);
}
SceneMetricsModel limits = currentParcelScene.metricsController.GetLimits();
SceneMetricsModel usage = currentParcelScene.metricsController.GetModel();
string leftDesc = AppendUsageAndLimit("ENTITIES", usage.entities, limits.entities);
leftDesc += "\n" + AppendUsageAndLimit("BODIES", usage.bodies, limits.bodies);
leftDesc += "\n" + AppendUsageAndLimit("TRIS", usage.triangles, limits.triangles);
string rightDesc = AppendUsageAndLimit("TEXTURES", usage.textures, limits.textures);
rightDesc += "\n" + AppendUsageAndLimit("MATERIALS", usage.materials, limits.materials);
rightDesc += "\n" + AppendUsageAndLimit("GEOMETRIES", usage.meshes, limits.meshes);
sceneLimitsView.SetLeftDescText(leftDesc);
sceneLimitsView.SetRightDescText(rightDesc);
SetFillInfo();
}
public static void SceneLimitsOverPassed(SceneMetricsModel sceneLimits)
{
Dictionary <string, string> events = new Dictionary <string, string>();
events.Add("scene_limits", JsonConvert.SerializeObject(ConvertSceneMetricsModelToDictionary(sceneLimits)));
SendEditorEvent("scene_limits_over_passed", events);
}
public static void EndScenePublish(SceneMetricsModel sceneLimits, string successOrError, float publicationTime)
{
Dictionary <string, string> events = new Dictionary <string, string>();
events.Add("success", successOrError);
events.Add("publication_time", publicationTime.ToString());
events.Add("scene_limits", JsonConvert.SerializeObject(ConvertSceneMetricsModelToDictionary(sceneLimits)));
SendEditorEvent("end_scene_publish", events);
}
void AssertMetricsModel(ParcelScene scene, int triangles, int materials, int entities, int meshes, int bodies,
int textures)
{
SceneMetricsModel inputModel = scene.metricsController.GetModel();
Assert.AreEqual(triangles, inputModel.triangles, "Incorrect triangle count, was: " + triangles);
Assert.AreEqual(materials, inputModel.materials, "Incorrect materials count");
Assert.AreEqual(entities, inputModel.entities, "Incorrect entities count");
Assert.AreEqual(meshes, inputModel.meshes, "Incorrect geometries/meshes count");
Assert.AreEqual(bodies, inputModel.bodies, "Incorrect bodies count");
Assert.AreEqual(textures, inputModel.textures, "Incorrect textures count");
}
public static WebInterface.MetricsModel ToMetricsModel(this SceneMetricsModel model)
{
return(new WebInterface.MetricsModel()
{
meshes = model.meshes,
bodies = model.bodies,
materials = model.materials,
textures = model.textures,
triangles = model.triangles,
entities = model.entities
});
}
private static Dictionary <string, string> ConvertSceneMetricsModelToDictionary(SceneMetricsModel sceneLimits)
{
Dictionary <string, string> sceneLimitsDictionary = new Dictionary <string, string>();
sceneLimitsDictionary.Add("meshes", sceneLimits.meshes.ToString());
sceneLimitsDictionary.Add("bodies", sceneLimits.bodies.ToString());
sceneLimitsDictionary.Add("materials", sceneLimits.materials.ToString());
sceneLimitsDictionary.Add("textures", sceneLimits.textures.ToString());
sceneLimitsDictionary.Add("triangles", sceneLimits.triangles.ToString());
sceneLimitsDictionary.Add("entities", sceneLimits.entities.ToString());
sceneLimitsDictionary.Add("scene_height", sceneLimits.sceneHeight.ToString());
return(sceneLimitsDictionary);
}
private bool IsInsideTheLimits(CatalogItem sceneObject)
{
if (HUDController.i.builderInWorldMainHud == null)
{
return(false);
}
SceneMetricsModel limits = sceneToEdit.metricsController.GetLimits();
SceneMetricsModel usage = sceneToEdit.metricsController.GetModel();
if (limits.bodies < usage.bodies + sceneObject.metrics.bodies)
{
HUDController.i.builderInWorldMainHud.ShowSceneLimitsPassed();
return(false);
}
if (limits.entities < usage.entities + sceneObject.metrics.entities)
{
HUDController.i.builderInWorldMainHud.ShowSceneLimitsPassed();
return(false);
}
if (limits.materials < usage.materials + sceneObject.metrics.materials)
{
HUDController.i.builderInWorldMainHud.ShowSceneLimitsPassed();
return(false);
}
if (limits.meshes < usage.meshes + sceneObject.metrics.meshes)
{
HUDController.i.builderInWorldMainHud.ShowSceneLimitsPassed();
return(false);
}
if (limits.textures < usage.textures + sceneObject.metrics.textures)
{
HUDController.i.builderInWorldMainHud.ShowSceneLimitsPassed();
return(false);
}
if (limits.triangles < usage.triangles + sceneObject.metrics.triangles)
{
HUDController.i.builderInWorldMainHud.ShowSceneLimitsPassed();
return(false);
}
return(true);
}
internal float GetHigherLimitPercentInfo()
{
SceneMetricsModel limits = currentParcelScene.metricsController.GetLimits();
SceneMetricsModel usage = currentParcelScene.metricsController.GetModel();
float percentEntities = usage.entities * 100 / limits.entities;
float percentBodies = usage.bodies * 100 / limits.bodies;
float percentTris = usage.triangles * 100 / limits.triangles;
float percentTexture = usage.textures * 100 / limits.textures;
float percentmats = usage.materials * 100 / limits.materials;
float percentMeshes = usage.meshes * 100 / limits.meshes;
float result = percentEntities;
if (percentBodies > result)
{
result = percentBodies;
}
if (percentTris > result)
{
result = percentTris;
}
if (percentTexture > result)
{
result = percentTexture;
}
if (percentmats > result)
{
result = percentmats;
}
if (percentMeshes > result)
{
result = percentMeshes;
}
return(result);
}
