void ShaderManager::LoadShaderFiles(std::vector<std::string> &program_names)
{
std::string directory;
//Load and compile the shaders
directory = project_mode_string + "vertex_shaders.txt";
compileShaders(GL_VERTEX_SHADER, directory);
directory = project_mode_string + "fragment_shaders.txt";
compileShaders(GL_FRAGMENT_SHADER, directory);
//Link the programs
createPrograms();
//Get shader names to send back
SPIterator it = shader_programs.begin();
for(; it!= shader_programs.end(); it++)
{
program_names.push_back((*it).first);
}
}
void TopazSample::initRendering()
{
if (!GLEW_ARB_bindless_texture)
{
LOGI("This sample requires ARB_bindless_texture");
exit(EXIT_FAILURE);
}
bindlessVboUbo = GLEW_NV_vertex_buffer_unified_memory && requireExtension("GL_NV_uniform_buffer_unified_memory", false);
NvAssetLoaderAddSearchPath("Topaz/Topaz");
if(!requireMinAPIVersion(NvGfxAPIVersionGL4_4(), true))
{
exit(EXIT_FAILURE);
}
compileShaders("draw", "shaders/vertex.glsl", "shaders/fragment.glsl");
/*
If needed geometry shader:
compileShaders("geometry", "shaders/vertex.glsl", "shaders/fragment.glsl", "shaders/geometry.glsl");
*/
compileShaders("weightBlended", "shaders/vertex.glsl", "shaders/fragmentBlendOIT.glsl");
compileShaders("weightBlendedFinal", "shaders/vertexOIT.glsl", "shaders/fragmentFinalOIT.glsl");
// like as glClearBufferfv for nv_command_list
compileShaders("clear", "shaders/vertexOIT.glsl", "shaders/clear.glsl");
loadModel("models/background.obj", shaderPrograms["draw"]->getProgram());
loadModel("models/way3.obj", shaderPrograms["draw"]->getProgram(), true);
loadModel("models/way4.obj", shaderPrograms["draw"]->getProgram(), true);
loadModel("models/way5.obj", shaderPrograms["draw"]->getProgram());
loadModel("models/formular.obj", shaderPrograms["draw"]->getProgram());
textures.skybox = NvImage::UploadTextureFromDDSFile("textures/sky_cube.dds");
cmdlist.state.programIncarnation++;
CHECK_GL_ERROR();
}
void Application::update(float time, float timeSinceLastFrame) {
if (comp_shaders == 1){
compileShaders();
comp_shaders = 0;
}
if (m_w_pressed)
m_camera.Move(CameraDirection::FORWARD);
if (m_s_pressed)
m_camera.Move(CameraDirection::BACK);
if (m_a_pressed)
m_camera.Move(CameraDirection::LEFT);
if (m_d_pressed)
m_camera.Move(CameraDirection::RIGHT);
if (m_q_pressed)
m_camera.Move(CameraDirection::UP);
if (m_e_pressed)
m_camera.Move(CameraDirection::DOWN);
// Updating the camera matrices
m_camera.Update();
m_camera.GetMatricies(m_projmat, m_viewmat, m_worldmat);
m_inv_viewmat = glm::inverse(m_viewmat);
glBindBufferBase(GL_UNIFORM_BUFFER, 0, m_transformation_buffer);
glm::mat4* transform_matrices = (glm::mat4*)glMapBufferRange(GL_UNIFORM_BUFFER, 0, 3 * sizeof(glm::mat4), GL_MAP_WRITE_BIT);
transform_matrices[0] = m_projmat;
transform_matrices[1] = m_viewmat;
transform_matrices[2] = m_worldmat;
glUnmapBuffer(GL_UNIFORM_BUFFER);
// updating the lighting info
glBindBufferBase(GL_UNIFORM_BUFFER, 1, m_lighting_buffer);
glm::vec4* light_info = (glm::vec4*)glMapBufferRange(GL_UNIFORM_BUFFER, 0, 2 * sizeof(glm::vec4), GL_MAP_WRITE_BIT);
light_info[0] = glm::vec4(-1, -1, -1, 0);
light_info[1] = glm::vec4(m_camera.getPosition(), 1.0f);
glUnmapBuffer(GL_UNIFORM_BUFFER);
// Buffer 2 is reserved for the sample points of the Ambient Occlusion Rendering
// updating the general information for every object
glBindBufferBase(GL_UNIFORM_BUFFER, 3, m_general_buffer);
glm::vec4* general_info = (glm::vec4*)glMapBufferRange(GL_UNIFORM_BUFFER, 0, 2 * sizeof(glm::vec4), GL_MAP_WRITE_BIT);
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
void GLContext::realize(int width, int height)
{
width_ = width;
height_ = height;
glViewport(0, 0, width, height);
glDepthRange(0.0f, 1.0f);
initDefaultMap(defaultAmbientMap, 0x808080);
initDefaultMap(defaultDiffuseMap, 0x808080);
initDefaultMap(defaultSpecularMap, 0x808080);
initDefaultMap(defaultEmissiveMap, 0x000000);
initDefaultMap(defaultOpacityMap, 0xffffff);
initDefaultMap(defaultCustomMap, 0xffffff);
compileShaders();
}
void Shadertoy::loop() {
GLuint points_vbo;
glGenBuffers (1, &points_vbo);
glBindBuffer (GL_ARRAY_BUFFER, points_vbo);
glBufferData (GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
GLuint vao;
glGenVertexArrays (1, &vao);
glBindVertexArray (vao);
glBindBuffer (GL_ARRAY_BUFFER, points_vbo);
glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
if (!loadFromFile()) {
compileShaders(vertexSource, fragmentSource);
}
auto pos = glGetAttribLocation(program, "position");
glEnableVertexAttribArray (pos);
auto time = glGetUniformLocation(program, "global_time");
auto resolution = glGetUniformLocation(program, "resolution");
glUseProgram(program);
while (!glfwWindowShouldClose(win)) {
glfwGetWindowSize(win, &g_width, &g_heigth);
updateFpsCounter();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, g_width, g_heigth);
auto current_time = glfwGetTime();
glUniform1f(time, current_time);
glUniform2f(resolution, g_width, g_heigth);
if(recompile) {
loadFromFile();
glUseProgram(program);
recompile = false;
}
glBindVertexArray (vao);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 6);
glfwPollEvents();
glfwSwapBuffers(win);
}
}
static int initRenderOpenGLES2() {
if(!compileShaders(vertexShader, fragmentShader, &vertexShaderObjectId, &fragmentShaderObjectId, &programObjectId)) {
renderer.destroy();
return 0;
}
if(!setupAttribLocations(&programObjectId, &_positionSlot, &_colorSlot, &_projectionUniform, &_modelViewUniform)){
renderer.destroy();
return 0;
}
if(!setupVBOs(&vertexBuffer, &indexBuffer, sizeof(verticesES2), verticesES2, sizeof(indicesES2), indicesES2)) {
renderer.destroy();
return 0;
}
return 1;
}
void init(EntityManager<EntityManagerTypes...> *entityManagerRef, std::string resourcesPath) {
this->entityManagerRef = entityManagerRef;
spriteShaderProgramId = compileShaders("sprite shaders", SPRITE_VERTEX_SHADER, SPRITE_FRAGMENT_SHADER);
if (spriteShaderProgramId == -1) {
// we're boned :/
printf("OH NOES, SHADERS FAILED TO COMPILE...\n");
exit(1);
}
boundsSprite.init(spriteShaderProgramId, resourcesPath + "DebugBounds.png");
componentMask |= 1 << getTypeId<TransformComponent>();
componentMask |= 1 << getTypeId<AABBComponent>();
}
bool RadialBlur::createResources()
{
/* Delete old shader */
deleteResources();
/* Create new resources */
if (!compileShaders())
{
io::Log::error("Compiling shaders for radial-blur failed");
deleteResources();
return false;
}
/* Validate effect */
Valid_ = true;
return true;
}
void Application::create() {
compileShaders();
const float vertices[] = {
1.0f, -0.5f, -0.5f,
1.0f, -0.5f, 0.5f,
1.0f, 0.5f, 0.0f
};
const float colors[] = {
1.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f
};
glGenBuffers(1, &vertices_buffer);
glBindBuffer(GL_ARRAY_BUFFER, vertices_buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glGenBuffers(1, &colors_buffer);
glBindBuffer(GL_ARRAY_BUFFER, colors_buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW);
const float mirror_vertices[] = {
0.0f, -1.0f,-1.0f,
0.0f, -1.0f, 1.0f,
0.0f, 1.0f,-1.0f,
0.0f, 1.0f, 1.0f
};
const float mirror_colors[] = {
1.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f,
0.4f, 0.7f, 0.1f
};
glGenBuffers(1, &mirror_vertices_buffer);
glBindBuffer(GL_ARRAY_BUFFER, mirror_vertices_buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(mirror_vertices), mirror_vertices, GL_STATIC_DRAW);
glGenBuffers(1, &mirror_colors_buffer);
glBindBuffer(GL_ARRAY_BUFFER, mirror_colors_buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(mirror_colors), mirror_colors, GL_STATIC_DRAW);
}
void keyboard(GLFWwindow* window, int key, int scancode, int action, int mode)
{
Camera* cam = (Camera*)glfwGetWindowUserPointer(window);
if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
glfwSetWindowShouldClose(window, 1);
/*if (key == GLFW_KEY_SPACE)
cam->Position.y += .01f;*/
if (key == GLFW_KEY_LEFT_SHIFT || key == GLFW_KEY_RIGHT_SHIFT)
cam->Position.y -= .01f;
if (key == GLFW_KEY_P && action == GLFW_RELEASE)
printf("%f, %f, %f", cam->Position.x, cam->Position.y, cam->Position.z);
/*if (key == GLFW_KEY_X && action == GLFW_RELEASE)
wireframe = !wireframe;*/
if (key == GLFW_KEY_SPACE && action == GLFW_RELEASE)
{
screenShader = compileShaders("../OpenGL3-3/shaders/advanced/fbo.vert.glsl", "../OpenGL3-3/shaders/advanced/fbo.frag.glsl");
std::cout << "Recompiled" << std::endl;
}
}
void initializeText(int width,int height){
screenWidth = width;
screenHeight = height;
// Initialize VBO
glGenBuffers(1, &Text2DVertexBufferID);
glGenBuffers(1, &Text2DUVBufferID);
// Initialize Shader
Text2DShaderID = compileShaders("TextPixelShader.glsl","TextVertexShader.glsl");
// Initialize uniforms' IDs
Text2DUniformID = glGetUniformLocation(Text2DShaderID, "basic_texture");
Text2DresID = glGetUniformLocation(Text2DShaderID, "resolution");
}
GLuint loadShaders(const char *vertFileName, const char *fragFileName)
// TO DO: Add geometry shader support
{
char *vs, *fs;
GLuint p;
vs = readFile((char *)vertFileName);
fs = readFile((char *)fragFileName);
if ((vs==NULL)||(fs==NULL)) // bug fixed 120126
{
printf("Loading shaders failed.\n");
return 0;
// Some better error reporting desired.
}
p = compileShaders(vs, fs);
if (vs != NULL) free(vs);
if (fs != NULL) free(fs);
return p;
}
GLuint loadShaders(const char *vertFileName, const char *fragFileName)
// TO DO: Add geometry shader support
{
// const
char *vs, *fs;
GLuint p;
vs = readFile((char *)vertFileName);
fs = readFile((char *)fragFileName);
if ((vs==NULL)||(fs==NULL))
{
printf("Loading shaders failed.\n");
return 0;
}
p = compileShaders(vs, fs);
if (vs != NULL) free(vs);
if (fs != NULL) free(fs);
return p;
}
/* Parameter constructor: specified the shader file path*/
ShaderProgram::ShaderProgram(const GLchar * vertex_file_path,const GLchar * fragment_file_path)
:m_uiProgramID(-1)
,m_invalidated(false)
,m_vertexShaderFile(vertex_file_path)
,m_fragmentShaderFile(fragment_file_path)
,m_isCompiled(false)
,m_vertexShaderHandle(-1)
,m_fragmentShaderHandle(-1)
,m_uniformNames(NULL)
,m_iUniformLocation(NULL)
,m_attributeNames(NULL)
,m_iAttributeLocation(NULL)
{
compileShaders(m_vertexShaderFile,m_fragmentShaderFile);
if (isCompiled())
{
fetchAttributes();
fetchUniforms();
addManagedShader();
}
}
void GLWidget::startGlutLoop()
{
glClearColor(0.0f/*.84*/, 0.0f/*.84*/, 0.0f/*.84*/, 0.0f);
char* version = (char*)glGetString(GL_VERSION);
fprintf(stdout, "Version: '%s'\n", version);
/**
* Create vertex buffer: glGenBuffers, glBindBuffer, glBufferData.
*/
createVertexBuffer();
/**
* Read shaders from file, compile, verify and add to shader program.
*/
compileShaders();
/**
* Start the rendering loop.
*/
glutMainLoop();
}
int main(int argc, char ** argv)
{
initGlutAndCreateWindow(argc, argv);
initGlew();
// compile and link shader programs, also sets program global variable
openGLProgramObject = compileShaders();
// get location/handle for coord variable in the vertex shader
coordAttribute = getAttributeLocation("coord");
// set the render function to continually call in the main loop
glutDisplayFunc(render);
// glClearColor only sets state, does not actually clear anything
glClearColor(1.0f, 0.0f, 0.0f, 1.0f);
// done with setup, now constantly loop and call render function
glutMainLoop();
return 1;
}
Program::Program(bool useNormals/*=false*/,
bool useColors/*=false*/,
bool useTextures/*=false*/) {
needsNormals = useNormals;
needsColors = useColors;
needsTextures = useTextures;
light=NULL;
view=NULL;
projection=NULL;
if (compileShaders()) {
//continue to find locations necessary
if(loadLocations()) {
//success, what else do we need to do?
} else {
std::cerr<<"Failed to locate value in program."<<std::endl;
exit(EXIT_FAILURE);
}
} else {
//error
std::cerr<<"Failed to compile shaders for program."<<std::endl;
exit(EXIT_FAILURE);
}
}
/*Non-parameter constructor:use the default shader*/
ShaderProgram::ShaderProgram()
:m_uiProgramID(-1)
,m_invalidated(false)
,m_vertexShaderFile("VertexShader.glsl")
,m_fragmentShaderFile("FragmentShader.glsl")
,m_isCompiled(false)
,m_vertexShaderHandle(-1)
,m_fragmentShaderHandle(-1)
,m_uniformNames(NULL)
,m_iUniformLocation(NULL)
,m_attributeNames(NULL)
,m_iAttributeLocation(NULL)
,m_iAttributeSize(0)
,m_iUniformSize(0)
{
compileShaders(m_vertexShaderFile,m_fragmentShaderFile);
if (isCompiled())
{
fetchAttributes();
fetchUniforms();
addManagedShader();
}
}
SpriteRender::SpriteRender(GLuint pos, GLuint col, int n, CL* cli, RTPSSettings* _settings):Render(pos,col,n,cli,_settings)
{
string path(GLSL_SOURCE_DIR);
string filename = settings->GetSettingAs<string>("render_texture");
//path += "../../../sprites/fsu_seal.jpg";
//path += "../../../sprites/firejet_blast.png"; //borrowed from http://homepage.mac.com/nephilim/sw3ddev/additive_blending.html
path = "../../sprites/" + filename;
//path += "../../../sprites/firejet_smoke.png";
//path += "../../../sprites/tomek.jpg";
//path += "../../../sprites/enjalot.jpg";
printf("LOAD TEXTURE!!!!!!!!!!!!!!\n");
printf("filename: %s\n", filename.c_str());
printf("path: %s\n", path.c_str());
settings->printSettings();
loadTexture(path, "texture");
//string vert(GLSL_BIN_DIR);
//string frag(GLSL_BIN_DIR);
//vert+="/sphere_vert.glsl";
//frag+="/sphere_tex_frag.glsl";
string vert = shader_source_dir + "/sprite_vert.glsl";
string frag = shader_source_dir + "/" + settings->GetSettingAs<string>("render_frag_shader");
glsl_program[SPHERE_SHADER] = compileShaders(vert.c_str(),frag.c_str());
}
int main() {
sf::RenderWindow mainWindow(
sf::VideoMode( 640, 480 ),
"ne0ndrag0n area51 - SFML & OpenGL Training",
sf::Style::Close
);
mainWindow.setVerticalSyncEnabled( true );
// Set this to true so GLEW knows to use a modern approach to retrieving function pointers and extensions
glewExperimental = GL_TRUE;
// Initialize GLEW to setup the OpenGL Function pointers
glewInit();
GLuint program = compileShaders();
glViewport( 0, 0, 640, 480 );
GLfloat vertices[] = {
0.5f, 0.5f, 0.0f, // Top Right
0.5f, -0.5f, 0.0f, // Bottom Right
-0.5f, -0.5f, 0.0f, // Bottom Left
-0.5f, 0.5f, 0.0f // Top Left
};
GLuint indicies[] = { 0, 1, 3, 1, 2, 3 };
GLuint VBO, VAO, EBO;
glGenVertexArrays( 1, &VAO );
glGenBuffers( 1, &VBO );
glGenBuffers( 1, &EBO );
glBindVertexArray( VAO );
glBindBuffer( GL_ARRAY_BUFFER, VBO );
glBufferData( GL_ARRAY_BUFFER, sizeof( vertices ), vertices, GL_STATIC_DRAW );
glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof( GLfloat ), ( GLvoid* ) 0 );
glEnableVertexAttribArray( 0 );
glBindBuffer( GL_ARRAY_BUFFER, 0 ); // Note that this is allowed, the call to glVertexAttribPointer registered VBO as the currently bound vertex buffer object so afterwards we can safely unbind
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, EBO );
glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof( indicies ), indicies, GL_STATIC_DRAW );
glBindVertexArray( 0 );
while( mainWindow.isOpen() ) {
mainWindow.clear( sf::Color::Black );
glUseProgram( program );
glBindVertexArray( VAO );
glDrawElements( GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0 );
glBindVertexArray( 0 );
mainWindow.display();
sf::Event event;
while( mainWindow.pollEvent( event ) ) {
if( event.type == sf::Event::Closed ) {
mainWindow.close();
glDeleteVertexArrays( 1, &VAO );
glDeleteBuffers( 1, &VBO );
}
}
}
return 0;
}
KawaiiGL::KawaiiGL(QWidget *parent)
: QMainWindow(parent), m_kView(NULL), m_edDlg(NULL), m_doc(NULL)
{
ui.setupUi(this);
m_sett.loadFromReg();
connect(&m_sett, SIGNAL(changed()), &m_sett, SLOT(storeToReg()));
setWindowTitle("KawaiiGL");
show(); // needed becase we're creating display lists in the c'tor.
QDir::setCurrent(EXAMPLES_DIR); // we're reading the config and textures from there
m_progMenu = new QMenu(this);
m_modelsMenu = new QMenu(this);
m_doc = new Document(this); // adds to the menus
m_progMenu->addSeparator();
QAction *loadFromFileAct = m_progMenu->addAction("From file...");
connect(loadFromFileAct, SIGNAL(triggered(bool)), m_doc, SLOT(loadProgramFile()));
m_kView = new T2GLWidget(this, m_doc);
setCentralWidget(m_kView);
m_edDlg = new KwEdit(this, m_sett.disp, m_doc, m_kView); // need the view for tracking vec2s
m_edDlg->show();
m_edDlg->move(pos() + QPoint(width() - 20, 30));
m_control = new MyDialog(this);
QBoxLayout *control_l = new QVBoxLayout();
m_control->setLayout(control_l);
control_l->setMargin(0);
control_l->setSpacing(0);
QTabWidget *tabs = new QTabWidget();
control_l->addWidget(tabs);
m_contDlg = new ControlPanel(&m_sett.disp, this, m_doc, m_kView);
tabs->addTab(m_contDlg, "Config");
m_browse = new ProjBrowser(this, m_doc);
tabs->addTab(m_browse, "Browser");
tabs->setCurrentWidget(m_browse);
//tabs->setCurrentIndex(m_sett.gui.configWindowTab);
tabs->setCurrentIndex(0);
m_control->show();
m_control->move(pos() + QPoint(-30, 20));
m_control->resize(100, 100); // make it as small as possible
m_doc->model()->m_errAct = new ErrorHighlight(m_edDlg);
connect(m_kView, SIGNAL(message(const QString&)), this, SLOT(message(const QString&)));
connect(m_edDlg, SIGNAL(changedModel(DocSrc*)), m_doc, SLOT(calc(DocSrc*)));
connect(m_edDlg, SIGNAL(updateShaders()), m_doc, SLOT(compileShaders()));
// connect(m_kView, SIGNAL(decompProgChanged(const QString&)), m_edDlg, SLOT(curChanged(const QString&)));
connect(m_doc, SIGNAL(loaded()), m_kView, SLOT(newModelLoaded()));
//connect(m_doc, SIGNAL(loaded()), m_edDlg, SLOT(doVarsUpdate())); // parsed new text. vars defs may be wrong
connect(m_doc, SIGNAL(modelChanged()), m_kView, SLOT(updateGL()));
connect(m_doc, SIGNAL(progChanged()), m_kView, SLOT(redoFrameBuffers()));
connect(m_kView, SIGNAL(changedFBOs()), m_contDlg, SLOT(updateTexEdits()));
connect(m_kView, SIGNAL(makeGradientTex(int, const QString&)), m_contDlg, SLOT(externalGradient(int, const QString&)));
connect(m_doc, SIGNAL(progParamChanged()), m_kView, SLOT(updateGL()));
connect(m_doc, SIGNAL(addModelLine(const QString&)), m_edDlg, SLOT(addModelLine(const QString&)));
connect(m_contDlg, SIGNAL(changedRend()), m_doc, SLOT(calcNoParse())); // passes update
connect(m_contDlg, SIGNAL(changedFont()), m_kView, SLOT(updateCoordFont()));
connect(m_contDlg, SIGNAL(doUpdate()), m_kView, SLOT(updateGL())); // passes update
connect(m_contDlg, SIGNAL(resetView()), m_kView, SLOT(resetState()));
connect(m_contDlg, SIGNAL(resetLight()), m_kView, SLOT(resetLight()));
connect(m_contDlg, SIGNAL(changedTexFile(int)), m_kView, SLOT(setTexture(int)));
// connect(m_contDlg, SIGNAL(reassertTex(int)), m_kView, SLOT(rebindTexture(int)));
connect(m_contDlg, SIGNAL(saveMesh()), m_doc, SLOT(calcSave()));
connect(m_browse, SIGNAL(openDocText(DocElement*)), m_edDlg, SLOT(addPage(DocElement*)) );
connect(m_browse, SIGNAL(openPassConf(DocElement*)), m_edDlg, SLOT(addPage(DocElement*)) );
connect(m_browse, SIGNAL(commitGuiData()), m_edDlg, SLOT(commitAll()));
connect(m_doc, SIGNAL(goingToClearProg()), m_edDlg, SLOT(clearingProg()));
connect(m_doc, SIGNAL(didReadProg(ProgKeep*)), m_edDlg, SLOT(readProg(ProgKeep*)) );
connect(m_doc, SIGNAL(didReadProg(ProgKeep*)), m_browse, SLOT(readProg(ProgKeep*)) );
connect(m_doc, SIGNAL(didReadModel(DocSrc*)), m_browse, SLOT(readModel()) );
connect(m_doc, SIGNAL(didReadModel(DocSrc*)), m_edDlg, SLOT(readModel(DocSrc*)));
connect(&m_sett.disp.bVtxNormals, SIGNAL(changed()), m_doc, SLOT(calcNoParse())); // TBD - this is bad.
connect(m_contDlg->ui.clipSlider, SIGNAL(valueChanged(int)), m_kView, SLOT(setClipValue(int)));
m_kView->setContextMenuPolicy(Qt::ActionsContextMenu);
QPushButton *viewBot = new QPushButton("View");
viewBot->setMaximumSize(60, 19);
statusBar()->addPermanentWidget(viewBot);
QMenu *view = new QMenu("View");
viewBot->setMenu(view);
QPushButton *fpsBot = new QPushButton(QIcon(":/images/arrow-circle.png"), QString());
fpsBot->setMaximumSize(20, 19);
statusBar()->addPermanentWidget(fpsBot);
(new CheckBoxIn(&m_sett.disp.fullFps, fpsBot))->reload();
QCheckBox *vSyncBox = new QCheckBox("vSync");
vSyncBox->setMaximumHeight(19);
statusBar()->addPermanentWidget(vSyncBox);
(new CheckBoxIn(&m_sett.disp.vSync, vSyncBox))->reload();
QAction *confVis = new QAction("Display", view);
view->addAction(confVis);
m_control->connectAction(confVis);
QAction *editVis = new QAction("Edit", view);
view->addAction(editVis);
m_edDlg->connectAction(editVis);
m_kView->connectedInit();
processCmdArgs();
}
ForwardProgram::ForwardProgram(const std::string& vertexPath, const std::string& fragmentPath, const std::string& geometryPath) : ShaderProgram() {
compileShaders(vertexPath, fragmentPath, geometryPath);
glUseProgram(mProgramID);
glUseProgram(0);
}
GLuint ShaderUtil::compileShaders(std::string name){
return compileShaders(name +".vert",name + ".frag");
}
void Background::setShaders()
{
program = compileShaders("./shaders/background.vert.glsl", "./shaders/background.frag.glsl");
}
void Tutorial::Run()
{
#ifdef __TUT_VERSION
#if __TUT_VERSION >= 17
if (_tutorialID >= 17) {
char windowName[255];
sprintf(&windowName[0], "Tutorial %d", _tutorialID);
if (!GLUTBackendCreateWindow(WINDOW_WIDTH, WINDOW_HEIGHT, false, windowName)) {
return;
}
#if __TUT_VERSION == 17
_tutorial = new Tutorial17();
#elif __TUT_VERSION == 18
_tutorial = new Tutorial18();
#elif __TUT_VERSION == 19
_tutorial = new Tutorial19();
#elif __TUT_VERSION == 20
_tutorial = new Tutorial20();
#elif __TUT_VERSION == 21
_tutorial = new Tutorial21();
#elif __TUT_VERSION == 22
_tutorial = new Tutorial22();
#elif __TUT_VERSION == 23
_tutorial = new Tutorial23();
#endif
if (!_tutorial->Init(pVSFileName, pFSFileName)) {
return;
}
char* version = (char*)glGetString(GL_VERSION);
fprintf(stdout, "Version: '%s'\n", version);
_tutorial->Run();
delete _tutorial;
return;
}
#endif
#endif
initGlut();
initGlew();
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
if (_tutorialID == 16) {
glFrontFace(GL_CW);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
}
char* version = (char*)glGetString(GL_VERSION);
fprintf(stdout, "Version: '%s'\n", version);
///
/// Create vertex buffer: glGenBuffers, glBindBuffer, glBufferData.
///
createVertexBuffer();
///
/// Create the index buffer: glGenBuffers, glBindBuffer, glBufferData.
///
createIndexBuffer();
///
/// Read shaders from file, compile, verify and add to shader program.
///
compileShaders();
if (_tutorialID == 16) {
glUniform1i(_gSampler, 0);
_pTexture = new Texture(GL_TEXTURE_2D, "/home/lparkin/Projects/S3/OpenGlDirsProject/LearnOpenGL-nonQt/Project/Content/test.png");
if (!_pTexture->Load()) {
exit(1);
}
}
///
/// Setup the perspective projection information.
///
_gPersProjInfo.FOV = 60.0f;
_gPersProjInfo.Height = WINDOW_HEIGHT_1_14;
_gPersProjInfo.Width = WINDOW_WIDTH_1_14;
_gPersProjInfo.zNear = 1.0f;
_gPersProjInfo.zFar = 100.0f;
///
/// Start the rendering loop.
///
glutMainLoop();
}
void GpuProgramManager::compileAllShaders(bool p_ForceRecompile,
bool p_UpdateResources)
{
compileShaders(_activeRefs, p_ForceRecompile, p_UpdateResources);
}
bool Shadertoy::loadFromFile() {
auto vSource = loadFile("shaders/s.vert");
auto fSource = loadFile("shaders/s.frag");
return compileShaders(vSource, fSource);
}
void Application::create() {
compileShaders();
int dim = static_cast<int>(glm::ceil(glm::sqrt(NUM_FRAME_BUFFERS)));
for (int idx = 0; idx < NUM_FRAME_BUFFERS; idx++){
float width = 400.0f;
glm::vec3 offset((idx % dim) / static_cast<float>(dim), 0.0f, idx / static_cast<float>(dim));
glm::float32 offset_scale = 20.0f;
PlyDataReader::getSingletonPtr()->renew();
#define PORSCHE
#ifdef PORSCHE
PlyDataReader::getSingletonPtr()->readDataInfo("big_porsche.ply", nullptr, 0);
#else
PlyDataReader::getSingletonPtr()->readDataInfo("happy.ply", nullptr, 0);
#endif
unsigned int nVertices = PlyDataReader::getSingletonPtr()->getNumVertices();
unsigned int nFaces = PlyDataReader::getSingletonPtr()->getNumFaces();
//#define GROUND
#ifdef GROUND
vertices[idx].resize(nVertices + 4);
indices[idx].resize(nFaces * 3 + 6);
#else
vertices[idx].resize(nVertices);
indices[idx].resize(nFaces * 3);
#endif
PlyDataReader::getSingletonPtr()->readData(vertices[idx].data(), indices[idx].data());
glm::vec3 center;
glm::float32 min_y = vertices[idx][0].pos.y;
size_t i = 0;
for (; i < vertices[idx].size() - 4; i++) {
center += vertices[idx][i].pos + offset_scale * offset;
min_y = glm::min(min_y, vertices[idx][i].pos.y);
}
center /= vertices[idx].size();
#ifdef GROUND
vertices[idx][nVertices + 0].pos = glm::vec3(-width, min_y, -width) + offset_scale * offset;
vertices[idx][nVertices + 0].normal = glm::vec3(0, 1, 0);
vertices[idx][nVertices + 1].pos = glm::vec3(-width, min_y, width) + offset_scale * offset;
vertices[idx][nVertices + 1].normal = glm::vec3(0, 1, 0);
vertices[idx][nVertices + 2].pos = glm::vec3(width, min_y, -width) + offset_scale * offset;
vertices[idx][nVertices + 2].normal = glm::vec3(0, 1, 0);
vertices[idx][nVertices + 3].pos = glm::vec3(width, min_y, width) + offset_scale * offset;
vertices[idx][nVertices + 3].normal = glm::vec3(0, 1, 0);
indices[idx][3 * nFaces + 0] = nVertices + 0;
indices[idx][3 * nFaces + 1] = nVertices + 1;
indices[idx][3 * nFaces + 2] = nVertices + 2;
indices[idx][3 * nFaces + 3] = nVertices + 2;
indices[idx][3 * nFaces + 4] = nVertices + 1;
indices[idx][3 * nFaces + 5] = nVertices + 3;
#endif
for (size_t i = 0; i < vertices[idx].size(); i++) {
vertices[idx][i].pos -= center;
}
for (size_t i = 0; i < vertices[idx].size(); i++) {
//vertices[i].pos *= 30.0;
#ifdef PORSCHE
vertices[idx][i].pos *= 0.4;
#else
vertices[i].pos *= 1.0;
#endif
}
glGenBuffers(1, &vertices_buffer[idx]);
glBindBuffer(GL_ARRAY_BUFFER, vertices_buffer[idx]);
glBufferData(GL_ARRAY_BUFFER, vertices[idx].size() * sizeof(PlyObjVertex), vertices[idx].data(), GL_STATIC_DRAW);
glGenBuffers(1, &indices_buffer[idx]);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices_buffer[idx]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices[idx].size() * sizeof(unsigned int), indices[idx].data(), GL_STATIC_DRAW);
}
}
void Shader::compileAndLink(const GLchar *vertexSource, const GLchar *fragmentSource ) {
compileShaders(vertexSource, fragmentSource);
linkProgram();
}
int main()
{
GLsizei multiSamples = 8;
GLFWwindow* window = initWindow();
if (window == nullptr)
{
std::cout << "Unable to initialize window." << std::endl;
return -1;
}
// Start the timer
GLfloat deltaTime, lastFrame, currentFrame;
lastFrame = 0.0f;
currentFrame = 0.0f;
// Setup the viewport;
GLfloat screenWidth = 800, screenHeight = 600;
glViewport(0, 0, screenWidth, screenHeight);
// Setup Camera
Camera cam = initCamera();
glfwSetWindowUserPointer(window, &cam);
// Load Models
Model planet = Model("./Models/planet/planet.obj");
Model asteroid = Model("./Models/rock/rock.obj");
// Load and Compile Shaders
GLuint program = compileShaders("../OpenGL3-3/shaders/advanced/instance/basic.vert.glsl", "../OpenGL3-3/shaders/advanced/instance/basic.frag.glsl");
GLuint modelShader = compileShaders("../OpenGL3-3/shaders/newModel/model.vert.glsl", "../OpenGL3-3/shaders/newModel/model.frag.glsl");
GLuint instancedModelShader = compileShaders("../OpenGL3-3/shaders/newModel/imodel.vert.glsl", "../OpenGL3-3/shaders/newModel/model.frag.glsl");
GLuint frameBufferShader = compileShaders("../OpenGL3-3/shaders/advanced/fbo.vert.glsl", "../OpenGL3-3/shaders/advanced/fbo.frag.glsl");
// Setup MVP model
glm::mat4 model, view, proj;
view = cam.GetViewMatrix();
proj = glm::perspective(glm::radians(45.0f), (float)screenWidth / (float)screenHeight, 0.1f, 1000.0f);
#pragma region quad
GLfloat quadVertices[] = {
// Positions // Colors
-0.05f, 0.05f, 1.0f, 0.0f, 0.0f,
0.05f, -0.05f, 0.0f, 1.0f, 0.0f,
-0.05f, -0.05f, 0.0f, 0.0f, 1.0f,
-0.05f, 0.05f, 1.0f, 0.0f, 0.0f,
0.05f, -0.05f, 0.0f, 1.0f, 0.0f,
0.05f, 0.05f, 0.0f, 1.0f, 1.0f
};
glm::vec2 translations[100];
int index = 0;
GLfloat offset = 0.1f;
for (GLint y = -10; y < 10; y += 2)
{
for (GLint x = -10; x < 10; x += 2)
{
glm::vec2 translation;
translation.x = (GLfloat)x / 10.0f + offset;
translation.y = (GLfloat)y / 10.0f + offset;
translations[index++] = translation;
}
}
GLfloat fboQuad[] =
{
-1.0f, 1.0f, 0.0f, 1.0f,
-1.0f, -1.0f, 0.0f, 0.0f,
1.0f, -1.0f, 1.0f, 0.0f,
1.0f, -1.0f, 1.0f, 0.0f,
1.0f, 1.0f, 1.0f, 1.0f,
-1.0f, 1.0f, 0.0f, 1.0f
};
#pragma endregion
GLuint VBO, VAO, instanceVBO;
glGenVertexArrays(1, &VAO);
glGenBuffers(1, &VBO);
glGenBuffers(1, &instanceVBO);
glBindBuffer(GL_ARRAY_BUFFER, instanceVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(glm::vec2) * 100, &translations[0], GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
// Create the Framebuffer
GLuint FBO;
glGenFramebuffers(1, &FBO);
glBindFramebuffer(GL_FRAMEBUFFER, FBO);
GLuint texture;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, texture);
glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, multiSamples, GL_RGB, screenWidth, screenHeight, GL_TRUE);// , GL_RGB, 800, 600, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, texture, 0);
GLuint sampleRBO;
glGenRenderbuffers(1, &sampleRBO);
glBindRenderbuffer(GL_RENDERBUFFER, sampleRBO);
glRenderbufferStorageMultisample(GL_RENDERBUFFER, multiSamples, GL_DEPTH24_STENCIL8, screenWidth, screenHeight);
glBindRenderbuffer(GL_RENDERBUFFER, 0);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, sampleRBO);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
std::cout << "FRAMEBUFFER INCOMPLETE!" << std::endl;
glBindFramebuffer(GL_FRAMEBUFFER, 0);
GLuint regularFBO;
glGenFramebuffers(1, ®ularFBO);
glBindFramebuffer(GL_FRAMEBUFFER, regularFBO);
GLuint tex;
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, screenWidth, screenHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_2D, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
std::cout << "FRAMEBUFFER 2 INCOMPLETE!" << std::endl;
glBindFramebuffer(GL_FRAMEBUFFER, 0);
GLuint fboVAO, fboVBO;
glGenVertexArrays(1, &fboVAO);
glGenBuffers(1, &fboVBO);
glBindVertexArray(fboVAO);
glBindBuffer(GL_ARRAY_BUFFER, fboVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(fboQuad), fboQuad, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)(2*sizeof(GLfloat)));
glBindVertexArray(0);
glBindVertexArray(VAO);
{
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(quadVertices), quadVertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 5, (GLvoid*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 5, (GLvoid*)(sizeof(GLfloat) * 2));
glEnableVertexAttribArray(2);
glBindBuffer(GL_ARRAY_BUFFER, instanceVBO);
glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (GLvoid*)0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glVertexAttribDivisor(2, 1);
}
glBindVertexArray(0);
std::cout << sizeof(glm::mat4) << std::endl;
const int amount = 100000;
glm::mat4* modelMats;
modelMats = new glm::mat4[amount];
srand(glfwGetTime());
GLfloat radius = 150.0f;
offset = 25.0f;
for (GLuint i = 0; i < amount; i++)
{
glm::mat4 model;
GLfloat angle = (GLfloat)i / (GLfloat)amount * 360.0f;
GLfloat displacement = (rand() % (GLint)(2 * offset)) / 100.0f - offset;
GLfloat x = sin(angle) * radius + displacement;
displacement = (rand() % (GLint)(2 * offset * 100)) / 100.0f - offset;
GLfloat y = displacement * 0.4f;
displacement = (rand() % (GLint)(2 * offset * 100)) / 100.0f - offset;
GLfloat z = cos(angle) * radius + displacement;
model = glm::translate(model, glm::vec3(x, y, z));
GLfloat scale = (rand() % 20) / 100.0f + 0.05f;
model = glm::scale(model, glm::vec3(scale));
GLfloat rotAngle = (rand() % 360);
model = glm::rotate(model, rotAngle, glm::vec3(0.4f, 0.6f, 0.8f));
modelMats[i] = model;
}
for (GLuint i = 0; i < asteroid.meshes.size(); i++)
{
GLuint VAO = asteroid.meshes[i].VAO;
GLuint buffer;
glBindVertexArray(VAO);
glGenBuffers(1, &buffer);
glBindBuffer(GL_ARRAY_BUFFER, buffer);
glBufferData(GL_ARRAY_BUFFER, amount * sizeof(glm::mat4), &modelMats[0], GL_STATIC_DRAW);
GLsizei vec4Size = sizeof(glm::vec4);
glEnableVertexAttribArray(3);
glVertexAttribPointer(3, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (GLvoid*)0);
glEnableVertexAttribArray(4);
glVertexAttribPointer(4, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (GLvoid*)(vec4Size));
glEnableVertexAttribArray(5);
glVertexAttribPointer(5, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (GLvoid*)(2 * vec4Size));
glEnableVertexAttribArray(6);
glVertexAttribPointer(6, 4, GL_FLOAT, GL_FALSE, 4 * vec4Size, (GLvoid*)(3 * vec4Size));
glVertexAttribDivisor(3, 1);
glVertexAttribDivisor(4, 1);
glVertexAttribDivisor(5, 1);
glVertexAttribDivisor(6, 1);
glBindVertexArray(0);
}
glUseProgram(modelShader);
glUniformMatrix4fv(glGetUniformLocation(modelShader, "projection"), 1, GL_FALSE, glm::value_ptr(proj));
glUseProgram(instancedModelShader);
glUniformMatrix4fv(glGetUniformLocation(instancedModelShader, "projection"), 1, GL_FALSE, glm::value_ptr(proj));
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
while (!glfwWindowShouldClose(window))
{
glfwPollEvents();
currentFrame = glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
glBindFramebuffer(GL_FRAMEBUFFER, FBO);
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
handleMovement(window, deltaTime);
glUseProgram(instancedModelShader);
glUniformMatrix4fv(glGetUniformLocation(instancedModelShader, "view"), 1, GL_FALSE, glm::value_ptr(cam.GetViewMatrix()));
glUseProgram(modelShader);
glUniformMatrix4fv(glGetUniformLocation(modelShader, "view"), 1, GL_FALSE, glm::value_ptr(cam.GetViewMatrix()));
glm::mat4 model;
model = glm::translate(model, glm::vec3(0.0f, -5.0f, 0.0f));
model = glm::scale(model, glm::vec3(4.0f));
glUniformMatrix4fv(glGetUniformLocation(modelShader, "model"), 1, GL_FALSE, glm::value_ptr(model));
planet.draw(modelShader);
glUseProgram(instancedModelShader);
glBindTexture(GL_TEXTURE_2D, asteroid.textures_loaded[0].id);
for (GLuint i = 0; i < asteroid.meshes.size(); i++)
{
glBindVertexArray(asteroid.meshes[i].VAO);
glDrawElementsInstanced(GL_TRIANGLES, asteroid.meshes[i].vertices.size(), GL_UNSIGNED_INT, 0, amount);
glBindVertexArray(0);
}
glBindTexture(GL_TEXTURE_2D, 0);
glBindFramebuffer(GL_READ_FRAMEBUFFER, FBO);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, regularFBO);
glBlitFramebuffer(0, 0, screenWidth, screenHeight, 0, 0, screenWidth, screenHeight, GL_COLOR_BUFFER_BIT, GL_NEAREST);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
glDisable(GL_DEPTH_TEST);
glUseProgram(frameBufferShader);
glBindVertexArray(fboVAO);
glBindTexture(GL_TEXTURE_2D, tex);
//glUniform1i(glGetUniformLocation(frameBufferShader, "myTexture"), 0);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindVertexArray(0);
glBindTexture(GL_TEXTURE_2D, 0);
glfwSwapBuffers(window);
}
glfwTerminate();
return 0;
}
