/**
* Menu interaction (enter/space/click to continue)
*/
void MenuTalker::logic() {
if (!visible || npc==NULL) return;
tablist.logic();
advanceButton->enabled = false;
closeButton->enabled = false;
// determine active button
if ((unsigned)dialog_node < npc->dialog.size() && !npc->dialog[dialog_node].empty() && event_cursor < npc->dialog[dialog_node].size()-1) {
if (npc->dialog[dialog_node][event_cursor+1].type != "") {
advanceButton->enabled = true;
tablist.remove(closeButton);
tablist.add(advanceButton);
}
else {
closeButton->enabled = true;
tablist.remove(advanceButton);
tablist.add(closeButton);
}
}
else {
closeButton->enabled = true;
tablist.remove(advanceButton);
tablist.add(closeButton);
}
bool more;
if (advanceButton->checkClick() || closeButton->checkClick()) {
// button was clicked
npc->processEvent(dialog_node, event_cursor);
event_cursor++;
more = npc->processDialog(dialog_node, event_cursor);
}
else if (inpt->pressing[ACCEPT] && !inpt->lock[ACCEPT]) {
inpt->lock[ACCEPT] = true;
// pressed next/more
npc->processEvent(dialog_node, event_cursor);
event_cursor++;
more = npc->processDialog(dialog_node, event_cursor);
}
else {
textbox->logic();
return;
}
if (more) {
createBuffer();
}
else {
// show the NPC Action Menu
menu->npc->setNPC(npc);
if (!menu->npc->selection())
menu->npc->visible = true;
else
menu->npc->setNPC(NULL);
// end dialog
setNPC(NULL);
}
}
// convert button to character output
void decodeLetter (char input) {
if (input == '1')
{
display[dLocx++] = '1';
}
else if (input == 'U')
{
screenY--;
}
else if (input == 'D')
{
screenY++;
}
else if (input == 'L')
{
screenX--;
}
else if (input == 'R')
{
screenX++;
}
else if (input == 'T')
{
if(dLocx != 0)
{
dLocx--;
display[dLocx] = '\0';
}
}
else if (input == 'S')
{
// output display buffer to OLED display
int i;
createBuffer();
UARTSend (buffer, dLocx+9);
RIT128x96x4Clear();
RIT128x96x4StringDraw("----------------------", 0, 50, 15);
RIT128x96x4StringDraw(display, 0, 0, 15);
RIT128x96x4StringDraw(display2, 0, 60, 15);
for(i=0; i<dLocx + 1; i++)
display[i]='\0';
dLocx=0;
return;
}
else if(input == 'P')
{
showError(); // Error
}
if (dLocx != 0)
{
if (input == '2')
{
if (flag == 1)
{
if (display[dLocx - 1] == 'A')
display[dLocx - 1] = 'B';
else if (display[dLocx - 1] == 'B')
display[dLocx - 1] = 'C';
else if (display[dLocx - 1] == 'C')
display[dLocx - 1] = '2';
else if (display[dLocx - 1] == '2')
display[dLocx - 1] = 'A';
else
display[dLocx++] = 'A';
}
else
{
display[dLocx++] = 'A';
}
}
else if (input == '3')
{
if (flag == 1)
{
if (display[dLocx - 1] == 'D')
display[dLocx - 1] = 'E';
else if (display[dLocx - 1] == 'E')
display[dLocx - 1] = 'F';
else if (display[dLocx - 1] == 'F')
display[dLocx - 1] = '3';
else if (display[dLocx - 1] == '3')
display[dLocx - 1] = 'D';
else
display[dLocx++] = 'D';
}
else
{
display[dLocx++] = 'D';
}
}
else if (input == '4')
{
if (flag == 1)
{
if (display[dLocx - 1] == 'G')
display[dLocx - 1] = 'H';
else if (display[dLocx - 1] == 'H')
display[dLocx - 1] = 'I';
else if (display[dLocx - 1] == 'I')
display[dLocx - 1] = '4';
else if (display[dLocx - 1] == '4')
display[dLocx - 1] = 'G';
else
display[dLocx++] = 'G';
}
else
{
display[dLocx++] = 'G';
}
}
else if (input == '5')
{
if (flag == 1)
{
if (display[dLocx - 1] == 'J')
display[dLocx - 1] = 'K';
else if (display[dLocx - 1] == 'K')
display[dLocx - 1] = 'L';
else if (display[dLocx - 1] == 'L')
display[dLocx - 1] = '5';
else if (display[dLocx - 1] == '5')
display[dLocx - 1] = 'J';
else
display[dLocx++] = 'J';
}
else
{
display[dLocx++] = 'J';
}
}
else if (input == '6')
{
if (flag == 1)
{
if (display[dLocx - 1] == 'M')
display[dLocx - 1] = 'N';
else if (display[dLocx - 1] == 'N')
display[dLocx - 1] = 'O';
else if (display[dLocx - 1] == 'O')
display[dLocx - 1] = '6';
else if (display[dLocx - 1] == '6')
display[dLocx - 1] = 'M';
else
display[dLocx++] = 'M';
}
else
{
display[dLocx++] = 'M';
}
}
else if (input == '7')
{
if (flag == 1)
{
if (display[dLocx - 1] == 'P')
display[dLocx - 1] = 'Q';
else if (display[dLocx - 1] == 'Q')
display[dLocx - 1] = 'R';
else if (display[dLocx - 1] == 'R')
display[dLocx - 1] = 'S';
else if (display[dLocx - 1] == 'S')
display[dLocx - 1] = '7';
else if (display[dLocx - 1] == '7')
display[dLocx - 1] = 'P';
else
display[dLocx++] = 'P';
}
else
{
display[dLocx++] = 'P';
}
}
else if (input == '8')
{
if (flag == 1)
{
if (display[dLocx - 1] == 'T')
display[dLocx - 1] = 'U';
else if (display[dLocx - 1] == 'U')
display[dLocx - 1] = 'V';
else if (display[dLocx - 1] == 'V')
display[dLocx - 1] = '8';
else if (display[dLocx - 1] == '8')
display[dLocx - 1] = 'T';
else
display[dLocx++] = 'T';
}
else
{
display[dLocx++] = 'T';
}
}
else if (input == '9')
{
if (flag == 1)
{
if (display[dLocx - 1] == 'W')
display[dLocx - 1] = 'X';
else if (display[dLocx - 1] == 'X')
display[dLocx - 1] = 'Y';
else if (display[dLocx - 1] == 'Y')
display[dLocx - 1] = 'Z';
else if (display[dLocx - 1] == 'Z')
display[dLocx - 1] = '9';
else if (display[dLocx - 1] == '9')
display[dLocx - 1] = 'W';
else
display[dLocx++] = 'W';
}
else
{
display[dLocx++] = 'W';
}
}
else if (input == '0')
{
if (flag == 1)
{
if (display[dLocx - 1] == ' ')
display[dLocx - 1] = '0';
else if (display[dLocx - 1] == '0')
display[dLocx - 1] = ' ';
else
display[dLocx++] = ' ';
}
else
{
display[dLocx++] = ' ';
}
}
}
else
{
if (input == '2')
{
display[dLocx++] = 'A';
}
else if (input == '3')
{
display[dLocx++] = 'D';
}
else if (input == '4')
{
display[dLocx++] = 'G';
}
else if (input == '5')
{
display[dLocx++] = 'J';
}
else if (input == '6')
{
display[dLocx++] = 'M';
}
else if (input == '7')
{
display[dLocx++] = 'P';
}
else if (input == '8')
{
display[dLocx++] = 'T';
}
else if (input == '9')
{
display[dLocx++] = 'W';
}
else if (input == '0')
{
display[dLocx++] = ' ';
}
}
display[dLocx] = '\0';
}
void ATetrahedronMesh::create(unsigned np, unsigned nt)
{
createBuffer(np, nt * 4);
setNumPoints(np);
setNumIndices(nt * 4);
}
void GLESHardwareIndexBuffer::notifyOnContextReset()
{
createBuffer();
mShadowUpdated = true;
_updateFromShadow();
}
void SessionPrivate::processLine(const QByteArray& line)
{
Q_Q(Session);
QString process = readString(line);
QString prefix, command;
QStringList params;
// From RFC 1459:
// <message> ::= [':' <prefix> <SPACE> ] <command> <params> <crlf>
// <prefix> ::= <servername> | <nick> [ '!' <user> ] [ '@' <host> ]
// <command> ::= <letter> { <letter> } | <number> <number> <number>
// <SPACE> ::= ' ' { ' ' }
// <params> ::= <SPACE> [ ':' <trailing> | <middle> <params> ]
// <middle> ::= <Any *non-empty* sequence of octets not including SPACE
// or NUL or CR or LF, the first of which may not be ':'>
// <trailing> ::= <Any, possibly *empty*, sequence of octets not including
// NUL or CR or LF>
// parse <prefix>
if (process.startsWith(QLatin1Char(':')))
{
prefix = process.mid(1, process.indexOf(QLatin1Char(' ')) - 1);
process.remove(0, prefix.length() + 2);
if (options & Session::StripNicks)
{
int index = prefix.indexOf(QRegExp(QLatin1String("[@!]")));
if (index != -1)
prefix.truncate(index);
}
}
// parse <command>
command = process.mid(0, process.indexOf(QLatin1Char(' ')));
process.remove(0, command.length() + 1);
bool isNumeric = false;
uint code = command.toInt(&isNumeric);
// parse middle/params
while (!process.isEmpty())
{
if (process.startsWith(QLatin1Char(':')))
{
process.remove(0, 1);
params << process;
process.clear();
}
else
{
QString param = process.mid(0, process.indexOf(QLatin1Char(' ')));
process.remove(0, param.length() + 1);
params << param;
}
}
// handle PING/PONG
if (command == QLatin1String("PING"))
{
QString arg = params.value(0);
q->raw(QString(QLatin1String("PONG %1")).arg(arg));
return;
}
// and dump
if (isNumeric)
{
switch (code)
{
case Irc::Rfc::RPL_WELCOME:
{
Buffer* buffer = createBuffer(host);
buffer->d_func()->setReceiver(prefix);
break;
}
case Irc::Rfc::RPL_TOPIC:
{
QString topic = params.value(1);
QString target = resolveTarget(QString(), topic);
Buffer* buffer = createBuffer(target);
buffer->d_func()->topic = topic;
break;
}
case Irc::Rfc::RPL_NAMREPLY:
{
QStringList list = params;
list.removeAll(QLatin1String("="));
list.removeAll(QLatin1String("@"));
list.removeAll(QLatin1String("*"));
QString target = resolveTarget(QString(), list.value(1));
Buffer* buffer = createBuffer(target);
QStringList names = list.value(2).split(QLatin1String(" "), QString::SkipEmptyParts);
foreach (const QString& name, names)
buffer->d_func()->addName(name);
break;
}
case Irc::Rfc::RPL_MOTDSTART:
motd.clear();
break;
case Irc::Rfc::RPL_MOTD:
motd.append(params.value(1) + QLatin1Char('\n'));
break;
case Irc::Rfc::RPL_ENDOFMOTD:
if (defaultBuffer)
emit defaultBuffer->motdReceived(motd);
motd.clear();
break;
default:
break;
}
if (code == Rfc::RPL_TOPICSET && options & Session::StripNicks)
{
QString user = params.value(2);
int index = user.indexOf(QRegExp(QLatin1String("[@!]")));
if (index != -1)
{
user.truncate(index);
params.replace(2, user);
}
}
if (defaultBuffer)
emit defaultBuffer->numericMessageReceived(prefix, code, params);
// join auto-join channels after MOTD
if (code == Rfc::RPL_ENDOFMOTD || code == Rfc::ERR_NOMOTD)
{
foreach (const QString& channel, channels)
q->join(channel);
}
}
// Main function
// *********************************************************************
int main(int argc, char **argv)
{
// set and log Global and Local work size dimensions
szLocalWorkSize = 16;
szGlobalWorkSize = (iNumElements + szLocalWorkSize - 1) / szLocalWorkSize * szLocalWorkSize; // rounded up to the nearest multiple of the LocalWorkSize
// Allocate and initialize host arrays
std::vector<float> radius;
std::vector<float4> position;
std::vector<float4> emission;
std::vector<float4> color;
std::vector<cl_short> reflType;
std::vector<float4> output;
cl_int numSpheres = parallelize(spheres, radius, position, emission, color, reflType);
output.resize(szGlobalWorkSize);
// Create the OpenCL context on a GPU device
cl_int err = 0;
cxGPUContext = clCreateContextFromType(0, CL_DEVICE_TYPE_GPU, NULL, NULL, &err);
CL_VERIFY(err);
// Get the list of GPU devices associated with context
clGetContextInfo(cxGPUContext, CL_CONTEXT_DEVICES, 0, NULL, &szParmDataBytes);
cdDevices = (cl_device_id*)malloc(szParmDataBytes);
clGetContextInfo(cxGPUContext, CL_CONTEXT_DEVICES, szParmDataBytes, cdDevices, NULL);
cqCommandQue = clCreateCommandQueue(cxGPUContext, cdDevices[0], 0, 0);
// Allocate the OpenCL buffer memory objects for source and result on the device GMEM
cl_mem radiusBuf = createBuffer(cxGPUContext, radius);
cl_mem positionBuf = createBuffer(cxGPUContext, position);
cl_mem emissionBuf = createBuffer(cxGPUContext, emission);
cl_mem colorBuf = createBuffer(cxGPUContext, color);
cl_mem reflTypeBuf = createBuffer(cxGPUContext, reflType);
cl_mem outputBuf = clCreateBuffer(cxGPUContext, CL_MEM_WRITE_ONLY, sizeof(output[0]) * output.size(), NULL, 0);
std::string source = readFile(cSourceFile);
const char *cSource = source.c_str();
// Create the program
cpProgram = clCreateProgramWithSource(cxGPUContext, 1, &cSource, 0, 0);
// Build the program
err = clBuildProgram(cpProgram, 0, NULL, NULL, NULL, NULL);
CL_VERIFY(err);
// Create the kernel
ckKernel = clCreateKernel(cpProgram, "radiance", &err);
CL_VERIFY(err);
// Set the Argument values
CL_VERIFY(clSetKernelArg(ckKernel, 0, sizeof(cl_mem), (void*)&radiusBuf));
CL_VERIFY(clSetKernelArg(ckKernel, 1, sizeof(cl_mem), (void*)&positionBuf));
CL_VERIFY(clSetKernelArg(ckKernel, 2, sizeof(cl_mem), (void*)&emissionBuf));
CL_VERIFY(clSetKernelArg(ckKernel, 3, sizeof(cl_mem), (void*)&colorBuf));
CL_VERIFY(clSetKernelArg(ckKernel, 4, sizeof(cl_mem), (void*)&reflTypeBuf));
CL_VERIFY(clSetKernelArg(ckKernel, 5, sizeof(cl_int), (void*)&numSpheres));
CL_VERIFY(clSetKernelArg(ckKernel, 6, sizeof(cl_mem), (void*)&outputBuf));
CL_VERIFY(clSetKernelArg(ckKernel, 7, sizeof(cl_int), (void*)&width));
CL_VERIFY(clSetKernelArg(ckKernel, 8, sizeof(cl_int), (void*)&height));
// --------------------------------------------------------
// Start Core sequence... copy input data to GPU, compute, copy results back
// Launch kernel
CL_VERIFY(clEnqueueNDRangeKernel(cqCommandQue, ckKernel, 1, NULL, &szGlobalWorkSize, &szLocalWorkSize, 0, NULL, NULL));
// Synchronous/blocking read of results, and check accumulated errors
CL_VERIFY(clEnqueueReadBuffer(cqCommandQue, outputBuf, CL_TRUE, 0, sizeof(output[0]) * output.size(), &output.front(), 0, NULL, NULL));
writePPM(output);
writeRaw(output);
// Cleanup and leave
Cleanup (EXIT_SUCCESS);
}
HRESULT Buffer::initialize(ID3D11Device *p_Device, ID3D11DeviceContext *p_DeviceContext,
Description &p_Description)
{
HRESULT result = S_OK;
D3D11_BUFFER_DESC bufferDescription;
m_Device = p_Device;
m_DeviceContext = p_DeviceContext;
m_Type = p_Description.type;
bufferDescription.StructureByteStride = 0;
bufferDescription.MiscFlags = 0;
switch (m_Type)
{
case Type::VERTEX_BUFFER:
{
bufferDescription.BindFlags = D3D11_BIND_VERTEX_BUFFER;
if (p_Description.usage == Usage::STREAM_OUT_TARGET)
{
bufferDescription.BindFlags |= D3D11_BIND_STREAM_OUTPUT;
}
break;
}
case Type::INDEX_BUFFER:
{
bufferDescription.BindFlags = D3D11_BIND_INDEX_BUFFER;
break;
}
case Type::CONSTANT_BUFFER_VS:
case Type::CONSTANT_BUFFER_GS:
case Type::CONSTANT_BUFFER_PS:
case Type::BUFFER_TYPE_COUNT:
case Type::CONSTANT_BUFFER_ALL:
{
bufferDescription.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
break;
}
case Type::STAGING_BUFFER:
{
bufferDescription.BindFlags = 0;
break;
}
case Type::STRUCTURED_BUFFER:
{
bufferDescription.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
bufferDescription.StructureByteStride = p_Description.sizeOfElement;
bufferDescription.BindFlags = 0;
break;
}
default:
{
return S_FALSE;
break;
}
}
if (p_Description.bindSRV) bufferDescription.BindFlags |= D3D11_BIND_SHADER_RESOURCE;
if (p_Description.bindUAV) bufferDescription.BindFlags |= D3D11_BIND_UNORDERED_ACCESS;
m_Usage = p_Description.usage;
m_SizeOfElement = p_Description.sizeOfElement;
m_NumOfElements = p_Description.numOfElements;
bufferDescription.CPUAccessFlags = 0;
switch (m_Usage)
{
case Usage::DEFAULT:
{
bufferDescription.Usage = D3D11_USAGE_DEFAULT;
break;
}
case Usage::STREAM_OUT_TARGET:
{
bufferDescription.Usage = D3D11_USAGE_DEFAULT;
break;
}
case Usage::CPU_WRITE:
{
bufferDescription.Usage = D3D11_USAGE_DYNAMIC;
bufferDescription.CPUAccessFlags |= D3D11_CPU_ACCESS_WRITE;
break;
}
case Usage::CPU_WRITE_DISCARD:
{
bufferDescription.Usage = D3D11_USAGE_DYNAMIC;
bufferDescription.CPUAccessFlags |= D3D11_CPU_ACCESS_WRITE;
break;
}
case Usage::CPU_READ:
{
if (m_Type != Type::STAGING_BUFFER)
{
throw BufferException("Cannot set CPU read to other than staging buffer", __LINE__, __FILE__);
}
bufferDescription.Usage = D3D11_USAGE_STAGING;
bufferDescription.CPUAccessFlags |= D3D11_CPU_ACCESS_READ;
break;
}
case Usage::USAGE_COUNT:
{
bufferDescription.Usage = D3D11_USAGE_DEFAULT;
break;
}
case Usage::USAGE_IMMUTABLE:
{
bufferDescription.Usage = D3D11_USAGE_IMMUTABLE;
break;
}
default:
{
break;
}
}
bufferDescription.ByteWidth = p_Description.numOfElements * p_Description.sizeOfElement;
bufferDescription.ByteWidth = ((bufferDescription.ByteWidth + 15) / 16) * 16;
if (p_Description.initData)
{
D3D11_SUBRESOURCE_DATA data;
data.pSysMem = p_Description.initData;
data.SysMemPitch = 0;
data.SysMemSlicePitch = 0;
result = createBuffer(&bufferDescription, &data, &m_Buffer);
}
else
{
result = createBuffer(&bufferDescription, nullptr, &m_Buffer);
}
return result;
}
vkts::IImageDataSP Example::gatherImageData() const
{
VkResult result;
auto fence = vkts::fenceCreate(device->getDevice(), 0);
if (!fence.get())
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not create fence.");
return vkts::IImageDataSP();
}
//
auto imageData = vkts::imageDataCreate(VKTS_IMAGE_NAME, VKTS_IMAGE_LENGTH, VKTS_IMAGE_LENGTH, 1, 1.0f, 0.0f, 0.0f, 1.0f, VK_IMAGE_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM);
// Check, if we can use a linear tiled image for staging.
if (physicalDevice->isImageTilingAvailable(VK_IMAGE_TILING_LINEAR, imageData->getFormat(), imageData->getImageType(), 0, imageData->getExtent3D(), imageData->getMipLevels(), 1, VK_SAMPLE_COUNT_1_BIT, imageData->getSize()))
{
vkts::IImageSP stageImage;
vkts::IDeviceMemorySP stageDeviceMemory;
if (!createTexture(stageImage, stageDeviceMemory, VK_IMAGE_TILING_LINEAR, VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, 0))
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not create stage image and device memory.");
return vkts::IImageDataSP();
}
//
cmdBuffer->reset();
result = cmdBuffer->beginCommandBuffer(0, VK_NULL_HANDLE, 0, VK_NULL_HANDLE, VK_FALSE, 0, 0);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not begin command buffer.");
return vkts::IImageDataSP();
}
VkImageSubresourceRange imageSubresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
// Prepare stage image for final layout etc.
stageImage->cmdPipelineBarrier(cmdBuffer->getCommandBuffer(), VK_ACCESS_TRANSFER_WRITE_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, imageSubresourceRange);
VkImageCopy imageCopy;
imageCopy.srcSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1};
imageCopy.srcOffset = {0, 0, 0};
imageCopy.dstSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1};
imageCopy.dstOffset = {0, 0, 0};
imageCopy.extent = { VKTS_IMAGE_LENGTH, VKTS_IMAGE_LENGTH, 1u };
// Copy form device to host visible image / memory. This command also sets the needed barriers.
image->copyImage(cmdBuffer->getCommandBuffer(), stageImage, imageCopy);
stageImage->cmdPipelineBarrier(cmdBuffer->getCommandBuffer(), VK_ACCESS_HOST_READ_BIT, VK_IMAGE_LAYOUT_GENERAL, imageSubresourceRange);
result = cmdBuffer->endCommandBuffer();
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not end command buffer.");
return VK_FALSE;
}
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.waitSemaphoreCount = 0;
submitInfo.pWaitSemaphores = nullptr;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = cmdBuffer->getCommandBuffers();
submitInfo.signalSemaphoreCount = 0;
submitInfo.pSignalSemaphores = nullptr;
result = queue->submit(1, &submitInfo, fence->getFence());
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not submit queue.");
return vkts::IImageDataSP();
}
//
result = fence->waitForFence(UINT64_MAX);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not wait for fence.");
return vkts::IImageDataSP();
}
//
// Copy pixel data from device memory into image data memory.
//
VkImageSubresource imageSubresource;
imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageSubresource.mipLevel = 0;
imageSubresource.arrayLayer = 0;
VkSubresourceLayout subresourceLayout;
stageImage->getImageSubresourceLayout(subresourceLayout, imageSubresource);
//
result = stageDeviceMemory->mapMemory(0, VK_WHOLE_SIZE, 0);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not map memory.");
return vkts::IImageDataSP();
}
imageData->upload(stageDeviceMemory->getMemory(), 0, 0, subresourceLayout);
if (!(stageDeviceMemory->getMemoryPropertyFlags() & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
{
result = stageDeviceMemory->invalidateMappedMemoryRanges(0, VK_WHOLE_SIZE);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not invalidate memory.");
return VK_FALSE;
}
}
stageDeviceMemory->unmapMemory();
// Stage image and device memory are automatically destroyed.
}
else
{
// As an alternative, use the buffer.
vkts::IBufferSP stageBuffer;
vkts::IDeviceMemorySP stageDeviceMemory;
VkBufferCreateInfo bufferCreateInfo{};
bufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bufferCreateInfo.size = imageData->getSize();
bufferCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
bufferCreateInfo.flags = 0;
bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
bufferCreateInfo.queueFamilyIndexCount = 0;
bufferCreateInfo.pQueueFamilyIndices = nullptr;
if (!createBuffer(stageBuffer, stageDeviceMemory, bufferCreateInfo, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not create buffer.");
return vkts::IImageDataSP();
}
//
cmdBuffer->reset();
result = cmdBuffer->beginCommandBuffer(0, VK_NULL_HANDLE, 0, VK_NULL_HANDLE, VK_FALSE, 0, 0);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not begin command buffer.");
return vkts::IImageDataSP();
}
VkBufferImageCopy bufferImageCopy;
bufferImageCopy.bufferOffset = 0;
bufferImageCopy.bufferRowLength = VKTS_IMAGE_LENGTH;
bufferImageCopy.bufferImageHeight = VKTS_IMAGE_LENGTH;
bufferImageCopy.imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1};
bufferImageCopy.imageOffset = {0, 0, 0};
bufferImageCopy.imageExtent = {VKTS_IMAGE_LENGTH, VKTS_IMAGE_LENGTH, 1};
image->copyImageToBuffer(cmdBuffer->getCommandBuffer(), stageBuffer, bufferImageCopy);
result = cmdBuffer->endCommandBuffer();
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not end command buffer.");
return VK_FALSE;
}
VkSubmitInfo submitInfo{};
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.waitSemaphoreCount = 0;
submitInfo.pWaitSemaphores = nullptr;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = cmdBuffer->getCommandBuffers();
submitInfo.signalSemaphoreCount = 0;
submitInfo.pSignalSemaphores = nullptr;
result = queue->submit(1, &submitInfo, fence->getFence());
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not submit queue.");
return vkts::IImageDataSP();
}
//
result = fence->waitForFence(UINT64_MAX);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not wait for fence.");
return vkts::IImageDataSP();
}
//
// Copy pixel data from device memory into image data memory.
//
VkSubresourceLayout subresourceLayout;
subresourceLayout.offset = 0;
subresourceLayout.size = stageBuffer->getSize();
subresourceLayout.rowPitch = VKTS_IMAGE_LENGTH * 4 * sizeof(uint8_t);
subresourceLayout.arrayPitch = VKTS_IMAGE_LENGTH * VKTS_IMAGE_LENGTH * 4 * sizeof(uint8_t);
subresourceLayout.depthPitch = VKTS_IMAGE_LENGTH * VKTS_IMAGE_LENGTH * 4 * sizeof(uint8_t);
result = stageDeviceMemory->mapMemory(0, VK_WHOLE_SIZE, 0);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not map memory.");
return vkts::IImageDataSP();
}
imageData->upload(stageDeviceMemory->getMemory(), 0, 0, subresourceLayout);
if (!(stageDeviceMemory->getMemoryPropertyFlags() & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT))
{
result = stageDeviceMemory->invalidateMappedMemoryRanges(0, VK_WHOLE_SIZE);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, __FILE__, __LINE__, "Could not invalidate memory.");
return VK_FALSE;
}
}
stageDeviceMemory->unmapMemory();
// Stage image and device memory are automatically destroyed.
}
// Fence is automatically destroyed.
return imageData;
}
return Lav_ERROR_NONE;
}
LavError createBuffer(LavHandle sim, LavHandle& h) {
ERRCHECK(Lav_createBufferNode(sim, &h));
LavHandle b;
ERRCHECK(Lav_createBuffer(sim, &b));
ERRCHECK(Lav_bufferLoadFromArray(b, 44100, 4, BUFFER_SIZE/4, buffer));
ERRCHECK(Lav_nodeSetBufferProperty(h, Lav_BUFFER_BUFFER, b));
return Lav_ERROR_NONE;
}
std::tuple<std::string, int, std::function<std::vector<LavHandle>(LavHandle, int)>> to_profile[] = {
ENTRY("sine", 1000, Lav_createSineNode(sim, &h)),
ENTRY("Blit", 1000, Lav_createBlitNode(sim, &h)),
ENTRY("4-channel buffer", 100, createBuffer(sim, h)),
ENTRY("crossfading delay line", 1000, Lav_createCrossfadingDelayNode(sim, 0.1, 1, &h)),
ENTRY("biquad", 1000, Lav_createBiquadNode(sim, 1, &h)),
ENTRY("One-pole filter", 1000, Lav_createOnePoleFilterNode(sim, 1, &h)),
ENTRY("2-channel 2-input crossfader", 500, createCrossfader(sim, h)),
ENTRY("amplitude panner", 1000, Lav_createAmplitudePannerNode(sim, &h)),
ENTRY("HRTF panner", 30, Lav_createHrtfNode(sim, "default", &h)),
ENTRY("hard limiter", 1000, Lav_createHardLimiterNode(sim, 2, &h)),
ENTRY("channel splitter", 1000, Lav_createChannelSplitterNode(sim, 10, &h)),
ENTRY("channel merger", 1000, Lav_createChannelMergerNode(sim, 10, &h)),
ENTRY("noise", 100, Lav_createNoiseNode(sim, &h)),
ENTRY("ringmod", 1000, Lav_createRingmodNode(sim, &h)),
ENTRY("16x16 FDN", 1, Lav_createFeedbackDelayNetworkNode(sim, 1.0f, 16, &h)),
ENTRY("32x32 FDN", 1, Lav_createFeedbackDelayNetworkNode(sim, 1.0f, 32, &h)),
};
int to_profile_size=sizeof(to_profile)/sizeof(to_profile[0]);
Buffer& DataSource::getBuffer()
{
if( ! mBuffer )
createBuffer();
return mBuffer;
}
bool AudioBufferManager::init_process_mode(AudioBufferParam_t& aParam)
{
mLenOfSample = aParam.mLenOfSample;
mInChannelNum = aParam.mInChannelNum;
mOutChannelNum = aParam.mOutChannelNum;
mProcessBufferNum = mInChannelNum > mOutChannelNum ? mInChannelNum : mOutChannelNum;
mInDefBufferSize = aParam.mFrameShiftSize;
mFrameShiftSize = aParam.mFrameShiftSize;
mInitDelay = aParam.mInitDelaySize;
mInDefBufferLen = mLenOfSample * mInDefBufferSize;
mProcessBufferLen = mLenOfSample * mFrameShiftSize;
mFrameShiftLen = mLenOfSample * mFrameShiftSize;
if (0 == mLenOfSample || 0 == mFrameShiftSize)
{
AUDIO_PROCESSING_PRINTF("init param is invalid!");
return false;
}
if(NULL != mpBufferCondition)
{
for (CAUDIO_U8_t channelIndex = 0; channelIndex < mInChannelNum; channelIndex++)
{
deleteBuffer(mpBufferCondition[channelIndex].mpInDeficiencyBuffer);
}
for (CAUDIO_U8_t channelIndex = 0; channelIndex < mOutChannelNum; channelIndex++)
{
deleteBuffer(mpBufferCondition[channelIndex].mpPostProcessBuffer);
}
for (CAUDIO_U8_t channelIndex = 0; channelIndex < mProcessBufferNum; channelIndex++)
{
deleteBuffer(mpBufferCondition[channelIndex].mpProcessBuffer);
}
delete[] mpBufferCondition;
mpBufferCondition = NULL;
}
mpBufferCondition = new BufferCondition_t[mProcessBufferNum];
memset(mpBufferCondition, 0, mProcessBufferNum*sizeof(BufferCondition_t));
if (NULL == mpBufferCondition)
{
AUDIO_PROCESSING_PRINTF("alloc mpBufferCondition failed!");
return false;
}
for (CAUDIO_U8_t channelIndex = 0; channelIndex < mInChannelNum; channelIndex++)
{
if (!createBuffer(mpBufferCondition[channelIndex].mpInDeficiencyBuffer, mInDefBufferLen))
{
AUDIO_PROCESSING_PRINTF("create in deficiency buffer failed!");
return false;
}
mpBufferCondition[channelIndex].mInDefBufferWritePtr = 0;
//mpBufferCondition[channelIndex].mInDefBufferWritePtr = mLenOfSample*mFrameShiftSize / 2;
}
for (CAUDIO_U8_t channelIndex = 0; channelIndex < mProcessBufferNum; channelIndex++)
{
if (!createBuffer(mpBufferCondition[channelIndex].mpProcessBuffer, mProcessBufferLen))
{
AUDIO_PROCESSING_PRINTF("create out deficiency buffer failed!");
return false;
}
}
for (CAUDIO_U8_t channelIndex = 0; channelIndex < mOutChannelNum; channelIndex++)
{
// introduce mInitDelay at the beginning of output
mpBufferCondition[channelIndex].mPostProBufWrtPtr = mInitDelay * mLenOfSample;
mPostProcessBufferLen = aParam.mPostProcessBufferLen;
if (!createBuffer(mpBufferCondition[channelIndex].mpPostProcessBuffer, mPostProcessBufferLen))
{
AUDIO_PROCESSING_PRINTF("create out post process buffer failed!");
return false;
}
}
if(NULL != mppProcessBufferPtrs)
{
delete[] mppProcessBufferPtrs;
mppProcessBufferPtrs = NULL;
}
mppProcessBufferPtrs = (void**) new CAUDIO_U8_t[mProcessBufferNum * sizeof(void*)];
if (NULL == mppProcessBufferPtrs)
{
AUDIO_PROCESSING_PRINTF("mppProcessBufferPtrs alloc failed!");
return false;
}
for (CAUDIO_U8_t channelIndex = 0; channelIndex < mProcessBufferNum; channelIndex++)
{
mppProcessBufferPtrs[channelIndex] = mpBufferCondition[channelIndex].mpProcessBuffer;
}
return true;
}
bool AudioBufferManager::init_buffer_mode(AudioBufferParam_t& aParam)
{
mLenOfSample = aParam.mLenOfSample;
mInChannelNum = aParam.mInChannelNum;
mOutChannelNum = aParam.mOutChannelNum;
if(mInChannelNum != mOutChannelNum)
{
AUDIO_PROCESSING_PRINTF("in channel num and out channel num should be the same in buffer mode");
return false;
}
mProcessBufferNum = mInChannelNum;
mInDefBufferSize = aParam.mFrameShiftSize;
mFrameShiftSize = aParam.mFrameShiftSize;
mInitDelay = aParam.mInitDelaySize;
mInDefBufferLen = mLenOfSample * mInDefBufferSize;
//mProcessBufferLen = mLenOfSample * mFrameShiftSize;
mFrameShiftLen = mLenOfSample * mFrameShiftSize;
if (0 == mLenOfSample || 0 == mFrameShiftSize)
{
AUDIO_PROCESSING_PRINTF("init param is invalid!");
return false;
}
if(NULL != mpBufferCondition)
{
for (CAUDIO_U8_t channelIndex = 0; channelIndex < mInChannelNum; channelIndex++)
{
deleteBuffer(mpBufferCondition[channelIndex].mpInDeficiencyBuffer);
}
for (CAUDIO_U8_t channelIndex = 0; channelIndex < mOutChannelNum; channelIndex++)
{
deleteBuffer(mpBufferCondition[channelIndex].mpPostProcessBuffer);
}
delete[] mpBufferCondition;
mpBufferCondition = NULL;
}
mpBufferCondition = new BufferCondition_t[mProcessBufferNum];
memset(mpBufferCondition, 0, mProcessBufferNum*sizeof(BufferCondition_t));
if (NULL == mpBufferCondition)
{
AUDIO_PROCESSING_PRINTF("alloc mpBufferCondition failed!");
return false;
}
for (CAUDIO_U8_t channelIndex = 0; channelIndex < mInChannelNum; channelIndex++)
{
if (!createBuffer(mpBufferCondition[channelIndex].mpInDeficiencyBuffer, mInDefBufferLen))
{
AUDIO_PROCESSING_PRINTF("create in deficiency buffer failed!");
return false;
}
mpBufferCondition[channelIndex].mInDefBufferWritePtr = mInitDelay * mLenOfSample;
//mpBufferCondition[channelIndex].mInDefBufferWritePtr = mLenOfSample*mFrameShiftSize / 2;
}
for (CAUDIO_U8_t channelIndex = 0; channelIndex < mOutChannelNum; channelIndex++)
{
// introduce mInitDelay at the beginning of output
mpBufferCondition[channelIndex].mPostProBufWrtPtr = mInitDelay * mLenOfSample;
//mPostProcessBufferLen = aParam.mPostProcessBufferLen;
mPostProcessBufferLen = mFrameShiftLen; // this len is different from process mode
if (!createBuffer(mpBufferCondition[channelIndex].mpPostProcessBuffer, mPostProcessBufferLen))
{
AUDIO_PROCESSING_PRINTF("create out post process buffer failed!");
return false;
}
}
return true;
}
int main(void) {
VkInstance instance;
{
const char debug_ext[] = "VK_EXT_debug_report";
const char* extensions[] = {debug_ext,};
const char validation_layer[] = "VK_LAYER_LUNARG_standard_validation";
const char* layers[] = {validation_layer,};
VkInstanceCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.pApplicationInfo = NULL,
.enabledLayerCount = NELEMS(layers),
.ppEnabledLayerNames = layers,
.enabledExtensionCount = NELEMS(extensions),
.ppEnabledExtensionNames = extensions,
};
assert(vkCreateInstance(&create_info, NULL, &instance) == VK_SUCCESS);
}
VkDebugReportCallbackEXT debug_callback;
{
VkDebugReportCallbackCreateInfoEXT create_info = {
.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT,
.pNext = NULL,
.flags = (VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT |
VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT),
.pfnCallback = &debugReportCallback,
.pUserData = NULL,
};
PFN_vkCreateDebugReportCallbackEXT createDebugReportCallback =
(PFN_vkCreateDebugReportCallbackEXT) vkGetInstanceProcAddr(instance, "vkCreateDebugReportCallbackEXT");
assert(createDebugReportCallback);
assert(createDebugReportCallback(instance, &create_info, NULL, &debug_callback) == VK_SUCCESS);
}
VkPhysicalDevice phy_device;
{
uint32_t num_devices;
assert(vkEnumeratePhysicalDevices(instance, &num_devices, NULL) == VK_SUCCESS);
assert(num_devices >= 1);
VkPhysicalDevice * phy_devices = malloc(sizeof(*phy_devices) * num_devices);
assert(vkEnumeratePhysicalDevices(instance, &num_devices, phy_devices) == VK_SUCCESS);
phy_device = phy_devices[0];
free(phy_devices);
}
VkPhysicalDeviceMemoryProperties memory_properties;
vkGetPhysicalDeviceMemoryProperties(phy_device, &memory_properties);
VkDevice device;
{
float queue_priorities[] = {1.0};
const char validation_layer[] = "VK_LAYER_LUNARG_standard_validation";
const char* layers[] = {validation_layer,};
uint32_t nqueues;
matchingQueues(phy_device, VK_QUEUE_GRAPHICS_BIT, &nqueues, NULL);
assert(nqueues > 0);
uint32_t * queue_family_idxs = malloc(sizeof(*queue_family_idxs) * nqueues);
matchingQueues(phy_device, VK_QUEUE_GRAPHICS_BIT, &nqueues, queue_family_idxs);
VkDeviceQueueCreateInfo queue_info = {
.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.queueFamilyIndex = queue_family_idxs[0],
.queueCount = 1,
.pQueuePriorities = queue_priorities,
};
free(queue_family_idxs);
VkPhysicalDeviceFeatures features = {
.geometryShader = VK_TRUE,
.fillModeNonSolid = VK_TRUE,
};
VkDeviceCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.queueCreateInfoCount = 1,
.pQueueCreateInfos = &queue_info,
.enabledLayerCount = NELEMS(layers),
.ppEnabledLayerNames = layers,
.enabledExtensionCount = 0,
.ppEnabledExtensionNames = NULL,
.pEnabledFeatures = &features,
};
assert(vkCreateDevice(phy_device, &create_info, NULL, &device) == VK_SUCCESS);
}
VkQueue queue;
vkGetDeviceQueue(device, 0, 0, &queue);
VkCommandPool cmd_pool;
{
VkCommandPoolCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.pNext = NULL,
.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
.queueFamilyIndex = 0,
};
assert(vkCreateCommandPool(device, &create_info, NULL, &cmd_pool) == VK_SUCCESS);
}
VkRenderPass render_pass;
{
VkAttachmentDescription attachments[] = {{
.flags = 0,
.format = VK_FORMAT_R8G8B8A8_UNORM,
.samples = VK_SAMPLE_COUNT_8_BIT,
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
}, {
.flags = 0,
.format = VK_FORMAT_D16_UNORM,
.samples = VK_SAMPLE_COUNT_8_BIT,
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
}, {
.flags = 0,
.format = VK_FORMAT_R8G8B8A8_UNORM,
.samples = VK_SAMPLE_COUNT_1_BIT,
.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.finalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
}};
VkAttachmentReference attachment_refs[NELEMS(attachments)] = {{
.attachment = 0,
.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
}, {
.attachment = 1,
.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
}, {
.attachment = 2,
.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
}};
VkSubpassDescription subpasses[1] = {{
.flags = 0,
.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
.inputAttachmentCount = 0,
.pInputAttachments = NULL,
.colorAttachmentCount = 1,
.pColorAttachments = &attachment_refs[0],
.pResolveAttachments = &attachment_refs[2],
.pDepthStencilAttachment = &attachment_refs[1],
.preserveAttachmentCount = 0,
.pPreserveAttachments = NULL,
}};
VkSubpassDependency dependencies[] = {{
.srcSubpass = 0,
.dstSubpass = VK_SUBPASS_EXTERNAL,
.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
.dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT,
.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
.dependencyFlags = 0,
}};
VkRenderPassCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.attachmentCount = NELEMS(attachments),
.pAttachments = attachments,
.subpassCount = NELEMS(subpasses),
.pSubpasses = subpasses,
.dependencyCount = NELEMS(dependencies),
.pDependencies = dependencies,
};
assert(vkCreateRenderPass(device, &create_info, NULL, &render_pass) == VK_SUCCESS);
}
VkImage images[3];
VkDeviceMemory image_memories[NELEMS(images)];
VkImageView views[NELEMS(images)];
createFrameImage(memory_properties, device, render_size,
VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_8_BIT,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_ASPECT_COLOR_BIT,
&images[0], &image_memories[0], &views[0]);
createFrameImage(memory_properties, device, render_size,
VK_FORMAT_D16_UNORM, VK_SAMPLE_COUNT_8_BIT,
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_ASPECT_DEPTH_BIT,
&images[1], &image_memories[1], &views[1]);
createFrameImage(memory_properties, device, render_size,
VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
VK_IMAGE_ASPECT_COLOR_BIT,
&images[2], &image_memories[2], &views[2]);
VkBuffer verts_buffer;
VkDeviceMemory verts_memory;
createBuffer(memory_properties, device, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, sizeof(verts), verts, &verts_buffer, &verts_memory);
VkBuffer index_buffer;
VkDeviceMemory index_memory;
createBuffer(memory_properties, device, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, sizeof(indices), indices, &index_buffer, &index_memory);
VkBuffer image_buffer;
VkDeviceMemory image_buffer_memory;
createBuffer(memory_properties, device, VK_BUFFER_USAGE_TRANSFER_DST_BIT, render_size.height * render_size.width * 4, NULL, &image_buffer, &image_buffer_memory);
VkFramebuffer framebuffer;
createFramebuffer(device, render_size, 3, views, render_pass, &framebuffer);
VkShaderModule shaders[5];
{
char* filenames[NELEMS(shaders)] = {"cube.vert.spv", "cube.geom.spv", "cube.frag.spv", "wireframe.geom.spv", "color.frag.spv"};
for (size_t i = 0; i < NELEMS(shaders); i++){
size_t code_size;
uint32_t * code;
assert((code_size = loadModule(filenames[i], &code)) != 0);
VkShaderModuleCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.codeSize = code_size,
.pCode = code,
};
assert(vkCreateShaderModule(device, &create_info, NULL, &shaders[i]) == VK_SUCCESS);
free(code);
}
}
VkPipelineLayout pipeline_layout;
{
VkPushConstantRange push_range = {
.stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
.offset = 0,
.size = 4,
};
VkPipelineLayoutCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.setLayoutCount = 0,
.pSetLayouts = NULL,
.pushConstantRangeCount = 1,
.pPushConstantRanges = &push_range,
};
assert(vkCreatePipelineLayout(device, &create_info, NULL, &pipeline_layout) == VK_SUCCESS);
}
VkPipeline pipelines[2];
{
VkPipelineShaderStageCreateInfo stages[3] = {{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.stage = VK_SHADER_STAGE_VERTEX_BIT,
.module = shaders[0],
.pName = "main",
.pSpecializationInfo = NULL,
},{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.stage = VK_SHADER_STAGE_GEOMETRY_BIT,
.module = shaders[1],
.pName = "main",
.pSpecializationInfo = NULL,
},{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.stage = VK_SHADER_STAGE_FRAGMENT_BIT,
.module = shaders[2],
.pName = "main",
.pSpecializationInfo = NULL,
}};
VkVertexInputBindingDescription vtx_binding = {
.binding = 0,
.stride = sizeof(struct Vertex),
.inputRate = VK_VERTEX_INPUT_RATE_VERTEX,
};
VkVertexInputAttributeDescription vtx_attr = {
.location = 0,
.binding = 0,
.format = VK_FORMAT_R32G32B32_SFLOAT,
.offset = offsetof(struct Vertex, pos),
};
VkPipelineVertexInputStateCreateInfo vtx_state = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.vertexBindingDescriptionCount = 1,
.pVertexBindingDescriptions = &vtx_binding,
.vertexAttributeDescriptionCount = 1,
.pVertexAttributeDescriptions = &vtx_attr,
};
VkPipelineInputAssemblyStateCreateInfo ia_state = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
.primitiveRestartEnable = VK_TRUE,
};
VkViewport viewport = {
.x = 0,
.y = 0,
.width = render_size.width,
.height = render_size.height,
.minDepth = 0.0,
.maxDepth = 1.0,
};
VkRect2D scissor= {
.offset = {.x = 0, .y = 0,},
.extent = render_size,
};
VkPipelineViewportStateCreateInfo viewport_state = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.viewportCount = 1,
.pViewports = &viewport,
.scissorCount = 1,
.pScissors = &scissor,
};
VkPipelineRasterizationStateCreateInfo rasterization_state = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.depthClampEnable = VK_FALSE,
.rasterizerDiscardEnable = VK_FALSE,
.polygonMode = VK_POLYGON_MODE_FILL,
.cullMode = VK_CULL_MODE_NONE,
.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE,
.depthBiasEnable = VK_FALSE,
.lineWidth = 1.0,
};
VkPipelineMultisampleStateCreateInfo multisample_state = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.rasterizationSamples = VK_SAMPLE_COUNT_8_BIT,
.sampleShadingEnable = VK_FALSE,
.minSampleShading = 0.0,
.pSampleMask = NULL,
.alphaToCoverageEnable = VK_FALSE,
.alphaToOneEnable = VK_FALSE,
};
VkPipelineDepthStencilStateCreateInfo depth_stencil_state = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.depthTestEnable = VK_TRUE,
.depthWriteEnable = VK_TRUE,
.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL,
.depthBoundsTestEnable = VK_FALSE,
.stencilTestEnable = VK_FALSE,
.front = {},
.back = {},
.minDepthBounds = 0.0,
.maxDepthBounds = 1.0,
};
VkPipelineColorBlendAttachmentState color_blend_attachment = {
.blendEnable = VK_FALSE,
.colorWriteMask = ( VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT
| VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT),
};
VkPipelineColorBlendStateCreateInfo color_blend_state = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.logicOpEnable = VK_FALSE, //.logicOp = 0,
.attachmentCount = 1,
.pAttachments = &color_blend_attachment,
.blendConstants = {},
};
VkGraphicsPipelineCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.stageCount = NELEMS(stages),
.pStages = stages,
.pVertexInputState = &vtx_state,
.pInputAssemblyState = &ia_state,
.pTessellationState = NULL,
.pViewportState = &viewport_state,
.pRasterizationState = &rasterization_state,
.pMultisampleState = &multisample_state,
.pDepthStencilState = &depth_stencil_state,
.pColorBlendState = &color_blend_state,
.pDynamicState = NULL,
.layout = pipeline_layout,
.renderPass = render_pass,
.subpass = 0,
.basePipelineHandle = VK_NULL_HANDLE,
.basePipelineIndex = 0,
};
assert(vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &create_info, NULL, &pipelines[0]) == VK_SUCCESS);
stages[1].module = shaders[3];
stages[2].module = shaders[4];
rasterization_state.polygonMode = VK_POLYGON_MODE_LINE;
assert(vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &create_info, NULL, &pipelines[1]) == VK_SUCCESS);
}
VkCommandBuffer draw_buffers[2];
{
VkCommandBufferAllocateInfo allocate_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
.pNext = NULL,
.commandPool = cmd_pool,
.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
.commandBufferCount = NELEMS(draw_buffers),
};
assert(vkAllocateCommandBuffers(device, &allocate_info, draw_buffers) == VK_SUCCESS);
}
{
VkCommandBufferBeginInfo begin_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.pNext = NULL,
.flags = 0,
.pInheritanceInfo = NULL,
};
VkClearValue clear_values[] = {{
.color.float32 = {0.0, 0.0, 0.0, 1.0},
}, {
.depthStencil = {.depth = 1.0},
}};
VkRenderPassBeginInfo renderpass_begin_info = {
.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
.pNext = NULL,
.renderPass = render_pass,
.framebuffer = framebuffer,
.renderArea = {
.offset = {.x = 0, .y = 0},
.extent = render_size,
},
.clearValueCount = NELEMS(clear_values),
.pClearValues = clear_values,
};
for (size_t i = 0; i < NELEMS(draw_buffers); i++){
assert(vkBeginCommandBuffer(draw_buffers[i], &begin_info) == VK_SUCCESS);
uint32_t persp = i == 0;
vkCmdPushConstants(draw_buffers[i], pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(persp), &persp);
vkCmdBeginRenderPass(draw_buffers[i], &renderpass_begin_info, VK_SUBPASS_CONTENTS_INLINE);
VkDeviceSize offset = 0;
vkCmdBindVertexBuffers(draw_buffers[i], 0, 1, &verts_buffer, &offset);
vkCmdBindIndexBuffer(draw_buffers[i], index_buffer, 0, VK_INDEX_TYPE_UINT32);
for (size_t j = 0; j < NELEMS(pipelines); j++) {
vkCmdBindPipeline(draw_buffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines[j]);
vkCmdDrawIndexed(draw_buffers[i], 20, 27, 0, 0, 0);
}
vkCmdEndRenderPass(draw_buffers[i]);
}
VkBufferImageCopy copy = {
.bufferOffset = 0,
.bufferRowLength = 0, // Tightly packed
.bufferImageHeight = 0, // Tightly packed
.imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
.imageOffset = {0, 0, 0},
.imageExtent = {.width = render_size.width,
.height = render_size.height,
.depth = 1},
};
VkBufferMemoryBarrier transfer_barrier = {
.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
.pNext = 0,
.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
.dstAccessMask = VK_ACCESS_HOST_READ_BIT,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.buffer = image_buffer,
.offset = 0,
.size = VK_WHOLE_SIZE,
};
for (size_t i = 0; i < NELEMS(draw_buffers); i++){
vkCmdCopyImageToBuffer(draw_buffers[i], images[2], VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, image_buffer, 1, ©);
vkCmdPipelineBarrier(draw_buffers[i], VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0, 0, NULL, 1, &transfer_barrier, 0, NULL);
assert(vkEndCommandBuffer(draw_buffers[i]) == VK_SUCCESS);
}
}
VkFence fence;
{
VkFenceCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
.pNext = 0,
.flags = 0,
};
assert(vkCreateFence(device, &create_info, NULL, &fence) == VK_SUCCESS);
}
{
char * filenames[] = {"cube_persp.tif", "cube_ortho.tif"};
char * image_data;
assert(vkMapMemory(device, image_buffer_memory, 0, VK_WHOLE_SIZE, 0, (void **) &image_data) == VK_SUCCESS);
VkMappedMemoryRange image_flush = {
.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, .pNext = NULL,
.memory = image_buffer_memory,
.offset = 0,
.size = VK_WHOLE_SIZE,
};
VkSubmitInfo submit_info = {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.pNext = NULL,
.waitSemaphoreCount = 0,
.pWaitSemaphores = NULL,
.pWaitDstStageMask = NULL,
.commandBufferCount = 1,
.pCommandBuffers = NULL,
.signalSemaphoreCount = 0,
.pSignalSemaphores = NULL,
};
for (size_t i = 0; i < NELEMS(filenames); i++){
submit_info.pCommandBuffers = &draw_buffers[i];
assert(vkResetFences(device, 1, &fence) == VK_SUCCESS);
assert(vkQueueSubmit(queue, 1, &submit_info, fence) == VK_SUCCESS);
assert(vkWaitForFences(device, 1, &fence, VK_TRUE, UINT64_MAX) == VK_SUCCESS);
assert(vkInvalidateMappedMemoryRanges(device, 1, &image_flush) == VK_SUCCESS);
assert(writeTiff(filenames[i], image_data, render_size, nchannels) == 0);
}
vkUnmapMemory(device, image_buffer_memory);
}
assert(vkQueueWaitIdle(queue) == VK_SUCCESS);
vkDestroyFence(device, fence, NULL);
vkDestroyFramebuffer(device, framebuffer, NULL);
for (size_t i = 0; i < NELEMS(images); i++){
vkDestroyImage(device, images[i], NULL);
vkDestroyImageView(device, views[i], NULL);
vkFreeMemory(device, image_memories[i], NULL);
}
vkDestroyBuffer(device, image_buffer, NULL);
vkFreeMemory(device, image_buffer_memory, NULL);
vkDestroyBuffer(device, verts_buffer, NULL);
vkFreeMemory(device, verts_memory, NULL);
vkDestroyBuffer(device, index_buffer, NULL);
vkFreeMemory(device, index_memory, NULL);
for (size_t i = 0; i < NELEMS(pipelines); i++){
vkDestroyPipeline(device, pipelines[i], NULL);
}
vkDestroyPipelineLayout(device, pipeline_layout, NULL);
for(size_t i = 0; i < NELEMS(shaders); i++)
vkDestroyShaderModule(device, shaders[i], NULL);
vkDestroyRenderPass(device, render_pass, NULL);
vkFreeCommandBuffers(device, cmd_pool, NELEMS(draw_buffers), draw_buffers);
vkDestroyCommandPool(device, cmd_pool, NULL);
vkDestroyDevice(device, NULL);
{
PFN_vkDestroyDebugReportCallbackEXT destroyDebugReportCallback =
(PFN_vkDestroyDebugReportCallbackEXT) vkGetInstanceProcAddr(instance, "vkDestroyDebugReportCallbackEXT");
assert(destroyDebugReportCallback);
destroyDebugReportCallback(instance, debug_callback, NULL);
}
vkDestroyInstance(instance, NULL);
return 0;
}
void SparseShaderIntrinsicsInstanceSampledBase::recordCommands (const VkCommandBuffer commandBuffer,
const VkImageCreateInfo& imageSparseInfo,
const VkImage imageSparse,
const VkImage imageTexels,
const VkImage imageResidency)
{
const InstanceInterface& instance = m_context.getInstanceInterface();
const DeviceInterface& deviceInterface = getDeviceInterface();
const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
const VkPhysicalDeviceProperties deviceProperties = getPhysicalDeviceProperties(instance, physicalDevice);
if (imageSparseInfo.extent.width > deviceProperties.limits.maxFramebufferWidth ||
imageSparseInfo.extent.height > deviceProperties.limits.maxFramebufferHeight ||
imageSparseInfo.arrayLayers > deviceProperties.limits.maxFramebufferLayers)
{
TCU_THROW(NotSupportedError, "Image size exceeds allowed framebuffer dimensions");
}
// Check if device supports image format for sampled images
if (!checkImageFormatFeatureSupport(instance, physicalDevice, imageSparseInfo.format, VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT))
TCU_THROW(NotSupportedError, "Device does not support image format for sampled images");
// Check if device supports image format for color attachment
if (!checkImageFormatFeatureSupport(instance, physicalDevice, imageSparseInfo.format, VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT))
TCU_THROW(NotSupportedError, "Device does not support image format for color attachment");
// Make sure device supports VK_FORMAT_R32_UINT format for color attachment
if (!checkImageFormatFeatureSupport(instance, physicalDevice, mapTextureFormat(m_residencyFormat), VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT))
TCU_THROW(TestError, "Device does not support VK_FORMAT_R32_UINT format for color attachment");
// Create buffer storing vertex data
std::vector<tcu::Vec2> vertexData;
vertexData.push_back(tcu::Vec2(-1.0f,-1.0f));
vertexData.push_back(tcu::Vec2( 0.0f, 0.0f));
vertexData.push_back(tcu::Vec2(-1.0f, 1.0f));
vertexData.push_back(tcu::Vec2( 0.0f, 1.0f));
vertexData.push_back(tcu::Vec2( 1.0f,-1.0f));
vertexData.push_back(tcu::Vec2( 1.0f, 0.0f));
vertexData.push_back(tcu::Vec2( 1.0f, 1.0f));
vertexData.push_back(tcu::Vec2( 1.0f, 1.0f));
const VkDeviceSize vertexDataSizeInBytes = sizeInBytes(vertexData);
const VkBufferCreateInfo vertexBufferCreateInfo = makeBufferCreateInfo(vertexDataSizeInBytes, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
m_vertexBuffer = createBuffer(deviceInterface, getDevice(), &vertexBufferCreateInfo);
m_vertexBufferAlloc = bindBuffer(deviceInterface, getDevice(), getAllocator(), *m_vertexBuffer, MemoryRequirement::HostVisible);
deMemcpy(m_vertexBufferAlloc->getHostPtr(), &vertexData[0], static_cast<std::size_t>(vertexDataSizeInBytes));
flushMappedMemoryRange(deviceInterface, getDevice(), m_vertexBufferAlloc->getMemory(), m_vertexBufferAlloc->getOffset(), vertexDataSizeInBytes);
// Create render pass
const VkAttachmentDescription texelsAttachmentDescription =
{
(VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags;
imageSparseInfo.format, // VkFormat format;
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
};
const VkAttachmentDescription residencyAttachmentDescription =
{
(VkAttachmentDescriptionFlags)0, // VkAttachmentDescriptionFlags flags;
mapTextureFormat(m_residencyFormat), // VkFormat format;
VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
VK_ATTACHMENT_LOAD_OP_CLEAR, // VkAttachmentLoadOp loadOp;
VK_ATTACHMENT_STORE_OP_STORE, // VkAttachmentStoreOp storeOp;
VK_ATTACHMENT_LOAD_OP_DONT_CARE, // VkAttachmentLoadOp stencilLoadOp;
VK_ATTACHMENT_STORE_OP_DONT_CARE, // VkAttachmentStoreOp stencilStoreOp;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, // VkImageLayout initialLayout;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout finalLayout;
};
const VkAttachmentDescription colorAttachmentsDescription[] = { texelsAttachmentDescription, residencyAttachmentDescription };
const VkAttachmentReference texelsAttachmentReference =
{
0u, // deUint32 attachment;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
};
const VkAttachmentReference residencyAttachmentReference =
{
1u, // deUint32 attachment;
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL // VkImageLayout layout;
};
const VkAttachmentReference colorAttachmentsReference[] = { texelsAttachmentReference, residencyAttachmentReference };
const VkAttachmentReference depthAttachmentReference =
{
VK_ATTACHMENT_UNUSED, // deUint32 attachment;
VK_IMAGE_LAYOUT_UNDEFINED // VkImageLayout layout;
};
const VkSubpassDescription subpassDescription =
{
(VkSubpassDescriptionFlags)0, // VkSubpassDescriptionFlags flags;
VK_PIPELINE_BIND_POINT_GRAPHICS, // VkPipelineBindPoint pipelineBindPoint;
0u, // deUint32 inputAttachmentCount;
DE_NULL, // const VkAttachmentReference* pInputAttachments;
2u, // deUint32 colorAttachmentCount;
colorAttachmentsReference, // const VkAttachmentReference* pColorAttachments;
DE_NULL, // const VkAttachmentReference* pResolveAttachments;
&depthAttachmentReference, // const VkAttachmentReference* pDepthStencilAttachment;
0u, // deUint32 preserveAttachmentCount;
DE_NULL // const deUint32* pPreserveAttachments;
};
const VkRenderPassCreateInfo renderPassInfo =
{
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkRenderPassCreateFlags)0, // VkRenderPassCreateFlags flags;
2u, // deUint32 attachmentCount;
colorAttachmentsDescription, // const VkAttachmentDescription* pAttachments;
1u, // deUint32 subpassCount;
&subpassDescription, // const VkSubpassDescription* pSubpasses;
0u, // deUint32 dependencyCount;
DE_NULL // const VkSubpassDependency* pDependencies;
};
m_renderPass = createRenderPass(deviceInterface, getDevice(), &renderPassInfo);
// Create descriptor set layout
DescriptorSetLayoutBuilder descriptorLayerBuilder;
descriptorLayerBuilder.addSingleBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT);
const Unique<VkDescriptorSetLayout> descriptorSetLayout(descriptorLayerBuilder.build(deviceInterface, getDevice()));
// Create descriptor pool
DescriptorPoolBuilder descriptorPoolBuilder;
descriptorPoolBuilder.addType(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, imageSparseInfo.mipLevels);
descriptorPool = descriptorPoolBuilder.build(deviceInterface, getDevice(), VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, imageSparseInfo.mipLevels);
// Create sampler object
const tcu::Sampler samplerObject(tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, tcu::Sampler::REPEAT_GL, tcu::Sampler::NEAREST_MIPMAP_NEAREST, tcu::Sampler::NEAREST);
const VkSamplerCreateInfo samplerCreateInfo = mapSampler(samplerObject, m_format);
m_sampler = createSampler(deviceInterface, getDevice(), &samplerCreateInfo);
struct PushConstants
{
deUint32 lod;
deUint32 padding; // padding needed to satisfy std430 rules
float lodWidth;
float lodHeight;
};
// Create pipeline layout
const VkPushConstantRange lodConstantRange =
{
VK_SHADER_STAGE_FRAGMENT_BIT, // VkShaderStageFlags stageFlags;
0u, // deUint32 offset;
sizeof(PushConstants), // deUint32 size;
};
const VkPipelineLayoutCreateInfo pipelineLayoutParams =
{
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
0u, // VkPipelineLayoutCreateFlags flags;
1u, // deUint32 setLayoutCount;
&descriptorSetLayout.get(), // const VkDescriptorSetLayout* pSetLayouts;
1u, // deUint32 pushConstantRangeCount;
&lodConstantRange, // const VkPushConstantRange* pPushConstantRanges;
};
const Unique<VkPipelineLayout> pipelineLayout(createPipelineLayout(deviceInterface, getDevice(), &pipelineLayoutParams));
// Create graphics pipeline
{
Move<VkShaderModule> vertexModule = createShaderModule(deviceInterface, getDevice(), m_context.getBinaryCollection().get("vertex_shader"), (VkShaderModuleCreateFlags)0);
Move<VkShaderModule> fragmentModule = createShaderModule(deviceInterface, getDevice(), m_context.getBinaryCollection().get("fragment_shader"), (VkShaderModuleCreateFlags)0);
Move<VkShaderModule> geometryModule;
if (imageSparseInfo.arrayLayers > 1u)
{
requireFeatures(instance, physicalDevice, FEATURE_GEOMETRY_SHADER);
geometryModule = createShaderModule(deviceInterface, getDevice(), m_context.getBinaryCollection().get("geometry_shader"), (VkShaderModuleCreateFlags)0);
}
pipelines.push_back(makeVkSharedPtr(makeGraphicsPipeline(
deviceInterface, getDevice(), *pipelineLayout, *m_renderPass, *vertexModule, *fragmentModule, *geometryModule)));
}
const VkPipeline graphicsPipeline = **pipelines[0];
{
const VkImageSubresourceRange fullImageSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers);
VkImageMemoryBarrier imageShaderAccessBarriers[3];
imageShaderAccessBarriers[0] = makeImageMemoryBarrier
(
VK_ACCESS_TRANSFER_WRITE_BIT,
VK_ACCESS_SHADER_READ_BIT,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
imageSparse,
fullImageSubresourceRange
);
imageShaderAccessBarriers[1] = makeImageMemoryBarrier
(
0u,
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
imageTexels,
fullImageSubresourceRange
);
imageShaderAccessBarriers[2] = makeImageMemoryBarrier
(
0u,
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
imageResidency,
fullImageSubresourceRange
);
deviceInterface.cmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 3u, imageShaderAccessBarriers);
}
imageSparseViews.resize(imageSparseInfo.mipLevels);
imageTexelsViews.resize(imageSparseInfo.mipLevels);
imageResidencyViews.resize(imageSparseInfo.mipLevels);
m_framebuffers.resize(imageSparseInfo.mipLevels);
descriptorSets.resize(imageSparseInfo.mipLevels);
std::vector<VkClearValue> clearValues;
clearValues.push_back(makeClearValueColor(tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f)));
clearValues.push_back(makeClearValueColor(tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f)));
for (deUint32 mipLevelNdx = 0u; mipLevelNdx < imageSparseInfo.mipLevels; ++mipLevelNdx)
{
const vk::VkExtent3D mipLevelSize = mipLevelExtents(imageSparseInfo.extent, mipLevelNdx);
const vk::VkRect2D renderArea = makeRect2D(mipLevelSize);
const VkViewport viewport = makeViewport(mipLevelSize);
const VkImageSubresourceRange mipLevelRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, mipLevelNdx, 1u, 0u, imageSparseInfo.arrayLayers);
// Create color attachments image views
imageTexelsViews[mipLevelNdx] = makeVkSharedPtr(makeImageView(deviceInterface, getDevice(), imageTexels, mapImageViewType(m_imageType), imageSparseInfo.format, mipLevelRange));
imageResidencyViews[mipLevelNdx] = makeVkSharedPtr(makeImageView(deviceInterface, getDevice(), imageResidency, mapImageViewType(m_imageType), mapTextureFormat(m_residencyFormat), mipLevelRange));
const VkImageView attachmentsViews[] = { **imageTexelsViews[mipLevelNdx], **imageResidencyViews[mipLevelNdx] };
// Create framebuffer
const VkFramebufferCreateInfo framebufferInfo =
{
VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, // VkStructureType sType;
DE_NULL, // const void* pNext;
(VkFramebufferCreateFlags)0, // VkFramebufferCreateFlags flags;
*m_renderPass, // VkRenderPass renderPass;
2u, // uint32_t attachmentCount;
attachmentsViews, // const VkImageView* pAttachments;
mipLevelSize.width, // uint32_t width;
mipLevelSize.height, // uint32_t height;
imageSparseInfo.arrayLayers, // uint32_t layers;
};
m_framebuffers[mipLevelNdx] = makeVkSharedPtr(createFramebuffer(deviceInterface, getDevice(), &framebufferInfo));
// Create descriptor set
descriptorSets[mipLevelNdx] = makeVkSharedPtr(makeDescriptorSet(deviceInterface, getDevice(), *descriptorPool, *descriptorSetLayout));
const VkDescriptorSet descriptorSet = **descriptorSets[mipLevelNdx];
// Update descriptor set
const VkImageSubresourceRange sparseImageSubresourceRange = sampledImageRangeToBind(imageSparseInfo, mipLevelNdx);
imageSparseViews[mipLevelNdx] = makeVkSharedPtr(makeImageView(deviceInterface, getDevice(), imageSparse, mapImageViewType(m_imageType), imageSparseInfo.format, sparseImageSubresourceRange));
const VkDescriptorImageInfo imageSparseDescInfo = makeDescriptorImageInfo(*m_sampler, **imageSparseViews[mipLevelNdx], VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
DescriptorSetUpdateBuilder descriptorUpdateBuilder;
descriptorUpdateBuilder.writeSingle(descriptorSet, DescriptorSetUpdateBuilder::Location::binding(BINDING_IMAGE_SPARSE), VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, &imageSparseDescInfo);
descriptorUpdateBuilder.update(deviceInterface, getDevice());
// Begin render pass
beginRenderPass(deviceInterface, commandBuffer, *m_renderPass, **m_framebuffers[mipLevelNdx], renderArea, (deUint32)clearValues.size(), &clearValues[0]);
// Bind graphics pipeline
deviceInterface.cmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);
// Bind descriptor set
deviceInterface.cmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet, 0u, DE_NULL);
// Bind vertex buffer
{
const VkDeviceSize offset = 0ull;
deviceInterface.cmdBindVertexBuffers(commandBuffer, 0u, 1u, &m_vertexBuffer.get(), &offset);
}
// Bind Viewport
deviceInterface.cmdSetViewport(commandBuffer, 0u, 1u, &viewport);
// Bind Scissor Rectangle
deviceInterface.cmdSetScissor(commandBuffer, 0u, 1u, &renderArea);
const PushConstants pushConstants =
{
mipLevelNdx,
0u, // padding
static_cast<float>(mipLevelSize.width),
static_cast<float>(mipLevelSize.height)
};
// Update push constants
deviceInterface.cmdPushConstants(commandBuffer, *pipelineLayout, VK_SHADER_STAGE_FRAGMENT_BIT, 0u, sizeof(PushConstants), &pushConstants);
// Draw full screen quad
deviceInterface.cmdDraw(commandBuffer, 4u, 1u, 0u, 0u);
// End render pass
endRenderPass(deviceInterface, commandBuffer);
}
{
const VkImageSubresourceRange fullImageSubresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, imageSparseInfo.mipLevels, 0u, imageSparseInfo.arrayLayers);
VkImageMemoryBarrier imageOutputTransferSrcBarriers[2];
imageOutputTransferSrcBarriers[0] = makeImageMemoryBarrier
(
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_ACCESS_TRANSFER_READ_BIT,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
imageTexels,
fullImageSubresourceRange
);
imageOutputTransferSrcBarriers[1] = makeImageMemoryBarrier
(
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_ACCESS_TRANSFER_READ_BIT,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
imageResidency,
fullImageSubresourceRange
);
deviceInterface.cmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0u, 0u, DE_NULL, 0u, DE_NULL, 2u, imageOutputTransferSrcBarriers);
}
}
PassRefPtr<WebCLBuffer> WebCLContext::createBuffer(unsigned memFlags, unsigned sizeInBytes, ExceptionState& es)
{
return createBuffer(memFlags, sizeInBytes, nullptr, es);
}
//%
Buffer i2cReadBuffer(int address, int size, bool repeat = false)
{
Buffer buf = createBuffer(size);
uBit.i2c.read(address << 1, (char*)buf->payload, size, repeat);
return buf;
}
main(){
// initialize the ST library runtime, necessary for up() and down()
st_init();
//BoundedBuffer into which input from stdin is stored
BoundedBuffer theInput;
createBuffer(&theInput, MAX_BUFF_SIZE);
// create a binary semaphore for use with input thread
semaphore input_sem;
createSem(&input_sem, 1);
ThreadInit getInputThread = {
NULL, // no input buffer for getInput thread, comes from stdin
&theInput, // puts data from stdin into BoundedBuffer theInput
&input_sem // for mutual exclusion
};
// create input thread
if (st_thread_create(getInput, &getInputThread, 0, 0) == NULL){
perror("st_thread_create for getInput failure");
exit(1);
}
//BoundedBuffer into which processed data w/o newlines are stored
BoundedBuffer newLinesProcessed;
createBuffer(&newLinesProcessed, MAX_BUFF_SIZE);
// create binary semaphore for use with newline thread
semaphore nl_sem;
createSem(&nl_sem, 1);
ThreadInit nlToSpaceThread = {
&theInput, // processes input from the BoundedBuffer theInput
&newLinesProcessed, // puts processed data into BB newLinesProcessed
&nl_sem // for mutual exclusion
};
//create newline processing thread
if (st_thread_create(newlineToSpace, &nlToSpaceThread,0,0) == NULL){
perror("st_thread_create for newlineToSpace failure");
exit(1);
}
//BoundedBuffer into which processed data after asterisks are handled go
BoundedBuffer caratsProcessed;
createBuffer(&caratsProcessed, MAX_BUFF_SIZE);
// create binary semaphore for use with newline thread
semaphore carat_sem;
createSem(&carat_sem, 1);
ThreadInit caratThread = {
&newLinesProcessed, // buffer from wich input is processed
&caratsProcessed, // puts processed data into BB caratsProcessed
&carat_sem // for mutual exclusion
};
//create asterisks to carat processing thread
if (st_thread_create(asterisksToCarat, &caratThread,0,0) == NULL){
perror("st_thread_create for newlineToSpace failure");
exit(1);
}
// create binary semaphore for use with print thread
semaphore print_sem;
createSem(&print_sem, 1);
ThreadInit printThread = {
&caratsProcessed, // buffer from which input is processed
NULL, // no output buffer, just printing to stdout
&print_sem // for mutual exclusion
};
// create print thread
if (st_thread_create(print80CharLines, &printThread,0,0) == NULL){
perror("st_thread_create for print80CharLines failure");
exit(1);
}
// exit main thread
st_thread_exit(NULL);
}
// generate vertex array object
void Mesh::generateVAO(int programId) {
GLuint tmpID;
if (!vao_dirty_) {
return;
}
obtainDeleter();
if (vertices_.size() == 0 && normals_.size() == 0
&& tex_coords_.size() == 0) {
std::string error = "no vertex data yet, shouldn't call here. ";
throw error;
}
if (0 != normals_.size() && vertices_.size() != normals_.size()) {
LOGW("mesh: number of vertices and normals do not match! vertices %d, normals %d", vertices_.size(), normals_.size());
}
GLuint vaoID_;
GLuint triangle_vboID_;
GLuint static_vboID_;
auto it = program_ids_.find(programId);
if (it != program_ids_.end())
{
GLVaoVboId ids = it->second;
vaoID_ = ids.vaoID;
triangle_vboID_ = ids.triangle_vboID;
static_vboID_ = ids.static_vboID;
}
else
{
glGenVertexArrays(1, &vaoID_);
glGenBuffers(1, &triangle_vboID_);
glGenBuffers(1, &static_vboID_);
}
glBindVertexArray(vaoID_);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, triangle_vboID_);
glBufferData(GL_ELEMENT_ARRAY_BUFFER,
sizeof(unsigned short) * indices_.size(), &indices_[0],
GL_STATIC_DRAW);
numTriangles_ = indices_.size() / 3;
attrMapping.clear();
int totalStride;
int attrLength;
createAttributeMapping(programId, totalStride, attrLength);
std::vector<GLfloat> buffer;
createBuffer(buffer, attrLength);
glBindBuffer(GL_ARRAY_BUFFER, static_vboID_);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * buffer.size(),
&buffer[0], GL_STATIC_DRAW);
int localCnt = 0;
for ( std::vector<GLAttributeMapping>::iterator it = attrMapping.begin(); it != attrMapping.end(); ++it)
{
GLAttributeMapping currData = *it;
glVertexAttribPointer(currData.index, currData.size, currData.type, 0, totalStride * sizeof(GLfloat), (GLvoid*) (currData.offset * sizeof(GLfloat)));
glEnableVertexAttribArray(currData.index);
}
// done generation
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
if (it == program_ids_.end())
{
GLVaoVboId id;
id.vaoID = vaoID_;
id.static_vboID = static_vboID_;
id.triangle_vboID = triangle_vboID_;
program_ids_[programId] = id;
}
vao_dirty_ = false;
}
static void connectServer(const char *stty, const char *dev) {
int fdmax, newfd;
fd_set master, read_fds;
FD_ZERO(&master);
FD_ZERO(&read_fds);
int serverfd;
serverfd = createServerSocket(dev);
if (serverfd < 0) {
syslog(LOG_ERR, "mTerm_server: Failed to create server socket\n");
return;
}
struct ttyRaw* tty_sol;
tty_sol = setTty(openTty(stty), 1);
if (!tty_sol) {
syslog(LOG_ERR, "mTerm_server: Failed to set tty to raw mode\n");
close(serverfd);
return;
}
struct bufStore* buf;
buf = createBuffer(dev, FILE_SIZE_BYTES);
if (!buf || (buf->buf_fd < 0)) {
syslog(LOG_ERR, "mTerm_server: Failed to create the log file\n");
closeTty(tty_sol);
close(serverfd);
return;
}
FD_SET(serverfd, &master);
FD_SET(tty_sol->fd,&master);
fdmax = (serverfd > tty_sol->fd) ? serverfd : tty_sol->fd;
for(;;) {
read_fds = master;
if (select(fdmax + 1, &read_fds, NULL, NULL, NULL) == -1) {
syslog(LOG_ERR, "mTerm_server: Server socket: select error\n");
break;
}
if (FD_ISSET(serverfd, &read_fds)) {
newfd = acceptClient(serverfd);
if (newfd < 0) {
syslog(LOG_ERR, "mTerm_server: Error on accepting client\n");
} else {
FD_SET(newfd, &master);
if (newfd > fdmax) {
fdmax = newfd;
}
}
}
if (FD_ISSET(tty_sol->fd, &read_fds)) {
if ( processSol(&master, serverfd, fdmax, tty_sol->fd, buf) < 0) {
break;
}
}
int i;
for(i = 0; i <= fdmax; i++) {
if (FD_ISSET(i, &read_fds)) {
if ((i == serverfd) || (i == tty_sol->fd)) {
continue;
} else {
processClient(&master, i, tty_sol->fd, buf);
}
}
}
}
closeTty(tty_sol);
close(serverfd);
closeBuffer(buf);
}
