VuoRenderedLayers.c

Go to the documentation of this file.

 
#include "type.h"
#include "VuoRenderedLayers.h"
#include "VuoImageText.h"
#include "VuoSceneText.h"
 
#ifdef VUO_COMPILER
VuoModuleMetadata({
                     "title" : "Window State",
                     "description" : "A set of layers, transformed to their final positions for rendering",
                     "keywords" : [ ],
                     "version" : "1.0.0",
                     "dependencies" : [
                         "VuoInteraction",
                         "VuoImageText",
                         "VuoRectangle",
                         "VuoSceneObject",
                         "VuoSceneText",
                         "VuoWindowReference",
                         "VuoList_VuoInteraction",
                         "VuoList_VuoSceneObject"
                     ]
                 });
#endif
 
bool VuoRenderedLayers_getTransformedLayer2(VuoRenderedLayers renderedLayers, float localToWorldMatrix[16], VuoSceneObject targetObject, VuoPoint2d *layerCenter, VuoPoint2d layerCorners[4]);
 
VuoRenderedLayers VuoRenderedLayers_make(   VuoSceneObject rootSceneObject,
                                            unsigned long int pixelsWide,
                                            unsigned long int pixelsHigh,
                                            float backingScaleFactor,
                                            VuoList_VuoInteraction interactions)
{
    VuoRenderedLayers rl;
    rl.rootSceneObject = rootSceneObject;
    rl.pixelsWide = pixelsWide;
    rl.pixelsHigh = pixelsHigh;
    rl.backingScaleFactor = backingScaleFactor;
    rl.window = 0;
    rl.interactions = interactions;
    rl.hasRootSceneObject = true;
    rl.hasRenderingDimensions = true;
    rl.hasWindow = false;
    return rl;
}
 
VuoRenderedLayers VuoRenderedLayers_makeWithWindow(VuoSceneObject rootSceneObject,
                                                   unsigned long int pixelsWide, unsigned long int pixelsHigh,
                                                   float backingScaleFactor,
                                                   VuoWindowReference window,
                                                   VuoList_VuoInteraction interactions)
{
    VuoRenderedLayers rl;
    rl.rootSceneObject = rootSceneObject;
    rl.pixelsWide = pixelsWide;
    rl.pixelsHigh = pixelsHigh;
    rl.backingScaleFactor = backingScaleFactor;
    rl.window = window;
    rl.interactions = interactions;
    rl.hasRootSceneObject = true;
    rl.hasRenderingDimensions = true;
    rl.hasWindow = true;
    return rl;
}
 
VuoRenderedLayers VuoRenderedLayers_makeEmpty(void)
{
    VuoRenderedLayers rl;
 
    rl.interactions = NULL;
 
    rl.hasRootSceneObject = false;
    rl.rootSceneObject = VuoSceneObject_makeEmpty();
 
    rl.hasRenderingDimensions = false;
    rl.pixelsWide = 0;
    rl.pixelsHigh = 0;
    rl.backingScaleFactor = 1;
 
    rl.hasWindow = false;
    rl.window = NULL;
 
    return rl;
}
 
void VuoRenderedLayers_setInteractions(VuoRenderedLayers *renderedLayers, VuoList_VuoInteraction interactions)
{
    renderedLayers->interactions = interactions;
}
 
void VuoRenderedLayers_setRootSceneObject(VuoRenderedLayers *renderedLayers, VuoSceneObject rootSceneObject)
{
    renderedLayers->hasRootSceneObject = true;
    renderedLayers->rootSceneObject = rootSceneObject;
}
 
void VuoRenderedLayers_setWindow(VuoRenderedLayers *renderedLayers, VuoWindowReference window)
{
    renderedLayers->hasWindow = true;
    renderedLayers->window = window;
}
 
bool VuoRenderedLayers_getInteractions(const VuoRenderedLayers renderedLayers, VuoList_VuoInteraction *interactions)
{
    if (renderedLayers.interactions)
    {
        *interactions = renderedLayers.interactions;
        return true;
    }
 
    return false;
}
 
bool VuoRenderedLayers_getRootSceneObject(const VuoRenderedLayers renderedLayers, VuoSceneObject *rootSceneObject)
{
    if (renderedLayers.hasRootSceneObject)
    {
        *rootSceneObject = renderedLayers.rootSceneObject;
        return true;
    }
 
    return false;
}
 
