Viewer.cpp File Reference

#include "tools/viewer/Viewer.h"
#include "bench/GpuTools.h"
#include "gm/gm.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorPriv.h"
#include "include/core/SkColorType.h"
#include "include/core/SkData.h"
#include "include/core/SkFontTypes.h"
#include "include/core/SkGraphics.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkPicture.h"
#include "include/core/SkPictureRecorder.h"
#include "include/core/SkRect.h"
#include "include/core/SkSamplingOptions.h"
#include "include/core/SkSerialProcs.h"
#include "include/core/SkStream.h"
#include "include/core/SkSurface.h"
#include "include/core/SkSurfaceProps.h"
#include "include/core/SkTextBlob.h"
#include "include/encode/SkPngEncoder.h"
#include "include/gpu/GrDirectContext.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkTPin.h"
#include "include/private/base/SkTo.h"
#include "include/utils/SkPaintFilterCanvas.h"
#include "src/base/SkBase64.h"
#include "src/base/SkTLazy.h"
#include "src/base/SkTSort.h"
#include "src/base/SkUTF.h"
#include "src/core/SkAutoPixmapStorage.h"
#include "src/core/SkLRUCache.h"
#include "src/core/SkMD5.h"
#include "src/core/SkOSFile.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkScan.h"
#include "src/core/SkStringUtils.h"
#include "src/core/SkTaskGroup.h"
#include "src/core/SkTextBlobPriv.h"
#include "src/image/SkImage_Base.h"
#include "src/sksl/SkSLCompiler.h"
#include "src/sksl/SkSLString.h"
#include "src/text/GlyphRun.h"
#include "src/utils/SkJSONWriter.h"
#include "src/utils/SkOSPath.h"
#include "src/utils/SkShaderUtils.h"
#include "tools/CodecUtils.h"
#include "tools/DecodeUtils.h"
#include "tools/Resources.h"
#include "tools/RuntimeBlendUtils.h"
#include "tools/SkMetaData.h"
#include "tools/flags/CommandLineFlags.h"
#include "tools/flags/CommonFlags.h"
#include "tools/skui/InputState.h"
#include "tools/skui/Key.h"
#include "tools/skui/ModifierKey.h"
#include "tools/trace/EventTracingPriv.h"
#include "tools/viewer/BisectSlide.h"
#include "tools/viewer/GMSlide.h"
#include "tools/viewer/ImageSlide.h"
#include "tools/viewer/MSKPSlide.h"
#include "tools/viewer/SKPSlide.h"
#include "tools/viewer/SkSLDebuggerSlide.h"
#include "tools/viewer/SkSLSlide.h"
#include "tools/viewer/Slide.h"
#include "tools/viewer/SlideDir.h"
#include <algorithm>
#include <cfloat>
#include <chrono>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <initializer_list>
#include <map>
#include <memory>
#include <optional>
#include <ratio>
#include <regex>
#include <tuple>
#include <utility>
#include <vector>
#include "imgui.h"
#include "misc/cpp/imgui_stdlib.h"

Go to the source code of this file.

Classes
class	CapturingShaderErrorHandler
struct	NamedPrimaries
class	NullSlide
struct	SkPaintTitleUpdater
class	OveridePaintFilterCanvas

Macros
#define	GL_BACKEND_STR
#define	VK_BACKEND_STR
#define	MTL_BACKEND_STR
#define	D3D_BACKEND_STR
#define	DAWN_BACKEND_STR
#define	BACKENDS_STR_EVALUATOR(sw, gl, vk, mtl, d3d, dawn)   sw gl vk mtl d3d dawn
#define	BACKENDS_STR
#define	PATH_PREFIX   ""
#define	MAX_ZOOM_LEVEL   8.0f
#define	MIN_ZOOM_LEVEL   -8.0f

Typedefs
using	OverrideFlag = SkSL::Compiler::OverrideFlag

