void
main(int argc, char **argv)
{
int i, mode = GLUT_DOUBLE;
glutInit(&argc, argv);
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-no3Dtex")) {
tex3dSupported = 0;
} else if (!strcmp(argv[i], "-sb")) {
mode = GLUT_SINGLE;
}
}
/* let glut do all the X Stuff */
glutInitDisplayMode(GLUT_RGB | mode);
glutCreateWindow("Voxel Head");
/* init our variables, etc */
init();
/* read texture data from a file */
readVoxelData();
/* set up OpenGL texturing */
if (tex3dSupported)
load3DTexture();
/* register specific routines to glut */
glutDisplayFunc(drawScene);
glutReshapeFunc(resize);
glutKeyboardFunc(keyboard);
/* create popup menu for glut */
glutCreateMenu(menu);
glutAddMenuEntry("Random Spin ON", SPIN_ON);
glutAddMenuEntry("Help", MENU_HELP);
glutAddMenuEntry("Exit", MENU_EXIT);
glutAttachMenu(GLUT_RIGHT_BUTTON);
/* loop for ever */
glutMainLoop();
}
// 셰이더와 프로그램 객체 초기화.
int InitShaderAndProgram() {
if (!mUserData)
return 0;
char* vShaderStr = AssetManager::getInstance()->readFile("YH_Shader.vert");
char* fShaderStr = AssetManager::getInstance()->readFile("YH_Shader.frag");
GLuint vertexShader;
GLuint fragmentShader;
GLuint programObject;
GLint linked;
// 정점과 프래그먼트 셰이더 적재.
vertexShader = LoadShader(GL_VERTEX_SHADER, vShaderStr);
fragmentShader = LoadShader(GL_FRAGMENT_SHADER, fShaderStr);
// 프로그램 객체 생성.
programObject = glCreateProgram();
if (programObject == 0)
return 0;
glAttachShader(programObject, vertexShader);
glAttachShader(programObject, fragmentShader);
// 프로그램 링크.
glLinkProgram(programObject);
// 링크 상태 점검.
glGetProgramiv(programObject, GL_LINK_STATUS, &linked);
if (!linked) {
GLint infoLen = 0;
glGetProgramiv(programObject, GL_INFO_LOG_LENGTH, &infoLen);
if(infoLen > 1)
{
char* infoLog = (char*) malloc (sizeof(char) * infoLen );
glGetProgramInfoLog(programObject, infoLen, NULL, infoLog);
ALOGE("Error linking program : %s", infoLog);
free(infoLog);
}
glDeleteProgram(programObject);
return false;
}
// 프로그램 객체 저장.
mUserData->programObject = programObject;
mUserData->offsetLoc = glGetUniformLocation(mUserData->programObject, "u_offset");
mUserData->mvpLoc = glGetUniformLocation(mUserData->programObject, "u_mvpMatrix");
mUserData->pointSizeLoc = glGetUniformLocation(mUserData->programObject, "u_pointSize");
mUserData->zPosLoc = glGetUniformLocation(mUserData->programObject, "zPos");
mUserData->vboIds[0] = 0;
mUserData->vboIds[1] = 0;
// 3D 텍스쳐 로드.
// mUserData->_3dTextId[0] = load3DTexture("/sdcard/VolumeData/backpack8.raw", 256, 256, 256, GL_RGB8, GL_RGB, GL_UNSIGNED_BYTE, false);
mUserData->_3dTextId[0] = load3DTexture("/sdcard/VolumeData/bonsai.raw", 256, 256, 256, GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE, false);
// mUserData->_3dTextId[0] = load3DTexture("/sdcard/VolumeData/BostonTeapot.raw", 256, 256, 128, GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE, false);
ALOGE("3D Texture ID : %d", mUserData->_3dTextId[0]);
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CCW);
glEnable(GL_TEXTURE_3D);
return true;
}
void RenderManager::init(const std::string& vertex_file, const std::string& geometry_file, const std::string& fragment_file, bool useShadow, int shadowMapSize) {
this->useShadow = useShadow;
this->softShadow = true;
renderingMode = RENDERING_MODE_BASIC;
// init glew
GLenum err = glewInit();
if (err != GLEW_OK) {
std::cout << "Error: " << glewGetErrorString(err) << std::endl;
}
// init program shader
// PASS 1
fragDataNamesP1.push_back("def_diffuse");
fragDataNamesP1.push_back("def_normal");
fragDataNamesP1.push_back("def_originPos");
fragDataNamesP1.push_back("def_intensity");
programs["pass1"] = shader.createProgram("../shaders/lc_vert_pass1.glsl", "../shaders/lc_frag_pass1.glsl", fragDataNamesP1);
// PASS 2
std::vector<QString> fragDataNamesP2;
fragDataNamesP2.push_back("def_AO");
programs["ssao"] = shader.createProgram("../shaders/lc_vert_ssao.glsl", "../shaders/lc_frag_ssao.glsl", fragDataNamesP2);
// PASS 3
programs["blur"] = shader.createProgram("../shaders/lc_vert_blur.glsl", "../shaders/lc_frag_blur.glsl");
// Line rendering
programs["line"] = shader.createProgram("../shaders/lc_vert_line.glsl", "../shaders/lc_frag_line.glsl");
// Shadow mapping
programs["shadow"] = shader.createProgram("../shaders/lc_vert_shadow.glsl", "../shaders/lc_frag_shadow.glsl");
glUseProgram(programs["pass1"]);
//////////////////////////////////////////////
// INIT SECOND PASS
// Quad
std::vector<Vertex> vert(4);
vert[0]=Vertex(glm::vec3(-1,-1,0),glm::vec3(0,0,0),glm::vec4(0,0,0,1), glm::vec2(0,0));
vert[1]=Vertex(glm::vec3(1,-1,0),glm::vec3(0,0,0),glm::vec4(0,0,0,1), glm::vec2(1,0));
vert[2]=Vertex(glm::vec3(1,1,0),glm::vec3(0,0,0),glm::vec4(0,0,0,1), glm::vec2(1,1));
vert[3]=Vertex(glm::vec3(-1,1,0),glm::vec3(0,0,0),glm::vec4(0,0,0,1), glm::vec2(0,1));
glGenVertexArrays(1,&secondPassVAO);
glBindVertexArray(secondPassVAO);
glGenBuffers(1, &secondPassVBO);
glBindBuffer(GL_ARRAY_BUFFER, secondPassVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex)*vert.size(), vert.data(), GL_STATIC_DRAW);
// Configure the attributes in the VAO.
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), 0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, normal));
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, color));
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offsetof(Vertex, texCoord));
glBindVertexArray(0);
// fragm
fragDataFB=INT_MAX;
///// load 3d texture for hatching
std::vector<QString> hatchingTextureFiles;
hatchingTextureFiles.push_back("hatching/hatching0.png");
hatchingTextureFiles.push_back("hatching/hatching1.png");
hatchingTextureFiles.push_back("hatching/hatching2.png");
hatchingTextureFiles.push_back("hatching/hatching3.png");
hatchingTextureFiles.push_back("hatching/hatching4.png");
hatchingTextureFiles.push_back("hatching/hatching5.png");
hatchingTextureFiles.push_back("hatching/hatching6.png");
hatchingTextureFiles.push_back("hatching/hatching7.png");
hatchingTextureFiles.push_back("hatching/hatching8.png");
hatchingTextures = load3DTexture(hatchingTextureFiles);
shadow.init(programs["shadow"], shadowMapSize, shadowMapSize);
}
