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));
}
