rooty/rpi-vk-driver
1
0
Fork 0
mirror of https://github.com/Yours3lf/rpi-vk-driver.git synced 2025-02-19 16:54:18 +01:00
Code Issues Releases Wiki Activity

fixed wsi stuff

Browse Source
This commit is contained in:
Unknown 2020-04-16 18:07:45 +01:00
parent 714d2dd8e1
commit efa43b2ccc
17 changed files with 555 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
driver/modeset.c
View File

@ -83,9 +83,7 @@ void modeset_enum_modes_for_display(int fd, uint32_t display, uint32_t* numModes
void modeset_create_surface_for_mode(int fd, uint32_t display, uint32_t mode, modeset_display_surface* surface)
{
fprintf(stderr, "modeset create surface\n");
modeset_debug_print(fd);
// modeset_debug_print(fd);
surface->savedState = 0;
@ -115,16 +113,18 @@ void modeset_create_surface_for_mode(int fd, uint32_t display, uint32_t mode, mo
surface->connector = connPtr;
surface->modeID = mode;
surface->crtc = drmModeGetCrtc(fd, encPtr->crtc_id);
//fprintf(stderr, "connector id %i, crtc id %i\n", connPtr->connector_id, encPtr->crtc_id);
}
drmModeFreeEncoder(encPtr);
}
drmModeFreeResources(resPtr);
}
void modeset_create_fb_for_surface(int fd, _image* buf, modeset_display_surface* surface)
{
fprintf(stderr, "modeset create fb\n");
int ret = drmModeAddFB(fd, buf->width, buf->height, 24, 32, buf->stride, buf->boundMem->bo, &buf->fb);
if(ret)
@ -142,8 +142,6 @@ void modeset_destroy_fb(int fd, _image* buf)
void modeset_present(int fd, _image *buf, modeset_display_surface* surface)
{
fprintf(stderr, "modeset present\n");
if(!surface->savedState)
{
while(saved_state_guard);
@ -166,6 +164,7 @@ void modeset_present(int fd, _image *buf, modeset_display_surface* surface)
saved_state_guard = 0;
}
//fprintf(stderr, "present connector id %i, crtc id %i, fb %i\n", surface->connector->connector_id, surface->crtc->crtc_id, buf->fb);
int ret = drmModeSetCrtc(fd, surface->crtc->crtc_id, buf->fb, 0, 0, &surface->connector->connector_id, 1, &surface->connector->modes[surface->modeID]);
if(ret)
{

1
driver/wsi.c
View File

@ -117,6 +117,7 @@ VKAPI_ATTR VkResult VKAPI_CALL rpi_vkCreateDisplayModeKHR(
_displayMode mode = { modes[c].connectorID, modes[c].modeID };
memcpy(pMode, &mode, sizeof(_displayMode));
break;
}
}
}

51
test/ETC/ETC.cpp
View File

@ -360,23 +360,50 @@ void createInstance() {
}
void createWindowSurface() {
/*PFN_vkCreateRpiSurfaceEXT vkCreateRpiSurfaceEXT = 0;
vkCreateRpiSurfaceEXT = (PFN_vkCreateRpiSurfaceEXT)vkGetInstanceProcAddr(instance, "vkCreateRpiSurfaceEXT");
windowSurface = 0;
LoaderTrampoline* trampoline = (LoaderTrampoline*)physicalDevice;
VkRpiPhysicalDevice* realPhysicalDevice = trampoline->loaderTerminator->physicalDevice;
uint32_t displayCount;
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, 0);
VkDisplayPropertiesKHR* displayProperties = (VkDisplayPropertiesKHR*)malloc(sizeof(VkDisplayPropertiesKHR)*displayCount);
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, displayProperties);
VkRpiSurfaceCreateInfoEXT ci = {};
ci.pSurface = &windowSurface;
printf("Enumerated displays\n");
for(uint32_t c = 0; c < displayCount; ++c)
{
printf("Display ID %i\n", displayProperties[c].display);
printf("Display name %s\n", displayProperties[c].displayName);
printf("Display width %i\n", displayProperties[c].physicalDimensions.width);
printf("Display height %i\n", displayProperties[c].physicalDimensions.height);
printf("Display horizontal resolution %i\n", displayProperties[c].physicalResolution.width);
printf("Display vertical resolution %i\n", displayProperties[c].physicalResolution.height);
}
realPhysicalDevice->customData = (uintptr_t)&ci;
uint32_t modeCount;
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, 0);
VkDisplayModePropertiesKHR* displayModeProperties = (VkDisplayModePropertiesKHR*)malloc(sizeof(VkDisplayModePropertiesKHR)*modeCount);
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, displayModeProperties);
if (vkCreateRpiSurfaceEXT(physicalDevice) != VK_SUCCESS) {
std::cerr << "failed to create window surface!" << std::endl;
assert(0);
}*/
// printf("\nEnumerated modes\n");
// for(uint32_t c = 0; c < modeCount; ++c)
// {
// printf("Mode refresh rate %i\n", displayModeProperties[c].parameters.refreshRate);
// printf("Mode width %i\n", displayModeProperties[c].parameters.visibleRegion.width);
// printf("Mode height %i\n\n", displayModeProperties[c].parameters.visibleRegion.height);
// }
VkDisplayModeCreateInfoKHR dmci = {};
dmci.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
dmci.parameters = displayModeProperties[0].parameters;
VkDisplayModeKHR displayMode;
vkCreateDisplayModeKHR(physicalDevice, displayProperties[0].display, &dmci, 0, &displayMode);
VkDisplaySurfaceCreateInfoKHR dsci = {};
dsci.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
dsci.displayMode = displayMode;
dsci.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
dsci.alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
dsci.imageExtent = displayModeProperties[0].parameters.visibleRegion;
vkCreateDisplayPlaneSurfaceKHR(instance, &dsci, 0, &windowSurface);
std::cout << "created window surface" << std::endl;
}

51
test/HDR/HDR.cpp
View File

@ -290,23 +290,50 @@ void createInstance() {
}
void createWindowSurface() {
/*PFN_vkCreateRpiSurfaceEXT vkCreateRpiSurfaceEXT = 0;
vkCreateRpiSurfaceEXT = (PFN_vkCreateRpiSurfaceEXT)vkGetInstanceProcAddr(instance, "vkCreateRpiSurfaceEXT");
windowSurface = 0;
LoaderTrampoline* trampoline = (LoaderTrampoline*)physicalDevice;
VkRpiPhysicalDevice* realPhysicalDevice = trampoline->loaderTerminator->physicalDevice;
uint32_t displayCount;
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, 0);
VkDisplayPropertiesKHR* displayProperties = (VkDisplayPropertiesKHR*)malloc(sizeof(VkDisplayPropertiesKHR)*displayCount);
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, displayProperties);
VkRpiSurfaceCreateInfoEXT ci = {};
ci.pSurface = &windowSurface;
printf("Enumerated displays\n");
for(uint32_t c = 0; c < displayCount; ++c)
{
printf("Display ID %i\n", displayProperties[c].display);
printf("Display name %s\n", displayProperties[c].displayName);
printf("Display width %i\n", displayProperties[c].physicalDimensions.width);
printf("Display height %i\n", displayProperties[c].physicalDimensions.height);
printf("Display horizontal resolution %i\n", displayProperties[c].physicalResolution.width);
printf("Display vertical resolution %i\n", displayProperties[c].physicalResolution.height);
}
realPhysicalDevice->customData = (uintptr_t)&ci;
uint32_t modeCount;
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, 0);
VkDisplayModePropertiesKHR* displayModeProperties = (VkDisplayModePropertiesKHR*)malloc(sizeof(VkDisplayModePropertiesKHR)*modeCount);
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, displayModeProperties);
if (vkCreateRpiSurfaceEXT(physicalDevice) != VK_SUCCESS) {
std::cerr << "failed to create window surface!" << std::endl;
assert(0);
}*/
// printf("\nEnumerated modes\n");
// for(uint32_t c = 0; c < modeCount; ++c)
// {
// printf("Mode refresh rate %i\n", displayModeProperties[c].parameters.refreshRate);
// printf("Mode width %i\n", displayModeProperties[c].parameters.visibleRegion.width);
// printf("Mode height %i\n\n", displayModeProperties[c].parameters.visibleRegion.height);
// }
VkDisplayModeCreateInfoKHR dmci = {};
dmci.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
dmci.parameters = displayModeProperties[0].parameters;
VkDisplayModeKHR displayMode;
vkCreateDisplayModeKHR(physicalDevice, displayProperties[0].display, &dmci, 0, &displayMode);
VkDisplaySurfaceCreateInfoKHR dsci = {};
dsci.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
dsci.displayMode = displayMode;
dsci.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
dsci.alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
dsci.imageExtent = displayModeProperties[0].parameters.visibleRegion;
vkCreateDisplayPlaneSurfaceKHR(instance, &dsci, 0, &windowSurface);
std::cout << "created window surface" << std::endl;
}

51
test/MSAA/MSAA.cpp
View File

@ -215,23 +215,50 @@ void createInstance() {
}
void createWindowSurface() {
/*PFN_vkCreateRpiSurfaceEXT vkCreateRpiSurfaceEXT = 0;
vkCreateRpiSurfaceEXT = (PFN_vkCreateRpiSurfaceEXT)vkGetInstanceProcAddr(instance, "vkCreateRpiSurfaceEXT");
windowSurface = 0;
LoaderTrampoline* trampoline = (LoaderTrampoline*)physicalDevice;
VkRpiPhysicalDevice* realPhysicalDevice = trampoline->loaderTerminator->physicalDevice;
uint32_t displayCount;
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, 0);
VkDisplayPropertiesKHR* displayProperties = (VkDisplayPropertiesKHR*)malloc(sizeof(VkDisplayPropertiesKHR)*displayCount);
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, displayProperties);
VkRpiSurfaceCreateInfoEXT ci = {};
ci.pSurface = &windowSurface;
printf("Enumerated displays\n");
for(uint32_t c = 0; c < displayCount; ++c)
{
printf("Display ID %i\n", displayProperties[c].display);
printf("Display name %s\n", displayProperties[c].displayName);
printf("Display width %i\n", displayProperties[c].physicalDimensions.width);
printf("Display height %i\n", displayProperties[c].physicalDimensions.height);
printf("Display horizontal resolution %i\n", displayProperties[c].physicalResolution.width);
printf("Display vertical resolution %i\n", displayProperties[c].physicalResolution.height);
}
realPhysicalDevice->customData = (uintptr_t)&ci;
uint32_t modeCount;
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, 0);
VkDisplayModePropertiesKHR* displayModeProperties = (VkDisplayModePropertiesKHR*)malloc(sizeof(VkDisplayModePropertiesKHR)*modeCount);
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, displayModeProperties);
if (vkCreateRpiSurfaceEXT(physicalDevice) != VK_SUCCESS) {
std::cerr << "failed to create window surface!" << std::endl;
assert(0);
}*/
// printf("\nEnumerated modes\n");
// for(uint32_t c = 0; c < modeCount; ++c)
// {
// printf("Mode refresh rate %i\n", displayModeProperties[c].parameters.refreshRate);
// printf("Mode width %i\n", displayModeProperties[c].parameters.visibleRegion.width);
// printf("Mode height %i\n\n", displayModeProperties[c].parameters.visibleRegion.height);
// }
VkDisplayModeCreateInfoKHR dmci = {};
dmci.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
dmci.parameters = displayModeProperties[0].parameters;
VkDisplayModeKHR displayMode;
vkCreateDisplayModeKHR(physicalDevice, displayProperties[0].display, &dmci, 0, &displayMode);
VkDisplaySurfaceCreateInfoKHR dsci = {};
dsci.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
dsci.displayMode = displayMode;
dsci.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
dsci.alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
dsci.imageExtent = displayModeProperties[0].parameters.visibleRegion;
vkCreateDisplayPlaneSurfaceKHR(instance, &dsci, 0, &windowSurface);
std::cout << "created window surface" << std::endl;
}

51
test/blending/blending.cpp
View File

@ -216,23 +216,50 @@ void createInstance() {
}
void createWindowSurface() {
/*PFN_vkCreateRpiSurfaceEXT vkCreateRpiSurfaceEXT = 0;
vkCreateRpiSurfaceEXT = (PFN_vkCreateRpiSurfaceEXT)vkGetInstanceProcAddr(instance, "vkCreateRpiSurfaceEXT");
windowSurface = 0;
LoaderTrampoline* trampoline = (LoaderTrampoline*)physicalDevice;
VkRpiPhysicalDevice* realPhysicalDevice = trampoline->loaderTerminator->physicalDevice;
uint32_t displayCount;
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, 0);
VkDisplayPropertiesKHR* displayProperties = (VkDisplayPropertiesKHR*)malloc(sizeof(VkDisplayPropertiesKHR)*displayCount);
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, displayProperties);
VkRpiSurfaceCreateInfoEXT ci = {};
ci.pSurface = &windowSurface;
printf("Enumerated displays\n");
for(uint32_t c = 0; c < displayCount; ++c)
{
printf("Display ID %i\n", displayProperties[c].display);
printf("Display name %s\n", displayProperties[c].displayName);
printf("Display width %i\n", displayProperties[c].physicalDimensions.width);
printf("Display height %i\n", displayProperties[c].physicalDimensions.height);
printf("Display horizontal resolution %i\n", displayProperties[c].physicalResolution.width);
printf("Display vertical resolution %i\n", displayProperties[c].physicalResolution.height);
}
realPhysicalDevice->customData = (uintptr_t)&ci;
uint32_t modeCount;
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, 0);
VkDisplayModePropertiesKHR* displayModeProperties = (VkDisplayModePropertiesKHR*)malloc(sizeof(VkDisplayModePropertiesKHR)*modeCount);
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, displayModeProperties);
if (vkCreateRpiSurfaceEXT(physicalDevice) != VK_SUCCESS) {
std::cerr << "failed to create window surface!" << std::endl;
assert(0);
}*/
// printf("\nEnumerated modes\n");
// for(uint32_t c = 0; c < modeCount; ++c)
// {
// printf("Mode refresh rate %i\n", displayModeProperties[c].parameters.refreshRate);
// printf("Mode width %i\n", displayModeProperties[c].parameters.visibleRegion.width);
// printf("Mode height %i\n\n", displayModeProperties[c].parameters.visibleRegion.height);
// }
VkDisplayModeCreateInfoKHR dmci = {};
dmci.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
dmci.parameters = displayModeProperties[0].parameters;
VkDisplayModeKHR displayMode;
vkCreateDisplayModeKHR(physicalDevice, displayProperties[0].display, &dmci, 0, &displayMode);
VkDisplaySurfaceCreateInfoKHR dsci = {};
dsci.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
dsci.displayMode = displayMode;
dsci.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
dsci.alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
dsci.imageExtent = displayModeProperties[0].parameters.visibleRegion;
vkCreateDisplayPlaneSurfaceKHR(instance, &dsci, 0, &windowSurface);
std::cout << "created window surface" << std::endl;
}

53
test/clear/clear.cpp
View File

@ -228,23 +228,50 @@ void createInstance() {
}
void createWindowSurface() {
/*PFN_vkCreateRpiSurfaceEXT vkCreateRpiSurfaceEXT = 0;
vkCreateRpiSurfaceEXT = (PFN_vkCreateRpiSurfaceEXT)vkGetInstanceProcAddr(instance, "vkCreateRpiSurfaceEXT");
windowSurface = 0;
//
LoaderTrampoline* trampoline = (LoaderTrampoline*)physicalDevice;
VkRpiPhysicalDevice* realPhysicalDevice = trampoline->loaderTerminator->physicalDevice;
VkRpiSurfaceCreateInfoEXT ci = {};
ci.pSurface = &windowSurface;
uint32_t displayCount;
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, 0);
VkDisplayPropertiesKHR* displayProperties = (VkDisplayPropertiesKHR*)malloc(sizeof(VkDisplayPropertiesKHR)*displayCount);
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, displayProperties);
realPhysicalDevice->customData = (uintptr_t)&ci;
printf("Enumerated displays\n");
for(uint32_t c = 0; c < displayCount; ++c)
{
printf("Display ID %i\n", displayProperties[c].display);
printf("Display name %s\n", displayProperties[c].displayName);
printf("Display width %i\n", displayProperties[c].physicalDimensions.width);
printf("Display height %i\n", displayProperties[c].physicalDimensions.height);
printf("Display horizontal resolution %i\n", displayProperties[c].physicalResolution.width);
printf("Display vertical resolution %i\n", displayProperties[c].physicalResolution.height);
}
if (vkCreateRpiSurfaceEXT(physicalDevice) != VK_SUCCESS) {
std::cerr << "failed to create window surface!" << std::endl;
assert(0);
}*/
uint32_t modeCount;
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, 0);
VkDisplayModePropertiesKHR* displayModeProperties = (VkDisplayModePropertiesKHR*)malloc(sizeof(VkDisplayModePropertiesKHR)*modeCount);
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, displayModeProperties);
// printf("\nEnumerated modes\n");
// for(uint32_t c = 0; c < modeCount; ++c)
// {
// printf("Mode refresh rate %i\n", displayModeProperties[c].parameters.refreshRate);
// printf("Mode width %i\n", displayModeProperties[c].parameters.visibleRegion.width);
// printf("Mode height %i\n\n", displayModeProperties[c].parameters.visibleRegion.height);
// }
VkDisplayModeCreateInfoKHR dmci = {};
dmci.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
dmci.parameters = displayModeProperties[0].parameters;
VkDisplayModeKHR displayMode;
vkCreateDisplayModeKHR(physicalDevice, displayProperties[0].display, &dmci, 0, &displayMode);
VkDisplaySurfaceCreateInfoKHR dsci = {};
dsci.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
dsci.displayMode = displayMode;
dsci.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
dsci.alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
dsci.imageExtent = displayModeProperties[0].parameters.visibleRegion;
vkCreateDisplayPlaneSurfaceKHR(instance, &dsci, 0, &windowSurface);
std::cout << "created window surface" << std::endl;
}

