TEST_F(testTaskDispatcherBase, executeQueue) {
unsigned int somethingDone = 0;
mTasks.post(std::bind([&]() { ++somethingDone; }));
mTasks.post(std::bind([&]() { ++somethingDone; }));
executeQueue();
EXPECT_EQ(somethingDone, 2);
}
//moves the elevator to queued levels, will only stop if direction desired is the same as the elevators direction.
// calls itself to go the other direction when complete if not empty.
//sets to IDLE when complete
void cs415_elevator::executeQueue(){
//go through queue to each floor
if(maxQueue.empty() && minQueue.empty()){ // a little bit of recursion in my life
return;
}
std::cout << "Elevator is at: " << currentFloor << std::endl;
int flr;
if(direction == UP){
while(!minQueue.empty()){
flr = minQueue.top();
minQueue.pop();
while(currentFloor <= flr){
std::cout << "waiting for move ......." << std::endl;
std::cout << "moved to " << currentFloor << std::endl;
if(flr != currentFloor){
move_up();
}
}
}
}
else if(direction == DOWN){
while(!maxQueue.empty()){
flr = maxQueue.top();
maxQueue.pop();
while(currentFloor >= flr){
std::cout << "waiting for move ......." << std::endl;
std::cout << "moved to " << currentFloor << std::endl;
if(flr != currentFloor){
move_down();
}
}
}
}
if(direction == UP){
direction = DOWN;
}
else{
direction = UP;
}
executeQueue();
direction = IDLE;
std::cout << "Elevator is IDLE" << std::endl;
}
bool initSwapChains()
{
std::cout << "initing swapchain...";
if( !getSurfaceFormats() || !getSurfacePresentModes() )
{
return false;
}
VkResult res;
res = vkGetPhysicalDeviceSurfaceCapabilitiesKHR( gDevices[0], gSurface, &gSurfaceCaps );
if( res != VK_SUCCESS )
{
std::cout << "error getting surface capabilities\n";
}
VkExtent2D swapChainExtent = gSurfaceCaps.currentExtent;
if( std::find( gPresentModes.begin(), gPresentModes.end(), VK_PRESENT_MODE_MAILBOX_KHR ) != gPresentModes.end() )
gPresentMode = VK_PRESENT_MODE_MAILBOX_KHR;
else if( std::find( gPresentModes.begin(), gPresentModes.end(), VK_PRESENT_MODE_IMMEDIATE_KHR ) != gPresentModes.end() )
gPresentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
else
gPresentMode = VK_PRESENT_MODE_FIFO_KHR;
uint32_t desiredNumberOfSwapChainImages = gSurfaceCaps.minImageCount + 1;
desiredNumberOfSwapChainImages = gSurfaceCaps.maxImageCount ? max( desiredNumberOfSwapChainImages, gSurfaceCaps.maxImageCount ) : desiredNumberOfSwapChainImages;
VkSurfaceTransformFlagBitsKHR preTransform;
preTransform = gSurfaceCaps.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR ? VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR : gSurfaceCaps.currentTransform;
VkSwapchainCreateInfoKHR swapChain = {};
swapChain.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
swapChain.pNext = nullptr;
swapChain.surface = gSurface;
swapChain.minImageCount = desiredNumberOfSwapChainImages;
swapChain.imageFormat = gFormat;
swapChain.imageExtent = swapChainExtent;
swapChain.preTransform = preTransform;
swapChain.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
swapChain.imageArrayLayers = 1;
swapChain.presentMode = gPresentMode;
swapChain.oldSwapchain = NULL;
swapChain.clipped = true;
swapChain.imageColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
swapChain.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
swapChain.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
swapChain.queueFamilyIndexCount = 0;
swapChain.pQueueFamilyIndices = nullptr;
res = vkCreateSwapchainKHR( gDevice, &swapChain, nullptr, &gSwapchain );
if( res != VK_SUCCESS )
{
std::cout << "error creating swapchain "<< res << std::endl;
return false;
}
std::vector<VkImage> images;
u32 imagesCount = 0;
HR( vkGetSwapchainImagesKHR(gDevice, gSwapchain, &imagesCount, nullptr ) );
images.resize( imagesCount );
HR( vkGetSwapchainImagesKHR(gDevice, gSwapchain, &imagesCount, images.data() ) );
beginCommandBuffer( gCmd );
vkGetDeviceQueue( gDevice, gQueueFamilyIndex, 0, &gQueue );
gSwapBuffers.resize( imagesCount );
for( u32 i = 0; i < gSwapBuffers.size(); ++i )
{
VkImageViewCreateInfo imageView = {};
imageView.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
imageView.pNext = nullptr;
imageView.format = gFormat;
imageView.components.r = VK_COMPONENT_SWIZZLE_R;
imageView.components.g = VK_COMPONENT_SWIZZLE_G;
imageView.components.b = VK_COMPONENT_SWIZZLE_B;
imageView.components.a = VK_COMPONENT_SWIZZLE_A;
imageView.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageView.subresourceRange.baseMipLevel = 0;
imageView.subresourceRange.levelCount = 1;
imageView.subresourceRange.baseArrayLayer = 0;
imageView.subresourceRange.layerCount = 1;
imageView.viewType = VK_IMAGE_VIEW_TYPE_2D;
imageView.flags = 0;
imageView.image = images[i];
setImageLayout( gCmd, gSwapBuffers[i].image, VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL );
HR( vkCreateImageView( gDevice, &imageView, nullptr, &gSwapBuffers[i].view ) );
}
endCommandBuffer( gCmd );
executeQueue( gCmd );
std::cout << "inited\n";
return true;
}
TEST_F(testTaskDispatcherBase, signalizeStop) {
mTasks.stop();
EXPECT_EQ(this->mAborts, 0);
executeQueue();
EXPECT_EQ(this->mAborts, 1);
}