int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow )
{
WNDCLASSEX wcex;
HWND hwnd;
HDC hDC;
HGLRC hRC;
MSG msg;
BOOL bQuit = FALSE;
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_OWNDC;
wcex.lpfnWndProc = WindowProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
wcex.lpszMenuName = NULL;
wcex.lpszClassName = WINDOW_CLASS;
wcex.hIconSm = LoadIcon(NULL, IDI_APPLICATION);;
if( !RegisterClassEx( &wcex )) {
return 0;
}
hwnd = CreateWindowEx(
0, WINDOW_CLASS, WINDOW_TITLE,
//WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
WS_OVERLAPPEDWINDOW, 30, 20,
screen_w + GetSystemMetrics( SM_CYFRAME ) * 2,
screen_h + GetSystemMetrics( SM_CYFRAME ) * 2 + GetSystemMetrics( SM_CYCAPTION ),
NULL, NULL, hInstance, NULL
);
ShowWindow( hwnd, nCmdShow );
enableOpenGL( hwnd, &hDC, &hRC );
enableOpenAL();
resizeScene( screen_w, screen_h );
glEnable( GL_TEXTURE_2D );
glClearColor( 0.1f, 0.1f, 0.1f, 0.0f );
glClearDepth( 1.0f );
glEnable( GL_DEPTH_TEST );
glDepthFunc( GL_LEQUAL );
glShadeModel( GL_SMOOTH );
glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
// FIXME NOPE...audio en video out of sync, packet queue is wel goed
//char *file = "C:/Users/vin777/Documents/Dump/Films/Monsters.Vs.Aliens.DVDRiP.XviD-JUMANJi/jmj-mona.avi";
// FIXME NOPE...geen audio codec gevonden
//char *file = "C:/Users/vin777/Documents/Dump/Films/Monsters.Vs.Aliens.2009.1080p.BluRay.x264-CiNEFiLE.mkv";
// FIXME OK...foutje in begin van de file maar voor de rest gaat het uitstekend
//char *file = "C:/Users/vin777/Documents/Dump/Films/Transformers Revenge of the Fallen[2009]DvDrip[Eng]-FXG/Transformers Revenge of the Fallen[2009]DvDrip[Eng]-FXG.avi";
// De avi file is ook niet helemaal perfect, loopt goed.
// FIXME NOPE...foutje in begin file en video packet queue buffer altijd leeg?
//char *file = "../stuff/video.avi";
// FIXME UPDATE...OK! Stream had een pFormatCtx->start_time, werkt nu! Maar waarom is de audio packet queue nog vol aan het einde?
// NOPE...audio en beeld out of sync, packet queue is wel goed
//char *file = "../stuff/video.wmv";
//char media[] = "C:/Users/vin777/Documents/Dump/Encode/fulco/howtotrainyourdragon-tlr2_h720p_fulco.mp4";
//char media2[] = "C:/Users/vin777/Documents/Dump/Encode/fulco/julieandjulia-tlr1_h720p_fulco.mp4";
//char media[] = "http://scfire-mtc-aa03.stream.aol.com:80/stream/1025";
//char media[] = "http://72.26.204.18:6256#.aac";
//char media[] = "../DUMP/image.png";
//char media[] = "./stuff/video.gif";
//char media2[] = "../DUMP/image.jpg";
//char media[] = "http://tweakimg.net/g/if/v2/breadcrumb/award_2009_transparent.png";
//char media2[] = "http://ccms.e-billboard.eu/webcam/?id=19#.jpg";
//char media[] = "./stuff/music.mp3";
int i;
int num_vid = 5;
char *media[] = {
"C:/Users/vin777/Documents/Dump/Encode/fulco/howtotrainyourdragon-tlr2_h720p_fulco.mp4",
"C:/Users/vin777/Documents/Dump/Encode/fulco/julieandjulia-tlr1_h720p_fulco.mp4",
"C:/Users/vin777/Documents/Dump/Encode/fulco/aliceinwonderland-tsr1_h720p_fulco.mp4",
"E:/vincent/data/snapshot_0/vincent/films/wake_up/Vincent_van_Ingen-Wake_Up-H264-AAC-720p.mov",
"http://ccms.e-billboard.eu/webcam/?id=19#.jpg",
};
Vineo v[num_vid];
for( i = 0; i < num_vid; i++ )
{
vineoInit( &v[i] );
glBindTexture( GL_TEXTURE_2D, v[i].tex_gl );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
vineoOpenAndDecodeThread( &v[i], media[i] );
}
float r = 0.0f;
float x = 0.0f;
float x_space = 3.0f;
int num_box = 15;
int64_t time = av_gettime();
int64_t ptime = time;
int64_t ctime = 0;
int count = 0;
int max_count = 200;
while( !bQuit )
{
if( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
{
if( msg.message == WM_QUIT )
{
bQuit = 1;
}
else
{
TranslateMessage( &msg );
DispatchMessage( &msg );
}
}
else
{
ptime = time;
time = av_gettime();
ctime += time - ptime;
if( ++count == max_count )
{
float fps = (float)AV_TIME_BASE / (float)ctime * (float)max_count;
char title[64];
//printf( "fps: %f\n", fps );
sprintf( title, "Vineo = OpenGL / OpenAL / FFmpeg, fps: %f", fps );
SetWindowText( hwnd, title );
ctime = 0;
count = 0;
}
if( keys[VK_ESCAPE] ) {
bQuit = 1;
}
if( keys[VK_ESCAPE] ) {
PostQuitMessage( 0 );
}
if( keys['R'] )
{
for( i = 0; i < num_vid; i++ )
{
vineoClose( &v[i] );
//v[i] = vineoNew();
vineoInit( &v[i] );
glBindTexture( GL_TEXTURE_2D, v[i].tex_gl );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
//vineoOpen( v[i], media[i] );
//vineoPlay( v[i] );
vineoOpenAndDecodeThread( &v[i], media[i] );
}
}
x += (float)( time - ptime ) / 1000000.0f;
if( x > num_vid * x_space ) {
x -= num_vid * x_space;
}
r += (float)( time - ptime ) / 100000.0f;
for( i = 0; i < num_vid; i++ ) {
vineoFlush( &v[i] );
}
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
// camera
glRotatef( 45.0f, 0.0f, 1.0f, 0.0f );
glTranslatef( -x, -0.8f, -8.0f );
// spiegel reflectie
for( i = 0; i < num_box; i++ )
{
if( !v[i%num_vid].is_frame_flushed ) {
continue;
}
glPushMatrix();
glBindTexture( GL_TEXTURE_2D, v[i%num_vid].tex_gl );
glColor3f( 1.0f, 1.0f, 1.0f );
glTranslatef( i * x_space, -1.2f, 0.0f );
glRotatef( r, 0.0f, 1.0f, 0.0f );
glScalef( 1.0f, -1.0f, 1.0f );
texCube();
glPopMatrix();
}
// vloer
glPushMatrix();
glBindTexture( GL_TEXTURE_2D, 0 );
glColor4f( 0.0f, 0.0f, 0.0f, 0.8f );
glBegin( GL_QUADS );
glVertex3f( 100.0f, 0.0f,-100.0f );
glVertex3f(-100.0f, 0.0f,-100.0f );
glVertex3f(-100.0f, 0.0f, 100.0f );
glVertex3f( 100.0f, 0.0f, 100.0f );
glEnd();
glPopMatrix();
// top
for( i = 0; i < num_box; i++ )
{
if( !v[i%num_vid].is_frame_flushed ) {
continue;
}
glPushMatrix();
glBindTexture( GL_TEXTURE_2D, v[i%num_vid].tex_gl );
glColor3f( 1.0f, 1.0f, 1.0f );
glTranslatef( i * x_space, 1.2f, 0.0f );
glRotatef( r, 0.0f, 1.0f, 0.0f );
texCube();
glPopMatrix();
}
SwapBuffers( hDC );
PrintMemoryInfo( GetCurrentProcessId() );
}
}
for( i = 0; i < num_vid; i++ ) {
vineoClose( &v[i] );
};
disableOpenAL();
disableOpenGL( hwnd, hDC, hRC );
DestroyWindow( hwnd );
return msg.wParam;
}
void loadCubemap(std::string filename, VkFormat format, bool forceLinearTiling)
{
#if defined(__ANDROID__)
// Textures are stored inside the apk on Android (compressed)
// So they need to be loaded via the asset manager
AAsset* asset = AAssetManager_open(androidApp->activity->assetManager, filename.c_str(), AASSET_MODE_STREAMING);
assert(asset);
size_t size = AAsset_getLength(asset);
assert(size > 0);
void *textureData = malloc(size);
AAsset_read(asset, textureData, size);
AAsset_close(asset);
gli::texture_cube texCube(gli::load((const char*)textureData, size));
#else
gli::texture_cube texCube(gli::load(filename));
#endif
assert(!texCube.empty());
cubeMap.width = texCube.extent().x;
cubeMap.height = texCube.extent().y;
cubeMap.mipLevels = texCube.levels();
VkMemoryAllocateInfo memAllocInfo = vks::initializers::memoryAllocateInfo();
VkMemoryRequirements memReqs;
// Create a host-visible staging buffer that contains the raw image data
VkBuffer stagingBuffer;
VkDeviceMemory stagingMemory;
VkBufferCreateInfo bufferCreateInfo = vks::initializers::bufferCreateInfo();
bufferCreateInfo.size = texCube.size();
// This buffer is used as a transfer source for the buffer copy
bufferCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
VK_CHECK_RESULT(vkCreateBuffer(device, &bufferCreateInfo, nullptr, &stagingBuffer));
// Get memory requirements for the staging buffer (alignment, memory type bits)
vkGetBufferMemoryRequirements(device, stagingBuffer, &memReqs);
memAllocInfo.allocationSize = memReqs.size;
// Get memory type index for a host visible buffer
memAllocInfo.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
VK_CHECK_RESULT(vkAllocateMemory(device, &memAllocInfo, nullptr, &stagingMemory));
VK_CHECK_RESULT(vkBindBufferMemory(device, stagingBuffer, stagingMemory, 0));
// Copy texture data into staging buffer
uint8_t *data;
VK_CHECK_RESULT(vkMapMemory(device, stagingMemory, 0, memReqs.size, 0, (void **)&data));
memcpy(data, texCube.data(), texCube.size());
vkUnmapMemory(device, stagingMemory);
// Create optimal tiled target image
VkImageCreateInfo imageCreateInfo = vks::initializers::imageCreateInfo();
imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
imageCreateInfo.format = format;
imageCreateInfo.mipLevels = cubeMap.mipLevels;
imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
imageCreateInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imageCreateInfo.extent = { cubeMap.width, cubeMap.height, 1 };
imageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
// Cube faces count as array layers in Vulkan
imageCreateInfo.arrayLayers = 6;
// This flag is required for cube map images
imageCreateInfo.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
VK_CHECK_RESULT(vkCreateImage(device, &imageCreateInfo, nullptr, &cubeMap.image));
vkGetImageMemoryRequirements(device, cubeMap.image, &memReqs);
memAllocInfo.allocationSize = memReqs.size;
memAllocInfo.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
VK_CHECK_RESULT(vkAllocateMemory(device, &memAllocInfo, nullptr, &cubeMap.deviceMemory));
VK_CHECK_RESULT(vkBindImageMemory(device, cubeMap.image, cubeMap.deviceMemory, 0));
VkCommandBuffer copyCmd = VulkanExampleBase::createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
// Setup buffer copy regions for each face including all of it's miplevels
std::vector<VkBufferImageCopy> bufferCopyRegions;
uint32_t offset = 0;
for (uint32_t face = 0; face < 6; face++)
{
for (uint32_t level = 0; level < cubeMap.mipLevels; level++)
{
VkBufferImageCopy bufferCopyRegion = {};
bufferCopyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
bufferCopyRegion.imageSubresource.mipLevel = level;
bufferCopyRegion.imageSubresource.baseArrayLayer = face;
bufferCopyRegion.imageSubresource.layerCount = 1;
bufferCopyRegion.imageExtent.width = texCube[face][level].extent().x;
bufferCopyRegion.imageExtent.height = texCube[face][level].extent().y;
bufferCopyRegion.imageExtent.depth = 1;
bufferCopyRegion.bufferOffset = offset;
bufferCopyRegions.push_back(bufferCopyRegion);
// Increase offset into staging buffer for next level / face
offset += texCube[face][level].size();
}
}
// Image barrier for optimal image (target)
// Set initial layout for all array layers (faces) of the optimal (target) tiled texture
VkImageSubresourceRange subresourceRange = {};
subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
subresourceRange.baseMipLevel = 0;
subresourceRange.levelCount = cubeMap.mipLevels;
subresourceRange.layerCount = 6;
vks::tools::setImageLayout(
copyCmd,
cubeMap.image,
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
subresourceRange);
// Copy the cube map faces from the staging buffer to the optimal tiled image
vkCmdCopyBufferToImage(
copyCmd,
stagingBuffer,
cubeMap.image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
static_cast<uint32_t>(bufferCopyRegions.size()),
bufferCopyRegions.data()
);
// Change texture image layout to shader read after all faces have been copied
cubeMap.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
vks::tools::setImageLayout(
copyCmd,
cubeMap.image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
cubeMap.imageLayout,
subresourceRange);
VulkanExampleBase::flushCommandBuffer(copyCmd, queue, true);
// Create sampler
VkSamplerCreateInfo sampler = vks::initializers::samplerCreateInfo();
sampler.magFilter = VK_FILTER_LINEAR;
sampler.minFilter = VK_FILTER_LINEAR;
sampler.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
sampler.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
sampler.addressModeV = sampler.addressModeU;
sampler.addressModeW = sampler.addressModeU;
sampler.mipLodBias = 0.0f;
sampler.compareOp = VK_COMPARE_OP_NEVER;
sampler.minLod = 0.0f;
sampler.maxLod = cubeMap.mipLevels;
sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
sampler.maxAnisotropy = 1.0f;
if (vulkanDevice->features.samplerAnisotropy)
{
sampler.maxAnisotropy = vulkanDevice->properties.limits.maxSamplerAnisotropy;
sampler.anisotropyEnable = VK_TRUE;
}
VK_CHECK_RESULT(vkCreateSampler(device, &sampler, nullptr, &cubeMap.sampler));
// Create image view
VkImageViewCreateInfo view = vks::initializers::imageViewCreateInfo();
// Cube map view type
view.viewType = VK_IMAGE_VIEW_TYPE_CUBE;
view.format = format;
view.components = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
view.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
// 6 array layers (faces)
view.subresourceRange.layerCount = 6;
// Set number of mip levels
view.subresourceRange.levelCount = cubeMap.mipLevels;
view.image = cubeMap.image;
VK_CHECK_RESULT(vkCreateImageView(device, &view, nullptr, &cubeMap.view));
// Clean up staging resources
vkFreeMemory(device, stagingMemory, nullptr);
vkDestroyBuffer(device, stagingBuffer, nullptr);
}
void loadTexture(const char* filename, VkFormat format, bool forceLinearTiling)
{
VkFormatProperties formatProperties;
VkResult err;
gli::textureCube texCube(gli::load(filename));
assert(!texCube.empty());
cubeMap.width = texCube[0].dimensions().x;
cubeMap.height = texCube[0].dimensions().y;
// Get device properites for the requested texture format
vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &formatProperties);
VkImageCreateInfo imageCreateInfo = vkTools::initializers::imageCreateInfo();
imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
imageCreateInfo.format = format;
imageCreateInfo.extent = { cubeMap.width, cubeMap.height, 1 };
imageCreateInfo.mipLevels = 1;
imageCreateInfo.arrayLayers = 1;
imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageCreateInfo.tiling = VK_IMAGE_TILING_LINEAR;
imageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;
imageCreateInfo.flags = 0;
VkMemoryAllocateInfo memAllocInfo = vkTools::initializers::memoryAllocateInfo();
VkMemoryRequirements memReqs;
struct {
VkImage image;
VkDeviceMemory memory;
} cubeFace[6];
// Allocate command buffer for image copies and layouts
VkCommandBuffer cmdBuffer;
VkCommandBufferAllocateInfo cmdBufAlllocatInfo =
vkTools::initializers::commandBufferAllocateInfo(
cmdPool,
VK_COMMAND_BUFFER_LEVEL_PRIMARY,
1);
err = vkAllocateCommandBuffers(device, &cmdBufAlllocatInfo, &cmdBuffer);
assert(!err);
VkCommandBufferBeginInfo cmdBufInfo =
vkTools::initializers::commandBufferBeginInfo();
err = vkBeginCommandBuffer(cmdBuffer, &cmdBufInfo);
assert(!err);
// Load separate cube map faces into linear tiled textures
for (uint32_t face = 0; face < 6; ++face)
{
err = vkCreateImage(device, &imageCreateInfo, nullptr, &cubeFace[face].image);
assert(!err);
vkGetImageMemoryRequirements(device, cubeFace[face].image, &memReqs);
memAllocInfo.allocationSize = memReqs.size;
getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &memAllocInfo.memoryTypeIndex);
err = vkAllocateMemory(device, &memAllocInfo, nullptr, &cubeFace[face].memory);
assert(!err);
err = vkBindImageMemory(device, cubeFace[face].image, cubeFace[face].memory, 0);
assert(!err);
VkImageSubresource subRes = {};
subRes.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
VkSubresourceLayout subResLayout;
void *data;
vkGetImageSubresourceLayout(device, cubeFace[face].image, &subRes, &subResLayout);
assert(!err);
err = vkMapMemory(device, cubeFace[face].memory, 0, memReqs.size, 0, &data);
assert(!err);
memcpy(data, texCube[face][subRes.mipLevel].data(), texCube[face][subRes.mipLevel].size());
vkUnmapMemory(device, cubeFace[face].memory);
// Image barrier for linear image (base)
// Linear image will be used as a source for the copy
vkTools::setImageLayout(
cmdBuffer,
cubeFace[face].image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_PREINITIALIZED,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
}
// Transfer cube map faces to optimal tiling
// Setup texture as blit target with optimal tiling
imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
imageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
imageCreateInfo.flags = VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT;
imageCreateInfo.arrayLayers = 6;
err = vkCreateImage(device, &imageCreateInfo, nullptr, &cubeMap.image);
assert(!err);
vkGetImageMemoryRequirements(device, cubeMap.image, &memReqs);
memAllocInfo.allocationSize = memReqs.size;
getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &memAllocInfo.memoryTypeIndex);
err = vkAllocateMemory(device, &memAllocInfo, nullptr, &cubeMap.deviceMemory);
assert(!err);
err = vkBindImageMemory(device, cubeMap.image, cubeMap.deviceMemory, 0);
assert(!err);
// Image barrier for optimal image (target)
// Optimal image will be used as destination for the copy
// Set initial layout for all array layers of the optimal (target) tiled texture
VkImageSubresourceRange subresourceRange = {};
subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
subresourceRange.baseMipLevel = 0;
subresourceRange.levelCount = 1;
subresourceRange.layerCount = 6;
vkTools::setImageLayout(
cmdBuffer,
cubeMap.image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_PREINITIALIZED,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
subresourceRange);
// Copy cube map faces one by one
for (uint32_t face = 0; face < 6; ++face)
{
// Copy region for image blit
VkImageCopy copyRegion = {};
copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
copyRegion.srcSubresource.baseArrayLayer = 0;
copyRegion.srcSubresource.mipLevel = 0;
copyRegion.srcSubresource.layerCount = 1;
copyRegion.srcOffset = { 0, 0, 0 };
copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
copyRegion.dstSubresource.baseArrayLayer = face;
copyRegion.dstSubresource.mipLevel = 0;
copyRegion.dstSubresource.layerCount = 1;
copyRegion.dstOffset = { 0, 0, 0 };
copyRegion.extent.width = cubeMap.width;
copyRegion.extent.height = cubeMap.height;
copyRegion.extent.depth = 1;
// Put image copy into command buffer
vkCmdCopyImage(
cmdBuffer,
cubeFace[face].image,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
cubeMap.image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1, ©Region);
}
// Change texture image layout to shader read after all faces have been copied
cubeMap.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
vkTools::setImageLayout(
cmdBuffer,
cubeMap.image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
cubeMap.imageLayout,
subresourceRange);
err = vkEndCommandBuffer(cmdBuffer);
assert(!err);
VkFence nullFence = { VK_NULL_HANDLE };
// Submit command buffer to graphis queue
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &cmdBuffer;
err = vkQueueSubmit(queue, 1, &submitInfo, nullFence);
assert(!err);
err = vkQueueWaitIdle(queue);
assert(!err);
// Create sampler
VkSamplerCreateInfo sampler = vkTools::initializers::samplerCreateInfo();
sampler.magFilter = VK_FILTER_LINEAR;
sampler.minFilter = VK_FILTER_LINEAR;
sampler.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
sampler.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
sampler.addressModeV = sampler.addressModeU;
sampler.addressModeW = sampler.addressModeU;
sampler.mipLodBias = 0.0f;
sampler.maxAnisotropy = 8;
sampler.compareOp = VK_COMPARE_OP_NEVER;
sampler.minLod = 0.0f;
sampler.maxLod = 0.0f;
sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
err = vkCreateSampler(device, &sampler, nullptr, &cubeMap.sampler);
assert(!err);
// Create image view
VkImageViewCreateInfo view = vkTools::initializers::imageViewCreateInfo();
view.image = VK_NULL_HANDLE;
view.viewType = VK_IMAGE_VIEW_TYPE_CUBE;
view.format = format;
view.components = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
view.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
view.subresourceRange.layerCount = 6;
view.image = cubeMap.image;
err = vkCreateImageView(device, &view, nullptr, &cubeMap.view);
assert(!err);
// Cleanup
for (auto& face : cubeFace)
{
vkDestroyImage(device, face.image, nullptr);
vkFreeMemory(device, face.memory, nullptr);
}
}