Example #1
0
 public Object3D(Device device, float a, float b, float c)
 {
     material         = new Direct3D.Material();
     material.Diffuse = material.Ambient = Color.FromArgb(0, 0, 255, 100);
     mesh             = Mesh.Box(device, a, b, c);
     quat             = new Quaternion();
 }
Example #2
0
 public Object3D(Device device)
 {
     material         = new Direct3D.Material();
     material.Diffuse = material.Ambient = Color.White;
     mesh             = Mesh.Box(device, 1, 1, 1);
     quat             = new Quaternion();
 }
Example #3
0
        private void SetupLights()
        {
            System.Drawing.Color col = System.Drawing.Color.White;
            //Set up a material. The material here just has the diffuse and ambient
            //colors set to yellow. Note that only one material can be used at a time.
            Direct3D.Material mtrl = new Direct3D.Material();
            mtrl.Diffuse    = col;
            mtrl.Ambient    = col;
            device.Material = mtrl;

            //Set up a white, directional light, with an oscillating direction.
            //Note that many lights may be active at a time (but each one slows down
            //the rendering of our scene). However, here we are just using one. Also,
            //we need to set the D3DRS_LIGHTING renderstate to enable lighting

            device.Lights[0].Type      = LightType.Directional;
            device.Lights[0].Diffuse   = System.Drawing.Color.DarkTurquoise;
            device.Lights[0].Direction = new Vector3((float)Math.Cos(Environment.TickCount / 250.0f), 1.0f, (float)Math.Sin(Environment.TickCount / 250.0f));

            device.Lights[0].Commit();            //let d3d know about the light
            device.Lights[0].Enabled = true;      //turn it on

            //Finally, turn on some ambient light.
            //Ambient light is light that scatters and lights all objects evenly
            device.RenderState.Ambient = System.Drawing.Color.FromArgb(0x202020);
        }
Example #4
0
        public void AddLightMesh()
        {
            Direct3D.Material mat = new Direct3D.Material();
            mat.Diffuse           = Color.Yellow;
            mat.Ambient           = Color.Yellow;
            mat.Specular          = Color.Yellow;
            mat.SpecularSharpness = 1;

            Direct3D.Material matoff = new Direct3D.Material();
            matoff.Diffuse           = Color.DarkGray;
            matoff.Ambient           = Color.DarkGray;
            matoff.Specular          = Color.DarkGray;
            matoff.SpecularSharpness = 1;
            Mesh m  = Mesh.Sphere(Device, 0.2f, 10, 4);
            Mesh mp = Mesh.Box(Device, 0.2f, 0.2f, 0.2f);

            MeshBox mb;

            for (int i = 0; i < Device.Lights.Count; i++)
            {
                Light l = Device.Lights[i];
                if (!l.Enabled)
                {
                    mb = new MeshBox("Light", m, 1, matoff);
                }
                else
                {
                    mb = new MeshBox("Light", m, 1, mat);
                }

                Vector3 v = l.Position;

                mb.Transform = MeshTransform.Translation(v);
                this.Meshes.Add(mb);

                if (!l.Enabled)
                {
                    mb = new MeshBox("Light", mp, 1, matoff);
                }
                else
                {
                    mb = new MeshBox("Light", mp, 1, mat);
                }
                mb.Transform = MeshTransform.Translation(l.Position + 0.4f * l.Direction);
                this.Meshes.Add(mb);

                if (!l.Enabled)
                {
                    mb = new MeshBox("Light", mp, 1, matoff);
                }
                else
                {
                    mb = new MeshBox("Light", mp, 1, mat);
                }
                mb.Transform = MeshTransform.Translation(l.Position + 0.5f * l.Direction);
                this.Meshes.Add(mb);
            }
        }
Example #5
0
        public MidgetMaterial()
        {
            material = new Material();

            ambient           = material.Ambient;
            diffuse           = material.Diffuse;
            emissive          = material.Emissive;
            specular          = material.Specular;
            specularSharpness = material.SpecularSharpness;
        }
Example #6
0
        public MidgetMaterial()
        {
            material = new Material();

            ambient = material.Ambient;
            diffuse = material.Diffuse;
            emissive = material.Emissive;
            specular = material.Specular;
            specularSharpness = material.SpecularSharpness;
        }
Example #7
0
        /// <summary>
        /// Builds the material using a standard Direct3D material structure and the name of the VisualEffect.
        /// </summary>
        public Material( Renderer renderer, Direct3D.Material material, string visualEffectName )
        {
            if ( renderer == null )
                throw new ArgumentNullException( "renderer",
                    "Cannot create a material with a null renderer reference." );

            this.renderer = renderer;
            d3dMaterial = material;
            this.visualEffectName = visualEffectName;
        }
Example #8
0
        /// <summary>
        /// The device exists, but may have just been Reset().  Resources in
        /// Pool.Default and any other device state that persists during
        /// rendering should be set here.  Render states, matrices, textures,
        /// etc., that don't change during rendering can be set once here to
        /// avoid redundant state setting during Render() or FrameMove().
        /// </summary>
        protected override void RestoreDeviceObjects(System.Object sender, System.EventArgs e)
        {
            // Build the device objects for the file-based objecs
            helicopterMesh.RestoreDeviceObjects(device, null);
            terrainMesh.RestoreDeviceObjects(device, null);

            // Set up textures
            device.TextureState[0].ColorArgument1 = TextureArgument.TextureColor;
            device.TextureState[0].ColorArgument2 = TextureArgument.Diffuse;
            device.TextureState[0].ColorOperation = TextureOperation.Modulate;
            device.SamplerState[0].MinFilter      = TextureFilter.Linear;
            device.SamplerState[0].MagFilter      = TextureFilter.Linear;

            // Set up misc render states
            device.RenderState.ZBufferEnable  = true;
            device.RenderState.DitherEnable   = true;
            device.RenderState.SpecularEnable = false;
            device.RenderState.Ambient        = System.Drawing.Color.FromArgb(0x00555555);

            // Set the transform matrices
            Vector3 vEyePt = new Vector3(0.0f, 5.5f, -15.0f);
            Vector3 vLookatPt = new Vector3(0.0f, 1.5f, 0.0f);
            Vector3 vUpVec = new Vector3(0.0f, 1.0f, 0.0f);
            Matrix  matWorld, matView, matProj;

            matWorld = Matrix.Identity;
            matView  = Matrix.LookAtLH(vEyePt, vLookatPt, vUpVec);
            float fAspect = device.PresentationParameters.BackBufferWidth / (float)device.PresentationParameters.BackBufferHeight;

            matProj = Matrix.PerspectiveFovLH((float)Math.PI / 4, fAspect, 1.0f, 1000.0f);

            device.Transform.World      = matWorld;
            device.Transform.View       = matView;
            device.Transform.Projection = matProj;

            // Set up a material
            mirrorMaterial = GraphicsUtility.InitMaterial(System.Drawing.Color.LightBlue);

            // Set up the light
            GraphicsUtility.InitLight(device.Lights[0], LightType.Directional, 0.0f, -1.0f, 1.0f);
            device.Lights[0].Commit();
            device.Lights[0].Enabled = true;

            // Turn on fog
            float fFogStart = 80.0f;
            float fFogEnd   = 100.0f;

            device.RenderState.FogEnable      = true;
            device.RenderState.FogColor       = FogColor;
            device.RenderState.FogTableMode   = FogMode.None;
            device.RenderState.FogVertexMode  = FogMode.Linear;
            device.RenderState.RangeFogEnable = false;
            device.RenderState.FogStart       = fFogStart;
            device.RenderState.FogEnd         = fFogEnd;
        }
