1/*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES 3.0 Module
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 Polygon offset tests.
22 *//*--------------------------------------------------------------------*/
23
24#include "es3fPolygonOffsetTests.hpp"
25#include "deStringUtil.hpp"
26#include "deRandom.hpp"
27#include "gluContextInfo.hpp"
28#include "gluRenderContext.hpp"
29#include "gluShaderProgram.hpp"
30#include "gluPixelTransfer.hpp"
31#include "gluStrUtil.hpp"
32#include "glwEnums.hpp"
33#include "glwDefs.hpp"
34#include "glwFunctions.hpp"
35#include "tcuTestContext.hpp"
36#include "tcuTestLog.hpp"
37#include "tcuTextureUtil.hpp"
38#include "tcuRenderTarget.hpp"
39#include "tcuVectorUtil.hpp"
40#include "rrRenderer.hpp"
41#include "rrFragmentOperations.hpp"
42
43#include "sglrReferenceContext.hpp"
44
45#include <string>
46#include <limits>
47
48using namespace glw; // GLint and other GL types
49
50namespace deqp
51{
52namespace gles3
53{
54namespace Functional
55{
56namespace
57{
58
59const char* s_shaderSourceVertex	= "#version 300 es\n"
60									  "in highp vec4 a_position;\n"
61									  "in highp vec4 a_color;\n"
62									  "out highp vec4 v_color;\n"
63									  "void main (void)\n"
64									  "{\n"
65									  "	gl_Position = a_position;\n"
66									  "	v_color = a_color;\n"
67									  "}\n";
68const char* s_shaderSourceFragment	= "#version 300 es\n"
69									  "in highp vec4 v_color;\n"
70									  "layout(location = 0) out mediump vec4 fragColor;"
71									  "void main (void)\n"
72									  "{\n"
73									  "	fragColor = v_color;\n"
74									  "}\n";
75
76static const tcu::Vec4	MASK_COLOR_OK	= tcu::Vec4(0.0f, 0.1f, 0.0f, 1.0f);
77static const tcu::Vec4	MASK_COLOR_DEV	= tcu::Vec4(0.8f, 0.5f, 0.0f, 1.0f);
78static const tcu::Vec4	MASK_COLOR_FAIL	= tcu::Vec4(1.0f, 0.0f, 1.0f, 1.0f);
79
80inline bool compareThreshold (const tcu::IVec4& a, const tcu::IVec4& b, const tcu::IVec4& threshold)
81{
82	return tcu::boolAll(tcu::lessThanEqual(tcu::abs(a - b), threshold));
83}
84
85/*--------------------------------------------------------------------*//*!
86* \brief Pixelwise comparison of two images.
87* \note copied & modified from glsRasterizationTests
88*
89* Kernel radius defines maximum allowed distance. If radius is 0, only
90* perfect match is allowed. Radius of 1 gives a 3x3 kernel.
91*
92* Return values: -1 = Perfect match
93* 0 = Deviation within kernel
94* >0 = Number of faulty pixels
95*//*--------------------------------------------------------------------*/
96int compareImages (tcu::TestLog& log, glu::RenderContext& renderCtx, const tcu::ConstPixelBufferAccess& test, const tcu::ConstPixelBufferAccess& ref, const tcu::PixelBufferAccess& diffMask, int radius)
97{
98	const int			height			= test.getHeight();
99	const int			width			= test.getWidth();
100	const int			colorThreshold	= 128;
101	const tcu::RGBA		formatThreshold	= renderCtx.getRenderTarget().getPixelFormat().getColorThreshold();
102	const tcu::IVec4	threshold		= tcu::IVec4(colorThreshold, colorThreshold, colorThreshold, formatThreshold.getAlpha() > 0 ? colorThreshold : 0)
103										+ tcu::IVec4(formatThreshold.getRed(), formatThreshold.getGreen(), formatThreshold.getBlue(), formatThreshold.getAlpha());
104
105	int			deviatingPixels = 0;
106	int			faultyPixels	= 0;
107	int			compareFailed	= -1;
108
109	tcu::clear(diffMask, MASK_COLOR_OK);
110
111	for (int y = 0; y < height; y++)
112	{
113		for (int x = 0; x < width; x++)
114		{
115			const tcu::IVec4 cRef = ref.getPixelInt(x, y);
116
117			// Pixelwise match, no deviation or fault
118			{
119				const tcu::IVec4 cTest = test.getPixelInt(x, y);
120				if (compareThreshold(cRef, cTest, threshold))
121					continue;
122			}
123
124			// If not, search within kernel radius
125			{
126				const int kYmin = deMax32(y - radius, 0);
127				const int kYmax = deMin32(y + radius, height-1);
128				const int kXmin = deMax32(x - radius, 0);
129				const int kXmax = deMin32(x + radius, width-1);
130				bool found = false;
131
132				for (int kY = kYmin; kY <= kYmax; kY++)
133				for (int kX = kXmin; kX <= kXmax; kX++)
134				{
135					const tcu::IVec4 cTest = test.getPixelInt(kX, kY);
136					if (compareThreshold(cRef, cTest, threshold))
137						found = true;
138				}
139
140				if (found)	// The pixel is deviating if the color is found inside the kernel
141				{
142					diffMask.setPixel(MASK_COLOR_DEV, x, y);
143					if (compareFailed == -1)
144						compareFailed = 0;
145					deviatingPixels++;
146					continue;
147				}
148			}
149
150			diffMask.setPixel(MASK_COLOR_FAIL, x, y);
151			faultyPixels++;										// The pixel is faulty if the color is not found
152			compareFailed = 1;
153		}
154	}
155
156	log << tcu::TestLog::Message << faultyPixels << " faulty pixel(s) found." << tcu::TestLog::EndMessage;
157
158	return (compareFailed == 1 ? faultyPixels : compareFailed);
159}
160
161void verifyImages (tcu::TestLog& log, tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const tcu::ConstPixelBufferAccess& testImage, const tcu::ConstPixelBufferAccess& referenceImage)
162{
163	using tcu::TestLog;
164
165	const int			kernelRadius		= 1;
166	const int			faultyPixelLimit	= 20;
167	int					faultyPixels;
168	tcu::Surface		diffMask			(testImage.getWidth(), testImage.getHeight());
169
170	faultyPixels = compareImages(log, renderCtx, referenceImage, testImage, diffMask.getAccess(), kernelRadius);
171
172	if (faultyPixels > faultyPixelLimit)
173	{
174		log << TestLog::ImageSet("Images", "Image comparison");
175		log << TestLog::Image("Test image", "Test image", testImage);
176		log << TestLog::Image("Reference image", "Reference image", referenceImage);
177		log << TestLog::Image("Difference mask", "Difference mask", diffMask.getAccess());
178		log << TestLog::EndImageSet;
179
180		log << tcu::TestLog::Message << "Got " << faultyPixels << " faulty pixel(s)." << tcu::TestLog::EndMessage;
181		testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got faulty pixels");
182	}
183}
184
185void verifyError (tcu::TestContext& testCtx, const glw::Functions& gl, GLenum expected)
186{
187	deUint32 got = gl.getError();
188	if (got != expected)
189	{
190		testCtx.getLog() << tcu::TestLog::Message << "// ERROR: expected " << glu::getErrorStr(expected) << "; got " << glu::getErrorStr(got) << tcu::TestLog::EndMessage;
191		if (testCtx.getTestResult() == QP_TEST_RESULT_PASS)
192			testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got invalid error");
193	}
194}
195
196void checkCanvasSize (int width, int height, int minWidth, int minHeight)
197{
198	if (width < minWidth || height < minHeight)
199		throw tcu::NotSupportedError(std::string("Render context size must be at least ") + de::toString(minWidth) + "x" + de::toString(minWidth));
200}
201
202class PositionColorShader : public sglr::ShaderProgram
203{
204public:
205	enum
206	{
207		VARYINGLOC_COLOR = 0
208	};
209
210			PositionColorShader (void);
211	void	shadeVertices		(const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const;
212	void	shadeFragments		(rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const;
213};
214
215PositionColorShader::PositionColorShader (void)
216	: sglr::ShaderProgram(sglr::pdec::ShaderProgramDeclaration()
217							<< sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT)
218							<< sglr::pdec::VertexAttribute("a_color", rr::GENERICVECTYPE_FLOAT)
219							<< sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT)
220							<< sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT)
221							<< sglr::pdec::VertexSource(s_shaderSourceVertex)
222							<< sglr::pdec::FragmentSource(s_shaderSourceFragment))
223{
224}
225
226void PositionColorShader::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
227{
228	for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
229	{
230		const int positionAttrLoc = 0;
231		const int colorAttrLoc = 1;
232
233		rr::VertexPacket& packet = *packets[packetNdx];
234
235		// Transform to position
236		packet.position = rr::readVertexAttribFloat(inputs[positionAttrLoc], packet.instanceNdx, packet.vertexNdx);
237
238		// Pass color to FS
239		packet.outputs[VARYINGLOC_COLOR] = rr::readVertexAttribFloat(inputs[colorAttrLoc], packet.instanceNdx, packet.vertexNdx);
240	}
241}
242
243void PositionColorShader::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
244{
245	for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
246	{
247		rr::FragmentPacket& packet = packets[packetNdx];
248
249		for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
250			rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, rr::readTriangleVarying<float>(packet, context, VARYINGLOC_COLOR, fragNdx));
251	}
252}
253
254// PolygonOffsetTestCase
255
256class PolygonOffsetTestCase : public TestCase
257{
258public:
259					PolygonOffsetTestCase	(Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName, int canvasSize);
260
261	virtual void	testPolygonOffset		(void) = DE_NULL;
262	IterateResult	iterate					(void);
263
264protected:
265	const GLenum	m_internalFormat;
266	const char*		m_internalFormatName;
267	const int		m_targetSize;
268};
269
270PolygonOffsetTestCase::PolygonOffsetTestCase (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName, int canvasSize)
271	: TestCase				(context, name, description)
272	, m_internalFormat		(internalFormat)
273	, m_internalFormatName	(internalFormatName)
274	, m_targetSize			(canvasSize)
275{
276}
277
278PolygonOffsetTestCase::IterateResult PolygonOffsetTestCase::iterate (void)
279{
280	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
281	m_testCtx.getLog() << tcu::TestLog::Message << "Testing PolygonOffset with " << m_internalFormatName << " depth buffer." << tcu::TestLog::EndMessage;
282
283	if (m_internalFormat == 0)
284	{
285		// default framebuffer
286		const int width		= m_context.getRenderTarget().getWidth();
287		const int height	= m_context.getRenderTarget().getHeight();
288
289		checkCanvasSize(width, height, m_targetSize, m_targetSize);
290
291		if (m_context.getRenderTarget().getDepthBits() == 0)
292			throw tcu::NotSupportedError("polygon offset tests require depth buffer");
293
294		testPolygonOffset();
295	}
296	else
297	{
298		const glw::Functions& gl = m_context.getRenderContext().getFunctions();
299
300		// framebuffer object
301		GLuint	colorRboId	= 0;
302		GLuint	depthRboId	= 0;
303		GLuint	fboId		= 0;
304		bool	fboComplete;
305
306		gl.genRenderbuffers(1, &colorRboId);
307		gl.bindRenderbuffer(GL_RENDERBUFFER, colorRboId);
308		gl.renderbufferStorage(GL_RENDERBUFFER, GL_RGBA4, m_targetSize, m_targetSize);
309		verifyError(m_testCtx, gl, GL_NO_ERROR);
310
311		gl.genRenderbuffers(1, &depthRboId);
312		gl.bindRenderbuffer(GL_RENDERBUFFER, depthRboId);
313		gl.renderbufferStorage(GL_RENDERBUFFER, m_internalFormat, m_targetSize, m_targetSize);
314		verifyError(m_testCtx, gl, GL_NO_ERROR);
315
316		gl.genFramebuffers(1, &fboId);
317		gl.bindFramebuffer(GL_FRAMEBUFFER, fboId);
318		gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, colorRboId);
319		gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,	GL_RENDERBUFFER, depthRboId);
320		verifyError(m_testCtx, gl, GL_NO_ERROR);
321
322		fboComplete = gl.checkFramebufferStatus(GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE;
323
324		if (fboComplete)
325			testPolygonOffset();
326
327		gl.deleteFramebuffers(1, &fboId);
328		gl.deleteRenderbuffers(1, &depthRboId);
329		gl.deleteRenderbuffers(1, &colorRboId);
330
331		if (!fboComplete)
332			throw tcu::NotSupportedError("could not create fbo for testing.");
333	}
334
335	return STOP;
336}
337
338// UsageTestCase
339
340class UsageTestCase : public PolygonOffsetTestCase
341{
342public:
343			UsageTestCase		(Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName);
344
345	void	testPolygonOffset	(void);
346};
347
348UsageTestCase::UsageTestCase (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName)
349	: PolygonOffsetTestCase(context, name, description, internalFormat, internalFormatName, 200)
350{
351}
352
353void UsageTestCase::testPolygonOffset (void)
354{
355	using tcu::TestLog;
356
357	const tcu::Vec4 triangle[] =
358	{
359		tcu::Vec4(-1,  1,  0,  1),
360		tcu::Vec4( 1,  1,  0,  1),
361		tcu::Vec4( 1, -1,  0,  1),
362	};
363
364	tcu::TestLog&		log				= m_testCtx.getLog();
365	tcu::Surface		testImage		(m_targetSize, m_targetSize);
366	tcu::Surface		referenceImage	(m_targetSize, m_targetSize);
367
368	// render test image
369	{
370		const glw::Functions&		gl			= m_context.getRenderContext().getFunctions();
371		const glu::ShaderProgram	program		(m_context.getRenderContext(), glu::makeVtxFragSources(s_shaderSourceVertex, s_shaderSourceFragment));
372		const GLint					positionLoc = gl.getAttribLocation(program.getProgram(), "a_position");
373		const GLint					colorLoc	= gl.getAttribLocation(program.getProgram(), "a_color");
374
375		if (!program.isOk())
376		{
377			log << program;
378			TCU_FAIL("Shader compile failed.");
379		}
380
381		gl.clearColor				(0, 0, 0, 1);
382		gl.clearDepthf				(1.0f);
383		gl.clear					(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
384		gl.viewport					(0, 0, m_targetSize, m_targetSize);
385		gl.useProgram				(program.getProgram());
386		gl.enable					(GL_DEPTH_TEST);
387		gl.depthFunc				(GL_LEQUAL);	// make test pass if polygon offset doesn't do anything. It has its own test case. This test is only for to detect always-on cases.
388
389		log << TestLog::Message << "DepthFunc = GL_LEQUAL" << TestLog::EndMessage;
390
391		gl.enableVertexAttribArray	(positionLoc);
392		gl.vertexAttribPointer		(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangle);
393
394		//draw back (offset disabled)
395
396		log << TestLog::Message << "Draw bottom-right. Color = White.\tState: PolygonOffset(0, -2), POLYGON_OFFSET_FILL disabled." << TestLog::EndMessage;
397
398		gl.polygonOffset			(0, -2);
399		gl.disable					(GL_POLYGON_OFFSET_FILL);
400		gl.vertexAttrib4f			(colorLoc, 1.0f, 1.0f, 1.0f, 1.0f);
401		gl.drawArrays				(GL_TRIANGLES, 0, 3);
402
403		//draw front
404
405		log << TestLog::Message << "Draw bottom-right. Color = Red.\tState: PolygonOffset(0, -1), POLYGON_OFFSET_FILL enabled." << TestLog::EndMessage;
406
407		gl.polygonOffset			(0, -1);
408		gl.enable					(GL_POLYGON_OFFSET_FILL);
409		gl.vertexAttrib4f			(colorLoc, 1.0f, 0.0f, 0.0f, 1.0f);
410		gl.drawArrays				(GL_TRIANGLES, 0, 3);
411
412		gl.disableVertexAttribArray	(positionLoc);
413		gl.useProgram				(0);
414		gl.finish					();
415
416		glu::readPixels(m_context.getRenderContext(), 0, 0, testImage.getAccess());
417	}
418
419	// render reference image
420	{
421		rr::Renderer		referenceRenderer;
422		rr::VertexAttrib	attribs[2];
423		rr::RenderState		state((rr::ViewportState)(rr::WindowRectangle(0, 0, m_targetSize, m_targetSize)));
424
425		PositionColorShader program;
426
427		attribs[0].type				= rr::VERTEXATTRIBTYPE_FLOAT;
428		attribs[0].size				= 4;
429		attribs[0].stride			= 0;
430		attribs[0].instanceDivisor	= 0;
431		attribs[0].pointer			= triangle;
432
433		attribs[1].type				= rr::VERTEXATTRIBTYPE_DONT_CARE;
434		attribs[1].generic			= tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f);
435
436		tcu::clear(referenceImage.getAccess(), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
437
438		log << TestLog::Message << "Expecting: Bottom-right = Red." << TestLog::EndMessage;
439
440		referenceRenderer.draw(
441			rr::DrawCommand(
442				state,
443				rr::RenderTarget(rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(referenceImage.getAccess())),
444				rr::Program(program.getVertexShader(), program.getFragmentShader()),
445				2,
446				attribs,
447				rr::PrimitiveList(rr::PRIMITIVETYPE_TRIANGLES, 3, 0)));
448	}
449
450	// compare
451	verifyImages(log, m_testCtx, m_context.getRenderContext(), testImage.getAccess(), referenceImage.getAccess());
452}
453
454// UsageDisplacementTestCase
455
456class UsageDisplacementTestCase : public PolygonOffsetTestCase
457{
458public:
459				UsageDisplacementTestCase	(Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName);
460
461private:
462	tcu::Vec4	genRandomVec4				(de::Random& rnd) const;
463	void		testPolygonOffset			(void);
464};
465
466UsageDisplacementTestCase::UsageDisplacementTestCase (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName)
467	: PolygonOffsetTestCase(context, name, description, internalFormat, internalFormatName, 200)
468{
469}
470
471tcu::Vec4 UsageDisplacementTestCase::genRandomVec4 (de::Random& rnd) const
472{
473	// generater triangle endpoint with following properties
474	//	1) it will not be clipped
475	//	2) it is not near either far or near plane to prevent possible problems related to depth clamping
476	// => w >= 1.0 and z in (-0.9, 0.9) range
477	tcu::Vec4 retVal;
478
479	retVal.x() = rnd.getFloat(-1, 1);
480	retVal.y() = rnd.getFloat(-1, 1);
481	retVal.z() = 0.5f;
482	retVal.w() = 1.0f + rnd.getFloat();
483
484	return retVal;
485}
486
487void UsageDisplacementTestCase::testPolygonOffset (void)
488{
489	using tcu::TestLog;
490
491	de::Random			rnd				(0xdec0de);
492	tcu::TestLog&		log				= m_testCtx.getLog();
493	tcu::Surface		testImage		(m_targetSize, m_targetSize);
494	tcu::Surface		referenceImage	(m_targetSize, m_targetSize);
495
496	// render test image
497	{
498		const glw::Functions&		gl				= m_context.getRenderContext().getFunctions();
499		const glu::ShaderProgram	program			(m_context.getRenderContext(), glu::makeVtxFragSources(s_shaderSourceVertex, s_shaderSourceFragment));
500		const GLint					positionLoc		= gl.getAttribLocation(program.getProgram(), "a_position");
501		const GLint					colorLoc		= gl.getAttribLocation(program.getProgram(), "a_color");
502		const int					numIterations	= 40;
503
504		if (!program.isOk())
505		{
506			log << program;
507			TCU_FAIL("Shader compile failed.");
508		}
509
510		gl.clearColor				(0, 0, 0, 1);
511		gl.clearDepthf				(1.0f);
512		gl.clear					(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
513		gl.viewport					(0, 0, m_targetSize, m_targetSize);
514		gl.useProgram				(program.getProgram());
515		gl.enable					(GL_DEPTH_TEST);
516		gl.enable					(GL_POLYGON_OFFSET_FILL);
517		gl.enableVertexAttribArray	(positionLoc);
518		gl.vertexAttrib4f			(colorLoc, 0.0f, 1.0f, 0.0f, 1.0f);
519
520		log << TestLog::Message << "Framebuffer cleared, clear color = Black." << TestLog::EndMessage;
521		log << TestLog::Message << "POLYGON_OFFSET_FILL enabled." << TestLog::EndMessage;
522
523		// draw colorless (mask = 0,0,0) triangle at random* location, set offset and render green triangle with depthfunc = equal
524		// *) w >= 1.0 and z in (-1, 1) range
525		for (int iterationNdx = 0; iterationNdx < numIterations; ++iterationNdx)
526		{
527			const bool		offsetDirection = rnd.getBool();
528			const float		offset = offsetDirection ? -1.0f : 1.0f;
529			tcu::Vec4		triangle[3];
530
531			for (int vertexNdx = 0; vertexNdx < DE_LENGTH_OF_ARRAY(triangle); ++vertexNdx)
532				triangle[vertexNdx] = genRandomVec4(rnd);
533
534			gl.vertexAttribPointer		(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangle);
535
536			log << TestLog::Message << "Setup triangle with random coordinates:" << TestLog::EndMessage;
537			for (size_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(triangle); ++ndx)
538				log << TestLog::Message
539						<< "\tx=" << triangle[ndx].x()
540						<< "\ty=" << triangle[ndx].y()
541						<< "\tz=" << triangle[ndx].z()
542						<< "\tw=" << triangle[ndx].w()
543						<< TestLog::EndMessage;
544
545			log << TestLog::Message << "Draw colorless triangle.\tState: DepthFunc = GL_ALWAYS, PolygonOffset(0, 0)." << TestLog::EndMessage;
546
547			gl.depthFunc				(GL_ALWAYS);
548			gl.polygonOffset			(0, 0);
549			gl.colorMask				(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
550			gl.drawArrays				(GL_TRIANGLES, 0, 3);
551
552			// all fragments should have different Z => DepthFunc == GL_EQUAL fails with every fragment
553
554			log << TestLog::Message << "Draw green triangle.\tState: DepthFunc = GL_EQUAL, PolygonOffset(0, " << offset << ")." << TestLog::EndMessage;
555
556			gl.depthFunc				(GL_EQUAL);
557			gl.polygonOffset			(0, offset);
558			gl.colorMask				(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
559			gl.drawArrays				(GL_TRIANGLES, 0, 3);
560
561			log << TestLog::Message << TestLog::EndMessage; // empty line for clarity
562		}
563
564		gl.disableVertexAttribArray	(positionLoc);
565		gl.useProgram				(0);
566		gl.finish					();
567
568		glu::readPixels(m_context.getRenderContext(), 0, 0, testImage.getAccess());
569	}
570
571	// render reference image
572	log << TestLog::Message << "Expecting black framebuffer." << TestLog::EndMessage;
573	tcu::clear(referenceImage.getAccess(), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
574
575	// compare
576	verifyImages(log, m_testCtx, m_context.getRenderContext(), testImage.getAccess(), referenceImage.getAccess());
577}
578
579// UsagePositiveNegativeTestCase
580
581class UsagePositiveNegativeTestCase : public PolygonOffsetTestCase
582{
583public:
584			UsagePositiveNegativeTestCase	(Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName);
585
586	void	testPolygonOffset				(void);
587};
588
589UsagePositiveNegativeTestCase::UsagePositiveNegativeTestCase (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName)
590	: PolygonOffsetTestCase(context, name, description, internalFormat, internalFormatName, 200)
591{
592}
593
594void UsagePositiveNegativeTestCase::testPolygonOffset (void)
595{
596	using tcu::TestLog;
597
598	const tcu::Vec4 triangleBottomRight[] =
599	{
600		tcu::Vec4(-1,  1,  0,  1),
601		tcu::Vec4( 1,  1,  0,  1),
602		tcu::Vec4( 1, -1,  0,  1),
603	};
604	const tcu::Vec4 triangleTopLeft[] =
605	{
606		tcu::Vec4(-1, -1,  0,  1),
607		tcu::Vec4(-1,  1,  0,  1),
608		tcu::Vec4( 1, -1,  0,  1),
609	};
610
611	tcu::TestLog&		log				= m_testCtx.getLog();
612	tcu::Surface		testImage		(m_targetSize, m_targetSize);
613	tcu::Surface		referenceImage	(m_targetSize, m_targetSize);
614
615	// render test image
616	{
617		const glw::Functions&		gl				= m_context.getRenderContext().getFunctions();
618		const glu::ShaderProgram	program			(m_context.getRenderContext(), glu::makeVtxFragSources(s_shaderSourceVertex, s_shaderSourceFragment));
619		const GLint					positionLoc		= gl.getAttribLocation(program.getProgram(), "a_position");
620		const GLint					colorLoc		= gl.getAttribLocation(program.getProgram(), "a_color");
621
622		if (!program.isOk())
623		{
624			log << program;
625			TCU_FAIL("Shader compile failed.");
626		}
627
628		gl.clearColor				(0, 0, 0, 1);
629		gl.clearDepthf				(1.0f);
630		gl.clear					(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
631		gl.viewport					(0, 0, m_targetSize, m_targetSize);
632		gl.depthFunc				(GL_LESS);
633		gl.useProgram				(program.getProgram());
634		gl.enable					(GL_DEPTH_TEST);
635		gl.enable					(GL_POLYGON_OFFSET_FILL);
636		gl.enableVertexAttribArray	(positionLoc);
637
638		log << TestLog::Message << "DepthFunc = GL_LESS." << TestLog::EndMessage;
639		log << TestLog::Message << "POLYGON_OFFSET_FILL enabled." << TestLog::EndMessage;
640
641		//draw top left (negative offset test)
642		{
643			gl.vertexAttribPointer		(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangleTopLeft);
644
645			log << TestLog::Message << "Draw top-left. Color = White.\tState: PolygonOffset(0, 0)." << TestLog::EndMessage;
646
647			gl.polygonOffset			(0, 0);
648			gl.vertexAttrib4f			(colorLoc, 1.0f, 1.0f, 1.0f, 1.0f);
649			gl.drawArrays				(GL_TRIANGLES, 0, 3);
650
651			log << TestLog::Message << "Draw top-left. Color = Green.\tState: PolygonOffset(0, -1)." << TestLog::EndMessage;
652
653			gl.polygonOffset			(0, -1);
654			gl.vertexAttrib4f			(colorLoc, 0.0f, 1.0f, 0.0f, 1.0f);
655			gl.drawArrays				(GL_TRIANGLES, 0, 3);
656		}
657
658		//draw bottom right (positive offset test)
659		{
660			gl.vertexAttribPointer		(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangleBottomRight);
661
662			log << TestLog::Message << "Draw bottom-right. Color = White.\tState: PolygonOffset(0, 1)." << TestLog::EndMessage;
663
664			gl.polygonOffset			(0, 1);
665			gl.vertexAttrib4f			(colorLoc, 1.0f, 1.0f, 1.0f, 1.0f);
666			gl.drawArrays				(GL_TRIANGLES, 0, 3);
667
668			log << TestLog::Message << "Draw bottom-right. Color = Yellow.\tState: PolygonOffset(0, 0)." << TestLog::EndMessage;
669
670			gl.polygonOffset			(0, 0);
671			gl.vertexAttrib4f			(colorLoc, 1.0f, 1.0f, 0.0f, 1.0f);
672			gl.drawArrays				(GL_TRIANGLES, 0, 3);
673		}
674
675		gl.disableVertexAttribArray	(positionLoc);
676		gl.useProgram				(0);
677		gl.finish					();
678
679		glu::readPixels(m_context.getRenderContext(), 0, 0, testImage.getAccess());
680	}
681
682	// render reference image
683	{
684		rr::Renderer		referenceRenderer;
685		rr::VertexAttrib	attribs[2];
686		rr::RenderState		state((rr::ViewportState)(rr::WindowRectangle(0, 0, m_targetSize, m_targetSize)));
687
688		PositionColorShader program;
689
690		attribs[0].type				= rr::VERTEXATTRIBTYPE_FLOAT;
691		attribs[0].size				= 4;
692		attribs[0].stride			= 0;
693		attribs[0].instanceDivisor	= 0;
694		attribs[0].pointer			= triangleTopLeft;
695
696		attribs[1].type				= rr::VERTEXATTRIBTYPE_DONT_CARE;
697		attribs[1].generic			= tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f);
698
699		tcu::clear(referenceImage.getAccess(), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
700
701		log << TestLog::Message << "Expecting: Top-left = Green, Bottom-right = Yellow." << TestLog::EndMessage;
702
703		referenceRenderer.draw(
704			rr::DrawCommand(
705				state,
706				rr::RenderTarget(rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(referenceImage.getAccess())),
707				rr::Program(program.getVertexShader(), program.getFragmentShader()),
708				2,
709				attribs,
710				rr::PrimitiveList(rr::PRIMITIVETYPE_TRIANGLES, 3, 0)));
711
712		attribs[0].pointer = triangleBottomRight;
713		attribs[1].generic = tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f);
714
715		referenceRenderer.draw(
716			rr::DrawCommand(
717				state,
718				rr::RenderTarget(rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(referenceImage.getAccess())),
719				rr::Program(program.getVertexShader(), program.getFragmentShader()),
720				2,
721				attribs,
722				rr::PrimitiveList(rr::PRIMITIVETYPE_TRIANGLES, 3, 0)));
723	}
724
725	// compare
726	verifyImages(log, m_testCtx, m_context.getRenderContext(), testImage.getAccess(), referenceImage.getAccess());
727}
728
729// ResultClampingTestCase
730
731class ResultClampingTestCase : public PolygonOffsetTestCase
732{
733public:
734			ResultClampingTestCase	(Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName);
735
736	void	testPolygonOffset		(void);
737};
738
739ResultClampingTestCase::ResultClampingTestCase (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName)
740	: PolygonOffsetTestCase(context, name, description, internalFormat, internalFormatName, 200)
741{
742}
743
744void ResultClampingTestCase::testPolygonOffset (void)
745{
746	using tcu::TestLog;
747
748	const tcu::Vec4 triangleBottomRight[] =
749	{
750		tcu::Vec4(-1,  1,  1,  1),
751		tcu::Vec4( 1,  1,  1,  1),
752		tcu::Vec4( 1, -1,  1,  1),
753	};
754	const tcu::Vec4 triangleTopLeft[] =
755	{
756		tcu::Vec4(-1, -1, -1,  1),
757		tcu::Vec4(-1,  1, -1,  1),
758		tcu::Vec4( 1, -1, -1,  1),
759	};
760
761	tcu::TestLog&		log				= m_testCtx.getLog();
762	tcu::Surface		testImage		(m_targetSize, m_targetSize);
763	tcu::Surface		referenceImage	(m_targetSize, m_targetSize);
764
765	// render test image
766	{
767		const glw::Functions&		gl			= m_context.getRenderContext().getFunctions();
768		const glu::ShaderProgram	program		(m_context.getRenderContext(), glu::makeVtxFragSources(s_shaderSourceVertex, s_shaderSourceFragment));
769		const GLint					positionLoc = gl.getAttribLocation(program.getProgram(), "a_position");
770		const GLint					colorLoc	= gl.getAttribLocation(program.getProgram(), "a_color");
771
772		if (!program.isOk())
773		{
774			log << program;
775			TCU_FAIL("Shader compile failed.");
776		}
777
778		gl.clearColor				(0, 0, 0, 1);
779		gl.clearDepthf				(1.0f);
780		gl.clear					(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
781		gl.viewport					(0, 0, m_targetSize, m_targetSize);
782		gl.useProgram				(program.getProgram());
783		gl.enable					(GL_DEPTH_TEST);
784		gl.enable					(GL_POLYGON_OFFSET_FILL);
785		gl.enableVertexAttribArray	(positionLoc);
786
787		log << TestLog::Message << "POLYGON_OFFSET_FILL enabled." << TestLog::EndMessage;
788
789		//draw bottom right (far)
790		{
791			gl.vertexAttribPointer		(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangleBottomRight);
792
793			log << TestLog::Message << "Draw bottom-right. Color = White.\tState: DepthFunc = ALWAYS, PolygonOffset(0, 8), Polygon Z = 1.0. (Result depth should clamp to 1.0)." << TestLog::EndMessage;
794
795			gl.depthFunc				(GL_ALWAYS);
796			gl.polygonOffset			(0, 8);
797			gl.vertexAttrib4f			(colorLoc, 1.0f, 1.0f, 1.0f, 1.0f);
798			gl.drawArrays				(GL_TRIANGLES, 0, 3);
799
800			log << TestLog::Message << "Draw bottom-right. Color = Red.\tState: DepthFunc = GREATER, PolygonOffset(0, 9), Polygon Z = 1.0. (Result depth should clamp to 1.0 too)" << TestLog::EndMessage;
801
802			gl.depthFunc				(GL_GREATER);
803			gl.polygonOffset			(0, 9);
804			gl.vertexAttrib4f			(colorLoc, 1.0f, 0.0f, 0.0f, 1.0f);
805			gl.drawArrays				(GL_TRIANGLES, 0, 3);
806		}
807
808		//draw top left (near)
809		{
810			gl.vertexAttribPointer		(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangleTopLeft);
811
812			log << TestLog::Message << "Draw top-left. Color = White.\tState: DepthFunc = ALWAYS, PolygonOffset(0, -8), Polygon Z = -1.0. (Result depth should clamp to -1.0)" << TestLog::EndMessage;
813
814			gl.depthFunc				(GL_ALWAYS);
815			gl.polygonOffset			(0, -8);
816			gl.vertexAttrib4f			(colorLoc, 1.0f, 1.0f, 1.0f, 1.0f);
817			gl.drawArrays				(GL_TRIANGLES, 0, 3);
818
819			log << TestLog::Message << "Draw top-left. Color = Yellow.\tState: DepthFunc = LESS, PolygonOffset(0, -9), Polygon Z = -1.0. (Result depth should clamp to -1.0 too)." << TestLog::EndMessage;
820
821			gl.depthFunc				(GL_LESS);
822			gl.polygonOffset			(0, -9);
823			gl.vertexAttrib4f			(colorLoc, 1.0f, 1.0f, 0.0f, 1.0f);
824			gl.drawArrays				(GL_TRIANGLES, 0, 3);
825		}
826
827		gl.disableVertexAttribArray	(positionLoc);
828		gl.useProgram				(0);
829		gl.finish					();
830
831		glu::readPixels(m_context.getRenderContext(), 0, 0, testImage.getAccess());
832	}
833
834	// render reference image
835	log << TestLog::Message << "Expecting: Top-left = White, Bottom-right = White." << TestLog::EndMessage;
836	tcu::clear(referenceImage.getAccess(), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f));
837
838	// compare
839	verifyImages(log, m_testCtx, m_context.getRenderContext(), testImage.getAccess(), referenceImage.getAccess());
840}
841
842// UsageSlopeTestCase
843
844class UsageSlopeTestCase  : public PolygonOffsetTestCase
845{
846public:
847			UsageSlopeTestCase	(Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName);
848
849	void	testPolygonOffset	(void);
850};
851
852UsageSlopeTestCase::UsageSlopeTestCase (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName)
853	: PolygonOffsetTestCase(context, name, description, internalFormat, internalFormatName, 200)
854{
855}
856
857void UsageSlopeTestCase::testPolygonOffset (void)
858{
859	using tcu::TestLog;
860
861	const tcu::Vec4 triangleBottomRight[] =
862	{
863		tcu::Vec4(-1,  1,  0.0f,  1),
864		tcu::Vec4( 1,  1,  0.9f,  1),
865		tcu::Vec4( 1, -1,  0.9f,  1),
866	};
867	const tcu::Vec4 triangleTopLeft[] =
868	{
869		tcu::Vec4(-1, -1,  -0.9f,  1),
870		tcu::Vec4(-1,  1,   0.9f,  1),
871		tcu::Vec4( 1, -1,   0.0f,  1),
872	};
873
874	tcu::TestLog&		log				= m_testCtx.getLog();
875	tcu::Surface		testImage		(m_targetSize, m_targetSize);
876	tcu::Surface		referenceImage	(m_targetSize, m_targetSize);
877
878	// render test image
879	{
880		const glw::Functions&		gl			= m_context.getRenderContext().getFunctions();
881		const glu::ShaderProgram	program		(m_context.getRenderContext(), glu::makeVtxFragSources(s_shaderSourceVertex, s_shaderSourceFragment));
882		const GLint					positionLoc = gl.getAttribLocation(program.getProgram(), "a_position");
883		const GLint					colorLoc	= gl.getAttribLocation(program.getProgram(), "a_color");
884
885		if (!program.isOk())
886		{
887			log << program;
888			TCU_FAIL("Shader compile failed.");
889		}
890
891		gl.clearColor				(0, 0, 0, 1);
892		gl.clearDepthf				(1.0f);
893		gl.clear					(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
894		gl.viewport					(0, 0, m_targetSize, m_targetSize);
895		gl.useProgram				(program.getProgram());
896		gl.enable					(GL_DEPTH_TEST);
897		gl.enable					(GL_POLYGON_OFFSET_FILL);
898		gl.enableVertexAttribArray	(positionLoc);
899
900		log << TestLog::Message << "POLYGON_OFFSET_FILL enabled." << TestLog::EndMessage;
901
902		//draw top left (negative offset test)
903		{
904			gl.vertexAttribPointer		(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangleTopLeft);
905
906			log << TestLog::Message << "Draw top-left. Color = White.\tState: DepthFunc = ALWAYS, PolygonOffset(0, 0)." << TestLog::EndMessage;
907
908			gl.depthFunc				(GL_ALWAYS);
909			gl.polygonOffset			(0, 0);
910			gl.vertexAttrib4f			(colorLoc, 1.0f, 1.0f, 1.0f, 1.0f);
911			gl.drawArrays				(GL_TRIANGLES, 0, 3);
912
913			log << TestLog::Message << "Draw top-left. Color = Green.\tState: DepthFunc = LESS, PolygonOffset(-1, 0)." << TestLog::EndMessage;
914
915			gl.depthFunc				(GL_LESS);
916			gl.polygonOffset			(-1, 0);
917			gl.vertexAttrib4f			(colorLoc, 0.0f, 1.0f, 0.0f, 1.0f);
918			gl.drawArrays				(GL_TRIANGLES, 0, 3);
919		}
920
921		//draw bottom right (positive offset test)
922		{
923			gl.vertexAttribPointer		(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangleBottomRight);
924
925			log << TestLog::Message << "Draw bottom-right. Color = White.\tState: DepthFunc = ALWAYS, PolygonOffset(0, 0)." << TestLog::EndMessage;
926
927			gl.depthFunc				(GL_ALWAYS);
928			gl.polygonOffset			(0, 0);
929			gl.vertexAttrib4f			(colorLoc, 1.0f, 1.0f, 1.0f, 1.0f);
930			gl.drawArrays				(GL_TRIANGLES, 0, 3);
931
932			log << TestLog::Message << "Draw bottom-right. Color = Green.\tState: DepthFunc = GREATER, PolygonOffset(1, 0)." << TestLog::EndMessage;
933
934			gl.depthFunc				(GL_GREATER);
935			gl.polygonOffset			(1, 0);
936			gl.vertexAttrib4f			(colorLoc, 0.0f, 1.0f, 0.0f, 1.0f);
937			gl.drawArrays				(GL_TRIANGLES, 0, 3);
938		}
939
940		gl.disableVertexAttribArray	(positionLoc);
941		gl.useProgram				(0);
942		gl.finish					();
943
944		glu::readPixels(m_context.getRenderContext(), 0, 0, testImage.getAccess());
945	}
946
947	// render reference image
948	log << TestLog::Message << "Expecting: Top-left = Green, Bottom-right = Green." << TestLog::EndMessage;
949	tcu::clear(referenceImage.getAccess(), tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f));
950
951	// compare
952	verifyImages(log, m_testCtx, m_context.getRenderContext(), testImage.getAccess(), referenceImage.getAccess());
953}
954
955// ZeroSlopeTestCase
956
957class ZeroSlopeTestCase : public PolygonOffsetTestCase
958{
959public:
960			ZeroSlopeTestCase	(Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName);
961
962	void	testPolygonOffset	(void);
963};
964
965ZeroSlopeTestCase::ZeroSlopeTestCase (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName)
966	: PolygonOffsetTestCase(context, name, description, internalFormat, internalFormatName, 200)
967{
968}
969
970void ZeroSlopeTestCase::testPolygonOffset (void)
971{
972	using tcu::TestLog;
973
974	const tcu::Vec4 triangle[] =
975	{
976		tcu::Vec4(-0.4f,  0.4f, 0.0f, 1.0f),
977		tcu::Vec4(-0.8f, -0.5f, 0.0f, 1.0f),
978		tcu::Vec4( 0.7f,  0.2f, 0.0f, 1.0f),
979	};
980
981	tcu::TestLog&		log				= m_testCtx.getLog();
982	tcu::Surface		testImage		(m_targetSize, m_targetSize);
983	tcu::Surface		referenceImage	(m_targetSize, m_targetSize);
984
985	// log the triangle
986	log << TestLog::Message << "Setup triangle with coordinates:" << TestLog::EndMessage;
987	for (size_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(triangle); ++ndx)
988		log << TestLog::Message
989				<< "\tx=" << triangle[ndx].x()
990				<< "\ty=" << triangle[ndx].y()
991				<< "\tz=" << triangle[ndx].z()
992				<< "\tw=" << triangle[ndx].w()
993				<< TestLog::EndMessage;
994
995	// render test image
996	{
997		const glw::Functions&		gl			= m_context.getRenderContext().getFunctions();
998		const glu::ShaderProgram	program		(m_context.getRenderContext(), glu::makeVtxFragSources(s_shaderSourceVertex, s_shaderSourceFragment));
999		const GLint					positionLoc = gl.getAttribLocation(program.getProgram(), "a_position");
1000		const GLint					colorLoc	= gl.getAttribLocation(program.getProgram(), "a_color");
1001
1002		if (!program.isOk())
1003		{
1004			log << program;
1005			TCU_FAIL("Shader compile failed.");
1006		}
1007
1008		gl.clearColor				(0, 0, 0, 1);
1009		gl.clearDepthf				(1.0f);
1010		gl.clear					(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1011		gl.viewport					(0, 0, m_targetSize, m_targetSize);
1012		gl.useProgram				(program.getProgram());
1013		gl.enable					(GL_DEPTH_TEST);
1014		gl.enable					(GL_POLYGON_OFFSET_FILL);
1015		gl.enableVertexAttribArray	(positionLoc);
1016
1017		log << TestLog::Message << "POLYGON_OFFSET_FILL enabled." << TestLog::EndMessage;
1018
1019		{
1020			gl.vertexAttribPointer		(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangle);
1021
1022			log << TestLog::Message << "Draw triangle. Color = Red.\tState: DepthFunc = ALWAYS, PolygonOffset(0, 0)." << TestLog::EndMessage;
1023
1024			gl.depthFunc				(GL_ALWAYS);
1025			gl.polygonOffset			(0, 0);
1026			gl.vertexAttrib4f			(colorLoc, 1.0f, 0.0f, 0.0f, 1.0f);
1027			gl.drawArrays				(GL_TRIANGLES, 0, 3);
1028
1029			log << TestLog::Message << "Draw triangle. Color = Black.\tState: DepthFunc = EQUAL, PolygonOffset(4, 0)." << TestLog::EndMessage;
1030
1031			gl.depthFunc				(GL_EQUAL);
1032			gl.polygonOffset			(4, 0);	// triangle slope == 0
1033			gl.vertexAttrib4f			(colorLoc, 0.0f, 0.0f, 0.0f, 1.0f);
1034			gl.drawArrays				(GL_TRIANGLES, 0, 3);
1035		}
1036
1037		gl.disableVertexAttribArray	(positionLoc);
1038		gl.useProgram				(0);
1039		gl.finish					();
1040
1041		glu::readPixels(m_context.getRenderContext(), 0, 0, testImage.getAccess());
1042	}
1043
1044	// render reference image
1045	log << TestLog::Message << "Expecting black triangle." << TestLog::EndMessage;
1046	tcu::clear(referenceImage.getAccess(), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
1047
1048	// compare
1049	verifyImages(log, m_testCtx, m_context.getRenderContext(), testImage.getAccess(), referenceImage.getAccess());
1050}
1051
1052// OneSlopeTestCase
1053
1054class OneSlopeTestCase : public PolygonOffsetTestCase
1055{
1056public:
1057			OneSlopeTestCase	(Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName);
1058
1059	void	testPolygonOffset	(void);
1060};
1061
1062OneSlopeTestCase::OneSlopeTestCase (Context& context, const char* name, const char* description, GLenum internalFormat, const char* internalFormatName)
1063	: PolygonOffsetTestCase(context, name, description, internalFormat, internalFormatName, 200)
1064{
1065}
1066
1067void OneSlopeTestCase::testPolygonOffset (void)
1068{
1069	using tcu::TestLog;
1070
1071	/*
1072		* setup vertices subject to following properties
1073		*   dz_w / dx_w == 1
1074		*   dz_w / dy_w == 0
1075		* or
1076		*   dz_w / dx_w == 0
1077		*   dz_w / dy_w == 1
1078		* ==> m == 1
1079		*/
1080	const float cornerDepth = float(m_targetSize);
1081	const tcu::Vec4 triangles[2][3] =
1082	{
1083		{
1084			tcu::Vec4(-1, -1, -cornerDepth, 1),
1085			tcu::Vec4(-1,  1, -cornerDepth, 1),
1086			tcu::Vec4( 1, -1,  cornerDepth, 1),
1087		},
1088		{
1089			tcu::Vec4(-1,  1,  cornerDepth, 1),
1090			tcu::Vec4( 1,  1,  cornerDepth, 1),
1091			tcu::Vec4( 1, -1, -cornerDepth, 1),
1092		},
1093	};
1094
1095	tcu::TestLog&		log				= m_testCtx.getLog();
1096	tcu::Surface		testImage		(m_targetSize, m_targetSize);
1097	tcu::Surface		referenceImage	(m_targetSize, m_targetSize);
1098
1099	// log triangle info
1100	log << TestLog::Message << "Setup triangle0 coordinates: (slope in window coordinates = 1.0)" << TestLog::EndMessage;
1101	for (size_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(triangles[0]); ++ndx)
1102		log << TestLog::Message
1103				<< "\tx=" << triangles[0][ndx].x()
1104				<< "\ty=" << triangles[0][ndx].y()
1105				<< "\tz=" << triangles[0][ndx].z()
1106				<< "\tw=" << triangles[0][ndx].w()
1107				<< TestLog::EndMessage;
1108	log << TestLog::Message << "Setup triangle1 coordinates: (slope in window coordinates = 1.0)" << TestLog::EndMessage;
1109	for (size_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(triangles[1]); ++ndx)
1110		log << TestLog::Message
1111				<< "\tx=" << triangles[1][ndx].x()
1112				<< "\ty=" << triangles[1][ndx].y()
1113				<< "\tz=" << triangles[1][ndx].z()
1114				<< "\tw=" << triangles[1][ndx].w()
1115				<< TestLog::EndMessage;
1116
1117	// render test image
1118	{
1119		const glw::Functions&		gl			= m_context.getRenderContext().getFunctions();
1120		const glu::ShaderProgram	program		(m_context.getRenderContext(), glu::makeVtxFragSources(s_shaderSourceVertex, s_shaderSourceFragment));
1121		const GLint					positionLoc = gl.getAttribLocation(program.getProgram(), "a_position");
1122		const GLint					colorLoc	= gl.getAttribLocation(program.getProgram(), "a_color");
1123
1124		if (!program.isOk())
1125		{
1126			log << program;
1127			TCU_FAIL("Shader compile failed.");
1128		}
1129
1130		gl.clearColor				(0, 0, 0, 1);
1131		gl.clear					(GL_COLOR_BUFFER_BIT);
1132		gl.viewport					(0, 0, m_targetSize, m_targetSize);
1133		gl.useProgram				(program.getProgram());
1134		gl.enable					(GL_DEPTH_TEST);
1135		gl.enable					(GL_POLYGON_OFFSET_FILL);
1136		gl.enableVertexAttribArray	(positionLoc);
1137
1138		log << TestLog::Message << "Framebuffer cleared, clear color = Black." << TestLog::EndMessage;
1139		log << TestLog::Message << "POLYGON_OFFSET_FILL enabled." << TestLog::EndMessage;
1140
1141		// top left (positive offset)
1142		{
1143			log << TestLog::Message << "Clear depth to 1.0." << TestLog::EndMessage;
1144
1145			gl.clearDepthf			(1.0f); // far
1146			gl.clear				(GL_DEPTH_BUFFER_BIT);
1147
1148			gl.vertexAttribPointer	(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangles[0]);
1149
1150			log << TestLog::Message << "Draw triangle0. Color = Red.\tState: DepthFunc = NOTEQUAL, PolygonOffset(10, 0). (Result depth should clamp to 1.0)." << TestLog::EndMessage;
1151
1152			gl.polygonOffset		(10, 0);		// clamps any depth on the triangle to 1
1153			gl.depthFunc			(GL_NOTEQUAL);
1154			gl.vertexAttrib4f		(colorLoc, 1.0f, 0.0f, 0.0f, 1.0f);
1155			gl.drawArrays			(GL_TRIANGLES, 0, 3);
1156		}
1157		// bottom right (negative offset)
1158		{
1159			log << TestLog::Message << "Clear depth to 0.0." << TestLog::EndMessage;
1160
1161			gl.clearDepthf			(0.0f); // far
1162			gl.clear				(GL_DEPTH_BUFFER_BIT);
1163
1164			gl.vertexAttribPointer	(positionLoc, 4, GL_FLOAT, GL_FALSE, 0, triangles[1]);
1165
1166			log << TestLog::Message << "Draw triangle1. Color = Green.\tState: DepthFunc = NOTEQUAL, PolygonOffset(-10, 0). (Result depth should clamp to 0.0)." << TestLog::EndMessage;
1167
1168			gl.polygonOffset		(-10, 0); // clamps depth to 0
1169			gl.depthFunc			(GL_NOTEQUAL);
1170			gl.vertexAttrib4f		(colorLoc, 0.0f, 1.0f, 0.0f, 1.0f);
1171			gl.drawArrays			(GL_TRIANGLES, 0, 3);
1172		}
1173
1174		gl.disableVertexAttribArray	(positionLoc);
1175		gl.useProgram				(0);
1176		gl.finish					();
1177
1178		glu::readPixels(m_context.getRenderContext(), 0, 0, testImage.getAccess());
1179	}
1180
1181	// render reference image
1182	log << TestLog::Message << "Expecting black framebuffer." << TestLog::EndMessage;
1183	tcu::clear(referenceImage.getAccess(), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
1184
1185	// compare
1186	verifyImages(log, m_testCtx, m_context.getRenderContext(), testImage.getAccess(), referenceImage.getAccess());
1187}
1188
1189} // anonymous
1190
1191PolygonOffsetTests::PolygonOffsetTests (Context& context)
1192	: TestCaseGroup(context, "polygon_offset", "Polygon offset tests")
1193{
1194}
1195
1196PolygonOffsetTests::~PolygonOffsetTests (void)
1197{
1198}
1199
1200void PolygonOffsetTests::init (void)
1201{
1202	const struct DepthBufferFormat
1203	{
1204		enum BufferType
1205		{
1206			TYPE_FIXED_POINT,
1207			TYPE_FLOATING_POINT,
1208			TYPE_UNKNOWN
1209		};
1210
1211		GLenum		internalFormat;
1212		int			bits;
1213		BufferType	floatingPoint;
1214		const char* name;
1215	} depthFormats[]=
1216	{
1217		{ 0,						0,		DepthBufferFormat::TYPE_UNKNOWN,		"default" },
1218		{ GL_DEPTH_COMPONENT16,		16,		DepthBufferFormat::TYPE_FIXED_POINT,	"fixed16" },
1219		{ GL_DEPTH_COMPONENT24,		24,		DepthBufferFormat::TYPE_FIXED_POINT,	"fixed24" },
1220		{ GL_DEPTH_COMPONENT32F,	32,		DepthBufferFormat::TYPE_FLOATING_POINT,	"float32" },
1221	};
1222
1223	for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(depthFormats); ++ndx)
1224	{
1225		const DepthBufferFormat& format = depthFormats[ndx];
1226
1227		// enable works?
1228		addChild(new UsageTestCase(m_context, (std::string(format.name) + "_enable").c_str(), "test enable GL_POLYGON_OFFSET_FILL", format.internalFormat, format.name));
1229
1230		// Really moves the polygons ?
1231		addChild(new UsageDisplacementTestCase(m_context, (std::string(format.name) + "_displacement_with_units").c_str(), "test polygon offset", format.internalFormat, format.name));
1232
1233		// Really moves the polygons to right direction ?
1234		addChild(new UsagePositiveNegativeTestCase(m_context, (std::string(format.name) + "_render_with_units").c_str(), "test polygon offset", format.internalFormat, format.name));
1235
1236		// Is total result clamped to [0,1] like promised?
1237		addChild(new ResultClampingTestCase(m_context, (std::string(format.name) + "_result_depth_clamp").c_str(), "test polygon offset clamping", format.internalFormat, format.name));
1238
1239		// Slope really moves the polygon?
1240		addChild(new UsageSlopeTestCase(m_context, (std::string(format.name) + "_render_with_factor").c_str(), "test polygon offset factor", format.internalFormat, format.name));
1241
1242		// Factor with zero slope
1243		addChild(new ZeroSlopeTestCase(m_context, (std::string(format.name) + "_factor_0_slope").c_str(), "test polygon offset factor", format.internalFormat, format.name));
1244
1245		// Factor with 1.0 slope
1246		addChild(new OneSlopeTestCase(m_context, (std::string(format.name) + "_factor_1_slope").c_str(), "test polygon offset factor", format.internalFormat, format.name));
1247	}
1248}
1249
1250} // Functional
1251} // gles3
1252} // deqp
1253