51
test/cubemapping/cubemapping.cpp
View File

@ -278,23 +278,50 @@ void createInstance() {
}
void createWindowSurface() {
/*PFN_vkCreateRpiSurfaceEXT vkCreateRpiSurfaceEXT = 0;
vkCreateRpiSurfaceEXT = (PFN_vkCreateRpiSurfaceEXT)vkGetInstanceProcAddr(instance, "vkCreateRpiSurfaceEXT");
windowSurface = 0;
LoaderTrampoline* trampoline = (LoaderTrampoline*)physicalDevice;
VkRpiPhysicalDevice* realPhysicalDevice = trampoline->loaderTerminator->physicalDevice;
uint32_t displayCount;
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, 0);
VkDisplayPropertiesKHR* displayProperties = (VkDisplayPropertiesKHR*)malloc(sizeof(VkDisplayPropertiesKHR)*displayCount);
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, displayProperties);
VkRpiSurfaceCreateInfoEXT ci = {};
ci.pSurface = &windowSurface;
printf("Enumerated displays\n");
for(uint32_t c = 0; c < displayCount; ++c)
{
printf("Display ID %i\n", displayProperties[c].display);
printf("Display name %s\n", displayProperties[c].displayName);
printf("Display width %i\n", displayProperties[c].physicalDimensions.width);
printf("Display height %i\n", displayProperties[c].physicalDimensions.height);
printf("Display horizontal resolution %i\n", displayProperties[c].physicalResolution.width);
printf("Display vertical resolution %i\n", displayProperties[c].physicalResolution.height);
}
realPhysicalDevice->customData = (uintptr_t)&ci;
uint32_t modeCount;
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, 0);
VkDisplayModePropertiesKHR* displayModeProperties = (VkDisplayModePropertiesKHR*)malloc(sizeof(VkDisplayModePropertiesKHR)*modeCount);
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, displayModeProperties);
if (vkCreateRpiSurfaceEXT(physicalDevice) != VK_SUCCESS) {
std::cerr << "failed to create window surface!" << std::endl;
assert(0);
}*/
// printf("\nEnumerated modes\n");
// for(uint32_t c = 0; c < modeCount; ++c)
// {
// printf("Mode refresh rate %i\n", displayModeProperties[c].parameters.refreshRate);
// printf("Mode width %i\n", displayModeProperties[c].parameters.visibleRegion.width);
// printf("Mode height %i\n\n", displayModeProperties[c].parameters.visibleRegion.height);
// }
VkDisplayModeCreateInfoKHR dmci = {};
dmci.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
dmci.parameters = displayModeProperties[0].parameters;
VkDisplayModeKHR displayMode;
vkCreateDisplayModeKHR(physicalDevice, displayProperties[0].display, &dmci, 0, &displayMode);
VkDisplaySurfaceCreateInfoKHR dsci = {};
dsci.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
dsci.displayMode = displayMode;
dsci.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
dsci.alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
dsci.imageExtent = displayModeProperties[0].parameters.visibleRegion;
vkCreateDisplayPlaneSurfaceKHR(instance, &dsci, 0, &windowSurface);
std::cout << "created window surface" << std::endl;
}

