#include <Windows.h>
#include <gl/GL.h>
#include <gl/GLU.h>
#include <gl/freeglut.h>

// mat4 等
#include <gl/glm-0.9.9/glm.hpp>

// perspective , transform 等
#include <gl/glm-0.9.9/gtc/matrix_transform.hpp>

// value_ptr 等
#include <gl/glm-0.9.9/gtc/type_ptr.hpp>


// freeglut:
// http://freeglut.sourceforge.net/

// glm
// https://github.com/g-truc/glm

//ウィンドウの幅と高さ
int width, height;

double rotate_angle = 0;


//描画関数
void disp(void) {


    glClearColor(0.2, 0.2, 0.2, 1);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glViewport(0, 0, width, height);

#if 0
    //カメラの設定
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(60, width / (double)height, 0.1, 3);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslated(0, 0, -2);
    glRotated(rotate_angle, 0, 1, 0);
#else

    // 行列を計算
    glm::mat4 P = glm::perspective(glm::radians(60.f), width / (float)height, 0.1f, 3.f);

    glm::mat4 M;
    M = glm::identity<glm::mat4>();
    M = glm::translate(M, glm::vec3(0.f, 0.f, -2.f));
    M = glm::rotate(M, glm::radians((float)rotate_angle), glm::vec3(0.f, 1.f, 0.f));

    // 行列の設定

    glMatrixMode(GL_PROJECTION);
    glLoadMatrixf(glm::value_ptr(P));

    glMatrixMode(GL_MODELVIEW);
    glLoadMatrixf(glm::value_ptr(M));

#endif

    double v = 0.7;

    glBegin(GL_QUADS);
    glColor3d(0, 0, 1);
    glVertex2d(-v, -v);
    glColor3d(1, 0, 1);
    glVertex2d(v, -v);
    glColor3d(1, 1, 1);
    glVertex2d(v, v);
    glColor3d(0, 1, 1);
    glVertex2d(-v, v);

    glEnd();
    glFlush();
}

//ウィンドウサイズの変化時に呼び出される
void reshape(int w, int h) {
    width = w; height = h;

    disp();
}

void timer(int value)
{
    rotate_angle += 5;

    disp();
    glutTimerFunc(10, timer, 0);
}

//エントリポイント
int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitWindowPosition(100, 50);
    glutInitWindowSize(500, 500);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);

    glutCreateWindow("sample");
    glutDisplayFunc(disp);
    glutReshapeFunc(reshape);
    glutTimerFunc(1000, timer, 0);//タイマー
    glutMainLoop();

    return 0;
}

// このマクロを定義しないとエントリポイントが SDL_main になる
#define SDL_MAIN_HANDLED
#include <SDL.h>

// IMG_Load
#include <SDL_image.h>

#pragma comment(lib,"SDL2.lib")

#pragma comment(lib,"SDL2_image.lib")

// 必要ファイル：
// SDL2.dll
// SDL2_image.dll
// libpng16-16.dll
// zlib1.dll

int main(int argc, char* argv[])
{
  // これがないと IMG_Loadがnullptrを返す
  //SDL_Init(SDL_INIT_VIDEO);

  // PNG読むなら必要
  //IMG_Init(IMG_INIT_PNG);

  // ↑の筈なんだが無くても動いたりする？


  //////////////////////////////
  Uint32 rmask, gmask, bmask, amask;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
  rmask = 0xff000000;
  gmask = 0x00ff0000;
  bmask = 0x0000ff00;
  amask = 0x000000ff;
#else 
  rmask = 0x000000ff;
  gmask = 0x0000ff00;
  bmask = 0x00ff0000;
  amask = 0xff000000;
#endif

  //////////////////////////////
  //■ レンダラ作成
  SDL_Surface* surf_out = SDL_CreateRGBSurface(0, 500, 500, 32,
    rmask, gmask, bmask, amask);
  SDL_Renderer* rend_out = SDL_CreateSoftwareRenderer(surf_out);

  ////////////////////////////
  // 画像を読み込んでコピー
  SDL_Surface* surf_in = IMG_Load("C:\\test\\data\\a.png");
  SDL_BlitSurface(surf_in, nullptr, surf_out, nullptr);
  SDL_FreeSurface(surf_in);
  ////////////////////////////

  // アルファブレンドの設定
  SDL_SetRenderDrawBlendMode(rend_out, SDL_BLENDMODE_BLEND);

  //////////////////////////////
  // 赤で直線
  SDL_SetRenderDrawColor(rend_out, 255, 0, 0, 100);
  SDL_RenderDrawLine(rend_out, 50, 20, 500, 200);

  // ファイルに保存
  //SDL_SaveBMP(surf_out, "out.bmp");
  IMG_SavePNG(surf_out, "out.png");
  //////////////////////////////

  //■ レンダラ破棄
  SDL_DestroyRenderer(rend_out);

  SDL_FreeSurface(surf_out);


  return 0;
}

