const SDL_VideoInfo* info = NULL;

if (SDL_Init(SDL_INIT_VIDEO) < 0) {

Logger::Instance()->OutputString("Error: " + std::string(SDL_GetError()));

return -1;

}

Logger::Instance()->OutputString("SDL_Init succeeded");

title = title_;

SDL_WM_SetCaption(title.c_str(), NULL);

info = SDL_GetVideoInfo( );

if (!info) {

Logger::Instance()->OutputString("Error: " + std::string(SDL_GetError()));

return -1;

}

Logger::Instance()->OutputString("SDL_GetVideoInfo succeeded");

bpp = info->vfmt->BitsPerPixel;

// 適当です

SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);

SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 5);

SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);

SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);

SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);

width = width_;

height = height_;

if (SDL_SetVideoMode(width, height, bpp, SDLflags) == 0) {

Logger::Instance()->OutputString("Error: " + std::string(SDL_GetError()));

return -1;

}

Logger::Instance()->OutputString("SDL_SetVideoMode succeeded");

#ifdef __WIN32__

// GLEW

if (glewInit() != GLEW_OK) {

Logger::Instance()->OutputString("Error: glewInit()");

return -1;

}

Logger::Instance()->OutputString("glewInit succeeded");

#endif __WIN32__

// オプションのテクスチャ

glGenTextures(1, &optionTexture);

SDL_Surface* bmp = SDL_LoadBMP("option.bmp");

if (bmp != NULL) {

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* tmp = SDL_CreateRGBSurface(SDL_SWSURFACE, bmp->w, bmp->h, 32, rmask, gmask, bmask, amask);

SDL_Rect rect;

rect.x = rect.y = 0;

rect.w = bmp->w; rect.h = bmp->h;

SDL_BlitSurface(bmp, &rect, tmp, &rect);

SDL_LockSurface(tmp);

//glActiveTexture(GL_TEXTURE1);

glBindTexture(GL_TEXTURE_2D, optionTexture);

glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bmp->w, bmp->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, tmp->pixels);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

//glActiveTexture(GL_TEXTURE0);

SDL_UnlockSurface(tmp);

SDL_FreeSurface(tmp);

SDL_FreeSurface(bmp);

} else {

Logger::Instance()->OutputString("Error: SDL_LoadBMP");

}

frameBuffer = 0;

renderBuffer = 0;

renderTexture = 0;

glGenFramebuffers(1, &frameBuffer);

glGenRenderbuffers(1, &renderBuffer);

glGenTextures(1, &renderTexture);

// フレームバッファ

glBindTexture(GL_TEXTURE_2D, renderTexture);

glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);

glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, renderTexture, 0);

// レンダーバッファ

glBindRenderbuffer(GL_RENDERBUFFER, renderBuffer);

glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height);

glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, renderBuffer);

//

glBindTexture(GL_TEXTURE_2D, 0);

glBindRenderbuffer(GL_RENDERBUFFER, 0);

glBindFramebuffer(GL_FRAMEBUFFER, 0);

SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE);

SDL_EnableUNICODE(true);

SDL_EnableKeyRepeat(250, 25);

errorHighlight = true;

return 0;

SDL_Event eve;

// まずマウス関係のイベントを処理する（なぜかPollEventでこない）

SDL_PumpEvents();

int mouseX, mouseY;

SDL_GetMouseState(&mouseX, &mouseY);

mouseBuffer.SetPosition((0.5 - (float)mouseX / width) * 2.0, (0.5 - (float)mouseY / height) * 2.0);

keyBuffer.Clear();