Functions
static	DEFINE_string (slide, "", "Start on this sample.")
static	DEFINE_bool (list, false, "List samples?")
static	DEFINE_string2 (backend, b, "sw", "Backend to use. Allowed values are " BACKENDS_STR ".")
static	DEFINE_int (msaa, 1, "Number of subpixel samples. 0 for no HW antialiasing.")
static	DEFINE_bool (dmsaa, false, "Use internal MSAA to render to non-MSAA surfaces?")
static	DEFINE_string (bisect, "", "Path to a .skp or .svg file to bisect.")
static	DEFINE_string2 (file, f, "", "Open a single file for viewing.")
static	DEFINE_string2 (match, m, nullptr, "[~][^]substring[$] [...] of name to run.\n" "Multiple matches may be separated by spaces.\n" "~ causes a matching name to always be skipped\n" "^ requires the start of the name to match\n" "$ requires the end of the name to match\n" "^ and $ requires an exact match\n" "If a name does not match any list entry,\n" "it is skipped unless some list entry starts with ~")
static	DEFINE_string (jpgs, PATH_PREFIX "jpgs", "Directory to read jpgs from.")
static	DEFINE_string (jxls, PATH_PREFIX "jxls", "Directory to read jxls from.")
static	DEFINE_string (skps, PATH_PREFIX "skps", "Directory to read skps from.")
static	DEFINE_string (mskps, PATH_PREFIX "mskps", "Directory to read mskps from.")
static	DEFINE_string (lotties, PATH_PREFIX "lotties", "Directory to read (Bodymovin) jsons from.")
static	DEFINE_string (svgs, "", "Directory to read SVGs from, or a single SVG file.")
static	DEFINE_string (rives, "", "Directory to read RIVs from, or a single .riv file.")
static	DEFINE_int_2 (threads, j, -1, "Run threadsafe tests on a threadpool with this many extra threads, " "defaulting to one extra thread per core.")
static	DEFINE_bool (redraw, false, "Toggle continuous redraw.")
static	DEFINE_bool (offscreen, false, "Force rendering to an offscreen surface.")
static	DEFINE_bool (stats, false, "Display stats overlay on startup.")
static	DEFINE_bool (createProtected, false, "Create a protected native backend (e.g., in EGL).")
static bool	is_graphite_backend_type (sk_app::Window::BackendType type)
const char *	get_backend_string (sk_app::Window::BackendType type)
static sk_app::Window::BackendType	get_backend_type (const char *str)
static bool	primaries_equal (const SkColorSpacePrimaries &a, const SkColorSpacePrimaries &b)
static Window::BackendType	backend_type_for_window (Window::BackendType backendType)
static sk_sp< SkData >	data_from_file (FILE *fp)
static sk_sp< SkData >	base64_string_to_data (const std::string &s)
static std::vector< sk_sp< SkImage > >	find_data_uri_images (sk_sp< SkData > data)
static SkSerialProcs	serial_procs_using_png ()
static void	ImGui_Primaries (SkColorSpacePrimaries *primaries, SkPaint *gamutPaint)
static bool	ImGui_DragLocation (SkPoint *pt)
static bool	ImGui_DragQuad (SkPoint *pts)
static std::string	build_sksl_highlight_shader ()
static std::string	build_metal_highlight_shader (const std::string &inShader)
static std::string	build_glsl_highlight_shader (const GrShaderCaps &shaderCaps)
template<typename OptionsFunc >
static void	WriteStateObject (SkJSONWriter &writer, const char *name, const char *value, OptionsFunc &&optionsFunc)

Variables
static CapturingShaderErrorHandler	gShaderErrorHandler
static std::map< GpuPathRenderers, std::string >	gGaneshPathRendererNames
static SkColorSpacePrimaries	gSrgbPrimaries
static SkColorSpacePrimaries	gAdobePrimaries
static SkColorSpacePrimaries	gP3Primaries
static SkColorSpacePrimaries	gRec2020Primaries
struct NamedPrimaries	gNamedPrimaries []
static const char	kName [] = "name"
static const char	kValue [] = "value"
static const char	kOptions [] = "options"
static const char	kSlideStateName [] = "Slide"
static const char	kBackendStateName [] = "Backend"
static const char	kMSAAStateName [] = "MSAA"
static const char	kPathRendererStateName [] = "Path renderer"
static const char	kSoftkeyStateName [] = "Softkey"
static const char	kSoftkeyHint [] = "Please select a softkey"
static const char	kON [] = "ON"
static const char	kRefreshStateName [] = "Refresh"