bool VuoRenderedLayers_getRenderingDimensions(const VuoRenderedLayers renderedLayers, unsigned long int *pixelsWide, unsigned long int *pixelsHigh, float *backingScaleFactor)
{
    if (renderedLayers.hasRenderingDimensions)
    {
        *pixelsWide = renderedLayers.pixelsWide;
        *pixelsHigh = renderedLayers.pixelsHigh;
        *backingScaleFactor = renderedLayers.backingScaleFactor;
        return true;
    }
 
    return false;
}
 
bool VuoRenderedLayers_getWindow(const VuoRenderedLayers renderedLayers, VuoWindowReference *window)
{
    if (renderedLayers.hasWindow)
    {
        *window = renderedLayers.window;
        return true;
    }
 
    return false;
}
 
bool VuoRenderedLayers_windowChanged(const VuoRenderedLayers accumulatedRenderedLayers, const VuoRenderedLayers newerRenderedLayers)
{
    VuoWindowReference window;
    if (VuoRenderedLayers_getWindow(newerRenderedLayers, &window))
    {
        VuoWindowReference oldWindow;
        bool hasWindow = VuoRenderedLayers_getWindow(accumulatedRenderedLayers, &oldWindow);
        if (! hasWindow || oldWindow != window)
            return true;
    }
 
    return false;
}
 
void VuoRenderedLayers_update(VuoRenderedLayers *accumulatedRenderedLayers, const VuoRenderedLayers newerRenderedLayers,
                              bool *renderingDimensionsChanged)
{
    *renderingDimensionsChanged = false;
 
    VuoRetain(newerRenderedLayers.interactions);
    VuoRelease(accumulatedRenderedLayers->interactions);
    VuoRenderedLayers_setInteractions(accumulatedRenderedLayers, newerRenderedLayers.interactions);
 
    VuoSceneObject rootSceneObject;
    if (VuoRenderedLayers_getRootSceneObject(newerRenderedLayers, &rootSceneObject))
    {
        VuoSceneObject_retain(rootSceneObject);
        VuoSceneObject_release(accumulatedRenderedLayers->rootSceneObject);
        VuoRenderedLayers_setRootSceneObject(accumulatedRenderedLayers, rootSceneObject);
    }
 
    VuoWindowReference window;
    if (VuoRenderedLayers_getWindow(newerRenderedLayers, &window))
    {
        VuoRetain(window);
        VuoRelease(accumulatedRenderedLayers->window);
        VuoRenderedLayers_setWindow(accumulatedRenderedLayers, window);
    }
 
    if (VuoRenderedLayers_getWindow(*accumulatedRenderedLayers, &window))
    {
        VuoInteger pixelsWide;
        VuoInteger pixelsHigh;
        float backingScaleFactor;
        VuoWindowReference_getContentSize(window, &pixelsWide, &pixelsHigh, &backingScaleFactor);
 
        if (! accumulatedRenderedLayers->hasRenderingDimensions ||
                accumulatedRenderedLayers->pixelsWide != pixelsWide || accumulatedRenderedLayers->pixelsHigh != pixelsHigh || accumulatedRenderedLayers->backingScaleFactor != backingScaleFactor)
            *renderingDimensionsChanged = true;
 
        accumulatedRenderedLayers->hasRenderingDimensions = true;
        accumulatedRenderedLayers->pixelsWide = pixelsWide;
        accumulatedRenderedLayers->pixelsHigh = pixelsHigh;
        accumulatedRenderedLayers->backingScaleFactor = backingScaleFactor;
    }
}
 
bool VuoRenderedLayers_findLayer(VuoRenderedLayers renderedLayers, VuoText layerName, VuoList_VuoSceneObject ancestorObjects, VuoSceneObject *foundObject)
{
    return VuoSceneObject_find(renderedLayers.rootSceneObject, layerName, ancestorObjects, foundObject);
}
 
bool VuoRenderedLayers_findLayerId(VuoRenderedLayers renderedLayers, uint64_t layerId, VuoList_VuoSceneObject ancestorObjects, VuoSceneObject *foundObject)
{
    return VuoSceneObject_findById(renderedLayers.rootSceneObject, layerId, ancestorObjects, foundObject);
}
 
