int main(int argc,char**argv)
{
string vss = loadShaderSrc("shaders/light.vert");
string fss = loadShaderSrc("shaders/light.frag");
engInit(argc,argv);
GLuint vs = newShader(vss,GL_VERTEX_SHADER);
GLuint fs = newShader(fss,GL_FRAGMENT_SHADER);
GLuint prog = newProgram(vs,fs);
glUseProgram(prog);
glutMainLoop();
}
GLuint loadShaderPair(const char *szVertexProg, const char *szFragmentProg) {
// Temporary Shader objects
GLuint hVertexShader;
GLuint hFragmentShader;
GLuint programID = 0;
GLint testVal;
// Create shader objects
hVertexShader = glCreateShader(GL_VERTEX_SHADER);
hFragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
loadShaderSrc(szVertexProg, hVertexShader);
loadShaderSrc(szFragmentProg, hFragmentShader);
// Compile them
glCompileShader(hVertexShader);
glCompileShader(hFragmentShader);
// Check for errors
if (!checkStatus(hVertexShader, glGetShaderiv, glGetShaderInfoLog, GL_COMPILE_STATUS)) {
glDeleteShader(hVertexShader);
glDeleteShader(hFragmentShader);
return (GLuint) NULL;
}
if (!checkStatus(hFragmentShader, glGetShaderiv, glGetShaderInfoLog, GL_COMPILE_STATUS)) {
glDeleteShader(hVertexShader);
glDeleteShader(hFragmentShader);
return (GLuint) NULL;
}
// Link them - assuming it works...
programID = glCreateProgram();
glAttachShader(programID, hVertexShader);
glAttachShader(programID, hFragmentShader);
glLinkProgram(programID);
// These are no longer needed
glDeleteShader(hVertexShader);
glDeleteShader(hFragmentShader);
// Make sure link worked too
if (!checkStatus(programID, glGetProgramiv, glGetProgramInfoLog, GL_LINK_STATUS)) {
glDeleteProgram(programID);
return (GLuint) NULL;
}
return programID;
}
int loadShader(GLuint program, GLenum type, const char *filename) {
GLuint shader;
char *shaderSrc = loadShaderSrc(filename);
shader = compileShader(type, shaderSrc);
if (!shader) return 1;
free(shaderSrc);
glAttachShader(program, shader);
return 0;
}
/**
* Tetraバッファの作成.
* @param model Tetraモデル.
*/
bool TetraBuffer::Create(const TetraModel* model)
{
bool r = true;
if (!model) {
fprintf(stderr,"Failed to create line: ");
return false;
}
m_model = model;
// load shader
const std::string& shadername = model->GetShader();
printf("%s\n", shadername.c_str());
r &= loadShaderSrc(shadername.c_str());
if (!r) {
fprintf(stderr,"[Error] A shader is not set\n");
return false;
}
BufferTetraData* tetra = model->GetTetra();
if (!tetra) {
fprintf(stderr,"[Error] Invalid tetra data\n");
return false;
}
const int vnum = tetra->Position()->GetNum();
m_vtxnum = vnum;
if (vnum == 0)
return false;
// Create tetra VB/IB
unsigned int normal_id, mat_id, tex_id, index_id;
CreateVBIB_SGL(vnum, tetra->Position()->GetBuffer(),
/* normal */ 0,
/* material(todo) */ 0,
/* texcoord */ 0,
/* numIndices */ 0,
/* indices */ 0,
m_vtx_id, normal_id, mat_id, tex_id, index_id);
createExtraBuffers(m_model);
cacheTextures(model);
return r;
}
/**
* Volumeバッファ作成
* @param model Volumeモデル
* @retval true 作成成功
* @retval false 作成失敗
*/
bool SparseVolumeBuffer::Create(const SparseVolumeModel* model)
{
bool r = true;
if (!model) {
fprintf(stderr,"Failed to create volume\n");
return false;
}
m_model = (SparseVolumeModel*)(model);
// load shader
const std::string& shadername = model->GetShader();
printf("%s\n", shadername.c_str());
r &= loadShaderSrc(shadername.c_str());
if (!r) {
fprintf(stderr,"[Error]Not set shader\n");
return false;
}
// make VolumeData
BufferSparseVolumeData* volume = model->GetSparseVolume();
if(!volume) {
fprintf(stderr,"[Error] BufferSparseVolumeData is NULL\n");
return false;
}
if(volume->VolumeBlocks().size() > 0) {
float sw = volume->Width();
float sh = volume->Height();
float sd = volume->Depth();
r = CreateSparseTexture3D(volume, model->GetClampToEdgeS(), model->GetClampToEdgeT(), model->GetClampToEdgeR());
MakeBox(sw,sh,sd);
} else {
fprintf(stderr,"[Error] Not load buffer\n");
}
cacheTextures(model);
return r;
}
void QTGLScene::initializeGL()
{
// setting up timer
m_time = QTime::currentTime();
// seting up gl
ngl::NGLInit::instance();
glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
glEnable(GL_DEPTH_TEST);
glEnable(GL_MULTISAMPLE);
//setting up vao
glGenVertexArrays(1, &m_vao);
glBindVertexArray(m_vao);
//setting up my scene
GLfloat data[] = {
-0.5f, 0.5f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f,//tl
0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f,//tr
-0.5f,-0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,//bl
0.5f,-0.5f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f //br
};
glGenBuffers(1, &m_vbo);
glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);
GLuint elements[] = {0, 1, 2, 2, 3, 1};
glGenBuffers(1, &m_ebo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(elements), elements, GL_STATIC_DRAW);
//shaders
GLuint vertShader = loadShaderSrc("shaders/basicVert.glsl", GL_VERTEX_SHADER);
GLuint fragShader = loadShaderSrc("shaders/basicFrag.glsl", GL_FRAGMENT_SHADER);
m_shaderProg = glCreateProgram();
glAttachShader(m_shaderProg, vertShader);
glAttachShader(m_shaderProg, fragShader);
glLinkProgram(m_shaderProg);
glUseProgram(m_shaderProg);
//linking shader and vert data
GLint posAttrib = glGetAttribLocation(m_shaderProg, "position");
glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 7*sizeof(GLfloat), 0);
glEnableVertexAttribArray(posAttrib);
GLint colAttrib = glGetAttribLocation(m_shaderProg, "colour");
glVertexAttribPointer(colAttrib, 3, GL_FLOAT, GL_FALSE, 7*sizeof(GLfloat), (void*)(2*sizeof(GLfloat)));
glEnableVertexAttribArray(colAttrib);
GLint uvAttrib = glGetAttribLocation(m_shaderProg, "uv");
glVertexAttribPointer(uvAttrib, 2, GL_FLOAT, GL_FALSE, 7*sizeof(GLfloat), (void*)(5*sizeof(GLfloat)));
glEnableVertexAttribArray(uvAttrib);
//texture
ngl::Image cat("textures/cat_01.jpg");
glGenTextures(1, &m_tex);
glBindTexture(GL_TEXTURE_2D, m_tex);
//loading texture data
std::cout << cat.getColour((GLuint)1200, (GLuint)2400).m_r << ", " <<
cat.getColour((GLuint)1200, (GLuint)2400).m_g << ", " <<
cat.getColour((GLuint)1200, (GLuint)2400).m_b << std::endl;
glTexImage2D(GL_TEXTURE, 0, GL_RGBA, cat.width(), cat.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, cat.getPixels());
//texture parameters
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// float borderCol[] = {1.0f, 1.0f, 0.0f, 1.0f};
// glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderCol);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glGenerateMipmap(GL_TEXTURE_2D);
m_timeUniform = glGetUniformLocation(m_shaderProg, "time");
startTimer(10);
}