Macro Definition Documentation

BACKENDS_STR

#define BACKENDS_STR

Value:

    BACKENDS_STR_EVALUATOR( \
    "\"sw\"", GL_BACKEND_STR, VK_BACKEND_STR, MTL_BACKEND_STR, D3D_BACKEND_STR, DAWN_BACKEND_STR)

Definition at line 208 of file Viewer.cpp.

BACKENDS_STR_EVALUATOR

#define BACKENDS_STR_EVALUATOR	(		sw,
			gl,
			vk,
			mtl,
			d3d,
			dawn
	)		sw gl vk mtl d3d dawn

Definition at line 207 of file Viewer.cpp.

D3D_BACKEND_STR

#define D3D_BACKEND_STR

Definition at line 200 of file Viewer.cpp.

DAWN_BACKEND_STR

#define DAWN_BACKEND_STR

Definition at line 205 of file Viewer.cpp.

GL_BACKEND_STR

#define GL_BACKEND_STR

Definition at line 185 of file Viewer.cpp.

MAX_ZOOM_LEVEL

#define MAX_ZOOM_LEVEL   8.0f

Definition at line 1395 of file Viewer.cpp.

MIN_ZOOM_LEVEL

#define MIN_ZOOM_LEVEL   -8.0f

Definition at line 1396 of file Viewer.cpp.

MTL_BACKEND_STR

#define MTL_BACKEND_STR

Definition at line 195 of file Viewer.cpp.

PATH_PREFIX

#define PATH_PREFIX   ""

Definition at line 263 of file Viewer.cpp.

VK_BACKEND_STR

#define VK_BACKEND_STR

Definition at line 190 of file Viewer.cpp.

Typedef Documentation

OverrideFlag

using OverrideFlag = SkSL::Compiler::OverrideFlag

Definition at line 171 of file Viewer.cpp.

Function Documentation

backend_type_for_window()

static Window::BackendType backend_type_for_window ( Window::BackendType  backendType )

static

Definition at line 474 of file Viewer.cpp.

                                                                                {
    // In raster mode, we still use GL for the window.
    // This lets us render the GUI faster (and correct).
    return Window::kRaster_BackendType == backendType ? Window::kNativeGL_BackendType : backendType;
}

base64_string_to_data()

static sk_sp< SkData > base64_string_to_data ( const std::string &  s )

static

Definition at line 897 of file Viewer.cpp.

                                                               {
    size_t dataLen;
    if (SkBase64::Decode(s.c_str(), s.size(), nullptr, &dataLen) != SkBase64::kNoError) {
        return nullptr;
    }
 
    sk_sp<SkData> decodedData = SkData::MakeUninitialized(dataLen);
    void* rawData = decodedData->writable_data();
    if (SkBase64::Decode(s.c_str(), s.size(), rawData, &dataLen) != SkBase64::kNoError) {
        return nullptr;
    }
 
    return decodedData;
}

build_glsl_highlight_shader()

static std::string build_glsl_highlight_shader ( const GrShaderCaps &  shaderCaps )

static

Definition at line 2104 of file Viewer.cpp.

                                                                             {
    const char* versionDecl = shaderCaps.fVersionDeclString;
    std::string highlight = versionDecl ? versionDecl : "";
    if (shaderCaps.fUsesPrecisionModifiers) {
        highlight.append("precision mediump float;\n");
    }
    SkSL::String::appendf(&highlight, "out vec4 sk_FragColor;\n"
                                      "void main() { sk_FragColor = vec4(1, 0, 1, 0.5); }");
    return highlight;
}

build_metal_highlight_shader()

static std::string build_metal_highlight_shader ( const std::string &  inShader )

static

