Home | History | Annotate | Download | only in opengl
      1 /*-------------------------------------------------------------------------
      2  * drawElements Quality Program OpenGL ES Utilities
      3  * ------------------------------------------------
      4  *
      5  * Copyright 2014 The Android Open Source Project
      6  *
      7  * Licensed under the Apache License, Version 2.0 (the "License");
      8  * you may not use this file except in compliance with the License.
      9  * You may obtain a copy of the License at
     10  *
     11  *      http://www.apache.org/licenses/LICENSE-2.0
     12  *
     13  * Unless required by applicable law or agreed to in writing, software
     14  * distributed under the License is distributed on an "AS IS" BASIS,
     15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     16  * See the License for the specific language governing permissions and
     17  * limitations under the License.
     18  *
     19  *//*!
     20  * \file
     21  * \brief OpenGL ES context wrapper that uses FBO as default framebuffer.
     22  *//*--------------------------------------------------------------------*/
     23 
     24 #include "gluFboRenderContext.hpp"
     25 #include "gluContextFactory.hpp"
     26 #include "gluRenderConfig.hpp"
     27 #include "glwEnums.hpp"
     28 #include "glwFunctions.hpp"
     29 #include "tcuCommandLine.hpp"
     30 #include "gluTextureUtil.hpp"
     31 #include "tcuTextureUtil.hpp"
     32 
     33 #include <sstream>
     34 
     35 namespace glu
     36 {
     37 
     38 static int getNumDepthBits (const tcu::TextureFormat& format)
     39 {
     40 	if (format.order == tcu::TextureFormat::DS)
     41 	{
     42 		const tcu::TextureFormat	depthOnlyFormat		= tcu::getEffectiveDepthStencilTextureFormat(format, tcu::Sampler::MODE_DEPTH);
     43 		return tcu::getTextureFormatBitDepth(depthOnlyFormat).x();
     44 	}
     45 	else if (format.order == tcu::TextureFormat::D)
     46 		return tcu::getTextureFormatBitDepth(format).x();
     47 	else
     48 		return 0;
     49 }
     50 
     51 static int getNumStencilBits (const tcu::TextureFormat& format)
     52 {
     53 	if (format.order == tcu::TextureFormat::DS)
     54 	{
     55 		const tcu::TextureFormat	stencilOnlyFormat		= tcu::getEffectiveDepthStencilTextureFormat(format, tcu::Sampler::MODE_STENCIL);
     56 		return tcu::getTextureFormatBitDepth(stencilOnlyFormat).x();
     57 	}
     58 	else if (format.order == tcu::TextureFormat::S)
     59 		return tcu::getTextureFormatBitDepth(format).x();
     60 	else
     61 		return 0;
     62 }
     63 
     64 static tcu::PixelFormat getPixelFormat (deUint32 colorFormat)
     65 {
     66 	const tcu::IVec4 bits = tcu::getTextureFormatBitDepth(glu::mapGLInternalFormat(colorFormat));
     67 	return tcu::PixelFormat(bits[0], bits[1], bits[2], bits[3]);
     68 }
     69 
     70 static void getDepthStencilBits (deUint32 depthStencilFormat, int* depthBits, int* stencilBits)
     71 {
     72 	const tcu::TextureFormat	combinedFormat	= glu::mapGLInternalFormat(depthStencilFormat);
     73 
     74 	*depthBits		= getNumDepthBits(combinedFormat);
     75 	*stencilBits	= getNumStencilBits(combinedFormat);
     76 }
     77 
     78 deUint32 chooseColorFormat (const glu::RenderConfig& config)
     79 {
     80 	static const deUint32 s_formats[] =
     81 	{
     82 		GL_RGBA8,
     83 		GL_RGB8,
     84 		GL_RG8,
     85 		GL_R8,
     86 		GL_RGBA4,
     87 		GL_RGB5_A1,
     88 		GL_RGB565,
     89 		GL_RGB5
     90 	};
     91 
     92 	for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(s_formats); fmtNdx++)
     93 	{
     94 		const deUint32		format	= s_formats[fmtNdx];
     95 		const tcu::IVec4	bits	= tcu::getTextureFormatBitDepth(glu::mapGLInternalFormat(format));
     96 
     97 		if (config.redBits != glu::RenderConfig::DONT_CARE &&
     98 			config.redBits != bits[0])
     99 			continue;
    100 
    101 		if (config.greenBits != glu::RenderConfig::DONT_CARE &&
    102 			config.greenBits != bits[1])
    103 			continue;
    104 
    105 		if (config.blueBits != glu::RenderConfig::DONT_CARE &&
    106 			config.blueBits != bits[2])
    107 			continue;
    108 
    109 		if (config.alphaBits != glu::RenderConfig::DONT_CARE &&
    110 			config.alphaBits != bits[3])
    111 			continue;
    112 
    113 		return format;
    114 	}
    115 
    116 	return 0;
    117 }
    118 
    119 deUint32 chooseDepthStencilFormat (const glu::RenderConfig& config)
    120 {
    121 	static const deUint32 s_formats[] =
    122 	{
    123 		GL_DEPTH32F_STENCIL8,
    124 		GL_DEPTH24_STENCIL8,
    125 		GL_DEPTH_COMPONENT32F,
    126 		GL_DEPTH_COMPONENT24,
    127 		GL_DEPTH_COMPONENT16,
    128 		GL_STENCIL_INDEX8
    129 	};
    130 
    131 	for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(s_formats); fmtNdx++)
    132 	{
    133 		const deUint32				format			= s_formats[fmtNdx];
    134 		const tcu::TextureFormat	combinedFormat	= glu::mapGLInternalFormat(format);
    135 		const int					depthBits		= getNumDepthBits(combinedFormat);
    136 		const int					stencilBits		= getNumStencilBits(combinedFormat);
    137 
    138 		if (config.depthBits != glu::RenderConfig::DONT_CARE &&
    139 			config.depthBits != depthBits)
    140 			continue;
    141 
    142 		if (config.stencilBits != glu::RenderConfig::DONT_CARE &&
    143 			config.stencilBits != stencilBits)
    144 			continue;
    145 
    146 		return format;
    147 	}
    148 
    149 	return 0;
    150 }
    151 
    152 FboRenderContext::FboRenderContext (RenderContext* context, const RenderConfig& config)
    153 	: m_context				(context)
    154 	, m_framebuffer			(0)
    155 	, m_colorBuffer			(0)
    156 	, m_depthStencilBuffer	(0)
    157 	, m_renderTarget		()
    158 {
    159 	try
    160 	{
    161 		createFramebuffer(config);
    162 	}
    163 	catch (...)
    164 	{
    165 		destroyFramebuffer();
    166 		throw;
    167 	}
    168 }
    169 
    170 FboRenderContext::FboRenderContext (const ContextFactory& factory, const RenderConfig& config, const tcu::CommandLine& cmdLine)
    171 	: m_context				(DE_NULL)
    172 	, m_framebuffer			(0)
    173 	, m_colorBuffer			(0)
    174 	, m_depthStencilBuffer	(0)
    175 	, m_renderTarget		()
    176 {
    177 	try
    178 	{
    179 		RenderConfig nativeRenderConfig;
    180 		nativeRenderConfig.type				= config.type;
    181 		nativeRenderConfig.windowVisibility	= config.windowVisibility;
    182 		// \note All other properties are defaults, mostly DONT_CARE
    183 		m_context = factory.createContext(nativeRenderConfig, cmdLine);
    184 		createFramebuffer(config);
    185 	}
    186 	catch (...)
    187 	{
    188 		delete m_context;
    189 		throw;
    190 	}
    191 }
    192 
    193 FboRenderContext::~FboRenderContext (void)
    194 {
    195 	// \todo [2013-04-08 pyry] Do we want to destry FBO before destroying context?
    196 	delete m_context;
    197 }
    198 
    199 void FboRenderContext::postIterate (void)
    200 {
    201 	// \todo [2012-11-27 pyry] Blit to default framebuffer in ES3?
    202 	m_context->getFunctions().finish();
    203 }
    204 
    205 void FboRenderContext::createFramebuffer (const RenderConfig& config)
    206 {
    207 	DE_ASSERT(m_framebuffer == 0 && m_colorBuffer == 0 && m_depthStencilBuffer == 0);
    208 
    209 	const glw::Functions&	gl					= m_context->getFunctions();
    210 	const deUint32			colorFormat			= chooseColorFormat(config);
    211 	const deUint32			depthStencilFormat	= chooseDepthStencilFormat(config);
    212 	int						width				= config.width;
    213 	int						height				= config.height;
    214 	tcu::PixelFormat		pixelFormat;
    215 	int						depthBits			= 0;
    216 	int						stencilBits			= 0;
    217 
    218 	if (config.numSamples > 0 && !gl.renderbufferStorageMultisample)
    219 		throw tcu::NotSupportedError("Multisample FBO is not supported");
    220 
    221 	if (colorFormat == 0)
    222 		throw tcu::NotSupportedError("Unsupported color attachment format");
    223 
    224 	if (width == glu::RenderConfig::DONT_CARE || height == glu::RenderConfig::DONT_CARE)
    225 	{
    226 		int maxSize = 0;
    227 		gl.getIntegerv(GL_MAX_RENDERBUFFER_SIZE, &maxSize);
    228 
    229 		width	= (width	== glu::RenderConfig::DONT_CARE) ? maxSize : width;
    230 		height	= (height	== glu::RenderConfig::DONT_CARE) ? maxSize : height;
    231 	}
    232 
    233 	{
    234 		pixelFormat = getPixelFormat(colorFormat);
    235 
    236 		gl.genRenderbuffers(1, &m_colorBuffer);
    237 		gl.bindRenderbuffer(GL_RENDERBUFFER, m_colorBuffer);
    238 
    239 		if (config.numSamples > 0)
    240 			gl.renderbufferStorageMultisample(GL_RENDERBUFFER, config.numSamples, colorFormat, width, height);
    241 		else
    242 			gl.renderbufferStorage(GL_RENDERBUFFER, colorFormat, width, height);
    243 
    244 		gl.bindRenderbuffer(GL_RENDERBUFFER, 0);
    245 		GLU_EXPECT_NO_ERROR(gl.getError(), "Creating color renderbuffer");
    246 	}
    247 
    248 	if (depthStencilFormat != GL_NONE)
    249 	{
    250 		getDepthStencilBits(depthStencilFormat, &depthBits, &stencilBits);
    251 
    252 		gl.genRenderbuffers(1, &m_depthStencilBuffer);
    253 		gl.bindRenderbuffer(GL_RENDERBUFFER, m_depthStencilBuffer);
    254 
    255 		if (config.numSamples > 0)
    256 			gl.renderbufferStorageMultisample(GL_RENDERBUFFER, config.numSamples, depthStencilFormat, width, height);
    257 		else
    258 			gl.renderbufferStorage(GL_RENDERBUFFER, depthStencilFormat, width, height);
    259 
    260 		gl.bindRenderbuffer(GL_RENDERBUFFER, 0);
    261 		GLU_EXPECT_NO_ERROR(gl.getError(), "Creating depth / stencil renderbuffer");
    262 	}
    263 
    264 	gl.genFramebuffers(1, &m_framebuffer);
    265 	gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
    266 
    267 	if (m_colorBuffer)
    268 		gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_colorBuffer);
    269 
    270 	if (m_depthStencilBuffer)
    271 	{
    272 		if (depthBits > 0)
    273 			gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer);
    274 
    275 		if (stencilBits > 0)
    276 			gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilBuffer);
    277 	}
    278 
    279 	GLU_EXPECT_NO_ERROR(gl.getError(), "Creating framebuffer");
    280 
    281 	if (gl.checkFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
    282 		throw tcu::NotSupportedError("Framebuffer is not complete");
    283 
    284 	// Set up correct viewport for first test case.
    285 	gl.viewport(0, 0, width, height);
    286 
    287 	m_renderTarget = tcu::RenderTarget(width, height, pixelFormat, depthBits, stencilBits, config.numSamples);
    288 }
    289 
    290 void FboRenderContext::destroyFramebuffer (void)
    291 {
    292 	const glw::Functions& gl = m_context->getFunctions();
    293 
    294 	if (m_framebuffer)
    295 	{
    296 		gl.deleteFramebuffers(1, &m_framebuffer);
    297 		m_framebuffer = 0;
    298 	}
    299 
    300 	if (m_depthStencilBuffer)
    301 	{
    302 		gl.deleteRenderbuffers(1, &m_depthStencilBuffer);
    303 		m_depthStencilBuffer = 0;
    304 	}
    305 
    306 	if (m_colorBuffer)
    307 	{
    308 		gl.deleteRenderbuffers(1, &m_colorBuffer);
    309 		m_colorBuffer = 0;
    310 	}
    311 }
    312 
    313 } // glu
    314