void VuoRenderedLayers_applyTransforms( VuoRenderedLayers renderedLayers,
                                        VuoList_VuoSceneObject ancestorObjects,
                                        VuoSceneObject targetObject,
                                        VuoPoint3d* layerCenter3d,
                                        VuoPoint3d layerCorners3d[4],
                                        bool applyTargetTransform)
{
    float matrix[16];
    VuoPoint3d center = *layerCenter3d;
    bool isText = targetObject.type == VuoSceneObjectSubType_Text && targetObject.text != NULL;
 
    if (targetObject.isRealSize || (isText && !targetObject.scaleWithScene))
    {
        // Real-size layer:
        // Apply the layer's transformations to the center point.
        unsigned long ancestorObjectCount = VuoListGetCount_VuoSceneObject(ancestorObjects);
 
        // apply local transform first
        if(applyTargetTransform)
        {
            VuoTransform_getMatrix(targetObject.transform, matrix);
            center = VuoTransform_transformPoint(matrix, center);
        }
 
        for (unsigned long i = ancestorObjectCount; i >= 1; --i)
        {
            VuoSceneObject ancestorObject = VuoListGetValue_VuoSceneObject(ancestorObjects, i);
            VuoTransform_getMatrix(ancestorObject.transform, matrix);
            center = VuoTransform_transformPoint(matrix, center);
        }
    }
    else
    {
        // Scaled layer:
        // Apply the layer's transformations to each of its corner points.
        unsigned long ancestorObjectCount = VuoListGetCount_VuoSceneObject(ancestorObjects);
 
        // local transform first
        if(applyTargetTransform)
        {
            VuoTransform_getMatrix(targetObject.transform, matrix);
 
            for(int i = 0; i < 4; i++)
                layerCorners3d[i] = VuoTransform_transformPoint(matrix, layerCorners3d[i]);
 
            center = VuoTransform_transformPoint(matrix, center);
        }
 
        for (unsigned long i = ancestorObjectCount; i >= 1; --i)
        {
            VuoSceneObject ancestorObject = VuoListGetValue_VuoSceneObject(ancestorObjects, i);
            VuoTransform_getMatrix(ancestorObject.transform, matrix);
            if(layerCorners3d != NULL)
            {
                for (int i = 0; i < 4; ++i)
                    layerCorners3d[i] = VuoTransform_transformPoint(matrix, layerCorners3d[i]);
            }
            center = VuoTransform_transformPoint(matrix, center);
        }
    }
 
    *layerCenter3d = center;
}
 
bool VuoRenderedLayers_getLayerCorners(const VuoSceneObject targetObject, VuoPoint3d layerCorners3d[4])
{
    if( targetObject.mesh == NULL ||
        targetObject.mesh->submeshCount < 1 ||
        targetObject.mesh->submeshes[0].vertexCount < 3)
        return false;
 
    VuoSubmesh layerQuad = targetObject.mesh->submeshes[0];
 
    // point3d because transformations are carried out using 3d transform functions
    layerCorners3d[0] = VuoPoint3d_make(layerQuad.positions[0].x, layerQuad.positions[0].y, 0);
    layerCorners3d[1] = VuoPoint3d_make(layerQuad.positions[1].x, layerQuad.positions[1].y, 0);
    layerCorners3d[2] = VuoPoint3d_make(layerQuad.positions[2].x, layerQuad.positions[2].y, 0);
    layerCorners3d[3] = VuoPoint3d_make(layerQuad.positions[3].x, layerQuad.positions[3].y, 0);
 
    return true;
}
 
VuoPoint3d VuoRenderedLayers_getQuadCenter(VuoPoint3d layerCorners3d[4])
{
    VuoPoint3d c = layerCorners3d[0];
 
    for(int i = 1; i < 4; i++)
    {
        c.x += layerCorners3d[i].x;
        c.y += layerCorners3d[i].y;
    }
 
    return VuoPoint3d_multiply(c, .25);
}
 
bool VuoRenderedLayers_getRectRecursive(VuoRenderedLayers renderedLayers, float compositeMatrix[16], VuoSceneObject targetObject, VuoRectangle* rect, bool rectIsInitialized)
{
    bool foundRect = rectIsInitialized;
    VuoPoint2d layerCenter;
    VuoPoint2d layerCorners[4];
 
    // apply targetObject transform
    float localToWorldMatrix[16];
    float modelMatrix[16];
 
    VuoTransform_getMatrix(targetObject.transform, modelMatrix);
    VuoTransform_multiplyMatrices4x4(modelMatrix, compositeMatrix, localToWorldMatrix);
 
    if( VuoRenderedLayers_getTransformedLayer2(renderedLayers, localToWorldMatrix, targetObject, &layerCenter, layerCorners) )
    {
        VuoRectangle thisRect = VuoRenderedLayers_getBoundingBox(layerCorners);
 
        if(rectIsInitialized)
            *rect = VuoRectangle_union(*rect, thisRect);
        else
            *rect = thisRect;
 
        foundRect = true;
    }
 
    int children = VuoListGetCount_VuoSceneObject(targetObject.childObjects);
 
    for(int i = 1; i <= children; i++)
    {
        VuoSceneObject child = VuoListGetValue_VuoSceneObject(targetObject.childObjects, i);
 
        if( VuoRenderedLayers_getRectRecursive(renderedLayers, localToWorldMatrix, child, rect, foundRect) )
            foundRect = true;
    }
 
    return foundRect;
}
 
