PROJECT(vkvg VERSION 0.3.0 DESCRIPTION "Vulkan Vector Graphic")
ADD_COMPILE_DEFINITIONS(
- "VKVG_VERSION_MAJOR=${vkvg_VERSION_MAJOR}"
- "VKVG_VERSION_MINOR=${vkvg_VERSION_MINOR}"
- "VKVG_VERSION_REVISION=${vkvg_VERSION_PATCH}"
+ "VKVG_VERSION_MAJOR=${vkvg_VERSION_MAJOR}"
+ "VKVG_VERSION_MINOR=${vkvg_VERSION_MINOR}"
+ "VKVG_VERSION_REVISION=${vkvg_VERSION_PATCH}"
)
INCLUDE(CheckSymbolExists)
ENDIF()
IF (VKVG_USE_GLUTESS)
- ADD_DEFINITIONS (-DVKVG_FILL_NZ_GLUTESS)
- ADD_SUBDIRECTORY (external/glutess)
+ ADD_DEFINITIONS (-DVKVG_FILL_NZ_GLUTESS)
+ ADD_SUBDIRECTORY (external/glutess)
ENDIF ()
FILE(GLOB VKVG_SRC src/*.c src/deps/*.c)
+FILE(GLOB VKVG_HEADERS src/*.h)
SET (VKVG_PUBLIC_HEADERS "include/vkvg.h;include/vkvg-svg.h")
IF (VKVG_SVG)
- ADD_DEFINITIONS (-DVKVG_SVG)
- FILE(GLOB SVG_SRC external/vkvg-svg/src/*.c)
+ ADD_DEFINITIONS (-DVKVG_SVG)
+ FILE(GLOB SVG_SRC external/vkvg-svg/src/*.c)
ELSE()
- FILE(GLOB SVG_SRC src/nsvg/*.c)
+ FILE(GLOB SVG_SRC src/nsvg/*.c)
ENDIF()
LIST (APPEND VKVG_SRC ${SVG_SRC})
IF (VKVG_RECORDING)
- ADD_DEFINITIONS (-DVKVG_RECORDING)
- FILE(GLOB RECORDING_SRC src/recording/*.c)
- LIST (APPEND VKVG_SRC ${RECORDING_SRC})
+ ADD_DEFINITIONS (-DVKVG_RECORDING)
+ FILE(GLOB RECORDING_SRC src/recording/*.c)
+ LIST (APPEND VKVG_SRC ${RECORDING_SRC})
ENDIF()
CONFIGURE_FILE(vkvg.pc.in vkvg.pc @ONLY)
SOURCE_GROUP(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${VKVG_SRC})
-ADD_LIBRARY("${PROJECT_NAME}" ${VKVG_SRC})
+
+ADD_LIBRARY("${PROJECT_NAME}" ${VKVG_SRC} ${VKVG_HEADERS})
SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES
OUTPUT_NAME ${PROJECT_NAME}
)
IF (UNIX AND BUILD_SHARED_LIBS)
- #make libm public for shared build to solve libm missing for common_test object lib linking even
- #if -lm present on cc command.
- TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PUBLIC m)
+ #make libm public for shared build to solve libm missing for common_test object lib linking even
+ #if -lm present on cc command.
+ TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PUBLIC m)
ENDIF()
IF(VKVG_USE_FREETYPE)
- TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PUBLIC ${FREETYPE_LIBRARY})
+ TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PUBLIC ${FREETYPE_LIBRARY})
ENDIF()
IF(VKVG_USE_FONTCONFIG)
- TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PRIVATE ${Fontconfig_LIBRARIES})
+ TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PRIVATE ${Fontconfig_LIBRARIES})
ENDIF()
IF(VKVG_USE_HARFBUZZ)
- TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PRIVATE ${HarfBuzz_LIBRARIES})
+ TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PRIVATE ${HarfBuzz_LIBRARIES})
ENDIF()
IF(VKVG_USE_GLUTESS)
- TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PRIVATE glutess)
+ TARGET_LINK_LIBRARIES("${PROJECT_NAME}" PRIVATE glutess)
ENDIF()
TARGET_LINK_LIBRARIES("${PROJECT_NAME}"
- PUBLIC
- ${Vulkan_LIBRARIES}
- vkh
+ PUBLIC
+ ${Vulkan_LIBRARIES}
+ vkh
)
IF (SHADERS_H)
- ADD_DEPENDENCIES("${PROJECT_NAME}" BuildShadersHeader)
+ ADD_DEPENDENCIES("${PROJECT_NAME}" BuildShadersHeader)
ENDIF()
INSTALL(TARGETS "${PROJECT_NAME}" "${PROJECT_NAME}"
- LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
- RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
- ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
- PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+ LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+ RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+ ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+ PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
IF (VKVG_BUILD_TESTS)
- ADD_SUBDIRECTORY(tests)
+ ADD_SUBDIRECTORY(tests)
ELSEIF (VKVG_BUILD_OFFSCREEN_TEST)
- ADD_EXECUTABLE(test_offscreen "${CMAKE_CURRENT_SOURCE_DIR}/tests/offscreen.c")
- TARGET_INCLUDE_DIRECTORIES(test_offscreen PRIVATE
- ${Vulkan_INCLUDE_DIRS}
- ${CMAKE_CURRENT_SOURCE_DIR}/include
- )
- TARGET_LINK_LIBRARIES(test_offscreen
- vkvg
- ${Vulkan_LIBRARIES}
- )
+ ADD_EXECUTABLE(test_offscreen "${CMAKE_CURRENT_SOURCE_DIR}/tests/offscreen.c")
+ TARGET_INCLUDE_DIRECTORIES(test_offscreen PRIVATE
+ ${Vulkan_INCLUDE_DIRS}
+ ${CMAKE_CURRENT_SOURCE_DIR}/include
+ )
+ TARGET_LINK_LIBRARIES(test_offscreen
+ vkvg
+ ${Vulkan_LIBRARIES}
+ )
ENDIF (VKVG_BUILD_TESTS)
IF (VKVG_BUILD_DOCS)
basicDraw.cpp
drawTestBase.cpp
drawTestBase.h
+ imageDraw.cpp
+ matrices.cpp
+ patternDraw.cpp
)
target_compile_definitions("${PROJECT_NAME}" PUBLIC
GTEST_PNG_ROOT="${GTEST_PNG_ROOT}"
vkvg_destroy(ctx);
EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_device_status(dev));
EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_surface_status(surf));
- EXPECT_EQ(0, vkvg_get_reference_count(ctx));
+ //EXPECT_EQ(0, vkvg_get_reference_count(ctx));
EXPECT_EQ(1, vkvg_surface_get_reference_count(surf));
EXPECT_EQ(2, vkvg_device_get_reference_count(dev));
}
EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_device_status(dev));
vkvg_device_destroy(dev);
- EXPECT_EQ(0, vkvg_device_get_reference_count(dev));
+ //EXPECT_EQ(0, vkvg_device_get_reference_count(dev));
}
/*TEST(Device, GetVulkanRequirements)
--- /dev/null
+#include "drawTestBase.h"
+
+class ImageDrawTest : public DrawTestBase {
+
+ protected:
+ fs::path imgPath = fs::path(GTEST_DATA_ROOT) / "miroir2.png";
+ VkvgSurface imgSurf;
+
+ void SetUp() override {
+ surf = vkvg_surface_create(dev, 512, 512);
+ imgSurf = vkvg_surface_create_from_image(dev, (char*)imgPath.c_str());
+ }
+ void TearDown() override {
+ vkvg_surface_destroy(imgSurf);
+ DrawTestBase::TearDown();
+ }
+};
+TEST_F(ImageDrawTest, References) {
+ EXPECT_EQ(VKVG_STATUS_NULL_POINTER, vkvg_surface_status(NULL));
+ EXPECT_EQ(0, vkvg_surface_get_reference_count(NULL));
+ EXPECT_NO_FATAL_FAILURE(vkvg_surface_reference(NULL));
+
+ VkvgSurface surf2 = vkvg_surface_create_from_image(NULL, NULL);
+ EXPECT_EQ(VKVG_STATUS_NULL_POINTER, vkvg_surface_status(surf2));
+ surf2 = vkvg_surface_create_from_image(dev, NULL);
+ EXPECT_EQ(VKVG_STATUS_NULL_POINTER, vkvg_surface_status(surf2));
+
+ uint32_t devRefCntInit = vkvg_device_get_reference_count(dev);
+
+ surf2 = vkvg_surface_create_from_image(dev, (char*)imgPath.c_str());
+ EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_surface_status(surf2));
+ EXPECT_EQ(1, vkvg_surface_get_reference_count(surf2));
+ EXPECT_EQ(devRefCntInit + 1, vkvg_device_get_reference_count(dev));
+ EXPECT_EQ(285, vkvg_surface_get_width(surf2));
+ EXPECT_EQ(285, vkvg_surface_get_height(surf2));
+
+ vkvg_surface_reference(surf2);
+ EXPECT_EQ(2, vkvg_surface_get_reference_count(surf2));
+
+ vkvg_surface_destroy(surf2);
+
+ EXPECT_EQ(1, vkvg_surface_get_reference_count(surf2));
+ vkvg_surface_destroy(surf2);
+ //EXPECT_EQ(NULL, surf2);
+ EXPECT_EQ(devRefCntInit, vkvg_device_get_reference_count(dev));
+}
+
+TEST_F(ImageDrawTest, PaintImage) {
+ VkvgContext ctx = vkvg_create(surf);
+ vkvg_set_source_surface(ctx, imgSurf, 0, 0);
+ EXPECT_EQ(2, vkvg_surface_get_reference_count(imgSurf));
+ vkvg_paint(ctx);
+ vkvg_destroy(ctx);
+ EXPECT_EQ(1, vkvg_surface_get_reference_count(imgSurf));
+
+ compareWithRefImage();
+}
+TEST_F(ImageDrawTest, PaintImageOffset) {
+ VkvgContext ctx = vkvg_create(surf);
+ vkvg_set_source_rgb(ctx, 0.5f, 0.5f, 0.5f);
+ vkvg_paint(ctx);
+
+ vkvg_set_source_surface(ctx, imgSurf, 50, 50);
+ vkvg_paint(ctx);
+ vkvg_destroy(ctx);
+
+ compareWithRefImage();
+}
+TEST_F(ImageDrawTest, PaintImageRotateOffset) {
+ VkvgContext ctx = vkvg_create(surf);
+ vkvg_set_source_rgb(ctx, 0.5f, 0.5f, 0.5f);
+ vkvg_paint(ctx);
+
+ vkvg_rotate(ctx, 1.2f);
+ vkvg_set_source_surface(ctx, imgSurf, 100, 100);
+ vkvg_paint(ctx);
+ vkvg_destroy(ctx);
+
+ compareWithRefImage();
+}
+TEST_F(ImageDrawTest, PaintImageRotateInPlace) {
+ VkvgContext ctx = vkvg_create(surf);
+ vkvg_set_source_rgb(ctx, 0.5f, 0.5f, 0.5f);
+ vkvg_paint(ctx);
+ vkvg_matrix_t mat;
+ vkvg_matrix_init_translate(&mat, 142,142);
+ vkvg_matrix_rotate(&mat,0.1f);
+ vkvg_matrix_init_translate(&mat, -142,-142);
+
+ vkvg_set_source_surface(ctx, imgSurf, 50, 50);
+ vkvg_set_matrix(ctx, &mat);
+ vkvg_paint(ctx);
+ vkvg_destroy(ctx);
+
+ compareWithRefImage();
+}
+
+TEST_F(ImageDrawTest, PaintImageTransform) {
+ VkvgContext ctx = vkvg_create(surf);
+ vkvg_set_source_rgb(ctx, 0.5f, 0.5f, 0.5f);
+ vkvg_paint(ctx);
+
+ fs::path imgPath = fs::path(GTEST_DATA_ROOT) / "miroir2-64.png";
+ VkvgSurface imgSurf = vkvg_surface_create_from_image(dev, (char*)imgPath.c_str());
+
+ vkvg_translate(ctx, 10, 10);
+ vkvg_set_source_surface(ctx, imgSurf, 0, 0);
+ vkvg_paint(ctx);
+
+ vkvg_identity_matrix(ctx);
+ vkvg_translate(ctx, 80, 0);
+ vkvg_scale(ctx, 2.f, 1.f);
+ vkvg_paint(ctx);
+
+ vkvg_identity_matrix(ctx);
+ vkvg_translate(ctx, 240, 0);
+ vkvg_scale(ctx, 2.f, 2.f);
+ vkvg_paint(ctx);
+
+ vkvg_identity_matrix(ctx);
+ vkvg_translate(ctx, 0, 80);
+ vkvg_translate(ctx, -32, -32);
+ vkvg_rotate(ctx, 1.2f);
+ vkvg_translate(ctx, 32, 32);
+
+ vkvg_paint(ctx);
+
+ vkvg_destroy(ctx);
+
+ compareWithRefImage();
+}
+
+
--- /dev/null
+#include "vkvg.h"
+#include <gtest/gtest.h>
+
+#define CHECK_MAT(_xx,_yx,_xy,_yy,_x0,_y0) \
+EXPECT_FLOAT_EQ (mat.xx, _xx);EXPECT_FLOAT_EQ (mat.yx, _yx);\
+EXPECT_FLOAT_EQ (mat.xy, _xy);EXPECT_FLOAT_EQ (mat.yy, _yy);\
+EXPECT_FLOAT_EQ (mat.x0, _x0);EXPECT_FLOAT_EQ (mat.y0, _y0);
+
+
+TEST(MatrixTest, MatixInit) {
+ vkvg_matrix_t mat = VKVG_IDENTITY_MATRIX;
+ CHECK_MAT(1,0,0,1,0,0);
+
+ vkvg_matrix_init_identity(&mat);
+ CHECK_MAT(1,0,0,1,0,0);
+
+ vkvg_matrix_init(&mat, 1.3f, 2.5f, 0.3f, 0.7f, 1.2f, 1.7f);
+ CHECK_MAT(1.3f, 2.5f, 0.3f, 0.7f, 1.2f, 1.7f);
+
+ float a,b;
+
+ vkvg_matrix_init_translate(&mat, 1.3f, 2.5f);
+ CHECK_MAT(1,0,0,1,1.3f,2.5f);
+
+ vkvg_matrix_init_scale(&mat, 2.1f, 1.5f);
+ CHECK_MAT(2.1f,0,0,1.5f,0,0);
+ vkvg_matrix_get_scale(&mat, &a, &b);
+ EXPECT_FLOAT_EQ(a,2.1f);
+ EXPECT_FLOAT_EQ(b,1.5f);
+
+ vkvg_matrix_init_rotate(&mat, 2.f);
+ CHECK_MAT(cosf(2.f),sinf(2.f),-sinf(2.f),cosf(2.f),0,0);
+}
+
+TEST(MatrixTest, MatixOperation) {
+ vkvg_matrix_t mat = {0,0,0,0,0,0};
+ //TODO
+
+}
+TEST(MatrixTest, MatixIvert) {
+ vkvg_matrix_t mat = {0,0,0,0,0,0};
+ vkvg_status_t res = vkvg_matrix_invert(&mat);
+ EXPECT_EQ(res,VKVG_STATUS_INVALID_MATRIX);
+
+ mat = {1,1,0,0,0,0};
+ res = vkvg_matrix_invert(&mat);
+ EXPECT_EQ(res,VKVG_STATUS_INVALID_MATRIX);
+
+ mat = {1,0,0,1,0,0};
+ res = vkvg_matrix_invert(&mat);
+ EXPECT_EQ(res,VKVG_STATUS_SUCCESS);
+ CHECK_MAT(1,0,0,1,0,0);
+
+ vkvg_matrix_init_scale(&mat, 2.1f, 1.5f);
+ res = vkvg_matrix_invert(&mat);
+ EXPECT_EQ(res,VKVG_STATUS_SUCCESS);
+ CHECK_MAT(1.f/2.1f,0,0,1.f/1.5f,0,0);
+
+ vkvg_matrix_init_translate(&mat, 2.1f, 1.5f);
+ res = vkvg_matrix_invert(&mat);
+ EXPECT_EQ(res,VKVG_STATUS_SUCCESS);
+ CHECK_MAT(1,0,0,1,-2.1f,-1.5f);
+
+ vkvg_matrix_init_rotate(&mat, 2.f);
+ res = vkvg_matrix_invert(&mat);
+ EXPECT_EQ(res,VKVG_STATUS_SUCCESS);
+ CHECK_MAT(cosf(2.f),-sinf(2.f),sinf(2.f),cosf(2.f),0,0);
+
+
+}
--- /dev/null
+#include "drawTestBase.h"
+
+class PatternDrawTest : public DrawTestBase {
+
+ protected:
+ fs::path imgPath = fs::path(GTEST_DATA_ROOT) / "miroir2.png";
+ VkvgSurface imgSurf;
+
+ void SetUp() override {
+ surf = vkvg_surface_create(dev, 512, 512);
+ imgSurf = vkvg_surface_create_from_image(dev, (char*)imgPath.c_str());
+ }
+ void TearDown() override {
+ vkvg_surface_destroy(imgSurf);
+ DrawTestBase::TearDown();
+ }
+};
+TEST_F(PatternDrawTest, References) {
+ EXPECT_EQ(VKVG_STATUS_NULL_POINTER, vkvg_pattern_status(NULL));
+ EXPECT_EQ(0, vkvg_pattern_get_reference_count(NULL));
+ EXPECT_NO_FATAL_FAILURE(vkvg_pattern_reference(NULL));
+
+ VkvgPattern pat = vkvg_pattern_create_for_surface(NULL);
+ EXPECT_EQ(VKVG_STATUS_NULL_POINTER, vkvg_pattern_status(pat));
+
+ pat = vkvg_pattern_create_linear(0,0,0,0);
+ EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_pattern_status(pat));
+ EXPECT_EQ(1, vkvg_pattern_get_reference_count(pat));
+ vkvg_pattern_reference(pat);
+ EXPECT_EQ(2, vkvg_pattern_get_reference_count(pat));
+
+ EXPECT_NO_FATAL_FAILURE(vkvg_pattern_destroy(NULL));
+ vkvg_pattern_destroy(pat);
+ EXPECT_EQ(1, vkvg_pattern_get_reference_count(pat));
+ vkvg_pattern_destroy(pat);
+ //EXPECT_EQ(NULL, pat);
+}
+
+TEST_F(PatternDrawTest, PaintPattern) {
+
+ VkvgContext ctx = vkvg_create(surf);
+ VkvgPattern pat = vkvg_pattern_create_for_surface(imgSurf);
+ EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_pattern_status(pat));
+ EXPECT_EQ(1, vkvg_pattern_get_reference_count(pat));
+ EXPECT_EQ(2, vkvg_surface_get_reference_count(imgSurf));
+ vkvg_set_source(ctx, pat);
+ EXPECT_EQ(2, vkvg_pattern_get_reference_count(pat));
+ vkvg_paint(ctx);
+ vkvg_pattern_destroy(pat);
+ EXPECT_EQ(1, vkvg_pattern_get_reference_count(pat));
+ vkvg_destroy(ctx);
+
+ compareWithRefImage();
+}
+TEST_F(PatternDrawTest, PaintPatternRepeat) {
+ VkvgContext ctx = vkvg_create(surf);
+ VkvgPattern pat = vkvg_pattern_create_for_surface(imgSurf);
+ vkvg_pattern_set_extend(pat, VKVG_EXTEND_REPEAT);
+ vkvg_set_source(ctx, pat);
+ vkvg_paint(ctx);
+ vkvg_pattern_destroy(pat);
+ vkvg_destroy(ctx);
+
+ compareWithRefImage();
+}
+TEST_F(PatternDrawTest, PaintPatternRepeatScaled) {
+ VkvgContext ctx = vkvg_create(surf);
+ vkvg_scale(ctx, 0.2f, 0.2f);
+ VkvgPattern pat = vkvg_pattern_create_for_surface(imgSurf);
+ vkvg_pattern_set_extend(pat, VKVG_EXTEND_REPEAT);
+ vkvg_set_source(ctx, pat);
+ vkvg_paint(ctx);
+ vkvg_pattern_destroy(pat);
+ vkvg_destroy(ctx);
+
+ compareWithRefImage();
+}
+TEST_F(PatternDrawTest, PaintPatternPad) {
+ VkvgContext ctx = vkvg_create(surf);
+ VkvgPattern pat = vkvg_pattern_create_for_surface(imgSurf);
+ vkvg_pattern_set_extend(pat, VKVG_EXTEND_PAD);
+ vkvg_set_source(ctx, pat);
+ vkvg_paint(ctx);
+ vkvg_pattern_destroy(pat);
+ vkvg_destroy(ctx);
+
+ compareWithRefImage();
+}
void SetUp() override {}
void TearDown() override {}
+
+ void checkPixels(VkvgSurface surf, uint32_t expectedPixelValue) {
+ uint32_t w = vkvg_surface_get_width(surf);
+ uint32_t h = vkvg_surface_get_height(surf);
+ uint32_t* buff = (uint32_t*)malloc(w * h * sizeof(uint32_t));
+ vkvg_surface_write_to_memory(surf, (unsigned char*)buff);
+
+ for (int i = 0; i < w * h; ++i) {
+ EXPECT_EQ(expectedPixelValue, buff[i]);
+ }
+ free(buff);
+ }
};
TEST_F(SurfaceTest, SurfCreate) {
EXPECT_EQ(VKVG_STATUS_NULL_POINTER, vkvg_surface_status(NULL));
+ EXPECT_NO_FATAL_FAILURE(vkvg_surface_destroy(NULL));
VkvgSurface surf = vkvg_surface_create(NULL, 0, 0);
-
EXPECT_EQ(VKVG_STATUS_DEVICE_ERROR, vkvg_surface_status(surf));
+ EXPECT_NO_FATAL_FAILURE(vkvg_surface_reference(surf));
surf = vkvg_surface_create(dev, 512, 512);
}
TEST_F(SurfaceTest, SurfReference) {
+ EXPECT_EQ(0, vkvg_surface_get_reference_count(NULL));
+ EXPECT_NO_FATAL_FAILURE(vkvg_surface_reference(NULL));
+
VkvgSurface surf = vkvg_surface_create(NULL, 0, 0);
EXPECT_EQ(0, vkvg_surface_get_reference_count(surf));
- vkvg_surface_reference(surf);
-
EXPECT_EQ(VKVG_STATUS_DEVICE_ERROR, vkvg_surface_status(surf));
+ EXPECT_NO_FATAL_FAILURE(vkvg_surface_reference(surf));
+
+ uint32_t devRefCntInit = vkvg_device_get_reference_count(dev);
surf = vkvg_surface_create(dev, 512, 512);
EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_device_status(dev));
EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_surface_status(surf));
- EXPECT_EQ(2, vkvg_device_get_reference_count(dev));
+ EXPECT_EQ(devRefCntInit + 1, vkvg_device_get_reference_count(dev));
EXPECT_EQ(1, vkvg_surface_get_reference_count(surf));
vkvg_surface_reference(surf);
-
- EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_surface_status(surf));
EXPECT_EQ(2, vkvg_surface_get_reference_count(surf));
- EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_surface_status(surf));
vkvg_surface_destroy(surf);
-
- EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_surface_status(surf));
EXPECT_EQ(1, vkvg_surface_get_reference_count(surf));
- EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_surface_status(surf));
vkvg_surface_destroy(surf);
- EXPECT_EQ(0, vkvg_surface_get_reference_count(surf));
+ EXPECT_EQ(devRefCntInit, vkvg_device_get_reference_count(dev));
+ //EXPECT_EQ(0, vkvg_surface_get_reference_count(surf));
+}
+TEST_F(SurfaceTest, SurfProperties) {
+ EXPECT_EQ(0, vkvg_surface_get_width(NULL));
+ EXPECT_EQ(0, vkvg_surface_get_height(NULL));
+ EXPECT_EQ(NULL, vkvg_surface_get_vk_image(NULL));
+ EXPECT_EQ(VK_FORMAT_UNDEFINED, vkvg_surface_get_vk_format(NULL));
+
+ VkvgSurface surf = vkvg_surface_create(dev, 512, 256);
+ EXPECT_EQ(512, vkvg_surface_get_width(surf));
+ EXPECT_EQ(256, vkvg_surface_get_height(surf));
+ EXPECT_EQ(VK_FORMAT_B8G8R8A8_UNORM, vkvg_surface_get_vk_format(surf));
+ EXPECT_NE(nullptr, vkvg_surface_get_vk_image(surf));
+
+ vkvg_surface_destroy(surf);
+}
+TEST_F(SurfaceTest, SurfWrite) {
+ EXPECT_EQ(VKVG_STATUS_INVALID_STATUS, vkvg_surface_write_to_memory(NULL, NULL));
+ EXPECT_EQ(VKVG_STATUS_INVALID_STATUS, vkvg_surface_write_to_png(NULL, NULL));
+ const uint32_t imgSize = 8;
+ VkvgSurface surf = vkvg_surface_create(dev, imgSize, imgSize);
+ EXPECT_EQ(VKVG_STATUS_WRITE_ERROR, vkvg_surface_write_to_memory(surf, NULL));
+ EXPECT_EQ(VKVG_STATUS_WRITE_ERROR, vkvg_surface_write_to_png(surf, NULL));
+ uint32_t buff[imgSize*imgSize];
+ EXPECT_EQ(VKVG_STATUS_SUCCESS, vkvg_surface_write_to_memory(surf, (unsigned char*)buff));
+
+ vkvg_surface_destroy(surf);
+}
+
+TEST_F(SurfaceTest, SurfClear) {
+ const uint32_t imgSize = 8;
+ VkvgSurface surf = vkvg_surface_create(dev, imgSize, imgSize);
+ VkvgContext ctx = vkvg_create(surf);
+ vkvg_set_source_rgb(ctx, 1, 0, 0);
+ vkvg_paint(ctx);
+ vkvg_destroy(ctx);
+
+ vkvg_surface_clear(surf);
+
+ checkPixels(surf, 0x00000000);
+ vkvg_surface_destroy(surf);
}
home / projects / jp / vkvg.git / commitdiff