while (SDL_PollEvent(&eve)) {

switch(eve.type) {

case SDL_KEYDOWN:

{

Uint16 ch = eve.key.keysym.unicode;

SDLKey key = isprint(ch) ? (SDLKey)ch : eve.key.keysym.sym;

if (editMode)

keyAnalyzer.KeyHit(&textEditor, key, eve.key.keysym.mod, EffectFileTable[nowEffect]);

if (eve.key.keysym.sym == SDLK_ESCAPE)

return -1;

int ctrl = eve.key.keysym.mod & KMOD_CTRL;

int alt = eve.key.keysym.mod & KMOD_ALT;

if (SDLK_F1 <= eve.key.keysym.sym && eve.key.keysym.sym <= SDLK_F12 && eve.key.keysym.sym != SDLK_F11) {

nowEffect = eve.key.keysym.sym - SDLK_F1;

if (alt)

nowEffect += 12;

else if (ctrl)

nowEffect += 24;

shaderGL[nowEffect].CompileFromFile(EffectFileTable[nowEffect]);

textEditor.Load(EffectFileTable[nowEffect]);

}

if (eve.key.keysym.sym == SDLK_F11) {

if (editMode)

editMode = false;

else

editMode = true;

}

if (eve.key.keysym.mod & KMOD_CTRL && eve.key.keysym.sym == SDLK_TAB) {

errorHighlight = !errorHighlight;

}

if (eve.key.keysym.mod & KMOD_CTRL && eve.key.keysym.sym == SDLK_SPACE) {

static bool cursor = true;

cursor = !cursor;

SDL_ShowCursor(cursor);

}

}

break;

case SDL_QUIT:

return -1;

}

}

return 0;

/*

glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glLoadIdentity();

glEnable(GL_TEXTURE_2D);

glBindTexture(GL_TEXTURE_2D, optionTexture);

glBegin(GL_QUADS);

glTexCoord2d(0.0, 1.0); glVertex2d(-1,1);

glTexCoord2d(0.0, 0.0); glVertex2d(-1,-1);

glTexCoord2d(1.0, 0.0); glVertex2d(1,-1);

glTexCoord2d(1.0, 1.0); glVertex2d(1,1);

glEnd();

glBindTexture(GL_TEXTURE_2D, 0);

SDL_GL_SwapBuffers();

return;*/

// レンダーターゲット切替

glBindFramebuffer(GL_FRAMEBUFFER, frameBuffer);

glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glLoadIdentity();

std::string str = textEditor.ToString();

if (nowSource != str) {

nowSource = str;

if (shaderGL[nowEffect].Compile(nowSource) != 0)

nowCompiled = true;

else

nowCompiled = false;

}

Uint32 nowTime = SDL_GetTicks();

float realSec = (nowTime - baseTime) / 1000.0f;

float low = 0.0;

float mid = 0.0;

float high = 0.0;

float cy = -9999.0;

const int fontWidth = 10;

const int fontHeight = 15;

BitmapFontGL::Instance()->SetFontSize(fontWidth, fontHeight);

if (shaderGL[nowEffect].Valid()) {

shaderGL[nowEffect].Bind();

shaderGL[nowEffect].SetUniform("resolution", (float)width, (float)height);

shaderGL[nowEffect].SetUniform("time", realSec);

shaderGL[nowEffect].SetUniform("mouse", mouseBuffer.GetCursorX(), mouseBuffer.GetCursorY());

glEnable(GL_TEXTURE_2D);

glActiveTexture(GL_TEXTURE1);

glBindTexture(GL_TEXTURE_2D, optionTexture);

shaderGL[nowEffect].SetUniform("optTex", (int)1);

if (audioBuffer != NULL) {

GLfloat texture[1024];

for (int i = 0; i < 1024; i ++) {

texture[i] = audioBuffer[i];

}

glEnable(GL_TEXTURE_1D);

glActiveTexture(GL_TEXTURE0);

glBindTexture(GL_TEXTURE_1D, audioTexture);

glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

glTexImage1D(GL_TEXTURE_1D, 0, 1, 1024, 0 , GL_RED, GL_FLOAT, texture);

shaderGL[nowEffect].SetUniform("fft", (int)0);

int lowband = (int)floor(500.0 * 1024.0 / 44100.0 + 0.5);

int midband = (int)floor(5000.0 * 1024.0 / 44100.0 + 0.5);

for (int i = 0; i < lowband; i ++)

low += audioBuffer[i];

for (int i = lowband; i < midband; i ++)

mid += audioBuffer[i];

for (int i = midband; i < 1024;i ++)

high += audioBuffer[i];

//- 500 low

// 500 - 5000 mid

// 5000 - high

low /= lowband;

mid /= (midband - lowband);

high /= (1024 - midband);

shaderGL[nowEffect].SetUniform("lowFreq", (float)low);

shaderGL[nowEffect].SetUniform("midFreq", (float)mid);

shaderGL[nowEffect].SetUniform("highFreq", (float)high);

/*

float buf[1024];

for (int i = 0; i < 1024; i ++)

buf[i] = (float)audioBuffer[i];

shaderGL.SetUniform("audio", buf, 1024);*/

}

glRecti(1, 1, -1, -1);

shaderGL[nowEffect].Unbind();

glActiveTexture(GL_TEXTURE0);

}