bool VuoRenderedLayers_getRect(VuoRenderedLayers renderedLayers, VuoSceneObject layer, VuoRectangle* rect)
{
    float identity[16] = {
        1, 0, 0, 0,
        0, 1, 0, 0,
        0, 0, 1, 0,
        0, 0, 0, 1,
    };
 
    return VuoRenderedLayers_getRectRecursive(renderedLayers, identity, layer, rect, false);
}
 
bool VuoRenderedLayers_getTransformedLayer(
    VuoRenderedLayers renderedLayers,
    VuoList_VuoSceneObject ancestorObjects,
    VuoSceneObject targetObject,
    VuoPoint2d *layerCenter,
    VuoPoint2d layerCorners[4],
    bool includeChildrenInBounds)
{
    for (int i = 0; i < 4; ++i)
        layerCorners[i] = (VuoPoint2d){NAN,NAN};
 
    // Get the layer's corner points.
    VuoPoint3d layerCorners3d[4];
 
    if(includeChildrenInBounds)
    {
        VuoRectangle rect;
 
        if(!VuoRenderedLayers_getRect(renderedLayers, targetObject, &rect))
            return false;
 
        VuoPoint2d c = rect.center;
        VuoPoint2d e = VuoPoint2d_multiply(rect.size, .5);
 
        layerCorners3d[0] = VuoPoint3d_make( c.x - e.x, c.y - e.y, 0. );
        layerCorners3d[1] = VuoPoint3d_make( c.x + e.x, c.y - e.y, 0. );
        layerCorners3d[2] = VuoPoint3d_make( c.x - e.x, c.y + e.y, 0. );
        layerCorners3d[3] = VuoPoint3d_make( c.x + e.x, c.y + e.y, 0. );
    }
    else
    {
        if( !VuoRenderedLayers_getLayerCorners(targetObject, layerCorners3d) )
            return false;
    }
 
    bool isText = targetObject.type == VuoSceneObjectSubType_Text && targetObject.text != NULL;
 
    // if includeChildren is true VuoRenderedLayers_getRect will have already applied scale
    if(!includeChildrenInBounds && !isText && targetObject.shader != NULL)
    {
        for (int i = 0; i < 4; ++i)
        {
            layerCorners3d[i].x *= targetObject.shader->objectScale;
            layerCorners3d[i].y *= targetObject.shader->objectScale;
        }
    }
 
    // Transform the layer to the rendered layers' coordinate space.
    VuoPoint3d layerCenter3d = VuoRenderedLayers_getQuadCenter(layerCorners3d);
 
    VuoRenderedLayers_applyTransforms(renderedLayers, ancestorObjects, targetObject, &layerCenter3d, layerCorners3d, !includeChildrenInBounds);
 
    for (int i = 0; i < 4; ++i)
        layerCorners[i] = VuoPoint2d_make(layerCorners3d[i].x, layerCorners3d[i].y);
 
    *layerCenter = VuoPoint2d_make(layerCenter3d.x, layerCenter3d.y);
 
    return true;
}
 
bool VuoRenderedLayers_getTransformedPoint(VuoRenderedLayers renderedLayers, VuoList_VuoSceneObject ancestorObjects, VuoSceneObject targetObject, VuoPoint2d point, VuoPoint2d *transformedPoint)
{
    if(targetObject.shader == NULL)
        return false;
 
    VuoPoint3d tp = VuoPoint3d_make(point.x, point.y, 0);
 
    tp.x *= targetObject.shader->objectScale;
    tp.y *= targetObject.shader->objectScale;
 
    // Transform the layer to the rendered layers' coordinate space.
    VuoRenderedLayers_applyTransforms(renderedLayers, ancestorObjects, targetObject, &tp, NULL, true);
 
    *transformedPoint = VuoPoint2d_make(tp.x, tp.y);
 
    return true;
}
 
