bool begin()
{
bool Validated = true;
Validated = Validated && glf::checkGLVersion(SAMPLE_MAJOR_VERSION, SAMPLE_MINOR_VERSION);
if(Validated && glf::checkExtension("GL_ARB_debug_output"))
Validated = initDebugOutput();
if(Validated)
Validated = initProgram();
glf::checkError("initProgram Apple workaround");
if(Validated)
Validated = initBuffer();
if(Validated)
Validated = initVertexArray();
if(Validated)
Validated = initTexture();
if(Validated)
Validated = initFramebuffer();
return Validated && glf::checkError("begin");
}
bool begin()
{
bool Validated = glf::checkGLVersion(SAMPLE_MAJOR_VERSION, SAMPLE_MINOR_VERSION);
if(Validated && glf::checkExtension("GL_ARB_debug_output"))
Validated = initDebugOutput();
if(Validated)
Validated = initProgram();
if(Validated)
Validated = initArrayBuffer();
if(Validated)
Validated = initVertexArray();
if(Validated)
Validated = initTexture2D();
if(Validated)
Validated = initSampler();
if(Validated)
Validated = initFramebuffer();
return Validated && glf::checkError("begin");
}
bool begin()
{
bool Validated = true;
Validated = Validated && this->checkExtension("GL_AMD_vertex_shader_viewport_index");
Validated = Validated && this->checkExtension("GL_AMD_vertex_shader_layer");
if(Validated)
Validated = initProgram();
if(Validated)
Validated = initBuffer();
if(Validated)
Validated = initVertexArray();
if(Validated)
Validated = initTexture();
if(Validated)
Validated = initFramebuffer();
if(Validated)
Validated = initSampler();
return Validated;
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
//表示モード
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
//表示ウィンドウのサイズ
glutInitWindowSize(width, height);
//左上の位置
glutInitWindowPosition(100, 100);
//ウィンドウ作成
glutCreateWindow("FBOテクスチャ(SL_TextureFBO)");
//ウィンドウのサイズ変更
glutReshapeFunc(resize);
//表示
glutDisplayFunc(display);
//キーボードの利用
glutKeyboardFunc(keyboard);
//矢印キーなどの特殊キー利用
glutSpecialFunc(special);
//マウス操作
glutMouseFunc(mouse);
glutMotionFunc(motion);
//再描画
glutIdleFunc(idle);
//初期設定
glewInit();
init();
initFramebuffer();
initGlsl(&shaderProg1, "colorMap.vert", "colorMap.frag");
initGlsl(&shaderProg2, "Phong.vert", "Phong.frag");
//イベント処理ループに入る
glutMainLoop();
//リソースの解放
glDeleteTextures(1, &texName);
glDeleteRenderbuffersEXT(1, &rbName);
glDeleteFramebuffersEXT(1, &fbName);
glDeleteProgram(shaderProg1);
glDeleteProgram(shaderProg2);
return 0;
}
bool begin()
{
bool Validated = this->checkExtension("GL_INTEL_fragment_shader_ordering");
/*
glm::vec2 const WindowSize(this->getWindowSize());
glm::vec2 const WindowRange = WindowSize * 3.f;
this->Viewports.resize(1000);
for (std::size_t i = 0; i < this->Viewports.size(); ++i)
{
glm::vec2 const ViewportPos(i % 17u, i % 13u);
glm::vec2 const ViewportSize(i % 11u);
this->Viewports[i] = glm::vec4(ViewportPos / glm::vec2(17, 13) * WindowRange - WindowSize, ViewportSize / glm::vec2(11));
}
*/
glm::vec2 WindowSize(this->getWindowSize());
this->Viewports.resize(1000);
for (std::size_t i = 0; i < this->Viewports.size(); ++i)
{
this->Viewports[i] = glm::vec4(
glm::linearRand(-WindowSize.x, WindowSize.x * 2.0f),
glm::linearRand(-WindowSize.y, WindowSize.y * 2.0f),
WindowSize * glm::linearRand(0.0f, 1.0f));
}
if(Validated)
Validated = initProgram();
if(Validated)
Validated = initBuffer();
if(Validated)
Validated = initVertexArray();
if(Validated)
Validated = initTexture();
if(Validated)
Validated = initFramebuffer();
return Validated;
}
bool begin()
{
bool Validated = true;
Validated = Validated && this->checkExtension("GL_NV_explicit_multisample");
if(Validated)
Validated = initProgram();
if(Validated)
Validated = initBuffer();
if(Validated)
Validated = initVertexArray();
if(Validated)
Validated = initSampler();
if(Validated)
Validated = initRenderbuffer();
if(Validated)
Validated = initTexture();
if(Validated)
Validated = initFramebuffer();
return Validated && this->checkError("begin");
}
bool begin()
{
bool Validated = true;
if(Validated)
Validated = initProgram();
if(Validated)
Validated = initSampler();
if(Validated)
Validated = initBuffer();
if(Validated)
Validated = initVertexArray();
if(Validated)
Validated = initTexture();
if(Validated)
Validated = initFramebuffer();
//glEnable(GL_SAMPLE_MASK);
//glSampleMaski(0, 0xFF);
return Validated;
}
bool begin()
{
bool Validated = true;
Validated = Validated && glf::checkGLVersion(SAMPLE_MAJOR_VERSION, SAMPLE_MINOR_VERSION);
Validated = Validated && glf::checkExtension("GL_EXT_direct_state_access");
Validated = Validated && glf::checkExtension("GL_NV_texture_multisample");
if(Validated)
Validated = initProgram();
if(Validated)
Validated = initSampler();
if(Validated)
Validated = initArrayBuffer();
if(Validated)
Validated = initVertexArray();
if(Validated)
Validated = initTexture2D();
if(Validated)
Validated = initFramebuffer();
return Validated && glf::checkError("begin");
}
bool begin()
{
bool Validated = this->checkExtension("GL_EXT_direct_state_access");
if(Validated)
Validated = initProgram();
if(Validated)
Validated = initSampler();
if(Validated)
Validated = initBuffer();
if(Validated)
Validated = initVertexArray();
if(Validated)
Validated = initTexture();
if(Validated)
Validated = initFramebuffer();
//glEnable(GL_SAMPLE_MASK);
//glSampleMaski(0, 0xFF);
return Validated;
}
bool begin()
{
bool Validated(true);
Validated = Validated && this->checkExtension("GL_ARB_framebuffer_no_attachments");
Validated = Validated && this->checkExtension("GL_ARB_clear_texture");
Validated = Validated && this->checkExtension("GL_ARB_shader_storage_buffer_object");
if(Validated)
Validated = initProgram();
if(Validated)
Validated = initBuffer();
if(Validated)
Validated = initVertexArray();
if(Validated)
Validated = initTexture();
if(Validated)
Validated = initSampler();
if(Validated)
Validated = initFramebuffer();
return Validated;
}
bool begin()
{
bool Validated = true;
Validated = Validated && glf::checkGLVersion(SAMPLE_MAJOR_VERSION, SAMPLE_MINOR_VERSION);
Validated = Validated && glf::checkExtension("GL_EXT_texture_sRGB_decode");
if(Validated && glf::checkExtension("GL_ARB_debug_output"))
Validated = initDebugOutput();
if(Validated)
Validated = initProgram();
if(Validated)
Validated = initSampler();
if(Validated)
Validated = initBuffer();
if(Validated)
Validated = initTexture();
if(Validated)
Validated = initFramebuffer();
if(Validated)
Validated = initVertexArray();
return Validated;
}
bool begin()
{
GLint MajorVersion = 0;
GLint MinorVersion = 0;
glGetIntegerv(GL_MAJOR_VERSION, &MajorVersion);
glGetIntegerv(GL_MINOR_VERSION, &MinorVersion);
bool Validated = (MajorVersion * 10 + MinorVersion) >= (SAMPLE_MAJOR_VERSION * 10 + SAMPLE_MINOR_VERSION);
if(Validated)
Validated = initProgram();
if(Validated)
Validated = initArrayBuffer();
if(Validated)
Validated = initSampler();
if(Validated)
Validated = initTexture2D();
if(Validated)
Validated = initFramebuffer();
if(Validated)
Validated = initVertexArray();
return Validated && glf::checkError("begin");
}
bool begin()
{
bool Validated = true;
Validated = Validated && glf::checkGLVersion(SAMPLE_MAJOR_VERSION, SAMPLE_MINOR_VERSION);
Validated = Validated && glf::checkExtension("GL_GTC_direct_state_access");
if(Validated)
Validated = initDebugOutput();
if(Validated)
Validated = initProgram();
if(Validated)
Validated = initBuffer();
if(Validated)
Validated = initVertexArray();
if(Validated)
Validated = initSampler();
if(Validated)
Validated = initTexture();
if(Validated)
Validated = initFramebuffer();
return Validated && glf::checkError("begin");
}
void init(const char *title)
{
int argc = 0;
glutInit(&argc, NULL);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowPosition(-1, -1);
glutInitWindowSize(w, h);
glutCreateWindow(title);
glutSetCursor(GLUT_CURSOR_INHERIT);
glutIgnoreKeyRepeat(1);
initFramebuffer();
initProgram();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(goKeyboard);
glutKeyboardUpFunc(goKeyboardUp);
glutSpecialFunc(goSpecial);
glutSpecialUpFunc(goSpecialUp);
glutMotionFunc(goMotion);
glutPassiveMotionFunc(goMotion);
glutMouseFunc(goMouse);
glutEntryFunc(goEntry);
glutVisibilityFunc(visible);
glClearColor(1.0f, 1.0f, 1.0f, 0.0f);
goReady();
glutMainLoop();
glDeleteTextures(1, &fbo_texture);
glDeleteFramebuffers(1, &fbo);
glDeleteProgram(program);
}
bool begin()
{
bool Validated = true;
Validated = Validated && this->checkExtension("GL_AMD_performance_monitor");
if(Validated)
{
this->Monitor.reset(new monitor());
this->Monitor->record("CP", 1);
}
if(Validated)
Validated = initProgram();
if(Validated)
Validated = initBuffer();
if(Validated)
Validated = initVertexArray();
if(Validated)
Validated = initTexture();
if(Validated)
Validated = initFramebuffer();
return Validated;
}
bool begin()
{
bool Validated = true;
Validated = Validated && glf::checkGLVersion(SAMPLE_MAJOR_VERSION, SAMPLE_MINOR_VERSION);
Validated = Validated && glf::checkExtension("GL_ARB_viewport_array");
Validated = Validated && glf::checkExtension("GL_ARB_separate_shader_objects");
if(Validated && glf::checkExtension("GL_ARB_debug_output"))
Validated = initDebugOutput();
if(Validated)
Validated = initProgram();
if(Validated)
Validated = initArrayBuffer();
if(Validated)
Validated = initVertexArray();
if(Validated)
Validated = initSampler();
if(Validated)
Validated = initTexture2D();
if(Validated)
Validated = initFramebuffer();
return Validated && glf::checkError("begin");
}
bool begin()
{
bool Validated(true);
float MinFragmentInterpolationOffset(0);
float MaxFragmentInterpolationOffset(0);
float FragmentInterpolationOffsetBits(0);
glGetFloatv(GL_MIN_FRAGMENT_INTERPOLATION_OFFSET, &MinFragmentInterpolationOffset);
glGetFloatv(GL_MAX_FRAGMENT_INTERPOLATION_OFFSET, &MaxFragmentInterpolationOffset);
glGetFloatv(GL_FRAGMENT_INTERPOLATION_OFFSET_BITS, &FragmentInterpolationOffsetBits);
if(Validated)
Validated = initProgram();
if(Validated)
Validated = initBuffer();
if(Validated)
Validated = initVertexArray();
if(Validated)
Validated = initTexture();
if(Validated)
Validated = initFramebuffer();
return Validated;
}
int main(int argc, char *argv[])
{
Core *core;
int option;
bool enableMemoryDump = false;
uint32_t memDumpBase = 0;
uint32_t memDumpLength = 0;
char *memDumpFilename = NULL;
size_t memDumpFilenameLen = 0;
bool verbose = false;
uint32_t fbWidth = 640;
uint32_t fbHeight = 480;
bool blockDeviceOpen = false;
bool enableFbWindow = false;
uint32_t totalThreads = 4;
char *separator;
uint32_t memorySize = 0x1000000;
const char *sharedMemoryFile = NULL;
struct stat st;
enum
{
MODE_NORMAL,
MODE_COSIMULATION,
MODE_GDB_REMOTE_DEBUG
} mode = MODE_NORMAL;
while ((option = getopt(argc, argv, "f:d:vm:b:t:c:r:s:i:o:")) != -1)
{
switch (option)
{
case 'v':
verbose = true;
break;
case 'r':
gScreenRefreshRate = parseNumArg(optarg);
break;
case 'f':
enableFbWindow = true;
separator = strchr(optarg, 'x');
if (!separator)
{
fprintf(stderr, "Invalid framebuffer size %s\n", optarg);
return 1;
}
fbWidth = parseNumArg(optarg);
fbHeight = parseNumArg(separator + 1);
break;
case 'm':
if (strcmp(optarg, "normal") == 0)
mode = MODE_NORMAL;
else if (strcmp(optarg, "cosim") == 0)
mode = MODE_COSIMULATION;
else if (strcmp(optarg, "gdb") == 0)
mode = MODE_GDB_REMOTE_DEBUG;
else
{
fprintf(stderr, "Unkown execution mode %s\n", optarg);
return 1;
}
break;
case 'd':
// Memory dump, of the form: filename,start,length
separator = strchr(optarg, ',');
if (separator == NULL)
{
fprintf(stderr, "bad format for memory dump\n");
usage();
return 1;
}
memDumpFilenameLen = (size_t)(separator - optarg);
memDumpFilename = (char*) malloc(memDumpFilenameLen + 1);
strncpy(memDumpFilename, optarg, memDumpFilenameLen);
memDumpFilename[memDumpFilenameLen] = '\0';
memDumpBase = parseNumArg(separator + 1);
separator = strchr(separator + 1, ',');
if (separator == NULL)
{
fprintf(stderr, "bad format for memory dump\n");
usage();
return 1;
}
memDumpLength = parseNumArg(separator + 1);
enableMemoryDump = true;
break;
case 'b':
if (openBlockDevice(optarg) < 0)
return 1;
blockDeviceOpen = true;
break;
case 'c':
memorySize = parseNumArg(optarg);
break;
case 't':
totalThreads = parseNumArg(optarg);
if (totalThreads < 1 || totalThreads > 32)
{
fprintf(stderr, "Total threads must be between 1 and 32\n");
return 1;
}
break;
case 's':
sharedMemoryFile = optarg;
break;
case 'i':
recvInterruptFd = open(optarg, O_RDWR);
if (recvInterruptFd < 0)
{
perror("main: failed to open receive interrupt pipe");
return 1;
}
if (fstat(recvInterruptFd, &st) < 0)
{
perror("main: stat failed on receive interrupt pipe");
return 1;
}
if ((st.st_mode & S_IFMT) != S_IFIFO)
{
fprintf(stderr, "%s is not a pipe\n", optarg);
return 1;
}
break;
case 'o':
sendInterruptFd = open(optarg, O_RDWR);
if (sendInterruptFd < 0)
{
perror("main: failed to open send interrupt pipe");
return 1;
}
if (fstat(sendInterruptFd, &st) < 0)
{
perror("main: stat failed on send interrupt pipe");
return 1;
}
if ((st.st_mode & S_IFMT) != S_IFIFO)
{
fprintf(stderr, "%s is not a pipe\n", optarg);
return 1;
}
break;
case '?':
usage();
return 1;
}
}
if (optind == argc)
{
fprintf(stderr, "No image filename specified\n");
usage();
return 1;
}
// Don't randomize memory for cosimulation mode, because
// memory is checked against the hardware model to ensure a match
core = initCore(memorySize, totalThreads, mode != MODE_COSIMULATION,
sharedMemoryFile);
if (core == NULL)
return 1;
if (loadHexFile(core, argv[optind]) < 0)
{
fprintf(stderr, "Error reading image %s\n", argv[optind]);
return 1;
}
if (enableFbWindow)
{
if (initFramebuffer(fbWidth, fbHeight) < 0)
return 1;
}
switch (mode)
{
case MODE_NORMAL:
if (verbose)
enableTracing(core);
setStopOnFault(core, false);
if (enableFbWindow)
{
while (executeInstructions(core, ALL_THREADS, gScreenRefreshRate))
{
updateFramebuffer(core);
pollFbWindowEvent();
checkInterruptPipe(core);
}
}
else
{
while (executeInstructions(core, ALL_THREADS, 1000000))
checkInterruptPipe(core);
}
break;
case MODE_COSIMULATION:
setStopOnFault(core, false);
if (runCosimulation(core, verbose) < 0)
return 1; // Failed
break;
case MODE_GDB_REMOTE_DEBUG:
setStopOnFault(core, true);
remoteGdbMainLoop(core, enableFbWindow);
break;
}
if (enableMemoryDump)
writeMemoryToFile(core, memDumpFilename, memDumpBase, memDumpLength);
dumpInstructionStats(core);
if (blockDeviceOpen)
closeBlockDevice();
if (stoppedOnFault(core))
return 1;
return 0;
}
void opengl_init(int w, int h)
{
/* init statue *********************************************************************************/
CLoad3DS g_Load3ds;
t3DModel g_3DModel;
shader_loader vs,ps;
initFramebuffer();
if(torus_mesh.program == NULL)
{
LOGI("begin load shader");
torus_mesh.program = new shader_program;
if(!torus_mesh.program->build(vs.load_shader_source("media/torus.vs"),ps.load_shader_source("media/torus.ps")))
{
LOGI("build shader failed");
return;
}
torus_mesh.attribute_locations[static_mesh::POSITION] = glGetAttribLocation(torus_mesh.program->get_program(),"rm_Vertex");
;
LOGI("begin to load 3ds file");
g_Load3ds.Import3DS(&g_3DModel, "media/Torus.3ds");
LOGI("load 3ds end");
t3DObject* p = &g_3DModel.pObject[0];
torus_mesh.loc_view_proj_matrix = glGetUniformLocation(torus_mesh.program->get_program(), "view_proj_matrix");
glGenBuffers(1, &torus_mesh.attribute_vbos[static_mesh::POSITION]);
glGenBuffers(1, &torus_mesh.attribute_vbos[static_mesh::INDEX]);
glBindBuffer(GL_ARRAY_BUFFER, torus_mesh.attribute_vbos[static_mesh::POSITION]);
glBufferData(GL_ARRAY_BUFFER, 4*3*p->numOfVerts, &(p->pVerts[0].x), GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, torus_mesh.attribute_vbos[static_mesh::INDEX]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 2*3*p->numOfFaces, &(p->pFaces[0].vertIndex[0]), GL_STATIC_DRAW);
torus_mesh.num_faces = p->numOfFaces;
}
/* init background *********************************************************************************/
if(quad_mesh.program == NULL)
{
float *pos_data;
GLushort *inds;
GLuint num_ves;
quad_mesh.program = new shader_program;
if(!quad_mesh.program->build(vs.load_shader_source("media/quad.vs"),ps.load_shader_source("media/quad.ps")))
{
LOGI("build shader failed");
return;
}
check_gl_error("build shader");
quad_mesh.texs_idxs[0] = texture;
quad_mesh.texs_idxs[1] = create_texture("media/Flame.tga");
shape::create_plane(1, &pos_data, NULL, NULL, &inds, num_ves);
// quad_mesh.loc_view_proj_matrix = glGetUniformLocation(quad_mesh.program->get_program(), "view_proj_matrix");
quad_mesh.texs_locs[0] = glGetUniformLocation(quad_mesh.program->get_program(), "RT");
quad_mesh.texs_locs[1] = glGetUniformLocation(quad_mesh.program->get_program(), "color");
quad_mesh.attribute_locations[static_mesh::POSITION] = glGetAttribLocation(quad_mesh.program->get_program(),"rm_Vertex");
glGenBuffers(1, &quad_mesh.attribute_vbos[static_mesh::POSITION]);
glGenBuffers(1, &quad_mesh.attribute_vbos[static_mesh::INDEX]);
glBindBuffer(GL_ARRAY_BUFFER, quad_mesh.attribute_vbos[static_mesh::POSITION]);
glBufferData(GL_ARRAY_BUFFER, num_ves*4*3, pos_data, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, quad_mesh.attribute_vbos[static_mesh::INDEX]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 6*2*3, inds, GL_STATIC_DRAW);
quad_mesh.num_faces = 6;
delete []pos_data;
delete []inds;
}
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDisable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
width = w;
height = h;
quad_proj_matrix.perspective(60, (float)w/h, 1.0f,3000.0f);
}