Definition at line 2091 of file Viewer.cpp.

                                                                         {
    // Metal fragment shaders need a lot of non-trivial boilerplate that we don't want to recompute
    // here. So keep all shader code, but right before `return *_out;`, swap out the sk_FragColor.
    size_t pos = inShader.rfind("return _out;\n");
    if (pos == std::string::npos) {
        return inShader;
    }
 
    std::string replacementShader = inShader;
    replacementShader.insert(pos, "_out.sk_FragColor = float4(1.0, 0.0, 1.0, 0.5); ");
    return replacementShader;
}

build_sksl_highlight_shader()

static std::string build_sksl_highlight_shader ( )

static

Definition at line 2087 of file Viewer.cpp.

                                               {
    return std::string("void main() { sk_FragColor = half4(1, 0, 1, 0.5); }");
}

data_from_file()

static sk_sp< SkData > data_from_file ( FILE *  fp )

static

Definition at line 888 of file Viewer.cpp.

                                              {
    SkDynamicMemoryWStream stream;
    char buf[4096];
    while (size_t bytesRead = fread(buf, 1, 4096, fp)) {
        stream.write(buf, bytesRead);
    }
    return stream.detachAsData();
}

DEFINE_bool() [1/6]

static DEFINE_bool ( createProtected  , false  , "Create a protected native backend (e.g., in EGL)."    )

static

DEFINE_bool() [2/6]

static DEFINE_bool ( dmsaa  , false  , "Use internal MSAA to render to non-MSAA surfaces?"    )

static

DEFINE_bool() [3/6]

static DEFINE_bool ( list  , false  , "List samples?"    )

static

DEFINE_bool() [4/6]

static DEFINE_bool ( offscreen  , false  , "Force rendering to an offscreen surface."    )

static

DEFINE_bool() [5/6]

static DEFINE_bool ( redraw  , false  , "Toggle continuous redraw."    )

static

DEFINE_bool() [6/6]

static DEFINE_bool ( stats  , false  , "Display stats overlay on startup."    )

static

DEFINE_int()

static DEFINE_int ( msaa  , 1  , "Number of subpixel samples. 0 for no HW antialiasing."    )

static

DEFINE_int_2()

static DEFINE_int_2 ( threads  , j  , -  1, "Run threadsafe tests on a threadpool with this many extra  threads, " "defaulting to one extra thread per core."    )

static

DEFINE_string() [1/9]

static DEFINE_string ( bisect  , ""  , "Path to a .skp or .svg file to bisect."    )

static

DEFINE_string() [2/9]

static DEFINE_string ( jpgs  , PATH_PREFIX "jpgs"  , "Directory to read jpgs from."    )

static

DEFINE_string() [3/9]

static DEFINE_string ( jxls  , PATH_PREFIX "jxls"  , "Directory to read jxls from."    )

static

DEFINE_string() [4/9]

static DEFINE_string ( lotties  , PATH_PREFIX "lotties"  , "Directory to read (Bodymovin) jsons from."    )

static

DEFINE_string() [5/9]

static DEFINE_string ( mskps  , PATH_PREFIX "mskps"  , "Directory to read mskps from."    )

static

DEFINE_string() [6/9]

static DEFINE_string ( rives  , ""  , "Directory to read RIVs  from, or a single .riv file."    )

static

DEFINE_string() [7/9]

static DEFINE_string ( skps  , PATH_PREFIX "skps"  , "Directory to read skps from."    )

static

DEFINE_string() [8/9]

static DEFINE_string ( slide  , ""  , "Start on this sample."    )

static

DEFINE_string() [9/9]

static DEFINE_string ( svgs  , ""  , "Directory to read SVGs  from, or a single SVG file."    )

static

DEFINE_string2() [1/3]

static DEFINE_string2 ( backend  , b  , "sw"  , "Backend to use. Allowed values are " BACKENDS_STR "."    )

static

DEFINE_string2() [2/3]

static DEFINE_string2 ( file  , f  , ""  , "Open a single file for viewing."    )

static

DEFINE_string2() [3/3]

