VuoLayer.c

Go to the documentation of this file.

 
#include "type.h"
#include "VuoLayer.h"
#include "VuoAnchor.h"
#include "VuoImageBlur.h"
#include "VuoImageText.h"
#include "VuoSceneText.h"
 
#ifdef VUO_COMPILER
VuoModuleMetadata({
                     "title" : "Layer",
                     "description" : "A 2D Layer: visible (image), or virtual (group).",
                     "keywords" : [ ],
                     "version" : "1.0.0",
                     "dependencies" : [
                        "VuoAnchor",
                        "VuoColor",
                        "VuoImageBlur",
                        "VuoImageText",
                        "VuoPoint2d",
                        "VuoRectangle",
                        "VuoSceneObject",
                        "VuoSceneText",
                        "VuoTransform2d",
                        "VuoWindowReference",
                        "VuoList_VuoColor",
                        "VuoList_VuoLayer",
                        "VuoList_VuoSceneObject"
                     ]
                 });
#endif
 
 
VuoLayer VuoLayer_makeEmpty(void)
{
    VuoLayer o;
    o.sceneObject = VuoSceneObject_makeEmpty();
    return o;
}
 
VuoLayer VuoLayer_make(VuoText name, VuoImage image, VuoPoint2d center, VuoReal rotation, VuoReal width, VuoReal alpha)
{
    VuoLayer o;
    VuoPoint3d center3d = VuoPoint3d_make(center.x, center.y, 0);
    VuoPoint3d rotation3d = VuoPoint3d_make(0, 0, rotation);
    o.sceneObject = VuoSceneObject_makeImage(image, center3d, rotation3d, width, alpha);
    o.sceneObject.name = name;
    return o;
}
 
VuoLayer VuoLayer_makeWithTransform(VuoText name, VuoImage image, VuoTransform2d transform, VuoReal alpha)
{
    VuoLayer o;
    VuoPoint3d center3d = VuoPoint3d_make(transform.translation.x, transform.translation.y, 0);
    // VuoSceneObject_makeImage wants rotation in degrees
    VuoPoint3d rotation3d = VuoPoint3d_make(0, 0, transform.rotation * 57.295779513f);
    o.sceneObject = VuoSceneObject_makeImage(image, center3d, rotation3d, 2, alpha);
    o.sceneObject.transform.scale = VuoPoint3d_make(transform.scale.x, transform.scale.y, 1);
    o.sceneObject.name = name;
    return o;
}
 
VuoLayer VuoLayer_makeRealSize(VuoText name, VuoImage image, VuoPoint2d center, VuoReal alpha, VuoBoolean preservePhysicalSize)
{
    VuoLayer l = VuoLayer_make(name,image,center,0,0,alpha);
    l.sceneObject.isRealSize = true;
    l.sceneObject.preservePhysicalSize = preservePhysicalSize;
    return l;
}
 
