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