indigo
/
UsdLayerManager
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
UsdLayerManager/tests/viewport_display_test.cpp

608 lines
22 KiB
C++
Raw Blame History

#include "../src/utils/Logger.h"
#include "../src/core/UsdSceneRenderer.h"
#include "../src/core/ViewportCamera.h"
#include "../src/utils/GLExt.h"
#include <pxr/usd/usd/stage.h>
#include <pxr/usd/usd/primRange.h>
#include <pxr/usd/usdGeom/cube.h>
#include <pxr/usd/usdGeom/sphere.h>
#include <pxr/usd/usdGeom/xform.h>
#include <pxr/usd/usdGeom/bboxCache.h>
#include <pxr/usd/usdGeom/tokens.h>
#include <Windows.h>
#include <iostream>
#include <cmath>
#include <string>
#include <vector>
using namespace UsdLayerManager;
using namespace pxr;
static HWND g_hwnd = nullptr;
static HDC g_hdc = nullptr;
static HGLRC g_hglrc = nullptr;
static int g_testsPassed = 0;
static int g_testsFailed = 0;
static int g_testsSkipped = 0;
#define TEST_ASSERT(cond, msg) \
do { \
if (!(cond)) { \
std::cout << "[FAIL] " << (msg) << " (at " << __FILE__ << ":" << __LINE__ << ")" << std::endl; \
g_testsFailed++; \
return false; \
} else { \
std::cout << "[PASS] " << (msg) << std::endl; \
g_testsPassed++; \
} \
} while(0)
#define TEST_SKIP(msg) \
do { \
std::cout << "[SKIP] " << (msg) << std::endl; \
g_testsSkipped++; \
return true; \
} while(0)
static bool CreateGLContext() {
WNDCLASSEXW wc = { sizeof(wc), CS_OWNDC, DefWindowProcW, 0L, 0L,
GetModuleHandle(nullptr), nullptr, nullptr, nullptr, nullptr,
L"ViewportTest", nullptr };
RegisterClassExW(&wc);
g_hwnd = CreateWindowW(wc.lpszClassName, L"ViewportTest", WS_OVERLAPPEDWINDOW,
100, 100, 800, 600, nullptr, nullptr, wc.hInstance, nullptr);
if (!g_hwnd) {
std::cerr << "[FAIL] CreateWindowW failed" << std::endl;
return false;
}
g_hdc = GetDC(g_hwnd);
PIXELFORMATDESCRIPTOR pfd = {};
pfd.nSize = sizeof(pfd);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 32;
pfd.cDepthBits = 24;
pfd.cStencilBits = 8;
int pixelFormat = ChoosePixelFormat(g_hdc, &pfd);
if (pixelFormat == 0) {
std::cerr << "[FAIL] ChoosePixelFormat failed" << std::endl;
return false;
}
if (!SetPixelFormat(g_hdc, pixelFormat, &pfd)) {
std::cerr << "[FAIL] SetPixelFormat failed" << std::endl;
return false;
}
g_hglrc = wglCreateContext(g_hdc);
if (!g_hglrc) {
std::cerr << "[FAIL] wglCreateContext failed" << std::endl;
return false;
}
if (!wglMakeCurrent(g_hdc, g_hglrc)) {
std::cerr << "[FAIL] wglMakeCurrent failed" << std::endl;
return false;
}
return true;
}
static void DestroyGLContext() {
if (g_hglrc) { wglMakeCurrent(nullptr, nullptr); wglDeleteContext(g_hglrc); g_hglrc = nullptr; }
if (g_hdc) { ReleaseDC(g_hwnd, g_hdc); g_hdc = nullptr; }
if (g_hwnd) { DestroyWindow(g_hwnd); UnregisterClassW(L"ViewportTest", GetModuleHandle(nullptr)); g_hwnd = nullptr; }
}
static UsdStageRefPtr CreateTestStageWithCube() {
UsdStageRefPtr stage = UsdStage::CreateInMemory();
if (!stage) return nullptr;
UsdGeomXform xform = UsdGeomXform::Define(stage, SdfPath("/TestXform"));
UsdGeomCube cube = UsdGeomCube::Define(stage, SdfPath("/TestXform/TestCube"));
cube.GetSizeAttr().Set(50.0);
cube.GetDisplayColorAttr().Set(VtVec3fArray{{1.0f, 0.0f, 0.0f}});
cube.GetDisplayOpacityAttr().Set(VtFloatArray{1.0f});
UsdGeomSphere sphere = UsdGeomSphere::Define(stage, SdfPath("/TestSphere"));
sphere.GetRadiusAttr().Set(25.0);
sphere.GetDisplayColorAttr().Set(VtVec3fArray{{0.0f, 1.0f, 0.0f}});
sphere.GetDisplayOpacityAttr().Set(VtFloatArray{1.0f});
return stage;
}
static GfVec4d MulMatrixVec4(const GfMatrix4d& m, const GfVec4d& v) {
GfVec4d result;
for (int j = 0; j < 4; ++j) {
result[j] = 0;
for (int i = 0; i < 4; ++i) {
result[j] += v[i] * m[i][j];
}
}
return result;
}
bool Test_StageCreation() {
std::cout << "\n=== Test 1: Stage Creation ===" << std::endl;
UsdStageRefPtr stage = CreateTestStageWithCube();
TEST_ASSERT(stage != nullptr, "In-memory stage created");
size_t primCount = 0;
for ([[maybe_unused]] const auto& prim : stage->Traverse()) { ++primCount; }
std::cout << " Prim count: " << primCount << std::endl;
TEST_ASSERT(primCount >= 3, "Stage has at least 3 prims (xform, cube, sphere)");
UsdPrim cubePrim = stage->GetPrimAtPath(SdfPath("/TestXform/TestCube"));
TEST_ASSERT(cubePrim.IsValid(), "Cube prim found at /TestXform/TestCube");
TEST_ASSERT(cubePrim.IsA<UsdGeomCube>(), "Prim is a UsdGeomCube");
UsdPrim spherePrim = stage->GetPrimAtPath(SdfPath("/TestSphere"));
TEST_ASSERT(spherePrim.IsValid(), "Sphere prim found at /TestSphere");
return true;
}
bool Test_StageBounds() {
std::cout << "\n=== Test 2: Stage Bounds Computation ===" << std::endl;
UsdStageRefPtr stage = CreateTestStageWithCube();
TEST_ASSERT(stage != nullptr, "Stage created for bounds test");
UsdSceneRenderer renderer;
renderer.SetStage(stage);
GfRange3d bounds = renderer.ComputeStageBounds();
TEST_ASSERT(!bounds.IsEmpty(), "Stage bounds are not empty");
GfVec3d min = bounds.GetMin();
GfVec3d max = bounds.GetMax();
std::cout << " Bounds min: (" << min[0] << ", " << min[1] << ", " << min[2] << ")" << std::endl;
std::cout << " Bounds max: (" << max[0] << ", " << max[1] << ", " << max[2] << ")" << std::endl;
GfVec3d size = bounds.GetSize();
double maxSize = size.GetLength();
std::cout << " Bounds size length: " << maxSize << std::endl;
TEST_ASSERT(maxSize > 0.0, "Bounds size is greater than zero");
return true;
}
bool Test_CameraSetup() {
std::cout << "\n=== Test 3: Camera Setup ===" << std::endl;
ViewportCamera camera;
TEST_ASSERT(camera.GetMode() == ViewportCamera::CameraMode::Free, "Camera starts in Free mode");
GfVec3d eye = camera.GetEye();
GfVec3d focal = camera.GetFocalPoint();
std::cout << " Default eye: (" << eye[0] << ", " << eye[1] << ", " << eye[2] << ")" << std::endl;
std::cout << " Default focal: (" << focal[0] << ", " << focal[1] << ", " << focal[2] << ")" << std::endl;
std::cout << " Near/Far: " << camera.GetNearClip() << " / " << camera.GetFarClip() << std::endl;
std::cout << " FOV: " << camera.GetFOV() << ", Aspect: " << camera.GetAspectRatio() << std::endl;
UsdStageRefPtr stage = CreateTestStageWithCube();
camera.SetStage(stage);
GfRange3d bounds = GfRange3d(GfVec3d(-25, -25, -25), GfVec3d(25, 25, 25));
camera.FrameBoundingBox(bounds);
eye = camera.GetEye();
focal = camera.GetFocalPoint();
std::cout << " After FrameBB eye: (" << eye[0] << ", " << eye[1] << ", " << eye[2] << ")" << std::endl;
std::cout << " After FrameBB focal: (" << focal[0] << ", " << focal[1] << ", " << focal[2] << ")" << std::endl;
std::cout << " After FrameBB Near/Far: " << camera.GetNearClip() << " / " << camera.GetFarClip() << std::endl;
TEST_ASSERT(camera.GetNearClip() > 0.0f, "Near clip is positive after framing");
TEST_ASSERT(camera.GetFarClip() > camera.GetNearClip(), "Far clip > near clip after framing");
GfMatrix4d viewMatrix = camera.GetViewMatrix();
GfMatrix4d projMatrix = camera.GetProjectionMatrix();
double detView = viewMatrix.GetDeterminant();
double detProj = projMatrix.GetDeterminant();
std::cout << " View matrix determinant: " << detView << std::endl;
std::cout << " Proj matrix determinant: " << detProj << std::endl;
TEST_ASSERT(std::abs(detView) > 0.001, "View matrix is non-degenerate");
TEST_ASSERT(std::abs(detProj) > 0.000001, "Projection matrix is non-degenerate");
return true;
}
bool Test_CameraAspectRatio() {
std::cout << "\n=== Test 4: Camera Aspect Ratio Update ===" << std::endl;
ViewportCamera camera;
float defaultAspect = camera.GetAspectRatio();
std::cout << " Default aspect: " << defaultAspect << std::endl;
camera.SetAspectRatio(800.0f / 600.0f);
float newAspect = camera.GetAspectRatio();
std::cout << " After update: " << newAspect << std::endl;
TEST_ASSERT(std::abs(newAspect - (800.0f / 600.0f)) < 0.01f, "Aspect ratio updated correctly");
GfMatrix4d proj = camera.GetProjectionMatrix();
double det = proj.GetDeterminant();
std::cout << " Projection determinant with new aspect: " << det << std::endl;
TEST_ASSERT(std::abs(det) > 0.000001, "Projection matrix valid after aspect update");
return true;
}
bool Test_ViewProjectionSanity() {
std::cout << "\n=== Test 5: View/Projection Matrix Sanity ===" << std::endl;
ViewportCamera camera;
camera.SetAspectRatio(800.0f / 600.0f);
GfRange3d bounds(GfVec3d(-25, -25, -25), GfVec3d(25, 25, 25));
camera.FrameBoundingBox(bounds);
GfMatrix4d view = camera.GetViewMatrix();
GfMatrix4d proj = camera.GetProjectionMatrix();
std::cout << " View matrix:" << std::endl;
for (int r = 0; r < 4; ++r) {
std::cout << " [" << view[r][0] << ", " << view[r][1] << ", "
<< view[r][2] << ", " << view[r][3] << "]" << std::endl;
}
std::cout << " Projection matrix:" << std::endl;
for (int r = 0; r < 4; ++r) {
std::cout << " [" << proj[r][0] << ", " << proj[r][1] << ", "
<< proj[r][2] << ", " << proj[r][3] << "]" << std::endl;
}
GfVec3d testPoint(0, 0, 0);
GfVec4d viewSpacePoint = MulMatrixVec4(view, GfVec4d(testPoint[0], testPoint[1], testPoint[2], 1.0));
std::cout << " Origin in view space: (" << viewSpacePoint[0] << ", "
<< viewSpacePoint[1] << ", " << viewSpacePoint[2] << ", "
<< viewSpacePoint[3] << ")" << std::endl;
TEST_ASSERT(viewSpacePoint[3] != 0.0, "Origin has valid w component in view space");
GfVec4d clipSpacePoint = MulMatrixVec4(proj, viewSpacePoint);
std::cout << " Origin in clip space: (" << clipSpacePoint[0] << ", "
<< clipSpacePoint[1] << ", " << clipSpacePoint[2] << ", "
<< clipSpacePoint[3] << ")" << std::endl;
if (clipSpacePoint[3] != 0.0) {
double ndcX = clipSpacePoint[0] / clipSpacePoint[3];
double ndcY = clipSpacePoint[1] / clipSpacePoint[3];
double ndcZ = clipSpacePoint[2] / clipSpacePoint[3];
std::cout << " Origin in NDC: (" << ndcX << ", " << ndcY << ", " << ndcZ << ")" << std::endl;
bool inFrustum = (ndcX >= -1.0 && ndcX <= 1.0 &&
ndcY >= -1.0 && ndcY <= 1.0 &&
ndcZ >= -1.0 && ndcZ <= 1.0);
if (inFrustum) {
std::cout << " [PASS] Scene origin is inside the view frustum" << std::endl;
g_testsPassed++;
} else {
std::cout << " [FAIL] Scene origin is OUTSIDE the view frustum - this explains nothing visible!" << std::endl;
std::cout << " This likely means the camera framing calculation is wrong." << std::endl;
g_testsFailed++;
}
} else {
std::cout << " [FAIL] Clip space w=0 - projection is broken" << std::endl;
g_testsFailed++;
}
return true;
}
bool Test_RendererInitAndRender() {
std::cout << "\n=== Test 6: Renderer Init and Render ===" << std::endl;
if (!GL::InitExtensions()) {
TEST_SKIP("OpenGL extensions not available");
}
UsdStageRefPtr stage = CreateTestStageWithCube();
TEST_ASSERT(stage != nullptr, "Test stage created");
UsdSceneRenderer renderer;
renderer.SetStage(stage);
GfRange3d bounds = renderer.ComputeStageBounds();
TEST_ASSERT(!bounds.IsEmpty(), "Stage bounds not empty");
ViewportCamera camera;
camera.SetStage(stage);
camera.FrameBoundingBox(bounds);
camera.SetAspectRatio(800.0f / 600.0f);
renderer.SetCameraState(camera.GetViewMatrix(), camera.GetProjectionMatrix());
int width = 800, height = 600;
renderer.Render(width, height);
uint32_t texID = renderer.GetColorTextureID();
std::cout << " Color texture ID: " << texID << std::endl;
TEST_ASSERT(texID != 0, "Renderer produced a valid texture ID");
GfVec3f bgColor = renderer.GetBackgroundColor();
std::cout << " Background color: (" << bgColor[0] << ", " << bgColor[1] << ", " << bgColor[2] << ")" << std::endl;
return true;
}
bool Test_RendererDrawTargetValid() {
std::cout << "\n=== Test 7: Renderer DrawTarget Validity ===" << std::endl;
if (!GL::InitExtensions()) {
TEST_SKIP("OpenGL extensions not available");
}
UsdStageRefPtr stage = CreateTestStageWithCube();
TEST_ASSERT(stage != nullptr, "Test stage created");
UsdSceneRenderer renderer;
renderer.SetStage(stage);
ViewportCamera camera;
camera.SetStage(stage);
GfRange3d bounds = renderer.ComputeStageBounds();
if (!bounds.IsEmpty()) {
camera.FrameBoundingBox(bounds);
}
camera.SetAspectRatio(400.0f / 300.0f);
renderer.SetCameraState(camera.GetViewMatrix(), camera.GetProjectionMatrix());
renderer.Render(400, 300);
auto drawTarget = renderer.GetDrawTargetForTest();
TEST_ASSERT(drawTarget != nullptr, "DrawTarget is not null after render");
if (drawTarget) {
GLuint fboId = drawTarget->GetFramebufferId();
auto colorAttach = drawTarget->GetAttachment("color");
auto depthAttach = drawTarget->GetAttachment("depth");
std::cout << " FBO ID: " << fboId << std::endl;
std::cout << " Color attachment: " << (colorAttach ? "present" : "MISSING") << std::endl;
std::cout << " Depth attachment: " << (depthAttach ? "present" : "MISSING") << std::endl;
TEST_ASSERT(fboId != 0, "FBO ID is non-zero");
TEST_ASSERT(colorAttach != nullptr, "Color attachment exists");
TEST_ASSERT(depthAttach != nullptr, "Depth attachment exists");
if (colorAttach) {
GLuint texId = colorAttach->GetGlTextureName();
std::cout << " Color texture ID: " << texId << std::endl;
TEST_ASSERT(texId != 0, "Color attachment has valid GL texture");
GfVec2i texSize = drawTarget->GetSize();
std::cout << " DrawTarget size: " << texSize[0] << "x" << texSize[1] << std::endl;
TEST_ASSERT(texSize[0] > 0 && texSize[1] > 0, "DrawTarget has non-zero size");
}
}
return true;
}
bool Test_MultipleRenderFrames() {
std::cout << "\n=== Test 8: Multiple Render Frames (Stability) ===" << std::endl;
if (!GL::InitExtensions()) {
TEST_SKIP("OpenGL extensions not available");
}
UsdStageRefPtr stage = CreateTestStageWithCube();
TEST_ASSERT(stage != nullptr, "Stage created for stability test");
UsdSceneRenderer renderer;
renderer.SetStage(stage);
ViewportCamera camera;
camera.SetStage(stage);
GfRange3d bounds = renderer.ComputeStageBounds();
if (!bounds.IsEmpty()) {
camera.FrameBoundingBox(bounds);
}
camera.SetAspectRatio(400.0f / 300.0f);
renderer.SetCameraState(camera.GetViewMatrix(), camera.GetProjectionMatrix());
for (int i = 0; i < 5; ++i) {
renderer.Render(400, 300);
uint32_t texID = renderer.GetColorTextureID();
if (texID == 0) {
std::cout << "[FAIL] Render frame " << i << " produced invalid texture" << std::endl;
g_testsFailed++;
return false;
}
}
std::cout << " [PASS] 5 consecutive renders completed successfully" << std::endl;
g_testsPassed++;
return true;
}
bool Test_CameraOrbitAndRender() {
std::cout << "\n=== Test 9: Camera Orbit + Render ===" << std::endl;
if (!GL::InitExtensions()) {
TEST_SKIP("OpenGL extensions not available");
}
UsdStageRefPtr stage = CreateTestStageWithCube();
TEST_ASSERT(stage != nullptr, "Stage created for orbit test");
UsdSceneRenderer renderer;
renderer.SetStage(stage);
ViewportCamera camera;
camera.SetStage(stage);
GfRange3d bounds = renderer.ComputeStageBounds();
if (!bounds.IsEmpty()) {
camera.FrameBoundingBox(bounds);
}
camera.SetAspectRatio(400.0f / 300.0f);
for (int angle = 0; angle < 4; ++angle) {
camera.Orbit(45.0f, 0.0f);
renderer.SetCameraState(camera.GetViewMatrix(), camera.GetProjectionMatrix());
renderer.Render(400, 300);
uint32_t texID = renderer.GetColorTextureID();
if (texID == 0) {
std::cout << "[FAIL] Render after orbit " << angle << " failed" << std::endl;
g_testsFailed++;
return false;
}
}
std::cout << " [PASS] Renders after camera orbit completed" << std::endl;
g_testsPassed++;
return true;
}
bool Test_EmptyStageRender() {
std::cout << "\n=== Test 10: Empty Stage Render ===" << std::endl;
if (!GL::InitExtensions()) {
TEST_SKIP("OpenGL extensions not available");
}
UsdStageRefPtr stage = UsdStage::CreateInMemory();
TEST_ASSERT(stage != nullptr, "Empty in-memory stage created");
UsdSceneRenderer renderer;
renderer.SetBackgroundColor(GfVec3f(0.1f, 0.1f, 0.15f));
renderer.SetStage(stage);
ViewportCamera camera;
camera.SetStage(stage);
camera.SetAspectRatio(400.0f / 300.0f);
renderer.SetCameraState(camera.GetViewMatrix(), camera.GetProjectionMatrix());
renderer.Render(400, 300);
uint32_t texID = renderer.GetColorTextureID();
TEST_ASSERT(texID != 0, "Empty stage still produces a valid texture");
auto drawTarget = renderer.GetDrawTargetForTest();
if (drawTarget) {
std::cout << " Empty stage FBO: " << drawTarget->GetFramebufferId() << std::endl;
std::cout << " [PASS] Empty stage render produces valid FBO" << std::endl;
g_testsPassed++;
}
return true;
}
bool Test_CameraFrameSceneIntegration() {
std::cout << "\n=== Test 11: Camera + FrameScene Integration ===" << std::endl;
UsdStageRefPtr stage = CreateTestStageWithCube();
TEST_ASSERT(stage != nullptr, "Stage created for integration test");
ViewportCamera camera;
camera.SetStage(stage);
UsdSceneRenderer renderer;
renderer.SetStage(stage);
GfRange3d bounds = renderer.ComputeStageBounds();
TEST_ASSERT(!bounds.IsEmpty(), "Stage has bounds for framing");
camera.FrameBoundingBox(bounds);
float nearClip = camera.GetNearClip();
float farClip = camera.GetFarClip();
float distance = 0.0f;
GfVec3d eye = camera.GetEye();
GfVec3d focal = camera.GetFocalPoint();
GfVec3d diff = eye - focal;
distance = static_cast<float>(diff.GetLength());
std::cout << " Camera distance after FrameBoundingBox: " << distance << std::endl;
std::cout << " Near clip: " << nearClip << ", Far clip: " << farClip << std::endl;
std::cout << " Eye: (" << eye[0] << ", " << eye[1] << ", " << eye[2] << ")" << std::endl;
TEST_ASSERT(distance > 0.0f, "Camera has non-zero distance from focal point");
TEST_ASSERT(nearClip > 0.0f, "Near clip is positive");
TEST_ASSERT(farClip > nearClip, "Far clip is beyond near clip");
TEST_ASSERT(nearClip < distance, "Near clip is less than camera distance (scene is in front of camera)");
GfMatrix4d view = camera.GetViewMatrix();
GfMatrix4d proj = camera.GetProjectionMatrix();
GfVec4d originView = MulMatrixVec4(view, GfVec4d(0, 0, 0, 1));
if (originView[3] != 0.0) {
GfVec4d originClip = MulMatrixVec4(proj, originView);
if (originClip[3] != 0.0) {
double ndcZ = originClip[2] / originClip[3];
std::cout << " Scene origin NDC Z: " << ndcZ << std::endl;
bool zInRange = (ndcZ >= -1.0 && ndcZ <= 1.0);
TEST_ASSERT(zInRange, "Scene origin is within NDC Z range [-1,1] - visible in depth");
}
}
return true;
}
int main() {
std::cout << "============================================" << std::endl;
std::cout << " Viewport Display Logic Test Suite" << std::endl;
std::cout << "============================================" << std::endl;
char exePath[MAX_PATH];
GetModuleFileNameA(nullptr, exePath, MAX_PATH);
std::string exeDir(exePath);
size_t lastSlash = exeDir.find_last_of("\\/");
if (lastSlash != std::string::npos) {
exeDir = exeDir.substr(0, lastSlash);
}
std::string pluginPath = exeDir + "\\usd";
SetEnvironmentVariableA("PXR_PLUGINPATH_NAME", pluginPath.c_str());
Logger::Instance().SetLogLevel(LogLevel::Warning);
if (!CreateGLContext()) {
std::cerr << "FATAL: Cannot create OpenGL context. Tests require a valid GL context." << std::endl;
return 1;
}
GL::InitExtensions();
Test_StageCreation();
Test_StageBounds();
Test_CameraSetup();
Test_CameraAspectRatio();
Test_ViewProjectionSanity();
Test_CameraFrameSceneIntegration();
Test_RendererInitAndRender();
Test_RendererDrawTargetValid();
Test_MultipleRenderFrames();
Test_CameraOrbitAndRender();
Test_EmptyStageRender();
std::cout << "\n============================================" << std::endl;
std::cout << " Results: " << g_testsPassed << " passed, "
<< g_testsFailed << " failed, "
<< g_testsSkipped << " skipped" << std::endl;
std::cout << "============================================" << std::endl;
if (g_testsFailed > 0) {
std::cout << "\n DIAGNOSIS: If Test 5 (View/Projection Sanity) shows the origin" << std::endl;
std::cout << " is outside the frustum, the camera framing logic in" << std::endl;
std::cout << " ViewportCamera::FrameBoundingBox() is broken. Check:" << std::endl;
std::cout << " 1. The view matrix construction in ComputeFreeViewMatrix()" << std::endl;
std::cout << " 2. The projection matrix in ComputeFreeProjectionMatrix()" << std::endl;
std::cout << " 3. Whether GfMatrix4d row/column conventions match USD's expectations" << std::endl;
}
DestroyGLContext();
return g_testsFailed > 0 ? 1 : 0;
}
Reference in New Issue View Git Blame Copy Permalink