static DEFINE_string2 ( match  , m  , nullptr  , "substring of name to run.\n" "Multiple matches may be separated by spaces.\n" "~ causes a matching name to always be skipped\n" "^ requires the start of the name to match\n" "$ requires the end of the name to match\n" "^ and $ requires an exact match\n" "If a name does not match any list  entry[~][^][$][...], \n" "it is skipped unless some list entry starts with ~"    )

static

find_data_uri_images()

static std::vector< sk_sp< SkImage > > find_data_uri_images ( sk_sp< SkData >  data )

static

Definition at line 912 of file Viewer.cpp.

                                                                          {
    std::string str(reinterpret_cast<const char*>(data->data()), data->size());
    std::regex re("data:image/png;base64,([a-zA-Z0-9+/=]+)");
    std::sregex_iterator images_begin(str.begin(), str.end(), re);
    std::sregex_iterator images_end;
    std::vector<sk_sp<SkImage>> images;
 
    for (auto iter = images_begin; iter != images_end; ++iter) {
        const std::smatch& match = *iter;
        auto raw = base64_string_to_data(match[1].str());
        if (!raw) {
            continue;
        }
        auto image = SkImages::DeferredFromEncodedData(std::move(raw));
        if (image) {
            images.push_back(std::move(image));
        }
    }
 
    return images;
}

get_backend_string()

const char * get_backend_string

(

sk_app::Window::BackendType

type

)

Definition at line 355 of file Viewer.cpp.

                                                             {
    switch (type) {
        case sk_app::Window::kNativeGL_BackendType: return "OpenGL";
#if SK_ANGLE && (defined(SK_BUILD_FOR_WIN) || defined(SK_BUILD_FOR_MAC))
        case sk_app::Window::kANGLE_BackendType: return "ANGLE";
#endif
#ifdef SK_DAWN
#if defined(SK_GRAPHITE)
        case sk_app::Window::kGraphiteDawn_BackendType: return "Dawn (Graphite)";
#endif
#endif
#ifdef SK_VULKAN
        case sk_app::Window::kVulkan_BackendType: return "Vulkan";
#if defined(SK_GRAPHITE)
        case sk_app::Window::kGraphiteVulkan_BackendType: return "Vulkan (Graphite)";
#endif
#endif
#ifdef SK_METAL
        case sk_app::Window::kMetal_BackendType: return "Metal";
#if defined(SK_GRAPHITE)
        case sk_app::Window::kGraphiteMetal_BackendType: return "Metal (Graphite)";
#endif
#endif
#ifdef SK_DIRECT3D
        case sk_app::Window::kDirect3D_BackendType: return "Direct3D";
#endif
        case sk_app::Window::kRaster_BackendType: return "Raster";
    }
    SkASSERT(false);
    return nullptr;
}

get_backend_type()

static sk_app::Window::BackendType get_backend_type ( const char *  str )

static

Definition at line 387 of file Viewer.cpp.

                                                                 {
#ifdef SK_DAWN
#if defined(SK_GRAPHITE)
    if (0 == strcmp(str, "grdawn")) {
        return sk_app::Window::kGraphiteDawn_BackendType;
    } else
#endif
#endif
#ifdef SK_VULKAN
    if (0 == strcmp(str, "vk")) {
        return sk_app::Window::kVulkan_BackendType;
    } else
#if defined(SK_GRAPHITE)
        if (0 == strcmp(str, "grvk")) {
            return sk_app::Window::kGraphiteVulkan_BackendType;
        } else
#endif
#endif
#if SK_ANGLE && (defined(SK_BUILD_FOR_WIN) || defined(SK_BUILD_FOR_MAC))
    if (0 == strcmp(str, "angle")) {
        return sk_app::Window::kANGLE_BackendType;
    } else
#endif
#ifdef SK_METAL
    if (0 == strcmp(str, "mtl")) {
        return sk_app::Window::kMetal_BackendType;
    } else
#if defined(SK_GRAPHITE)
    if (0 == strcmp(str, "grmtl")) {
        return sk_app::Window::kGraphiteMetal_BackendType;
    } else
#endif
#endif
#ifdef SK_DIRECT3D
    if (0 == strcmp(str, "d3d")) {
        return sk_app::Window::kDirect3D_BackendType;
    } else
#endif
 
    if (0 == strcmp(str, "gl")) {
        return sk_app::Window::kNativeGL_BackendType;
    } else if (0 == strcmp(str, "sw")) {
        return sk_app::Window::kRaster_BackendType;
    } else {
        SkDebugf("Unknown backend type, %s, defaulting to sw.", str);
        return sk_app::Window::kRaster_BackendType;
    }
}