51
test/depthTest/depthTest.cpp
View File

@ -221,23 +221,50 @@ void createInstance() {
}
void createWindowSurface() {
/*PFN_vkCreateRpiSurfaceEXT vkCreateRpiSurfaceEXT = 0;
vkCreateRpiSurfaceEXT = (PFN_vkCreateRpiSurfaceEXT)vkGetInstanceProcAddr(instance, "vkCreateRpiSurfaceEXT");
windowSurface = 0;
LoaderTrampoline* trampoline = (LoaderTrampoline*)physicalDevice;
VkRpiPhysicalDevice* realPhysicalDevice = trampoline->loaderTerminator->physicalDevice;
uint32_t displayCount;
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, 0);
VkDisplayPropertiesKHR* displayProperties = (VkDisplayPropertiesKHR*)malloc(sizeof(VkDisplayPropertiesKHR)*displayCount);
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, displayProperties);
VkRpiSurfaceCreateInfoEXT ci = {};
ci.pSurface = &windowSurface;
printf("Enumerated displays\n");
for(uint32_t c = 0; c < displayCount; ++c)
{
printf("Display ID %i\n", displayProperties[c].display);
printf("Display name %s\n", displayProperties[c].displayName);
printf("Display width %i\n", displayProperties[c].physicalDimensions.width);
printf("Display height %i\n", displayProperties[c].physicalDimensions.height);
printf("Display horizontal resolution %i\n", displayProperties[c].physicalResolution.width);
printf("Display vertical resolution %i\n", displayProperties[c].physicalResolution.height);
}
realPhysicalDevice->customData = (uintptr_t)&ci;
uint32_t modeCount;
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, 0);
VkDisplayModePropertiesKHR* displayModeProperties = (VkDisplayModePropertiesKHR*)malloc(sizeof(VkDisplayModePropertiesKHR)*modeCount);
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, displayModeProperties);
if (vkCreateRpiSurfaceEXT(physicalDevice) != VK_SUCCESS) {
std::cerr << "failed to create window surface!" << std::endl;
assert(0);
}*/
// printf("\nEnumerated modes\n");
// for(uint32_t c = 0; c < modeCount; ++c)
// {
// printf("Mode refresh rate %i\n", displayModeProperties[c].parameters.refreshRate);
// printf("Mode width %i\n", displayModeProperties[c].parameters.visibleRegion.width);
// printf("Mode height %i\n\n", displayModeProperties[c].parameters.visibleRegion.height);
// }
VkDisplayModeCreateInfoKHR dmci = {};
dmci.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
dmci.parameters = displayModeProperties[0].parameters;
VkDisplayModeKHR displayMode;
vkCreateDisplayModeKHR(physicalDevice, displayProperties[0].display, &dmci, 0, &displayMode);
VkDisplaySurfaceCreateInfoKHR dsci = {};
dsci.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
dsci.displayMode = displayMode;
dsci.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
dsci.alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
dsci.imageExtent = displayModeProperties[0].parameters.visibleRegion;
vkCreateDisplayPlaneSurfaceKHR(instance, &dsci, 0, &windowSurface);
std::cout << "created window surface" << std::endl;
}

