Example #1
0
        private void DrawStar(Star star)
        {
            //sačuvaj poziciju
            Gl.glPushMatrix();

            rotateSphereOrbit(star.Orbit);

            goToPosition(star.CurrentPosition);
            if (Eye.LookingAt == star)
            {
                Eye.LookAt = new Position3D(star.CurrentPosition.Angle, star.CurrentPosition.Distance);
                if (tracking)
                {
                    Eye.LookingAt = star;
                }
            }
            if (Eye.LookingFrom == star)
            {
                Eye.Position = new Position3D(star.CurrentPosition.Angle, star.CurrentPosition.Distance);
                Eye.Position.Distance += star.Radius * 1.5;
                if (tracking)
                {
                    Eye.LookingFrom = star;
                }
            }

            foreach (Planet pl in star.Planets)
            {
                DrawPlanet(pl, star);
            }

            // Create light components
            float[] ambientLight = { 0.2f, 0.2f, 0.2f, 1.0f };
            float[] diffuseLight = { 0.7f, 0.7f, 0.7f, 1.0f };
            float[] specularLight = { 0.3f, 0.3f, 0.3f, 1.0f };
            float[] position = getFloatArrayOfCoordinates(star.CurrentPosition);

            // Assign created components to GL_LIGHT0
            Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_AMBIENT, ambientLight);
            Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_DIFFUSE, diffuseLight);
            Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_SPECULAR, specularLight);
            Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_POSITION, position);

            //Gl.glLightfv(Gl.GL_LIGHT0, Gl.GL_POSITION, light);

            SetMaterialForSun(star.Color, star.Shinines.ToFloat());

            if (drawCoordinates)
            {
                drawCoordinateSystem(star.Radius);
            }

            Gl.glMaterialf(Gl.GL_FRONT, Gl.GL_SHININESS, star.Shinines.ToFloat());

            drawSphere(star);

            ReSetMaterialForSun();

            // vrati poziciju
            Gl.glPopMatrix();
        }
Example #2
0
        private Star CreateStarFromData(StarData data, float distanceSc, float StarSc, float planetSc, float moonDistSc)
        {
            Orbit orbit = new Orbit(data.DaysForRevolution, new Ecliptic(data.DistanceFromCenter,data.EclipticEccentrity), new SpatialAngle(data.EclipseAngleX, data.EclipticInclination), data.StartAngle);
            Sphere sphere = new Sphere(data.Radius / StarSc, data.Color, new Position3D(new SpatialAngle(0, data.StartAngle), data.DistanceFromCenter / distanceSc), data.Name);
            Star star = new Star(sphere, data.Shinines);
            star.Orbit = orbit;

            if (data.Planets != null)
            {
                foreach (PlanetData planet in data.Planets)
                {
                    star.Planets.Add(CreatePlanetFromData(planet, distanceSc, planetSc, moonDistSc));
                }
            }

            return star;
        }
Example #3
0
        private void DrawPlanet(Planet planet, Star star)
        {
            Gl.glPushMatrix();

            rotateSphereOrbit(planet.Orbit);

            goToCenterOfOrbit(planet.Orbit);

            goToPosition(planet.CurrentPosition);

            if (drawCoordinates)
            {
                SetMaterialForSun(planet.Color, 1);
                Gl.glRasterPos3f((planet.Radius*1.5).ToFloat(), 0, 0);
                text(planet.Name);
                ReSetMaterialForSun();
            }

            if (Eye.LookingAt == planet)
            {
                SpatialAngle planetAngle = new SpatialAngle(
                    planet.CurrentPosition.Angle.Horizontal + planet.Orbit.Up.Horizontal,
                    planet.CurrentPosition.Angle.Vertical + planet.Orbit.Up.Vertical);
                Eye.LookAt = new Position3D(planetAngle, planet.CurrentPosition.Distance);
                if (tracking)
                {
                    Eye.LookingAt = planet;
                }
            }
            if (Eye.LookingFrom == planet)
            {
                SpatialAngle planetAngle = new SpatialAngle(
                    planet.CurrentPosition.Angle.Horizontal + planet.Orbit.Up.Horizontal + star.Orbit.Up.Horizontal,
                    planet.CurrentPosition.Angle.Vertical + planet.Orbit.Up.Vertical + star.Orbit.Up.Vertical);
                Eye.Position = new Position3D(planetAngle, planet.CurrentPosition.Distance + planet.Radius * 5);
                if (tracking)
                {
                    Eye.LookingFrom = planet;
                }
            }

            rotatePlanetAxis(planet);

            foreach (Planet s in planet.Satelites)
            {
                DrawPlanet(s, star);
            }

            Gl.glRotated(planet.CurrentRotationAngle * 180 / Math.PI, 1, 0, 0);

            SetMaterialForPlanet(planet, star.Shinines.ToFloat());

            if (drawCoordinates)
            {
                drawCoordinateSystem(planet.Radius);
            }

            drawSphere(planet);
            if (planet.Rings != null)
            {
                SetMaterialForPlanet(planet, (star.Shinines / 10f).ToFloat());
                Gl.glRotated(90, 0, 1, 0);
                foreach (Projektni_zadatak.Bodies.Ring r in planet.Rings)
                {
                    drawDisc(r);
                }
            }
            //Glut.glutWireCone(planet.Radius, planet.Radius, 30, 30);
            ReSetMaterialForPlanet();
            Gl.glPopMatrix();
        }