ImGui_DragLocation()

static bool ImGui_DragLocation ( SkPoint *  pt )

static

Definition at line 2064 of file Viewer.cpp.

                                            {
    ImGui::DragCanvas dc(pt);
    dc.fillColor(IM_COL32(0, 0, 0, 128));
    dc.dragPoint(pt);
    return dc.fDragging;
}

ImGui_DragQuad()

static bool ImGui_DragQuad ( SkPoint *  pts )

static

Definition at line 2071 of file Viewer.cpp.

                                         {
    ImGui::DragCanvas dc(pts);
    dc.fillColor(IM_COL32(0, 0, 0, 128));
 
    for (int i = 0; i < 4; ++i) {
        dc.dragPoint(pts + i);
    }
 
    dc.fDrawList->AddLine(dc.fScreenPoints[0], dc.fScreenPoints[1], 0xFFFFFFFF);
    dc.fDrawList->AddLine(dc.fScreenPoints[1], dc.fScreenPoints[3], 0xFFFFFFFF);
    dc.fDrawList->AddLine(dc.fScreenPoints[3], dc.fScreenPoints[2], 0xFFFFFFFF);
    dc.fDrawList->AddLine(dc.fScreenPoints[2], dc.fScreenPoints[0], 0xFFFFFFFF);
 
    return dc.fDragging;
}

ImGui_Primaries()

static void ImGui_Primaries ( SkColorSpacePrimaries *  primaries, SkPaint *  gamutPaint  )

static

Definition at line 2046 of file Viewer.cpp.

                                                                                   {
    // The gamut image covers a (0.8 x 0.9) shaped region
    ImGui::DragCanvas dc(primaries, { 0.0f, 0.9f }, { 0.8f, 0.0f });
 
    // Background image. Only draw a subset of the image, to avoid the regions less than zero.
    // Simplifes re-mapping math, clipping behavior, and increases resolution in the useful area.
    // Magic numbers are pixel locations of the origin and upper-right corner.
    dc.fDrawList->AddImage(gamutPaint, dc.fPos,
                           ImVec2(dc.fPos.x + dc.fSize.x, dc.fPos.y + dc.fSize.y),
                           ImVec2(242, 61), ImVec2(1897, 1922));
 
    dc.dragPoint((SkPoint*)(&primaries->fRX), true, 0xFF000040);
    dc.dragPoint((SkPoint*)(&primaries->fGX), true, 0xFF004000);
    dc.dragPoint((SkPoint*)(&primaries->fBX), true, 0xFF400000);
    dc.dragPoint((SkPoint*)(&primaries->fWX), true);
    dc.fDrawList->AddPolyline(dc.fScreenPoints.begin(), 3, 0xFFFFFFFF, true, 1.5f);
}

is_graphite_backend_type()

static bool is_graphite_backend_type ( sk_app::Window::BackendType  type )

static

Definition at line 291 of file Viewer.cpp.

                                                                   {
#if defined(SK_GRAPHITE)
    switch (type) {
#ifdef SK_DAWN
        case sk_app::Window::kGraphiteDawn_BackendType:
#endif
#ifdef SK_METAL
        case sk_app::Window::kGraphiteMetal_BackendType:
#endif
#ifdef SK_VULKAN
        case sk_app::Window::kGraphiteVulkan_BackendType:
#endif
            return true;
        default:
            break;
    }
#endif
    return false;
}

primaries_equal()

static bool primaries_equal ( const SkColorSpacePrimaries &  a, const SkColorSpacePrimaries &  b  )

static

Definition at line 470 of file Viewer.cpp.

                                                                                            {
    return memcmp(&a, &b, sizeof(SkColorSpacePrimaries)) == 0;
}