Example #9
0
        public void Render(Device device)
        {
            if (Geometry.Clr != -1)
            {
                device.RenderState.Lighting = true;
                Microsoft.DirectX.Direct3D.Material mt = new Microsoft.DirectX.Direct3D.Material();
                mt.AmbientColor = ColorValue.FromArgb(Geometry.Clr);
                mt.DiffuseColor = ColorValue.FromArgb(Geometry.Clr);
                device.RenderState.DiffuseMaterialSource = ColorSource.Material;
                device.Material = mt;
                device.RenderState.AmbientColor = Geometry.Clr;
            }

            device.VertexFormat = vFormat;
            device.SetStreamSource(0, vBuffer, 0);
            if (matIBuffers != null)
            {
                for (int mat = 0; mat < MaterialIndices.Length; mat++)
                {
                    Microsoft.DirectX.Direct3D.Material oMat = device.Material;
                    if (MaterialIndices[mat].Material.Texture == null)
                    {
                        Microsoft.DirectX.Direct3D.Material material = new Microsoft.DirectX.Direct3D.Material();
                        material.AmbientColor = ColorValue.FromColor(System.Drawing.Color.FromArgb(MaterialIndices[mat].Material.Ambient.A,
                                                                                                   MaterialIndices[mat].Material.Ambient.R,
                                                                                                   MaterialIndices[mat].Material.Ambient.G,
                                                                                                   MaterialIndices[mat].Material.Ambient.B));
                        material.DiffuseColor = ColorValue.FromColor(System.Drawing.Color.FromArgb(MaterialIndices[mat].Material.Diffuse.A,
                                                                                                   MaterialIndices[mat].Material.Diffuse.R,
                                                                                                   MaterialIndices[mat].Material.Diffuse.G,
                                                                                                   MaterialIndices[mat].Material.Diffuse.B));
                        device.Material = material;
                    }
                    else
                    {
                        device.SetTexture(0, MaterialIndices[mat].Material.Texture);
                    }

                    device.Indices = matIBuffers[mat];
                    device.DrawIndexedPrimitives(Geometry.PrimType, 0, 0, Geometry.Vertices.Length, 0, MaterialIndices[mat].PrimCount);

                    device.Material = oMat;
                }
            }
            else if (iBuffer != null)
            {
                device.Indices = iBuffer;
                device.DrawIndexedPrimitives(Geometry.PrimType, 0, 0, Geometry.Vertices.Length, 0, numPrimitives);
            }
            else
            {
                device.Indices = null;
                device.DrawPrimitives(Geometry.PrimType, 0, numPrimitives);
            }
        }
Example #10
0
        public Material(Renderer renderer, Direct3D.Material material,
            string diffuseMapFilename)
        {
            if (renderer == null)
                throw new ArgumentNullException("renderer",
                    "Cannot create a material with a null renderer reference.");

            this.renderer = renderer;
            d3dMaterial = material;
            diffuseMap = new Texture(renderer, diffuseMapFilename);
        }
        protected void RenderDxScene()
        {
            //device.RenderState.FillMode = FillMode.WireFrame;
            //device.RenderState.CullMode = Cull.None;

            if (abScene.Lights != null)
            {
                for (int light = 0; light < abScene.Lights.Length; light++)
                {
                    abScene.Lights[light].SetupDx(device.Lights[light]);
                }

                device.RenderState.Lighting = true;

                Microsoft.DirectX.Direct3D.Material mt = new Microsoft.DirectX.Direct3D.Material();
                mt.AmbientColor = ColorValue.FromArgb(Color.Black.ToArgb());
                mt.DiffuseColor = ColorValue.FromArgb(Color.White.ToArgb());
                device.RenderState.DiffuseMaterialSource = ColorSource.Material;
                device.Material = mt;
                device.RenderState.AmbientColor = Color.Black.ToArgb();
            }
            else
            {
                device.RenderState.Lighting = false;
            }

            device.Clear(ClearFlags.Target | ClearFlags.ZBuffer, BackColor, 1, 0);

            if (abScene.CurrentCamera != -1)
            {
                viewMat = Matrix.LookAtLH(abScene.Cameras[abScene.CurrentCamera].Position,
                                          abScene.Cameras[abScene.CurrentCamera].Target,
                                          new Vector3(0, 1, 0));
            }
            else
            {
                viewMat = Matrix.LookAtLH(new Vector3(40, 20, 20), new Vector3(), new Vector3(0, 1, 0));
            }

            device.Transform.Projection = projMat;
            device.Transform.View       = viewMat;
            device.Transform.World      = Matrix.Identity;

            // render avalon view
            foreach (ABModel3D model in abScene.Models)
            {
                device.BeginScene();
                model.Render(device);
                device.EndScene();
            }

            device.Present();
        }
Example #12
0
        /// <summary>
        /// Builds the material using default parameters.
        /// </summary>
        public Material( Renderer renderer )
        {
            if ( renderer == null )
                throw new ArgumentNullException( "renderer",
                    "Cannot create a material with a null renderer reference." );

            this.renderer = renderer;

            d3dMaterial = new Direct3D.Material();
            d3dMaterial.Ambient = DefaultAmbientColor;
            d3dMaterial.Diffuse = DefaultDiffuseColor;
            d3dMaterial.Specular = DefaultSpecularColor;
            d3dMaterial.SpecularSharpness = DefaultShininess;
        }
Example #13
0
        public void R_FR()
        {
            TimeSpan ts = DateTime.Now - t_start;
            double t = ts.TotalSeconds;

            dev2.Clear(ClearFlags.Target | ClearFlags.ZBuffer, System.Drawing.Color.Blue, 1.0f, 0);
            dev2.BeginScene();

            System.Drawing.Color col = System.Drawing.Color.White;
            Direct3D.Material mtrl = new Direct3D.Material();
            mtrl.Diffuse = col;
            mtrl.Ambient = col;
            dev2.Material = mtrl;

            Vector4 lightdir = new Vector4((float)Math.Cos(Environment.TickCount / 550.0f), 1.0f, (float)Math.Sin(Environment.TickCount / 250.0f), 0);

            dev2.Transform.World = Matrix.RotationAxis(new Vector3((float)Math.Cos(t), 1, (float)Math.Sin(Environment.TickCount / 250.0f)), Environment.TickCount / 3000.0f);

            dev2.Transform.View = Matrix.LookAtLH(new Vector3(0.0f, 4.0f, -5.0f), new Vector3(0.0f, 0.0f, 0.0f), new Vector3(0.0f, 1.0f, 0.0f));

            dev2.Transform.Projection = Matrix.PerspectiveFovLH((float)Math.PI / 4.0f, 1.0f, 1.0f, 100.0f);

            ColorValue WhiteColor = new ColorValue(1.0f, 1.0f, 1.0f, 1.0f);
            ColorValue YellowColor = new ColorValue(1.0f, 1.0f, 0.0f, 1.0f);

            eff.SetValue("projectionMatrix", dev2.Transform.Projection);
            eff.SetValue("viewMatrix", dev2.Transform.View);
            eff.SetValue("worldMatrix", dev2.Transform.World);
            eff.SetValue("appTime", (float)t);

            //		eff.SetValue("g_MaterialDiffuseColor", WhiteColor);
            //		eff.SetValue("g_nNumLights", 1);

            dev2.SetStreamSource(0, vb, 0);
            dev2.VertexFormat = CustomVertex.PositionNormal.Format;

            eff.Begin(0);
            for (int p = 0; p < 4; p++)
            {
                eff.BeginPass(p);
                dev2.DrawPrimitives(PrimitiveType.TriangleList, 0, usteps * vsteps * 2 );
                eff.EndPass();
            }
            eff.End();
            dev2.EndScene();
            dev2.Present();
        }