static VuoLayer VuoLayer_makeWithShadowInternal(VuoText name, VuoImage image, VuoPoint2d center, VuoReal rotation, VuoReal width, VuoReal alpha, VuoBoolean preservePhysicalSize, VuoColor shadowColor, VuoReal shadowBlur, VuoReal shadowAngle, VuoReal shadowDistance, VuoBoolean isRealSize)
{
    if (!image)
        return VuoLayer_makeEmpty();
 
    // Create a pair of layers, one for the main layer and one for the shadow, and put them in a group.
    // Apply the transformation to the individual layers, rather than to the group, so that
    // VuoRenderedLayers_getTransformedLayer() can work with the individual layers.
 
    float rotationInRadians = rotation * M_PI/180.;
    VuoTransform groupTransform = VuoTransform_makeFrom2d( VuoTransform2d_make(center, rotationInRadians, VuoPoint2d_make(width,width)) );
    float matrix[16];
    VuoTransform_getMatrix(groupTransform, matrix);
 
    VuoPoint3d center3d = VuoPoint3d_make(0,0,0);
    VuoPoint3d layerCenter3d = VuoTransform_transformPoint(matrix, center3d);
    VuoPoint2d layerCenter = VuoPoint2d_make(layerCenter3d.x, layerCenter3d.y);
    VuoLayer layer = VuoLayer_make(name, image, layerCenter, rotation, width, alpha);
    layer.sceneObject.isRealSize = isRealSize;
    layer.sceneObject.preservePhysicalSize = preservePhysicalSize;
 
    VuoList_VuoColor colors = VuoListCreate_VuoColor();
    VuoRetain(colors);
    VuoListAppendValue_VuoColor(colors, shadowColor);
    VuoImage recoloredImage = VuoImage_mapColors(image, colors, 1);
    VuoRetain(recoloredImage);
    VuoRelease(colors);
 
    VuoImageBlur *ib = VuoImageBlur_make();
    VuoRetain(ib);
    VuoImage blurredImage = VuoImageBlur_blur(ib, recoloredImage, NULL, VuoBlurShape_Gaussian, shadowBlur, 1, TRUE);
    VuoRelease(ib);
    float shadowAngleInRadians = shadowAngle * M_PI/180.;
    VuoPoint3d shadowOffset3d = VuoPoint3d_make(shadowDistance * cos(shadowAngleInRadians),
                                                shadowDistance * sin(shadowAngleInRadians),
                                                0);
    VuoPoint3d shadowCenter3d = VuoTransform_transformPoint(matrix, shadowOffset3d);
    VuoPoint2d shadowCenter = VuoPoint2d_make(shadowCenter3d.x, shadowCenter3d.y);
    VuoReal shadowWidth = width * blurredImage->pixelsWide/image->pixelsWide;
    VuoLayer shadow = VuoLayer_make(NULL, blurredImage, shadowCenter, rotation, shadowWidth, alpha);
    shadow.sceneObject.isRealSize = isRealSize;
    shadow.sceneObject.preservePhysicalSize = preservePhysicalSize;
 
    VuoList_VuoLayer layers = VuoListCreate_VuoLayer();
    VuoRetain(layers);
    VuoListAppendValue_VuoLayer(layers, shadow);
    VuoListAppendValue_VuoLayer(layers, layer);
 
    VuoRelease(recoloredImage);
 
    VuoLayer group = VuoLayer_makeGroup(layers, VuoTransform2d_makeIdentity());
    VuoRelease(layers);
 
    return group;
}
 
VuoLayer VuoLayer_makeWithShadow(VuoText name, VuoImage image, VuoPoint2d center, VuoReal rotation, VuoReal width, VuoReal alpha, VuoColor shadowColor, VuoReal shadowBlur, VuoReal shadowAngle, VuoReal shadowDistance)
{
    return VuoLayer_makeWithShadowInternal(name,image,center,rotation,width,alpha,false,shadowColor,shadowBlur,shadowAngle,shadowDistance,false);
}
 
VuoLayer VuoLayer_makeRealSizeWithShadow(VuoText name, VuoImage image, VuoPoint2d center, VuoReal alpha, VuoBoolean preservePhysicalSize, VuoColor shadowColor, VuoReal shadowBlur, VuoReal shadowAngle, VuoReal shadowDistance)
{
    return VuoLayer_makeWithShadowInternal(name,image,center,0,1,alpha,preservePhysicalSize,shadowColor,shadowBlur,shadowAngle,shadowDistance,true);
}
 
VuoLayer VuoLayer_makeColor(VuoText name, VuoColor color, VuoPoint2d center, VuoReal rotation, VuoReal width, VuoReal height)
{
    VuoLayer o;
    o.sceneObject = VuoSceneObject_makeQuad(
                VuoShader_makeUnlitColorShader(color),
                VuoPoint3d_make(center.x, center.y, 0),
                VuoPoint3d_make(0, 0, rotation),
                width,
                height
            );
    o.sceneObject.name = name;
    return o;
}
 