// このマクロを定義しないとエントリポイントが SDL_main になる
#define SDL_MAIN_HANDLED
#include <SDL.h>

#pragma comment(lib,"SDL2.lib")

// 必要ファイル：
// SDL2.dll

int main(int argc, char* argv[])
{
  //////////////////////////////
  Uint32 rmask, gmask, bmask, amask;
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
  rmask = 0xff000000;
  gmask = 0x00ff0000;
  bmask = 0x0000ff00;
  amask = 0x000000ff;
#else 
  rmask = 0x000000ff;
  gmask = 0x0000ff00;
  bmask = 0x00ff0000;
  amask = 0xff000000;
#endif
  //////////////////////////////

  SDL_Surface* surf = SDL_CreateRGBSurface(
    0,
    256,
    256,
    32, rmask, gmask, bmask, amask);

  //■ レンダラ作成
  SDL_Renderer* render = SDL_CreateSoftwareRenderer(surf);

  // アルファブレンドの設定
  SDL_SetRenderDrawBlendMode(render, SDL_BLENDMODE_BLEND);

  //////////////////////////////
  // 黒でクリア
  SDL_SetRenderDrawColor(render, 0, 0, 0, 255);
  SDL_RenderClear(render);
  //////////////////////////////
  // 赤で直線
  SDL_SetRenderDrawColor(render, 255, 0, 0, 150);
  SDL_RenderDrawLine(render, 50, 20, 500, 200);
  //////////////////////////////
  // ファイルに保存
  SDL_SaveBMP(surf, "out.bmp");
  //////////////////////////////

  //■ レンダラ破棄
  SDL_DestroyRenderer(render);


  SDL_FreeSurface(surf);


  return 0;
}

#include<array>

namespace szl {

  //! @brief 最大要素数が決まっている可変長配列
  //! @tparam T arrayに入れるデータ型
  //! @tparam MAX arrayの要素数
  template<typename T, size_t MAX>
  class LimitedVector {
    std::array<T, MAX> _data;
    size_t count; //!< 現在の要素数
  public:
    LimitedVector() :count(0) {}

    auto begin() { return _data.begin(); }
    auto end() { return _data.begin() + count; }
    const auto cbegin()const { return _data.cbegin(); }
    const auto cend()const { return _data.cbegin() + count; }

    void push_back(const T& v) {

      if (count >= MAX)
        throw "count >= MAX";

      _data[count++] = v;
    }
    void pop_back() {

      if (count == 0)
        throw "count == 0";

      count--;
    }
    T& back() {

      if (count == 0)
        throw "count == 0";

      return _data[count - 1];
    }
    const T& back()const {
      return _data[count - 1];
    }
    const T* data()const { return _data; }
    T* data() { return _data; }

    size_t size()const { return count; }

    const T& operator[](const size_t index)const {
      return _data[index];
    }
    T& operator[](const size_t index) {
      return _data[index];
    }

  };

}

#include "LimitedVector.hpp"

int main()
{
  szl::LimitedVector<int, 3> v;

  v.push_back(3);
  v.push_back(4);
  v.push_back(6);

  printf("%d\n", v.size());

  v[1] = 1;

  for (auto vv : v) {
      printf("-- %d\n", vv);
  }
  v.pop_back();

  printf("-------\n");
  for (auto vv : v) {
      printf("-- %d\n", vv);
  }

}