Example #14
0
        public static void LoadMesh(Stream stream, D3D.Device dev, ref D3D.Mesh mesh, ref D3D.Material[] meshMaterials, ref D3D.Texture[] meshTextures)
        {
            D3D.ExtendedMaterial[] materialArray;
            mesh = D3D.Mesh.FromStream(stream, D3D.MeshFlags.Managed, dev, out materialArray);

            if ((materialArray != null) && (materialArray.Length > 0))
            {
                meshMaterials = new D3D.Material[materialArray.Length];
                meshTextures  = new D3D.Texture[materialArray.Length];
                for (int i = 0; i < materialArray.Length; i++)
                {
                    meshMaterials[i] = materialArray[i].Material3D;
                    if (!string.IsNullOrEmpty(materialArray[i].TextureFilename))
                    {
                        meshTextures[i] = D3D.TextureLoader.FromFile(dev, materialArray[i].TextureFilename);
                    }
                }
            }
        }
Example #15
0
        public void AddAxisMesh()
        {
            Direct3D.Material mat = new Direct3D.Material();
            mat.Diffuse           = Color.Red;
            mat.Ambient           = mat.Diffuse;
            mat.Specular          = mat.Diffuse;
            mat.SpecularSharpness = 1;



            Mesh    m  = Mesh.Cylinder(device, 0.001f, 0.001f, 1, 6, 1);
            MeshBox mb = new MeshBox("Axis", m, 1, mat);

            mb.Transform = MeshTransform.Translation(new Vector3(0, 0, 0));
            mb.Wire      = false;
            this.Meshes.Add(mb);

            mat.Diffuse  = Color.Green;
            mat.Ambient  = mat.Diffuse;
            mat.Specular = mat.Diffuse;
            m            = Mesh.Cylinder(device, 0.001f, 0.001f, 1, 6, 1);
            mb           = new MeshBox("Axis", m, 1, mat);
            mb.Transform = MeshTransform.RotationYawPitchRoll(
                0,
                -Math.PI / 2.0,
                0
                );
            mb.Wire = false;
            this.Meshes.Add(mb);

            mat.Diffuse  = Color.Blue;
            mat.Ambient  = mat.Diffuse;
            mat.Specular = mat.Diffuse;
            m            = Mesh.Cylinder(device, 0.001f, 0.001f, 1, 6, 1);
            mb           = new MeshBox("Axis", m, 1, mat);
            mb.Transform = MeshTransform.RotationYawPitchRoll(
                -Math.PI / 2.0,
                0,
                0
                );
            mb.Wire = false;
            this.Meshes.Add(mb);
        }
Example #16
0
        public void SetupLights()
        {
            if (transformLightOnFrame)
            {
                return;
            }

            // Turn off all the lights to start.
            for (int i = 0; i < 4; i++)
            {
                OuterSpace.device.Lights[i].Enabled = false;
            }

            // Set our material and it's colors.
            Color col = Color.White;;

            Direct3D.Material mtrl = new Direct3D.Material();

            mtrl.Diffuse = col;
            mtrl.Ambient = col;
            OuterSpace.device.Material = mtrl;

            Vector4 curSunPos = new Vector4();

            curSunPos = getsunpos();
            OuterSpace.device.Lights[0].Type      = LightType.Directional;
            OuterSpace.device.Lights[0].Diffuse   = Color.White;
            OuterSpace.device.Lights[0].Direction = new Vector3(curSunPos.X, curSunPos.Y, curSunPos.Z + 1500.0F);
            OuterSpace.device.Lights[0].Enabled   = true;
            OuterSpace.device.RenderState.Ambient = Color.FromArgb(65, 65, 65, 65);
            OuterSpace.msgbox.pushmsgs(Convert.ToString(curSunPos.Z));
            if (OuterSpace.theGameState.IsGameInState(OuterSpace.GameStates.Landed) && curSunPos.Z < 250)
            {
                OuterSpace.TV.lightson = 4;
                TVHeadlights();
            }

            transformLightOnFrame = true;
        }
