void QuadRenderer::render (const Quad& quad) const
{
const float position[] =
{
quad.posA.x(), quad.posA.y(), quad.depth[0], 1.0f,
quad.posA.x(), quad.posB.y(), quad.depth[1], 1.0f,
quad.posB.x(), quad.posA.y(), quad.depth[2], 1.0f,
quad.posB.x(), quad.posB.y(), quad.depth[3], 1.0f
};
const deUint8 indices[] = { 0, 2, 1, 1, 2, 3 };
DE_STATIC_ASSERT(sizeof(tcu::Vec4) == sizeof(float)*4);
DE_STATIC_ASSERT(sizeof(quad.color) == sizeof(float)*4*4);
DE_STATIC_ASSERT(sizeof(quad.color1) == sizeof(float)*4*4);
std::vector<glu::VertexArrayBinding> vertexArrays;
vertexArrays.push_back(glu::va::Float(m_positionLoc, 4, 4, 0, &position[0]));
vertexArrays.push_back(glu::va::Float(m_colorLoc, 4, 4, 0, (const float*)&quad.color[0]));
if (m_blendFuncExt)
vertexArrays.push_back(glu::va::Float(m_color1Loc, 4, 4, 0, (const float*)&quad.color1[0]));
m_context.getFunctions().useProgram(m_program->getProgram());
glu::draw(m_context, m_program->getProgram(),
(int)vertexArrays.size(), &vertexArrays[0],
glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0]));
}
string NumSamplesParams::getDescription (const NumSamplesParams& params)
{
ostringstream os;
bool first = true;
static const char* const s_names[] = { "color", "depth", "stencil" };
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == DE_LENGTH_OF_ARRAY(params.numSamples));
for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_names); i++)
{
GLsizei ns = params.numSamples[i];
if (ns == SAMPLES_NONE)
continue;
if (first)
first = false;
else
os << ", ";
if (ns == SAMPLES_TEXTURE)
os << "texture " << s_names[i] << " attachment";
else
os << ns << "-sample renderbuffer " << s_names[i] << " attachment";
}
return os.str();
}
inline Vector<T, Size> cross (const Vector<T, Size>& a, const Vector<T, Size>& b)
{
DE_STATIC_ASSERT(Size == 3);
return Vector<T, Size>(
a.y() * b.z() - b.y() * a.z(),
a.z() * b.x() - b.z() * a.x(),
a.x() * b.y() - b.x() * a.y());
}
void ReferenceQuadRenderer::render (const tcu::PixelBufferAccess& colorBuffer,
const tcu::PixelBufferAccess& depthBuffer,
const tcu::PixelBufferAccess& stencilBuffer,
const IntegerQuad& quad,
const rr::FragmentOperationState& state)
{
bool flipX = quad.posA.x() > quad.posB.x();
bool flipY = quad.posA.y() > quad.posB.y();
rr::FaceType faceType = flipX == flipY ? rr::FACETYPE_FRONT : rr::FACETYPE_BACK;
int xFirst = flipX ? quad.posB.x() : quad.posA.x();
int xLast = flipX ? quad.posA.x() : quad.posB.x();
int yFirst = flipY ? quad.posB.y() : quad.posA.y();
int yLast = flipY ? quad.posA.y() : quad.posB.y();
float width = (float)(xLast - xFirst + 1);
float height = (float)(yLast - yFirst + 1);
for (int y = yFirst; y <= yLast; y++)
{
// Interpolation factor for y.
float yRatio = (0.5f + (float)(y - yFirst)) / height;
if (flipY)
yRatio = 1.0f - yRatio;
for (int x = xFirst; x <= xLast; x++)
{
// Interpolation factor for x.
float xRatio = (0.5f + (float)(x - xFirst)) / width;
if (flipX)
xRatio = 1.0f - xRatio;
tcu::Vec4 color = triQuadInterpolate(quad.color, xRatio, yRatio);
tcu::Vec4 color1 = triQuadInterpolate(quad.color1, xRatio, yRatio);
float depth = triQuadInterpolate(quad.depth, xRatio, yRatio);
// Interpolated color and depth.
DE_STATIC_ASSERT(MAX_FRAGMENT_BUFFER_SIZE == DE_LENGTH_OF_ARRAY(m_fragmentBuffer));
if (m_fragmentBufferSize >= MAX_FRAGMENT_BUFFER_SIZE)
flushFragmentBuffer(rr::MultisamplePixelBufferAccess::fromMultisampleAccess(colorBuffer),
rr::MultisamplePixelBufferAccess::fromMultisampleAccess(depthBuffer),
rr::MultisamplePixelBufferAccess::fromMultisampleAccess(stencilBuffer), faceType, state);
m_fragmentDepths[m_fragmentBufferSize] = depth;
m_fragmentBuffer[m_fragmentBufferSize] = rr::Fragment(tcu::IVec2(x, y), rr::GenericVec4(color), rr::GenericVec4(color1), 1u /* coverage mask */, &m_fragmentDepths[m_fragmentBufferSize]);
m_fragmentBufferSize++;
}
}
flushFragmentBuffer(rr::MultisamplePixelBufferAccess::fromMultisampleAccess(colorBuffer),
rr::MultisamplePixelBufferAccess::fromMultisampleAccess(depthBuffer),
rr::MultisamplePixelBufferAccess::fromMultisampleAccess(stencilBuffer), faceType, state);
}
static const char* getPrecisionPostfix (glu::Precision precision)
{
static const char* s_postfix[] =
{
"_lowp",
"_mediump",
"_highp"
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_postfix) == glu::PRECISION_LAST);
DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(s_postfix)));
return s_postfix[precision];
}
static const char* getLoopCountTypeName (LoopCountType countType)
{
static const char* s_names[] =
{
"constant",
"uniform",
"dynamic"
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == LOOPCOUNT_LAST);
DE_ASSERT(deInBounds32((int)countType, 0, LOOPCOUNT_LAST));
return s_names[(int)countType];
}
static const char* getLoopTypeName (LoopType loopType)
{
static const char* s_names[] =
{
"for",
"while",
"do_while"
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == LOOPTYPE_LAST);
DE_ASSERT(deInBounds32((int)loopType, 0, LOOPTYPE_LAST));
return s_names[(int)loopType];
}
IterateResult NumSamplesTest::build (FboBuilder& builder)
{
static const GLenum s_targets[] =
{
GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_DEPTH_ATTACHMENT,
};
// Non-integer formats for each attachment type.
// \todo [2013-12-17 lauri] Add fixed/floating/integer metadata for formats so
// we can pick one smartly or maybe try several.
static const GLenum s_formats[] =
{
GL_RGBA8, GL_RGB565, GL_DEPTH_COMPONENT24,
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_targets) == DE_LENGTH_OF_ARRAY(m_params.numSamples));
for (int i = 0; i < DE_LENGTH_OF_ARRAY(s_targets); i++)
{
const GLenum target = s_targets[i];
const ImageFormat fmt = { s_formats[i], GL_NONE };
const GLsizei ns = m_params.numSamples[i];
if (ns == -2)
continue;
if (ns == -1)
{
attachTargetToNew(target, GL_TEXTURE, fmt, 64, 64, builder);
}
else
{
Renderbuffer& rboCfg = builder.makeConfig<Renderbuffer>();
rboCfg.internalFormat = fmt;
rboCfg.width = rboCfg.height = 64;
rboCfg.numSamples = ns;
const GLuint rbo = builder.glCreateRbo(rboCfg);
// Implementations do not necessarily support sample sizes greater than 1.
TCU_CHECK_AND_THROW(NotSupportedError,
builder.getError() != GL_INVALID_OPERATION,
"Unsupported number of samples");
RenderbufferAttachment& att = builder.makeConfig<RenderbufferAttachment>();
att.imageName = rbo;
builder.glAttach(target, &att);
}
}
return STOP;
}
static const char* getMessageTypeName (MessageType type)
{
static const char* s_names[] =
{
"RESUME",
"PAUSE",
"FINISH",
"WINDOW_CREATED",
"WINDOW_RESIZED",
"WINDOW_DESTROYED",
"INPUT_QUEUE_CREATED",
"INPUT_QUEUE_DESTROYED",
"SYNC"
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == MESSAGETYPE_LAST);
return s_names[type];
}
static const char* getLoopCaseName (LoopCase loopCase)
{
static const char* s_names[] =
{
"empty_body",
"infinite_with_unconditional_break_first",
"infinite_with_unconditional_break_last",
"infinite_with_conditional_break",
"single_statement",
"compound_statement",
"sequence_statement",
"no_iterations",
"single_iteration",
"select_iteration_count",
"conditional_continue",
"unconditional_continue",
"only_continue",
"double_continue",
"conditional_break",
"unconditional_break",
"pre_increment",
"post_increment",
"mixed_break_continue",
"vector_counter",
"101_iterations",
"sequence",
"nested",
"nested_sequence",
"nested_tricky_dataflow_1",
"nested_tricky_dataflow_2"
//"multi_declaration",
};
DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == LOOPCASE_LAST);
DE_ASSERT(deInBounds32((int)loopCase, 0, LOOPCASE_LAST));
return s_names[(int)loopCase];
}
VkResult createSurface (const InstanceInterface& vki,
VkInstance instance,
Type wsiType,
const Display& nativeDisplay,
const Window& nativeWindow,
const VkAllocationCallbacks* pAllocator,
VkSurfaceKHR* pSurface)
{
// Update this function if you add more WSI implementations
DE_STATIC_ASSERT(TYPE_LAST == 7);
switch (wsiType)
{
case TYPE_XLIB:
{
const XlibDisplayInterface& xlibDisplay = dynamic_cast<const XlibDisplayInterface&>(nativeDisplay);
const XlibWindowInterface& xlibWindow = dynamic_cast<const XlibWindowInterface&>(nativeWindow);
const VkXlibSurfaceCreateInfoKHR createInfo =
{
VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,
DE_NULL,
(VkXlibSurfaceCreateFlagsKHR)0,
xlibDisplay.getNative(),
xlibWindow.getNative()
};
return vki.createXlibSurfaceKHR(instance, &createInfo, pAllocator, pSurface);
}
case TYPE_XCB:
{
const XcbDisplayInterface& xcbDisplay = dynamic_cast<const XcbDisplayInterface&>(nativeDisplay);
const XcbWindowInterface& xcbWindow = dynamic_cast<const XcbWindowInterface&>(nativeWindow);
const VkXcbSurfaceCreateInfoKHR createInfo =
{
VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR,
DE_NULL,
(VkXcbSurfaceCreateFlagsKHR)0,
xcbDisplay.getNative(),
xcbWindow.getNative()
};
return vki.createXcbSurfaceKHR(instance, &createInfo, pAllocator, pSurface);
}
case TYPE_WAYLAND:
{
const WaylandDisplayInterface& waylandDisplay = dynamic_cast<const WaylandDisplayInterface&>(nativeDisplay);
const WaylandWindowInterface& waylandWindow = dynamic_cast<const WaylandWindowInterface&>(nativeWindow);
const VkWaylandSurfaceCreateInfoKHR createInfo =
{
VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR,
DE_NULL,
(VkWaylandSurfaceCreateFlagsKHR)0,
waylandDisplay.getNative(),
waylandWindow.getNative()
};
return vki.createWaylandSurfaceKHR(instance, &createInfo, pAllocator, pSurface);
}
case TYPE_MIR:
{
const MirDisplayInterface& mirDisplay = dynamic_cast<const MirDisplayInterface&>(nativeDisplay);
const MirWindowInterface& mirWindow = dynamic_cast<const MirWindowInterface&>(nativeWindow);
const VkMirSurfaceCreateInfoKHR createInfo =
{
VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR,
DE_NULL,
(VkXcbSurfaceCreateFlagsKHR)0,
mirDisplay.getNative(),
mirWindow.getNative()
};
return vki.createMirSurfaceKHR(instance, &createInfo, pAllocator, pSurface);
}
case TYPE_ANDROID:
{
const AndroidWindowInterface& androidWindow = dynamic_cast<const AndroidWindowInterface&>(nativeWindow);
const VkAndroidSurfaceCreateInfoKHR createInfo =
{
VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR,
DE_NULL,
(VkAndroidSurfaceCreateFlagsKHR)0,
androidWindow.getNative()
};
return vki.createAndroidSurfaceKHR(instance, &createInfo, pAllocator, pSurface);
}
case TYPE_WIN32:
{
const Win32DisplayInterface& win32Display = dynamic_cast<const Win32DisplayInterface&>(nativeDisplay);
const Win32WindowInterface& win32Window = dynamic_cast<const Win32WindowInterface&>(nativeWindow);
const VkWin32SurfaceCreateInfoKHR createInfo =
{
VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,
DE_NULL,
(VkWin32SurfaceCreateFlagsKHR)0,
win32Display.getNative(),
win32Window.getNative()
};
return vki.createWin32SurfaceKHR(instance, &createInfo, pAllocator, pSurface);
}
case TYPE_MACOS:
{
const MacOSWindowInterface& macOSWindow = dynamic_cast<const MacOSWindowInterface&>(nativeWindow);
const VkMacOSSurfaceCreateInfoMVK createInfo =
{
VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK,
DE_NULL,
(VkMacOSSurfaceCreateFlagsMVK)0,
macOSWindow.getNative()
};
return vki.createMacOSSurfaceMVK(instance, &createInfo, pAllocator, pSurface);
}
default:
DE_FATAL("Unknown WSI type");
return VK_ERROR_SURFACE_LOST_KHR;
}
}