51
test/depthTex/depthTex.cpp
View File

@ -278,23 +278,50 @@ void createInstance() {
}
void createWindowSurface() {
/*PFN_vkCreateRpiSurfaceEXT vkCreateRpiSurfaceEXT = 0;
vkCreateRpiSurfaceEXT = (PFN_vkCreateRpiSurfaceEXT)vkGetInstanceProcAddr(instance, "vkCreateRpiSurfaceEXT");
windowSurface = 0;
LoaderTrampoline* trampoline = (LoaderTrampoline*)physicalDevice;
VkRpiPhysicalDevice* realPhysicalDevice = trampoline->loaderTerminator->physicalDevice;
uint32_t displayCount;
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, 0);
VkDisplayPropertiesKHR* displayProperties = (VkDisplayPropertiesKHR*)malloc(sizeof(VkDisplayPropertiesKHR)*displayCount);
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, displayProperties);
VkRpiSurfaceCreateInfoEXT ci = {};
ci.pSurface = &windowSurface;
printf("Enumerated displays\n");
for(uint32_t c = 0; c < displayCount; ++c)
{
printf("Display ID %i\n", displayProperties[c].display);
printf("Display name %s\n", displayProperties[c].displayName);
printf("Display width %i\n", displayProperties[c].physicalDimensions.width);
printf("Display height %i\n", displayProperties[c].physicalDimensions.height);
printf("Display horizontal resolution %i\n", displayProperties[c].physicalResolution.width);
printf("Display vertical resolution %i\n", displayProperties[c].physicalResolution.height);
}
realPhysicalDevice->customData = (uintptr_t)&ci;
uint32_t modeCount;
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, 0);
VkDisplayModePropertiesKHR* displayModeProperties = (VkDisplayModePropertiesKHR*)malloc(sizeof(VkDisplayModePropertiesKHR)*modeCount);
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, displayModeProperties);
if (vkCreateRpiSurfaceEXT(physicalDevice) != VK_SUCCESS) {
std::cerr << "failed to create window surface!" << std::endl;
assert(0);
}*/
// printf("\nEnumerated modes\n");
// for(uint32_t c = 0; c < modeCount; ++c)
// {
// printf("Mode refresh rate %i\n", displayModeProperties[c].parameters.refreshRate);
// printf("Mode width %i\n", displayModeProperties[c].parameters.visibleRegion.width);
// printf("Mode height %i\n\n", displayModeProperties[c].parameters.visibleRegion.height);
// }
VkDisplayModeCreateInfoKHR dmci = {};
dmci.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
dmci.parameters = displayModeProperties[0].parameters;
VkDisplayModeKHR displayMode;
vkCreateDisplayModeKHR(physicalDevice, displayProperties[0].display, &dmci, 0, &displayMode);
VkDisplaySurfaceCreateInfoKHR dsci = {};
dsci.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
dsci.displayMode = displayMode;
dsci.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
dsci.alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
dsci.imageExtent = displayModeProperties[0].parameters.visibleRegion;
vkCreateDisplayPlaneSurfaceKHR(instance, &dsci, 0, &windowSurface);
std::cout << "created window surface" << std::endl;
}

