public IEnumerator UpdateGeometryOnMainThread()
{
if (InteriorComponents == null)
{
yield break;
}
if (is_disconnected)
{
yield break;
}
ComponentData interior = InteriorComponents;
// if mesh was modified before we got here, push it back onto dirty list
if (interior.timestamp != SO.Mesh.ShapeTimestamp)
{
OnComputeUpdateRequired?.Invoke(this);
yield break;
}
foreach (DMesh3 mesh in interior.InteriorMeshes)
{
if (is_disconnected || interior.timestamp != SO.Mesh.ShapeTimestamp)
{
yield break;
}
fMeshGameObject go = GameObjectFactory.CreateMeshGO("interior_comp", new fMesh(mesh), false, true);
SO.RootGameObject.AddChild(go, false);
go.SetMaterial(CavityMaterial, true);
go.SetLayer(FPlatform.WidgetOverlayLayer);
MeshGOs.Add(go);
yield return(null);
}
}
public void Create(SOMaterial useMaterial, fGameObject parent)
{
if (curve == null)
{
curve = new DCurve3();
}
meshObject = GameObjectFactory.CreateMeshGO("mesh_tube_preview");
//meshObject.SetMesh(new fMesh())
meshObject.SetMaterial(MaterialUtil.ToMaterialf(useMaterial));
bUpdatePending = true;
parent.AddChild(meshObject, false);
}
protected override fGameObject create_pivot_shape()
{
mesh_height = CC.Settings.LayerHeightMM;
TrivialBox3Generator boxgen = new TrivialBox3Generator()
{
NoSharedVertices = true,
Box = new Box3d(Vector3d.Zero, new Vector3d(2.5, CC.Settings.LayerHeightMM, 2.5))
};
DMesh3 mesh = boxgen.Generate().MakeDMesh();
fMeshGameObject meshGO = GameObjectFactory.CreateMeshGO("pivotMesh",
new fMesh(mesh), true, true);
meshGO.SetMaterial(MaterialUtil.CreateStandardMaterial(Colorf.Orange));
return(meshGO);
}
void add_snap_source(Vector3 vPosition, string name, SnapSet targets)
{
fMeshGameObject go = AppendMeshGO(name,
UnityUtil.GetPrimitiveMesh(PrimitiveType.Sphere), srcMaterial, gizmo);
go.SetLocalScale(0.5f * Vector3f.One);
Frame3f sourceFrame = new Frame3f(vPosition);
UnityUtil.SetGameObjectFrame(go, sourceFrame, CoordSpace.ObjectCoords);
Widgets[go] = new SnapDragSourceWidget(this, this.parentScene, targets)
{
RootGameObject = go, StandardMaterial = srcMaterial, HoverMaterial = srcHoverMaterial,
SourceFrameL = sourceFrame
};
}
override protected void BuildGizmo()
{
gizmo.SetName("PositionConstrainedGizmo");
make_materials();
centerGO = AppendMeshGO("object_origin",
UnityUtil.GetPrimitiveMesh(PrimitiveType.Sphere), srcMaterial, gizmo);
centerGO.SetLocalScale(WidgetScale);
Widgets[centerGO] = new PositionConstrainedPointWidget(this, this.parentScene)
{
RootGameObject = centerGO, StandardMaterial = srcMaterial, HoverMaterial = srcHoverMaterial
};
gizmo.Hide();
}
protected override void on_curve_validated()
{
if (previewGO != null)
{
RemoveGO((fGameObject)previewGO);
previewGO.Destroy();
}
if (EnableRegionOverlay)
{
if (TargetModelSO == null)
{
throw new InvalidOperationException("EnclosedPatchSO.on_curve_validated: curve is not connected to a Target");
}
if (TransformMode != OutputCurveTransform.ToTargetSO)
{
throw new InvalidOperationException("EnclosedPatchSO.on_curve_validated: curve is not transformed to TargetSO");
}
DCurve3 target_curve = RequestCurveCopyFromMainThread();
MeshFacesFromLoop loop = new MeshFacesFromLoop(TargetModel.SourceMesh,
target_curve, TargetModel.SourceSpatial);
MeshFaceSelection face_selection = loop.ToSelection();
DSubmesh3 submesh = new DSubmesh3(TargetModel.SourceMesh, face_selection, face_selection.Count);
MeshNormals normals = new MeshNormals(submesh.SubMesh);
normals.Compute();
foreach (int vid in submesh.SubMesh.VertexIndices())
{
Vector3d n = normals.Normals[vid];
Vector3d v = submesh.SubMesh.GetVertex(vid);
v += 0.1 * n;
v = SceneTransforms.TransformTo(v, TargetModelSO, this);
submesh.SubMesh.SetVertex(vid, v);
}
previewGO = GameObjectFactory.CreateMeshGO("patch",
new fMesh(submesh.SubMesh), false, true);
previewGO.SetMaterial(previewMaterial, true);
previewGO.SetLayer(FPlatform.WidgetOverlayLayer);
previewGO.SetIgnoreMaterialChanges();
AppendNewGO(previewGO, root, false);
}
}
public void Create(SOMaterial useMaterial, fGameObject parent, int nLayer = -1)
{
if (curve == null)
{
curve = new DCurve3();
}
axis = Frame3f.Identity;
meshObject = GameObjectFactory.CreateMeshGO("revolve_preview");
meshObject.SetMaterial(MaterialUtil.ToMaterialf(useMaterial), true);
if (nLayer != -1)
{
meshObject.SetLayer(nLayer);
}
bUpdatePending = true;
meshObject.SetParent(parent, false);
meshObject.SetLocalScale(1.001f * Vector3f.One);
}
void update_mesh()
{
clear_mesh();
AxisAlignedBox3i bounds = grid.Extents;
Vector3i minCorner = bounds.Min;
Vector3f cornerXYZ = grid.ToXYZ(minCorner);
Bitmap3d bmp;
try {
bmp = new Bitmap3d(bounds.Diagonal + Vector3i.One);
} catch (Exception e) {
Debug.Log("update_mesh: exception allocating grid of size " + bounds.Diagonal);
throw e;
}
foreach (Vector3i idx in grid.GridIndices(MinSamples))
{
Vector3i bidx = idx - minCorner;
try {
bmp.Set(bidx, true);
} catch (Exception e) {
Debug.Log("bad index is " + bidx + " grid dims " + bmp.Dimensions);
throw e;
}
}
// get rid of one-block tubes, floaters, etc.
// todo: use a queue instead of passes? or just descend into
// nbrs when changing one block? one pass to compute counts and
// then another to remove? (yes that is a good idea...)
bmp.Filter(2);
bmp.Filter(2);
bmp.Filter(2);
bmp.Filter(2);
bmp.Filter(2);
bmp.Filter(2);
VoxelSurfaceGenerator gen = new VoxelSurfaceGenerator()
{
Voxels = bmp, Clockwise = false,
MaxMeshElementCount = 65000,
ColorSourceF = (idx) => {
idx = idx + minCorner;
return(grid.GetColor(idx));
}
};
gen.Generate();
List <DMesh3> meshes = gen.Meshes;
List <fMeshGameObject> newMeshGOs = new List <fMeshGameObject>();
foreach (DMesh3 mesh in meshes)
{
MeshTransforms.Scale(mesh, grid.GridStepSize);
MeshTransforms.Translate(mesh, cornerXYZ);
Mesh m = UnityUtil.DMeshToUnityMesh(mesh, false);
fMeshGameObject meshGO = GameObjectFactory.CreateMeshGO("gridmesh", m, false, true);
meshGO.SetMaterial(MaterialUtil.CreateStandardVertexColorMaterialF(Colorf.White));
newMeshGOs.Add(meshGO);
}
CurrentMeshGOs = newMeshGOs;
}
