bool initBuffer() { GLint UniformBufferOffset(0); glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &UniformBufferOffset); this->UniformBlockSize = glm::max(GLint(sizeof(glm::mat4)), UniformBufferOffset); glCreateBuffers(buffer::MAX, &BufferName[0]); glNamedBufferStorage(BufferName[buffer::ELEMENT], ElementSize, ElementData, 0); glNamedBufferStorage(BufferName[buffer::VERTEX], VertexSize, VertexData, 0); glNamedBufferStorage(BufferName[buffer::TRANSFORM], this->UniformBlockSize * 2, nullptr, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT); this->UniformPointer = static_cast<glm::uint8*>(glMapNamedBufferRange( BufferName[buffer::TRANSFORM], 0, this->UniformBlockSize * 2, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT | GL_MAP_INVALIDATE_BUFFER_BIT)); return true; }
static void light2Active(OSG::SHLChunk::GetUniformLocProc fULoc, OSG::DrawEnv *pEnv, GLuint uiProg) { GLint iLoc = fULoc(uiProg, "Light2Active"); if(iLoc != -1) { OSGGETGLFUNC_EXT(glUniform1i, osgGlUniform1i, OSG::ShaderProgram::getFuncIdUniform1i()); osgGlUniform1i(iLoc, GLint(pEnv->getLightState() & 0x0004)); } }
bool initTexture() { gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); assert(!Texture.empty()); glm::uvec2 FramebufferSize(this->getWindowSize() / 16u); glCreateTextures(GL_TEXTURE_2D_ARRAY, texture::MAX, &TextureName[0]); glTextureParameteri(TextureName[0], GL_TEXTURE_BASE_LEVEL, 0); glTextureParameteri(TextureName[0], GL_TEXTURE_MAX_LEVEL, 0); glTextureParameteri(TextureName[0], GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTextureParameteri(TextureName[0], GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTextureStorage3D(TextureName[0], GLint(1), GL_RGBA8, GLsizei(FramebufferSize.x), GLsizei(FramebufferSize.y), 1); return true; }
void WrappedOpenGL::glGetIntegeri_v(GLenum pname, GLuint index, GLint *data) { if(pname == eGL_MIN_MAP_BUFFER_ALIGNMENT) { if(data) *data = (GLint)64; return; } else if(pname == eGL_DEBUG_TOOL_PURPOSE_EXT) { if(data) *data = GLint(eGL_DEBUG_TOOL_FRAME_CAPTURE_BIT_EXT); return; } m_Real.glGetIntegeri_v(pname, index, data); }
bool initTexture() { bool Validated(true); gli::gl GL; gli::texture2D Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); gli::gl::format const Format = GL.translate(Texture.format()); assert(!Texture.empty()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGenTextures(texture::MAX, &TextureName[0]); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA); glTexStorage2D(GL_TEXTURE_2D, static_cast<GLint>(Texture.levels()), Format.Internal, static_cast<GLsizei>(Texture.dimensions().x), static_cast<GLsizei>(Texture.dimensions().y)); for (std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexSubImage2D(GL_TEXTURE_2D, static_cast<GLint>(Level), 0, 0, static_cast<GLsizei>(Texture[Level].dimensions().x), static_cast<GLsizei>(Texture[Level].dimensions().y), Format.External, static_cast<GLsizei>(Texture[Level].size()), Texture[Level].data()); } glm::vec2 WindowSize(this->getWindowSize()); glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexStorage2D(GL_TEXTURE_2D, static_cast<GLint>(1), GL_RGBA8, static_cast<GLsizei>(WindowSize.x), static_cast<GLsizei>(WindowSize.y)); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); return Validated; }
bool initTexture() { gli::texture2D Texture(gli::loadStorageDDS(glf::DATA_DIRECTORY + TEXTURE_DIFFUSE)); glGenTextures(texture::MAX, &TextureName[0]); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glTexImage2D( GL_TEXTURE_2D, GLint(Level), GL_RGBA8UI, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), 0, GL_BGR_INTEGER, GL_UNSIGNED_BYTE, Texture[Level].data()); } glBindTexture(GL_TEXTURE_2D, 0); GLint MaxSampleMaskWords(0); GLint MaxColorTextureSamples(0); GLint MaxDepthTextureSamples(0); GLint MaxIntegerSamples(0); glGetIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &MaxSampleMaskWords); glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &MaxColorTextureSamples); glGetIntegerv(GL_MAX_DEPTH_TEXTURE_SAMPLES, &MaxDepthTextureSamples); glGetIntegerv(GL_MAX_INTEGER_SAMPLES, &MaxIntegerSamples); glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, TextureName[texture::MULTISAMPLE]); glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, MaxIntegerSamples, GL_RGBA8UI, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y, GL_TRUE); glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8UI, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y, 0, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, 0); glBindTexture(GL_TEXTURE_2D, 0); return glf::checkError("initTexture"); }
bool initTexture() { GLint MaxSampleMaskWords(0); GLint MaxColorTextureSamples(0); GLint MaxDepthTextureSamples(0); GLint MaxIntegerSamples(0); glGetIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &MaxSampleMaskWords); glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &MaxColorTextureSamples); glGetIntegerv(GL_MAX_DEPTH_TEXTURE_SAMPLES, &MaxDepthTextureSamples); glGetIntegerv(GL_MAX_INTEGER_SAMPLES, &MaxIntegerSamples); gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); gli::gl GL(gli::gl::PROFILE_GL32); glGenTextures(texture::MAX, &TextureName[0]); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 3); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); gli::gl::format const Format = GL.translate(gli::FORMAT_RGB8_UINT_PACK8, Texture.swizzles()); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glTexImage2D(GL_TEXTURE_2D, GLint(Level), Format.Internal, GLsizei(Texture[Level].extent().x), GLsizei(Texture[Level].extent().y), 0, Format.External, Format.Type, Texture[Level].data()); } glm::ivec2 WindowSize(this->getWindowSize()); glBindTexture(GL_TEXTURE_2D, TextureName[texture::RENDERBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8UI, WindowSize.x / FRAMEBUFFER_SIZE, WindowSize.y / FRAMEBUFFER_SIZE, 0, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, 0); glBindTexture(GL_TEXTURE_2D, 0); return this->checkError("initTexture"); }
void Pager::addChild(Widget* newChild) { /* Do nothing if the new child is actually a page button: */ if(addingPageButton) return; /* Add the child to the list at the selected position: */ children.insert(children.begin()+nextChildIndex,newChild); /* Create a new page button: */ char pbName[20]; snprintf(pbName,sizeof(pbName),"PageButton%u",nextPageIndex); ++nextPageIndex; Button* newPageButton; addingPageButton=true; if(!nextPageName.empty()) { newPageButton=new Button(pbName,this,nextPageName.c_str()); nextPageName=""; } else { /* Create a default page button label: */ char pbLabel[20]; snprintf(pbLabel,sizeof(pbLabel),"Page %u",nextPageIndex); newPageButton=new Button(pbName,this,pbLabel); } addingPageButton=false; newPageButton->setBorderWidth(newPageButton->getBorderWidth()*0.5f); newPageButton->getSelectCallbacks().add(this,&Pager::pageButtonSelectCallback); /* Add the page button to the list: */ pageButtons.insert(pageButtons.begin()+nextChildIndex,newPageButton); /* Select the just-added child: */ setCurrentChildIndex(nextChildIndex); /* Prepare for the next page: */ nextChildIndex=GLint(children.size()); if(isManaged) { /* Try to resize the widget to accomodate the new child: */ parent->requestResize(this,calcNaturalSize()); } }
bool initTexture2D() { glGenTextures(1, &Texture2DName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, Texture2DName); gli::texture2D Texture(gli::loadStorageDDS(glf::DATA_DIRECTORY + TEXTURE_DIFFUSE_DXT5)); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexImage2D( GL_TEXTURE_2D, GLint(Level), GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), 0, GLsizei(Texture[Level].size()), Texture[Level].data()); } SwizzleR[viewport::V00] = GL_RED; SwizzleG[viewport::V00] = GL_GREEN; SwizzleB[viewport::V00] = GL_BLUE; SwizzleA[viewport::V00] = GL_ALPHA; SwizzleR[viewport::V10] = GL_BLUE; SwizzleG[viewport::V10] = GL_GREEN; SwizzleB[viewport::V10] = GL_RED; SwizzleA[viewport::V10] = GL_ALPHA; SwizzleR[viewport::V11] = GL_ONE; SwizzleG[viewport::V11] = GL_GREEN; SwizzleB[viewport::V11] = GL_BLUE; SwizzleA[viewport::V11] = GL_ALPHA; SwizzleR[viewport::V01] = GL_ZERO; SwizzleG[viewport::V01] = GL_GREEN; SwizzleB[viewport::V01] = GL_BLUE; SwizzleA[viewport::V01] = GL_ALPHA; glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, 0); return glf::checkError("initTexture2D"); }
bool initTexture2D() { glGenTextures(1, &Texture2DName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, Texture2DName); gli::image Image = gli::import_as(TEXTURE_DIFFUSE_DXT5); for(std::size_t Level = 0; Level < Image.levels(); ++Level) { glCompressedTexImage2D( GL_TEXTURE_2D, GLint(Level), GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GLsizei(Image[Level].dimensions().x), GLsizei(Image[Level].dimensions().y), 0, GLsizei(Image[Level].capacity()), Image[Level].data()); } SwizzleR[viewport::V00] = GL_RED; SwizzleG[viewport::V00] = GL_GREEN; SwizzleB[viewport::V00] = GL_BLUE; SwizzleA[viewport::V00] = GL_ALPHA; SwizzleR[viewport::V10] = GL_BLUE; SwizzleG[viewport::V10] = GL_GREEN; SwizzleB[viewport::V10] = GL_RED; SwizzleA[viewport::V10] = GL_ALPHA; SwizzleR[viewport::V11] = GL_ONE; SwizzleG[viewport::V11] = GL_GREEN; SwizzleB[viewport::V11] = GL_BLUE; SwizzleA[viewport::V11] = GL_ALPHA; SwizzleR[viewport::V01] = GL_ZERO; SwizzleG[viewport::V01] = GL_GREEN; SwizzleB[viewport::V01] = GL_BLUE; SwizzleA[viewport::V01] = GL_ALPHA; glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, 0); return glf::checkError("initTexture2D"); }
inline void drawElementsInstancedBaseVertexBaseInstance( DrawElementsInstancedBaseVertexBaseInstanceMode mode, GLsizei count, DrawElementsInstancedBaseVertexBaseInstanceType type, GLvoid *indices, GLsizei primcount, GLint basevertex, GLuint baseinstance) { glDrawElementsInstancedBaseVertexBaseInstance( GLenum(mode), GLsizei(count), GLenum(type), (GLvoid*)(indices), GLsizei(primcount), GLint(basevertex), GLuint(baseinstance)); }
void glCompileShaderFromFile(GLhandleARB shaderObject,const char* shaderSourceFileName,IO::File& shaderSourceFile) { /* Read the entire shader source: */ size_t shaderAllocSize=8192; GLcharARB* shaderSource=new GLcharARB[shaderAllocSize]; size_t shaderSourceLength=0; while(!shaderSourceFile.eof()) { /* Make room in the shader source buffer: */ if(shaderSourceLength==shaderAllocSize) { shaderAllocSize=(shaderAllocSize*3)/2; GLcharARB* newShaderSource=new GLcharARB[shaderAllocSize]; memcpy(newShaderSource,shaderSource,shaderSourceLength); delete[] shaderSource; shaderSource=newShaderSource; } /* Read more data from the file: */ size_t numBytesRead=shaderSourceFile.readUpTo(shaderSource+shaderSourceLength,shaderAllocSize-shaderSourceLength); shaderSourceLength+=numBytesRead; } /* Upload the shader source into the shader object: */ const GLcharARB* ss=shaderSource; GLint ssl=GLint(shaderSourceLength); glShaderSourceARB(shaderObject,1,&ss,&ssl); delete[] shaderSource; /* Compile the shader source: */ glCompileShaderARB(shaderObject); /* Check if the shader compiled successfully: */ GLint compileStatus; glGetObjectParameterivARB(shaderObject,GL_OBJECT_COMPILE_STATUS_ARB,&compileStatus); if(!compileStatus) { /* Get some more detailed information: */ GLcharARB compileLogBuffer[2048]; GLsizei compileLogSize; glGetInfoLogARB(shaderObject,sizeof(compileLogBuffer),&compileLogSize,compileLogBuffer); /* Signal an error: */ Misc::throwStdErr("glCompileShaderFromFile: Error \"%s\" while compiling shader %s",compileLogBuffer,shaderSourceFileName); } }
bool initBuffer() { glGenBuffers(buffer::MAX, BufferName); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, BufferName[buffer::ELEMENT]); glBufferData(GL_ELEMENT_ARRAY_BUFFER, ElementSize, ElementData, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, BufferName[buffer::POSITION_INPUT]); glBufferData(GL_ARRAY_BUFFER, PositionSize * 2, NULL, GL_STATIC_DRAW); glBufferSubData(GL_ARRAY_BUFFER, 0, PositionSize, PositionData); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, BufferName[buffer::TEXCOORD_INPUT]); glBufferData(GL_ARRAY_BUFFER, TexcoordSize * 2, TexcoordData, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, BufferName[buffer::COLOR_INPUT]); glBufferData(GL_ARRAY_BUFFER, ColorSize * 2, ColorData, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, BufferName[buffer::POSITION_OUTPUT]); glBufferData(GL_ARRAY_BUFFER, PositionSize * 2, NULL, GL_STATIC_COPY); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, BufferName[buffer::TEXCOORD_OUTPUT]); glBufferData(GL_ARRAY_BUFFER, TexcoordSize * 2, NULL, GL_STATIC_COPY); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, BufferName[buffer::COLOR_OUTPUT]); glBufferData(GL_ARRAY_BUFFER, ColorSize * 2, NULL, GL_STATIC_COPY); glBindBuffer(GL_ARRAY_BUFFER, 0); GLint UniformBufferOffset(0); glGetIntegerv( GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &UniformBufferOffset); GLint UniformBlockSize = glm::max(GLint(sizeof(glm::mat4)), UniformBufferOffset); glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]); glBufferData(GL_UNIFORM_BUFFER, UniformBlockSize, NULL, GL_DYNAMIC_DRAW); glBindBuffer(GL_UNIFORM_BUFFER, 0); return true; }
void VertexData::use() { uint32_t flags(0); for(auto& element : _vertexStreams) { flags = flags | (1 << element.second._stream._semantic); } GL::enableVertexAttribs(flags); for(auto& element : _vertexStreams) { //glEnableVertexAttribArray((GLint)element.second._stream._semantic); glBindBuffer(GL_ARRAY_BUFFER, element.second._buffer->getVBO()); glVertexAttribPointer(GLint(element.second._stream._semantic),element.second._stream._size, element.second._stream._type,element.second._stream._normalize, element.second._buffer->getSizePerVertex(), (GLvoid*)element.second._stream._offset); } }
bool initBuffer() { GLint UniformBufferOffset(0); glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &UniformBufferOffset); GLint UniformBlockSize = glm::max(GLint(sizeof(glm::mat4)), UniformBufferOffset); glm::vec4 Material0(1.0f, 0.5f, 0.0f, 1.0f); glm::vec4 Material1(0.0f, 0.5f, 1.0f, 1.0f); glCreateBuffers(buffer::MAX, &BufferName[0]); glNamedBufferStorage(BufferName[buffer::VERTEX], VertexSize, VertexData, 0); glNamedBufferStorage(BufferName[buffer::ELEMENT], ElementSize, ElementData, 0); glNamedBufferStorage(BufferName[buffer::TRANSFORM], UniformBlockSize, nullptr, GL_MAP_WRITE_BIT); glNamedBufferStorage(BufferName[buffer::MATERIAL0], sizeof(glm::vec4), &Material0[0], 0); glNamedBufferStorage(BufferName[buffer::MATERIAL1], sizeof(glm::vec4), &Material1[0], 0); return true; }
bool initBuffer() { glGenBuffers(buffer::MAX, &BufferName[0]); glBindBuffer(GL_ARRAY_BUFFER, BufferName[buffer::VERTEX]); glBufferData(GL_ARRAY_BUFFER, VertexSize, VertexData, GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); GLint UniformBufferOffset(0); glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &UniformBufferOffset); GLint UniformBlockSize = glm::max(GLint(sizeof(glm::mat4)), UniformBufferOffset); glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]); glBufferData(GL_UNIFORM_BUFFER, UniformBlockSize, NULL, GL_DYNAMIC_DRAW); glBindBuffer(GL_UNIFORM_BUFFER, 0); return this->checkError("initBuffer"); }
bool initBuffer() { glGenBuffers(buffer::MAX, &BufferName[0]); glBindBuffer(GL_SHADER_STORAGE_BUFFER, BufferName[buffer::VERTEX]); glBufferStorage(GL_SHADER_STORAGE_BUFFER, VertexSize, VertexData, 0); glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0); GLint UniformBufferOffset(0); glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &UniformBufferOffset); GLint UniformBlockSize = glm::max(GLint(sizeof(transform)), UniformBufferOffset); glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]); glBufferStorage(GL_UNIFORM_BUFFER, UniformBlockSize, nullptr, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT); glBindBuffer(GL_UNIFORM_BUFFER, 0); return true; }
bool initBuffer() { glGenBuffers(buffer::MAX, &BufferName[0]); glBindBuffer(GL_ARRAY_BUFFER, BufferName[buffer::VERTEX]); glBufferData(GL_ARRAY_BUFFER, PositionSize, &PositionData[0][0], GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER, 0); GLint UniformBufferOffset(0); glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &UniformBufferOffset); GLint UniformBlockSize = glm::max(GLint(sizeof(glm::mat4)), UniformBufferOffset); glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]); glBufferData(GL_UNIFORM_BUFFER, UniformBlockSize, nullptr, GL_DYNAMIC_DRAW); glBindBuffer(GL_UNIFORM_BUFFER, 0); return true; }
bool initTexture2D() { glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGenTextures(1, &Texture2DName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, Texture2DName); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // Set image gli::texture2D Texture = gli::load(TEXTURE_DIFFUSE); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glTexImage2D( GL_TEXTURE_2D, GLint(Level), GL_RGB, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), 0, GL_BGR, GL_UNSIGNED_BYTE, NULL); } GLsizei TextureSize = GLsizei(Texture[0].dimensions().x) * GLsizei(Texture[0].dimensions().y) * 3; glGenBuffers(1, &PixelBuffer); glBindBuffer(GL_PIXEL_UNPACK_BUFFER, PixelBuffer); glBufferData(GL_PIXEL_UNPACK_BUFFER, TextureSize, NULL, GL_STREAM_DRAW); //void* Pointer = glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY); void* Pointer = glMapBufferRange(GL_PIXEL_UNPACK_BUFFER, 0, TextureSize, GL_MAP_WRITE_BIT); memcpy(Pointer, Texture[0].data(), TextureSize); glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, GLsizei(Texture[0].dimensions().x), GLsizei(Texture[0].dimensions().y), GL_BGR, GL_UNSIGNED_BYTE, NULL); glDeleteBuffers(1, &PixelBuffer); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); return glf::checkError("initTexture2D"); }
/** * @glsymbols * @glfunref{StencilFuncSeparate} */ static void StencilFuncSeparate( Face face, CompareFunction func, GLint ref = GLint(0), GLuint mask = ~GLuint(0) ) { OGLPLUS_GLFUNC(StencilFuncSeparate)( GLenum(face), GLenum(func), ref, mask ); OGLPLUS_VERIFY( StencilFuncSeparate, Error, EnumParam(func) ); }
void WebGL2Context::BindSampler(GLuint unit, WebGLSampler* sampler) { if (IsContextLost()) return; if (!ValidateObjectAllowDeletedOrNull("bindSampler", sampler)) return; if (GLint(unit) >= mGLMaxTextureUnits) return ErrorInvalidValue("bindSampler: unit must be < %d", mGLMaxTextureUnits); if (sampler && sampler->IsDeleted()) return ErrorInvalidOperation("bindSampler: binding deleted sampler"); WebGLContextUnchecked::BindSampler(unit, sampler); mBoundSamplers[unit] = sampler; }
bool initBuffer() { // Generate a buffer object glGenBuffers(buffer::MAX, &BufferName[0]); glBindBuffer(GL_ARRAY_BUFFER, BufferName[buffer::VERTEX]); glBufferStorage(GL_ARRAY_BUFFER, VertexSize, VertexData, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); GLint UniformBufferOffset(0); glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &UniformBufferOffset); GLint UniformBlockSize = glm::max(GLint(sizeof(glm::mat4)), UniformBufferOffset); glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]); glBufferStorage(GL_UNIFORM_BUFFER, UniformBlockSize, NULL, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT); glBindBuffer(GL_UNIFORM_BUFFER, 0); return this->checkError("initBuffer");; }
GLint WebGLProgram::GetAttribLocation(const nsAString& userName_wide) const { if (!ValidateGLSLVariableName(userName_wide, mContext, "getAttribLocation")) return -1; if (!IsLinked()) { mContext->ErrorInvalidOperation("getAttribLocation: `program` must be linked."); return -1; } const NS_LossyConvertUTF16toASCII userName(userName_wide); const webgl::AttribInfo* info; if (!LinkInfo()->FindAttrib(userName, &info)) return -1; return GLint(info->mLoc); }
bool initTexture() { glm::vec2 WindowSize(this->getWindowSize()); glGenTextures(1, &TextureName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 1); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_RED); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_G, GL_GREEN); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_BLUE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_A, GL_ALPHA); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexStorage2D(GL_TEXTURE_2D, GLint(1), GL_RGBA8, GLsizei(WindowSize.x), GLsizei(WindowSize.y)); return true; }
bool initTexture() { bool Validated(true); gli::gl GL(gli::gl::PROFILE_GL33); gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); assert(!Texture.empty()); gli::gl::format const Format = GL.translate(Texture.format(), Texture.swizzles()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glCreateTextures(GL_TEXTURE_2D_ARRAY, 1, &TextureName); glTextureParameteri(TextureName, GL_TEXTURE_SWIZZLE_R, Format.Swizzles[0]); glTextureParameteri(TextureName, GL_TEXTURE_SWIZZLE_G, Format.Swizzles[1]); glTextureParameteri(TextureName, GL_TEXTURE_SWIZZLE_B, Format.Swizzles[2]); glTextureParameteri(TextureName, GL_TEXTURE_SWIZZLE_A, Format.Swizzles[3]); glTextureParameteri(TextureName, GL_TEXTURE_BASE_LEVEL, 0); glTextureParameteri(TextureName, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTextureParameteri(TextureName, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTextureParameteri(TextureName, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTextureStorage3D(TextureName, static_cast<GLint>(Texture.levels()), Format.Internal, static_cast<GLsizei>(Texture.extent().x), static_cast<GLsizei>(Texture.extent().y), 1); for(gli::texture2d::size_type Level(0); Level < Texture.levels(); ++Level) { glTextureSubImage3D(TextureName, static_cast<GLint>(Level), 0, 0, 0, static_cast<GLsizei>(Texture[Level].extent().x), static_cast<GLsizei>(Texture[Level].extent().y), 1, Format.External, Format.Type, Texture[Level].data()); } glPixelStorei(GL_UNPACK_ALIGNMENT, 4); // Query the texture handle and make the texture resident TextureHandle = glGetTextureHandleNV(TextureName); glMakeTextureHandleResidentNV(TextureHandle); return Validated; }
bool render() { glm::ivec2 WindowSize(this->getWindowSize()); glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, 4.0f / 3.0f, 0.1f, 1000.0f); glm::mat4 Model = glm::mat4(1.0f); glm::mat4 MVP = Projection * this->view() * Model; glViewport(0, 0, WindowSize.x, WindowSize.y); glScissor(0, 0, WindowSize.x, WindowSize.y); glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]); // Bind the program for use glUseProgram(ProgramName); glUniformMatrix4fv(UniformMVP, 1, GL_FALSE, &MVP[0][0]); glBindSampler(0, SamplerName[0]); glBindSampler(1, SamplerName[1]); glBindSampler(2, SamplerName[2]); glBindSampler(3, SamplerName[3]); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, Texture2DName); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, Texture2DName); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, Texture2DName); glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, Texture2DName); glBindVertexArray(VertexArrayName); for(std::size_t Index = 0; Index < viewport::MAX; ++Index) { glUniform1i(UniformDiffuse, GLint(Index)); glScissor(Viewport[Index].x, Viewport[Index].y, Viewport[Index].z, Viewport[Index].w); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1); } return true; }
bool initUniformBuffer() { bool Validated(true); GLint UniformBufferOffset(0); glGetIntegerv( GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &UniformBufferOffset); { GLint UniformBlockSize = glm::max(GLint(sizeof(glm::mat4)), UniformBufferOffset); glGenBuffers(1, &BufferName[buffer::TRANSFORM]); glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]); glBufferData(GL_UNIFORM_BUFFER, UniformBlockSize, nullptr, GL_DYNAMIC_DRAW); glBindBuffer(GL_UNIFORM_BUFFER, 0); } return Validated; }
// Control mouse void PassiveMouseMove(GLint x, GLint y) { GLint viewport[4]; GLdouble modelview[16]; GLdouble projection[16]; GLfloat winX, winY, winZ; GLdouble posX, posY, posZ; glGetDoublev(GL_MODELVIEW_MATRIX, modelview); glGetDoublev(GL_PROJECTION_MATRIX, projection); glGetIntegerv(GL_VIEWPORT, viewport); winX = (GLfloat)x; winY = (GLfloat)viewport[3] - (GLfloat)y; glReadPixels(x, GLint(winY), 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ); gluUnProject(winX, winY, winZ, modelview, projection, viewport, &posX, &posY, &posZ); reflectorX = posX; reflectorY = posY; }
bool initTexture2D() { glPixelStorei(GL_UNPACK_ALIGNMENT, 4); GLint TextureSize = 0; glGetIntegerv(GL_MAX_RECTANGLE_TEXTURE_SIZE, &TextureSize); glGenTextures(1, &TextureRectName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_RECTANGLE, TextureRectName); glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri(GL_TEXTURE_RECTANGLE, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // Set image gli::texture2D Image = gli::load(TEXTURE_DIFFUSE); for(std::size_t Level = 0; Level < Image.levels(); ++Level) { assert( Image[Level].dimensions().x <= std::size_t(TextureSize) && Image[Level].dimensions().y <= std::size_t(TextureSize)); glTexImage2D( GL_TEXTURE_RECTANGLE, GLint(Level), GL_RGB, GLsizei(Image[Level].dimensions().x), GLsizei(Image[Level].dimensions().y), //GLsizei(1), //depth 0, GL_RGB, GL_UNSIGNED_BYTE, Image[Level].data()); } glPixelStorei(GL_UNPACK_ALIGNMENT, 1); return glf::checkError("initTexture2D"); }
bool initBuffer() { glGenBuffers(buffer::MAX, &BufferName[0]); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, BufferName[buffer::ELEMENT]); glBufferData(GL_ELEMENT_ARRAY_BUFFER, ElementSize, ElementData, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_SHADER_STORAGE_BUFFER, BufferName[buffer::VERTEX]); glBufferData(GL_SHADER_STORAGE_BUFFER, VertexSize, VertexData, GL_STATIC_DRAW); glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0); GLint UniformBufferOffset(0); glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &UniformBufferOffset); GLint UniformBlockSize = glm::max(GLint(sizeof(glm::mat4)), UniformBufferOffset); glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]); glBufferData(GL_UNIFORM_BUFFER, UniformBlockSize, nullptr, GL_DYNAMIC_DRAW); glBindBuffer(GL_UNIFORM_BUFFER, 0); return true; }