51
test/indexedTriangle/indexedTriangle.cpp
View File

@ -214,23 +214,50 @@ void createInstance() {
}
void createWindowSurface() {
/*PFN_vkCreateRpiSurfaceEXT vkCreateRpiSurfaceEXT = 0;
vkCreateRpiSurfaceEXT = (PFN_vkCreateRpiSurfaceEXT)vkGetInstanceProcAddr(instance, "vkCreateRpiSurfaceEXT");
windowSurface = 0;
LoaderTrampoline* trampoline = (LoaderTrampoline*)physicalDevice;
VkRpiPhysicalDevice* realPhysicalDevice = trampoline->loaderTerminator->physicalDevice;
uint32_t displayCount;
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, 0);
VkDisplayPropertiesKHR* displayProperties = (VkDisplayPropertiesKHR*)malloc(sizeof(VkDisplayPropertiesKHR)*displayCount);
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, displayProperties);
VkRpiSurfaceCreateInfoEXT ci = {};
ci.pSurface = &windowSurface;
printf("Enumerated displays\n");
for(uint32_t c = 0; c < displayCount; ++c)
{
printf("Display ID %i\n", displayProperties[c].display);
printf("Display name %s\n", displayProperties[c].displayName);
printf("Display width %i\n", displayProperties[c].physicalDimensions.width);
printf("Display height %i\n", displayProperties[c].physicalDimensions.height);
printf("Display horizontal resolution %i\n", displayProperties[c].physicalResolution.width);
printf("Display vertical resolution %i\n", displayProperties[c].physicalResolution.height);
}
realPhysicalDevice->customData = (uintptr_t)&ci;
uint32_t modeCount;
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, 0);
VkDisplayModePropertiesKHR* displayModeProperties = (VkDisplayModePropertiesKHR*)malloc(sizeof(VkDisplayModePropertiesKHR)*modeCount);
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, displayModeProperties);
if (vkCreateRpiSurfaceEXT(physicalDevice) != VK_SUCCESS) {
std::cerr << "failed to create window surface!" << std::endl;
assert(0);
}*/
// printf("\nEnumerated modes\n");
// for(uint32_t c = 0; c < modeCount; ++c)
// {
// printf("Mode refresh rate %i\n", displayModeProperties[c].parameters.refreshRate);
// printf("Mode width %i\n", displayModeProperties[c].parameters.visibleRegion.width);
// printf("Mode height %i\n\n", displayModeProperties[c].parameters.visibleRegion.height);
// }
VkDisplayModeCreateInfoKHR dmci = {};
dmci.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
dmci.parameters = displayModeProperties[0].parameters;
VkDisplayModeKHR displayMode;
vkCreateDisplayModeKHR(physicalDevice, displayProperties[0].display, &dmci, 0, &displayMode);
VkDisplaySurfaceCreateInfoKHR dsci = {};
dsci.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
dsci.displayMode = displayMode;
dsci.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
dsci.alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
dsci.imageExtent = displayModeProperties[0].parameters.visibleRegion;
vkCreateDisplayPlaneSurfaceKHR(instance, &dsci, 0, &windowSurface);
std::cout << "created window surface" << std::endl;
}