bool VuoRenderedLayers_getInverseTransformedPointLayer(VuoRenderedLayers renderedLayers, uint64_t targetLayer, VuoPoint2d point, VuoPoint2d* localPoint)
{
    VuoList_VuoSceneObject ancestors = VuoListCreate_VuoSceneObject();
    VuoLocal(ancestors);
    VuoSceneObject target;
 
    if( VuoRenderedLayers_findLayerId(renderedLayers, targetLayer, ancestors, &target) )
    {
        VuoSceneObject dummy = VuoSceneObject_makeEmpty();
 
        if(VuoRenderedLayers_getInverseTransformedPoint(renderedLayers, ancestors, dummy, point, localPoint))
            return true;
    }
 
    return false;
}
bool VuoRenderedLayers_getInverseTransformedPoint(VuoRenderedLayers renderedLayers, VuoList_VuoSceneObject ancestorObjects, VuoSceneObject targetObject, VuoPoint2d point, VuoPoint2d *inverseTransformedPoint)
{
    float localToWorldMatrix[16];
    float tmp[16];
    float modelMatrix[16];
 
    // start off with the targetObject matrix, then work up
    VuoTransform_getMatrix(targetObject.transform, localToWorldMatrix);
 
    int count = VuoListGetCount_VuoSceneObject(ancestorObjects);
 
    for(int i = count; i > 0; i--)
    {
        // apply targetObject transform
        VuoSceneObject node = VuoListGetValue_VuoSceneObject(ancestorObjects, i);
 
        VuoTransform_copyMatrix4x4(localToWorldMatrix, tmp);
        VuoTransform_getMatrix(node.transform, modelMatrix);
        VuoTransform_multiplyMatrices4x4(modelMatrix, tmp, localToWorldMatrix);
    }
 
    float worldToLocalMatrix[16];
    VuoTransform_invertMatrix4x4(localToWorldMatrix, worldToLocalMatrix);
 
    VuoPoint3d point3d = VuoPoint3d_make(point.x, point.y, 0);
    VuoPoint3d invPoint = VuoTransform_transformPoint(worldToLocalMatrix, point3d);
 
    if(targetObject.shader != NULL)
    {
        invPoint.x /= targetObject.shader->objectScale;
        invPoint.y /= targetObject.shader->objectScale;
    }
 
    *inverseTransformedPoint = VuoPoint2d_make(invPoint.x, invPoint.y);
 
    return true;
}
 
bool VuoRenderedLayers_getTransformedLayer2(VuoRenderedLayers renderedLayers, float localToWorldMatrix[16], VuoSceneObject targetObject, VuoPoint2d *layerCenter, VuoPoint2d layerCorners[4])
{
    // Get the layer's corner points.
    VuoPoint3d layerCorners3d[4];
 
    if( !VuoRenderedLayers_getLayerCorners(targetObject, layerCorners3d) )
        return false;
 
    bool isText = targetObject.type == VuoSceneObjectSubType_Text && targetObject.text != NULL;
 
    if(targetObject.shader == NULL && !isText)
        return false;
 
    if(!isText)
    {
        for (int i = 0; i < 4; ++i)
        {
            layerCorners3d[i].x *= targetObject.shader->objectScale;
            layerCorners3d[i].y *= targetObject.shader->objectScale;
        }
    }
 
    // Transform the layer to the rendered layers' coordinate space.
    VuoPoint3d center = VuoPoint3d_make(0,0,0);
 
    if (targetObject.isRealSize || isText)
    {
        // Real-size layer:
        // Apply the layer's transformations to the center point.
        center = VuoTransform_transformPoint(localToWorldMatrix, center);
 
        float widthScale = 1, heightScale = 1;
 
        // Scale the layer's corner points to the rendered layers' coordinate space.
        if(isText)
        {
            float verticalScale = 1.;
            float rotationZ = 0.;
            if (targetObject.scaleWithScene)
            {
                VuoTransform transform = VuoTransform_makeFromMatrix4x4(localToWorldMatrix);
                widthScale    = transform.scale.x;
                verticalScale = transform.scale.y / transform.scale.x;
                rotationZ     = VuoTransform_getEuler(transform).z;
            }
 
            VuoPoint2d size = VuoRenderedLayers_getTextSize(renderedLayers, targetObject.text, targetObject.font, targetObject.scaleWithScene, verticalScale, rotationZ, targetObject.wrapWidth, true);
 
            center.xy += VuoSceneText_getAnchorOffset(targetObject, verticalScale, rotationZ, targetObject.wrapWidth,
                targetObject.scaleWithScene ? VuoGraphicsWindowDefaultWidth * renderedLayers.backingScaleFactor : renderedLayers.pixelsWide,
                renderedLayers.backingScaleFactor);
 
            widthScale *= size.x;
            heightScale *= size.y;
        }
        else
        {
            VuoImage image = VuoShader_getUniform_VuoImage(targetObject.shader, "texture");
 
            widthScale = 2. * (float)image->pixelsWide / (float)renderedLayers.pixelsWide;
            heightScale = widthScale * (float)image->pixelsHigh / (float)image->pixelsWide;
 
            VuoReal combinedScaleFactor = 1;
 
            if (targetObject.preservePhysicalSize)
                combinedScaleFactor = renderedLayers.backingScaleFactor / image->scaleFactor;
 
            widthScale  *= combinedScaleFactor;
            heightScale *= combinedScaleFactor;
        }
 
        for (int i = 0; i < 4; ++i)
        {
            layerCorners3d[i].x *= widthScale;
            layerCorners3d[i].y *= heightScale;
 
            layerCorners3d[i].x += center.x;
            layerCorners3d[i].y += center.y;
        }
    }
    else
    {
        // Scaled layer:
        // Apply the layer's transformations to each of its corner points.
        for (int i = 0; i < 4; ++i)
            layerCorners3d[i] = VuoTransform_transformPoint(localToWorldMatrix, layerCorners3d[i]);
 
        center = VuoTransform_transformPoint(localToWorldMatrix, center);
    }
 
    for (int i = 0; i < 4; ++i)
        layerCorners[i] = VuoPoint2d_make(layerCorners3d[i].x, layerCorners3d[i].y);
 
    *layerCenter = VuoPoint2d_make(center.x, center.y);
 
    return true;
}
 
