/// <summary>
        /// Draw.
        /// </summary>
        /// <param name="gt">The gt.</param>
        /// <param name="obj">The obj.</param>
        /// <param name="render">The render.</param>
        /// <param name="camera">The camera.</param>
        /// <param name="lights">The lights.</param>
        protected override void Draw(GameTime gt, IObject obj, RenderHelper render, ICamera camera, IList <ILight> lights)
        {
            IModelo modelo = obj.Modelo;

            IdParameter.SetValue(shaderId);
            SpecularIntensityParameter.SetValue(specularIntensity);
            SpecularPowerParameter.SetValue(specularPower);
            ViewProjectionParameter.SetValue(camera.ViewProjection);

            for (int i = 0; i < modelo.MeshNumber; i++)
            {
                BatchInformation[] bi = modelo.GetBatchInformation(i);
                for (int j = 0; j < bi.Count(); j++)
                {
                    if (useAmbientCubeMap)
                    {
                        render.Textures[4] = modelo.GetCubeTexture(TextureType.AMBIENT_CUBE_MAP, i, j);
                        //PAmbientCubeTexture.SetValue(modelo.GetCubeTexture(TextureType.AMBIENT_CUBE_MAP, i, j));
                        PAmbientCubeMapScale.SetValue(AmbientCubeMapScale);
                    }
                    render.Textures[0] = modelo.getTexture(TextureType.DIFFUSE, i, j);
                    //TextureParameter.SetValue(modelo.getTexture(TextureType.DIFFUSE,i,j));
                    WorldParameter.SetValue(bi[j].ModelLocalTransformation * obj.WorldMatrix);
                    render.RenderBatch(bi[j], _shader);
                }
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Draw
        /// </summary>
        /// <param name="gt">The gt.</param>
        /// <param name="obj">The obj.</param>
        /// <param name="render">The render.</param>
        /// <param name="cam">The cam.</param>
        /// <param name="lights">The lights.</param>
        public void iDraw(GameTime gt, IObject obj, RenderHelper render, ICamera cam, IList <ILight> lights)
        {
            if (OcclusionQuery != null)
            {
                while (OcclusionQuery.Tag == null && OcclusionQuery.IsComplete == false)
                {
                }

                if ((OcclusionQuery.Tag == null && OcclusionQuery.PixelCount > 0) || obj.PhysicObject.BoundingBox == null)
                {
                    PixelsRendered = OcclusionQuery.PixelCount;
                    //Enable rendering to screen.
                    //Enable or disable writing to depth buffer (depends on whether the object is translucent or opaque).
                    //Render the object itself.
                    OcclusionQuery.Begin();
                    this.Draw(gt, obj, render, cam, lights);
                    OcclusionQuery.End();
                }
                else
                {
                    //Disable rendering to screen.
                    //Disable writing to depth buffer.
                    //"Render" the object's bounding box.

                    PixelsRendered = 0;
                    OcclusionQuery.Begin();
                    render.PushBlendState(BlendState);
                    render.PushDepthStencilState(DepthStencilState.DepthRead);
                    BoundingBox BoundingBox = obj.PhysicObject.BoundingBox.Value;
                    BasicEffect.View       = cam.View;
                    BasicEffect.Projection = cam.Projection;
                    Vector3 centerPos = obj.PhysicObject.Position;
                    Vector3 scale     = BoundingBox.Max - BoundingBox.Min;

                    Matrix world = Matrix.CreateScale(scale);
                    world.Translation = centerPos;
                    BasicEffect.World = world;
                    render.RenderBatch(Modelo.GetBatchInformation(0)[0], BasicEffect);
                    OcclusionQuery.End();
                    render.PopDepthStencilState();
                    render.PopBlendState();
                    OcclusionQuery.Tag = null;
                }
            }
            else
            {
                PixelsRendered = 0;
                this.Draw(gt, obj, render, cam, lights);
            }
        }
        public override void Draw(Texture2D ImageToProcess, RenderHelper rHelper, Microsoft.Xna.Framework.GameTime gt, PloobsEngine.Engine.GraphicInfo GraphicInfo, IWorld world, bool useFloatBuffer)
        {
            rHelper.PushRenderTarget(target);
            rHelper.Clear(Color.Black);
            effectdistorcion.Parameters["halfPixel"].SetValue(GraphicInfo.HalfPixel);
            effectdistorcion.Parameters["DEPTH"].SetValue(rHelper[PrincipalConstants.DephRT]);
            effectdistorcion.Parameters["DistortionScale"].SetValue(Distortion);
            rHelper.PushDepthStencilState(DepthStencilState.None);

            foreach (var obj in objs)
            {
                IModelo modelo = obj.Modelo;

                for (int i = 0; i < modelo.MeshNumber; i++)
                {
                    BatchInformation[] bi = modelo.GetBatchInformation(i);
                    for (int j = 0; j < bi.Count(); j++)
                    {
                        Matrix w = bi[j].ModelLocalTransformation * obj.WorldMatrix;
                        effectdistorcion.Parameters["WorldViewProjection"].SetValue(w * world.CameraManager.ActiveCamera.View * world.CameraManager.ActiveCamera.Projection);
                        effectdistorcion.Parameters["WorldView"].SetValue(w * world.CameraManager.ActiveCamera.View);
                        rHelper.RenderBatch(bi[j], effectdistorcion);
                    }
                }
            }

            rHelper.PopDepthStencilState();

            x = rHelper.PopRenderTargetAsSingleRenderTarget2D();

            rHelper.Clear(Color.Black);
            effect.Parameters["SceneTexture"].SetValue(ImageToProcess);
            effect.Parameters["DistortionMap"].SetValue(x);
            //effect.Parameters["halfPixel"].SetValue(GraphicInfo.HalfPixel);
            rHelper.RenderTextureToFullScreenSpriteBatch(ImageToProcess, effect, GraphicInfo.FullScreenRectangle);
        }
        /// <summary>
        /// Helper to get the vertex and index List from the model.
        /// </summary>
        /// <param name="vert">The vert.</param>
        /// <param name="ind">The ind.</param>
        /// <param name="model">The model.</param>
        private void ExtractData(ref Vector3[] vert, ref int[] ind, IModelo model)
        {
            List <Vector3> vertices = new List <Vector3>();
            List <int>     indices  = new List <int>();

            for (int i = 0; i < model.MeshNumber; i++)
            {
                BatchInformation[] bi = model.GetBatchInformation(i);
                for (int j = 0; j < bi.Length; j++)
                {
                    BatchInformation info = bi[j];
                    int       offset      = vertices.Count;
                    Vector3[] a           = new Vector3[info.NumVertices];

                    // Read the format of the vertex buffer
                    VertexDeclaration declaration    = bi[j].VertexBuffer.VertexDeclaration;
                    VertexElement[]   vertexElements = declaration.GetVertexElements();
                    // Find the element that holds the position
                    VertexElement vertexPosition = new VertexElement();
                    foreach (VertexElement elem in vertexElements)
                    {
                        if (elem.VertexElementUsage == VertexElementUsage.Position &&
                            elem.VertexElementFormat == VertexElementFormat.Vector3)
                        {
                            vertexPosition = elem;
                            // There should only be one
                            break;
                        }
                    }
                    // Check the position element found is valid
                    if (vertexPosition == null ||
                        vertexPosition.VertexElementUsage != VertexElementUsage.Position ||
                        vertexPosition.VertexElementFormat != VertexElementFormat.Vector3)
                    {
                        throw new Exception("Model uses unsupported vertex format!");
                    }
                    // This where we store the vertices until transformed
                    // Read the vertices from the buffer in to the array
                    bi[j].VertexBuffer.GetData <Vector3>(
                        bi[j].BaseVertex * declaration.VertexStride + vertexPosition.Offset,
                        a,
                        0,
                        bi[j].NumVertices,
                        declaration.VertexStride);

                    for (int k = 0; k != a.Length; ++k)
                    {
                        Vector3.Transform(ref a[k], ref info.ModelLocalTransformation, out a[k]);
                    }
                    vertices.AddRange(a);

                    if (info.IndexBuffer.IndexElementSize != IndexElementSize.SixteenBits)
                    {
                        int[] s = new int[info.PrimitiveCount * 3];
                        info.IndexBuffer.GetData <int>(info.StartIndex * 2, s, 0, info.PrimitiveCount * 3);
                        for (int k = 0; k != info.PrimitiveCount; ++k)
                        {
                            indices.Add(s[k * 3 + 2] + offset);
                            indices.Add(s[k * 3 + 1] + offset);
                            indices.Add(s[k * 3 + 0] + offset);
                        }
                    }
                    else
                    {
                        short[] s = new short[info.PrimitiveCount * 3];
                        info.IndexBuffer.GetData <short>(info.StartIndex * 2, s, 0, info.PrimitiveCount * 3);
                        for (int k = 0; k != info.PrimitiveCount; ++k)
                        {
                            indices.Add(s[k * 3 + 2] + offset);
                            indices.Add(s[k * 3 + 1] + offset);
                            indices.Add(s[k * 3 + 0] + offset);
                        }
                    }
                }
            }

            ind  = indices.ToArray();
            vert = vertices.ToArray();
        }