bool APP_OBJLoader::Start()
{
m_appName = "OBJ loader";
Gizmos::create();
GameCam = new Camera();
//std::string err = tinyobj::LoadObj(shapes, materials, "./assets/stanford_objs/bunny.obj");
//loads obj from file and creates a binary version, loads from that if it exists
// objCtrl = new OBJIO();
//
// objCtrl->ReadObj("./assets/stanford_objs/bunny.obj", "OBJbunny.dat", &shapes);
createShaders(); //created the program and loads shaders
//createOpenGLBuffers(shapes);
isLoaded = true;
return true; //not being used in this lesson
}
int main(int argc, char *argv[]){
clock_0 = clock();
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH | GLUT_ALPHA);
glutCreateWindow("Demo");
glutInitWindowPosition(20, 20);
glutInitWindowSize(800, 600);
glewInit();
gl_init();
glutIdleFunc(gl_anim);
glutDisplayFunc(gl_draw);
glutReshapeFunc(reshape);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutKeyboardFunc(keyboard);
createShaders();
glutMainLoop();
}
int main (int argc, char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH);
glutInitWindowSize(800, 600);
glutCreateWindow("Index Buffers");
glutReshapeFunc(changeViewport);
glutDisplayFunc(render);
glewInit();
/*set up the matricies*/
initMatrices();
// Make a shader
shaderProgramID = createShaders();
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
// Create the buffer, but don't load anything yet
glBufferData(GL_ARRAY_BUFFER, sizeof(colors)*sizeof(vertices), NULL, GL_STATIC_DRAW);
// Load the vertex points
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices);
// Load the colors right after that
glBufferSubData(GL_ARRAY_BUFFER, sizeof(vertices),sizeof(colors), colors);
glGenBuffers(1, &indexBufferID);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
positionID = glGetAttribLocation(shaderProgramID, "s_vPosition");
colorID = glGetAttribLocation(shaderProgramID, "s_vColor");
perspectiveMatrixID = glGetUniformLocation(shaderProgramID, "mP");
viewMatrixID = glGetUniformLocation(shaderProgramID, "mV");
modelMatrixID = glGetUniformLocation(shaderProgramID, "mM");
glVertexAttribPointer(positionID, 3, GL_FLOAT, GL_FALSE, 0, 0);
glVertexAttribPointer(colorID, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(vertices)));
glutKeyboardFunc(keyboard);
glUseProgram(shaderProgramID);
glEnableVertexAttribArray(positionID);
glEnableVertexAttribArray(colorID);
glutSpecialFunc(SpecialInput);
printWelcome();
glutMainLoop();
return 0;
}
bool ScreenSpaceFramebuffer::initialize(){
_originalViewportSize = OsEng.windowWrapper().currentWindowResolution();
createPlane();
createShaders();
createFragmentbuffer();
return isReady();
}
bool ScreenSpaceImage::initialize() {
_originalViewportSize = OsEng.windowWrapper().currentWindowResolution();
createPlane();
createShaders();
updateTexture();
return isReady();
}
void RD_ShaderProgramFxDX11::load()
{
D3DPREAMBLE;
if ( (_i->_vertShader != 0) ||
(_i->_fragShader != 0) )
{
return;
}
D3D11_BUFFER_DESC desc;
memset (&desc, 0, sizeof(desc));
// Assign constant buffer.
desc.Usage = D3D11_USAGE_DEFAULT;
desc.ByteWidth = sizeof(Impl::VertexConstantDesc);
desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
desc.CPUAccessFlags = 0;
_i->_device->CreateBuffer (&desc, NULL, &_i->_vertConstant);
// vertex layout.
D3D11_INPUT_ELEMENT_DESC vertexDesc[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, offsetof( RD_RenderScriptFx::VertexData, _x ), D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, offsetof( RD_RenderScriptFx::VertexData, _color ), D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, offsetof( RD_RenderScriptFx::VertexData, _u0 ), D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 1, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, offsetof( RD_RenderScriptFx::VertexData, _fxParams0[0] ), D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 2, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, offsetof( RD_RenderScriptFx::VertexData, _fxViewport0[0] ), D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 3, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, offsetof( RD_RenderScriptFx::VertexData, _boneParams[0] ), D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
// compile shaders.
//compileAndCreateShaders( _i->_device,
// g_fxVertShaderDX11_hlsl,
// g_fxFragShaderDX11_hlsl,
// vertexDesc,
// sizeof(vertexDesc) / sizeof(D3D11_INPUT_ELEMENT_DESC),
// &_i->_vertShader,
// &_i->_fragShader,
// &_i->_vertLayout );
createShaders( _i->_device,
(const void*)g_fxVertShaderDX11_cso,
sizeof(g_fxVertShaderDX11_cso),
(const void*)g_fxFragShaderDX11_cso,
sizeof(g_fxFragShaderDX11_cso),
vertexDesc,
sizeof(vertexDesc) / sizeof(D3D11_INPUT_ELEMENT_DESC),
&_i->_vertShader,
&_i->_fragShader,
&_i->_vertLayout );
}
ParticleRenderer::ParticleRenderer(bool isGL)
: m_vbo(0)
, m_frameId(0)
, m_eboArray(NULL)
, m_eboCount(2)
, m_isGL(isGL)
{
m_particleSystem = new ParticleSystem();
createShaders();
createVBO();
createEBOs();
}
////////////////////////////////////////////////////////////////////////////////
// SoftShadowsRenderer::initRendering()
////////////////////////////////////////////////////////////////////////////////
void SoftShadowsRenderer::initRendering()
{
GLint depthBits;
glGetIntegerv(GL_DEPTH_BITS, &depthBits);
LOGI("depth bits = %d\n", depthBits);
// Setup the eye's view parameters
initCamera(
NvCameraXformType::MAIN,
nv::vec3f(-0.644995f, 0.614183f, 0.660632f) * 1.5f, // position
nv::vec3f(0.0f, 0.0f, 0.0f)); // look at point
// Setup the light's view parameters
initCamera(
NvCameraXformType::SECONDARY,
nv::vec3f(3.57088f, 6.989f, 5.19698f) * 1.5f, // position
nv::vec3f(0.0f, 0.0f, 0.0f)); // look at point
// Generate the samplers
glGenSamplers(5, m_samplers);
CHECK_GL_ERROR();
for (GLuint unit = 0; unit < NumTextureUnits; ++unit)
{
glBindSampler(unit, m_samplers[unit]);
}
// Create resources
createShadowMap();
createGeometry();
createTextures();
createShaders();
// Set states that don't change
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glDepthFunc(GL_LESS);
glCullFace(GL_BACK);
glDisable(GL_BLEND);
glClearColor(
m_backgroundColor.x,
m_backgroundColor.y,
m_backgroundColor.z,
m_backgroundColor.w);
glClearDepthf(1.0f);
for (GLuint unit = 0; unit < NumTextureUnits; ++unit)
{
glBindSampler(unit, 0);
}
}
void Shading::checkGLContext()
// ----------------------------------------------------------------------------
// Re-create context-dependent resources if GL context has changed
// ----------------------------------------------------------------------------
{
tao->makeGLContextCurrent();
if (*pcontext != QGLContext::currentContext())
{
IFTRACE(shading)
debug() << "Context has changed" << "\n";
*pcontext = QGLContext::currentContext();
createShaders();
}
}
void MyGLWidget::initializeGL()
{
glewInit();
setMouseTracking(MOUSE_TRACKING);
//showFullScreen();
//glViewport(0,0, 1920, 1080);
//camera.SetPosition(0,2,-4);
lastMousePos = glm::vec2(-1,-1);
glEnable(GL_DEPTH_TEST);
glClearColor(0,0,0,1);
fillBuffer();
createShaders();
}
void GameWindow::initGL() {
glewInit();
createVBOs();
createShaders();
texture.load("life_cell.bmp");
worldLocation = glGetUniformLocation(shaderProgram.getGLProgram(), "world");
assert(worldLocation != 0xFFFFFFFF);
stateLocation = glGetUniformLocation(shaderProgram.getGLProgram(), "cellState");
assert(stateLocation != 0xFFFFFFFF);
samplerLocation = glGetUniformLocation(shaderProgram.getGLProgram(), "sampler");
assert(samplerLocation != 0xFFFFFFFF);
glUniform1i(samplerLocation, 0);
}
//==============================================================================
void initialise() override
{
// In this example the shader source codes are downloaded from a memory
// structure, but they could be downloaded from a text file or any other
// string structure
createShaders();
#if DEFAULT_TEXTURE == 2
// Use a 2-D texture (graphic) file or memory block to render (paint) the main object
// Get memory data block created by IntroJucer in BinaryDaya.cpp file
Image textureImage = ImageCache::getFromMemory (TEXTURE_DATA);
// Image must have height and width equal to a power of 2 pixels to be more efficient
// when used with older GPU architectures
if (! (isPowerOfTwo (textureImage.getWidth()) && isPowerOfTwo (textureImage.getHeight())))
textureImage = textureImage.rescaled (jmin (1024, nextPowerOfTwo (textureImage.getWidth())),
jmin (1024, nextPowerOfTwo (textureImage.getHeight())));
// Use that image as a 2-D texture for the object that will be painted
texture.loadImage(textureImage);
#endif
}
void startGame()
{
GLFWwindow* Window = initWindow();
bool Clicked = false;
GLuint VAO[2];
GLuint VBO[2];
GLuint LinesVBO[2];
glGenVertexArrays(2, VAO);
CellList cellList = createCellList();
GLfloat* cellVertexArray = createCellVertexArray(cellVertexArray, cellList);
GLfloat* cellColorArray = constructCellColorArray(cellColorArray, cellList, true);
constructVO(VAO[0], VBO, cellVertexArray, cellColorArray);
//constructLines(VAO[1], LinesVBO);
createShaders();
glClearColor(1.0, 1.0, 1.0, 1.0);
while (!glfwWindowShouldClose(Window)){
glClear(GL_COLOR_BUFFER_BIT);
constructCellColorArray(cellColorArray, cellList, false);
constructVO(VAO[0], VBO, cellVertexArray, cellColorArray);
glBindVertexArray(VAO[0]);
glDrawArrays(GL_TRIANGLES, 0, cellDim * cellDim * 12);
glBindVertexArray(VAO[1]);
//glDrawArrays(GL_LINES, 0, cellDim * 8);
glfwSwapBuffers(Window);
glfwWaitEvents();
if (glfwGetMouseButton(Window, GLFW_MOUSE_BUTTON_LEFT) == 1 && !Clicked){
Clicked = true;
mouseClick(Window, cellList);
}
if (glfwGetMouseButton(Window, GLFW_MOUSE_BUTTON_LEFT) == 0 && Clicked)
Clicked = false;
}
glfwDestroyWindow(Window);
glfwTerminate();
}
bool Shader::Initialize(const Microsoft::WRL::ComPtr<ID3D11Device> &pDevice
, const std::wstring &shaderFile, const std::wstring &textureFile)
{
if(!createShaders(pDevice, shaderFile, "vsMain", "psMain")){
return false;
}
if (!m_IASource->Initialize(pDevice)){
return false;
}
auto wicFactory = std::make_shared<imageutil::Factory>();
auto image=wicFactory->Load(textureFile);
if(image){
if (!m_texture->Initialize(pDevice, image)){
return false;
}
}
return true;
}
GLManager::GLManager(Window *window)
{
glm::vec2 drawableSize = window->getDrawableSize();
this->width = (int)(drawableSize.x);
this->height = (int)(drawableSize.y);
// this->width = width;
// this->height = height;
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClearDepthf(1.0f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_CULL_FACE);
glViewport(0, 0, this->width, this->height);
createShaders();
glGenBuffers(1, &lineBuffer);
}
void OpenGLWidget::sliderChanged(int i) {
dividerValue = i/100.0;
createShaders();
update();
}
void OpenGLWidget::mouseMoveEvent(QMouseEvent *event)
{
mouse = event->globalPos();
createShaders();
update();
}
void OpenGLWidget :: shaderChanged(int i)
{
currentShader = i;
createShaders() ;
update();
}
void OpenGLWidget::setEdgeThreshold(int value)
{
edgeThreshold = value/1000.0;
createShaders();
update();
}
void OpenGLWidget::setBillboardGrid(int value)
{
billboardGrid = value/100.0;
createShaders();
update();
}
void initShaders (){
//generate VAO
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
// Create a Vertex Buffer Object and copy the vertex data to it
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
// Create the buffer, but don't load anything yet
glBufferData(GL_ARRAY_BUFFER, sizeof(colors)+sizeof(vertices)+sizeof(textures), NULL, GL_STATIC_DRAW);
//glBufferData(GL_ARRAY_BUFFER, sizeof(colors)*sizeof(vertices)*sizeof(textures), NULL, GL_STATIC_DRAW);
// Load the vertex points
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices);
// Load the colors right after that
glBufferSubData(GL_ARRAY_BUFFER, sizeof(vertices),sizeof(colors), colors);
//Load the textures after that
glBufferSubData(GL_ARRAY_BUFFER, sizeof(vertices)+sizeof(colors),sizeof(textures), textures);//fixme
glGenBuffers(1, &indexBufferID);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferID);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
// Make a shader
shaderProgramID = createShaders();
//use shader
glUseProgram(shaderProgramID);
// Specify the layout of the vertex data
int offset = 0;
positionID = glGetAttribLocation(shaderProgramID, "s_vPosition");
glEnableVertexAttribArray(positionID);
//glVertexAttribPointer(positionID, 2, GL_FLOAT, GL_FALSE, 7 * sizeof(GLfloat), 0);
glVertexAttribPointer(positionID, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(offset));
offset += sizeof(vertices);
colorID = glGetAttribLocation(shaderProgramID, "s_vColor");
glEnableVertexAttribArray(colorID);
//glVertexAttribPointer(colorID, 3, GL_FLOAT, GL_FALSE, 7 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));
glVertexAttribPointer(colorID, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(offset));
//textures -- texcoords are missing!
offset += sizeof(colors);
GLuint texAttrib = glGetAttribLocation(shaderProgramID, "texcoord");
glEnableVertexAttribArray(texAttrib);
//glVertexAttribPointer(textureID, 3, GL_FLOAT, GL_FALSE, 7 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));
glVertexAttribPointer(texAttrib, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(offset));
//Load Textures
GLuint textures[1];
glGenTextures(1, textures);
int width, height;
unsigned char* image;
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textures[0]);
image = SOIL_load_image("image.jpg", &width, &height, 0, SOIL_LOAD_RGB);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);
SOIL_free_image_data(image);
glUniform1i(glGetUniformLocation(shaderProgramID, "texRink"), 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
perspectiveMatrixID = glGetUniformLocation(shaderProgramID, "mP");
viewMatrixID = glGetUniformLocation(shaderProgramID, "mV");
modelMatrixID = glGetUniformLocation(shaderProgramID, "mM");
}
void OpenGLWidget::setBlurSize(int value)
{
blurSize = value/10.0;
createShaders();
update();
}
EGLContextType *eglInit(Display *x11Display, XID x11Window, uint32_t fourcc)
{
EGLContextType *context = NULL;
GLProgram *glProgram = NULL;
context = calloc(1, sizeof(EGLContextType));
EGLDisplay eglDisplay = eglGetDisplay(x11Display);
if (eglDisplay == EGL_NO_DISPLAY) {
ERROR("eglGetDisplay fail");
}
CHECK_HANDLE_RET(eglDisplay, EGL_NO_DISPLAY, "eglGetDisplay", NULL);
context->eglContext.display = eglDisplay;
EGLint major, minor;
EGLBoolean result = eglInitialize(eglDisplay, &major, &minor);
if (result != EGL_TRUE) {
ERROR("eglInitialize fail");
}
EGL_CHECK_RESULT_RET(result, "eglInitialize", NULL);
// eglBindAPI(EGL_OPENGL_ES_API); // gles is the default one
EGLint const eglConfigAttribs[] = {
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_DEPTH_SIZE, 8,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_NONE
};
EGLConfig eglConfig;
EGLint eglConfigCount;
result = eglChooseConfig(eglDisplay, eglConfigAttribs, &eglConfig, 1, &eglConfigCount);
EGL_CHECK_RESULT_RET(result, "eglChooseConfig", NULL);
context->eglContext.config = eglConfig;
EGLSurface eglSurface = eglCreateWindowSurface(eglDisplay, eglConfig, x11Window, NULL);
CHECK_HANDLE_RET(eglSurface, EGL_NO_SURFACE, "eglCreateWindowSurface", NULL);
context->eglContext.surface = eglSurface;
EGLint const eglContextAttribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
EGLContext eglContext = eglCreateContext(eglDisplay, eglConfig, EGL_NO_CONTEXT, eglContextAttribs);
CHECK_HANDLE_RET(eglContext, EGL_NO_CONTEXT, "eglCreateContext", NULL);
context->eglContext.context = eglContext;
result = eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext);
EGL_CHECK_RESULT_RET(result, "eglMakeCurrent", NULL);
const unsigned char* glVersion = glGetString(GL_VERSION);
INFO("Runing GL version: %s, please make sure it support GL 2.0 API", glVersion);
// clear to middle blue
glClearColor(0.0, 0.0, 0.5, 0.0);
glEnable(GL_DEPTH_TEST);
glClearDepthf(1.0f);
{
int width, height;
Window root;
int x, y, borderWidth, depth;
XGetGeometry(x11Display, x11Window, &root, &x, &y, &width, &height, &borderWidth, &depth);
glViewport(0, 0, width, height);
}
glProgram = createShaders(vertexShaderText_rgba, fragShaderText_rgba, 1);
CHECK_HANDLE_RET(glProgram, NULL, "createShaders", NULL);
context->glProgram = glProgram;
return context;
}
void OpenGLWidget::setLuminosityThreshold(int value)
{
luminosityThreshold = value/100.0;
createShaders();
update();
}
void initialise() override
{
createShaders();
}
SimpleRenderer::SimpleRenderer()
{
createShaders();
}
void ShaderManagerDX::initialize()
{
createShaders();
createInputLayout();
createConstantBuffers();
}
void OpenGLWidget::setGamma(int value)
{
gamma = value/33.3;
createShaders();
update();
}