if (editMode) {

//keyAnalyzer.Input(&textEditor, EffectFileTable[nowEffect]);

glPushMatrix();

// TextEditor Background

const float aspect = width/static_cast<float>(height);

const float textEditorHeight = textEditor.GetMaxLineNum() * fontHeight * (0.25f * 8.0f / width * aspect);

const float textEditorBGHeight = textEditorHeight * 1.2f;

const float editorOffsetY = -(2.0 - textEditorHeight) / 2.0;

const float editorBGOffsetY = -(2.0 - textEditorBGHeight) / 2.0;

glPushMatrix();

glTranslatef(-1.0f, 1.0f + editorBGOffsetY, 0);

glPushAttrib(GL_ENABLE_BIT);

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

glEnable(GL_BLEND);

glDisable(GL_DEPTH_TEST);

glBegin(GL_QUADS);

glColor4f(0.0, 0.0, 0.0, 0.0);

glVertex2f(0.0, 0.0);

glVertex2f(0.0 + width, 0.0);

glColor4f(0.0, 0.0, 0.0, 0.8);

glVertex2f(0.0 + width, -textEditorBGHeight/5.0);

glVertex2f(0.0, -textEditorBGHeight/5.0);

glEnd();

glBegin(GL_QUADS);

glColor4f(0.0, 0.0, 0.0, 0.8);

glVertex2f(0.0, -textEditorBGHeight/5.0);

glVertex2f(0.0 + width, - textEditorBGHeight/5.0);

glColor4f(0.0, 0.0, 0.0, 0.8);

glVertex2f(0.0 + width, -4.0*textEditorBGHeight/5.0 );

glVertex2f(0.0, -4.0*textEditorBGHeight/5.0 );

glEnd();

glBegin(GL_QUADS);

glColor4f(0.0, 0.0, 0.0, 0.8);

glVertex2f(0.0,-4.0*textEditorBGHeight/5.0);

glVertex2f(0.0 + width , -4.0*textEditorBGHeight/5.0);

glColor4f(0.0, 0.0, 0.0, 0.0);

glVertex2f(0.0 + width, -textEditorBGHeight);

glVertex2f(0.0, - textEditorBGHeight);

glEnd();

glPopAttrib();

glPopMatrix();

glTranslatef(-1.0f, 1.0f + editorOffsetY,0);

TextEditorPtrBuffer ptrbuf = textEditor.GetVisibleText();

TextEditorPtrBuffer textbuf = textEditor.GetText();

bool upAlpha = true;

bool downAlpha = true;

if (textEditor.GetLineOffset() == 0) {

upAlpha = false;

}

if (textEditor.GetLineOffset() + textEditor.GetMaxLineNum() >= textEditor.GetLineNum()) {

downAlpha = false;

}

const int transRange = 5;

BitmapFontGL::Instance()->Reset();

for (int i = 0; i < textEditor.GetLineOffset(); i ++) {

BitmapFontGL::Instance()->ProcessComment(*textbuf[i]);

}

std::set<int> errorLinesFS = shaderGL[nowEffect].GetErrorLinesFS();

for (int i = 0; i < ptrbuf.size(); i ++) {

float up = 1.0;

float down = 1.0;

if (upAlpha) {

if (i < transRange) {

up = (float)i/transRange;

down = (float)(i + 1)/transRange;

}

}

if (downAlpha) {

if (i >= ptrbuf.size() - transRange) {

up = 1.0 - (float)(i - ptrbuf.size() + transRange)/transRange;

down = 1.0 - (float)(i + 1 - ptrbuf.size() + transRange)/transRange;

}

}

bool errorLine = false;

if (errorLinesFS.find(i + textEditor.GetLineOffset() + 1) != errorLinesFS.end())

errorLine = true;

if (errorHighlight == false)

errorLine = false;

BitmapFontGL::Instance()->DrawLine(ptrbuf[i]->c_str(), aspect, width, i, up, down, errorLine);

if (i == textEditor.GetCursorPosition().col)

cy = height - i * fontHeight - fontHeight/2.0 + height * editorOffsetY/2.0;

}

if (nowCompiled)

BitmapFontGL::Instance()->DrawLine(EffectFileTable[nowEffect], aspect, width, textEditor.GetMaxLineNum(), 0.5, 0.5);

else

BitmapFontGL::Instance()->DrawLine(EffectFileTable[nowEffect], aspect, width, textEditor.GetMaxLineNum(), 0.5, 0.5, 1.0, 0.0, 0.0);

BitmapFontGL::Instance()->DrawLine("F1-F10: Change File F11: Show/Hide code F12: Edit PostFx", aspect, width, textEditor.GetMaxLineNum() + 1, 0.5, 0.5);

EditorCursor cursor = textEditor.GetCursorPosition();

BitmapFontGL::Instance()->DrawCursor(cursor.col, cursor.row, aspect, width);

if (textEditor.IsSelectMode()) {

EditorCursor selectStart = textEditor.GetSelectStart();

if (selectStart.col > cursor.col)

std::swap(selectStart, cursor);

if (selectStart.col == cursor.col) {

int start = selectStart.row;

int end = cursor.row;

BitmapFontGL::Instance()->DrawSelect(aspect, width, selectStart.col, start, end, 0.5, 0.5, 0.5);

} else {

for (int i = selectStart.col; i <= cursor.col; i ++) {

if (i < 0 || i >= textEditor.GetMaxLineNum())

continue;

if (i == selectStart.col) {

BitmapFontGL::Instance()->DrawSelect(aspect, width, i, selectStart.row, textEditor.GetLineLength(i));

} else if (i < cursor.col) {

BitmapFontGL::Instance()->DrawSelect(aspect, width, i, 0, textEditor.GetLineLength(i));

} else if (i == cursor.col) {

BitmapFontGL::Instance()->DrawSelect(aspect, width, i, 0, cursor.row);

}

}

}

}

// BitmapFontGL::Instance()->DrawSelect(aspect, width, 5, 1, 9);

glPopMatrix();

}

