bool initTexture() { glGenTextures(texture::MAX, TextureName); gli::texture2D Texture(gli::loadStorageDDS(glf::DATA_DIRECTORY + TEXTURE_DIFFUSE)); assert(!Texture.empty()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]); 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_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexStorage2D(GL_TEXTURE_2D, GLint(Texture.levels()), GL_RGBA8, GLsizei(Texture[0].dimensions().x), GLsizei(Texture[0].dimensions().y)); for(gli::texture2D::size_type Level = 0; Level < Texture.levels(); ++Level) { glTexSubImage2D( GL_TEXTURE_2D, GLint(Level), 0, 0, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), GL_BGR, GL_UNSIGNED_BYTE, Texture[Level].data()); } glPixelStorei(GL_UNPACK_ALIGNMENT, 4); GLint TextureBufferOffset(0); glGetIntegerv( GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT, &TextureBufferOffset); GLint TextureBufferRange = glm::max(GLint(PositionSize), TextureBufferOffset); glBindTexture(GL_TEXTURE_BUFFER, TextureName[texture::POSITION_INPUT]); glTexBufferRange(GL_TEXTURE_BUFFER, GL_RGBA32F, BufferName[buffer::POSITION_INPUT], 0, TextureBufferRange); glBindTexture(GL_TEXTURE_BUFFER, TextureName[texture::TEXCOORD_INPUT]); glTexBufferRange(GL_TEXTURE_BUFFER, GL_RGBA32F, BufferName[buffer::TEXCOORD_INPUT], 0, TextureBufferRange); glBindTexture(GL_TEXTURE_BUFFER, TextureName[texture::COLOR_INPUT]); glTexBufferRange(GL_TEXTURE_BUFFER, GL_RGBA32F, BufferName[buffer::COLOR_INPUT], 0, TextureBufferRange); glBindTexture(GL_TEXTURE_BUFFER, TextureName[texture::POSITION_OUTPUT]); glTexBufferRange(GL_TEXTURE_BUFFER, GL_RGBA32F, BufferName[buffer::POSITION_OUTPUT], 0, TextureBufferRange); glBindTexture(GL_TEXTURE_BUFFER, TextureName[texture::TEXCOORD_OUTPUT]); glTexBufferRange(GL_TEXTURE_BUFFER, GL_RGBA32F, BufferName[buffer::TEXCOORD_OUTPUT], 0, TextureBufferRange); glBindTexture(GL_TEXTURE_BUFFER, TextureName[texture::COLOR_OUTPUT]); glTexBufferRange(GL_TEXTURE_BUFFER, GL_RGBA32F, BufferName[buffer::COLOR_OUTPUT], 0, TextureBufferRange); glBindTexture(GL_TEXTURE_BUFFER, 0); return true; }
void adjustViewport() { float scaleX, scaleY; int winWidth = glutGet(GLUT_WINDOW_WIDTH); int winHeight = glutGet(GLUT_WINDOW_HEIGHT); getAspectRatioAdjustment(XY_ASPECT, float(winWidth) / float(winHeight), &scaleX, &scaleY); GLsizei vpWidth = GLsizei(winWidth * scaleX); GLsizei vpHeight = GLsizei(winHeight * scaleY); glViewport((winWidth-vpWidth)/2, (winHeight-vpHeight)/2, vpWidth, vpHeight); }
void ogl::texture::load_png(const void *buf, size_t len, std::vector<GLubyte>& p) { // Initialize all PNG import data structures. png_structp rp = 0; png_infop ip = 0; png_bytep *bp = 0; if (!(rp = png_create_read_struct(PNG_LIBPNG_VER_STRING, 0, 0, 0))) throw std::runtime_error("Failure creating PNG read structure"); if (!(ip = png_create_info_struct(rp))) throw std::runtime_error("Failure creating PNG info structure"); // Initialize the user-defined IO structure. struct png_user_io user; user.buf = (png_bytep) buf; user.len = (png_size_t) len; png_set_read_fn(rp, &user, png_user_read); // Enable the default PNG error handler. if (setjmp(png_jmpbuf(rp)) == 0) { // Read the PNG header. png_read_png(rp, ip, PNG_TRANSFORM_EXPAND | PNG_TRANSFORM_PACKING | PNG_TRANSFORM_STRIP_16 | PNG_TRANSFORM_SWAP_ENDIAN, 0); // Extract image properties. w = GLsizei(png_get_image_width (rp, ip)); h = GLsizei(png_get_image_height(rp, ip)); c = GLsizei(png_get_channels (rp, ip)); p.resize(w * h * c); // Read the pixel data. if ((bp = png_get_rows(rp, ip))) for (GLsizei i = 0, j = h - 1; i < h; ++i, --j) memcpy(&p[w * c * i], bp[j], (w * c)); } // Release all resources. png_destroy_read_struct(&rp, &ip, 0); }
bool initTexture() { bool Validated(true); gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); assert(!Texture.empty()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 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, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexImage2D(GL_TEXTURE_2D, GLint(Level), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture[Level].extent().x), GLsizei(Texture[Level].extent().y), 0, GLsizei(Texture[Level].size()), Texture[Level].data()); } glm::ivec2 WindowSize(this->getWindowSize() * this->FramebufferScale); glActiveTexture(GL_TEXTURE0); 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_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, GLint(0), GL_RGBA8, GLsizei(WindowSize.x), GLsizei(WindowSize.y), 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DEPTHBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexImage2D(GL_TEXTURE_2D, GLint(0), GL_DEPTH_COMPONENT24, GLsizei(WindowSize.x), GLsizei(WindowSize.y), 0, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::STENCILBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexImage2D(GL_TEXTURE_2D, GLint(0), GL_STENCIL_INDEX8, GLsizei(WindowSize.x), GLsizei(WindowSize.y), 0, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, nullptr); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); return Validated; }
void RenderablePatchSolid::render(const RenderInfo& info) const { #ifdef PATCHES_USE_VBO glBindBuffer(GL_ARRAY_BUFFER, _vboData); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vboIdx); glNormalPointer(GL_DOUBLE, sizeof(ArbitraryMeshVertex), BUFFER_OFFSET(16)); glClientActiveTexture(GL_TEXTURE0); glTexCoordPointer(2, GL_DOUBLE, sizeof(ArbitraryMeshVertex), BUFFER_OFFSET(0)); glVertexPointer(3, GL_DOUBLE, sizeof(ArbitraryMeshVertex), BUFFER_OFFSET(40)); const RenderIndex* strip_indices = 0; for (std::size_t i = 0; i < m_tess.m_numStrips; i++, strip_indices += m_tess.m_lenStrips) { glDrawElements(GL_QUAD_STRIP, GLsizei(m_tess.m_lenStrips), RenderIndexTypeID, strip_indices); } GlobalOpenGL().assertNoErrors(); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); #else if (m_tess.vertices.empty() || m_tess.indices.empty()) return; if (info.checkFlag(RENDER_BUMP)) { glVertexAttribPointerARB(11, 3, GL_DOUBLE, 0, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().normal); glVertexAttribPointerARB(8, 2, GL_DOUBLE, 0, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().texcoord); glVertexAttribPointerARB(9, 3, GL_DOUBLE, 0, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().tangent); glVertexAttribPointerARB(10, 3, GL_DOUBLE, 0, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().bitangent); } else { glNormalPointer(GL_DOUBLE, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().normal); glTexCoordPointer(2, GL_DOUBLE, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().texcoord); } glVertexPointer(3, GL_DOUBLE, sizeof(ArbitraryMeshVertex), &m_tess.vertices.front().vertex); const RenderIndex* strip_indices = &m_tess.indices.front(); for(std::size_t i = 0; i<m_tess.m_numStrips; i++, strip_indices += m_tess.m_lenStrips) { glDrawElements(GL_QUAD_STRIP, GLsizei(m_tess.m_lenStrips), RenderIndexTypeID, strip_indices); } #if defined(_DEBUG) //RenderNormals(); #endif #endif }
bool initTexture() { bool Validated(true); gli::gl GL(gli::gl::PROFILE_GL32); gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); assert(!Texture.empty()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 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, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); gli::gl::format const Format = GL.translate(Texture.format(), Texture.swizzles()); for (gli::texture2d::size_type Level = 0; Level < Texture.levels(); ++Level) { glTexImage2D(GL_TEXTURE_2D, static_cast<GLint>(Level), Format.Internal, static_cast<GLsizei>(Texture[Level].extent().x), static_cast<GLsizei>(Texture[Level].extent().y), 0, Format.External, Format.Type, Texture[Level].data()); } glm::ivec2 WindowSize(this->getWindowSize() * this->FramebufferScale); glActiveTexture(GL_TEXTURE0); 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_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexImage2D(GL_TEXTURE_2D, GLint(0), GL_RGBA8, GLsizei(WindowSize.x), GLsizei(WindowSize.y), 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName[texture::RENDERBUFFER]); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); glTexImage2D(GL_TEXTURE_2D, GLint(0), GL_DEPTH_COMPONENT24, GLsizei(WindowSize.x), GLsizei(WindowSize.y), 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); return Validated; }
bool initTexture() { bool Validated(true); gli::texture2D Texture(gli::loadStorageDDS(glf::DATA_DIRECTORY + TEXTURE_DIFFUSE)); assert(!Texture.empty()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glBindBuffer(GL_PIXEL_PACK_BUFFER, BufferName[buffer::VERTEX]); glGenTextures(1, &TextureName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName); 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_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, GLint(Texture.levels() - 1)); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexStorage2D(GL_TEXTURE_2D, GLint(Texture.levels()), gli::internal_format(Texture.format()), GLsizei(Texture.dimensions().x), GLsizei(Texture.dimensions().y)); for(gli::texture2D::size_type Level(0); Level < Texture.levels(); ++Level) { glTexSubImage2D( GL_TEXTURE_2D, GLint(Level), 0, 0, GLsizei(Texture[Level].dimensions().x), GLsizei(Texture[Level].dimensions().y), gli::external_format(Texture.format()), gli::type_format(Texture.format()), Texture[Level].data()); } glPixelStorei(GL_UNPACK_ALIGNMENT, 4); // Query the texture handle and make the texture resident TextureHandle = glGetTextureHandleNV(TextureName); glMakeTextureHandleResidentNV(TextureHandle); glBindTexture(GL_TEXTURE_2D, 0); return Validated; }
void flush(GLuint path) { glPathCommandsNV ( path, GLsizei(commands.size()), commands.data(), GLsizei(points.size() << 1), GL_FLOAT, points.data() ); commands.clear(); points.clear(); }
bool initTexture() { bool Validated(true); gli::texture2d Texture(gli::load_dds((getDataDirectory() + TEXTURE_DIFFUSE).c_str())); assert(!Texture.empty()); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); 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, 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_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); for(std::size_t Level = 0; Level < Texture.levels(); ++Level) { glCompressedTexImage2D(GL_TEXTURE_2D, GLint(Level), GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GLsizei(Texture[Level].extent().x), GLsizei(Texture[Level].extent().y), 0, GLsizei(Texture[Level].size()), Texture[Level].data()); } glm::ivec2 WindowSize(this->getWindowSize()); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, TextureName[texture::MULTISAMPLE]); this->checkError("initTexture 1"); glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_MAX_LEVEL, 0); this->checkError("initTexture 2"); glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_DEPTH_COMPONENT24, GLsizei(WindowSize.x), GLsizei(WindowSize.y), GL_TRUE); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); return Validated && this->checkError("initTexture"); }
inline void drawElementsInstancedBaseVertex( DrawElementsInstancedBaseVertexMode mode, GLsizei count, DrawElementsInstancedBaseVertexType type, GLvoid *indices, GLsizei primcount, GLint basevertex) { glDrawElementsInstancedBaseVertex( GLenum(mode), GLsizei(count), GLenum(type), (GLvoid*)(indices), GLsizei(primcount), GLint(basevertex)); }
// ************************************************************************* // ScissorRect::ScissorRect( float _x, float _y, float _w, float _h ) { // Store old state to restore it later m_wasEnabled = GL_RET_CALL(glIsEnabled, GL_SCISSOR_TEST) == GL_TRUE; GL_CALL(glGetIntegerv, GL_SCISSOR_BOX, m_previousRect); // TODO: Avoid glgetter IVec2 size = Device::GetBackbufferSize(); // Translate coordinates to absolute pixel coordinates and set directly. GL_CALL(glScissor, GLint((_x * 0.5f + 0.5f) * size[0]), GLint((_y * 0.5f + 0.5f) * size[1]), GLsizei(_w * 0.5f * size[0]), GLsizei(_h * 0.5f * size[1]) ); GL_CALL(glEnable, GL_SCISSOR_TEST); }
bool render() { glm::vec2 WindowSize(this->getWindowSize()); { glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]); glm::mat4* Pointer = (glm::mat4*)glMapBufferRange( GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT); glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x * 0.5f / WindowSize.y, 0.1f, 100.0f); glm::mat4 Model = glm::mat4(1.0f); *Pointer = Projection * this->view() * Model; // Make sure the uniform buffer is uploaded glUnmapBuffer(GL_UNIFORM_BUFFER); } float Depth(1.0f); glClearBufferfv(GL_DEPTH, 0, &Depth); glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]); glActiveTexture(GL_TEXTURE0 + sementics::sampler::RGB8); glBindTexture(GL_TEXTURE_2D, TextureName[texture::RGB8]); glActiveTexture(GL_TEXTURE0 + sementics::sampler::DXT1); glBindTexture(GL_TEXTURE_2D, TextureName[texture::DXT1]); glBindProgramPipeline(PipelineName); glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]); glBindVertexArray(VertexArrayName); glUseProgram(ProgramName); std::vector<GLuint> Index(2); Index[0] = sementics::sampling::RGB8; Index[1] = sementics::sampling::DXT1; glViewportIndexedf(0, 0, 0, GLfloat(WindowSize.x) / 2.0f, GLfloat(WindowSize.y)); glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, GLsizei(1), &Index[0]); glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_INT, nullptr, 1, 0); glViewportIndexedf(0, GLfloat(WindowSize.x) / 2.0f, 0, GLfloat(WindowSize.x) / 2.0f, GLfloat(WindowSize.y)); glUniformSubroutinesuiv(GL_FRAGMENT_SHADER, GLsizei(1), &Index[1]); glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_INT, nullptr, 1, 0); return true; }
void ScreenText::draw(GLContext* context) { if(!usedSize_) return; #ifdef SCIGMA_USE_OPENGL_3_2 glBindVertexArray(vertexArray_); #else glBindBuffer(GL_ARRAY_BUFFER,glBuffer_); prepare_attributes(); #endif glUniform4fv(fColorLocation_,1,fColor_); glUniform4fv(bColorLocation_,1,bColor_); glUniform2fv(offsetLocation_,1,offset_); switch(screenAnchor_) { case SCREEN_ANCHOR_BOTTOM_LEFT: glUniform4f(screenAnchorLocation_,-1,-1,0,0);break; case SCREEN_ANCHOR_BOTTOM_RIGHT: glUniform4f(screenAnchorLocation_,1,-1,0,0);break; case SCREEN_ANCHOR_TOP_RIGHT: glUniform4f(screenAnchorLocation_,1,1,0,0);;break; case SCREEN_ANCHOR_TOP_LEFT: glUniform4f(screenAnchorLocation_,-1,1,0,0);break; } glBindTexture(GL_TEXTURE_2D,font_.textureID); glPolygonMode(GL_FRONT_AND_BACK,GL_FILL); glDrawArrays(GL_TRIANGLES, 0, GLsizei(usedSize_/4)); GLERR; }
/// @brief Sets the render bounds /// @param fX Screen x coordinate, in [0, 1] /// @param fY Screen y coordinate, in [0, 1] /// @param fW Screen width, in [0, 1] /// @param fH Screen height, in [0, 1] /// @return 0 on failure, non-0 for success /// @note Tested int SetBounds (float fX, float fY, float fW, float fH) { Graphics::Main & g = Graphics::Main::Get(); fX *= g.mResW; fY = (1.0f - fY - fH) * g.mResH; fW *= g.mResW; fH *= g.mResH; fX = floorf(fX), fY = floorf(fY); fW = ceilf(fW), fH = ceilf(fH); glScissor(GLint(fX), GLint(fY), GLsizei(fW), GLsizei(fH)); return 1; }
void Raycaster::initDataItem(Raycaster::DataItem* dataItem) const { /* Calculate the appropriate volume texture's size: */ if(dataItem->hasNPOTDTextures) { /* Use the data size directly: */ for(int i=0;i<3;++i) dataItem->textureSize[i]=dataSize[i]; } else { /* Pad to the next power of two: */ for(int i=0;i<3;++i) for(dataItem->textureSize[i]=1;dataItem->textureSize[i]<GLsizei(dataSize[i]);dataItem->textureSize[i]<<=1) ; } /* Calculate the texture coordinate box for trilinear interpolation and the transformation from model space to data space: */ Point tcMin,tcMax; for(int i=0;i<3;++i) { tcMin[i]=Scalar(0.5)/Scalar(dataItem->textureSize[i]); tcMax[i]=(Scalar(dataSize[i])-Scalar(0.5))/Scalar(dataItem->textureSize[i]); Scalar scale=(tcMax[i]-tcMin[i])/domain.getSize(i); dataItem->mcScale[i]=GLfloat(scale); dataItem->mcOffset[i]=GLfloat(tcMin[i]-domain.min[i]*scale); } dataItem->texCoords=Box(tcMin,tcMax); }
// 塗り潰し円弧 // center_x, center_y 円の中心位置 // radius_x, radius_y 半径(横と縦) // start_rad, end_rad 開始・終了角度 // division 円の分割数(数値が大きいと滑らかな円になる) // color 色 void drawFillArc(const float center_x, const float center_y, const float radius_x, const float radius_y, const float start_rad, const float end_rad, const int division, const Color& color) { // 色を設定 color.setToGl(); // 頂点データを生成 std::vector<GLfloat> vtx; vtx.reserve(division * 2); // TIPS:正確な値である必要はない vtx.push_back(center_x); vtx.push_back(center_y); for (int i = 0; i <= division; ++i) { float r = ((end_rad - start_rad) * i) / division + start_rad; vtx.push_back(radius_x * std::sin(r) + center_x); vtx.push_back(radius_y * std::cos(r) + center_y); } glVertexPointer(2, GL_FLOAT, 0, &vtx[0]); glEnableClientState(GL_VERTEX_ARRAY); glDrawArrays(GL_TRIANGLE_FAN, 0, GLsizei(vtx.size() / 2)); glDisableClientState(GL_VERTEX_ARRAY); }
// 塗り潰し円 // center_x, center_y 円の中心位置 // radius_x, radius_y 半径(横と縦) // division 円の分割数(数値が大きいと滑らかな円になる) // color 色 void drawFillCircle(const float center_x, const float center_y, const float radius_x, const float radius_y, const int division, const Color& color) { // 色を設定 color.setToGl(); // 頂点データを生成 std::vector<GLfloat> vtx; vtx.reserve(division * 2); vtx.push_back(center_x); vtx.push_back(center_y); for (int i = 0; i <= division; ++i) { float r = (M_PI * 2.0 * i) / division; // 反時計回りが表面となる vtx.push_back(radius_x * -std::sin(r) + center_x); vtx.push_back(radius_y * std::cos(r) + center_y); } glVertexPointer(2, GL_FLOAT, 0, &vtx[0]); glEnableClientState(GL_VERTEX_ARRAY); glDrawArrays(GL_TRIANGLE_FAN, 0, GLsizei(vtx.size() / 2)); glDisableClientState(GL_VERTEX_ARRAY); }
// 円を描画 // center_x, center_y 円の中心位置 // radius_x, radius_y 半径(横と縦) // division 円の分割数(数値が大きいと滑らかな円になる) // line_width 線幅 // color 色 void drawCircle(const float center_x, const float center_y, const float radius_x, const float radius_y, const int division, const float line_width, const Color& color) { // 線分の太さを指示 glLineWidth(line_width); // 色を設定 color.setToGl(); // 頂点データを生成 std::vector<GLfloat> vtx; vtx.reserve(division * 2); for (int i = 0; i < division; ++i) { float r = (M_PI * 2.0 * i) / division; vtx.push_back(radius_x * std::sin(r) + center_x); vtx.push_back(radius_y * std::cos(r) + center_y); } glVertexPointer(2, GL_FLOAT, 0, &vtx[0]); glEnableClientState(GL_VERTEX_ARRAY); glDrawArrays(GL_LINE_LOOP, 0, GLsizei(vtx.size() / 2)); glDisableClientState(GL_VERTEX_ARRAY); }
bool PickingShaderForPointCloud::PrepareBinding(const Geometry &geometry, const RenderOption &option, const ViewControl &view, std::vector<Eigen::Vector3f> &points, std::vector<float> &indices) { if (geometry.GetGeometryType() != Geometry::GeometryType::PointCloud) { PrintShaderWarning("Rendering type is not PointCloud."); return false; } const PointCloud &pointcloud = (const PointCloud &)geometry; if (pointcloud.HasPoints() == false) { PrintShaderWarning("Binding failed with empty pointcloud."); return false; } points.resize(pointcloud.points_.size()); indices.resize(pointcloud.points_.size()); for (size_t i = 0; i < pointcloud.points_.size(); i++) { const auto &point = pointcloud.points_[i]; points[i] = point.cast<float>(); indices[i] = (float)i; } draw_arrays_mode_ = GL_POINTS; draw_arrays_size_ = GLsizei(points.size()); return true; }
bool render() { glm::vec2 WindowSize(this->getWindowSize()); { float Aspect = (WindowSize.x * 0.33f) / (WindowSize.y * 0.50f); glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, Aspect, 0.1f, 100.0f); glm::mat4 MVP = Projection * this->view() * glm::mat4(1.0f); *UniformPointer = MVP; } glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]); glBindProgramPipeline(PipelineName); glBindBuffersBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, 1, &BufferName[buffer::TRANSFORM]); glBindTextures(semantic::sampler::DIFFUSE, 1, &TextureName); glBindVertexArray(VertexArrayName); glBindVertexBuffer(semantic::buffer::STATIC, BufferName[buffer::VERTEX], 0, GLsizei(sizeof(vertex))); for(std::size_t Index = 0; Index < viewport::MAX; ++Index) { glViewportIndexedf(0, Viewport[Index].x, Viewport[Index].y, Viewport[Index].z, Viewport[Index].w); glBindSamplers(0, 1, &SamplerName[Index]); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1); } return true; }
void NVprPathRendererState::validate() { if (valid) { return; } NVprPathCacheProcessor processor(owner, path, fill_rule); owner->processSegments(processor); if (owner->style.do_stroke) { glPathParameteriNV(path, GL_PATH_JOIN_STYLE_NV, lineJoinConverter(owner)); glPathParameteriNV(path, GL_PATH_END_CAPS_NV, lineCapConverter(owner)); glPathParameterfNV(path, GL_PATH_STROKE_WIDTH_NV, owner->style.stroke_width); glPathParameterfNV(path, GL_PATH_MITER_LIMIT_NV, owner->style.miter_limit); if (owner->style.dash_array.size()) { glPathDashArrayNV(path, GLsizei(owner->style.dash_array.size()), &owner->style.dash_array[0]); glPathParameteriNV(path, GL_PATH_DASH_CAPS_NV, lineCapConverter(owner)); glPathParameterfNV(path, GL_PATH_DASH_OFFSET_NV, owner->style.dash_offset); GLenum dash_offset_reset = (owner->style.dash_phase == PathStyle::MOVETO_RESETS) ? GL_MOVE_TO_RESETS_NV : GL_MOVE_TO_CONTINUES_NV; glPathParameteriNV(path, GL_PATH_DASH_OFFSET_RESET_NV, dash_offset_reset); } else { glPathDashArrayNV(path, 0, NULL); } } valid = true; }
/* Render the leaf with buffer objects. */ void VertexBufferLeaf::renderBufferObject( VertexBufferState& state ) const { GLuint buffers[4]; for( int i = 0; i < 4; ++i ) buffers[i] = state.getBufferObject( reinterpret_cast< const char* >(this) + i ); if( buffers[VERTEX_OBJECT] == state.INVALID || buffers[NORMAL_OBJECT] == state.INVALID || buffers[COLOR_OBJECT] == state.INVALID || buffers[INDEX_OBJECT] == state.INVALID ) setupRendering( state, buffers ); if( state.useColors() ) { glBindBuffer( GL_ARRAY_BUFFER, buffers[COLOR_OBJECT] ); glColorPointer( 4, GL_UNSIGNED_BYTE, 0, 0 ); } glBindBuffer( GL_ARRAY_BUFFER, buffers[NORMAL_OBJECT] ); glNormalPointer( GL_FLOAT, 0, 0 ); glBindBuffer( GL_ARRAY_BUFFER, buffers[VERTEX_OBJECT] ); glVertexPointer( 3, GL_FLOAT, 0, 0 ); glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, buffers[INDEX_OBJECT] ); glDrawElements( GL_TRIANGLES, GLsizei( _indexLength ), GL_UNSIGNED_SHORT, 0 ); }
/* * \brief Method that draws the polyhedron to the currently bound buffer * \param[in] shader the shader containing the uniforms to be bound in the method */ void Polyhedron::draw(Shader & shader) { glEnableVertexAttribArray(0); glBindBuffer(GL_ARRAY_BUFFER, m_buffer_id[0]); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_buffer_id[5]); computeModelMatrix(); glm::mat4 MVP = m_projection_matrix * m_view_matrix * m_model_matrix; glm::mat3 M3x3 = glm::mat3(glm::transpose(glm::inverse(m_model_matrix))); glm::mat4 V_inv = glm::inverse(m_view_matrix); glUniformMatrix4fv(shader.getUniform("M"), 1, GL_FALSE, &m_model_matrix[0][0]); glUniformMatrix4fv(shader.getUniform("MVP"), 1, GL_FALSE, &MVP[0][0]); glUniformMatrix4fv(shader.getUniform("V_inv"), 1, GL_FALSE, &V_inv[0][0]); glUniformMatrix3fv(shader.getUniform("M3x3"), 1, GL_FALSE, &M3x3[0][0]); glUniform3fv(shader.getUniform("material_color"), 1, &m_color[0]); glUniform1i(shader.getUniform("normal_computation_mode"), m_normal_computation_mode); //Patches for geometry shader glDrawElements(GL_PATCHES, GLsizei(m_indexes.size()), GL_UNSIGNED_SHORT, 0); glDisableVertexAttribArray(0); }
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; }
bool initTexture() { std::size_t const Size(32); std::vector<float> Data(Size * Size * Size); for(std::size_t k = 0; k < Size; ++k) for(std::size_t j = 0; j < Size; ++j) for(std::size_t i = 0; i < Size; ++i) Data[i + j * Size + k * Size * Size] = glm::simplex(glm::vec4(i, j, k, 0.0f) / float((Size / 8 - 1))); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glGenTextures(1, &TextureName); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_3D, TextureName); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_BASE_LEVEL, 0); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAX_LEVEL, int(glm::log2(float(Size)))); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE); glTexImage3D( GL_TEXTURE_3D, 0, GL_R32F, GLsizei(Size), GLsizei(Size), GLsizei(Size), 0, GL_RED, GL_FLOAT, &Data[0]); glGenerateMipmap(GL_TEXTURE_3D); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); GLuint FramebufferName = 0; glGenFramebuffers(1, &FramebufferName); glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName); glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, TextureName, 0); return this->checkError("initTexture"); }
bool render() { glm::ivec2 WindowSize(this->getWindowSize()); glm::vec3 MinScissor( 10000.f); glm::vec3 MaxScissor(-10000.f); { glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]); glm::mat4* Pointer = (glm::mat4*)glMapBufferRange( GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT); glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, 4.0f / 3.0f, 0.1f, 100.0f); glm::mat4 View = this->view(); glm::mat4 Model = glm::mat4(1.0f); *Pointer = Projection * View * Model; // Make sure the uniform buffer is uploaded glUnmapBuffer(GL_UNIFORM_BUFFER); glm::mat4 Ortho = glm::ortho(0.0f, 0.0f, float(WindowSize.x), float(WindowSize.y)); for(GLsizei i = 0; i < VertexCount; ++i) { glm::vec3 Projected = glm::project( glm::vec3(VertexData[i].Position, 0.0f), View * Model, Projection, glm::ivec4(0, 0, WindowSize.x, WindowSize.y)); MinScissor = glm::min(MinScissor, glm::vec3(Projected)); MaxScissor = glm::max(MaxScissor, glm::vec3(Projected)); } } glViewport(0, 0, WindowSize.x, WindowSize.y); glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]); glScissor(GLint(MinScissor.x), GLint(MinScissor.y), GLsizei(MaxScissor.x - MinScissor.x), GLsizei(MaxScissor.y - MinScissor.y)); glEnable(GL_SCISSOR_TEST); glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]); // Bind the program for use glUseProgram(ProgramName); glUniform1i(UniformDiffuse, 0); glUniformBlockBinding(ProgramName, UniformTransform, semantic::uniform::TRANSFORM0); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, TextureName); glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]); glBindVertexArray(VertexArrayName); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1); glDisable(GL_SCISSOR_TEST); return true; }
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 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"); }
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"); }
void GL1GraphicContextProvider::set_viewport(const Rectf &viewport) { set_active(); glViewport( GLsizei(viewport.left), GLsizei(viewport.top), GLsizei(viewport.right - viewport.left), GLsizei(viewport.bottom - viewport.top)); }