51
test/mipmapping/mipmapping.cpp
View File

@ -281,23 +281,50 @@ void createInstance() {
}
void createWindowSurface() {
/*PFN_vkCreateRpiSurfaceEXT vkCreateRpiSurfaceEXT = 0;
vkCreateRpiSurfaceEXT = (PFN_vkCreateRpiSurfaceEXT)vkGetInstanceProcAddr(instance, "vkCreateRpiSurfaceEXT");
windowSurface = 0;
LoaderTrampoline* trampoline = (LoaderTrampoline*)physicalDevice;
VkRpiPhysicalDevice* realPhysicalDevice = trampoline->loaderTerminator->physicalDevice;
uint32_t displayCount;
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, 0);
VkDisplayPropertiesKHR* displayProperties = (VkDisplayPropertiesKHR*)malloc(sizeof(VkDisplayPropertiesKHR)*displayCount);
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, displayProperties);
VkRpiSurfaceCreateInfoEXT ci = {};
ci.pSurface = &windowSurface;
printf("Enumerated displays\n");
for(uint32_t c = 0; c < displayCount; ++c)
{
printf("Display ID %i\n", displayProperties[c].display);
printf("Display name %s\n", displayProperties[c].displayName);
printf("Display width %i\n", displayProperties[c].physicalDimensions.width);
printf("Display height %i\n", displayProperties[c].physicalDimensions.height);
printf("Display horizontal resolution %i\n", displayProperties[c].physicalResolution.width);
printf("Display vertical resolution %i\n", displayProperties[c].physicalResolution.height);
}
realPhysicalDevice->customData = (uintptr_t)&ci;
uint32_t modeCount;
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, 0);
VkDisplayModePropertiesKHR* displayModeProperties = (VkDisplayModePropertiesKHR*)malloc(sizeof(VkDisplayModePropertiesKHR)*modeCount);
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, displayModeProperties);
if (vkCreateRpiSurfaceEXT(physicalDevice) != VK_SUCCESS) {
std::cerr << "failed to create window surface!" << std::endl;
assert(0);
}*/
// printf("\nEnumerated modes\n");
// for(uint32_t c = 0; c < modeCount; ++c)
// {
// printf("Mode refresh rate %i\n", displayModeProperties[c].parameters.refreshRate);
// printf("Mode width %i\n", displayModeProperties[c].parameters.visibleRegion.width);
// printf("Mode height %i\n\n", displayModeProperties[c].parameters.visibleRegion.height);
// }
VkDisplayModeCreateInfoKHR dmci = {};
dmci.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
dmci.parameters = displayModeProperties[0].parameters;
VkDisplayModeKHR displayMode;
vkCreateDisplayModeKHR(physicalDevice, displayProperties[0].display, &dmci, 0, &displayMode);
VkDisplaySurfaceCreateInfoKHR dsci = {};
dsci.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
dsci.displayMode = displayMode;
dsci.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
dsci.alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
dsci.imageExtent = displayModeProperties[0].parameters.visibleRegion;
vkCreateDisplayPlaneSurfaceKHR(instance, &dsci, 0, &windowSurface);
std::cout << "created window surface" << std::endl;
}

51
test/query/query.cpp
View File

@ -245,23 +245,50 @@ void createInstance() {
}
void createWindowSurface() {
/*PFN_vkCreateRpiSurfaceEXT vkCreateRpiSurfaceEXT = 0;
vkCreateRpiSurfaceEXT = (PFN_vkCreateRpiSurfaceEXT)vkGetInstanceProcAddr(instance, "vkCreateRpiSurfaceEXT");
windowSurface = 0;
LoaderTrampoline* trampoline = (LoaderTrampoline*)physicalDevice;
VkRpiPhysicalDevice* realPhysicalDevice = trampoline->loaderTerminator->physicalDevice;
uint32_t displayCount;
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, 0);
VkDisplayPropertiesKHR* displayProperties = (VkDisplayPropertiesKHR*)malloc(sizeof(VkDisplayPropertiesKHR)*displayCount);
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, displayProperties);
VkRpiSurfaceCreateInfoEXT ci = {};
ci.pSurface = &windowSurface;
printf("Enumerated displays\n");
for(uint32_t c = 0; c < displayCount; ++c)
{
printf("Display ID %i\n", displayProperties[c].display);
printf("Display name %s\n", displayProperties[c].displayName);
printf("Display width %i\n", displayProperties[c].physicalDimensions.width);
printf("Display height %i\n", displayProperties[c].physicalDimensions.height);
printf("Display horizontal resolution %i\n", displayProperties[c].physicalResolution.width);
printf("Display vertical resolution %i\n", displayProperties[c].physicalResolution.height);
}
realPhysicalDevice->customData = (uintptr_t)&ci;
uint32_t modeCount;
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, 0);
VkDisplayModePropertiesKHR* displayModeProperties = (VkDisplayModePropertiesKHR*)malloc(sizeof(VkDisplayModePropertiesKHR)*modeCount);
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, displayModeProperties);
if (vkCreateRpiSurfaceEXT(physicalDevice) != VK_SUCCESS) {
std::cerr << "failed to create window surface!" << std::endl;
assert(0);
}*/
// printf("\nEnumerated modes\n");
// for(uint32_t c = 0; c < modeCount; ++c)
// {
// printf("Mode refresh rate %i\n", displayModeProperties[c].parameters.refreshRate);
// printf("Mode width %i\n", displayModeProperties[c].parameters.visibleRegion.width);
// printf("Mode height %i\n\n", displayModeProperties[c].parameters.visibleRegion.height);
// }
VkDisplayModeCreateInfoKHR dmci = {};
dmci.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
dmci.parameters = displayModeProperties[0].parameters;
VkDisplayModeKHR displayMode;
vkCreateDisplayModeKHR(physicalDevice, displayProperties[0].display, &dmci, 0, &displayMode);
VkDisplaySurfaceCreateInfoKHR dsci = {};
dsci.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
dsci.displayMode = displayMode;
dsci.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
dsci.alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
dsci.imageExtent = displayModeProperties[0].parameters.visibleRegion;
vkCreateDisplayPlaneSurfaceKHR(instance, &dsci, 0, &windowSurface);
std::cout << "created window surface" << std::endl;
}