VuoLayer VuoLayer_makeOval(VuoText name, VuoColor color, VuoPoint2d center, VuoReal rotation, VuoReal width, VuoReal height, VuoReal sharpness)
{
    VuoLayer o;
    // Since VuoShader_makeUnlitCircleShader() produces a shader that fills half the size (to leave enough room for sharpness=0),
    // make the layer twice the specified size.
    o.sceneObject = VuoSceneObject_makeQuad(
                VuoShader_makeUnlitCircleShader(color, sharpness),
                VuoPoint3d_make(center.x, center.y, 0),
                VuoPoint3d_make(0, 0, rotation),
                width*2,
                height*2
            );
    o.sceneObject.name = name;
    return o;
}
 
VuoLayer VuoLayer_makeCheckmark(VuoText name, VuoColor fillColor, VuoColor outlineColor, VuoReal outlineThickness, VuoPoint2d center, VuoReal rotation, VuoReal width, VuoReal height)
{
    VuoLayer o;
 
    o.sceneObject = VuoSceneObject_makeQuad(
                VuoShader_makeUnlitCheckmarkShader(fillColor, outlineColor, outlineThickness),
                VuoPoint3d_make(center.x, center.y, 0),
                VuoPoint3d_make(0, 0, rotation),
                width,
                height );
    o.sceneObject.name = name;
    return o;
}
 
VuoLayer VuoLayer_makeRoundedRectangle(VuoText name, VuoColor color, VuoPoint2d center, VuoReal rotation, VuoReal width, VuoReal height, VuoReal sharpness, VuoReal roundness)
{
    VuoLayer o;
 
    o.sceneObject = VuoSceneObject_makeQuad(
                VuoShader_makeUnlitRoundedRectangleShader(color, sharpness, roundness, width/height),
                VuoPoint3d_make(center.x, center.y, 0),
                VuoPoint3d_make(0, 0, rotation),
                width  * 2,
                height * 2
                );
    o.sceneObject.name = name;
 
    return o;
}
 
VuoLayer VuoLayer_makeLinearGradient(VuoText name, VuoList_VuoColor colors, VuoPoint2d start, VuoPoint2d end, VuoPoint2d center, VuoReal rotation, VuoReal width, VuoReal height, VuoReal noiseAmount)
{
    VuoShader shader = VuoShader_makeLinearGradientShader();
    VuoShader_setLinearGradientShaderValues(shader, colors, start, end, 1, noiseAmount);
    VuoLayer o;
    o.sceneObject = VuoSceneObject_makeQuad(
                shader,
                VuoPoint3d_make(center.x, center.y, 0),
                VuoPoint3d_make(0, 0, rotation),
                width,
                height
            );
    o.sceneObject.name = name;
    return o;
}
 
VuoLayer VuoLayer_makeRadialGradient(VuoText name, VuoList_VuoColor colors, VuoPoint2d gradientCenter, VuoReal radius, VuoPoint2d center, VuoReal rotation, VuoReal width, VuoReal height, VuoReal noiseAmount)
{
    VuoShader shader = VuoShader_makeRadialGradientShader();
    VuoShader_setRadialGradientShaderValues(shader, colors, gradientCenter, radius, width, height, noiseAmount);
    VuoLayer o;
    o.sceneObject = VuoSceneObject_makeQuad(
                shader,
                VuoPoint3d_make(center.x, center.y, 0),
                VuoPoint3d_make(0, 0, rotation),
                width,
                height
            );
    o.sceneObject.name = name;
    return o;
}
 
VuoLayer VuoLayer_makeGroup(VuoList_VuoLayer childLayers, VuoTransform2d transform)
{
    VuoLayer o;
    o.sceneObject = VuoSceneObject_makeGroup(VuoListCreate_VuoSceneObject(), VuoTransform_makeFrom2d(transform));
 
    unsigned long childLayerCount = VuoListGetCount_VuoLayer(childLayers);
    for (unsigned long i = 1; i <= childLayerCount; ++i)
        VuoListAppendValue_VuoSceneObject(o.sceneObject.childObjects, VuoListGetValue_VuoLayer(childLayers, i).sceneObject);
 
    return o;
}
 
