text:
De Deutscher Handballbund (DHB) is de koepelorganisatie in Duitsland voor de beoefening van het handbal. De DHB organiseert het handbal in Duitsland en vertegenwoordigt het Duitse handbal op internationale sportevenementen.

De bond is opgericht in 1949 en sinds 1950 lid van de Internationale Handbalfederatie. De DHB werd na de eenwording van Duitsland in 1991 ook lid van de Europese Handbalfederatie. Anno 2020 telde de federatie 754.958 leden, verspreid over 4.163 verenigingen. Daarmee is de DHB de grootste van alle nationale handbalbonden.

Nationale ploegen
 Duits handbalteam (mannen)
 Duits handbalteam (vrouwen)
 Duits handbalteam junioren (mannen)
 Duits handbalteam junioren (vrouwen)
 Duits handbalteam jeugd (mannen)
 Duits handbalteam jeugd (vrouwen)

Ledenaantallen
Hieronder de ontwikkeling van het ledenaantal en het aantal verenigingen:

Per deelstaat

Mannen

Vrouwen

Verenigingen

Per bond

Mannen

Vrouwen

Verenigingen

Handbalbond
Handbal
Bond


Baby Killer And Spare Parts Wheeler N' Dealer, Planned Parenthood's Dr. Mary Gatter!!
Don Surber: Dr. Mary Gatter — the Josef Mengele of abortion — a soulless plague upon the land, making light of aborting babies and selling their parts. Mustela abortionist. Pray for her.
Ah, the good Dr. Gatter. Watching the video of her in action, dickering on prices and than demurring from making a final deal, you know, 'until we see what others are getting' and realizing that your tax dollars are funding this is a unique sensation. We truly are becoming the abettors of Moloch and moving towards damnation. And why not? After all, we elected (and re-elected, apparently) a president who fought tooth and nail against legislation that would have mandated physicians like Dr. Gatter to provide medical care to babies that survived an abortion rather than simply allowing the unwanted arrivals to die from neglect.
When indecency leads, the weak follow, because it's convenient.
I personally would pray more for America than for the likes of Dr. Gatter, but perhaps that's just me. To legally allow a 20-week-old healthy child with a fully developed nervous system to feel the pain of being ripped from the womb as its limbs are crushed when there is no health issue involved, but simply convenience – and profit – is bad enough, but to force everyone to subsidize it… that's in a whole different category.
At present, The Center for Medical Progress, the group that released the video of Dr. Gatter has been subjected to lawfare.
They've been hit with a lawsuit by a company called StemExpress who profits from the traffic with Planned Parenthood in body parts and a temporary restraining order was issued by the Los Angeles Superior Court preventing them from releasing any more videos until a hearing is held on August 19th.
Dr. Gatter is not here with us tonight of course. Her Weasel will be shipped to her offices… as soon as the blood red paint I spattered it with dries.


text:
The MCCI Journey & Growth Story
Starting its journey way back in 1901, the Merchants' Chamber of Commerce & Industry (MCCI) has emerged as one of the most dynamic and front-ranking Chambers in the city of Kolkata. Being born in an environment of National Upsurge, it's prime objective has been to provide a sense of integrity, secularity and idealism to the business community of Eastern India. The Chamber today is steadily making it's presence felt across the country and abroad, through well-thought out, meaningful initiatives aimed at taking Indian Industry to a higher growth trajectory.
Historically, the Chamber carries with it a legacy of uniting the business community in Kolkata, forming an organisation and raising its voice of concern against all sorts of injustice in the pre–independence days. It played a significant nationalist role at different times of the last 117 years of it's existence. The Chamber has always been in the forefront of challenges faced and policy-actions taken by the emerging India, championing the cause of indigenous industry as generators of maximum wealth and employment for the millions of people in India.
The MCCI started its function in the name of 'Vaishya Mitra Sabha', which was renamed as the 'Merchants' Committee' in 1904 and membership was opened to all. It plunged itself into the Swadeshi Movement launched by Mahatma Gandhi in 1921. In 1952, the name was changed into 'Merchants' Chamber of Commerce', which was ultimately changed to "Merchants' Chamber of Commerce & Industry" in 2016, to re-affirm and reflect its focus on trade, commerce & industry.
MCCI Vision
To be the leading chamber of Eastern India providing the crucial link between businesses and the policy makers, creating an economic environment which helps members prosper and flourish benefitting all stake holders in the economy.
MCCI Mission
To establish ourselves as the leading chamber of Eastern India including the North East by aggressively expanding member base especially among medium scale Industry and rising corporate houses.
To liaise with the Govt. and administration to promote the cause of businesses and members.
To help the Govt. especially the Govt. of West Bengal and North East States to create the right economic policy and socio-economic environment for the development of business.
To point out the deficiencies in Govt. Policy in economic matters without being constrained to be politically correct.
To create member awareness about various policy and law changes including future policy directions to enable them to adjust better in a fast changing economic environment.
To disseminate information & knowledge to members on a continuous basis on very economic issue, national and international opportunities and B2B opportunities.
To carry out research in all economic areas and publish them at regular intervals.
To help bring member grievances to the State Administration to enable quick relief.
To promote and assist in the efforts aimed at improving the competitiveness of the members and to encourage and help them to utilize various business opportunities arising in this globalised digital age.
To ensure wide participation of members in Chamber initiatives by taking up relevant and important economic issues which are of interest to members.
To align strongly with the Govt. of West Bengal and the North Eastern States and partner the State Government in all it's developmental activities & initiatives and facilitate the growth of focus sectors / areas like MSMEs, Textiles, Start-Ups and IT & ITeS.
To strengthen Policy Advocacy services, and submit Research Reports focusing on sectoral opportunities as well as macro-economic trends to the State Government as well as Central Ministries, Departments and Regulators at regular intervals.
To forge partnerships & collaborations with counterpart Chambers, Research Agencies, Trade Associations through signing of MoUs to ensure national and global reach.
To align with Media and other relevant stakeholders to ensure a better visibility of the MCCI brand among Government & Industry circles.
To promote Ethical Business Practices and Corporate Social Responsibility among members and contribute towards the enhancement of their brand image among public at large.
To actively promote the cause of Women Empowerment by taking up meaningful initiatives through the MLF wing of the Chamber.
Evolution of the Chamber
The Chamber has spread out its wings over the years, to cover a wide spectrum of industries, trade & services. While being a strong voice of small and medium enterprises, the Chamber has pro-actively advocated that in a mixed economy like ours, the Public and Private Sectors are complementary to each other, and can together create an inclusive and futuristic India.
MCCI has members covering a wide cross-section of small, medium & large industries, trade, different professions and services, apart from indirect members through various industry and trade associations affiliated to the Chamber. The administration rests in the hands of the Executive Committee, comprised of upto 157 members drawn from different sectors of industry, trade, profession, past Presidents and Trustees. Currently, there are several Standing Committees under the Executive Committee, looking after various key aspects of the industry, trade and services sectors.
The Committee, headed by the President, appoints various Standing Committees, to deal with specific issues emerging in the areas of their concern. There is an Advisory Council, headed by a Chairman to offer guidance to the Committee on major issues. The Chamber also has a developmental wing called MCC Foundation, whose major thrust is on development of rural areas & socio-economic upliftment of the rural sector.
In the recent years, the Chamber has successfully led Business Delegations to countries including Myanmar, China, Vietnam and Bahrain, and held focused B-2-B interactions & meetings between relevant stakeholders to foster & facilitate bilateral trade, JVs and FDI.
Conference facilities of the Chamber include two well-equipped Conference Halls – Somany Conference Hall with a seating capacity of 100 persons and Jhajharia Committee Room, which can accommodate 20 persons, both of which are frequently used for business meetings.
Major thrust areas of the Chamber
Major thrust areas of the Chamber are
Interaction with the Central and State Governments, various apex bodies & institutions set up by the Union Government including the NITI Aayog, RBI, SEBI etc, Foreign Diplomatic Missions and other concerned authorities for promotion of industry and trade.
Focused initiatives on development and promotion of industry & trade, organising Meetings, Seminars, Symposia on several contemporary macro & sectoral issues, and provide a platform for discussion and deliberations amongst the stakeholders.
Dissemination of information & knowledge to members on a continuous basis on corporate laws & rules, economic & tax issues and national & international business opportunities.
Policy Advocacy and liaison with the Union and State Governments for creation and formulation of right economic policies aimed at boosting socio-economic development and industrial growth. Initiating necessary steps against critical bottlenecks/ deficiencies to ensure faster growth of industry and commerce and submission of Policy Blueprints & Representations for necessary action.
Facilitating and organizing Trade Delegations to and receive Trade Delegations from different countries to foster better relations with them and create a conducive environment for rapid growth of industry and foreign trade by connecting Indian businesses with their global partners.
Forging partnerships & collaborations with counterpart Chambers, national & international Research & Development Agencies, Trade Associations through signing of MoUs to ensure national and global reach.
Aligning with the Print & Electronic Media and other relevant stakeholders to ensure a better visibility of the MCCI brand amongst Government & Industry circles.

redpajama_set_name: RedPajamaCommonCrawl


text:
namespace angle
{
egl::Error ToEGL(Result result, rx::DisplayVk *displayVk, EGLint errorCode)
{
    if (result != angle::Result::Continue)
    {
        return displayVk->getEGLError(errorCode);
    }
    else
    {
        return egl::NoError();
    }
}
}  // namespace angle