51
test/stencilTest/stencilTest.cpp
View File

@ -223,23 +223,50 @@ void createInstance() {
}
void createWindowSurface() {
/*PFN_vkCreateRpiSurfaceEXT vkCreateRpiSurfaceEXT = 0;
vkCreateRpiSurfaceEXT = (PFN_vkCreateRpiSurfaceEXT)vkGetInstanceProcAddr(instance, "vkCreateRpiSurfaceEXT");
windowSurface = 0;
LoaderTrampoline* trampoline = (LoaderTrampoline*)physicalDevice;
VkRpiPhysicalDevice* realPhysicalDevice = trampoline->loaderTerminator->physicalDevice;
uint32_t displayCount;
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, 0);
VkDisplayPropertiesKHR* displayProperties = (VkDisplayPropertiesKHR*)malloc(sizeof(VkDisplayPropertiesKHR)*displayCount);
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, displayProperties);
VkRpiSurfaceCreateInfoEXT ci = {};
ci.pSurface = &windowSurface;
printf("Enumerated displays\n");
for(uint32_t c = 0; c < displayCount; ++c)
{
printf("Display ID %i\n", displayProperties[c].display);
printf("Display name %s\n", displayProperties[c].displayName);
printf("Display width %i\n", displayProperties[c].physicalDimensions.width);
printf("Display height %i\n", displayProperties[c].physicalDimensions.height);
printf("Display horizontal resolution %i\n", displayProperties[c].physicalResolution.width);
printf("Display vertical resolution %i\n", displayProperties[c].physicalResolution.height);
}
realPhysicalDevice->customData = (uintptr_t)&ci;
uint32_t modeCount;
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, 0);
VkDisplayModePropertiesKHR* displayModeProperties = (VkDisplayModePropertiesKHR*)malloc(sizeof(VkDisplayModePropertiesKHR)*modeCount);
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, displayModeProperties);
if (vkCreateRpiSurfaceEXT(physicalDevice) != VK_SUCCESS) {
std::cerr << "failed to create window surface!" << std::endl;
assert(0);
}*/
// printf("\nEnumerated modes\n");
// for(uint32_t c = 0; c < modeCount; ++c)
// {
// printf("Mode refresh rate %i\n", displayModeProperties[c].parameters.refreshRate);
// printf("Mode width %i\n", displayModeProperties[c].parameters.visibleRegion.width);
// printf("Mode height %i\n\n", displayModeProperties[c].parameters.visibleRegion.height);
// }
VkDisplayModeCreateInfoKHR dmci = {};
dmci.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
dmci.parameters = displayModeProperties[0].parameters;
VkDisplayModeKHR displayMode;
vkCreateDisplayModeKHR(physicalDevice, displayProperties[0].display, &dmci, 0, &displayMode);
VkDisplaySurfaceCreateInfoKHR dsci = {};
dsci.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
dsci.displayMode = displayMode;
dsci.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
dsci.alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
dsci.imageExtent = displayModeProperties[0].parameters.visibleRegion;
vkCreateDisplayPlaneSurfaceKHR(instance, &dsci, 0, &windowSurface);
std::cout << "created window surface" << std::endl;
}

51
test/texturing/texturing.cpp
View File

@ -278,23 +278,50 @@ void createInstance() {
}
void createWindowSurface() {
/*PFN_vkCreateRpiSurfaceEXT vkCreateRpiSurfaceEXT = 0;
vkCreateRpiSurfaceEXT = (PFN_vkCreateRpiSurfaceEXT)vkGetInstanceProcAddr(instance, "vkCreateRpiSurfaceEXT");
windowSurface = 0;
LoaderTrampoline* trampoline = (LoaderTrampoline*)physicalDevice;
VkRpiPhysicalDevice* realPhysicalDevice = trampoline->loaderTerminator->physicalDevice;
uint32_t displayCount;
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, 0);
VkDisplayPropertiesKHR* displayProperties = (VkDisplayPropertiesKHR*)malloc(sizeof(VkDisplayPropertiesKHR)*displayCount);
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, displayProperties);
VkRpiSurfaceCreateInfoEXT ci = {};
ci.pSurface = &windowSurface;
printf("Enumerated displays\n");
for(uint32_t c = 0; c < displayCount; ++c)
{
printf("Display ID %i\n", displayProperties[c].display);
printf("Display name %s\n", displayProperties[c].displayName);
printf("Display width %i\n", displayProperties[c].physicalDimensions.width);
printf("Display height %i\n", displayProperties[c].physicalDimensions.height);
printf("Display horizontal resolution %i\n", displayProperties[c].physicalResolution.width);
printf("Display vertical resolution %i\n", displayProperties[c].physicalResolution.height);
}
realPhysicalDevice->customData = (uintptr_t)&ci;
uint32_t modeCount;
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, 0);
VkDisplayModePropertiesKHR* displayModeProperties = (VkDisplayModePropertiesKHR*)malloc(sizeof(VkDisplayModePropertiesKHR)*modeCount);
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, displayModeProperties);
if (vkCreateRpiSurfaceEXT(physicalDevice) != VK_SUCCESS) {
std::cerr << "failed to create window surface!" << std::endl;
assert(0);
}*/
// printf("\nEnumerated modes\n");
// for(uint32_t c = 0; c < modeCount; ++c)
// {
// printf("Mode refresh rate %i\n", displayModeProperties[c].parameters.refreshRate);
// printf("Mode width %i\n", displayModeProperties[c].parameters.visibleRegion.width);
// printf("Mode height %i\n\n", displayModeProperties[c].parameters.visibleRegion.height);
// }
VkDisplayModeCreateInfoKHR dmci = {};
dmci.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
dmci.parameters = displayModeProperties[0].parameters;
VkDisplayModeKHR displayMode;
vkCreateDisplayModeKHR(physicalDevice, displayProperties[0].display, &dmci, 0, &displayMode);
VkDisplaySurfaceCreateInfoKHR dsci = {};
dsci.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
dsci.displayMode = displayMode;
dsci.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
dsci.alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
dsci.imageExtent = displayModeProperties[0].parameters.visibleRegion;
vkCreateDisplayPlaneSurfaceKHR(instance, &dsci, 0, &windowSurface);
std::cout << "created window surface" << std::endl;
}

