spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

        public override void SetRenderStates()
        {
            gD3DDevice.RenderState.DitherEnable = true;
            gD3DDevice.RenderState.ZBufferEnable = false; //ZBuffer hier ausschalten!


            // Bilineare Texturfilter mit linearem MIP-Mapping

            gD3DDevice.SamplerState[0].MinFilter = TextureFilter.Linear;
            gD3DDevice.SamplerState[0].MagFilter = TextureFilter.Linear;
            gD3DDevice.SamplerState[0].MipFilter = TextureFilter.Linear;

            // Direct3D soll den Alphakanal der Texturen und den Alphawert der Streufarbe verwenden.

            gD3DDevice.TextureState[0].AlphaOperation = TextureOperation.Modulate;
            gD3DDevice.TextureState[0].AlphaArgument1 = TextureArgument.Current;
            gD3DDevice.TextureState[0].AlphaArgument2 = TextureArgument.TextureColor;
        }


        public override void Render(float fNumSecsPassed)
        {           
            Matrix mCamera;
            Light PointLight;

            // Zeichnen

            try
            {
                // NUR!! Bildpuffer leeren und Szene beginnen

                gD3DDevice.Clear(ClearFlags.Target,
                    Color.Black.ToArgb(),
                    1.0f,
                    0);

                gD3DDevice.BeginScene();

                // Die Kamera schaut schräg von oben auf das Geschehen.

                mCamera = my3DHelpers.tbMatrixCamera(
                    gvCamera,                           // Position

                    new Vector3(0.0f, 0.0f, 0.0f),      // Blickrichtung

                    new Vector3(0.0f, 1.0f, 0.0f));     // Oben ist oben

                gD3DDevice.SetTransform(TransformType.View, mCamera);

                // Das Sternenfeld zeichnen. Dazu muss die Beleuchtung ausgeschaltet werden.

                // Alpha-Blending können wir auch nicht brauchen und erst recht keine Textur.

                gD3DDevice.RenderState.Lighting=false;
                gD3DDevice.RenderState.AlphaBlendEnable=false;

                gD3DDevice.SetTexture(0, null);

                gD3DDevice.SetTransform(TransformType.World, Matrix.Identity);
                gD3DDevice.VertexFormat = CustomVertex.PositionColored.Format;
                gD3DDevice.DrawUserPrimitives(
                    PrimitiveType.PointList,
                    gNumStars,
                    gStars);


                // Beleuchtung wieder einschalten und Punktlicht setzen

                gD3DDevice.RenderState.Lighting=true;

                // Da in der Methode "Move" das Planeten-Array immer neu gemacht wird,

                // ist hier Planet 0 immer die Sonne!

                // Das Punktlicht wird nun erstellt. Es ist genau in der Mitte.

                PointLight = new Light();
                PointLight.Type         = LightType.Point;              // Punktlicht

                PointLight.Diffuse      = my3DHelpers.floats2Color(1.0f, 1.0f, 0.75f);  // Gelbe Streufarbe

                PointLight.Ambient      = my3DHelpers.floats2Color(1.0f, 1.0f, 0.75f);  // Gelbe Hintergrundfarbe

                PointLight.Position     = gPlanets[0].vPosition;        // Die Position der Sonne

                PointLight.Range        = 1000.0f;                      // 1000 Einheiten Reichweite

                PointLight.Attenuation0 = 1.0f;                         // Lichtabschwächung

                PointLight.Attenuation1 = 0.0f;                         // ...

                PointLight.Attenuation2 = 0.0f;                         // ...


                // Licht einsetzen und aktivieren

                my3DHelpers.SetLight(gD3DDevice,0,PointLight);
                gD3DDevice.Lights[0].Enabled=true;

                // Renderstates für Alpha-Blending

                gD3DDevice.RenderState.AlphaBlendEnable = true;
                gD3DDevice.RenderState.AlphaSourceBlend = Blend.SourceAlpha;
                gD3DDevice.RenderState.AlphaDestinationBlend = Blend.InvSourceAlpha;

                // Die Planeten nach ihrer Entfernung sortieren

                Array.Sort(gPlanets);

                // Die Planeten zeichnen

                for(int iPlanet = 0; iPlanet < 6; iPlanet++)
                {
                    if(gPlanets[iPlanet].iType == 0)
                        RenderSun(iPlanet); // Es ist die Sonne

                    else
                        RenderPlanet(iPlanet); // Es ist ein normaler Planet.

                }

                // Szene beenden

                gD3DDevice.EndScene();

                // Der große Moment: den Bildpuffer sichtbar machen

                gD3DDevice.Present();
            }
            catch (DirectXException exp)
            {
                MessageBox.Show(exp.ErrorString);
            }


        private void RenderPlanet(int iPlanet)
        {
            Matrix mWorld;
            // Mit einer Matrix wird der Planet an seine Position gebracht und nebenbei noch

            // ein wenig rotiert. Zuerst skalieren wir ihn auf seine angegebene Größe.

            mWorld = 
                Matrix.Scaling(my3DHelpers.tbVector3SameXYZ(gPlanets[iPlanet].fRadius)) *
                Matrix.RotationAxis(Vector3.Normalize(new Vector3(0.5f, 1.0f, 0.25f)), gfTime) *
                Matrix.Translation(gPlanets[iPlanet].vPosition);
            gD3DDevice.SetTransform(TransformType.World, mWorld);
    
            // Das Material für diesen Planet erstellen. Die Glanzfarbe wird vernachlässigt,

            // da die Glanzberechnung deaktiviert ist.

            Material mat = new Material();
            mat.Diffuse     = my3DHelpers.floats2Color(1.0f, 1.0f, 1.0f);       // Weiße Streufarbe

            mat.Ambient     = my3DHelpers.floats2Color(0.25f, 0.25f, 0.25f);    // Dunkelgraue Hintergrundfarbe

            mat.Emissive    = my3DHelpers.floats2Color(0.0f, 0.0f, 0.0f);       // Keine Eigenfarbe

    
            // Das Material einsetzen

            gD3DDevice.Material=mat;
    
            // Textur setzen

            gD3DDevice.SetTexture(0, gPlanets[iPlanet].texture);
    
            // Den Planet zuerst von der Rückseite zeichnen, danach von der Vorderseite

            gD3DDevice.RenderState.CullMode = Cull.Clockwise;
            gPlanetModel.DrawSubset(0);
            gD3DDevice.RenderState.CullMode = Cull.CounterClockwise;
            gPlanetModel.DrawSubset(0);
        }