freezer/frz_scene.hpp

/* Scene rendering data structures.
 * Copyright (C) 2010 Francois Galea <fgalea@free.fr>
 *
 * This file is part of Freezer.
 *
 * Freezer is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * Freezer 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 Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with Freezer.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef _FRZ_SCENE_HPP_
#define _FRZ_SCENE_HPP_

#include <stdint.h>

#include <altivec.h>

#include "frz_obj3d.hpp"
#include "frz_misc.hpp"
#include "frz_defs.h"
#include "frz_vertex.hpp"

namespace Frz {

class Scene {
  friend class Script;

struct vvertex : public vertex {
  vvertex(): vertex() {}
  vvertex(const Object3d::Vertex &v): vertex(v.x, v.y, v.z, 1.0f) {}
  vvertex(const vertex &v): vertex(v) {}
  vertex &as_vertex() const { return *(vertex*)this; }
  void update_norm(const vvertex &a, const vvertex &b, const vvertex &c) {
    vertex::update_norm(a, b, c);
  }
};

public:
struct Triangle {
  uint16_t ob_type;
  uint16_t sh_type;
  uint16_t rot_id;
  uint16_t tex_id;
  uint16_t flags;
  uint16_t thickness;
  uint32_t color;

  vertex dummy;

  vertex a;
  vertex b;
  vertex c;
  vertex d;
  svertex na;
  svertex nb;
  svertex nc;
  svertex nd;

  Triangle(uint16_t _ob_type, uint16_t _sh_type, uint16_t _rot_id,
      uint16_t _tex_id, uint32_t _color, const vvertex &_a, const vvertex &_b,
      const vvertex &_c, const vvertex &_d=vvertex()):
      ob_type(_ob_type), sh_type(_sh_type), rot_id(_rot_id), tex_id(_tex_id),
      flags(0), thickness(0), color(_color), 
      a(_a), b(_b), c(_c), d(_d), na(), nb(), nc(), nd() {}

  void setThickness(uint16_t th);
  void setFlatNormal(bool fn=true);
  void setDoubleSided(bool ds=true);
  void flatNormal();
};

private:
  alignvec<Triangle> triangles;
  alignvec<Triangle> shared_triangles;
  vertex lightsource;
  uint16_t n_obj;
  int n_tri;
  int n_shared_tri;
  bool f_flash;
  uint32_t background;
  uint32_t fade_color;
  float fade_strength;

  const vertex &getLightSource() const { return lightsource; }

  bool getFlash() {
    bool f = f_flash; 
    f_flash = false;
    return f;
  }

  uint32_t getBackgroundColor() const { return background; }

  uint32_t getFadeColor() const { return fade_color; }

  float getFadeStrength() const { return fade_strength; }

protected:
  void flash() {
    f_flash = true;
  }
  void setBackgroundColor(uint32_t c) {
    background = c;
  }
  void setFade(uint32_t c, float s) {
    fade_color = c;
    fade_strength = s;
  }
  int add_triangle(uint16_t _sh_type, uint16_t _rot_id, uint16_t _tex_id,
      uint32_t _color, const vertex &_a, const vertex &_b, const vertex &_c);

  int add_quad(uint16_t _sh_type, uint16_t _rot_id, uint16_t _tex_id,
      uint32_t _color, const vertex &_a, const vertex &_b, const vertex &_c,
      const vertex &_d);

  /* \brief Adds an element in shared list.
   *
   * This method is for internal purposes only.
   *
   * \param _ob_type object type (cf. frz_defs.h)
   * \param _sh_type shading type (cf. frz_defs.h)
   * \param _rot_id rotation matrix number
   * \param _tex_id texture number (unused yet)
   * \param _color color (ARGB binary format)
   * \param _a first vertex
   * \param _b second vertex
   * \param _c third vertex
   * \param _d fourth vertex
   * \return polygon index in internal array
   */
  /*int add_shared(uint16_t _ob_type, uint16_t _sh_type, uint16_t _rot_id,
      uint16_t _tex_id, uint32_t _color, const vertex &_a, const vertex &_b,
      const vertex &_c, const vertex &_d);*/

  int add_object(const Object3d &obj, uint16_t type=SH_SMOOTH, float zoom=1.0f,
      uint16_t tex_id=-1);

  int add_object_extrude(const Object3d &obj, uint16_t th, float zoom=1.0f);

  int add_object();

  Triangle *getTriangles() { return &triangles[0]; }

  /* \brief Returns a reference to the internal shared polygon array.
   *
   * This method is for internal purposes only.
   *
   * \return a reference to the internal polygon array
   */
  //Triangle *getSharedTriangles() { return &shared_triangles[0]; }

  int getTriangleCount() { return n_tri; }

  /* \brief Returns the number of elements in the internal shared polygon
   * array.
   *
   * This method is for internal purposes only.
   *
   * \return the number of elements in the internal shared polygon array.
   */
  //int getSharedTriangleCount() { return n_shared_tri; }

  int getObjectCount() { return n_obj; }

  virtual void setupFrame(uint32_t time, trans t[]) = 0;

public:
  Scene();
  virtual ~Scene();
};

}; // namespace Frz


#endif

---