18
test/triangle/triangle.cpp
View File

@ -148,7 +148,7 @@ void setupVulkan() {
void mainLoop() {
//while (!glfwWindowShouldClose(window)) {
for(int c = 0; c < 30; ++c){
for(int c = 0; c < 300; ++c){
draw();
//glfwPollEvents();
@ -214,22 +214,6 @@ void createInstance() {
void createWindowSurface() {
windowSurface = 0;
/*PFN_vkCreateRpiSurfaceEXT vkCreateRpiSurfaceEXT = 0;
vkCreateRpiSurfaceEXT = (PFN_vkCreateRpiSurfaceEXT)vkGetInstanceProcAddr(instance, "vkCreateRpiSurfaceEXT");
LoaderTrampoline* trampoline = (LoaderTrampoline*)physicalDevice;
VkRpiPhysicalDevice* realPhysicalDevice = trampoline->loaderTerminator->physicalDevice;
VkRpiSurfaceCreateInfoEXT ci = {};
ci.pSurface = &windowSurface;
realPhysicalDevice->customData = (uintptr_t)&ci;
if (vkCreateRpiSurfaceEXT(physicalDevice) != VK_SUCCESS) {
std::cerr << "failed to create window surface!" << std::endl;
assert(0);
}*/
uint32_t displayCount;
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, 0);
VkDisplayPropertiesKHR* displayProperties = (VkDisplayPropertiesKHR*)malloc(sizeof(VkDisplayPropertiesKHR)*displayCount);

51
test/varyings/varyings.cpp
View File

@ -212,23 +212,50 @@ void createInstance() {
}
void createWindowSurface() {
/*PFN_vkCreateRpiSurfaceEXT vkCreateRpiSurfaceEXT = 0;
vkCreateRpiSurfaceEXT = (PFN_vkCreateRpiSurfaceEXT)vkGetInstanceProcAddr(instance, "vkCreateRpiSurfaceEXT");
windowSurface = 0;
LoaderTrampoline* trampoline = (LoaderTrampoline*)physicalDevice;
VkRpiPhysicalDevice* realPhysicalDevice = trampoline->loaderTerminator->physicalDevice;
uint32_t displayCount;
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, 0);
VkDisplayPropertiesKHR* displayProperties = (VkDisplayPropertiesKHR*)malloc(sizeof(VkDisplayPropertiesKHR)*displayCount);
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayCount, displayProperties);
VkRpiSurfaceCreateInfoEXT ci = {};
ci.pSurface = &windowSurface;
printf("Enumerated displays\n");
for(uint32_t c = 0; c < displayCount; ++c)
{
printf("Display ID %i\n", displayProperties[c].display);
printf("Display name %s\n", displayProperties[c].displayName);
printf("Display width %i\n", displayProperties[c].physicalDimensions.width);
printf("Display height %i\n", displayProperties[c].physicalDimensions.height);
printf("Display horizontal resolution %i\n", displayProperties[c].physicalResolution.width);
printf("Display vertical resolution %i\n", displayProperties[c].physicalResolution.height);
}
realPhysicalDevice->customData = (uintptr_t)&ci;
uint32_t modeCount;
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, 0);
VkDisplayModePropertiesKHR* displayModeProperties = (VkDisplayModePropertiesKHR*)malloc(sizeof(VkDisplayModePropertiesKHR)*modeCount);
vkGetDisplayModePropertiesKHR(physicalDevice, displayProperties[0].display, &modeCount, displayModeProperties);
if (vkCreateRpiSurfaceEXT(physicalDevice) != VK_SUCCESS) {
std::cerr << "failed to create window surface!" << std::endl;
assert(0);
}*/
// printf("\nEnumerated modes\n");
// for(uint32_t c = 0; c < modeCount; ++c)
// {
// printf("Mode refresh rate %i\n", displayModeProperties[c].parameters.refreshRate);
// printf("Mode width %i\n", displayModeProperties[c].parameters.visibleRegion.width);
// printf("Mode height %i\n\n", displayModeProperties[c].parameters.visibleRegion.height);
// }
VkDisplayModeCreateInfoKHR dmci = {};
dmci.sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
dmci.parameters = displayModeProperties[0].parameters;
VkDisplayModeKHR displayMode;
vkCreateDisplayModeKHR(physicalDevice, displayProperties[0].display, &dmci, 0, &displayMode);
VkDisplaySurfaceCreateInfoKHR dsci = {};
dsci.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
dsci.displayMode = displayMode;
dsci.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
dsci.alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
dsci.imageExtent = displayModeProperties[0].parameters.visibleRegion;
vkCreateDisplayPlaneSurfaceKHR(instance, &dsci, 0, &windowSurface);
std::cout << "created window surface" << std::endl;
}