// レンダーターゲット元に戻す

glBindFramebuffer(GL_FRAMEBUFFER, 0);

if (shaderGL[POSTFxID].Valid()) {

shaderGL[POSTFxID].Bind();

glBindTexture(GL_TEXTURE_2D, renderTexture);

shaderGL[POSTFxID].SetUniform("texture0", (int)0);

shaderGL[POSTFxID].SetUniform("resolution", (float)width, (float)height);

shaderGL[POSTFxID].SetUniform("time", realSec);

shaderGL[POSTFxID].SetUniform("mouse", mouseBuffer.GetCursorX(), mouseBuffer.GetCursorY());

shaderGL[POSTFxID].SetUniform("lowFreq", (float)low);

shaderGL[POSTFxID].SetUniform("midFreq", (float)mid);

shaderGL[POSTFxID].SetUniform("highFreq", (float)high);

shaderGL[POSTFxID].SetUniform("editorCursorY", (float)cy);

//float cy = (textEditor.GetCursorPosition().col - textEditor.GetLineOffset()) * 11

glRecti(1, 1, -1, -1);

glBindTexture(GL_TEXTURE_2D, 0);

shaderGL[POSTFxID].Unbind();

} else {

glBindTexture(GL_TEXTURE_2D, renderTexture);

glRecti(1, 1, -1, -1);

glBindTexture(GL_TEXTURE_2D, 0);

}

SDL_GL_SwapBuffers();

Logger::Instance()->OutputString("MainLoop...");

BitmapFontGL::Instance()->CreateTexture();

baseTime = SDL_GetTicks();

// テキスト用エフェクトだけは事前にコンパイルしておく

shaderGL[POSTFxID].CompileFromFile(EffectFileTable[POSTFxID]);

textEditor.Load(EffectFileTable[0]);

glGenTextures(1 , &audioTexture);

while (!end) {

if (ProcessSDLEvents() < 0)

break;

audioBuffer = audioAnalyzer->Capture();

Render();

}

Logger::Instance()->OutputString("End");

return 0;