public void Render(ModelControl control, IFlatGuiGraphics graphics) { var instance = control.ModelInstance; if (control.VoxelEffect == null && control.CubeRenderer == null) { return; } var needToRender = control.VoxelEffect != null && control.ModelInstance != null || control.CubeRenderer != null && control.SelectedCube != null; if (!needToRender) { return; } var bounds = control.GetAbsoluteBounds(); var voxelEffect = control.VoxelEffect; var context = graphics.Engine.ImmediateContext; float aspectRatio = bounds.Width / bounds.Height; Matrix projection; var fov = (float)Math.PI / 3.6f; Matrix.PerspectiveFovLH(fov, aspectRatio, 0.5f, 100f, out projection); Matrix view = Matrix.LookAtLH(new Vector3(0, 0, -1.9f), Vector3.Zero, Vector3.UnitY); //Set custom ViewPort graphics.Engine.SetCustomViewPort(new ViewportF(bounds.X, bounds.Y, bounds.Width, bounds.Height)); //Rendering the Tool RenderStatesRepo.ApplyStates(context, DXStates.Rasters.Default, DXStates.Blenders.Enabled, DXStates.DepthStencils.DepthReadWriteEnabled); if (instance != null) { voxelEffect.Begin(context); voxelEffect.CBPerFrame.Values.LightDirection = Vector3.Zero; voxelEffect.CBPerFrame.Values.ViewProjection = Matrix.Transpose(view * projection); voxelEffect.CBPerFrame.IsDirty = true; var state = instance.VoxelModel.GetMainState(); instance.SetState(state); var sphere = BoundingSphere.FromBox(state.BoundingBox); var rMax = 2f * Math.Sin(fov / 2); var size = state.BoundingBox.GetSize(); var offset = -size / 2 - state.BoundingBox.Minimum; var scale = (float)rMax / sphere.Radius; instance.World = Matrix.Translation(offset) * Matrix.Scaling(scale) * Matrix.RotationY(MathHelper.Pi + MathHelper.PiOver4) * control.AlterTransform * Matrix.RotationQuaternion(control.Rotation); control.VisualVoxelModel.Draw(context, control.VoxelEffect, instance); } else if (control.SelectedCube != null) { control.CubeRenderer.Render(context, control.AlterTransform * Matrix.RotationQuaternion(control.Rotation) * view, projection, new Color3(1, 1, 1)); } graphics.Engine.SetScreenViewPort(); }
public override BoundingSphere GetGizmoCenter() { BoundingSphere boundingSphere = BoundingSphere.FromBox(boundingBox); boundingSphere.Radius *= 0.9f; return(boundingSphere); }
static private Mesh CreateMesh(GraphicsDevice device, VertexPositionNormalTexture[] verts, uint[] indices) { /* now set up the GPU side stuff */ var vbo = Xenko.Graphics.Buffer.Vertex.New( device, verts, /* allocated size of buffer inferred from the stored datatype and the length of the array */ GraphicsResourceUsage.Default /* usage hint to the GPU for it to allocate it appropriately (explicit default in our case) */ ); /* NOTE: if resource usage here is set to immutable (the default) you will encounter an error if you try to update it after creating it */ var ibo = Xenko.Graphics.Buffer.Index.New(device, indices, GraphicsResourceUsage.Default); var newMesh = new Mesh() { Draw = new MeshDraw() { PrimitiveType = PrimitiveType.TriangleList, VertexBuffers = new[] { new VertexBufferBinding(vbo, VertexPositionNormalTexture.Layout, verts.Length), }, IndexBuffer = new IndexBufferBinding(ibo, is32Bit: true, count: indices.Length), DrawCount = indices.Length } }; /* bounding box for culling */ newMesh.BoundingBox = Utils.FromPoints(verts); newMesh.BoundingSphere = BoundingSphere.FromBox(newMesh.BoundingBox); return(newMesh); }
public void Build(RenderDrawContext context) { if (Mesh == null && TryGetHeightMapImageData(context.CommandList, out var data)) { Data = new GeometryBuilder(data).BuildTerrainData(Size, MaxHeight, UvScale); MeshBoundingBox = Utils.FromPoints(Data.Vertices); MeshBoundingSphere = BoundingSphere.FromBox(MeshBoundingBox); BoundingBox = new BoundingBoxExt(MeshBoundingBox); var vertexBuffer = Buffer.Vertex.New(context.GraphicsDevice, Data.Vertices, GraphicsResourceUsage.Dynamic); var indexBuffer = Buffer.Index.New(context.GraphicsDevice, Data.Indices); var vertexBufferBinding = new VertexBufferBinding(vertexBuffer, VertexPositionNormalTexture.Layout, vertexBuffer.ElementCount); var indexBufferBinding = new IndexBufferBinding(indexBuffer, true, indexBuffer.ElementCount); MeshDraw = new MeshDraw { StartLocation = 0, PrimitiveType = PrimitiveType.TriangleList, VertexBuffers = new[] { vertexBufferBinding }, IndexBuffer = indexBufferBinding, DrawCount = indexBuffer.ElementCount }; Mesh = new Mesh(MeshDraw, new ParameterCollection()); } }
static private Mesh CreateMesh(GraphicsDevice device, VertexPositionNormalTexture[] verts) { /* now set up the GPU side stuff */ var vbo = Xenko.Graphics.Buffer.Vertex.New( device, verts, /* allocated size of buffer inferred from the stored datatype and the length of the array */ GraphicsResourceUsage.Default /* usage hint to the GPU for it to allocate it appropriately (explicit default in our case) */ ); var newMesh = new Mesh() { Draw = new MeshDraw() { PrimitiveType = PrimitiveType.TriangleList, VertexBuffers = new[] { new VertexBufferBinding(vbo, VertexPositionNormalTexture.Layout, verts.Length) }, DrawCount = verts.Length } }; /* bounding box+sphere for culling */ newMesh.BoundingBox = Utils.FromPoints(verts); newMesh.BoundingSphere = BoundingSphere.FromBox(newMesh.BoundingBox); return(newMesh); }
/// <summary> /// Gets the actor bounding sphere (including child actors). /// </summary> /// <param name="actor">The actor.</param> /// <param name="sphere">The bounding sphere.</param> public static void GetActorEditorSphere(Actor actor, out BoundingSphere sphere) { BoundingBox box; Internal_GetEditorBoxWithChildren(actor.unmanagedPtr, out box); BoundingSphere.FromBox(ref box, out sphere); sphere.Radius = Math.Max(sphere.Radius, 15.0f); }
private void UpdateBounds(bool transformOnly = false) { if (!transformOnly) { originalBound = new BoundingBox(DomainBoundMin, DomainBoundMax); originalBoundsSphere = BoundingSphere.FromBox(originalBound); BoundingBox newBound; BoundingSphere newBoundSphere; if (HasInstances) { newBound = OriginalBounds.Transform(Instances[0]); newBoundSphere = OriginalBoundsSphere.TransformBoundingSphere(Instances[0]); foreach (var instance in Instances) { var b = OriginalBounds.Transform(instance); BoundingBox.Merge(ref newBound, ref b, out newBound); var bs = OriginalBoundsSphere.TransformBoundingSphere(instance); BoundingSphere.Merge(ref newBoundSphere, ref bs, out newBoundSphere); } } else { newBound = OriginalBounds; newBoundSphere = OriginalBoundsSphere; } var old = bounds; if (Set(ref bounds, newBound)) { RaiseOnBoundChanged(new BoundChangeArgs <BoundingBox>(ref bounds, ref old)); } var oldS = boundsSphere; if (Set(ref boundsSphere, newBoundSphere)) { RaiseOnBoundSphereChanged(new BoundChangeArgs <BoundingSphere>(ref boundsSphere, ref oldS)); } } var oldT = boundsWithTransform; if (Set(ref boundsWithTransform, bounds.Transform(ModelMatrix))) { RaiseOnTransformBoundChanged(new BoundChangeArgs <BoundingBox>(ref boundsWithTransform, ref oldT)); } var oldTS = boundsSphereWithTransform; if (Set(ref boundsSphereWithTransform, boundsSphere.TransformBoundingSphere(ModelMatrix))) { RaiseOnTransformBoundSphereChanged(new BoundChangeArgs <BoundingSphere>(ref boundsSphereWithTransform, ref oldTS)); } }
private void CreateMesh() { var vbo = Xenko.Graphics.Buffer.Vertex.New( GraphicsDevice, verts, GraphicsResourceUsage.Dynamic ); var ibo = Xenko.Graphics.Buffer.Index.New( GraphicsDevice, tris, GraphicsResourceUsage.Dynamic ); _vertexBufferBinding = new VertexBufferBinding(vbo, VertexPositionNormalTexture.Layout, verts.Length); _indexBufferBinding = new IndexBufferBinding(ibo, is32Bit: true, count: tris.Length); _mesh = new Mesh() { Draw = new MeshDraw() { PrimitiveType = PrimitiveType.TriangleList, VertexBuffers = new[] { _vertexBufferBinding }, IndexBuffer = _indexBufferBinding, DrawCount = tris.Length } }; _modelComponent = new ModelComponent() { Model = new Model() { _mesh, Material } }; Entity.Add(_modelComponent); // Bounding box for culling (stops rendering the mesh when the camera isn't looking at it) _mesh.BoundingBox = MathHelpers.FromPoints(verts); _mesh.BoundingSphere = BoundingSphere.FromBox(_mesh.BoundingBox); CreateCollider(); }
private void CreateMesh() { var vbo = Xenko.Graphics.Buffer.Vertex.New( GraphicsDevice, vertices, GraphicsResourceUsage.Default ); var ibo = Xenko.Graphics.Buffer.Index.New( GraphicsDevice, indices, GraphicsResourceUsage.Default ); _vertexBufferBinding = new VertexBufferBinding(vbo, VertexPositionNormalColor.Layout, vertices.Length); _indexBufferBinding = new IndexBufferBinding(ibo, is32Bit: true, count: indices.Length); _mesh = new Mesh() { Draw = new MeshDraw() { PrimitiveType = PrimitiveType.TriangleList, VertexBuffers = new[] { _vertexBufferBinding }, IndexBuffer = _indexBufferBinding, DrawCount = indices.Length } }; _modelComponent = new ModelComponent() { Model = new Model() { _mesh, material } }; Entity.Add(_modelComponent); // Bounding box for culling _mesh.BoundingBox = Helpers.FromPoints(vertices); _mesh.BoundingSphere = BoundingSphere.FromBox(_mesh.BoundingBox); }
/// <summary> /// Called when task calls <see cref="SceneRenderTask.Draw" /> event. /// </summary> /// <param name="collector">The draw calls collector.</param> public virtual void OnDraw(DrawCallsCollector collector) { if (_highlightMaterial == null) { return; } Matrix m1, m2, world; for (var i = 0; i < _highlights.Count; i++) { HighlightData highlight = _highlights[i]; if (highlight.Target is StaticModel staticModel) { if (staticModel.Model == null) { continue; } staticModel.Transform.GetWorld(out m1); staticModel.Entries[highlight.EntryIndex].Transform.GetWorld(out m2); Matrix.Multiply(ref m2, ref m1, out world); BoundingSphere bounds = BoundingSphere.FromBox(staticModel.Box); collector.AddDrawCall(staticModel.Model, highlight.EntryIndex, _highlightMaterial, ref bounds, ref world); } } if (_highlightTriangles.Count > 0) { var mesh = _highlightTrianglesModel.LODs[0].Meshes[0]; if (!Utils.ArraysEqual(_highlightTrianglesSet, _highlightTriangles)) { _highlightIndicesSet = new int[_highlightTriangles.Count]; for (int i = 0; i < _highlightIndicesSet.Length; i++) { _highlightIndicesSet[i] = i; } _highlightTrianglesSet = _highlightTriangles.ToArray(); mesh.UpdateMesh(_highlightTrianglesSet, _highlightIndicesSet); } world = Matrix.Identity; collector.AddDrawCall(mesh, _highlightMaterial, ref world); } }
protected void CreateBoundingBox() { if (IsZone == 1 || _arenaRadius == -1f) { Vector3[] vertices = new Vector3[SharpRenderer.pyramidVertices.Count]; for (int i = 0; i < SharpRenderer.pyramidVertices.Count; i++) { vertices[i] = (Vector3)Vector3.Transform(SharpRenderer.pyramidVertices[i], world); } boundingBox = BoundingBox.FromPoints(vertices); boundingSphere = BoundingSphere.FromBox(boundingBox); } else { boundingSphere = new BoundingSphere(_position, _arenaRadius); boundingBox = BoundingBox.FromSphere(boundingSphere); } }
protected Mesh CreateMesh(IndexBufferBinding indexBuffer, IMeshData <TVertex> meshData) { Contracts.Requires.That(indexBuffer != null); Contracts.Requires.That(meshData != null); var vertexBuffers = new[] { new VertexBufferBinding( Buffer.Vertex.New(this.GraphicsDevice, meshData.Vertices, GraphicsResourceUsage.Immutable), this.Format.Layout, meshData.VerticesCount), }; var meshDraw = new MeshDraw() { IndexBuffer = indexBuffer, VertexBuffers = vertexBuffers, DrawCount = meshData.IndicesCount, PrimitiveType = PrimitiveType.TriangleList, }; // create the bounding volumes var boundingBox = BoundingBox.Empty; for (int index = 0; index < meshData.VerticesCount; index++) { var position = this.Format.GetPosition(meshData.Vertices[index]); BoundingBox.Merge(ref boundingBox, ref position, out boundingBox); } var boundingSphere = BoundingSphere.FromBox(boundingBox); return(new Mesh { Draw = meshDraw, BoundingBox = boundingBox, BoundingSphere = boundingSphere, }); }
/// <summary> /// Tries to get the bounding sphere for the given render-loop. /// Returns BoundingSphere.Empty, if it is not available. /// </summary> /// <param name="viewInfo">The ViewInformation for which to get the BoundingSphere.</param> public override BoundingSphere TryGetBoundingSphere(ViewInformation viewInfo) { GeometryResource geometryResource = m_localResources[viewInfo.Device.DeviceIndex]; if ((geometryResource != null) && (geometryResource.IsLoaded)) { // Get BoundingBox object BoundingBox boundingBox = geometryResource.BoundingBox; // Calculate bounding sphare BoundingSphere result; BoundingSphere.FromBox(ref boundingBox, out result); result.Transform(this.Transform); return(result); } else { return(BoundingSphere.Empty); } }
protected override void CreateBoundingBox() { if (Shape == TriggerShape.Box) { boundingBox = new BoundingBox(-Vector3.One, Vector3.One); boundingBox.Maximum = (Vector3)Vector3.Transform(boundingBox.Maximum, world); boundingBox.Minimum = (Vector3)Vector3.Transform(boundingBox.Minimum, world); boundingSphere = BoundingSphere.FromBox(boundingBox); } else if (Shape == TriggerShape.Sphere) { boundingSphere = new BoundingSphere(_trigPos0, Radius); boundingBox = BoundingBox.FromSphere(boundingSphere); } else { boundingBox = new BoundingBox { Maximum = new Vector3(Position0X, Position0Y, Position0Z) + new Vector3(Radius, Height * 2, Radius), Minimum = new Vector3(Position0X, Position0Y, Position0Z) - new Vector3(Radius, Height * 2, Radius) }; boundingSphere = BoundingSphere.FromBox(boundingBox); } }
/// <summary> /// Calculate the bounding sphere of the entity's models. /// </summary> /// <param name="entity">The entity to measure</param> /// <param name="isRecursive">Indicate the child entities bounding spheres should be merged</param> /// <param name="meshSelector">Selects which meshes are considered for bounding box calculation.</param> /// <returns>The bounding sphere (world matrix included)</returns> public static BoundingSphere CalculateBoundSphere(this Entity entity, bool isRecursive = true, Func <Model, IEnumerable <Mesh> > meshSelector = null) { entity.Transform.UpdateWorldMatrix(); var worldMatrix = entity.Transform.WorldMatrix; var boundingSphere = BoundingSphere.Empty; // calculate the bounding sphere of the model if any var modelComponent = entity.Get <ModelComponent>(); var hasModel = modelComponent?.Model != null; if (hasModel) { var hierarchy = modelComponent.Skeleton; var nodeTransforms = new Matrix[hierarchy.Nodes.Length]; // Calculate node transforms here, since there might not be a ModelProcessor running for (int i = 0; i < nodeTransforms.Length; i++) { if (hierarchy.Nodes[i].ParentIndex == -1) { nodeTransforms[i] = worldMatrix; } else { Matrix localMatrix; Matrix.Transformation( ref hierarchy.Nodes[i].Transform.Scale, ref hierarchy.Nodes[i].Transform.Rotation, ref hierarchy.Nodes[i].Transform.Position, out localMatrix); Matrix.Multiply(ref localMatrix, ref nodeTransforms[hierarchy.Nodes[i].ParentIndex], out nodeTransforms[i]); } } // calculate the bounding sphere var boundingBox = BoundingBoxExt.Empty; var meshes = modelComponent.Model.Meshes; var filteredMeshes = meshSelector == null ? meshes : meshSelector(modelComponent.Model); // Calculate skinned bounding boxes. // TODO: Cloned from ModelSkinningUpdater. Consolidate. foreach (var mesh in filteredMeshes) { var skinning = mesh.Skinning; if (skinning == null) { // For unskinned meshes, use the original bounding box var boundingBoxExt = (BoundingBoxExt)mesh.BoundingBox; boundingBoxExt.Transform(nodeTransforms[mesh.NodeIndex]); BoundingBoxExt.Merge(ref boundingBox, ref boundingBoxExt, out boundingBox); } else { var bones = skinning.Bones; var bindPoseBoundingBox = new BoundingBoxExt(mesh.BoundingBox); for (var index = 0; index < bones.Length; index++) { var nodeIndex = bones[index].NodeIndex; Matrix boneMatrix; // Compute bone matrix Matrix.Multiply(ref bones[index].LinkToMeshMatrix, ref nodeTransforms[nodeIndex], out boneMatrix); // Fast AABB transform: http://zeuxcg.org/2010/10/17/aabb-from-obb-with-component-wise-abs/ // Compute transformed AABB (by world) var boundingBoxExt = bindPoseBoundingBox; boundingBoxExt.Transform(boneMatrix); BoundingBoxExt.Merge(ref boundingBox, ref boundingBoxExt, out boundingBox); } } } var halfSize = boundingBox.Extent; var maxHalfSize = Math.Max(halfSize.X, Math.Max(halfSize.Y, halfSize.Z)); boundingSphere = BoundingSphere.Merge(boundingSphere, new BoundingSphere(boundingBox.Center, maxHalfSize)); } // Calculate the bounding sphere for the sprite component if any and merge the result var spriteComponent = entity.Get <SpriteComponent>(); var hasSprite = spriteComponent?.CurrentSprite != null; if (hasSprite && !(hasModel && meshSelector != null)) { var spriteSize = spriteComponent.CurrentSprite.Size; var spriteDiagonalSize = (float)Math.Sqrt(spriteSize.X * spriteSize.X + spriteSize.Y * spriteSize.Y); // Note: this is probably wrong, need to unify with SpriteComponentRenderer var center = worldMatrix.TranslationVector; var scales = new Vector3(worldMatrix.Row1.Length(), worldMatrix.Row2.Length(), worldMatrix.Row3.Length()); var maxScale = Math.Max(scales.X, Math.Max(scales.Y, scales.Z)); boundingSphere = BoundingSphere.Merge(boundingSphere, new BoundingSphere(center, maxScale * spriteDiagonalSize / 2f)); } var spriteStudioComponent = entity.Get <SpriteStudioComponent>(); if (spriteStudioComponent != null) { // Make sure nodes are prepared if (!SpriteStudioProcessor.PrepareNodes(spriteStudioComponent)) { return(new BoundingSphere()); } // Update root nodes foreach (var node in spriteStudioComponent.Nodes) { node.UpdateTransformation(); } // Compute bounding sphere for each node foreach (var node in spriteStudioComponent.Nodes.SelectDeep(x => x.ChildrenNodes)) { if (node.Sprite == null || node.Hide != 0) { continue; } var nodeMatrix = node.ModelTransform * worldMatrix; var spriteSize = node.Sprite.Size; var spriteDiagonalSize = (float)Math.Sqrt(spriteSize.X * spriteSize.X + spriteSize.Y * spriteSize.Y); Vector3 pos, scale; nodeMatrix.Decompose(out scale, out pos); var center = pos; var maxScale = Math.Max(scale.X, scale.Y); //2d ignore Z boundingSphere = BoundingSphere.Merge(boundingSphere, new BoundingSphere(center, maxScale * (spriteDiagonalSize / 2f))); } } var particleComponent = entity.Get <ParticleSystemComponent>(); if (particleComponent != null) { var center = worldMatrix.TranslationVector; var sphere = particleComponent.ParticleSystem?.BoundingShape != null?BoundingSphere.FromBox(particleComponent.ParticleSystem.BoundingShape.GetAABB(center, Quaternion.Identity, 1.0f)) : new BoundingSphere(center, 2.0f); boundingSphere = BoundingSphere.Merge(boundingSphere, sphere); } var boundingBoxComponent = entity.Get <NavigationBoundingBoxComponent>(); if (boundingBoxComponent != null) { var center = worldMatrix.TranslationVector; var scales = new Vector3(worldMatrix.Row1.Length(), worldMatrix.Row2.Length(), worldMatrix.Row3.Length()) * boundingBoxComponent.Size; boundingSphere = BoundingSphere.FromBox(new BoundingBox(-scales + center, scales + center)); } // Extend the bounding sphere to include the children if (isRecursive) { foreach (var child in entity.GetChildren()) { boundingSphere = BoundingSphere.Merge(boundingSphere, child.CalculateBoundSphere(true, meshSelector)); } } // If the entity does not contain any components having an impact on the bounding sphere, create an empty bounding sphere centered on the entity position. if (boundingSphere == BoundingSphere.Empty) { boundingSphere = new BoundingSphere(worldMatrix.TranslationVector, 0); } return(boundingSphere); }
/// <summary> /// Called when task calls <see cref="SceneRenderTask.CollectDrawCalls" /> event. /// </summary> /// <param name="renderContext">The rendering context.</param> public virtual void OnDraw(ref RenderContext renderContext) { if (_highlightMaterial == null || (_highlights.Count == 0 && _highlightTriangles.Count == 0) || renderContext.View.Pass == DrawPass.Depth ) { return; } Profiler.BeginEvent("ViewportDebugDrawData.OnDraw"); Matrix world; for (var i = 0; i < _highlights.Count; i++) { HighlightData highlight = _highlights[i]; if (highlight.Target is StaticModel staticModel) { var model = staticModel.Model; if (model == null) { continue; } staticModel.Transform.GetWorld(out world); var bounds = BoundingSphere.FromBox(staticModel.Box); // Pick a proper LOD int lodIndex = RenderTools.ComputeModelLOD(model, ref bounds.Center, bounds.Radius, ref renderContext); var lods = model.LODs; if (lods == null || lods.Length < lodIndex || lodIndex < 0) { continue; } var lod = lods[lodIndex]; // Draw meshes for (int meshIndex = 0; meshIndex < lod.Meshes.Length; meshIndex++) { if (lod.Meshes[meshIndex].MaterialSlotIndex == highlight.EntryIndex) { lod.Meshes[meshIndex].Draw(ref renderContext, _highlightMaterial, ref world); } } } } if (_highlightTriangles.Count > 0) { var mesh = _highlightTrianglesModel.LODs[0].Meshes[0]; if (!Utils.ArraysEqual(_highlightTrianglesSet, _highlightTriangles)) { _highlightIndicesSet = new int[_highlightTriangles.Count]; for (int i = 0; i < _highlightIndicesSet.Length; i++) { _highlightIndicesSet[i] = i; } _highlightTrianglesSet = _highlightTriangles.ToArray(); mesh.UpdateMesh(_highlightTrianglesSet, _highlightIndicesSet); } world = Matrix.Identity; mesh.Draw(ref renderContext, _highlightMaterial, ref world); } Profiler.EndEvent(); }
public static float Radius(BoundingBox bounding) { return(BoundingSphere.FromBox(bounding).Radius); }
public Texture2D CreateVoxelIcon(VisualVoxelModel visualVoxelModel, Size2 iconSize, VoxelModelState state = null, DeviceContext context = null, Matrix transform = default(Matrix)) { if (context == null) { context = _d3DEngine.ImmediateContext; } //Create the render texture var texture = ToDispose(new RenderedTexture2D(_d3DEngine, iconSize.Width, iconSize.Height, Format.R8G8B8A8_UNorm) { BackGroundColor = new Color4(0, 0, 0, 0) }); float aspectRatio = IconSize / IconSize; Matrix projection; var fov = (float)Math.PI / 3.6f; Matrix.PerspectiveFovLH(fov, aspectRatio, 0.5f, 100f, out projection); Matrix view = Matrix.LookAtLH(new Vector3(0, 0, -1.9f), Vector3.Zero, Vector3.UnitY); texture.Begin(context); RenderStatesRepo.ApplyStates(context, DXStates.Rasters.Default, DXStates.Blenders.Enabled, DXStates.DepthStencils.DepthReadWriteEnabled); _voxelEffect.Begin(context); _voxelEffect.CBPerFrame.Values.LightDirection = Vector3.Zero; _voxelEffect.CBPerFrame.Values.ViewProjection = Matrix.Transpose(view * projection); _voxelEffect.CBPerFrame.IsDirty = true; var instance = visualVoxelModel.VoxelModel.CreateInstance(); if (state == null) { var iconState = visualVoxelModel.VoxelModel.States.FirstOrDefault(s => string.Equals(s.Name, "Icon", StringComparison.CurrentCultureIgnoreCase)); state = iconState ?? visualVoxelModel.VoxelModel.GetMainState(); } instance.SetState(state); var sphere = BoundingSphere.FromBox(state.BoundingBox); var rMax = 2f * Math.Sin(fov / 2); var size = state.BoundingBox.GetSize(); var offset = -size / 2 - state.BoundingBox.Minimum; var scale = (float)rMax / sphere.Radius; // Math.Min(scaleFactor / size.X, Math.Min(scaleFactor / size.Y, scaleFactor / size.Z)); if (transform == default(Matrix)) { instance.World = Matrix.Translation(offset) * Matrix.Scaling(scale) * Matrix.RotationY(MathHelper.Pi + MathHelper.PiOver4) * Matrix.RotationX(-MathHelper.Pi / 5); } else { instance.World = transform; } visualVoxelModel.Draw(context, _voxelEffect, instance); texture.End(context, false); var tex2D = texture.CloneTexture(context, ResourceUsage.Default); tex2D = DrawOuterShadow(context, texture, tex2D, iconSize.Width); _d3DEngine.SetRenderTargetsAndViewPort(context); return(tex2D); }