예제 #1
0
        /// <summary>
        /// Initializes a new instance of the <see cref="nginz.FPSCamera"/> class.
        /// </summary>
        /// <param name="fieldOfView">Field of view.</param>
        /// <param name="resolution">Resolution.</param>
        /// <param name="mouse">Mouse.</param>
        /// <param name="keyboard">Keyboard.</param>
        public FPSCamera(float fieldOfView, Resolution resolution, MouseBuffer mouse, KeyboardBuffer keyboard)
        {
            // Create the base camera
            Camera = new Camera (fieldOfView, resolution, 0.01f, 256f);

            // Set the mouse and the keyboard
            Mouse = mouse;
            Keyboard = keyboard;

            // Initialize the mouse sensitivity
            MouseXSensitivity = .1f;
            MouseYSensitivity = .1f;

            // Initialize the actor speed
            Speed = 5f;
        }
예제 #2
0
        protected override void Initialize()
        {
            texture = Content.Load<Texture2D> ("particles_test.png", TextureConfiguration.Nearest);

            program = Content.Load<ShaderProgram> ("particle");

            positions = new GLBuffer<Vector4> (GLBufferSettings.StaticDraw4FloatArray, pos);
            texCoords = new GLBuffer<Vector2> (GLBufferSettings.StaticDraw2FloatArray, textureCoords);
            colors = new GLBuffer<Vector4> (GLBufferSettings.StaticDraw4FloatArray, col);

            abo = GL.GenVertexArray ();
            GL.BindVertexArray (abo);
            positions.PointTo (program.Attrib ("v_pos"));
            texCoords.PointTo (program.Attrib ("v_tex"));
            colors.PointTo (program.Attrib ("v_col"));

            camera = new Camera (60f, Resolution, 0.1f, 64f);

            camera.SetRelativePosition (new Vector3 (0, 0, 5));

            base.Initialize ();
        }
예제 #3
0
 /// <summary>
 /// Draw the specified program and camera.
 /// </summary>
 /// <param name="program">Program.</param>
 /// <param name="camera">Camera.</param>
 public void Draw(ShaderProgram program, Camera camera)
 {
     // Draw the geometry
     Geometry.Draw (program, Matrix, camera);
 }
예제 #4
0
        /// <summary>
        /// Begin batching sprites.
        /// </summary>
        public void Begin(Camera camera)
        {
            // Throw if the sprite batch is active
            if (active)
                this.Throw ("Cannot begin an active sprite batch.");

            GL.Clear (ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

            // Mark the sprite batch as active
            active = true;

            // Set the current camera
            CurrentCamera = camera ?? InternalCamera;

            // Reset the vertex and index counts
            vertexCount = 0;
            indexCount = 0;
        }
예제 #5
0
        /// <summary>
        /// Initializes a new instance of the <see cref="nginz.SpriteBatch"/> class.
        /// </summary>
        /// <param name = "game">The game.</param>
        /// <param name="shader">Shader.</param>
        public SpriteBatch(Game game, ShaderProgram shader = null)
        {
            // Set the game
            Game = game;

            // Compile predefined shaders if no shader program is given
            if (shader == null) {
                var vertShader = new VertexShader (vert_source);
                var fragShader = new FragmentShader (frag_source);
                Program = new ShaderProgram (vertShader, fragShader);
                Program.Link ();
            } else
                Program = shader;

            // Create the optimal buffer settings
            var settings = new GLBufferSettings {
                AttribSize = 0,
                Hint = BufferUsageHint.DynamicDraw,
                Normalized = false,
                Offset = 0,
                Target = BufferTarget.ArrayBuffer,
                Type = VertexAttribPointerType.Float
            };

            // Create temp variables for indices
            int indPtr = 0;
            var tempIndices = new uint[MAX_INDICES];

            // Fill temporary indices
            for (uint i = 0; i < MAX_VERTICES; i += 4) {

                // Triangle 1
                tempIndices [indPtr++] = i;
                tempIndices [indPtr++] = i + 1;
                tempIndices [indPtr++] = i + 2;

                // Triangle 2
                tempIndices [indPtr++] = i + 1;
                tempIndices [indPtr++] = i + 3;
                tempIndices [indPtr++] = i + 2;
            }

            // Set camera
            InternalCamera = new Camera (60f, game.Resolution, 0, 16, type: ProjectionType.Orthographic);

            // Set current texture
            CurrentTexture = Texture2D.Dot;

            // Generate array buffer object
            abo = GL.GenVertexArray ();

            // Create vertex buffer object
            vbo = new GLBufferDynamic<Vertex2D> (settings, Vertex2D.Size, MAX_VERTICES);

            // Create index buffer object
            ibo = new GLBuffer<uint> (GLBufferSettings.DynamicIndices, tempIndices);

            // Initialize vertices
            Vertices = new Vertex2D[MAX_VERTICES];

            framebuffer = new Framebuffer (FramebufferTarget.Framebuffer, Game.Resolution.Width, game.Resolution.Height)
                            .AttachTexture (FboAttachment.DiffuseAttachment, DrawBuffersEnum.ColorAttachment0, PixelInternalFormat.Rgb, PixelFormat.Rgb, PixelType.UnsignedByte, InterpolationMode.Linear);
        }