public IEnumerator AVGIsZeroWhenSourceShouldBeActive_Test()
{
// setup
float expected = 0f;
IInputWrapper input = Substitute.For <IInputWrapper>();
input.GetKeyDown(KeyCode.Space).Returns(true);
SetPrivateField(UnityInput.Instance, "input", input);
// till start is called
yield return(new WaitForEndOfFrame());
// till update is called
yield return(new WaitForEndOfFrame());
// perform
input.GetKeyDown(KeyCode.Space).Returns(false);
yield return(new WaitForSeconds(1f));
// get
controller = GetPrivateField <MeshController, RayReciever>(reciever, "controller");
float[] doses = controller.VerticeData.Select(x => x.Dose).ToArray();
float actual = DoseCalculator.GetAVGDose(doses);
// assert
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Exports all the components in this group to the in-RAM mesh.
/// </summary>
/// <param name="group">Group to export from</param>
/// <param name="reporter">Progress reporter</param>
public BXDAMesh ExportAll(CustomRigidGroup group, Guid guid, BXDIO.ProgressReporter reporter = null)
{
// Create output mesh
MeshController outputMesh = new MeshController(guid);
// Collect surfaces to export
List <SurfaceBody> plannedSurfaces = GenerateExportList(group, outputMesh.Mesh.physics);
// Export faces, multithreaded
if (plannedSurfaces.Count > 0)
{
// Reset progress bar
reporter?.Invoke(0, plannedSurfaces.Count);
// Start jobs
int totalJobsFinished = 0;
object finishLock = new object(); // Used to prevent multiple threads from updating progress bar at the same time.
Parallel.ForEach(plannedSurfaces, (SurfaceBody surface) =>
{
CalculateSurfaceFacets(surface, outputMesh, SynthesisGUI.PluginSettings.GeneralUseFancyColors);
lock (finishLock)
{
totalJobsFinished++;
reporter?.Invoke(totalJobsFinished, plannedSurfaces.Count);
}
});
outputMesh.DumpOutput();
}
return(outputMesh.Mesh);
}
void Start()
{
meshController = GameObject.Find("Collider").GetComponent <MeshController>();
flowerBloom = GameObject.Find("Flower").GetComponent <FlowerBloom>();
GetComponent <MeshFilter>().mesh = new Mesh();
InitMesh();
}
public void CopyFromOtherMeshController(MeshController m, bool xMirror = false, bool yMirror = false, bool zMirror = false)
{
if (indexes.Count() != m.indexes.Count())
{
return;
}
int indexesLength = indexes.Length;
// neutralのコピー
neutral = new Preset();
neutral.label = m.neutral.label;
for (int i = 0; i < indexesLength; i++)
{
Vector3 v = m.neutral.vertexPos[i].position;
neutral.vertexPos.Add(new VertexPos(indexes[i], new Vector3(xMirror ? -v.x : v.x, yMirror ? -v.y : v.y, zMirror ? -v.z : v.z)));
}
neutral.locked = m.neutral.locked;
// presetsのコピー
presets.Clear();
foreach (Preset p in m.presets)
{
Preset copiedPreset = new Preset();
copiedPreset.label = p.label;
for (int i = 0; i < indexesLength; i++)
{
Vector3 v = p.vertexPos[i].position;
copiedPreset.vertexPos.Add(new VertexPos(indexes[i], new Vector3(xMirror ? -v.x : v.x, yMirror ? -v.y : v.y, zMirror ? -v.z : v.z)));
}
copiedPreset.locked = p.locked;
presets.Add(copiedPreset);
}
}
// Update is called once per frame
void Update()
{
if (Input.GetMouseButtonDown(0))
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit))
{
GameObject g = GameObject.CreatePrimitive(PrimitiveType.Sphere);
g.transform.position = hit.point;
g.transform.localScale = Vector3.one * 0.3f;
meshPoints.Add(hit.point);
}
}
if (Input.GetKeyDown(KeyCode.Space))
{
MeshController meshController = new MeshController();
try
{
mesh = meshController.CreateSubMesh(meshPoints, thickness, "new_Mesh");
//BoxProjection b = new BoxProjection();
//b.BoxUvProjection(mesh.mesh, AXIS.X, 1, 45);
//b.BoxUvProjection(mesh.mesh, AXIS.Y, 1, 45);
//b.BoxUvProjection(mesh.mesh, AXIS.Z, 1, 45);
}
catch (System.Exception e)
{
print(e);
}
meshPoints.Clear();
}
}
//Main build function called by the map generator
public IEnumerator Build(int w, int h, MeshController mC, GameSettings s)
{
//Initializing necessary variables
settings = s;
meshController = mC;
width = w;
height = h;
int numVerts = CalculateVertices(w, h);
int numTris = TriArrayCalculator(w, h);
InitializeMeshData(numVerts, numTris);
//Lays out the geometry for the mesh as well as the UV coordinates
yield return(PlaceVertices(numVerts));
//Connects the vertices by a triangle array
yield return(SetTriangles());
//Calculates the normal values of each vertices
yield return(SetNormals(numVerts, numTris));
//Assigns these variables to a mesh object
CreateMesh();
//Draws the texture
yield return(CreateTexture());
yield return(null);
}
private void Start()
{
particleSystem = gameManager.particleSystem;
meshController = gameManager.meshController;
systemRenderer = particleSystem.GetComponent<ParticleSystemRenderer>();
systemRenderer.material = meshController.GetComponent<MeshRenderer>().material;
}
//Copies the vertices from one mesh onto another
//This helps reduce loading time by preventing thousands of floating point operations from having to be recalculated in identical meshes
public IEnumerator CopyMesh(int w, int h, MeshController mC, GameSettings s, MapMesh other)
{
width = w;
height = h;
if (width != other.GetWidth())
{
//The algorithm breaks if the widths are different so thinner chunks are built normally
yield return(Build(w, h, mC, s));
}
else
{
//Initializes necessary variables
settings = s;
meshController = mC;
int numVerts = CalculateVertices(w, h);
int numTris = TriArrayCalculator(w, h);
InitializeMeshData(numVerts, numTris);
//Copies the variables from the reference mesh
yield return(CopyVariables(other));
CreateMesh();
yield return(CreateTexture());
yield return(null);
}
}
/// <summary>
/// Calculates the facets of a surface, storing them in a <see cref="MeshController"/>.
/// </summary>
private void CalculateSurfaceFacets(SurfaceBody surf, MeshController outputMesh, bool separateFaces = false, BackgroundWorker backgroundWorker = null)
{
if (backgroundWorker != null && backgroundWorker.CancellationPending)
{
return;
}
double tolerance = DEFAULT_TOLERANCE;
PartialSurface bufferSurface = new PartialSurface();
// Store a list of faces separate from the Inventor API
Faces faces = surf.Faces;
// Don't separate if only one color
if (separateFaces)
{
separateFaces = MultipleAssets(faces);
}
// Do separate if too many faces
if (!separateFaces)
{
surf.CalculateFacets(tolerance, out bufferSurface.verts.count, out bufferSurface.facets.count, out bufferSurface.verts.coordinates, out bufferSurface.verts.norms, out bufferSurface.facets.indices);
if (bufferSurface.verts.count > MAX_VERTS_OR_FACETS || bufferSurface.facets.count > MAX_VERTS_OR_FACETS)
{
separateFaces = true;
}
}
if (separateFaces)
{
// Add facets for each face of the surface
foreach (Face face in faces)
{
if (face.Appearance != null)
{
face.CalculateFacets(tolerance, out bufferSurface.verts.count, out bufferSurface.facets.count, out bufferSurface.verts.coordinates, out bufferSurface.verts.norms, out bufferSurface.facets.indices);
outputMesh.AddSurface(ref bufferSurface, GetAssetProperties(face.Appearance));
}
}
}
else
{
// Add facets once for the entire surface
AssetProperties asset;
try
{
asset = GetAssetProperties(faces[1].Appearance);
}
catch (Exception)
{
asset = new AssetProperties();
}
outputMesh.AddSurface(ref bufferSurface, asset);
}
}
public IEnumerator Create(MeshController mc)
{
yield return(null);
//Mesh, 변수 생성 및 초기화
mc.mesh = new Mesh();
mc.root.AddComponent <MeshFilter>().mesh = mc.mesh;
mc.mesh.Clear();
var renderer = mc.root.AddComponent <MeshRenderer>();
var points = new List <Vector3>();
var minY = float.MaxValue;
var maxY = float.MinValue;
//모든 정점 좌표를 받아온다. (천장, 바닥, 벽면)
//층이 다른 건물이 있을 경우 하나 더 만든다.
List <Vector3> secondPoints;
points = mc.GetPoints(out secondPoints);
List <int> triangles = new List <int>();
//정점 좌표를 근거로 3개씩 묶어 면을 만든다.
triangles = CreateCeilTriangle(points);
Vector3[] vertices = points.ToArray();
//건물 높이 값 계산 (가장 높은 값과 가장 낮은 값을 구해 높이를 구한다.
foreach (var pos in points)
{
minY = Mathf.Min(pos.y, minY);
maxY = Mathf.Max(pos.y, maxY);
}
var height = Mathf.Abs(maxY - minY);
mc.root.transform.parent = DataManager.Instance.complexParent;
mc.root.transform.localPosition = new Vector3(0, mc.data.meta.height, 0);
mc.root.name = mc.data.meta.name;
if (triangles.Count > 0)
{
mc.mesh.vertices = vertices;
mc.mesh.triangles = triangles.ToArray();
mc.mesh.uv = new Vector2[vertices.Length];
SetUV(mc);
mc.CreatePoints();
renderer.sharedMaterial = DataManager.Instance.CreateMaterial();
renderer.sharedMaterial.SetTextureScale("_BaseMap", new Vector2(1, Mathf.Floor(height / 3f)));
renderer.sharedMaterial.SetTextureOffset("_BaseMap", new Vector2(0, 0));
//mesh.uv = uv.ToArray();
mc.mesh.Optimize();
mc.mesh.RecalculateNormals();
}
StartCoroutine(CreateSecondMesh(mc.data, secondPoints));
}
private void Start()
{
isActive = false;
container = new MeshContainer(this.transform);
controller = new MeshController(container);
container.ApplyColor(ColorCalculator.BASE_COLOR);
}
// Can't use normal [SetUp], because one test use different mocks.
// The default SetUp-Method can't have parameters.
public void SetUp(string mockName = "Mock_simple")
{
GameObject docMeshPref = Resources.Load <GameObject>("Prefabs/" + mockName);
docMeshObj = GameObject.Instantiate(docMeshPref);
MeshContainer container = new MeshContainer(docMeshPref.transform);
controller = new MeshController(container);
}
private void Update()
{
if (CamControl.CAMRTS != null)
{
if (MeshController == null)
{
MeshController = (MeshController)General.Create(Root.meshController, container: Program.ClassContainer.transform);
}
}
}
public void SetUV(MeshController mc)
{
List <Vector3> secondPoints;
var points = mc.GetPoints(out secondPoints);
var positions = new Dictionary <int, Vector3>();
for (int i = 0; i < points.Count; i++)
{
positions.Add(i, points[i]);
//포지션 6개 단위로 uv 매핑
if (positions.Count == 6)
{
var uv = mc.mesh.uv;
var state = GetWallState(positions, mc.GetFoward());
var pos = positions.ToArray();
if (pos.Length == 0)
{
positions.Clear();
continue;
}
switch (state)
{
case Defines.WallState.FRONT:
uv[pos[0].Key] = new Vector2(0.5f, 0); // 1 (1, 0)
uv[pos[1].Key] = new Vector2(0, 0); // 0 (0, 0)
uv[pos[2].Key] = new Vector2(0, 0.5f); // 3 (0, 1)
uv[pos[3].Key] = new Vector2(0, 0.5f); // 3 (0, 1)
uv[pos[4].Key] = new Vector2(0.5f, 0.5f); // 2 (1, 1)
uv[pos[5].Key] = new Vector2(0.5f, 0); // 1 (1, 0)
break;
case Defines.WallState.WALL:
uv[pos[0].Key] = new Vector2(0.75f, 0); // 1 (1, 0)
uv[pos[1].Key] = new Vector2(0.5f, 0); // 0 (0, 0)
uv[pos[2].Key] = new Vector2(0.5f, 0.5f); // 3 (0, 1)
uv[pos[3].Key] = new Vector2(0.5f, 0.5f); // 3 (0, 1)
uv[pos[4].Key] = new Vector2(0.75f, 0.5f); // 2 (1, 1)
uv[pos[5].Key] = new Vector2(0.75f, 0); // 1 (1, 0)
break;
case Defines.WallState.CEIL:
uv[pos[0].Key] = new Vector2(0.75f, 0); // 0 (0, 0)
uv[pos[1].Key] = new Vector2(1f, 0); // 1 (1, 0)
uv[pos[2].Key] = new Vector2(1f, 0.5f); // 2 (1, 1)
uv[pos[3].Key] = new Vector2(0.75f, 0); // 3 (0, 1)
uv[pos[4].Key] = new Vector2(0.75f, 0.5f); // 0 (0, 0)
uv[pos[5].Key] = new Vector2(1f, 0.5f); // 2 (1, 1)
break;
}
positions.Clear();
mc.mesh.uv = uv.ToArray();
}
}
}
public void MeshSameGlobalPointPass()
{
MeshController meshController = new MeshController();
meshController.CollisionAccuracy = 0.01F;
var mockV1 = new Vector3(1.20f, -2.30f, 3.40f);
var mockV2 = new Vector3(1.20f, -2.31f, 3.40f);
var samePointResult = MeshController.SameGlobalPoint(mockV1, mockV2);
Assert.IsTrue(samePointResult);
}
void CommonInit()
{
// Configure everything
ConfigureView();
ConfigureMeshController();
ConfigureMetal();
// Initialize 6D SDK
SDPlugin.SixDegreesSDK_Initialize();
MeshController.ShowMesh();
}
public void MeshPushDeformPass()
{
MeshController meshController = new MeshController();
meshController.DeformationType = DeformationType.PUSH;
meshController.CollisionForce = 1F;
var mockCollisionPoint = new Vector3(1.4f, 2.5f, 3.6f);
var mockCollisionNormal = new Vector3(4.7f, 5.8f, 6.9f);
var deformExpected = new Vector3(6.1F, 8.3F, 10.5F);
var deformResult = meshController.Deform(mockCollisionPoint, mockCollisionNormal);
// lower precision to prevent floating point inaccuracy
Assert.AreEqual(deformExpected.ToString("F8"), deformResult.ToString("F8"));
}
public void MeshPullDeformPass()
{
MeshController meshController = new MeshController();
meshController.DeformationType = DeformationType.PULL;
meshController.CollisionForce = 1F;
var mockCollisionPoint = new Vector3(1.2f, 2.3f, 3.4f);
var mockCollisionNormal = new Vector3(4.5f, 5.6f, 6.7f);
var deformExpected = new Vector3(-3.3F, -3.3F, -3.3F);
var deformResult = meshController.Deform(mockCollisionPoint, mockCollisionNormal);
// lower precision to prevent floating point inaccuracy
Assert.AreEqual(deformExpected.ToString("F8"), deformResult.ToString("F8"));
}
public void MeshSameGlobalPointFail()
{
try
{
MeshController meshController = new MeshController();
meshController.CollisionAccuracy = 0.01F;
var mockV1 = new Vector3(1.20f, -2.30f, 3.40f);
var mockV2 = new Vector3(1.20f, -2.32f, 3.40f);
var samePointResult = MeshController.SameGlobalPoint(mockV1, mockV2);
Assert.IsTrue(samePointResult);
}
catch (Exception ex)
{
Debug.Log("This test was supposed to fail, working as intended.\n" + ex);
}
}
public override void OnInspectorGUI()
{
MeshController mesh = (MeshController)target;
base.OnInspectorGUI();
if (GUILayout.Button("LoadMesh"))
{
mesh.LoadMesh();
}
if (GUILayout.Button("LoadInitial"))
{
mesh.LoadInitialPosition();
}
if (GUILayout.Button("SavePreset"))
{
mesh.Save();
}
if (GUILayout.Button("LoadPreset"))
{
mesh.Load();
}
if (GUILayout.Button("SaveNeutral"))
{
mesh.SaveNeutral();
}
if (GUILayout.Button("LoadNeutral"))
{
mesh.LoadNeutral();
}
mesh.copyOriginal = EditorGUILayout.TextField("コピーのオリジナル", mesh.copyOriginal);
mesh.xM = EditorGUILayout.Toggle("xMirror", mesh.xM);
mesh.yM = EditorGUILayout.Toggle("yMirror", mesh.yM);
mesh.zM = EditorGUILayout.Toggle("zMirror", mesh.zM);
if (GUILayout.Button("CopyFromOtherMeshController"))
{
MeshController[] meshes = mesh.gameObject.GetComponents <MeshController>();
foreach (MeshController m in meshes)
{
if (m.label.Equals(mesh.copyOriginal))
{
mesh.CopyFromOtherMeshController(m, mesh.xM, mesh.yM, mesh.zM);
break;
}
}
}
}
public void CreateMesh()
{
// Clear all objects in the containers array
if (controllers != null)
{
for (int i = controllers.Length - 1; i >= 0; i--)
{
GameObject.Destroy(controllers[i].Container);
}
}
n_sections_width = Int_Ceil_Divide(pipeline.Width, SectionSize);
n_sections_height = Int_Ceil_Divide(pipeline.Height, SectionSize);
int current_section = 0;
int left;
int right;
int bottom = 0;
int top;
controllers = new MeshController[n_sections_width * n_sections_height];
for (int j = 0; j < n_sections_height; j++)
{
left = 0;
for (int i = 0; i < n_sections_width; i++)
{
right = left + SectionSize + 1;
top = bottom + SectionSize + 1;
right = right > pipeline.Width ?
pipeline.Width : right;
top = top >= pipeline.Height ?
pipeline.Height : top;
controllers[current_section] = new MeshController(left, right,
bottom, top,
pipeline, material);
controllers[current_section].Container.transform.parent = mesh_parent.transform;
left += SectionSize;
current_section++;
}
bottom += SectionSize;
}
}
public void SubdivideModelSphere()
{
MeshController meshController = new MeshController();
GameObject sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
sphere.AddComponent <MeshCollider>();
meshController.AttachMesh(sphere);
meshController.Model.Start();
var preSubVertexCount = meshController.Model.vertices.Count;
meshController.Model.Subdivide();
var postSubVertexCount = meshController.Model.vertices.Count;
// lower precision to prevent floating point inaccuracy
Assert.AreEqual(515, preSubVertexCount);
Assert.AreEqual(1793, postSubVertexCount);
}
public void TrySmoothing()
{
MeshController meshController = new MeshController();
GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
cube.AddComponent <MeshCollider>();
meshController.AttachMesh(cube);
meshController.Model.Start();
meshController.Model.ResetIndexNeighborDict();
meshController.Model.UpdateVertex(0, new Vector3(4f, 4f, 4f));
bool canSmooth = meshController.Model.TrySmoothing();
Assert.False(canSmooth);
// Can't actually update in testing mode. Smoother will be tested seperately in ModelHelperTests
}
public void MeshPullDeformFail()
{
try
{
MeshController meshController = new MeshController();
meshController.DeformationType = DeformationType.PULL;
meshController.CollisionForce = 1F;
var mockCollisionPoint = new Vector3(1f, 2f, 3f);
var mockCollisionNormal = new Vector3(4f, 5f, 6f);
var deformExpected = new Vector3(6, 7, 8);
var deformResult = meshController.Deform(mockCollisionPoint, mockCollisionNormal);
// lower precision to prevent floating point inaccuracy
Assert.AreEqual(deformExpected.ToString("F8"), deformResult.ToString("F8"));
}
catch (Exception ex)
{
Debug.Log("This test was supposed to fail, working as intended.\n" + ex);
}
}
public void DisplayInEditor()
{
textureDetails.AttachToMaterial(areaMaterial);
textureDetails.RefreshHeights(areaMaterial, areaNoiseDetails.minHeight, areaNoiseDetails.maxHeight);
AreaNoise noiseArea = NoiseController.BuildNoiseArea(areaDetails.verticesPerLine, areaNoiseDetails, Vector2.zero);
if (displayMode == DisplayMode.Noise)
{
DisplayMap(TextureController.GenerateFromNoise(noiseArea));
}
else if (displayMode == DisplayMode.Mesh)
{
DisplayMesh(MeshController.BuildMesh(noiseArea.area, previevLOD, areaDetails));
}
else if (displayMode == DisplayMode.Falloff)
{
DisplayMap(TextureController.GenerateFromNoise(new AreaNoise(FalloffController.GenerateFalloffArea(areaDetails.verticesPerLine), 0, 1)));
}
}
public void Initialize()
{
if (!MeshController.CrystalManager1.IsFullyLoaded() || !Program.GameFullyLoaded())//making sure all build are fullt loaded
{
return;
}
init = false;
PersonData pData = XMLSerie.ReadXMLPerson();
CamControl.CAMRTS.InputRts.SaveFirstCamPos();
//brand new game
if (pData == null)
{
SpawnIniPersonas();
GameController.LoadStartingConditions(conditions[Difficulty]);
RestartController();
//here bz trees all spawneed after buildings.
//so if tree is inside a building wont be deleted. bz the building
//might be to big and wont collide with the building
BuildingPot.Control.Registro.DoLastStepOfTownLoaded();
}
//loading from file game
else
{
LoadFromFile(pData);
//game controller is loaded and Saved on BuildingSaveLoad.cs
//called here for the first time after a Storage was build.
//This is DEBUG
GameController.LoadStartingConditions(conditions[Difficulty]);
CamControl.CAMRTS.InputRts.LoadLastCamPos();
}
BuildingPot.CreateUnlockBuilds();
MeshController.InitBuyRegions();
Program.gameScene.GameController1.ReCheckWhatsOnStorage();
Program.gameScene.ReleaseLoadingScreen();
}
void Start()
{
leftLowerEyeBasePos = leftLowerEye.transform.localPosition;
leftUpperEyeBasePos = leftUpperEye.transform.localPosition;
rightLowerEyeBasePos = rightLowerEye.transform.localPosition;
rightUpperEyeBasePos = rightUpperEye.transform.localPosition;
if (eyeMeshControllerObject)
{
MeshController[] meshes = eyeMeshControllerObject.GetComponents <MeshController>();
foreach (MeshController m in meshes)
{
if (m.label.Equals("LeftEye"))
{
eyeSmileMeshLeft = m;
}
else if (m.label.Equals("RightEye"))
{
eyeSmileMeshRight = m;
}
}
}
}
public IEnumerator AVGIsZeroWhenSourceIsNotActive_Test()
{
// setup
float expected = 0f;
// wait till start is called
yield return(new WaitForEndOfFrame());
// wait till first update is called
yield return(new WaitForEndOfFrame());
// perform
yield return(new WaitForSeconds(1f));
// get
controller = GetPrivateField <MeshController, RayReciever>(reciever, "controller");
float[] doses = controller.VerticeData.Select(x => x.Dose).ToArray();
float actual = DoseCalculator.GetAVGDose(doses);
// assert
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Exports all the components in this group to the in-RAM mesh.
/// </summary>
/// <param name="group">Group to export from</param>
/// <param name="guid"></param>
/// <param name="reporter">Progress reporter</param>
/// <param name="backgroundWorker"></param>
public BXDAMesh ExportAll(CustomRigidGroup @group, Guid guid, BXDIO.ProgressReporter reporter = null, BackgroundWorker backgroundWorker = null)
{
// Create output mesh
MeshController outputMesh = new MeshController(guid);
// Collect surfaces to export
List <SurfaceBody> plannedSurfaces = GenerateExportList(group, outputMesh.Mesh.physics);
// Export faces, multithreaded
if (plannedSurfaces.Count > 0)
{
// Reset progress bar
reporter?.Invoke(0, plannedSurfaces.Count);
// Start jobs
int totalJobsFinished = 0;
object finishLock = new object(); // Used to prevent multiple threads from updating progress bar at the same time.
Parallel.ForEach(plannedSurfaces, (SurfaceBody surface) =>
{
CalculateSurfaceFacets(surface, outputMesh, RobotExporterAddInServer.Instance.AddInSettingsManager.DefaultExportWithColors, backgroundWorker);
lock (finishLock)
{
totalJobsFinished++;
reporter?.Invoke(totalJobsFinished, plannedSurfaces.Count);
}
});
if (backgroundWorker != null && backgroundWorker.CancellationPending)
{
return(null);
}
outputMesh.DumpOutput();
}
return(outputMesh.Mesh);
}
public void CreateEntities()
{
meshController = GameObject.FindObjectOfType <MeshController>();
RenderMesh rm = new RenderMesh()
{
mesh = meshController.mesh,
material = meshController.material,
castShadows = UnityEngine.Rendering.ShadowCastingMode.On
};
EntityManager entityManager = World.DefaultGameObjectInjectionWorld.EntityManager;
Entity meshEntity = entityManager.CreateEntity();
entityManager.AddComponentData(meshEntity, new Translation()
{
Value = meshController.transform.position
});
entityManager.AddComponentData(meshEntity, new LocalToWorld());
entityManager.AddComponentData(meshEntity, new RenderBounds());
entityManager.AddComponentData(meshEntity, new MeshDeformation());
entityManager.AddSharedComponentData(meshEntity, rm);
}
