Texture::Texture(const Image& image, MipmapGeneration mipmapGeneration, TextureFiltering filtering, bool clamp, const GLInfo& glInfo)
{
glGenTextures(1, &id);
Bind();
bool linearFiltering = (filtering == TextureFiltering::Linear);
GLint minFilterParam;
if (mipmapGeneration == MipmapGeneration::None)
{
minFilterParam = linearFiltering ? GL_LINEAR : GL_NEAREST;
}
else
{
minFilterParam = linearFiltering ? GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_LINEAR;
}
GLint magFilterParam = linearFiltering ? GL_LINEAR : GL_NEAREST;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilterParam);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilterParam);
GenerateMipmaps(image, mipmapGeneration, glInfo);
bool doClamp = (clamp && (GLEW_VERSION_1_2 || glewIsExtensionSupported("GL_EXT_texture_edge_clamp")));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, doClamp ? GL_CLAMP_TO_EDGE : GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, doClamp ? GL_CLAMP_TO_EDGE : GL_REPEAT);
}
RenderVolumeCollection* VoxelMipmapRenderPass::Execute (const Scene* scene, const Camera* camera, RenderVolumeCollection* rvc)
{
if (_firstTime || _continuousVoxelization) {
/*
* Start mipmapping pass
*/
StartVoxelMipmaping ();
/*
* Mipmapping pass
*/
GenerateMipmaps (rvc);
/*
* End mipmapping pass
*/
EndVoxelMipmaping ();
_firstTime = false;
}
return rvc;
}
bool CD3DTexture::CreateInternal(const void* pixels /* nullptr */, unsigned int srcPitch /* 0 */)
{
ID3D11Device* pD3DDevice = g_Windowing.Get3D11Device();
ID3D11DeviceContext* pD3D11Context = g_Windowing.Get3D11Context();
UINT miscFlags = 0;
bool autogenmm = false;
if (m_mipLevels == 0 && g_Windowing.IsFormatSupport(m_format, D3D11_FORMAT_SUPPORT_MIP_AUTOGEN))
{
autogenmm = pixels != nullptr;
miscFlags |= D3D11_RESOURCE_MISC_GENERATE_MIPS;
}
else
m_mipLevels = 1;
CD3D11_TEXTURE2D_DESC textureDesc(m_format, m_width, m_height, 1, m_mipLevels, m_bindFlags, m_usage, m_cpuFlags, 1, 0, miscFlags);
D3D11_SUBRESOURCE_DATA initData = { 0 };
initData.pSysMem = pixels;
initData.SysMemPitch = srcPitch ? srcPitch : CD3DHelper::BitsPerPixel(m_format) * m_width / 8;
initData.SysMemSlicePitch = 0;
HRESULT hr = pD3DDevice->CreateTexture2D(&textureDesc, (!autogenmm && pixels) ? &initData : nullptr, &m_texture);
if (SUCCEEDED(hr) && autogenmm)
{
pD3D11Context->UpdateSubresource(m_texture, 0, nullptr, pixels,
(srcPitch ? srcPitch : CD3DHelper::BitsPerPixel(m_format) * m_width / 8), 0);
}
if (autogenmm)
GenerateMipmaps();
return SUCCEEDED(hr);
}
void TextureOpenGL::check_mips() {
if (m_mip_filter!=TEX_FILTER_NONE) {
if (!m_have_mipmaps) {
GenerateMipmaps();
}
}
}
//-----------------------------------------------------------------------------
// Gets the texture all internally consistent assuming you've loaded
// mip 0 of all faces of all frames
//-----------------------------------------------------------------------------
void CVTFTexture::PostProcess(bool bGenerateSpheremap, LookDir_t lookDir)
{
Assert( m_Format == IMAGE_FORMAT_RGBA8888 );
// Set up the cube map faces
if (IsCubeMap())
{
// Rotate the cubemaps so they're appropriate for the material system
FixCubemapFaceOrientation();
// FIXME: We could theoretically not compute spheremap mip levels
// in generate spheremaps; should we? The trick is when external
// clients can be expected to call it
// Compute the spheremap fallback for cubemaps if we weren't able to load up one...
if (bGenerateSpheremap)
GenerateSpheremap(lookDir);
}
// Generate mipmap levels
GenerateMipmaps();
if( Flags() & TEXTUREFLAGS_ONEOVERMIPLEVELINALPHA )
{
PutOneOverMipLevelInAlpha();
}
// Compute reflectivity
ComputeReflectivity();
// Are we 8-bit or 1-bit alpha?
// NOTE: We have to do this *after* computing the spheremap fallback for
// cubemaps or it'll throw the flags off
ComputeAlphaFlags();
}
void Texture2D::ApplyTextureParameters(bool _generateMipmaps)
{
// Check if we should generate the mipmaps
if (_generateMipmaps)
{
// Generate the mipmaps
GenerateMipmaps();
}
// Check if we have a param list
if (m_NameArray.size())
{
// For each param
for (int i = 0; i < m_NameArray.size(); i++)
{
// Apply the param
glTexParameteri(GL_TEXTURE_2D, m_NameArray[i], m_Param[i]);
}
}
// Use the default param list
else
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
_generateMipmaps ? glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR) : glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
}
void Texture::AllocateResources()
{
glGenTextures(1, &mTextureId);
glBindTexture(GL_TEXTURE_2D, mTextureId);
SetUpFilter();
SetUpWrapping();
if (mDataType == DF_UNSIGNED_CHAR)
{
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
}
glTexImage2D(GL_TEXTURE_2D, 0, mBytesPerPixel, mWidth, mHeight, 0, GetInternalFormatMapping(), GetDataTypeMapping(), mpData);
if (mFilter == FM_MIPMAPS)
{
GenerateMipmaps();
}
// TODO: check allocation errors!
}