VuoLayer VuoLayer_makeGroup2(VuoLayer layer1, VuoLayer layer2, VuoTransform2d transform)
{
    VuoList_VuoLayer group = VuoListCreate_VuoLayer();
    VuoLocal(group);
    VuoListAppendValue_VuoLayer(group, layer1);
    VuoListAppendValue_VuoLayer(group, layer2);
    return VuoLayer_makeGroup(group, transform);
}
 
VuoLayer VuoLayer_makeGroup3(VuoLayer layer1, VuoLayer layer2, VuoLayer layer3, VuoTransform2d transform)
{
    VuoList_VuoLayer group = VuoListCreate_VuoLayer();
    VuoLocal(group);
    VuoListAppendValue_VuoLayer(group, layer1);
    VuoListAppendValue_VuoLayer(group, layer2);
    VuoListAppendValue_VuoLayer(group, layer3);
    return VuoLayer_makeGroup(group, transform);
}
 
VuoList_VuoLayer VuoLayer_getChildLayers(VuoLayer layer)
{
    unsigned long childLayerCount = VuoListGetCount_VuoSceneObject(layer.sceneObject.childObjects);
    if (childLayerCount == 0)
        return NULL;
 
    VuoList_VuoLayer childLayers = VuoListCreateWithCount_VuoLayer(childLayerCount, VuoLayer_makeEmpty());
    VuoLayer *childLayersData = VuoListGetData_VuoLayer(childLayers);
    VuoSceneObject *objects = VuoListGetData_VuoSceneObject(layer.sceneObject.childObjects);
    for (unsigned int i = 0; i < childLayerCount; ++i)
    {
        childLayersData[i] = (VuoLayer){objects[i]};
        VuoLayer_retain(childLayersData[i]);
    }
    return childLayers;
}
 
static VuoRectangle VuoLayer_getBoundingRectangleWithSceneObject(VuoSceneObject so, VuoInteger viewportWidth, VuoInteger viewportHeight, float backingScaleFactor)
{
    VuoRectangle b = VuoRectangle_make(NAN,NAN,0,0);
 
    float matrix[16];
 
    if (so.type == VuoSceneObjectSubType_Text)
    {
        if (so.scaleWithScene)
            viewportWidth = VuoGraphicsWindowDefaultWidth * backingScaleFactor;
 
        if (viewportWidth > 0)
        {
            b = VuoImage_getTextRectangle(so.text, so.font, backingScaleFactor, 1, 0, so.wrapWidth, true);
            b.size = VuoPoint2d_multiply(b.size, 2./viewportWidth);
 
            if (so.mesh)
            {
                VuoPoint2d anchorOffset = VuoAnchor_getOffset(VuoSceneText_getAnchor(so));
                b.center.x += anchorOffset.x * b.size.x;
                b.center.y += anchorOffset.y * b.size.y;
            }
 
            VuoTransform_getMatrix(so.transform, matrix);
            b = VuoTransform_transformRectangle(matrix, b);
        }
        else
        {
            b = VuoImage_getTextRectangle(so.text, so.font, backingScaleFactor, 1, 0, INFINITY, false);
            b.center = (VuoPoint2d){so.transform.translation.x, so.transform.translation.y};
            b.size = VuoPoint2d_multiply(b.size, 2./VuoGraphicsWindowDefaultWidth);
        }
    }
 
    if (so.shader)
    {
        VuoImage image = VuoShader_getUniform_VuoImage(so.shader, "texture");
        if (image && so.isRealSize)
        {
            VuoPoint2d mesh0 = (VuoPoint2d){so.mesh->submeshes[0].positions[0].x, so.mesh->submeshes[0].positions[0].y};
            VuoTransform_getBillboardMatrix(image->pixelsWide, image->pixelsHigh, image->scaleFactor, so.preservePhysicalSize, so.transform.translation.x, so.transform.translation.y, viewportWidth, viewportHeight, backingScaleFactor, mesh0, matrix);
        }
        else
            VuoTransform_getMatrix(so.transform, matrix);
 
        b = VuoTransform_transformRectangle(matrix, VuoRectangle_make(0,0,so.shader->objectScale,so.shader->objectScale));
    }
    else
        VuoTransform_getMatrix(so.transform, matrix);
 
    if (so.childObjects)
    {
        unsigned long childObjectCount = VuoListGetCount_VuoSceneObject(so.childObjects);
        for (unsigned long i = 1; i <= childObjectCount; ++i)
        {
            VuoSceneObject child = VuoListGetValue_VuoSceneObject(so.childObjects, i);
            VuoRectangle childBoundingBox = VuoLayer_getBoundingRectangleWithSceneObject(child, viewportWidth, viewportHeight, backingScaleFactor);
            childBoundingBox = VuoTransform_transformRectangle(matrix, childBoundingBox);
            if (!isnan(childBoundingBox.center.x))
            {
                if (!isnan(b.center.x))
                    b = VuoRectangle_union(b, childBoundingBox);
                else
                    b = childBoundingBox;
            }
        }
    }
 
    return b;
}
 