VuoPoint2d VuoRenderedLayers_getTextSize(VuoRenderedLayers renderedLayers, VuoText text, VuoFont font, bool scaleWithScene, float verticalScale, float rotationZ, float wrapWidth, bool includeTrailingWhiteSpace)
{
    // If we don't know the size of the render destination,
    // we can't calculate the size of real-size text.
    if (!scaleWithScene && (renderedLayers.pixelsWide < 1 || renderedLayers.pixelsHigh < 1))
        return VuoPoint2d_make(0, 0);
 
    VuoRectangle textBounds = VuoImage_getTextRectangle(text, font, renderedLayers.backingScaleFactor, verticalScale, rotationZ, wrapWidth, includeTrailingWhiteSpace);
 
    float w = textBounds.size.x;
    float h = textBounds.size.y;
 
    VuoPoint2d size;
    if (scaleWithScene)
        size.x = (w / (float)(VuoGraphicsWindowDefaultWidth * renderedLayers.backingScaleFactor)) * 2;
    else
        size.x = (w / (float)renderedLayers.pixelsWide) * 2;
    size.y = size.x * (h / w);
 
    return size;
}
 
VuoRectangle VuoRenderedLayers_getBoundingBox(VuoPoint2d layerCorners[4])
{
    VuoPoint2d min = VuoPoint2d_make( INFINITY,  INFINITY);
    VuoPoint2d max = VuoPoint2d_make(-INFINITY, -INFINITY);
    for (int i = 0; i < 4; ++i)
    {
        if (isnan(layerCorners[i].x) || isnan(layerCorners[i].y))
            goto nan;
 
        if (layerCorners[i].x < min.x)
            min.x = layerCorners[i].x;
        if (layerCorners[i].x > max.x)
            max.x = layerCorners[i].x;
        if (layerCorners[i].y < min.y)
            min.y = layerCorners[i].y;
        if (layerCorners[i].y > max.y)
            max.y = layerCorners[i].y;
    }
    return VuoRectangle_make(
                min.x + (max.x-min.x)/2.,
                min.y + (max.y-min.y)/2.,
                max.x-min.x,
                max.y-min.y);
nan:
    return (VuoRectangle){
        (VuoPoint2d){NAN,NAN},
        (VuoPoint2d){NAN,NAN}
    };
}
 
