private void mMeshListView_SelectionChanged(object sender, SelectionChangedEventArgs e) { mStateListView.Items.Clear(); SceneMesh m; if (e.AddedItems.Count > 0) { m = (SceneMesh)e.AddedItems[0]; mSelectedMesh = m; } else { mSelectedMesh = null; } m = mSelectedMesh; GeostatesPanel.Visibility = m == null || m.States.Count() == 0 ? Visibility.Collapsed : Visibility.Visible; if (m != null) { mStateListView.Items.Add(new SceneGeostate(m, null, null)); foreach (SceneGeostate s in m.States) { mStateListView.Items.Add(s); } mStateListView.SelectedIndex = 0; } else { GeostatesPanel.Visibility = Visibility.Collapsed; } UpdateMaterials(); }
public async System.Threading.Tasks.Task <bool> SetMaterialInstanceAsync(CRenderContext RHICtx, UInt32 index, Graphics.CGfxMaterialInstance material, CGfxShadingEnv[] envs, bool preUseEffect = false) { var ret = SetMaterialInstance(RHICtx, index, material, envs, preUseEffect); await SceneMesh.AwaitEffects(); return(ret); }
public bool SetMaterialInstance(CRenderContext RHICtx, UInt32 index, Graphics.CGfxMaterialInstance material, CGfxShadingEnv[] envs, bool preUseEffect = false) { if (index >= mSceneMesh.MtlMeshArray.Length) { return(false); } SceneMesh.SetMaterialInstance(RHICtx, index, material, envs, preUseEffect); return(true); }
public async System.Threading.Tasks.Task <bool> SetMaterialInstance(CRenderContext RHICtx, UInt32 index, RName materialName, CGfxShadingEnv[] envs) { var mtl = await CEngine.Instance.MaterialInstanceManager.GetMaterialInstanceAsync(RHICtx, materialName); if (mtl == null) { return(false); } var ret = SetMaterialInstance(RHICtx, index, mtl, envs); await SceneMesh.AwaitEffects(); return(ret); }
/// <summary> /// <para xml:lang="en">Internal method, do not call directly.</para> /// <para xml:lang="zh">内部方法,不可直接调用。</para> /// </summary> internal void UpdateData(BlockInfo info, SceneMesh easyarMesh) { Info = info; if (Info.numOfVertex == 0) { vertices = null; normals = null; indexes = null; gameObject.SetActive(false); return; } gameObject.SetActive(true); CopyMeshData(easyarMesh); }
private void CopyMeshData(SceneMesh easyarMesh) { using (var verticesBuffer = easyarMesh.getVerticesIncremental()) using (var normalBuffer = easyarMesh.getNormalsIncremental()) using (var indicesBuffer = easyarMesh.getIndicesIncremental()) { using (var vb = verticesBuffer.partition(Info.startPointOfVertex * 12, Info.numOfVertex * 12)) { var vbData = new float[Info.numOfVertex * 3]; Marshal.Copy(vb.data(), vbData, 0, vbData.Length); vertices = new Vector3[Info.numOfVertex]; for (int i = 0; i < Info.numOfVertex; ++i) { var idx = i * 3; vertices[i] = new Vector3(vbData[idx], vbData[idx + 1], -vbData[idx + 2]); } } using (var nb = easyarMesh.getNormalsIncremental().partition(Info.startPointOfVertex * 12, Info.numOfVertex * 12)) { var nbData = new float[Info.numOfVertex * 3]; Marshal.Copy(nb.data(), nbData, 0, nbData.Length); normals = new Vector3[Info.numOfVertex]; for (int i = 0; i < Info.numOfVertex; ++i) { var idx = i * 3; normals[i] = new Vector3(nbData[idx], nbData[idx + 1], -nbData[idx + 2]); } } using (var ib = easyarMesh.getIndicesIncremental().partition(Info.startPointOfIndex * 4, Info.numOfIndex * 4)) { indexes = new int[Info.numOfIndex - Info.numOfIndex % 3]; Marshal.Copy(ib.data(), indexes, 0, indexes.Length); for (int i = 2; i < Info.numOfIndex; i += 3) { var tmp = indexes[i]; indexes[i] = indexes[i - 1]; indexes[i - 1] = tmp; } } } }
public void SyncValues(MaterialInstanceEditProperty showvalue) { foreach (var varvalue in showvalue.VarRNameValues) { var varkey = varvalue.Key; var objvalue = varvalue.Value; var ShowName = SceneMesh.MtlMeshArray[MtlIndex].MtlInst.GetVarName((uint)varkey, true); var index = SceneMesh.McFindVar((uint)MtlIndex, ShowName); if (objvalue.GetType().Equals(typeof(float))) { SceneMesh.McSetVarFloat((uint)MtlIndex, index, (float)objvalue, 0); //elem.VarObject.mMaterialInstance.SetVarValue(elem.VarObject.Index, 0, ref value); } else if (objvalue.GetType().Equals(typeof(Vector2))) { SceneMesh.McSetVarVector2((uint)MtlIndex, index, (Vector2)objvalue, 0); } else if (objvalue.GetType().Equals(typeof(Vector3))) { SceneMesh.McSetVarVector3((uint)MtlIndex, index, (Vector3)objvalue, 0); } else if (objvalue.GetType().Equals(typeof(Vector4))) { SceneMesh.McSetVarColor4((uint)MtlIndex, index, (Vector4)objvalue, 0); } else if (objvalue.GetType().Equals(typeof(EngineNS.Color))) { SceneMesh.McSetVarColor4((uint)MtlIndex, index, (EngineNS.Color)objvalue, 0); } AddVarValue(varkey, objvalue); } foreach (var srvvalue in showvalue.SRVRNameValues) { var varkey = srvvalue.Key; var objvalue = srvvalue.Value; SceneMesh.McSetTexture((uint)MtlIndex, varkey, objvalue as RName); AddSRVValue(varkey, objvalue); } }
public SceneGeostate(SceneMesh owner, MLOD.GeometryState state, GeometryModel3D model) { Owner = owner; State = state; Model = model; }
private void CreateVisuals() { var compositor = ElementCompositionPreview.GetElementVisual(this).Compositor; var mesh = SceneMesh.Create(compositor); }
public List<MeshFilter> GetSceneMeshes () { MeshFilter[] filters = GameObject.FindObjectsOfType(typeof(MeshFilter)) as MeshFilter[]; List<MeshFilter> filteredFilters = new List<MeshFilter> (filters.Length/3); for (int i=0;i<filters.Length;i++) { MeshFilter filter = filters[i]; if (filter.renderer != null && filter.renderer.enabled && (((1 << filter.gameObject.layer) & mask) == (1 << filter.gameObject.layer) || tagMask.Contains (filter.tag))) { filteredFilters.Add (filter); } } List<SceneMesh> meshes = new List<SceneMesh>(); #if UNITY_4 bool containedStatic = false; #else HashSet<Mesh> staticMeshes = new HashSet<Mesh>(); #endif foreach (MeshFilter filter in filteredFilters) { //Workaround for statically batched meshes if (filter.renderer.isPartOfStaticBatch) { #if UNITY_4 containedStatic = true; #else Mesh mesh = filter.sharedMesh; if (!staticMeshes.Contains (mesh)) { staticMeshes.Add (mesh); SceneMesh smesh = new SceneMesh(); smesh.mesh = mesh; //This is not the real bounds, it will be expanded later as more renderers are found smesh.bounds = filter.renderer.bounds; smesh.matrix = Matrix4x4.identity; meshes.Add (smesh); } else { SceneMesh smesh; for (int i=0;i<meshes.Count;i++) { if (meshes[i].mesh == mesh) { smesh = meshes[i]; break; } } smesh.bounds.Encapsulate (filter.renderer.bounds); } #endif } else { //Only include it if it intersects with the graph if (filter.renderer.bounds.Intersects (forcedBounds)) { Mesh mesh = filter.sharedMesh; SceneMesh smesh = new SceneMesh(); smesh.matrix = filter.renderer.localToWorldMatrix; smesh.mesh = mesh; smesh.bounds = filter.renderer.bounds; meshes.Add (smesh); } } #if UNITY_4 if (containedStatic) Debug.LogWarning ("Some meshes were statically batched. These meshes can not be used for navmesh calculation" + " due to technical constraints."); #endif } #if ASTARDEBUG int y = 0; foreach (SceneMesh smesh in meshes) { y++; Vector3[] vecs = smesh.mesh.vertices; int[] tris = smesh.mesh.triangles; for (int i=0;i<tris.Length;i+=3) { Vector3 p1 = smesh.matrix.MultiplyPoint3x4(vecs[tris[i+0]]); Vector3 p2 = smesh.matrix.MultiplyPoint3x4(vecs[tris[i+1]]); Vector3 p3 = smesh.matrix.MultiplyPoint3x4(vecs[tris[i+2]]); Debug.DrawLine (p1,p2,Color.red,1); Debug.DrawLine (p2,p3,Color.red,1); Debug.DrawLine (p3,p1,Color.red,1); } } #endif return filteredFilters; }
private SpatialAwarenessSceneObject ConvertSceneObject(SceneObject sceneObject) { int quadCount = sceneObject.Quads.Count; int meshCount = sceneObject.Meshes.Count; List <SpatialAwarenessSceneObject.Quad> quads = new List <SpatialAwarenessSceneObject.Quad>(quadCount); List <SpatialAwarenessSceneObject.MeshData> meshes = new List <SpatialAwarenessSceneObject.MeshData>(meshCount); if (RequestPlaneData) { SceneQuad sceneQuad = null; for (int i = 0; i < quadCount; ++i) { sceneQuad = sceneObject.Quads[i]; var quadIdKey = sceneQuad.Id; byte[] occlusionMaskBytes = null; if (RequestOcclusionMask) { occlusionMaskBytes = new byte[OcclusionMaskResolution.x * OcclusionMaskResolution.y]; sceneQuad.GetSurfaceMask((ushort)OcclusionMaskResolution.x, (ushort)OcclusionMaskResolution.y, occlusionMaskBytes); } var extents = new UnityEngine.Vector2(sceneQuad.Extents.X, sceneQuad.Extents.Y); var quad = new SpatialAwarenessSceneObject.Quad(quadIdKey, extents, occlusionMaskBytes); quads.Add(quad); // Store a cache so we can retrieve best position on plane later. if (!cachedSceneQuads.ContainsKey(quadIdKey)) { cachedSceneQuads.Add(quadIdKey, new Tuple <SceneQuad, SceneObject>(sceneQuad, sceneObject)); } } } if (RequestMeshData) { SceneMesh sceneMesh = null; for (int i = 0; i < meshCount; ++i) { sceneMesh = sceneObject.Meshes[i]; var meshData = MeshData(sceneMesh); meshes.Add(meshData); } } // World space conversion System.Numerics.Matrix4x4 worldXformSystem = sceneObject.GetLocationAsMatrix() * sceneToWorldXformSystem * correctOrientation; System.Numerics.Vector3 worldTranslationSystem; System.Numerics.Quaternion worldRotationSytem; System.Numerics.Vector3 localScale; System.Numerics.Matrix4x4.Decompose(worldXformSystem, out localScale, out worldRotationSytem, out worldTranslationSystem); var result = new SpatialAwarenessSceneObject( sceneObject.Id, SpatialAwarenessSurfaceType(sceneObject.Kind), worldTranslationSystem.ToUnityVector3(), worldRotationSytem.ToUnityQuaternion(), quads, meshes); return(result); }
private SpatialAwarenessSceneObject.MeshData MeshData(SceneMesh sceneMesh) { // Indices var indices = new int[sceneMesh.TriangleIndexCount]; var meshIndices = new uint[sceneMesh.TriangleIndexCount]; sceneMesh.GetTriangleIndices(meshIndices); var ilength = meshIndices.Length; for (int i = 0; i < ilength; ++i) { indices[i] = (int)meshIndices[i]; } // Vertices var vertices = new UnityEngine.Vector3[sceneMesh.VertexCount]; var uvs = new UnityEngine.Vector2[sceneMesh.VertexCount]; var meshVertices = new System.Numerics.Vector3[sceneMesh.VertexCount]; sceneMesh.GetVertexPositions(meshVertices); var vlength = meshVertices.Length; var minx = meshVertices[0].X; var miny = meshVertices[0].Y; var maxx = minx; var maxy = miny; float x = minx; float y = miny; for (int i = 0; i < vlength; ++i) { x = meshVertices[i].X; y = meshVertices[i].Y; vertices[i] = new UnityEngine.Vector3(x, y, -meshVertices[i].Z); minx = Math.Min(minx, x); miny = Math.Min(miny, y); maxx = Math.Max(maxx, x); maxy = Math.Max(maxy, y); } // UVs - planar square projection float smallestDimension = Math.Min(minx, miny); float biggestDimension = Math.Max(maxx, maxy); for (int i = 0; i < vlength; ++i) { uvs[i] = new Vector2( Mathf.InverseLerp(smallestDimension, biggestDimension, vertices[i].x), Mathf.InverseLerp(smallestDimension, biggestDimension, vertices[i].y)); } var result = new SpatialAwarenessSceneObject.MeshData { indices = indices, vertices = vertices, guid = sceneMesh.Id, uvs = uvs }; return(result); }
/// <summary> /// Create a list of Unity GameObjects that represent all the Meshes/Geometry in a Scene /// Understanding Object /// </summary> /// <param name="suObject">The Scene Understanding Object to generate in Unity</param> private List <GameObject> CreateSUObjectInUnity(SceneObject suObject) { // Each SU object has a specific type, query for its correspoding color // according to its type Color?color = GetColor(suObject.Kind); int layer = GetLayer(suObject.Kind); // QUADS List <GameObject> listOfGeometryGameObjToReturn = new List <GameObject>(); if (SceneObjectRequestMode == RenderMode.Quad || SceneObjectRequestMode == RenderMode.QuadWithMask) { // If the Request Settings are requesting quads, create a gameobject in unity for // each quad in the Scene Object foreach (SceneQuad quad in suObject.Quads) { Mesh unityMesh = GenerateUnityMeshFromSceneObjectQuad(quad); Material tempMaterial = GetMaterial(suObject.Kind, SceneObjectRequestMode); GameObject gameObjectToReturn = new GameObject(suObject.Kind.ToString()); gameObjectToReturn.layer = layer; AddMeshToUnityObject(gameObjectToReturn, unityMesh, color, tempMaterial); if (SceneObjectRequestMode == RenderMode.QuadWithMask) { ApplyQuadRegionMask(quad, gameObjectToReturn, color.Value); } if (AddColliders) { gameObjectToReturn.AddComponent <BoxCollider>(); } // Add to list listOfGeometryGameObjToReturn.Add(gameObjectToReturn); } } else // MESH OR WUREFRAME { // If the Request Settings are requesting Meshes or WireFrame, create a gameobject in unity for // each Mesh, and apply either the default material or the wireframe material for (int i = 0; i < suObject.Meshes.Count; i++) { SceneMesh suGeometryMesh = suObject.Meshes[i]; SceneMesh suColliderMesh = suObject.ColliderMeshes[i]; // Generate the unity mesh for the Scene Understanding mesh. Mesh unityMesh = GenerateUnityMeshFromSceneObjectMeshes(new List <SceneMesh> { suGeometryMesh }); GameObject gameObjectToReturn = new GameObject(suObject.Kind.ToString() + "Mesh"); gameObjectToReturn.layer = layer; Material tempMaterial = GetMaterial(suObject.Kind, SceneObjectRequestMode); // Add the created Mesh into the Unity Object AddMeshToUnityObject(gameObjectToReturn, unityMesh, color, tempMaterial); if (AddColliders) { // Generate a unity mesh for physics Mesh unityColliderMesh = GenerateUnityMeshFromSceneObjectMeshes(new List <SceneMesh> { suColliderMesh }); MeshCollider col = gameObjectToReturn.AddComponent <MeshCollider>(); col.sharedMesh = unityColliderMesh; } listOfGeometryGameObjToReturn.Add(gameObjectToReturn); } } // Return all the Geometry GameObjects that represent a Scene // Understanding Object return(listOfGeometryGameObjToReturn); }