Example #17
0
        public void Initialize(Device device)
        {
            material          = new Material();
            material.Ambient  = ambient;
            material.Diffuse  = diffuse;
            material.Emissive = emissive;
            specular          = material.Specular;
            specularSharpness = material.SpecularSharpness;

            texture = null;

            if (texturePath.Length > 0)
            {
                try
                {
                    texture = TextureLoader.FromFile(device, texturePath);
                }
                catch
                {
                    System.Windows.Forms.MessageBox.Show("Texture could not be loaded");
                }
            }
        }
        private Texture texZ = null; //Texture for the z axis label

        #endregion Fields

        #region Constructors

        public RigidBody_DX(AnimatTools.Framework.DataObject doParent)
            : base(doParent)
        {
            m_vrLocation = new DxLocationRef(this);
            m_vrRotation = new DxRotationRef(this);

            m_snXLocalLocation = new AnimatTools.Framework.ScaledNumber(this, "XLocalLocationScaled", "meters", "m");
            m_snYLocalLocation = new AnimatTools.Framework.ScaledNumber(this, "YLocalLocationScaled", "meters", "m");
            m_snZLocalLocation = new AnimatTools.Framework.ScaledNumber(this, "ZLocalLocationScaled", "meters", "m");

            m_snXWorldLocation = new AnimatTools.Framework.ScaledNumber(this, "XWorldLocationScaled", "meters", "m");
            m_snYWorldLocation = new AnimatTools.Framework.ScaledNumber(this, "YWorldLocationScaled", "meters", "m");
            m_snZWorldLocation = new AnimatTools.Framework.ScaledNumber(this, "ZWorldLocationScaled", "meters", "m");

            m_snXRotation = new AnimatTools.Framework.ScaledNumber(this, "XRotationScaled", "Degrees", "Deg");
            m_snYRotation = new AnimatTools.Framework.ScaledNumber(this, "YRotationScaled", "Degrees", "Deg");
            m_snZRotation = new AnimatTools.Framework.ScaledNumber(this, "ZRotationScaled", "Degrees", "Deg");

            this.m_matTransparentSelectedMaterial = new Material();
            this.m_matTransparentSelectedMaterial.Diffuse = Color.FromArgb(128,Color.FloralWhite);
            this.m_matTransparentSelectedMaterial.Ambient = Color.FromArgb(128,Color.FloralWhite);

            Alpha = 255;
            Color = Color.Red;

            m_d3dRFPointMaterial = new Material();
            m_d3dRFPointMaterial.Ambient = Color.Green;
            m_d3dRFPointMaterial.Diffuse = Color.Green;

            m_d3dSelRFPointMaterial = new Material();
            m_d3dSelRFPointMaterial.Ambient = Color.DarkRed;
            m_d3dSelRFPointMaterial.Diffuse = Color.DarkRed;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="ambient"></param>
        /// <param name="diffuse"></param>
        /// <param name="specular"></param>
        /// <param name="emissive"></param>
        /// <param name="shininess"></param>
        public override void SetSurfaceParams(ColorEx ambient, ColorEx diffuse, ColorEx specular, ColorEx emissive, float shininess, TrackVertexColor tracking)
        {
            // TODO: Cache color values to prune unneccessary setting

            if (cache.materialAmbient.CompareTo(ambient) == 0 &&
                cache.materialDiffuse.CompareTo(diffuse) == 0 &&
                cache.materialSpecular.CompareTo(specular) == 0 &&
                cache.materialEmissive.CompareTo(emissive) == 0 &&
                cache.materialShininess == shininess &&
                cache.materialTracking == tracking)
                return;

            cache.materialAmbient = ambient.Clone();
            cache.materialDiffuse = diffuse.Clone();
            cache.materialSpecular = specular.Clone();
            cache.materialEmissive = emissive.Clone();
            cache.materialShininess = shininess;
            cache.materialTracking = tracking;

            // create a new material based on the supplied params
            D3D.Material mat = new D3D.Material();
            mat.Diffuse = diffuse.ToColor();
            mat.Ambient = ambient.ToColor();
            mat.Specular = specular.ToColor();
            mat.Emissive = emissive.ToColor();
            mat.SpecularSharpness = shininess;

            // set the current material
            device.Material = mat;

            if (tracking != TrackVertexColor.None) {
                SetRenderState(ref cache.colorVertex, RenderStates.ColorVertex, true);
                device.SetRenderState(RenderStates.AmbientMaterialSource, (int)(((tracking & TrackVertexColor.Ambient) != 0) ? D3D.ColorSource.Color1 : D3D.ColorSource.Material));
                device.SetRenderState(RenderStates.DiffuseMaterialSource, (int)(((tracking & TrackVertexColor.Diffuse) != 0) ? D3D.ColorSource.Color1 : D3D.ColorSource.Material));
                device.SetRenderState(RenderStates.SpecularMaterialSource, (int)(((tracking & TrackVertexColor.Specular) != 0) ? D3D.ColorSource.Color1 : D3D.ColorSource.Material));
                device.SetRenderState(RenderStates.EmissiveMaterialSource, (int)(((tracking & TrackVertexColor.Emissive) != 0) ? D3D.ColorSource.Color1 : D3D.ColorSource.Material));
            } else
                SetRenderState(ref cache.colorVertex, RenderStates.ColorVertex, false);
        }
Example #20
0
        public void Initialize(Device device)
        {
            material = new Material();
            material.Ambient = ambient;
            material.Diffuse = diffuse;
            material.Emissive = emissive;
            specular = material.Specular;
            specularSharpness = material.SpecularSharpness;

            texture = null;

            if(texturePath.Length > 0)
            {
                try
                {
                    texture = TextureLoader.FromFile(device,texturePath);
                }
                catch
                {
                    System.Windows.Forms.MessageBox.Show("Texture could not be loaded");
                }
            }
        }
Example #21
0
        /// <summary>
        /// Renders the terrain.
        /// </summary>
        public void RenderTerrain()
        {
            if ( _page != null )
            {
                if ( _page.TerrainPatch.RefreshBuffers )
                {
                    RefreshAllBuffers();
                    _page.TerrainPatch.RefreshBuffers = false;
                    _page.TerrainPatch.RefreshVertices = false;
                }

                if ( _buffers.VertexBuffer != null || _buffers.VertexBuffer_ColoredByHeight != null )
                {
                    D3D.Material mat = new D3D.Material();

                    mat.Diffuse = Color.White;
                    _viewport.Device.Material = mat;

                    if ( _enableLighting && !_viewport.Device.RenderState.Lighting && !_buffers.ColorByHeight )
                        _viewport.Device.RenderState.Lighting = true;
                    else if ( _buffers.ColorByHeight && _viewport.Device.RenderState.Lighting )
                        _viewport.Device.RenderState.Lighting = false;

                    if ( _viewport.Device.RenderState.FillMode == D3D.FillMode.WireFrame &&
                        _viewport.Device.RenderState.CullMode != D3D.Cull.None )
                        _viewport.Device.RenderState.CullMode = D3D.Cull.None;

                    if ( ( _buffers.ColorByHeight && _buffers.VertexBuffer_ColoredByHeight != null ) ||
                        _buffers.VertexBuffer == null )
                    {
                        _viewport.Device.VertexFormat = D3D.CustomVertex.PositionNormalColored.Format;
                        _viewport.Device.SetStreamSource( 0, _buffers.VertexBuffer_ColoredByHeight, 0 );
                    }
                    else
                    {
                        SelectVertexFormat();
                        _viewport.Device.SetStreamSource( 0, _buffers.VertexBuffer, 0 );
                    }

                    _viewport.Device.Transform.World = _viewport.Camera.WorldIdentity;

                    // Set the textures to render
                    if ( _renderTextures && _page.TerrainPatch.NumTextures > 0 && !_buffers.ColorByHeight )
                    {
                        for ( int i = 0; i < _page.TerrainPatch.NumTextures &&
                            i < _viewport.Device.DeviceCaps.MaxSimultaneousTextures; i++ )
                        {
                            if ( ( (DataCore.Texture) _page.TerrainPatch.Textures[i] ).Render )
                            {
                                _viewport.Device.SetTexture( i,
                                    ( (DataCore.Texture) _page.TerrainPatch.Textures[i] ).DXTexture );
                                SetTextureOperation( i );

                                if ( _viewport.Device.RenderState.AlphaBlendEnable )
                                    _viewport.Device.RenderState.AlphaBlendEnable = false;
                            }
                        }
                    }
                    else
                    {
                        _viewport.Device.SetTexture( 0, null );
                        _viewport.Device.TextureState[0].ColorOperation = D3D.TextureOperation.Disable;
                    }

                    if ( _buffers.IndexBuffer != null )
                    {
                        _viewport.Device.Indices = _buffers.IndexBuffer;
                        _viewport.Device.DrawIndexedPrimitives( D3D.PrimitiveType.TriangleList, 0, 0,
                            _buffers.VertexBufferSize, 0, _buffers.IndexBufferSize / 3 );
                    }
                    else
                        _viewport.Device.DrawPrimitives( D3D.PrimitiveType.TriangleList, 0,
                            _buffers.VertexBufferSize );
                }
            }
        }
Example #22
0
        public void SetupLights()
        {
            if (transformLightOnFrame) return;

            // Turn off all the lights to start.
            for (int i = 0; i < 4; i++)
            {
                OuterSpace.device.Lights[i].Enabled = false;
            }

            // Set our material and it's colors.
            Color col = Color.White; ;
            Direct3D.Material mtrl = new Direct3D.Material();

            mtrl.Diffuse = col;
            mtrl.Ambient = col;
            OuterSpace.device.Material = mtrl;

            Vector4 curSunPos = new Vector4();

            curSunPos = getsunpos();
            OuterSpace.device.Lights[0].Type = LightType.Directional;
            OuterSpace.device.Lights[0].Diffuse = Color.White;
            OuterSpace.device.Lights[0].Direction = new Vector3(curSunPos.X, curSunPos.Y, curSunPos.Z + 1500.0F);
            OuterSpace.device.Lights[0].Enabled = true;
            OuterSpace.device.RenderState.Ambient = Color.FromArgb(65, 65, 65, 65);
            OuterSpace.msgbox.pushmsgs(Convert.ToString(curSunPos.Z));
            if (OuterSpace.theGameState.IsGameInState(OuterSpace.GameStates.Landed) && curSunPos.Z < 250)
            {
                OuterSpace.TV.lightson = 4;
                TVHeadlights();
            }

            transformLightOnFrame = true;
        }
Example #23
0
        public Material(Renderer renderer, Color ambientColor, Color diffuseColor,
            string diffuseMapFilename)
        {
            if (renderer == null)
                throw new ArgumentNullException("renderer",
                    "Cannot create a material with a null renderer reference.");

            this.renderer = renderer;

            d3dMaterial = new Direct3D.Material();
            d3dMaterial.Ambient = ambientColor;
            d3dMaterial.Diffuse = diffuseColor;
            d3dMaterial.Specular = DefaultSpecularColor;
            d3dMaterial.SpecularSharpness = DefaultShininess;

            diffuseMap = new Texture(renderer, diffuseMapFilename);
        }
Example #24
0
        public static void LoadMesh(Stream stream, D3D.Device dev, ref D3D.Mesh mesh, ref D3D.Material[] meshMaterials, ref D3D.Texture[] meshTextures)
        {
            D3D.ExtendedMaterial[] materialArray;
            mesh = D3D.Mesh.FromStream(stream, D3D.MeshFlags.Managed, dev, out materialArray);

            if ((materialArray != null) && (materialArray.Length > 0))
            {
                meshMaterials = new D3D.Material[materialArray.Length];
                meshTextures = new D3D.Texture[materialArray.Length];
                for (int i = 0; i < materialArray.Length; i++)
                {
                    meshMaterials[i] = materialArray[i].Material3D;
                    if (!string.IsNullOrEmpty(materialArray[i].TextureFilename))
                        meshTextures[i] = D3D.TextureLoader.FromFile(dev, materialArray[i].TextureFilename);
                }
            }
        }
Example #25
0
        /// <summary>
        /// The device exists, but may have just been Reset().  Resources in
        /// Pool.Default and any other device state that persists during
        /// rendering should be set here.  Render states, matrices, textures,
        /// etc., that don't change during rendering can be set once here to
        /// avoid redundant state setting during Render() or FrameMove().
        /// </summary>
        protected override void RestoreDeviceObjects(System.Object sender, System.EventArgs e)
        {
            MyVertex[] v;
            Mesh       pWallMeshTemp = null;

            // Create a square grid numberVertsX*numberVertsZ for rendering the wall
            pWallMeshTemp = new Mesh(numTriangles, numTriangles * 3,
                                     0, MyVertex.Format, device);

            // Fill in the grid vertex data
            v = (MyVertex[])pWallMeshTemp.LockVertexBuffer(typeof(MyVertex), 0, numTriangles * 3);
            float dX = 1.0f / (numberVertsX - 1);
            float dZ = 1.0f / (numberVertsZ - 1);
            uint  k  = 0;

            for (uint z = 0; z < (numberVertsZ - 1); z++)
            {
                for (uint x = 0; x < (numberVertsX - 1); x++)
                {
                    v[k].p = new Vector3(10 * x * dX, 0.0f, 10 * z * dZ);
                    v[k].n = new Vector3(0.0f, 1.0f, 0.0f);
                    k++;
                    v[k].p = new Vector3(10 * x * dX, 0.0f, 10 * (z + 1) * dZ);
                    v[k].n = new Vector3(0.0f, 1.0f, 0.0f);
                    k++;
                    v[k].p = new Vector3(10 * (x + 1) * dX, 0.0f, 10 * (z + 1) * dZ);
                    v[k].n = new Vector3(0.0f, 1.0f, 0.0f);
                    k++;
                    v[k].p = new Vector3(10 * x * dX, 0.0f, 10 * z * dZ);
                    v[k].n = new Vector3(0.0f, 1.0f, 0.0f);
                    k++;
                    v[k].p = new Vector3(10 * (x + 1) * dX, 0.0f, 10 * (z + 1) * dZ);
                    v[k].n = new Vector3(0.0f, 1.0f, 0.0f);
                    k++;
                    v[k].p = new Vector3(10 * (x + 1) * dX, 0.0f, 10 * z * dZ);
                    v[k].n = new Vector3(0.0f, 1.0f, 0.0f);
                    k++;
                }
            }
            pWallMeshTemp.UnlockVertexBuffer();

            // Fill in index data
            ushort[] pIndex;
            pIndex = (ushort[])pWallMeshTemp.LockIndexBuffer(typeof(ushort), 0, numTriangles * 3);
            for (ushort iIndex = 0; iIndex < numTriangles * 3; iIndex++)
            {
                pIndex[iIndex] = iIndex;
            }
            pWallMeshTemp.UnlockIndexBuffer();

            // Eliminate redundant vertices
            int[]        pdwAdjacency = new int[3 * numTriangles];
            WeldEpsilons we           = new WeldEpsilons();

            pWallMeshTemp.GenerateAdjacency(0.01f, pdwAdjacency);
            pWallMeshTemp.WeldVertices(WeldEpsilonsFlags.WeldAll, we, pdwAdjacency);

            // Optimize the mesh
            wallMesh = pWallMeshTemp.Optimize(MeshFlags.OptimizeCompact | MeshFlags.OptimizeVertexCache |
                                              MeshFlags.VbDynamic | MeshFlags.VbWriteOnly, pdwAdjacency);

            pWallMeshTemp = null;
            pdwAdjacency  = null;

            // Create sphere and cone meshes to represent the lights
            sphereMesh = Mesh.Sphere(device, 0.25f, 20, 20);
            coneMesh   = Mesh.Cylinder(device, 0.0f, 0.25f, 0.5f, 20, 20);

            // Set up a material
            Microsoft.DirectX.Direct3D.Material mtrl = GraphicsUtility.InitMaterial(System.Drawing.Color.White);
            device.Material = mtrl;

            // Set miscellaneous render states
            device.RenderState.DitherEnable   = false;
            device.RenderState.SpecularEnable = false;

            // Set the world matrix
            Matrix matIdentity = Matrix.Identity;

            device.SetTransform(TransformType.World, matIdentity);

            // Set the view matrix.
            Matrix  matView;
            Vector3 vFromPt   = new Vector3(-10, 10, -10);
            Vector3 vLookatPt = new Vector3(0.0f, 0.0f, 0.0f);
            Vector3 vUpVec    = new Vector3(0.0f, 1.0f, 0.0f);

            matView = Matrix.LookAtLH(vFromPt, vLookatPt, vUpVec);
            device.SetTransform(TransformType.View, matView);

            // Set the projection matrix
            Matrix matProj;
            float  fAspect = ((float)device.PresentationParameters.BackBufferWidth) / device.PresentationParameters.BackBufferHeight;

            matProj = Matrix.PerspectiveFovLH((float)Math.PI / 4, fAspect, 1.0f, 100.0f);
            device.SetTransform(TransformType.Projection, matProj);

            // Turn on lighting.
            device.RenderState.Lighting = true;

            // Enable ambient lighting to a dim, grey light, so objects that
            // are not lit by the other lights are not completely black
            device.RenderState.Ambient = System.Drawing.Color.Gray;

            // Set light #0 to be a simple, faint grey directional light so
            // the walls and floor are slightly different shades of grey
            device.Lights[0].Type      = LightType.Directional;
            device.Lights[0].Direction = new Vector3(0.3f, -0.5f, 0.2f);
            device.Lights[0].Diffuse   = System.Drawing.Color.FromArgb(64, 64, 64);
            device.Lights[0].Commit();

            // Set light #1 to be a simple, bright directional light to use
            // on the mesh representing light #2
            device.Lights[1].Type      = LightType.Directional;
            device.Lights[1].Direction = new Vector3(0.5f, -0.5f, 0.5f);
            device.Lights[1].Diffuse   = System.Drawing.Color.White;
            device.Lights[1].Commit();

            // Light #2 will be the light used to light the floor and walls.  It will
            // be set up in FrameMove() since it changes every frame.
        }
Example #26
0
        /// <summary>
        /// Renders the terrain.
        /// </summary>
        public void RenderTerrain()
        {
            if (_page != null)
            {
                if (_page.TerrainPatch.RefreshBuffers)
                {
                    RefreshAllBuffers();
                    _page.TerrainPatch.RefreshBuffers  = false;
                    _page.TerrainPatch.RefreshVertices = false;
                }

                if (_buffers.VertexBuffer != null || _buffers.VertexBuffer_ColoredByHeight != null)
                {
                    D3D.Material mat = new D3D.Material();

                    mat.Diffuse = Color.White;
                    _viewport.Device.Material = mat;

                    if (_enableLighting && !_viewport.Device.RenderState.Lighting && !_buffers.ColorByHeight)
                    {
                        _viewport.Device.RenderState.Lighting = true;
                    }
                    else if (_buffers.ColorByHeight && _viewport.Device.RenderState.Lighting)
                    {
                        _viewport.Device.RenderState.Lighting = false;
                    }

                    if (_viewport.Device.RenderState.FillMode == D3D.FillMode.WireFrame &&
                        _viewport.Device.RenderState.CullMode != D3D.Cull.None)
                    {
                        _viewport.Device.RenderState.CullMode = D3D.Cull.None;
                    }

                    if ((_buffers.ColorByHeight && _buffers.VertexBuffer_ColoredByHeight != null) ||
                        _buffers.VertexBuffer == null)
                    {
                        _viewport.Device.VertexFormat = D3D.CustomVertex.PositionNormalColored.Format;
                        _viewport.Device.SetStreamSource(0, _buffers.VertexBuffer_ColoredByHeight, 0);
                    }
                    else
                    {
                        SelectVertexFormat();
                        _viewport.Device.SetStreamSource(0, _buffers.VertexBuffer, 0);
                    }

                    _viewport.Device.Transform.World = _viewport.Camera.WorldIdentity;

                    // Set the textures to render
                    if (_renderTextures && _page.TerrainPatch.NumTextures > 0 && !_buffers.ColorByHeight)
                    {
                        for (int i = 0; i < _page.TerrainPatch.NumTextures &&
                             i < _viewport.Device.DeviceCaps.MaxSimultaneousTextures; i++)
                        {
                            if (((DataCore.Texture)_page.TerrainPatch.Textures[i]).Render)
                            {
                                _viewport.Device.SetTexture(i,
                                                            ((DataCore.Texture)_page.TerrainPatch.Textures[i]).DXTexture);
                                SetTextureOperation(i);

                                if (_viewport.Device.RenderState.AlphaBlendEnable)
                                {
                                    _viewport.Device.RenderState.AlphaBlendEnable = false;
                                }
                            }
                        }
                    }
                    else
                    {
                        _viewport.Device.SetTexture(0, null);
                        _viewport.Device.TextureState[0].ColorOperation = D3D.TextureOperation.Disable;
                    }

                    if (_buffers.IndexBuffer != null)
                    {
                        _viewport.Device.Indices = _buffers.IndexBuffer;
                        _viewport.Device.DrawIndexedPrimitives(D3D.PrimitiveType.TriangleList, 0, 0,
                                                               _buffers.VertexBufferSize, 0, _buffers.IndexBufferSize / 3);
                    }
                    else
                    {
                        _viewport.Device.DrawPrimitives(D3D.PrimitiveType.TriangleList, 0,
                                                        _buffers.VertexBufferSize);
                    }
                }
            }
        }
Example #27
0
        public void Render(Device device)
        {
            if (Geometry.Clr != -1)
            {
                device.RenderState.Lighting = true;
                Microsoft.DirectX.Direct3D.Material mt = new Microsoft.DirectX.Direct3D.Material();
                mt.AmbientColor = ColorValue.FromArgb(Geometry.Clr);
                mt.DiffuseColor = ColorValue.FromArgb(Geometry.Clr);
                device.RenderState.DiffuseMaterialSource = ColorSource.Material;
                device.Material = mt;
                device.RenderState.AmbientColor = Geometry.Clr;
            }

            device.VertexFormat = vFormat;
            device.SetStreamSource(0, vBuffer, 0);
            if (matIBuffers != null)
            {
                for (int mat = 0; mat < MaterialIndices.Length; mat++)
                {
                    Microsoft.DirectX.Direct3D.Material oMat = device.Material;
                    if (MaterialIndices[mat].Material.Texture == null)
                    {
                        Microsoft.DirectX.Direct3D.Material material = new Microsoft.DirectX.Direct3D.Material();
                        material.AmbientColor = ColorValue.FromColor(System.Drawing.Color.FromArgb(MaterialIndices[mat].Material.Ambient.A,
                                                                                    MaterialIndices[mat].Material.Ambient.R,
                                                                                    MaterialIndices[mat].Material.Ambient.G,
                                                                                    MaterialIndices[mat].Material.Ambient.B));
                        material.DiffuseColor = ColorValue.FromColor(System.Drawing.Color.FromArgb(MaterialIndices[mat].Material.Diffuse.A,
                                                                                    MaterialIndices[mat].Material.Diffuse.R,
                                                                                    MaterialIndices[mat].Material.Diffuse.G,
                                                                                    MaterialIndices[mat].Material.Diffuse.B));
                        device.Material = material;
                    }
                    else
                        device.SetTexture(0, MaterialIndices[mat].Material.Texture);

                    device.Indices = matIBuffers[mat];
                    device.DrawIndexedPrimitives(Geometry.PrimType, 0, 0, Geometry.Vertices.Length, 0, MaterialIndices[mat].PrimCount);

                    device.Material = oMat;
                }
            }
            else if (iBuffer != null)
            {
                device.Indices = iBuffer;
                device.DrawIndexedPrimitives(Geometry.PrimType, 0, 0, Geometry.Vertices.Length, 0, numPrimitives);
            }
            else
            {
                device.Indices = null;
                device.DrawPrimitives(Geometry.PrimType, 0, numPrimitives);
            }
        }
Example #28
0
        /// <summary>
        /// The device has been created.  Resources that are not lost on
        /// Reset() can be created here -- resources in Pool.Managed,
        /// Pool.Scratch, or Pool.SystemMemory.  Image surfaces created via
        /// CreateImageSurface are never lost and can be created here.  Vertex
        /// shaders and pixel shaders can also be created here as they are not
        /// lost on Reset().
        /// </summary>
        protected override void InitializeDeviceObjects()
        {
            // Initialize the drawingFont's internal textures
            drawingFont.InitializeDeviceObjects(device);

            //ExtendedMaterial[] mtrl = null;
            mdlfile = new MDLFile();
            string path = DXUtil.FindMediaFile(initialDirectory, meshFilename);

            try
            {
                //systemMemoryMesh = Mesh.FromFile(path, MeshFlags.SystemMemory, device, out adjacency, out mtrl);
                if (!mdlfile.ReadFromFile(initialDirectory + "\\" + meshFilename))
                {
                    throw new FileLoadException("not a valide MDL file.", meshFilename);
                }
                MDLObject obj = mdlfile.RootObject;
                rootmdl = obj;

                CBLOD.Items.Clear();
                if (obj.type == MDLType.mdl_lod)
                {
                    CBLOD.Enabled = true;
                    for (int i = 0; i < obj.nchildren; i++)
                    {
                        CBLOD.Items.Add(obj.childrens[i].lodval);
                    }
                    obj = obj.childrens[0];
                    CBLOD.SelectedIndex = 0;
                }
                else
                {
                    CBLOD.Enabled = false;
                }

                //				while (obj.type != MDLType.mdl_mesh)
                //				{
                //					if (obj.childrens[0].type == MDLType.mdl_empty)
                //						obj = obj.childrens[1];
                //					else
                //						obj = obj.childrens[0];
                //
                //				}
                // process textures
                if (mdlfile.NumTextures > 0)
                {
                    meshMaterials = new Material[mdlfile.NumTextures];
                    meshTextures  = new Texture[mdlfile.NumTextures];
                    for (int i = 0; i < mdlfile.NumTextures; i++)
                    {
                        meshMaterials[i]         = new Direct3D.Material();
                        meshMaterials[i].Ambient = Color.White;
                        meshMaterials[i].Diffuse = Color.White;

                        MDLFile mdlbmp = new MDLFile();
                        if (mdlbmp.ReadFromFile(initialDirectory + "\\" + mdlfile.Textures[i] + ".mdl"))
                        {
                            if (mdlbmp.RootObject.type == MDLType.mdl_image)
                            {
                                MDLImage     mdlimg    = mdlbmp.RootObject.image;
                                MemoryStream memstream = new MemoryStream(mdlimg.bitmap);
                                try
                                {
                                    //meshTextures[i] = TextureLoader.FromStream(device,memstream,mdlimg.bitmap.Length,mdlimg.w,mdlimg.h,0,0,Format.R5G6B5,Pool.Managed,Filter.Linear,Filter.Linear,0);
                                    //meshTextures[i] = TextureLoader.FromStream(device,memstream,mdlimg.w,mdlimg.h,0,0,Format.R5G6B5,Pool.SystemMemory,Filter.Linear,Filter.Linear,1);
                                    Bitmap     bitmap = new Bitmap(mdlimg.w, mdlimg.h, PixelFormat.Format16bppRgb565);
                                    Rectangle  rect   = new Rectangle(0, 0, mdlimg.w, mdlimg.h);
                                    BitmapData bmdata = bitmap.LockBits(rect, ImageLockMode.WriteOnly, PixelFormat.Format16bppRgb565);
                                    IntPtr     pixels = bmdata.Scan0;
                                    unsafe
                                    {
                                        byte *pBits = (byte *)pixels.ToPointer();
                                        for (int p = 0; p < mdlimg.bitmap.Length; p++)
                                        {
                                            pBits[p] = mdlimg.bitmap[p];
                                        }
                                    }
                                    bitmap.UnlockBits(bmdata);
                                    //bitmap.RotateFlip(RotateFlipType.RotateNoneFlipX);
                                    meshTextures[i] = Texture.FromBitmap(device, bitmap, Usage.AutoGenerateMipMap, Pool.Managed);
                                }
                                catch (Exception e)
                                {
                                    string mess = e.Message;
                                    MessageBox.Show("error loading texture '" + mdlfile.Textures[i] + ".mdl'. " + e.Message);
                                }
                            }
                        }
                    }
                }

                ArrayList objs = FlattenChildren(obj);

                Meshes       = new Mesh[objs.Count];
                MeshesEnable = new bool[objs.Count];
                MeshesTex    = new int[objs.Count];
                objectRadius = 0;
                tvObj.Nodes.Clear();

                for (int oi = 0; oi < objs.Count; oi++)
                {
                    obj = (MDLObject)objs[oi];


                    TreeNode tn = new TreeNode("part " + oi.ToString());
                    tn.Tag     = oi;
                    tn.Checked = true;
                    tn.Nodes.Add("# vertices = " + obj.mesh.nvertex.ToString());
                    tn.Nodes.Add("# faces = " + (obj.mesh.nfaces / 3).ToString());
                    if (obj.textidx == -1)
                    {
                        tn.Nodes.Add("no texture");
                    }
                    else
                    {
                        tn.Nodes.Add("texture = " + mdlfile.Textures[obj.textidx]);
                    }
                    tvObj.Nodes.Add(tn);

                    // process mesh
                    systemMemoryMesh = new Mesh(obj.mesh.nfaces / 3, obj.mesh.nvertex, MeshFlags.SystemMemory, VertexFormats.Position | VertexFormats.Normal | VertexFormats.Texture1, device);

                    //systemMemoryMesh = Mesh.Box(device,12,15,2);
                    VertexBuffer pVB           = systemMemoryMesh.VertexBuffer;
                    int          dwNumVertices = systemMemoryMesh.NumberVertices;

                    CustomVertex.PositionNormalTextured [] dest =
                        (CustomVertex.PositionNormalTextured [])pVB.Lock(0,
                                                                         typeof(CustomVertex.PositionNormalTextured), 0, dwNumVertices);

                    for (int i = 0; i < dest.Length; i++)
                    {
                        dest[i].X = obj.mesh.vertices[i].x;
                        dest[i].Y = obj.mesh.vertices[i].y;
                        dest[i].Z = obj.mesh.vertices[i].z;

                        dest[i].Nx = obj.mesh.vertices[i].nx;
                        dest[i].Ny = obj.mesh.vertices[i].ny;
                        dest[i].Nz = obj.mesh.vertices[i].nz;

                        dest[i].Tu = obj.mesh.vertices[i].mx;
                        dest[i].Tv = obj.mesh.vertices[i].my;
                    }

                    pVB.Unlock();

                    int      dwNumFaces = systemMemoryMesh.NumberFaces * 3;
                    ushort[] idxs       = (ushort[])systemMemoryMesh.LockIndexBuffer(typeof(ushort), 0, dwNumFaces);

                    for (int i = 0; i < dwNumFaces; i += 3)
                    {
                        idxs[i]     = obj.mesh.faces[i];
                        idxs[i + 1] = obj.mesh.faces[i + 2];
                        idxs[i + 2] = obj.mesh.faces[i + 1];
                    }
                    systemMemoryMesh.UnlockIndexBuffer();
                    //systemMemoryMesh.SetIndexBufferData(obj.mesh.faces,LockFlags.None);
                    // Lock the vertex buffer, to generate a simple bounding sphere
                    VertexBuffer vb = null;
                    try
                    {
                        vb = systemMemoryMesh.VertexBuffer;
                        GraphicsStream vbStream = vb.Lock(0, 0, 0);
                        objectRadius = Math.Max(objectRadius, Geometry.ComputeBoundingSphere(vbStream, systemMemoryMesh.NumberVertices, systemMemoryMesh.VertexFormat, out objectCenter));
                    }
                    finally
                    {
                        // Make sure we unlock the buffer if we fail
                        if (vb != null)
                        {
                            vb.Unlock();
                        }
                    }
                    // Make sure there are normals, which are required for the tesselation
                    // enhancement
                    if ((systemMemoryMesh.VertexFormat & VertexFormats.Normal) != VertexFormats.Normal)
                    {
                        Mesh tempMesh = systemMemoryMesh.Clone(systemMemoryMesh.Options.Value, systemMemoryMesh.VertexFormat | VertexFormats.Normal, device);

                        tempMesh.ComputeNormals();
                        systemMemoryMesh.Dispose();
                        systemMemoryMesh = tempMesh;
                    }
                    Meshes[oi]       = systemMemoryMesh;
                    MeshesEnable[oi] = true;
                    MeshesTex[oi]    = obj.textidx;
                }                 // oi loop
                tvObj.ExpandAll();
                objectCenter = new Vector3(0, 0, 0);
            }             // try
            catch
            {
                // Hide the error so we display a blue screen
                return;
            }
        }
Example #29
0
        private void SetupLights()
        {
            System.Drawing.Color col = System.Drawing.Color.White;
            //Set up a material. The material here just has the diffuse and ambient
            //colors set to yellow. Note that only one material can be used at a time.
            Direct3D.Material mtrl = new Direct3D.Material();
            mtrl.Diffuse = col;
            mtrl.Ambient = col;
            device.Material = mtrl;

            //Set up a white, directional light, with an oscillating direction.
            //Note that many lights may be active at a time (but each one slows down
            //the rendering of our scene). However, here we are just using one. Also,
            //we need to set the D3DRS_LIGHTING renderstate to enable lighting

            device.Lights[0].Type = LightType.Directional;
            device.Lights[0].Diffuse = System.Drawing.Color.DarkTurquoise;
            device.Lights[0].Direction = new Vector3((float)Math.Cos(Environment.TickCount / 250.0f), 1.0f, (float)Math.Sin(Environment.TickCount / 250.0f));

            device.Lights[0].Enabled = true;//turn it on

            //Finally, turn on some ambient light.
            //Ambient light is light that scatters and lights all objects evenly
            device.RenderState.Ambient = System.Drawing.Color.FromArgb(0x202020);
        }
            public void ApplyCache(D3D9RenderSystem renderSystem, D3D.Device device, D3D.Caps d3dCaps)
            {
                log.Info("DirectXCache.ApplyCache: Starting to apply cache settings to device");

                renderSystem.SetSceneDetailLevel(rasterizationMode);

                renderSystem.SetColorBufferWriteEnabledInternal(writeEnabledRed, writeEnabledGreen, writeEnabledBlue, writeEnabledAlpha);

                device.RenderState.AlphaTestEnable = alphaTestEnable;
                device.RenderState.AlphaFunction = D3DHelper.ConvertEnum(alphaFunction);

                device.RenderState.ReferenceAlpha = referenceAlpha;

                renderSystem.SetRenderState(RenderStates.ColorVertex, colorVertex);

                device.RenderState.ShadeMode = D3DHelper.ConvertEnum(shadingMode);

                device.RenderState.CullMode = D3DHelper.ConvertEnum(cullingMode, cullingFlip);

                if (d3dCaps.RasterCaps.SupportsDepthBias)
                    renderSystem.SetRenderState(RenderStates.DepthBias, -constantBias / 250000.0f);

                if (d3dCaps.RasterCaps.SupportsSlopeScaleDepthBias)
                    renderSystem.SetRenderState(RenderStates.SlopeScaleDepthBias, -slopeScaleBias);

                renderSystem.SetRenderState(RenderStates.PointSpriteEnable, pointSpriteEnable);
                renderSystem.SetRenderState(RenderStates.PointScaleEnable, pointScaleEnable);

                renderSystem.SetRenderState(RenderStates.PointSize, pointSize);
                renderSystem.SetRenderState(RenderStates.PointSizeMin, pointSizeMin);
                renderSystem.SetRenderState(RenderStates.PointSizeMax, pointSizeMax);

                device.RenderState.ZBufferFunction = D3DHelper.ConvertEnum(zBufferFunction);

                if(depthCheck) {
                    // use w-buffer if available
                    if(renderSystem.useWBuffer && d3dCaps.RasterCaps.SupportsWBuffer)
                        device.RenderState.UseWBuffer = true;
                    else
                        device.RenderState.ZBufferEnable = true;

                }
                else
                    device.RenderState.ZBufferEnable = false;

                zBufferWriteEnable = device.RenderState.ZBufferWriteEnable;

                device.RenderState.AlphaBlendEnable = alphaBlendEnable;
                device.RenderState.SourceBlend = D3DHelper.ConvertEnum(sourceBlend);
                device.RenderState.DestinationBlend = D3DHelper.ConvertEnum(destinationBlend);

                for (int i=0; i<d3dCaps.MaxSimultaneousTextures; i++) {
                    device.TextureState[i].TextureCoordinateIndex = D3DHelper.ConvertEnum(renderSystem.texStageDesc[i].autoTexCoordType, d3dCaps) | textureCoordinateIndex[i];

                    renderSystem.texStageDesc[i].autoTexCoordType = TexCoordCalcMethod.None;

                    renderSystem.SetTextureMatrixInternal(i, textureMatrix[i]);

                    device.TextureState[i].ColorOperation = colorOperation[i];
                    device.TextureState[i].AlphaOperation = alphaOperation[i];

                    device.TextureState[i].ColorArgument1 = colorArgument1[i];
                    device.TextureState[i].ColorArgument2 = colorArgument2[i];
                    device.TextureState[i].AlphaArgument1 = alphaArgument1[i];
                    device.TextureState[i].AlphaArgument2 = alphaArgument2[i];
                    device.TextureState[i].TextureTransform = textureTransformOp[i];
                    for (int j=0; j<3; j++)
                        renderSystem.SetTextureUnitFilteringInternal(i, (FilterType)j, textureUnitFilteringFilter[i,j]);
                }
                device.RenderState.TextureFactor = textureFactor;;

                device.Transform.World = renderSystem.MakeD3DMatrix(worldMatrix);
                renderSystem.SetViewMatrixInternal(viewMatrix);
                renderSystem.SetProjectionMatrixInternal(projectionMatrix, false);

                device.RenderState.Ambient = ambient.ToColor();

                // create a new material based on the supplied params
                D3D.Material mat = new D3D.Material();
                mat.Diffuse = materialDiffuse.ToColor();
                mat.Ambient = materialAmbient.ToColor();
                mat.Specular = materialSpecular.ToColor();
                mat.Emissive = materialEmissive.ToColor();
                mat.SpecularSharpness = materialShininess;

                // set the current material
                device.Material = mat;

                device.VertexShader = vertexShader;
                device.PixelShader = pixelShader;

                device.Indices = indexBuffer;

                for (int i=0; i<d3dCaps.MaxStreams; i++) {
                    streamNull[i] = true;
                    device.SetStreamSource(i, null, 0, 0);
                }

                device.VertexDeclaration = null;

                device.RenderState.FogEnable = fogEnable;
                device.RenderState.FogColor = fogColor.ToColor();
                device.RenderState.FogDensity = fogDensity;
                device.RenderState.FogStart = fogStart;
                device.RenderState.FogEnd = fogEnd;
                device.RenderState.FogVertexMode = D3DHelper.ConvertEnum(fogMode);
                device.RenderState.FogTableMode = D3D.FogMode.None;

                intShaderConstants = new Object[d3dCaps.MaxVertexShaderConst];
                floatShaderConstants = new float[d3dCaps.MaxVertexShaderConst * 4];
                intPixelConstants = new Object[d3dCaps.MaxVertexShaderConst];
                floatPixelConstants = new float[d3dCaps.MaxVertexShaderConst * 4];

                for (int i=0; i<cachedLights.Length; i++) {
                    CachedLight cachedLight = cachedLights[i];
                    device.Lights[i].Enabled = cachedLight.enabled;
                    switch(cachedLight.type) {
                    case LightType.Point:
                        device.Lights[i].Type = D3D.LightType.Point;
                        break;
                    case LightType.Directional:
                        device.Lights[i].Type = D3D.LightType.Directional;
                        break;
                    case LightType.Spotlight:
                        device.Lights[i].Type = D3D.LightType.Spot;
                        break;
                    }
                    device.Lights[i].Falloff = cachedLight.spotFalloff;
                    device.Lights[i].InnerConeAngle = MathUtil.DegreesToRadians(cachedLight.spotInner);
                    device.Lights[i].OuterConeAngle = MathUtil.DegreesToRadians(cachedLight.spotOuter);
                    device.Lights[i].Diffuse = cachedLight.diffuse.ToColor();
                    device.Lights[i].Specular = cachedLight.specular.ToColor();
                    Axiom.MathLib.Vector3 vec = cachedLight.position;
                    device.Lights[i].Position = new DX.Vector3(vec.x, vec.y, vec.z);
                    vec = cachedLight.direction;
                    device.Lights[i].Direction = new DX.Vector3(vec.x, vec.y, vec.z);
                    device.Lights[i].Range = cachedLight.range;
                    device.Lights[i].Attenuation0 = cachedLight.attenuationConst;
                    device.Lights[i].Attenuation1 = cachedLight.attenuationLinear;
                    device.Lights[i].Attenuation2 = cachedLight.attenuationQuad;

                    device.RenderState.Lighting = renderSystem.lightingEnabled;
                }

                log.Info("DirectXCache.ApplyCache: Finished applying cache settings to device");
            }