VuoLayer VuoLayer_setAnchor(VuoLayer child, VuoAnchor anchor, VuoInteger viewportWidth, VuoInteger viewportHeight, float backingScaleFactor)
{
    if (VuoAnchor_areEqual(anchor, VuoAnchor_makeCentered()))
        return child;
 
    VuoTransform childTransform = child.sceneObject.transform;
    child.sceneObject.transform = VuoTransform_makeIdentity();
 
    VuoRectangle rect = VuoLayer_getBoundingRectangle(child, viewportWidth, viewportHeight, backingScaleFactor);
 
    VuoPoint3d childTranslation = childTransform.translation;
    VuoPoint2d boundsCenter = rect.center;
    VuoPoint3d parentTranslation = VuoPoint3d_make(childTranslation.x - boundsCenter.x, childTranslation.y - boundsCenter.y, 0);
 
    if (VuoAnchor_getHorizontal(anchor) == VuoHorizontalAlignment_Left)
        boundsCenter.x += rect.size.x * .5f;
    else if (VuoAnchor_getHorizontal(anchor) == VuoHorizontalAlignment_Right)
        boundsCenter.x -= rect.size.x * .5f;
 
    if (VuoAnchor_getVertical(anchor) == VuoVerticalAlignment_Top)
        boundsCenter.y -= rect.size.y * .5f;
    else if (VuoAnchor_getVertical(anchor) == VuoVerticalAlignment_Bottom)
        boundsCenter.y += rect.size.y * .5f;
 
    child.sceneObject.transform.translation = VuoPoint3d_make(boundsCenter.x, boundsCenter.y, 0);
 
    VuoTransform parentTransform = childTransform;
    parentTransform.translation = parentTranslation;
 
    VuoLayer parent;
    parent.sceneObject = VuoSceneObject_makeGroup(VuoListCreate_VuoSceneObject(), parentTransform);
 
    parent.sceneObject.name = child.sceneObject.name;
    child.sceneObject.name = VuoText_make(VuoText_format("%s (Child)", parent.sceneObject.name));
 
    VuoListAppendValue_VuoSceneObject(parent.sceneObject.childObjects, child.sceneObject);
 
    return parent;
}
 
VuoRectangle VuoLayer_getBoundingRectangle(VuoLayer layer, VuoInteger viewportWidth, VuoInteger viewportHeight, float backingScaleFactor)
{
    return VuoLayer_getBoundingRectangleWithSceneObject(layer.sceneObject, viewportWidth, viewportHeight, backingScaleFactor);
}
 
bool VuoLayer_isPopulated(VuoLayer layer)
{
    return VuoSceneObject_isPopulated(layer.sceneObject);
}
 
VuoLayer VuoLayer_makeFromJson(json_object * js)
{
    VuoLayer o;
    o.sceneObject = VuoSceneObject_makeFromJson(js);
    return o;
}
 
json_object * VuoLayer_getJson(const VuoLayer value)
{
    return VuoSceneObject_getJson(value.sceneObject);
}
 
char * VuoLayer_getSummary(const VuoLayer value)
{
    return VuoSceneObject_getSummary(value.sceneObject);
}