serial_procs_using_png()

static SkSerialProcs serial_procs_using_png ( )

static

Definition at line 1688 of file Viewer.cpp.

                                              {
    SkSerialProcs sProcs;
    sProcs.fImageProc = [](SkImage* img, void*) -> sk_sp<SkData> {
        return SkPngEncoder::Encode(as_IB(img)->directContext(), img, SkPngEncoder::Options{});
    };
    return sProcs;
}

WriteStateObject()

template<typename OptionsFunc >

static void WriteStateObject ( SkJSONWriter &  writer, const char *  name, const char *  value, OptionsFunc &&  optionsFunc  )

static

Definition at line 3178 of file Viewer.cpp.

                                                        {
    writer.beginObject();
    {
        writer.appendCString(kName , name);
        writer.appendCString(kValue, value);
 
        writer.beginArray(kOptions);
        {
            optionsFunc(writer);
        }
        writer.endArray();
    }
    writer.endObject();
}

Variable Documentation

gAdobePrimaries

SkColorSpacePrimaries gAdobePrimaries

static

Initial value:

= {
    0.64f, 0.33f,
    0.21f, 0.71f,
    0.15f, 0.06f,
    0.3127f, 0.3290f }

Definition at line 442 of file Viewer.cpp.

gGaneshPathRendererNames

std::map<GpuPathRenderers, std::string> gGaneshPathRendererNames

static

Definition at line 173 of file Viewer.cpp.

gNamedPrimaries

struct NamedPrimaries gNamedPrimaries[]

Initial value:

= {
    { "sRGB", &gSrgbPrimaries },
    { "AdobeRGB", &gAdobePrimaries },
    { "P3", &gP3Primaries },
    { "Rec. 2020", &gRec2020Primaries },
}

gP3Primaries

SkColorSpacePrimaries gP3Primaries

static

Initial value:

= {
    0.680f, 0.320f,
    0.265f, 0.690f,
    0.150f, 0.060f,
    0.3127f, 0.3290f }

Definition at line 448 of file Viewer.cpp.

gRec2020Primaries

SkColorSpacePrimaries gRec2020Primaries

static

Initial value:

= {
    0.708f, 0.292f,
    0.170f, 0.797f,
    0.131f, 0.046f,
    0.3127f, 0.3290f }

Definition at line 454 of file Viewer.cpp.

gShaderErrorHandler

CapturingShaderErrorHandler gShaderErrorHandler

static

Definition at line 165 of file Viewer.cpp.

gSrgbPrimaries

SkColorSpacePrimaries gSrgbPrimaries

static

Initial value:

= {
    0.64f, 0.33f,
    0.30f, 0.60f,
    0.15f, 0.06f,
    0.3127f, 0.3290f }

Definition at line 436 of file Viewer.cpp.

kBackendStateName

const char kBackendStateName[] = "Backend"

static

Definition at line 490 of file Viewer.cpp.

kMSAAStateName

const char kMSAAStateName[] = "MSAA"

static

Definition at line 491 of file Viewer.cpp.

kName

const char kName[] = "name"

static

Definition at line 486 of file Viewer.cpp.

kON

const char kON[] = "ON"

static

Definition at line 495 of file Viewer.cpp.

kOptions

const char kOptions[] = "options"

static

Definition at line 488 of file Viewer.cpp.

kPathRendererStateName

const char kPathRendererStateName[] = "Path renderer"

static

Definition at line 492 of file Viewer.cpp.

kRefreshStateName

const char kRefreshStateName[] = "Refresh"

static

Definition at line 496 of file Viewer.cpp.

kSlideStateName

const char kSlideStateName[] = "Slide"

static

Definition at line 489 of file Viewer.cpp.

kSoftkeyHint

const char kSoftkeyHint[] = "Please select a softkey"

static

Definition at line 494 of file Viewer.cpp.

kSoftkeyStateName

const char kSoftkeyStateName[] = "Softkey"

static

Definition at line 493 of file Viewer.cpp.

kValue

const char kValue[] = "value"

static

Definition at line 487 of file Viewer.cpp.