Ejemplo n.º 1
0
        /// <summary>Function called to update items per frame on the layer.</summary>
        protected override void OnUpdate()
        {
            if (Camera.NeedsUpdate)
            {
                if (Camera.ProjectionChanged)
                {
                    Camera.GetProjectionMatrix(out DX.Matrix projectionMatrix);
                    SetProjection(ref projectionMatrix);
                }

                if (Camera.ViewChanged)
                {
                    Camera.GetViewMatrix(out DX.Matrix viewMatrix);
                    SetView(ref viewMatrix);
                }
            }

            Camera.GetViewMatrix(out DX.Matrix view);

            _drawPlanets.Clear();

            for (int i = 0; i < Planets.Count; ++i)
            {
                Planet planet = Planets[i];
                planet.Update();

                DX.RectangleF aabb = DX.RectangleF.Empty;
                for (int j = 0; j < planet.Layers.Count; ++j)
                {
                    PlanetaryLayer layer            = planet.Layers[j];
                    DX.Vector3     originalPosition = layer.Mesh.Position;

                    UpdateMeshWorldMatrix(layer.Mesh);

                    DX.RectangleF meshAabb = layer.Mesh.GetAABB();

                    if (!meshAabb.IsEmpty)
                    {
                        if (aabb.IsEmpty)
                        {
                            aabb = meshAabb;
                        }
                        else
                        {
                            aabb = DX.RectangleF.Union(meshAabb, aabb);
                        }
                    }

                    layer.Mesh.Position = originalPosition;
                }

                // Cull the planet if it's outside of our view.
                if (Camera.ViewableRegion.Intersects(aabb))
                {
                    _drawPlanets.Add(planet);
                }
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Function to load the resources for the layer.
        /// </summary>
        public override void LoadResources()
        {
            _drawCalls = new List <GorgonDrawIndexCall>();
            BuildConstantBuffers();

            for (int i = 0; i < Planets.Count; ++i)
            {
                Planet planet = Planets[i];

                for (int j = 0; j < planet.Layers.Count; ++j)
                {
                    PlanetaryLayer layer = planet.Layers[j];

                    GorgonVertexShader vertexShader = _resources.VertexShaders[layer.Mesh.Material.VertexShader];
                    GorgonPixelShader  pixelShader  = _resources.PixelShaders[layer.Mesh.Material.PixelShader];

                    // Create our vertex layout now.
                    if (_vertexLayout == null)
                    {
                        _vertexLayout = _vertexLayout = GorgonInputLayout.CreateUsingType <Vertex3D>(_graphics, vertexShader);
                    }

                    // Set up a pipeline state for the mesh.
                    GorgonPipelineState pipelineState = _stateBuilder.Clear()
                                                        .PixelShader(pixelShader)
                                                        .VertexShader(vertexShader)
                                                        .BlendState(layer.Mesh.Material.BlendState)
                                                        .PrimitiveType(PrimitiveType.TriangleList)
                                                        .Build();
                    _drawCallBuilder.Clear()
                    .PipelineState(pipelineState)
                    .IndexBuffer(layer.Mesh.IndexBuffer, 0, layer.Mesh.IndexCount)
                    .VertexBuffer(_vertexLayout, new GorgonVertexBufferBinding(layer.Mesh.VertexBuffer, Vertex3D.Size))
                    .ConstantBuffer(ShaderType.Vertex, _viewProjectionBuffer)
                    .ConstantBuffer(ShaderType.Vertex, _worldBuffer, 1)
                    .ConstantBuffer(ShaderType.Pixel, _cameraBuffer)
                    .ConstantBuffer(ShaderType.Pixel, _lightBuffer, 1)
                    .ConstantBuffer(ShaderType.Pixel, _materialBuffer, 2);

                    (int startTexture, int textureCount) = layer.Mesh.Material.Textures.GetDirtyItems();

                    for (int k = startTexture; k < startTexture + textureCount; ++k)
                    {
                        GorgonTexture2DView texture = _resources.Textures[layer.Mesh.Material.Textures[k]];
                        _drawCallBuilder.ShaderResource(ShaderType.Pixel, texture, k);
                        // We should have this in the material, but since we know what we've got here, this will be fine.
                        _drawCallBuilder.SamplerState(ShaderType.Pixel, GorgonSamplerState.Wrapping, k);
                    }

                    _drawCalls.Add(_drawCallBuilder.Build());
                }
            }

            UpdateLightTransforms();
        }
Ejemplo n.º 3
0
        /// <summary>
        /// Function to render the layer data.
        /// </summary>
        public override void Render()
        {
            int drawCallIndex = 0;

            if (_drawPlanets.Count == 0)
            {
                return;
            }

            // Apply active lights
            Array.Clear(_lightData, 0, _lightData.Length);
            for (int i = 0; i < ActiveLights.Count.Min(_lightData.Length); ++i)
            {
                Light light = ActiveLights[i];

                if (light == null)
                {
                    continue;
                }

                _lightData[i] = new LightData
                {
                    SpecularPower = light.SpecularPower,
                    Attenuation   = light.Attenuation,
                    LightColor    = light.Color,
                    LightPosition = new DX.Vector3(light.Position.X, light.Position.Y, -light.Position.Z),
                    SpecularColor = GorgonColor.White,
                    Intensity     = light.Intensity
                };
            }

            if (ActiveLights.Count > 0)
            {
                _lightBuffer.Buffer.SetData(_lightData);
            }

            for (int i = 0; i < _drawPlanets.Count; ++i)
            {
                Planet planet = _drawPlanets[i];
                for (int j = 0; j < planet.Layers.Count; ++j)
                {
                    PlanetaryLayer layer = planet.Layers[j];
                    MoveableMesh   mesh  = layer.Mesh;

                    UpdateMaterial(mesh);
                    UpdateWorldTransform(mesh);

                    _graphics.Submit(_drawCalls[drawCallIndex++]);
                }
            }
        }