/// <summary> /// This is the main function of the class, it'll create a triangulated polygon /// from and SceneObject. /// </summary> /// <param name="gl">The gl.</param> /// <param name="sourceObject">The object to convert.</param> /// <param name="guarenteedView">A camera that can see the whole object.</param> /// <returns> /// A polygon created from 'sourceObject'. /// </returns> public Polygon CreatePolygon(OpenGL gl, IRenderable sourceObject, Camera guarenteedView) { // Save the current camera data. gl.MatrixMode(OpenGL.GL_PROJECTION); gl.PushMatrix(); // Look through the camera that can see the object. guarenteedView.Project(gl); // Start triangulation. Begin(gl); // Draw the object. sourceObject.Render(gl, RenderMode.Design); // End triangulation. End(gl); Polygon newPoly = Triangle; newPoly.Name = (sourceObject is SceneElement ? ((SceneElement)sourceObject).Name : "Object") + " (Triangulated Poly)"; return newPoly; }
/// <summary> /// This function draws all of the objects in the scene (i.e. every quadric /// in the quadrics arraylist etc). /// </summary> public virtual void Draw(Camera camera = null) { // TODO: we must decide what to do about drawing - are // cameras completely outside of the responsibility of the scene? // If no camera has been provided, use the current one. if (camera == null) camera = currentCamera; // Set the clear color. float[] clear = clearColour; gl.ClearColor(clear[0], clear[1], clear[2], clear[3]); // Reproject. if (camera != null) camera.Project(gl); // Clear. gl.Clear(OpenGL.GL_COLOR_BUFFER_BIT | OpenGL.GL_DEPTH_BUFFER_BIT | OpenGL.GL_STENCIL_BUFFER_BIT); //gl.BindTexture(OpenGL.GL_TEXTURE_2D, 0); // Render the root element, this will then render the whole // of the scene tree. RenderElement(sceneContainer, RenderMode.Design); // TODO: Adding this code here re-enables textures- it should work without it but it // doesn't, look into this. //gl.BindTexture(OpenGL.GL_TEXTURE_2D, 0); //gl.Enable(OpenGL.GL_TEXTURE_2D); gl.Flush(); }
protected virtual void InternalInitialise(SceneType sceneType) { // Add the default camera. currentCamera = new CameraPerspective(); currentCamera.Translate = new Vertex(-5.0f, 8.0f, 10.0f); cameras.Add(currentCamera); // Find out how many lights OpenGL can support. int [] umaxlights = new int[1]; gl.GetInteger(OpenGL.MAX_LIGHTS, umaxlights); // Now create as many lights as we can. for(uint u = 0; u < umaxlights[0]; u++) { Light light = new Light(); light.GLCode = OpenGL.LIGHT0 + u; light.Name = "Light " + u.ToString(); if(u == 0) { light.Ambient = new GLColor(1.0f, 1.0f, 1.0f, 0.0f); light.Diffuse = new GLColor(1.0f, 1.0f, 1.0f, 0.0f); light.On = true; } lights.Add(light); } // Set the scene type. SetSceneType(sceneType); // Initialise stock drawing. gl.InitialiseStockDrawing(); // Set the Scene OpenGL for the quadrics and nurbs. Quadric.SceneOpenGL = OpenGL; NURBSBase.SceneOpenGL = OpenGL; }
/// <summary> /// Renders the specified scene. /// </summary> /// <param name="scene">The scene.</param> /// <param name="camera">The camera.</param> /// <returns> /// The scene rendered with raytracing. /// </returns> public Image Render(Scene scene, Camera camera) { // Useful references. OpenGL gl = scene.OpenGL; // First, we need the matricies and viewport. double[] modelview = new double[16]; double[] projection = new double[16]; int[] viewport = new int[4]; gl.GetDouble(OpenGL.GL_MODELVIEW_MATRIX, modelview); gl.GetDouble(OpenGL.GL_PROJECTION_MATRIX, projection); gl.GetInteger(OpenGL.GL_VIEWPORT, viewport); int screenwidth = viewport[2]; int screenheight = viewport[3]; // From frustum data, we make a screen origin, and s/t vectors. Vertex s = new Vertex(0, 0.03f, 0); Vertex t = new Vertex(0, 0, 0.05f); Vertex vScreenOrigin = new Vertex(0, 0, 5); // Go through every pixel we have, and convert it into a screen pixel. ScreenPixel[] pixels = new ScreenPixel[viewport[2] * viewport[3]]; for (int y = 0; y < screenheight; y++) { for (int x = 0; x < screenwidth; x++) { // Get plane coordinates first of all. int planeX = x - (screenwidth / 2); int planeY = y - (screenwidth / 2); float worldX = vScreenOrigin.X + (planeX * t.X) + (planeY * s.X); float worldY = vScreenOrigin.Y + (planeX * t.Y) + (planeY * s.Y); float worldZ = vScreenOrigin.Z + (planeX * t.Z) + (planeY * s.Z); // Finally, pack all that data into a ScreenPixel. ScreenPixel pixel = new ScreenPixel(); pixel.x = x; pixel.y = y; pixel.worldpos = new Vertex(worldX, worldY, worldZ); pixel.ray.origin = camera.Position; pixel.ray.direction = pixel.worldpos - camera.Position; pixels[(y * viewport[2]) + x] = pixel; } } // Create the resulting bitmap. System.Drawing.Bitmap bmp = new System.Drawing.Bitmap(viewport[2], viewport[3]); // Now go through every ray and test for intersections. int pixelcounter = 0; int pixelcount = viewport[2] * viewport[3]; foreach (ScreenPixel pix in pixels) { // Raytrace the polygons. Intersection closest = new Intersection(); foreach (var raytracable in scene.SceneContainer.Traverse(se => se is IRayTracable)) { Intersection i = ((IRayTracable)raytracable).Raytrace(pix.ray, scene); if (i.intersected && (closest.intersected == false || i.closeness < closest.closeness)) closest = i; } if (closest.intersected == true) { System.Console.WriteLine("i = {0}, only {1} left!\n", closest.closeness, pixelcount - pixelcounter); } bmp.SetPixel(pix.x, pix.y, pix.ray.light); pixelcounter++; } // Return the ray traced imag. return bmp; }
public SetCameraToSceneViewCommand(SceneViewport sceneViewport, Camera camera) { _sceneViewport = sceneViewport; _camera = camera; }
private static bool CamerasEqual(Camera x, Camera y) { if (x == null || y == null) return false; return x.Position.Equals(y.Position) && DoubleEqual(x.AspectRatio, y.AspectRatio); }