src/canvas.h

/*
 * Copyright © 2008 Ben Smith
 * Copyright © 2010-2011 Linaro Limited
 *
 * This file is part of the glmark2 OpenGL (ES) 2.0 benchmark.
 *
 * glmark2 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 *
 * glmark2 is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * glmark2.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Authors:
 *  Ben Smith (original glmark benchmark)
 *  Alexandros Frantzis (glmark2)
 *  Jesse Barker
 */
#ifndef GLMARK2_CANVAS_H_
#define GLMARK2_CANVAS_H_

#include "gl-headers.h"
#include "mat.h"
#include "gl-visual-config.h"

#include <stdint.h>
#include <string>
#include <stdio.h>
#include <cmath>

/**
 * Abstraction for a GL rendering target.
 */
class Canvas
{
public:
    virtual ~Canvas() {}

    /**
     * A pixel value.
     */
    struct Pixel {
        Pixel():
            r(0), g(0), b(0), a(0) {}
        Pixel(uint8_t r, uint8_t g, uint8_t b, uint8_t a):
            r(r), g(g), b(b), a(a) {}
        /**
         * Gets the pixel value as a 32-bit integer in 0xAABBGGRR format.
         *
         * @return the pixel value
         */
        uint32_t to_le32()
        {
            return static_cast<uint32_t>(r) +
                   (static_cast<uint32_t>(g) << 8) +
                   (static_cast<uint32_t>(b) << 16) +
                   (static_cast<uint32_t>(a) << 24);

        }

        /**
         * Gets the euclidian distance from this pixel in 3D RGB space.
         *
         * @param p the pixel to get the distance from
         *
         * @return the euclidian distance
         */
        double distance_rgb(const Canvas::Pixel &p)
        {
            // These work without casts because of integer promotion rules
            // (the uint8_ts are promoted to ints)
            double d = (r - p.r) * (r - p.r) +
                       (g - p.g) * (g - p.g) +
                       (b - p.b) * (b - p.b);
            return std::sqrt(d);
        }

        uint8_t r;
        uint8_t g;
        uint8_t b;
        uint8_t a;
    };


    /**
     * Initializes the canvas and makes it the target of GL operations.
     *
     * This method should be implemented in derived classes.
     *
     * @return whether initialization succeeded
     */
    virtual bool init() { return false; }

    /**
     * Resets the canvas, destroying and recreating resources to give each new
     * test scenario a fresh context for rendering.
     *
     * This method should be implemented in derived classes.
     *
     * @return whether reset succeeded
     */
    virtual bool reset() { return false; }

    /**
     * Changes the visibility of the canvas.
     *
     * The canvas is initially not visible.
     *
     * This method should be implemented in derived classes.
     *
     * @param visible true to make the Canvas visible, false otherwise
     */
    virtual void visible(bool visible) { static_cast<void>(visible); }

    /**
     * Clears the canvas.
     * This method should be implemented in derived classes.
     */
    virtual void clear() {}

    /**
     * Ensures that the canvas on-screen representation gets updated
     * with the latest canvas contents.
     *
     * This method should be implemented in derived classes.
     */
    virtual void update() {}

    /**
     * Prints information about the canvas.
     *
     * This method should be implemented in derived classes.
     */
    virtual void print_info() {}

    /**
     * Reads a pixel from the canvas.
     *
     * The (0, 0) point is the lower left corner. The X and Y coordinates
     * increase towards the right and top, respectively.
     *
     * This method should be implemented in derived classes.
     *
     * @param x the X coordinate
     * @param y the Y coordinate
     *
     * @return the pixel
     */
    virtual Pixel read_pixel(int x, int y)
    {
        static_cast<void>(x);
        static_cast<void>(y);
        return Pixel();
    }

    /**
     * Writes the canvas contents to a file.
     *
     * The pixel save order is  upper left to lower right. Each pixel value
     * is stored as four consecutive bytes R,G,B,A.
     *
     * This method should be implemented in derived classes.
     *
     * @param filename the name of the file to write to
     */
    virtual void write_to_file(std::string &filename) { static_cast<void>(filename); }

    /**
     * Whether we should quit the application.
     *
     * This method should be implemented in derived classes.
     *
     * @return true if we should quit, false otherwise
     */
    virtual bool should_quit() { return false; }

    /**
     * Resizes the canvas.
     *
     * This method should be implemented in derived classes.
     *
     * @param width the new width in pixels
     * @param height the new height in pixels
     *
     * @return true if we should quit, false otherwise
     */
    virtual void resize(int width, int height) { static_cast<void>(width); static_cast<void>(height); }

    /**
     * Gets the FBO associated with the canvas.
     *
     * @return the FBO
     */
    virtual unsigned int fbo() { return 0; }

    /**
     * Gets a dummy canvas object.
     *
     * @return the dummy canvas
     */
    static Canvas &dummy()
    {
        static Canvas dummy_canvas(0, 0);
        return dummy_canvas;
    }

    /**
     * Gets the width of the canvas.
     *
     * @return the width in pixels
     */
    int width() { return width_; }

    /**
     * Gets the height of the canvas.
     *
     * @return the height in pixels
     */
    int height() { return height_; }

    /**
     * Gets the projection matrix recommended for use with the canvas.
     *
     * It's not mandatory to use this projection matrix.
     *
     * @return the projection matrix
     */
    const LibMatrix::mat4 &projection() { return projection_; }

    /**
     * Sets whether the canvas should be backed by an off-screen surface.
     *
     * This takes effect after the next init()/reset().
     */
    void offscreen(bool offscreen) { offscreen_ = offscreen; }

    /**
     * Sets the preferred visual configuration.
     *
     * This takes effect after the next init()/reset().
     */
    void visual_config(GLVisualConfig &config) { visual_config_ = config; }

protected:
    Canvas(int width, int height) :
        width_(width), height_(height), offscreen_(false) {}

    int width_;
    int height_;
    LibMatrix::mat4 projection_;
    bool offscreen_;
    GLVisualConfig visual_config_;
};

#endif