bool VuoRenderedLayers_isPointInQuad(VuoPoint2d corners[4], VuoPoint2d point)
{
    // Split the quad into two triangles with points specified counter-clockwise, and check each triangle.
    // https://stackoverflow.com/questions/2049582/how-to-determine-a-point-in-a-triangle
    VuoPoint2d triangles[] = { corners[0], corners[1], corners[2],
                                    corners[3], corners[2], corners[1] };
    for (int i = 0; i < 2; ++i)
    {
        VuoPoint2d p0 = triangles[3*i];
        VuoPoint2d p1 = triangles[3*i+1];
        VuoPoint2d p2 = triangles[3*i+2];
        float area = 1./2.*(-p1.y*p2.x + p0.y*(-p1.x + p2.x) + p0.x*(p1.y - p2.y) + p1.x*p2.y);
        float s = 1./(2.*area)*(p0.y*p2.x - p0.x*p2.y + (p2.y - p0.y)*point.x + (p0.x - p2.x)*point.y);
        float t = 1./(2.*area)*(p0.x*p1.y - p0.y*p1.x + (p0.y - p1.y)*point.x + (p1.x - p0.x)*point.y);
        if (s >= 0 && t >= 0 && s + t <= 1)
            return true;
    }
 
    return false;
}
 
bool VuoRenderedLayers_isPointInLayerRecursive(VuoRenderedLayers renderedLayers, float compositeMatrix[16], VuoSceneObject targetObject, VuoPoint2d point)
{
    VuoPoint2d layerCenter;
    VuoPoint2d layerCorners[4];
 
    // apply targetObject transform
    float localToWorldMatrix[16];
    float modelMatrix[16];
 
    VuoTransform_getMatrix(targetObject.transform, modelMatrix);
    VuoTransform_multiplyMatrices4x4(modelMatrix, compositeMatrix, localToWorldMatrix);
 
    if( VuoRenderedLayers_getTransformedLayer2(renderedLayers, localToWorldMatrix, targetObject, &layerCenter, layerCorners) )
    {
        if( VuoRenderedLayers_isPointInQuad(layerCorners, point) )
            return true;
    }
 
    int children = VuoListGetCount_VuoSceneObject(targetObject.childObjects);
 
    for(int i = 1; i <= children; i++)
    {
        VuoSceneObject child = VuoListGetValue_VuoSceneObject(targetObject.childObjects, i);
        if( VuoRenderedLayers_isPointInLayerRecursive(renderedLayers, localToWorldMatrix, child, point) )
            return true;
    }
 
    return false;
}
 
bool VuoRenderedLayers_isPointInLayer(VuoRenderedLayers renderedLayers, VuoText layerName, VuoPoint2d point)
{
    float aspect = (double) renderedLayers.pixelsHigh / (double) renderedLayers.pixelsWide;
 
    if( point.x < -1 || point.x > 1 || point.y < -aspect || point.y > aspect )
        return false;
 
    VuoSceneObject layer;
    VuoList_VuoSceneObject ancestors = VuoListCreate_VuoSceneObject();
    VuoLocal(ancestors);
 
    if(!VuoRenderedLayers_findLayer(renderedLayers, layerName, ancestors, &layer))
        return false;
 
    float modelMatrix[16], tmp[16];
    float composite[16] = {
        1, 0, 0, 0,
        0, 1, 0, 0,
        0, 0, 1, 0,
        0, 0, 0, 1,
    };
 
    for(int i = 1; i <= VuoListGetCount_VuoSceneObject(ancestors); i++)
    {
        VuoSceneObject o = VuoListGetValue_VuoSceneObject(ancestors, i);
        VuoTransform_getMatrix(o.transform, modelMatrix);
        VuoTransform_multiplyMatrices4x4(modelMatrix, composite, tmp);
        VuoTransform_copyMatrix4x4(tmp, composite);
    }
 
    return VuoRenderedLayers_isPointInLayerRecursive(renderedLayers, composite, layer, point);
}
 
bool VuoRenderedLayers_isPointInLayerId(VuoRenderedLayers renderedLayers, uint64_t layerId, VuoPoint2d point)
{
    float aspect = (double) renderedLayers.pixelsHigh / (double) renderedLayers.pixelsWide;
 
    if( point.x < -1 || point.x > 1 || point.y < -aspect || point.y > aspect )
        return false;
 
    VuoSceneObject layer;
    VuoList_VuoSceneObject ancestors = VuoListCreate_VuoSceneObject();
    VuoLocal(ancestors);
 
    if (!VuoSceneObject_findById(renderedLayers.rootSceneObject, layerId, ancestors, &layer))
        return false;
 
    float modelMatrix[16], tmp[16];
    float composite[16] = {
        1, 0, 0, 0,
        0, 1, 0, 0,
        0, 0, 1, 0,
        0, 0, 0, 1,
    };
 
    for(int i = 1; i <= VuoListGetCount_VuoSceneObject(ancestors); i++)
    {
        VuoSceneObject o = VuoListGetValue_VuoSceneObject(ancestors, i);
        VuoTransform_getMatrix(o.transform, modelMatrix);
        VuoTransform_multiplyMatrices4x4(modelMatrix, composite, tmp);
        VuoTransform_copyMatrix4x4(tmp, composite);
    }
 
    return VuoRenderedLayers_isPointInLayerRecursive(renderedLayers, composite, layer, point);
}
 