namespace rx
{
namespace
{
// Pick an arbitrary value to initialize non-zero memory for sanitization.  Note that 0x3F3F3F3F
// as float is about 0.75.
constexpr int kNonZeroInitValue = 0x3F;

VkImageUsageFlags GetStagingBufferUsageFlags(vk::StagingUsage usage)
{
    switch (usage)
    {
        case vk::StagingUsage::Read:
            return VK_BUFFER_USAGE_TRANSFER_DST_BIT;
        case vk::StagingUsage::Write:
            return VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
        case vk::StagingUsage::Both:
            return (VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
        default:
            UNREACHABLE();
            return 0;
    }
}

bool FindCompatibleMemory(const VkPhysicalDeviceMemoryProperties &memoryProperties,
                          const VkMemoryRequirements &memoryRequirements,
                          VkMemoryPropertyFlags requestedMemoryPropertyFlags,
                          VkMemoryPropertyFlags *memoryPropertyFlagsOut,
                          uint32_t *typeIndexOut)
{
    for (size_t memoryIndex : angle::BitSet32<32>(memoryRequirements.memoryTypeBits))
    {
        ASSERT(memoryIndex < memoryProperties.memoryTypeCount);

        if ((memoryProperties.memoryTypes[memoryIndex].propertyFlags &
             requestedMemoryPropertyFlags) == requestedMemoryPropertyFlags)
        {
            *memoryPropertyFlagsOut = memoryProperties.memoryTypes[memoryIndex].propertyFlags;
            *typeIndexOut           = static_cast<uint32_t>(memoryIndex);
            return true;
        }
    }

    return false;
}

angle::Result FindAndAllocateCompatibleMemory(vk::Context *context,
                                              const vk::MemoryProperties &memoryProperties,
                                              VkMemoryPropertyFlags requestedMemoryPropertyFlags,
                                              VkMemoryPropertyFlags *memoryPropertyFlagsOut,
                                              const VkMemoryRequirements &memoryRequirements,
                                              const void *extraAllocationInfo,
                                              vk::DeviceMemory *deviceMemoryOut)
{
    VkDevice device = context->getDevice();

    uint32_t memoryTypeIndex = 0;
    ANGLE_TRY(memoryProperties.findCompatibleMemoryIndex(context, memoryRequirements,
                                                         requestedMemoryPropertyFlags,
                                                         memoryPropertyFlagsOut, &memoryTypeIndex));

    VkMemoryAllocateInfo allocInfo = {};
    allocInfo.sType                = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
    allocInfo.pNext                = extraAllocationInfo;
    allocInfo.memoryTypeIndex      = memoryTypeIndex;
    allocInfo.allocationSize       = memoryRequirements.size;

    ANGLE_VK_TRY(context, deviceMemoryOut->allocate(device, allocInfo));

    // Wipe memory to an invalid value when the 'allocateNonZeroMemory' feature is enabled. The
    // invalid values ensures our testing doesn't assume zero-initialized memory.
    RendererVk *renderer = context->getRenderer();
    if (renderer->getFeatures().allocateNonZeroMemory.enabled)
    {
        if ((*memoryPropertyFlagsOut & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
        {
            // Can map the memory.
            ANGLE_TRY(vk::InitMappableDeviceMemory(context, deviceMemoryOut,
                                                   memoryRequirements.size, kNonZeroInitValue,
                                                   *memoryPropertyFlagsOut));
        }
    }

    return angle::Result::Continue;
}

template <typename T>
angle::Result AllocateAndBindBufferOrImageMemory(vk::Context *context,
                                                 VkMemoryPropertyFlags requestedMemoryPropertyFlags,
                                                 VkMemoryPropertyFlags *memoryPropertyFlagsOut,
                                                 const VkMemoryRequirements &memoryRequirements,
                                                 const void *extraAllocationInfo,
                                                 T *bufferOrImage,
                                                 vk::DeviceMemory *deviceMemoryOut)
{
    const vk::MemoryProperties &memoryProperties = context->getRenderer()->getMemoryProperties();

    ANGLE_TRY(FindAndAllocateCompatibleMemory(
        context, memoryProperties, requestedMemoryPropertyFlags, memoryPropertyFlagsOut,
        memoryRequirements, extraAllocationInfo, deviceMemoryOut));
    ANGLE_VK_TRY(context, bufferOrImage->bindMemory(context->getDevice(), *deviceMemoryOut));
    return angle::Result::Continue;
}

template <typename T>
angle::Result AllocateBufferOrImageMemory(vk::Context *context,
                                          VkMemoryPropertyFlags requestedMemoryPropertyFlags,
                                          VkMemoryPropertyFlags *memoryPropertyFlagsOut,
                                          const void *extraAllocationInfo,
                                          T *bufferOrImage,
                                          vk::DeviceMemory *deviceMemoryOut,
                                          VkDeviceSize *sizeOut)
{
    // Call driver to determine memory requirements.
    VkMemoryRequirements memoryRequirements;
    bufferOrImage->getMemoryRequirements(context->getDevice(), &memoryRequirements);

    ANGLE_TRY(AllocateAndBindBufferOrImageMemory(
        context, requestedMemoryPropertyFlags, memoryPropertyFlagsOut, memoryRequirements,
        extraAllocationInfo, bufferOrImage, deviceMemoryOut));

    *sizeOut = memoryRequirements.size;

    return angle::Result::Continue;
}

// Unified layer that includes full validation layer stack
constexpr char kVkKhronosValidationLayerName[]  = "VK_LAYER_KHRONOS_validation";
constexpr char kVkStandardValidationLayerName[] = "VK_LAYER_LUNARG_standard_validation";
const char *kVkValidationLayerNames[]           = {
    "VK_LAYER_GOOGLE_threading", "VK_LAYER_LUNARG_parameter_validation",
    "VK_LAYER_LUNARG_object_tracker", "VK_LAYER_LUNARG_core_validation",
    "VK_LAYER_GOOGLE_unique_objects"};

bool HasValidationLayer(const std::vector<VkLayerProperties> &layerProps, const char *layerName)
{
    for (const auto &layerProp : layerProps)
    {
        if (std::string(layerProp.layerName) == layerName)
        {
            return true;
        }
    }

    return false;
}

bool HasKhronosValidationLayer(const std::vector<VkLayerProperties> &layerProps)
{
    return HasValidationLayer(layerProps, kVkKhronosValidationLayerName);
}

bool HasStandardValidationLayer(const std::vector<VkLayerProperties> &layerProps)
{
    return HasValidationLayer(layerProps, kVkStandardValidationLayerName);
}

bool HasValidationLayers(const std::vector<VkLayerProperties> &layerProps)
{
    for (const char *layerName : kVkValidationLayerNames)
    {
        if (!HasValidationLayer(layerProps, layerName))
        {
            return false;
        }
    }

    return true;
}
}  // anonymous namespace

const char *VulkanResultString(VkResult result)
{
    switch (result)
    {
        case VK_SUCCESS:
            return "Command successfully completed";
        case VK_NOT_READY:
            return "A fence or query has not yet completed";
        case VK_TIMEOUT:
            return "A wait operation has not completed in the specified time";
        case VK_EVENT_SET:
            return "An event is signaled";
        case VK_EVENT_RESET:
            return "An event is unsignaled";
        case VK_INCOMPLETE:
            return "A return array was too small for the result";
        case VK_SUBOPTIMAL_KHR:
            return "A swapchain no longer matches the surface properties exactly, but can still be "
                   "used to present to the surface successfully";
        case VK_ERROR_OUT_OF_HOST_MEMORY:
            return "A host memory allocation has failed";
        case VK_ERROR_OUT_OF_DEVICE_MEMORY:
            return "A device memory allocation has failed";
        case VK_ERROR_INITIALIZATION_FAILED:
            return "Initialization of an object could not be completed for implementation-specific "
                   "reasons";
        case VK_ERROR_DEVICE_LOST:
            return "The logical or physical device has been lost";
        case VK_ERROR_MEMORY_MAP_FAILED:
            return "Mapping of a memory object has failed";
        case VK_ERROR_LAYER_NOT_PRESENT:
            return "A requested layer is not present or could not be loaded";
        case VK_ERROR_EXTENSION_NOT_PRESENT:
            return "A requested extension is not supported";
        case VK_ERROR_FEATURE_NOT_PRESENT:
            return "A requested feature is not supported";
        case VK_ERROR_INCOMPATIBLE_DRIVER:
            return "The requested version of Vulkan is not supported by the driver or is otherwise "
                   "incompatible for implementation-specific reasons";
        case VK_ERROR_TOO_MANY_OBJECTS:
            return "Too many objects of the type have already been created";
        case VK_ERROR_FORMAT_NOT_SUPPORTED:
            return "A requested format is not supported on this device";
        case VK_ERROR_SURFACE_LOST_KHR:
            return "A surface is no longer available";
        case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
            return "The requested window is already connected to a VkSurfaceKHR, or to some other "
                   "non-Vulkan API";
        case VK_ERROR_OUT_OF_DATE_KHR:
            return "A surface has changed in such a way that it is no longer compatible with the "
                   "swapchain";
        case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
            return "The display used by a swapchain does not use the same presentable image "
                   "layout, or is incompatible in a way that prevents sharing an image";
        case VK_ERROR_VALIDATION_FAILED_EXT:
            return "The validation layers detected invalid API usage";
        case VK_ERROR_INVALID_SHADER_NV:
            return "Invalid Vulkan shader was generated";
        case VK_ERROR_OUT_OF_POOL_MEMORY:
            return "A pool memory allocation has failed";
        case VK_ERROR_FRAGMENTED_POOL:
            return "A pool allocation has failed due to fragmentation of the pool's memory";
        case VK_ERROR_INVALID_EXTERNAL_HANDLE:
            return "An external handle is not a valid handle of the specified type";
        default:
            return "Unknown vulkan error code";
    }
}

bool GetAvailableValidationLayers(const std::vector<VkLayerProperties> &layerProps,
                                  bool mustHaveLayers,
                                  VulkanLayerVector *enabledLayerNames)
{
    // Favor unified Khronos layer, but fallback to standard validation
    if (HasKhronosValidationLayer(layerProps))
    {
        enabledLayerNames->push_back(kVkKhronosValidationLayerName);
    }
    else if (HasStandardValidationLayer(layerProps))
    {
        enabledLayerNames->push_back(kVkStandardValidationLayerName);
    }
    else if (HasValidationLayers(layerProps))
    {
        for (const char *layerName : kVkValidationLayerNames)
        {
            enabledLayerNames->push_back(layerName);
        }
    }
    else
    {
        // Generate an error if the layers were explicitly requested, warning otherwise.
        if (mustHaveLayers)
        {
            ERR() << "Vulkan validation layers are missing.";
        }
        else
        {
            WARN() << "Vulkan validation layers are missing.";
        }

        return false;
    }

    return true;
}

namespace vk
{
const char *gLoaderLayersPathEnv   = "VK_LAYER_PATH";
const char *gLoaderICDFilenamesEnv = "VK_ICD_FILENAMES";
const char *gANGLEPreferredDevice  = "ANGLE_PREFERRED_DEVICE";

VkImageAspectFlags GetDepthStencilAspectFlags(const angle::Format &format)
{
    return (format.depthBits > 0 ? VK_IMAGE_ASPECT_DEPTH_BIT : 0) |
           (format.stencilBits > 0 ? VK_IMAGE_ASPECT_STENCIL_BIT : 0);
}

VkImageAspectFlags GetFormatAspectFlags(const angle::Format &format)
{
    VkImageAspectFlags dsAspect = GetDepthStencilAspectFlags(format);
    // If the image is not depth stencil, assume color aspect.  Note that detecting color formats
    // is less trivial than depth/stencil, e.g. as block formats don't indicate any bits for RGBA
    // channels.
    return dsAspect != 0 ? dsAspect : VK_IMAGE_ASPECT_COLOR_BIT;
}

// Context implementation.
Context::Context(RendererVk *renderer) : mRenderer(renderer) {}

Context::~Context() {}

VkDevice Context::getDevice() const
{
    return mRenderer->getDevice();
}

// MemoryProperties implementation.
MemoryProperties::MemoryProperties() : mMemoryProperties{} {}

void MemoryProperties::init(VkPhysicalDevice physicalDevice)
{
    ASSERT(mMemoryProperties.memoryTypeCount == 0);
    vkGetPhysicalDeviceMemoryProperties(physicalDevice, &mMemoryProperties);
    ASSERT(mMemoryProperties.memoryTypeCount > 0);
}

void MemoryProperties::destroy()
{
    mMemoryProperties = {};
}

bool MemoryProperties::hasLazilyAllocatedMemory() const
{
    for (uint32_t typeIndex = 0; typeIndex < mMemoryProperties.memoryTypeCount; ++typeIndex)
    {
        const VkMemoryType &memoryType = mMemoryProperties.memoryTypes[typeIndex];
        if ((memoryType.propertyFlags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT) != 0)
        {
            return true;
        }
    }
    return false;
}

angle::Result MemoryProperties::findCompatibleMemoryIndex(
    Context *context,
    const VkMemoryRequirements &memoryRequirements,
    VkMemoryPropertyFlags requestedMemoryPropertyFlags,
    VkMemoryPropertyFlags *memoryPropertyFlagsOut,
    uint32_t *typeIndexOut) const
{
    ASSERT(mMemoryProperties.memoryTypeCount > 0 && mMemoryProperties.memoryTypeCount <= 32);

    // Find a compatible memory pool index. If the index doesn't change, we could cache it.
    // Not finding a valid memory pool means an out-of-spec driver, or internal error.
    // TODO(jmadill): Determine if it is possible to cache indexes.
    // TODO(jmadill): More efficient memory allocation.
    if (FindCompatibleMemory(mMemoryProperties, memoryRequirements, requestedMemoryPropertyFlags,
                             memoryPropertyFlagsOut, typeIndexOut))
    {
        return angle::Result::Continue;
    }

    // We did not find a compatible memory type.  If the caller wanted a host visible memory, just
    // return the memory index with fallback, guaranteed, memory flags.
    if (requestedMemoryPropertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)
    {
        // The Vulkan spec says the following -
        //     There must be at least one memory type with both the
        //     VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT and VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
        //     bits set in its propertyFlags
        constexpr VkMemoryPropertyFlags fallbackMemoryPropertyFlags =
            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;

        if (FindCompatibleMemory(mMemoryProperties, memoryRequirements, fallbackMemoryPropertyFlags,
                                 memoryPropertyFlagsOut, typeIndexOut))
        {
            return angle::Result::Continue;
        }
    }

    // TODO(jmadill): Add error message to error.
    context->handleError(VK_ERROR_INCOMPATIBLE_DRIVER, __FILE__, ANGLE_FUNCTION, __LINE__);
    return angle::Result::Stop;
}

// StagingBuffer implementation.
StagingBuffer::StagingBuffer() : mSize(0) {}

void StagingBuffer::destroy(RendererVk *renderer)
{
    VkDevice device = renderer->getDevice();
    mBuffer.destroy(device);
    mAllocation.destroy(renderer->getAllocator());
    mSize = 0;
}

angle::Result StagingBuffer::init(Context *context, VkDeviceSize size, StagingUsage usage)
{
    VkBufferCreateInfo createInfo    = {};
    createInfo.sType                 = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
    createInfo.flags                 = 0;
    createInfo.size                  = size;
    createInfo.usage                 = GetStagingBufferUsageFlags(usage);
    createInfo.sharingMode           = VK_SHARING_MODE_EXCLUSIVE;
    createInfo.queueFamilyIndexCount = 0;
    createInfo.pQueueFamilyIndices   = nullptr;

    VkMemoryPropertyFlags preferredFlags = 0;
    VkMemoryPropertyFlags requiredFlags =
        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;

    RendererVk *renderer       = context->getRenderer();
    const Allocator &allocator = renderer->getAllocator();

    uint32_t memoryTypeIndex = 0;
    ANGLE_VK_TRY(context,
                 allocator.createBuffer(createInfo, requiredFlags, preferredFlags,
                                        renderer->getFeatures().persistentlyMappedBuffers.enabled,
                                        &memoryTypeIndex, &mBuffer, &mAllocation));
    mSize = static_cast<size_t>(size);

    // Wipe memory to an invalid value when the 'allocateNonZeroMemory' feature is enabled. The
    // invalid values ensures our testing doesn't assume zero-initialized memory.
    if (renderer->getFeatures().allocateNonZeroMemory.enabled)
    {
        ANGLE_TRY(InitMappableAllocation(context, allocator, &mAllocation, size, kNonZeroInitValue,
                                         requiredFlags));
    }

    return angle::Result::Continue;
}

void StagingBuffer::release(ContextVk *contextVk)
{
    contextVk->addGarbage(&mBuffer);
    contextVk->addGarbage(&mAllocation);
}

void StagingBuffer::collectGarbage(RendererVk *renderer, Serial serial)
{
    GarbageList garbageList;
    garbageList.emplace_back(GetGarbage(&mBuffer));
    garbageList.emplace_back(GetGarbage(&mAllocation));

    SharedResourceUse sharedUse;
    sharedUse.init();
    sharedUse.updateSerialOneOff(serial);
    renderer->collectGarbage(std::move(sharedUse), std::move(garbageList));
}

angle::Result InitMappableAllocation(Context *context,
                                     const Allocator &allocator,
                                     Allocation *allocation,
                                     VkDeviceSize size,
                                     int value,
                                     VkMemoryPropertyFlags memoryPropertyFlags)
{
    uint8_t *mapPointer;
    ANGLE_VK_TRY(context, allocation->map(allocator, &mapPointer));
    memset(mapPointer, value, static_cast<size_t>(size));

    if ((memoryPropertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) == 0)
    {
        allocation->flush(allocator, 0, size);
    }

    allocation->unmap(allocator);

    return angle::Result::Continue;
}

angle::Result InitMappableDeviceMemory(Context *context,
                                       DeviceMemory *deviceMemory,
                                       VkDeviceSize size,
                                       int value,
                                       VkMemoryPropertyFlags memoryPropertyFlags)
{
    VkDevice device = context->getDevice();

    uint8_t *mapPointer;
    ANGLE_VK_TRY(context, deviceMemory->map(device, 0, VK_WHOLE_SIZE, 0, &mapPointer));
    memset(mapPointer, value, static_cast<size_t>(size));

    // if the memory type is not host coherent, we perform an explicit flush
    if ((memoryPropertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) == 0)
    {
        VkMappedMemoryRange mappedRange = {};
        mappedRange.sType               = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
        mappedRange.memory              = deviceMemory->getHandle();
        mappedRange.size                = VK_WHOLE_SIZE;
        ANGLE_VK_TRY(context, vkFlushMappedMemoryRanges(device, 1, &mappedRange));
    }

    deviceMemory->unmap(device);

    return angle::Result::Continue;
}

angle::Result AllocateBufferMemory(Context *context,
                                   VkMemoryPropertyFlags requestedMemoryPropertyFlags,
                                   VkMemoryPropertyFlags *memoryPropertyFlagsOut,
                                   const void *extraAllocationInfo,
                                   Buffer *buffer,
                                   DeviceMemory *deviceMemoryOut,
                                   VkDeviceSize *sizeOut)
{
    return AllocateBufferOrImageMemory(context, requestedMemoryPropertyFlags,
                                       memoryPropertyFlagsOut, extraAllocationInfo, buffer,
                                       deviceMemoryOut, sizeOut);
}

angle::Result AllocateImageMemory(Context *context,
                                  VkMemoryPropertyFlags memoryPropertyFlags,
                                  VkMemoryPropertyFlags *memoryPropertyFlagsOut,
                                  const void *extraAllocationInfo,
                                  Image *image,
                                  DeviceMemory *deviceMemoryOut,
                                  VkDeviceSize *sizeOut)
{
    return AllocateBufferOrImageMemory(context, memoryPropertyFlags, memoryPropertyFlagsOut,
                                       extraAllocationInfo, image, deviceMemoryOut, sizeOut);
}

angle::Result AllocateImageMemoryWithRequirements(Context *context,
                                                  VkMemoryPropertyFlags memoryPropertyFlags,
                                                  const VkMemoryRequirements &memoryRequirements,
                                                  const void *extraAllocationInfo,
                                                  Image *image,
                                                  DeviceMemory *deviceMemoryOut)
{
    VkMemoryPropertyFlags memoryPropertyFlagsOut = 0;
    return AllocateAndBindBufferOrImageMemory(context, memoryPropertyFlags, &memoryPropertyFlagsOut,
                                              memoryRequirements, extraAllocationInfo, image,
                                              deviceMemoryOut);
}

angle::Result AllocateBufferMemoryWithRequirements(Context *context,
                                                   VkMemoryPropertyFlags memoryPropertyFlags,
                                                   const VkMemoryRequirements &memoryRequirements,
                                                   const void *extraAllocationInfo,
                                                   Buffer *buffer,
                                                   VkMemoryPropertyFlags *memoryPropertyFlagsOut,
                                                   DeviceMemory *deviceMemoryOut)
{
    return AllocateAndBindBufferOrImageMemory(context, memoryPropertyFlags, memoryPropertyFlagsOut,
                                              memoryRequirements, extraAllocationInfo, buffer,
                                              deviceMemoryOut);
}

angle::Result InitShaderAndSerial(Context *context,
                                  ShaderAndSerial *shaderAndSerial,
                                  const uint32_t *shaderCode,
                                  size_t shaderCodeSize)
{
    VkShaderModuleCreateInfo createInfo = {};
    createInfo.sType                    = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
    createInfo.flags                    = 0;
    createInfo.codeSize                 = shaderCodeSize;
    createInfo.pCode                    = shaderCode;

    ANGLE_VK_TRY(context, shaderAndSerial->get().init(context->getDevice(), createInfo));
    shaderAndSerial->updateSerial(context->getRenderer()->issueShaderSerial());
    return angle::Result::Continue;
}

gl::TextureType Get2DTextureType(uint32_t layerCount, GLint samples)
{
    if (layerCount > 1)
    {
        if (samples > 1)
        {
            return gl::TextureType::_2DMultisampleArray;
        }
        else
        {
            return gl::TextureType::_2DArray;
        }
    }
    else
    {
        if (samples > 1)
        {
            return gl::TextureType::_2DMultisample;
        }
        else
        {
            return gl::TextureType::_2D;
        }
    }
}

GarbageObject::GarbageObject() : mHandleType(HandleType::Invalid), mHandle(VK_NULL_HANDLE) {}

GarbageObject::GarbageObject(HandleType handleType, GarbageHandle handle)
    : mHandleType(handleType), mHandle(handle)
{}

GarbageObject::GarbageObject(GarbageObject &&other) : GarbageObject()
{
    *this = std::move(other);
}

GarbageObject &GarbageObject::operator=(GarbageObject &&rhs)
{
    std::swap(mHandle, rhs.mHandle);
    std::swap(mHandleType, rhs.mHandleType);
    return *this;
}

// GarbageObject implementation
// Using c-style casts here to avoid conditional compile for MSVC 32-bit
//  which fails to compile with reinterpret_cast, requiring static_cast.
void GarbageObject::destroy(RendererVk *renderer)
{
    ANGLE_TRACE_EVENT0("gpu.angle", "GarbageObject::destroy");
    VkDevice device = renderer->getDevice();
    switch (mHandleType)
    {
        case HandleType::Semaphore:
            vkDestroySemaphore(device, (VkSemaphore)mHandle, nullptr);
            break;
        case HandleType::CommandBuffer:
            // Command buffers are pool allocated.
            UNREACHABLE();
            break;
        case HandleType::Event:
            vkDestroyEvent(device, (VkEvent)mHandle, nullptr);
            break;
        case HandleType::Fence:
            vkDestroyFence(device, (VkFence)mHandle, nullptr);
            break;
        case HandleType::DeviceMemory:
            vkFreeMemory(device, (VkDeviceMemory)mHandle, nullptr);
            break;
        case HandleType::Buffer:
            vkDestroyBuffer(device, (VkBuffer)mHandle, nullptr);
            break;
        case HandleType::BufferView:
            vkDestroyBufferView(device, (VkBufferView)mHandle, nullptr);
            break;
        case HandleType::Image:
            vkDestroyImage(device, (VkImage)mHandle, nullptr);
            break;
        case HandleType::ImageView:
            vkDestroyImageView(device, (VkImageView)mHandle, nullptr);
            break;
        case HandleType::ShaderModule:
            vkDestroyShaderModule(device, (VkShaderModule)mHandle, nullptr);
            break;
        case HandleType::PipelineLayout:
            vkDestroyPipelineLayout(device, (VkPipelineLayout)mHandle, nullptr);
            break;
        case HandleType::RenderPass:
            vkDestroyRenderPass(device, (VkRenderPass)mHandle, nullptr);
            break;
        case HandleType::Pipeline:
            vkDestroyPipeline(device, (VkPipeline)mHandle, nullptr);
            break;
        case HandleType::DescriptorSetLayout:
            vkDestroyDescriptorSetLayout(device, (VkDescriptorSetLayout)mHandle, nullptr);
            break;
        case HandleType::Sampler:
            vkDestroySampler(device, (VkSampler)mHandle, nullptr);
            break;
        case HandleType::DescriptorPool:
            vkDestroyDescriptorPool(device, (VkDescriptorPool)mHandle, nullptr);
            break;
        case HandleType::Framebuffer:
            vkDestroyFramebuffer(device, (VkFramebuffer)mHandle, nullptr);
            break;
        case HandleType::CommandPool:
            vkDestroyCommandPool(device, (VkCommandPool)mHandle, nullptr);
            break;
        case HandleType::QueryPool:
            vkDestroyQueryPool(device, (VkQueryPool)mHandle, nullptr);
            break;
        case HandleType::Allocation:
            vma::FreeMemory(renderer->getAllocator().getHandle(), (VmaAllocation)mHandle);
            break;
        default:
            UNREACHABLE();
            break;
    }

    renderer->getActiveHandleCounts().onDeallocate(mHandleType);
}

void MakeDebugUtilsLabel(GLenum source, const char *marker, VkDebugUtilsLabelEXT *label)
{
    static constexpr angle::ColorF kLabelColors[6] = {
        angle::ColorF(1.0f, 0.5f, 0.5f, 1.0f),  // DEBUG_SOURCE_API
        angle::ColorF(0.5f, 1.0f, 0.5f, 1.0f),  // DEBUG_SOURCE_WINDOW_SYSTEM
        angle::ColorF(0.5f, 0.5f, 1.0f, 1.0f),  // DEBUG_SOURCE_SHADER_COMPILER
        angle::ColorF(0.7f, 0.7f, 0.7f, 1.0f),  // DEBUG_SOURCE_THIRD_PARTY
        angle::ColorF(0.5f, 0.8f, 0.9f, 1.0f),  // DEBUG_SOURCE_APPLICATION
        angle::ColorF(0.9f, 0.8f, 0.5f, 1.0f),  // DEBUG_SOURCE_OTHER
    };

    int colorIndex = source - GL_DEBUG_SOURCE_API;
    ASSERT(colorIndex >= 0 && static_cast<size_t>(colorIndex) < ArraySize(kLabelColors));

    label->sType      = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
    label->pNext      = nullptr;
    label->pLabelName = marker;
    kLabelColors[colorIndex].writeData(label->color);
}

// ClearValuesArray implementation.
ClearValuesArray::ClearValuesArray() : mValues{}, mEnabled{} {}

ClearValuesArray::~ClearValuesArray() = default;

ClearValuesArray::ClearValuesArray(const ClearValuesArray &other) = default;

ClearValuesArray &ClearValuesArray::operator=(const ClearValuesArray &rhs) = default;

void ClearValuesArray::store(uint32_t index,
                             VkImageAspectFlags aspectFlags,
                             const VkClearValue &clearValue)
{
    ASSERT(aspectFlags != 0);

    // We do this double if to handle the packed depth-stencil case.
    if ((aspectFlags & VK_IMAGE_ASPECT_STENCIL_BIT) != 0)
    {
        // Ensure for packed DS we're writing to the depth index.
        ASSERT(index == kUnpackedDepthIndex ||
               (index == kUnpackedStencilIndex && aspectFlags == VK_IMAGE_ASPECT_STENCIL_BIT));

        storeNoDepthStencil(kUnpackedStencilIndex, clearValue);
    }

    if (aspectFlags != VK_IMAGE_ASPECT_STENCIL_BIT)
    {
        storeNoDepthStencil(index, clearValue);
    }
}

void ClearValuesArray::storeNoDepthStencil(uint32_t index, const VkClearValue &clearValue)
{
    mValues[index] = clearValue;
    mEnabled.set(index);
}

gl::DrawBufferMask ClearValuesArray::getColorMask() const
{
    constexpr uint32_t kColorBuffersMask =
        angle::Bit<uint32_t>(gl::IMPLEMENTATION_MAX_DRAW_BUFFERS) - 1;
    return gl::DrawBufferMask(mEnabled.bits() & kColorBuffersMask);
}

// ResourceSerialFactory implementation.
ResourceSerialFactory::ResourceSerialFactory() : mCurrentUniqueSerial(1) {}

ResourceSerialFactory::~ResourceSerialFactory() {}

uint32_t ResourceSerialFactory::issueSerial()
{
    uint32_t newSerial = ++mCurrentUniqueSerial;
    // make sure serial does not wrap
    ASSERT(newSerial > 0);
    return newSerial;
}

#define ANGLE_DEFINE_GEN_VK_SERIAL(Type)                         \
    Type##Serial ResourceSerialFactory::generate##Type##Serial() \
    {                                                            \
        return Type##Serial(issueSerial());                      \
    }

ANGLE_VK_SERIAL_OP(ANGLE_DEFINE_GEN_VK_SERIAL)
}  // namespace vk

#if !defined(ANGLE_SHARED_LIBVULKAN)
// VK_EXT_debug_utils
PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT   = nullptr;
PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = nullptr;
PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT       = nullptr;
PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT           = nullptr;
PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT     = nullptr;

// VK_EXT_debug_report
PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT   = nullptr;
PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT = nullptr;

// VK_KHR_get_physical_device_properties2
PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR             = nullptr;
PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR                 = nullptr;
PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR = nullptr;

// VK_KHR_external_semaphore_fd
PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR = nullptr;

// VK_EXT_external_memory_host
PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT = nullptr;

// VK_EXT_transform_feedback
PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT = nullptr;
PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT             = nullptr;
PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT                 = nullptr;
PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT                       = nullptr;
PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT                           = nullptr;
PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT               = nullptr;

// VK_KHR_get_memory_requirements2
PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR = nullptr;
PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR   = nullptr;

// VK_KHR_bind_memory2
PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR = nullptr;
PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR   = nullptr;

// VK_KHR_external_fence_capabilities
PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR =
    nullptr;

// VK_KHR_external_fence_fd
PFN_vkGetFenceFdKHR vkGetFenceFdKHR       = nullptr;
PFN_vkImportFenceFdKHR vkImportFenceFdKHR = nullptr;

// VK_KHR_external_semaphore_capabilities
PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR
    vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = nullptr;

// VK_KHR_sampler_ycbcr_conversion
PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR   = nullptr;
PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR = nullptr;

// VK_KHR_create_renderpass2
PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR = nullptr;

#    if defined(ANGLE_PLATFORM_FUCHSIA)
// VK_FUCHSIA_imagepipe_surface
PFN_vkCreateImagePipeSurfaceFUCHSIA vkCreateImagePipeSurfaceFUCHSIA = nullptr;
#    endif

#    if defined(ANGLE_PLATFORM_ANDROID)
PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID =
    nullptr;
PFN_vkGetMemoryAndroidHardwareBufferANDROID vkGetMemoryAndroidHardwareBufferANDROID = nullptr;
#    endif

#    if defined(ANGLE_PLATFORM_GGP)
PFN_vkCreateStreamDescriptorSurfaceGGP vkCreateStreamDescriptorSurfaceGGP = nullptr;
#    endif

#    define GET_INSTANCE_FUNC(vkName)                                                          \
        do                                                                                \
        {                                                                                \
            vkName = reinterpret_cast<PFN_##vkName>(vkGetInstanceProcAddr(instance, #vkName)); \
            ASSERT(vkName);                                                                    \
        } while (0)

#    define GET_DEVICE_FUNC(vkName)                                                        \
        do                                                                                \
        {                                                                                \
            vkName = reinterpret_cast<PFN_##vkName>(vkGetDeviceProcAddr(device, #vkName)); \
            ASSERT(vkName);                                                                \
        } while (0)

void InitDebugUtilsEXTFunctions(VkInstance instance)
{
    GET_INSTANCE_FUNC(vkCreateDebugUtilsMessengerEXT);
    GET_INSTANCE_FUNC(vkDestroyDebugUtilsMessengerEXT);
    GET_INSTANCE_FUNC(vkCmdBeginDebugUtilsLabelEXT);
    GET_INSTANCE_FUNC(vkCmdEndDebugUtilsLabelEXT);
    GET_INSTANCE_FUNC(vkCmdInsertDebugUtilsLabelEXT);
}

void InitDebugReportEXTFunctions(VkInstance instance)
{
    GET_INSTANCE_FUNC(vkCreateDebugReportCallbackEXT);
    GET_INSTANCE_FUNC(vkDestroyDebugReportCallbackEXT);
}

void InitGetPhysicalDeviceProperties2KHRFunctions(VkInstance instance)
{
    GET_INSTANCE_FUNC(vkGetPhysicalDeviceProperties2KHR);
    GET_INSTANCE_FUNC(vkGetPhysicalDeviceFeatures2KHR);
    GET_INSTANCE_FUNC(vkGetPhysicalDeviceMemoryProperties2KHR);
}

void InitTransformFeedbackEXTFunctions(VkDevice device)
{
    GET_DEVICE_FUNC(vkCmdBindTransformFeedbackBuffersEXT);
    GET_DEVICE_FUNC(vkCmdBeginTransformFeedbackEXT);
    GET_DEVICE_FUNC(vkCmdEndTransformFeedbackEXT);
    GET_DEVICE_FUNC(vkCmdBeginQueryIndexedEXT);
    GET_DEVICE_FUNC(vkCmdEndQueryIndexedEXT);
    GET_DEVICE_FUNC(vkCmdDrawIndirectByteCountEXT);
}

// VK_KHR_sampler_ycbcr_conversion
void InitSamplerYcbcrKHRFunctions(VkDevice device)
{
    GET_DEVICE_FUNC(vkCreateSamplerYcbcrConversionKHR);
    GET_DEVICE_FUNC(vkDestroySamplerYcbcrConversionKHR);
}

// VK_KHR_create_renderpass2
void InitRenderPass2KHRFunctions(VkDevice device)
{
    GET_DEVICE_FUNC(vkCreateRenderPass2KHR);
}

#    if defined(ANGLE_PLATFORM_FUCHSIA)
void InitImagePipeSurfaceFUCHSIAFunctions(VkInstance instance)
{
    GET_INSTANCE_FUNC(vkCreateImagePipeSurfaceFUCHSIA);
}
#    endif

#    if defined(ANGLE_PLATFORM_ANDROID)
void InitExternalMemoryHardwareBufferANDROIDFunctions(VkInstance instance)
{
    GET_INSTANCE_FUNC(vkGetAndroidHardwareBufferPropertiesANDROID);
    GET_INSTANCE_FUNC(vkGetMemoryAndroidHardwareBufferANDROID);
}
#    endif

#    if defined(ANGLE_PLATFORM_GGP)
void InitGGPStreamDescriptorSurfaceFunctions(VkInstance instance)
{
    GET_INSTANCE_FUNC(vkCreateStreamDescriptorSurfaceGGP);
}
#    endif  // defined(ANGLE_PLATFORM_GGP)

void InitExternalSemaphoreFdFunctions(VkInstance instance)
{
    GET_INSTANCE_FUNC(vkImportSemaphoreFdKHR);
}

void InitExternalMemoryHostFunctions(VkInstance instance)
{
    GET_INSTANCE_FUNC(vkGetMemoryHostPointerPropertiesEXT);
}

// VK_KHR_get_memory_requirements2
void InitGetMemoryRequirements2KHRFunctions(VkDevice device)
{
    GET_DEVICE_FUNC(vkGetBufferMemoryRequirements2KHR);
    GET_DEVICE_FUNC(vkGetImageMemoryRequirements2KHR);
}

// VK_KHR_bind_memory2
void InitBindMemory2KHRFunctions(VkDevice device)
{
    GET_DEVICE_FUNC(vkBindBufferMemory2KHR);
    GET_DEVICE_FUNC(vkBindImageMemory2KHR);
}

// VK_KHR_external_fence_capabilities
void InitExternalFenceCapabilitiesFunctions(VkInstance instance)
{
    GET_INSTANCE_FUNC(vkGetPhysicalDeviceExternalFencePropertiesKHR);
}

// VK_KHR_external_fence_fd
void InitExternalFenceFdFunctions(VkInstance instance)
{
    GET_INSTANCE_FUNC(vkGetFenceFdKHR);
    GET_INSTANCE_FUNC(vkImportFenceFdKHR);
}

// VK_KHR_external_semaphore_capabilities
void InitExternalSemaphoreCapabilitiesFunctions(VkInstance instance)
{
    GET_INSTANCE_FUNC(vkGetPhysicalDeviceExternalSemaphorePropertiesKHR);
}

#    undef GET_INSTANCE_FUNC
#    undef GET_DEVICE_FUNC

#endif  // !defined(ANGLE_SHARED_LIBVULKAN)

GLenum CalculateGenerateMipmapFilter(ContextVk *contextVk, const vk::Format &format)
{
    const bool formatSupportsLinearFiltering = contextVk->getRenderer()->hasImageFormatFeatureBits(
        format.actualImageFormatID, VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT);
    const bool hintFastest = contextVk->getState().getGenerateMipmapHint() == GL_FASTEST;

    return formatSupportsLinearFiltering && !hintFastest ? GL_LINEAR : GL_NEAREST;
}

// Return the log of samples.  Assumes |sampleCount| is a power of 2.  The result can be used to
// index an array based on sample count.  See for example TextureVk::PerSampleCountArray.
size_t PackSampleCount(GLint sampleCount)
{
    if (sampleCount == 0)
    {
        sampleCount = 1;
    }

    // We currently only support up to 16xMSAA.
    ASSERT(sampleCount <= VK_SAMPLE_COUNT_16_BIT);
    ASSERT(gl::isPow2(sampleCount));
    return gl::ScanForward(static_cast<uint32_t>(sampleCount));
}

namespace gl_vk
{

VkFilter GetFilter(const GLenum filter)
{
    switch (filter)
    {
        case GL_LINEAR_MIPMAP_LINEAR:
        case GL_LINEAR_MIPMAP_NEAREST:
        case GL_LINEAR:
            return VK_FILTER_LINEAR;
        case GL_NEAREST_MIPMAP_LINEAR:
        case GL_NEAREST_MIPMAP_NEAREST:
        case GL_NEAREST:
            return VK_FILTER_NEAREST;
        default:
            UNIMPLEMENTED();
            return VK_FILTER_MAX_ENUM;
    }
}

VkSamplerMipmapMode GetSamplerMipmapMode(const GLenum filter)
{
    switch (filter)
    {
        case GL_LINEAR_MIPMAP_LINEAR:
        case GL_NEAREST_MIPMAP_LINEAR:
            return VK_SAMPLER_MIPMAP_MODE_LINEAR;
        case GL_LINEAR:
        case GL_NEAREST:
        case GL_NEAREST_MIPMAP_NEAREST:
        case GL_LINEAR_MIPMAP_NEAREST:
            return VK_SAMPLER_MIPMAP_MODE_NEAREST;
        default:
            UNIMPLEMENTED();
            return VK_SAMPLER_MIPMAP_MODE_MAX_ENUM;
    }
}

VkSamplerAddressMode GetSamplerAddressMode(const GLenum wrap)
{
    switch (wrap)
    {
        case GL_REPEAT:
            return VK_SAMPLER_ADDRESS_MODE_REPEAT;
        case GL_MIRRORED_REPEAT:
            return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
        case GL_CLAMP_TO_BORDER:
            return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
        case GL_CLAMP_TO_EDGE:
            return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
        default:
            UNIMPLEMENTED();
            return VK_SAMPLER_ADDRESS_MODE_MAX_ENUM;
    }
}

VkRect2D GetRect(const gl::Rectangle &source)
{
    return {{source.x, source.y},
            {static_cast<uint32_t>(source.width), static_cast<uint32_t>(source.height)}};
}

VkPrimitiveTopology GetPrimitiveTopology(gl::PrimitiveMode mode)
{
    switch (mode)
    {
        case gl::PrimitiveMode::Triangles:
            return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
        case gl::PrimitiveMode::Points:
            return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
        case gl::PrimitiveMode::Lines:
            return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
        case gl::PrimitiveMode::LineStrip:
            return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
        case gl::PrimitiveMode::TriangleFan:
            return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
        case gl::PrimitiveMode::TriangleStrip:
            return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
        case gl::PrimitiveMode::LineLoop:
            return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
        case gl::PrimitiveMode::LinesAdjacency:
            return VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY;
        case gl::PrimitiveMode::LineStripAdjacency:
            return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY;
        case gl::PrimitiveMode::TrianglesAdjacency:
            return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY;
        case gl::PrimitiveMode::TriangleStripAdjacency:
            return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY;
        case gl::PrimitiveMode::Patches:
            return VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
        default:
            UNREACHABLE();
            return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
    }
}

VkCullModeFlagBits GetCullMode(const gl::RasterizerState &rasterState)
{
    if (!rasterState.cullFace)
    {
        return VK_CULL_MODE_NONE;
    }

    switch (rasterState.cullMode)
    {
        case gl::CullFaceMode::Front:
            return VK_CULL_MODE_FRONT_BIT;
        case gl::CullFaceMode::Back:
            return VK_CULL_MODE_BACK_BIT;
        case gl::CullFaceMode::FrontAndBack:
            return VK_CULL_MODE_FRONT_AND_BACK;
        default:
            UNREACHABLE();
            return VK_CULL_MODE_NONE;
    }
}

VkFrontFace GetFrontFace(GLenum frontFace, bool invertCullFace)
{
    // Invert CW and CCW to have the same behavior as OpenGL.
    switch (frontFace)
    {
        case GL_CW:
            return invertCullFace ? VK_FRONT_FACE_CLOCKWISE : VK_FRONT_FACE_COUNTER_CLOCKWISE;
        case GL_CCW:
            return invertCullFace ? VK_FRONT_FACE_COUNTER_CLOCKWISE : VK_FRONT_FACE_CLOCKWISE;
        default:
            UNREACHABLE();
            return VK_FRONT_FACE_CLOCKWISE;
    }
}

VkSampleCountFlagBits GetSamples(GLint sampleCount)
{
    switch (sampleCount)
    {
        case 0:
            UNREACHABLE();
            return VK_SAMPLE_COUNT_1_BIT;
        case 1:
            return VK_SAMPLE_COUNT_1_BIT;
        case 2:
            return VK_SAMPLE_COUNT_2_BIT;
        case 4:
            return VK_SAMPLE_COUNT_4_BIT;
        case 8:
            return VK_SAMPLE_COUNT_8_BIT;
        case 16:
            return VK_SAMPLE_COUNT_16_BIT;
        case 32:
            return VK_SAMPLE_COUNT_32_BIT;
        default:
            UNREACHABLE();
            return VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM;
    }
}

VkComponentSwizzle GetSwizzle(const GLenum swizzle)
{
    switch (swizzle)
    {
        case GL_ALPHA:
            return VK_COMPONENT_SWIZZLE_A;
        case GL_RED:
            return VK_COMPONENT_SWIZZLE_R;
        case GL_GREEN:
            return VK_COMPONENT_SWIZZLE_G;
        case GL_BLUE:
            return VK_COMPONENT_SWIZZLE_B;
        case GL_ZERO:
            return VK_COMPONENT_SWIZZLE_ZERO;
        case GL_ONE:
            return VK_COMPONENT_SWIZZLE_ONE;
        default:
            UNREACHABLE();
            return VK_COMPONENT_SWIZZLE_IDENTITY;
    }
}

VkCompareOp GetCompareOp(const GLenum compareFunc)
{
    switch (compareFunc)
    {
        case GL_NEVER:
            return VK_COMPARE_OP_NEVER;
        case GL_LESS:
            return VK_COMPARE_OP_LESS;
        case GL_EQUAL:
            return VK_COMPARE_OP_EQUAL;
        case GL_LEQUAL:
            return VK_COMPARE_OP_LESS_OR_EQUAL;
        case GL_GREATER:
            return VK_COMPARE_OP_GREATER;
        case GL_NOTEQUAL:
            return VK_COMPARE_OP_NOT_EQUAL;
        case GL_GEQUAL:
            return VK_COMPARE_OP_GREATER_OR_EQUAL;
        case GL_ALWAYS:
            return VK_COMPARE_OP_ALWAYS;
        default:
            UNREACHABLE();
            return VK_COMPARE_OP_ALWAYS;
    }
}

void GetOffset(const gl::Offset &glOffset, VkOffset3D *vkOffset)
{
    vkOffset->x = glOffset.x;
    vkOffset->y = glOffset.y;
    vkOffset->z = glOffset.z;
}

void GetExtent(const gl::Extents &glExtent, VkExtent3D *vkExtent)
{
    vkExtent->width  = glExtent.width;
    vkExtent->height = glExtent.height;
    vkExtent->depth  = glExtent.depth;
}

VkImageType GetImageType(gl::TextureType textureType)
{
    switch (textureType)
    {
        case gl::TextureType::_2D:
        case gl::TextureType::_2DArray:
        case gl::TextureType::_2DMultisample:
        case gl::TextureType::_2DMultisampleArray:
        case gl::TextureType::CubeMap:
        case gl::TextureType::CubeMapArray:
        case gl::TextureType::External:
            return VK_IMAGE_TYPE_2D;
        case gl::TextureType::_3D:
            return VK_IMAGE_TYPE_3D;
        default:
            // We will need to implement all the texture types for ES3+.
            UNIMPLEMENTED();
            return VK_IMAGE_TYPE_MAX_ENUM;
    }
}

VkImageViewType GetImageViewType(gl::TextureType textureType)
{
    switch (textureType)
    {
        case gl::TextureType::_2D:
        case gl::TextureType::_2DMultisample:
        case gl::TextureType::External:
            return VK_IMAGE_VIEW_TYPE_2D;
        case gl::TextureType::_2DArray:
        case gl::TextureType::_2DMultisampleArray:
            return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
        case gl::TextureType::_3D:
            return VK_IMAGE_VIEW_TYPE_3D;
        case gl::TextureType::CubeMap:
            return VK_IMAGE_VIEW_TYPE_CUBE;
        case gl::TextureType::CubeMapArray:
            return VK_IMAGE_VIEW_TYPE_CUBE_ARRAY;
        default:
            // We will need to implement all the texture types for ES3+.
            UNIMPLEMENTED();
            return VK_IMAGE_VIEW_TYPE_MAX_ENUM;
    }
}

VkColorComponentFlags GetColorComponentFlags(bool red, bool green, bool blue, bool alpha)
{
    return (red ? VK_COLOR_COMPONENT_R_BIT : 0) | (green ? VK_COLOR_COMPONENT_G_BIT : 0) |
           (blue ? VK_COLOR_COMPONENT_B_BIT : 0) | (alpha ? VK_COLOR_COMPONENT_A_BIT : 0);
}

VkShaderStageFlags GetShaderStageFlags(gl::ShaderBitSet activeShaders)
{
    VkShaderStageFlags flags = 0;
    for (const gl::ShaderType shaderType : activeShaders)
    {
        flags |= kShaderStageMap[shaderType];
    }
    return flags;
}

void GetViewport(const gl::Rectangle &viewport,
                 float nearPlane,
                 float farPlane,
                 bool invertViewport,
                 bool clipSpaceOriginUpperLeft,
                 GLint renderAreaHeight,
                 VkViewport *viewportOut)
{
    viewportOut->x        = static_cast<float>(viewport.x);
    viewportOut->y        = static_cast<float>(viewport.y);
    viewportOut->width    = static_cast<float>(viewport.width);
    viewportOut->height   = static_cast<float>(viewport.height);
    viewportOut->minDepth = gl::clamp01(nearPlane);
    viewportOut->maxDepth = gl::clamp01(farPlane);

    // Say an application intends to draw a primitive (shown as 'o' below), it can choose to use
    // different clip space origin. When clip space origin (shown as 'C' below) is switched from
    // lower-left to upper-left, primitives will be rendered with its y-coordinate flipped.

    // Rendered content will differ based on whether it is a default framebuffer or a user defined
    // framebuffer. We modify the viewport's 'y' and 'h' accordingly.

    // clip space origin is lower-left
    // Expected draw in GLES        default framebuffer    user defined framebuffer
    // (0,H)                        (0,0)                  (0,0)
    // +                            +-----------+  (W,0)   +-----------+ (W,0)
    // |                            |                      |  C----+
    // |                            |                      |  |    | (h)
    // |  +----+                    |  +----+              |  | O  |
    // |  | O  |                    |  | O  | (-h)         |  +----+
    // |  |    |                    |  |    |              |
    // |  C----+                    |  C----+              |
    // +-----------+ (W,0)          +                      +
    // (0,0)                        (0,H)                  (0,H)
    //                              y' = H - h             y' = y

    // clip space origin is upper-left
    // Expected draw in GLES        default framebuffer     user defined framebuffer
    // (0,H)                        (0,0)                  (0,0)
    // +                            +-----------+  (W,0)   +-----------+ (W,0)
    // |                            |                      |  +----+
    // |                            |                      |  | O  | (-h)
    // |  C----+                    |  C----+              |  |    |
    // |  |    |                    |  |    | (h)          |  C----+
    // |  | O  |                    |  | O  |              |
    // |  +----+                    |  +----+              |
    // +-----------+  (W,0)         +                      +
    // (0,0)                        (0,H)                  (0,H)
    //                              y' = H - (y + h)       y' = y + H

    if (clipSpaceOriginUpperLeft)
    {
        if (invertViewport)
        {
            viewportOut->y = static_cast<float>(renderAreaHeight - (viewport.height + viewport.y));
        }
        else
        {
            viewportOut->y      = static_cast<float>(viewport.height + viewport.y);
            viewportOut->height = -viewportOut->height;
        }
    }
    else
    {
        if (invertViewport)
        {
            viewportOut->y      = static_cast<float>(renderAreaHeight - viewport.y);
            viewportOut->height = -viewportOut->height;
        }
    }
}

void GetExtentsAndLayerCount(gl::TextureType textureType,
                             const gl::Extents &extents,
                             VkExtent3D *extentsOut,
                             uint32_t *layerCountOut)
{
    extentsOut->width  = extents.width;
    extentsOut->height = extents.height;

    switch (textureType)
    {
        case gl::TextureType::CubeMap:
            extentsOut->depth = 1;
            *layerCountOut    = gl::kCubeFaceCount;
            break;

        case gl::TextureType::_2DArray:
        case gl::TextureType::_2DMultisampleArray:
        case gl::TextureType::CubeMapArray:
            extentsOut->depth = 1;
            *layerCountOut    = extents.depth;
            break;

        default:
            extentsOut->depth = extents.depth;
            *layerCountOut    = 1;
            break;
    }
}

vk::LevelIndex GetLevelIndex(gl::LevelIndex levelGL, gl::LevelIndex baseLevel)
{
    ASSERT(baseLevel <= levelGL);
    return vk::LevelIndex(levelGL.get() - baseLevel.get());
}
}  // namespace gl_vk

namespace vk_gl
{
void AddSampleCounts(VkSampleCountFlags sampleCounts, gl::SupportedSampleSet *setOut)
{
    // The possible bits are VK_SAMPLE_COUNT_n_BIT = n, with n = 1 << b.  At the time of this
    // writing, b is in [0, 6], however, we test all 32 bits in case the enum is extended.
    for (size_t bit : angle::BitSet32<32>(sampleCounts & kSupportedSampleCounts))
    {
        setOut->insert(static_cast<GLuint>(1 << bit));
    }
}

GLuint GetMaxSampleCount(VkSampleCountFlags sampleCounts)
{
    GLuint maxCount = 0;
    for (size_t bit : angle::BitSet32<32>(sampleCounts & kSupportedSampleCounts))
    {
        maxCount = static_cast<GLuint>(1 << bit);
    }
    return maxCount;
}

GLuint GetSampleCount(VkSampleCountFlags supportedCounts, GLuint requestedCount)
{
    for (size_t bit : angle::BitSet32<32>(supportedCounts & kSupportedSampleCounts))
    {
        GLuint sampleCount = static_cast<GLuint>(1 << bit);
        if (sampleCount >= requestedCount)
        {
            return sampleCount;
        }
    }

    UNREACHABLE();
    return 0;
}

gl::LevelIndex GetLevelIndex(vk::LevelIndex levelVk, gl::LevelIndex baseLevel)
{
    return gl::LevelIndex(levelVk.get() + baseLevel.get());
}
}  // namespace vk_gl
}  // namespace rx

redpajama_set_name: RedPajamaGithub


text:
Apian-Bennewitz, auch Apian von Bennewitz oder Apianus von Bennewitz ist der Name einer deutschen Adelsfamilie. Der ursprüngliche Name Bennewitz bzw. Bienewitz ('Biene-witz' im Sinne von "Bienen-dorf") wurde dabei nach Apian eingedeutscht (lat. apis 'Biene'), Apianus stellt die latinisierte Form dar.

Geschichte
Peter Apian, gebürtig in Leisnig, wurde am 20. Juli 1541 zusammen mit seinen Brüdern Gregor, Niklas und Georg von Karl V. mit seinen Brüdern in den Reichsadelsstand erhoben.

Wappen
Das Wappen zeigt in Gold innerhalb eines Kranzes blau–silberner Wolken den doppelköpfigen schwarzen Reichsadler. Auf dem gekrönten Helm mit schwarz-goldenen Helmdecken das Schildbild.

Angehörige
 Georg Apian, auch Georg Apianus sowie Georg Bienewitz oder Bennewitz, deutscher Buchdrucker und Verleger des 16. Jahrhunderts (Bruder von Peter Apian)
 Peter Apian (1495–1552), auch Peter oder Petrus Apianus sowie Peter Bienewitz oder Bennewitz, deutscher Renaissancegelehrter
 Philipp Apian (1531–1589), auch Philipp Apianus, deutscher Mathematiker, Arzt und Kartograph
 Timotheus Apian († 1562), deutscher Landvermesser des 16. Jahrhunderts
 Karl Apian († 1600), auch Carolus Apianus, Grundherr der Hofmark Ittelhofen

sowie:
 Carl Gottlob Friedrich Apian-Bennewitz (1793–1847), Stadtrat in Zschopau/Sachsen
 Paul Otto Apian-Bennewitz (1847–1892), Organist und Lehrer, Begründer des Musikinstrumenten-Museums Markneukirchen

Siehe auch
 Krater Apianus (26° 9' S, 7° 9' O) auf dem Erdmond, benannt nach Peter Apian
 Asteroid (19139) Apian, benannt nach Peter Apian

Literatur
 Adelsdiplom der Familie Apian von Bennewitz. u. Zur 400jährigen Geburtstagsfeier Apian von Bennewitz. In: Der Wappensammler. 1, 1900/01, S. 145–155 u. 184–186

Weblinks
 Wappen der "Apianer" in Siebmachers Wappenbuch von 1701, Band 5, "Speyrische am Kaiserl: Cammergericht", Tafel 212
 Wappen der Apian-Bennewitz am Haus Nr. 2 in  Annaberg-Buchholz

Einzelnachweise

Deutsches Adelsgeschlecht

redpajama_set_name: RedPajamaWikipedia


text:
Sri Lanka judiciary's failure led Tamils to take arms - Ranil
[TamilNet, Friday, 10 January 2003, 17:20 GMT]
Sri Lanka's Prime Minister Mr.Ranil Wickremasinghe said Friday that the failure of the country's judiciary to fulfill its duties and responsibilities to safeguard the right of various ethnic groups has led the Tamils to launch an armed struggle for a separate state.
The Prime Minister made this observation Friday when inaugurating a three day conference of Chief Justices of the world at Colombo Hotel Oberoi. Chief Justices from nine countries including Nepal, Bangladesh, Tanzania, South Africa, Uganda, Phillipines and Karnataka state in India participated at the conference.
Members of the Free Media Movement held an agitation against the Sri Lanka Chief Justice, Mr.Sarath N Silva, in front of the Hotel Oberoi and handed over a memorandum to one of the conveners of the conference. The memorandum alleged several irregularities committed by the Sri Lanka's Chief Justice. Mr.Sarath N Silva did not attend the conference.
Sri Lanka's former judge of the Supreme Court and former vice president of the International Court Professor C.G.Weeramantry presided.
Mr.Ranil Wickremasinghe further said," action against frauds in the judiciary should not be restricted to agitation on the national level. Attention of the Asian countries should be drawn to forming a national charter on the freedom of courts and human rights. Struggle against fraud in the legal field should not be restricted to national level and time has come to launch action on regional basis."
Referring to the Indian judiciary, the Prime Minister said the Indian Supreme Court has rendered an immense service in the past five years to safeguard the rights of civilians. This has caused considerable impact to create an Indian identity. " However the situation in Sri Lanka is completely different," said Mr.Ranil Wickremasinghe.
" It is questionable whether the Sri Lankan judiciary fulfilled its duties and responsibilities to safeguard the rights and freedoms of various communities in the country. This has led the Tamils to launch an armed struggle to create a separate state in the country," said Mr.Wickremasinghe.
Email this article Print this article Feedback on this article
http://www.tamilnet.com/art.html?catid=13&artid=8136


I have been a regular user of massage therapies throughout my life. I found massage to be beneficial for many reasons including relaxation, sports injury recovery and to promote positive mental health and well being. I have always had a keen interest in the mechanics and systems of the body.I have worked in previous roles within the private and public health care settings. I am a strong believer that complementary therapies play a vital role working alongside allopathic health care to maintain well-balanced physical and mental health.
My journey to becoming a therapist began when I was recommended reflexology by a friend. I found it a very effective therapy for my own sleep issues, giving me great relief from my insomnia and contributing to positive well being. I became fascinated in the theories of reflexology and its use as a therapeutic practice. My interest in complimentary therapies evolved quickly, becoming aware that the path to training as a holistic therapist is where my future lay.
When looking for suitable training on my journey to becoming a therapist I looked to acquiring the highest available certification in this field. I undertook my study in complementary therapy with " The Complementary Therapy School" whose training is credit rated by Edinburgh Napier University.
Throughout this 2 year course there was a strong practical emphasis placed on training which included a comprehensive understanding of anatomy and physiology. It has given me invaluable knowledge and skills to excel as a therapist. I also gained skills in tailoring treatments to match the client. This includes acupressure reflexology, advanced massage, advanced reflexology techniques, and counselling skills among with many other business skills required as a therapist.
I have continued my professional development with the completion of a Practitioners Diploma in Hot & Cold Stone Therapy.This has been an excellent addition to the skills and services I can offer my clients.


text:
I thought you might be interested in this item at http://umaryland.worldcat.org/oclc/1158206640 Title: VILLAGE NARCISSIST. Author: GLENIS KELLET Publisher: [S.l.] : UK BOOK PUBLISHING, 2020. ISBN/ISSN: 1913179605 9781913179601 OCLC:1158206640
VILLAGE NARCISSIST.
GLENIS KELLET
[S.l.] : UK BOOK PUBLISHING, 2020.
Print book : English
Find more information about: GLENIS KELLET
Best Book I've Read This Year
by dare1958 (WorldCat user published 2020-09-29) Permalink
The Village Narcissist, by author Glenis Kellet first caught my eye before I even opened the book. The striking cover displays a black bell against a midnight blue background. (An omen of things...
The Village Narcissist, by author Glenis Kellet first caught my eye before I even opened the book. The striking cover displays a black bell against a midnight blue background. (An omen of things to come?). At the top of the cover are the names of Kellet's first two books: 'Faith in Love' and 'Falsely Accused of the Unthinkable,' the latter of the two I have already ordered; anticipating another thrilling reading experience.
I was drawn to 'The Village Narcissist' from the first page and had quite the adventure, experiencing the story along with the villagers and the detectives who finally solved the mystery.
The plot is fast paced and full of unforeseen surprises that challenge the reader to solve the mystery along with the detectives. From the first line 'A shrill piercing scream vibrated through the still, silent air,' you'll be hooked and won't be able to put the book down.
The story begins in an idyllic English village, where images of unspoiled beauty, fresh air, hospitable, hard-working people, and a serene way of life come to mind. A place far removed from the big cities: a place where nothing bad ever happens. That all changed when a pompous, overbearing stranger moved into the village. But, the worst was yet to come when the villagers discover that their close-knit community is not immune to murder and treachery, and an element among them threatens to unravel the bonds of unity and trust that has been part of village life since time began.
Be prepared for a reading experience like no other, as the author creates an elaborate rollercoaster of twists and turns; leaving you wanting more after each chapter. In the end, the villagers realized just how vulnerable they are to evil finding their quiet village, and their lives were forever changed by the events of a single day.
Dare Rogers
The Village Narcissist
by GlenisKellet (WorldCat user published 2020-09-24) Permalink
The Village Narcissist: Audacious, Abhorrent Murder Mystery Rings In. Think Village Life is Peaceful…?
Glenis Kellet's 'The Village Narcissist' is a captivating novel – it's...
Glenis Kellet's 'The Village Narcissist' is a captivating novel – it's a twisted and enthralling murder mystery set in a picture-perfect village. An idyllic place readers would dream of living in, until an obnoxious outsider purchases The Old Vicarage and placid life descends into something much more reminiscent of the dark, bloodied past. One critic wrote, "Gripped immediately! The thrilling complicated plots and twists compelled me to read it to the end. Never guessed what it's conclusion would be and it came as a real shock! It was riveting!"
Millions of Brits dream of village life. A place where neighbours are few but friendly, where the local pub is the epicentre of the action and crime wouldn't dream of showing its face. Oh, the dream…
The characters in Glenis Kellet's latest novel also shared that vision, until their remote village becomes the playground of sinister twists and turns, symbolised by the ever-ringing bell tower.
'The Village Narcissist' uniquely blends humour and dark mystery as Kellet crafts a place unlike anywhere else – inviting readers to step inside.
A body is found hanging from a noose made from a bell rope! Is this just the start of things to come?
The deceptively quiet remote village is shattered after a brazen obnoxious outsider purchases The Old Vicarage - strange disappearances occur. It wasn't until the gruesome village history was revealed - that the baffled police could solve the chilling mysteries connected to the bell tower.
The fictitious villager's characters play a colourful and humorous part in this book - bringing the small village to life - it's a gripping murder mystery, injecting the gruesome, spine-chilling history of this remote village into its final sinister twists and turns.
"Nothing symbolises the supposed-innocent nature of the UK better than its villages," explains the author. "I wanted to turn one village upside down, in a story that retains the murder mystery hallmarks readers cry out for, while also weaving together a unique narrative led by its unconventional characters."
Continuing, "It was a lot of fun to create the village and its residents from scratch. The characters are both amusing and vulnerable, I suppose perfectly mirroring real-world society itself. I won't say too much more about the book here, other than you will turn the last page with your jaw on the floor."
Readers agree, leaving five-star reviews. Lynne writes, "Glenis's books are getting better each time. She has a really fast-paced style, and a talent for interesting and unusual storylines. This book especially rang true to me, as I have lived in small village and recognise her true to life descriptions of characters and events! I am a lover of mysteries with a twist in the tail, and am really looking forward to the next one."
Other comments and reviews - "I was instantly hooked!" - "Keep writing, this is your best book yet!" - "Great imagination! plenty of plot and dialogue here. I find your books very plot-driven, plenty happening and this one is no exception." - "The Village Narcissist arrived to day brilliant could not put it down had to finish it and wow the end did not disappoint fantastic book well done. - Just ordered other 2 books." - "The vivid description made me feel I was actually there!"
FREE SAMPLE IN rogueanimalbooks
Add tags for "VILLAGE NARCISSIST.".
crime (by 1 person)
fiction (by 1 person)
murder mystery (by 1 person)
mystery (by 1 person)
romance (by 1 person)
suspense (by 1 person)
thriller (by 1 person)
1 items are tagged withcrime
1 items are tagged withfiction
1 items are tagged withmurder mystery
1 items are tagged withmystery
1 items are tagged withromance
1 items are tagged withsuspense
1 items are tagged withthriller


G-Watch is an independent national action research organization that works to promote dialogues in the Transparency-Participation- Accountability (TPA) field. It ultimately aims to contribute in the deepening of democracy through the scaling of accountability and citizen empowerment.
Browse our latest documents and publications covering G-Watch Monitoring Manuals, Governance Reform Studies, Political Democracy and Reforms (PODER) Publications, and Vertical Integration Research.


Congrats dear. Looking forward to many more lovely posts.
Thanks a lot Heena!So nice to see you here!
Congratulations Ila...and lovely top by the way..
Thanks Rupa! Glad to have you here!
Happy 2 birthday to The Flea Market Queen. Here's wishing you may more stylish years ahead.
Thanks babe! Same to you!


text:
Dimps Corporation
An Osaka-based developer founded by former SNK employees, including the co-creators of Street Fighter.
Short summary describing this company.
Company Wiki
Developed games
Published games
Loyal Employees
Goku is the main protagonist in the Dragon Ball franchise and one of the strongest fighters in the universe. He is a Saiyan warrior whose original name was Kakarot, son of Bardock. He is the husband of Chi Chi, and the father of Gohan and Goten. He is also Grandfather to Pan.
Piccolo is a character in the Dragon Ball universe who was originally portrayed as a villain but later became one of Earth's heroes.
Gohan is Goku's son and one of the heroes in the Dragon Ball Z universe. He is also the protagonist of the Cell Saga, where he is the first to reach the Super Saiyan 2 form, through immense anger and emotion. In his later Ultimate form, he is considered the most powerful warrior in Dragon Ball Z. He is Goten's older brother and the father of Pan. His wife is Videl and his grandfathers are Ox-king and Bardock, respectively.
In the Dragon Ball Z universe, Frieza is one of the first villains to really test Goku.
The Prince of all Saiyans, Vegeta is an incredibly strong elite Saiyan warrior. In his constant struggle to surpass his eternal rival Goku, he has become one of the most powerful fighters in the universe.
Krillin
Krillin holds the honor of being one of the most often killed characters in the Dragon Ball Z universe. After the cell games, Krillin grows hair and marries Android 18 and has a daughter with her named Marron.
Cell is an android constructed from cells taken from various fighters of the Dragon Ball Z universe. He is the main antagonist of the Android Saga of Dragon Ball.
Yamcha is a human fighter, ally of Goku, former bandit, and full-time (base)baller in the Dragonball universe.
Sonic the Hedgehog is one of the world's most famous video game characters and the mascot of Sega Enterprises Ltd. Sonic was introduced on June 23 1991 with the launch of Sonic the Hedgehog for the Sega Genesis. His super speed makes him one of the fastest fictional characters.
Trunks is the son of Bulma and Vegeta in the Dragon Ball franchise.
Twin sister of Android 17, the only female "Android" (actually a Cyborg in this case) created by Dr. Gero. 18 is absorbed by Cell to transform into his Perfect Form, but is later spat back out. She marries Krillin and they have a daughter, Marron.
Twin brother of Android 18 (technically Cyborgs in this case) Android 17 was created by Dr. Gero, but rebelled and killed him. 17 is absorbed by Cell and dies with him, but is later wished back to life with Cell's victims. He becomes a Park Ranger and starts a family.
The Legendary Super Saiyan from myth, Broly is one of the Dragon Ball Z franchise's most powerful and destructive Saiyan villains.
Miles "Tails" Prower is Sonic the Hedgehog's two-tailed sidekick who was first introduced in Sonic the Hedgehog 2.
Dr. Robotnik, also known as Dr. Eggman, is the antagonist in nearly every Sonic the Hedgehog title.
Nappa is a Saiyan and travels with Vegeta as his partner and former mentor. Gained a new legion of fans as Ghost Nappa of the Dragon Ball Z Abridged YouTube show. The Ghost Nappa song is his Video Game Championship Wrestling entrance theme.
Raditz
Raditz is Goku's older brother in the Dragon Ball Z frachise.
Bardock is Goku's father in the Dragon Ball Z franchise. He has appeared in several modern Dragon Ball games. He is also father to Raditz and grandfather to Gohan and Goten. His love interest is Gine and Chichi is his daughter-in-law. He is the great-grandfather of Pan.
One of Goku's allies in the struggle to protect Earth in the Dragon Ball Z saga.
Future Trunks
Trunks as he is first seen in Dragon Ball Z. He comes from the future to warn the Z fighters about the androids. When Trunks appears his is the youngest person to ever go Super Saiyan.
Majin Buu
One of Dragon Ball Z's most ferocious and transformation-happy of characters, Majin Buu is the last major enemy in the Dragon Ball Z storyline. With the ability to absorb foes, learn moves, and deliver a serious punch, Majin Buu is one of Goku and friends' most challenging of enemies.
Gotenks
Fusion Dance result between Goten and Trunks.
Goku and Vegeta fuse using the Potara Earrings to become Vegito, the most powerful character in the entire Dragon Ball Z storyline. With the strengths of the two greatest Saiyans, Vegito knows no equal in DBZ.
Cooler is Frieza's brother and the elder son of King Cold.
Mr. Satan (known as "Hercule" in the FUNimation dub of Dragon Ball Z) is the World Martial Arts Champion and Videl's father.
Android 16 is an android created by Dr. Gero to kill Goku. He was considered a failure and remained deactivated until Android 17 killed Gero and activated him.
Captain Ginyu
Leader of the Ginyu Force, Captain Ginyu possesses the ability to switch bodies with any living being.
Master Roshi
Known as 'Mutenroushi' (武天老師) in the original Japanese, Master Roshi is one of the most influential characters in all of the DBZ legend, he has raised and motivated many of the youth that would later become the universe's greatest warriors.
The second son of Goku and Chichi, younger brother of Gohan. Goten achieved the Super Saiyan transformation at just 7 years old, making him the youngest Super Saiyan ever.
A result from the performance of the Fusion Dance by Goku and Vegeta.
Top Rated Lists for Dimps Corporation
100 items StealthRUSH's Top 100 Favorite Developers / Systems of Games
Willy105 86
Gunstar_Ikari 10
Badam 6
FattyLobotnik 6
iAmJohn 4


Authors Gulati, S., Serrà J., Ganguli K. K., & Serra X.
Abstract Musical melodies contain hierarchically organized events, where some events are more salient than others, acting as melodic landmarks. In Hindustani music melodies, an important landmark is the occurrence of a nyas. Occurrence of nyas is crucial to build and sustain the format of a rag and mark the boundaries of melodic motifs. Detection of nyas segments is relevant to tasks such as melody segmentation, motif discovery and rag recognition. However, detection of nyas segments is challenging as these segments do not follow explicit set of rules in terms of segment length, contour characteristics, and melodic context. In this paper we propose a method for the automatic detection of nyas segments in Hindustani music melodies. It consists of two main steps: a segmentation step that incorporates domain knowledge in order to facilitate the placement of nyas boundaries, and a segment classification step that is based on a series of musically motivated pitch contour features. The proposed method obtains significant accuracies for a heterogeneous data set of 20 audio music recordings containing 1257 nyas svar occurrences and total duration of 1.5 hours. Further, we show that the proposed segmentation strategy significantly improves over a classical piece-wise linear segmentation approach.


text:
Business Basic
Learning Care
Style of Living
3Diesel.com
More smiling, less worrying
Keeping active outdoors
7 months ago Jubin
Ever wondered what the difference is between the two rugby codes? What began as a purely functional need for a paid league has evolved into two distinct ways of playing rugby. Read on to finally understand which is which and why we even have two codes of rugby.
History of Rugby League and Rugby Union
In the mid-19th century the Rugby Union was formed to standardize the game. The problem was that according to Rugby Union rules, players were not allowed to be paid. This was fine for the upper classes who played for fun, but working class Northerners lost money when they couldn't work. The Northern teams formed a Rugby League and split from the Union. At first the rules were the same apart form the remuneration, but these rules changed over time and the codes became distinct.
Main Differences in Game Play
In Rugby Union 15 players start and up to seven can be substituted. In Rugby League there are 13 active players with up to 10 substitutions. Rugby League is said to be a simpler, less complex game that is easier for spectators to follow. Tackling is a big area of difference: in League players must drop a ball and kick it behind them when successfully tackled, and there is a finite number of tackles; in Rugby Union there is no limit on tackles, and the ball can be picked up by anyone on their feet. In League a try is worth four points, a goal two and a field goal one point. In Union a try is worth five points, a drop goal three and a conversion kick is worth two points. Scrums are more likely to be awarded in Rugby Union but are also more likely to be contested, which is part of what makes the game more complex. If you want to watch the games to see the differences in the players you will need a TV Aerial Installation Cheltenham company to come and install an aerial to be able to get a signal from sites like steveunettaerials.co.uk/services/tv-aerials-repair-and-installation-cheltenham/.
Many of the basic skills are the same for both games, and rugby drill video options, will prove beneficial to players of both codes.
And there you have it. Today there is no need to have the difference in unpaid and paid leagues (all professional players are now paid), and many argue we should just have one code in rugby. But have the rules diverged too far from one another to be merged?
The writer of this article, currently manages his own blog moment for life and spread happiness and is managing to do well by mixing online marketing and traditional marketing practices into one.
Previous What Exactly Is the F1 Paddock Club?
What Exactly Is the F1 Paddock Club?
1 year ago Jubin
Eva Longoria Height, Age, Husband, Net Worth, Other Facts
Natalie Portman Height, Weight, Age, Measurements
Top 4 natural gas detector
The "never say die" of Men's fashions.
The Importance of Getting Online When Setting up a New Business
2 weeks ago Ronney
1 month ago Ronney
1 month ago Jubin
Eva Longoria Height, Age, Husband, Net Worth, Other Facts January 6, 2021
Natalie Portman Height, Weight, Age, Measurements December 25, 2020
Top 4 natural gas detector December 15, 2020
The "never say die" of Men's fashions. December 7, 2020
The Importance of Getting Online When Setting up a New Business December 1, 2020
What to buy the woman who has everything November 12, 2020
Six Types of Domain Name November 12, 2020
3 Diesel © All rights reserved. | Newsphere by AF themes.


text:
Injured Justin Timberlake postpones Oakland concert
Aidin VaziriDecember 4, 2018Updated: December 7, 2018, 10:41 am
Justin Timberlake performs onstage during this year's Super Bowl halftime show. Photo: Christopher Polk
Justin Timberlake announced that he is scrapping the remainder of his 2018 "Man Of The Woods" tour dates due to bruised vocal cords, per doctors orders. That includes his date at Oakland's Oracle Arena, which was scheduled for Wednesday, Dec. 5.
"My vocal cords are healing, but they are not all the way back to normal yet," Timberlake, 37, said in an Instagram post. "So my doctors want me to continue to rest my voice. They have asked me to hold off on singing until next month.
"I'm really sorry," he added. "I want to be back on the stage and I am doing all I can to get there quickly. Thank you for your understanding."
A post shared by Justin Timberlake (@justintimberlake) on Dec 5, 2018 at 7:50pm PST
Live Nation, the promoter of the tour, said that fans are encouraged to hold onto their tickets for the new date in Oakland set for March 15.
The rescheduled dates also make it unlikely that the 10-time Grammy winner will be able to appear as a headliner for the 2019 Coachella Valley Music and Arts Festival, as rumored earlier this year, due to the Goldenvoice promoted festival's radius clause.
Timberlake's tour is in support of his fifth studio album, "Man of the Woods," which he worked on with collaborators including Timbaland, Danja and the Neptunes. The tour came through the SAP Center in San Jose in April.
The New York Times best-selling author of the memoir "Hindsight" also rescheduled shows in Los Angeles; Fresno; Phoenix; Las Vegas; Omaha, Neb.; Kansas City; St. Louis; Indianapolis; Philadelphia; Buffalo, N.Y.; and Uncasville, Conn., because of his ongoing vocal issues.
In October, the former 'N Sync singer scrapped a show at New York's Madison Square Garden, telling his fans via Instagram that his doctors had ordered him to rest: "My vocal cords are severely bruised," he wrote. "I'm gonna make this up to you."
A post shared by Justin Timberlake (@justintimberlake) on Oct 24, 2018 at 1:26pm PDT
At the time, he also postponed planned shows in Buffalo, N.Y., and Tacoma, Wash. The Los Angeles date (Nov. 27) was to be his first back on stage.
This isn't the first time Timberlake has postponed Northern California shows because of vocal issues. In 2007, he rescheduled dates in Sacramento and San Jose following a doctor-mandated vocal rest prescribed after a strenuous MTV VMA performance.
'Crazy Rich Asians' director to make Journey biopic
Queen announces North America 'Rhapsody' tour with Adam Lambert
Childish Gambino reschedules Oakland, San Jose concerts due to injury
Aidin Vaziri
Aidin Vaziri	Aidin Vaziri is The San Francisco Chronicle's pop music critic. Email: avaziri@sfchronicle.com Twitter: @MusicSF
More In Music
Review: Contemporary Players make their own way, with help from John Cage
By Joshua Kosman
Anaïs Mitchell of 'Hadestown' fame loosens reins with Bonny Light Horseman
By Andrew Gilbert
King Princess ready to take her rock 'n' roll realness on tour with Harry Styles
Don't forget Amnesia, longtime San Francisco music venue, set to close
By Ryan Kost
Review: Julia Wolfe's 'Fountain' unleashes a glorious roar in SF Symphony premiere
San Jose's Doobie Brothers finally get into Rock & Roll Hall of Fame
From the East Bay, Charles Amirkhanian gives us a new soundtrack of San Francisco
Pearl Jam announces first Bay Area shows since 2014
Thursday, 8:00PM
The Howard Jones Trio
Palace of Fine Arts Theater
Friday, 8:00PM
Shakey Graves


text:
• Home • About • Training • Treatment • Books • Equipment • Contact
Michael Bono became a licensed electrologist in 1976, and attended the original Wilshire School of Electrology in Los Angeles (Arthur Hinkel). Michael maintains his practice in Santa Barbara, California. Before that, he was a High School history and special education teacher. Michael has a degree in History from UC Santa Barbara and a secondary teaching credential.
Michael has written three important books in the field of electrology. He has been involved with teaching, designing machines and inventing new techniques for the last 30 years. He has taught and conducted seminars in Norway, England, The Netherlands, Germany, Canada, USA, Peru, Japan, Australia and New Zealand. You may contact Michael by phone or email.
mikebono@cox.net


text:
Feb 13 Logos and the Erosion of Fashion
One of the trends in fashion at the moment, brought to us by established fashion houses like Gucci, Balenciaga, and Versace, as well as newcomers like Vetements, is logos: big, obvious, and impossible to ignore. It's always the case that fashion says so much about the time in which we live, but that can be a hard thing to wrap one's head around. Which is why a brilliant op-ed about the logo trend as a reflection of the state of fashion today caught my attention. Here's an excerpt, but I highly recommend reading the entire piece here.
"...How could you justify your hyper-luxury name when consumers crave banal (some might say ugly) clothing? How would you sell a classic cotton hoodie, a Stan Smith look-a-like sneaker or Levi's 501-inspired jeans for over $500 each?
The solution was something that had worked in the past: give the people the boring clothes they want to wear, but emblazoned with brand names and the price tag to match...logomania is now everywhere again, offering simple, generic and easy-to-wear garments that substitute new ideas with a recognized brand's name or symbol."
- Lirouy Choufan in the Business of Fashion
wait, who are you wearing?
The more I thought about this piece and its implications, the stronger I felt that logomania, as the author refers to it, is bad for fashion. Devastating, really. Take Balenciaga, a fashion house founded in the early 20th century by Cristóbal Balenciaga, whose obsession with tailoring, fit, proportion, and cut, made him a master at his craft. Fashion then couldn't exist without attention to those things. Today, it's being defined, at least in some capacity, by a brand name on a cotton t-shirt (although, to be fair, Demna Gvasalia, artistic director of Balenciaga, feels, at least at times, like he's in on the joke, particularly with his own label Vetements).
"Haute couture is like an orchestra, for which only Balenciaga is the conductor. The rest of us are just musicians, following the directions he gives us. "
— Christian Dior
the balenciaga of today
The tricky thing about markets is that there's a push and pull between consumers, who demand things, and producers, who supply them. It's a sort of dance, and it's not always clear who's leading. In our reality, a world of internet, Instagram and instant gratification, maybe the immediate cache of a recognizable logo does for us today what a meticulously-crafted Balenciaga dress did for women 70 years ago. Maybe we're demanding this kind of obviousness from the people who design our clothes. On the other hand, maybe there's so much out there, and fashion moves so quickly, and our attention is so diluted, that brands need to scream to grab our attention. Or perhaps this is yet another case of consumerism co-opting personal style. After all, these brands are businesses, with sales expectations and profit forecasts, and a viral pair of Gucci loafers does a lot for a bottom line.
need it be so?
For AW17, Demna Gvasalia re-created nine couture gowns in honor of the House of Balenciaga's 100th anniversary
I've asked before if a brand name really matters, I've questioned what luxury means in fashion today, and whether consumerism is warping our relationship with fashion. Now, I ask: are we complicit in the shift away from fashion as a craft towards fashion as a commercial entity? Do our desires for the patina of style, for convenience, and immediacy contribute to a system that pressures designers away from the time-honored process of slow creation that stitches in meaning, to the speedy splash of a logo, that spells it out for all to see?
Brands, Logos, Balenciaga, Vetements, Demna Gvasalia, The Role of Fashion in Society, Luxury Lamentations
Facebook0 Pinterest0 0 Likes
At Spring, Considering Fashion and the Self in Bloom
Reflections on the power of fashion to illuminate the journey to self
Summer Style Inspiration: Postcard from Portofino
A statement on summer dress from the Italian Riviera
against skin
Clothes and Prose
If Anthony Bourdain Shined His Light on Fashion
What if, instead of food, fashion was the subject of Anthony Bourdain's humane gaze?
style is...
Style is the answer to everything. A fresh way to approach a dull or dangerous thing. To do a dull thing with style is preferable to doing a dangerous thing without it. To do a dangerous thing with style is what I call art...Style is the difference, a way of doing, a way of being done.
- Charles Bukowski
Feb 15 Vetements Makes a Statement on Fashion's Toll
Feb 9 Slip Into the Warm, Calculated Minimalism of Axel Vervoordt
Mar 6 Gucci, Prada and the Big Fashion Questions Posed in Milan
Apr 4 What Does it Mean if Vetements is Losing Ground?


Convert a MS Word document to pdf using Word OLE automation.
The Word OLE CSharp sample is a simple Windows console application that converts a MS Word document (C:\Test.doc) to PDF using Word OLE automation. This can be a part of a larger application that works seamlessly with the novaPDF SDK development.
///    Summary description for Class1.
///    The main entry point for the application.