void VuoRenderedLayers_getEventsInLayer(VuoRenderedLayers renderedLayers,
                                        uint64_t id,
                                        bool *anyHover,
                                        bool *anyPressed,
                                        bool *anyReleased,
                                        bool *anyClicked)
{
    *anyHover = false;
    *anyPressed = false;
    *anyReleased = false;
    *anyClicked = false;
 
    if(renderedLayers.interactions == NULL || VuoListGetCount_VuoInteraction(renderedLayers.interactions) < 1)
        return;
 
    for(int i = 1; i <= VuoListGetCount_VuoInteraction(renderedLayers.interactions); i++)
    {
        VuoInteraction it = VuoListGetValue_VuoInteraction(renderedLayers.interactions, i);
 
        if( VuoRenderedLayers_isPointInLayerId(renderedLayers, id, it.position) )
        {
            *anyHover = true;
 
            if(it.isPressed)
                *anyPressed = true;
 
            if( it.type == VuoInteractionType_Click )
                *anyClicked = true;
 
            if( it.type == VuoInteractionType_Release )
                *anyReleased = true;
        }
    }
}
VuoRenderedLayers VuoRenderedLayers_makeFromJson(json_object * js)
{
    json_object *o = NULL;
 
    VuoSceneObject rootSceneObject;
    if (json_object_object_get_ex(js, "rootSceneObject", &o))
        rootSceneObject = VuoSceneObject_makeFromJson(o);
    else
        rootSceneObject = VuoSceneObject_makeEmpty();
 
    VuoInteger pixelsWide = 0;
    if (json_object_object_get_ex(js, "pixelsWide", &o))
        pixelsWide = json_object_get_int64(o);
 
    VuoInteger pixelsHigh = 0;
    if (json_object_object_get_ex(js, "pixelsHigh", &o))
        pixelsHigh = json_object_get_int64(o);
 
    float backingScaleFactor = 1;
    if (json_object_object_get_ex(js, "backingScaleFactor", &o))
        backingScaleFactor = VuoReal_makeFromJson(o);
 
    VuoList_VuoInteraction interactions = NULL;
    if (json_object_object_get_ex(js, "interactions", &o))
        interactions = VuoList_VuoInteraction_makeFromJson(o);
 
    VuoRenderedLayers rl = VuoRenderedLayers_make(rootSceneObject, pixelsWide, pixelsHigh, backingScaleFactor, interactions);
 
    VuoWindowReference window = 0;
    if (json_object_object_get_ex(js, "window", &o))
        VuoRenderedLayers_setWindow(&rl, window);
 
    return rl;
}
 
json_object * VuoRenderedLayers_getJson(const VuoRenderedLayers value)
{
    json_object *js = json_object_new_object();
 
    json_object *rootSceneObjectObject = VuoSceneObject_getJson(value.rootSceneObject);
    json_object_object_add(js, "rootSceneObject", rootSceneObjectObject);
 
    json_object *pixelsWideObject = json_object_new_int64(value.pixelsWide);
    json_object_object_add(js, "pixelsWide", pixelsWideObject);
 
    json_object *pixelsHighObject = json_object_new_int64(value.pixelsHigh);
    json_object_object_add(js, "pixelsHigh", pixelsHighObject);
 
    if (value.hasWindow)
    {
        json_object *windowObject = VuoWindowReference_getJson(value.window);
        json_object_object_add(js, "window", windowObject);
    }
 
    json_object *bsfObject = VuoReal_getJson(value.backingScaleFactor);
    json_object_object_add(js, "backingScaleFactor", bsfObject);
 
    json_object *interactionObj = VuoList_VuoInteraction_getJson(value.interactions);
    json_object_object_add(js, "interactions", interactionObj);
 
    return js;
}
 
char * VuoRenderedLayers_getSummary(const VuoRenderedLayers value)
{
    char *rootSummary = VuoSceneObject_getSummary(value.rootSceneObject);
    char *windowSummary = VuoWindowReference_getSummary(value.window);
 
    char *summary = VuoText_format("%lux%lu<br>%s<br>%s", value.pixelsWide, value.pixelsHigh, windowSummary, rootSummary);
 
    free(windowSummary);
    free(rootSummary);
 
    return summary;
}