VuoSceneText.c

Go to the documentation of this file.

 
#include "VuoSceneText.h"
#include "VuoImageText.h"
#include "module.h"
 
#ifdef VUO_COMPILER
VuoModuleMetadata({
                    "title" : "VuoSceneText",
                    "dependencies" : [
                        "VuoImageText",
                        "VuoSceneObject",
                        "VuoFont",
                        "VuoMesh"
                    ]
                 });
#endif
 
static VuoMesh makeAnchoredQuad(VuoAnchor anchor)
{
    unsigned int vertexCount = 4;
 
    VuoPoint4d *positions = (VuoPoint4d *)malloc(sizeof(VuoPoint4d) * vertexCount);
    positions[0] = VuoPoint4d_make(-.5,-.5,0,1);
    positions[1] = VuoPoint4d_make( .5,-.5,0,1);
    positions[2] = VuoPoint4d_make(-.5, .5,0,1);
    positions[3] = VuoPoint4d_make( .5, .5,0,1);
 
    VuoPoint4d *textureCoordinates = (VuoPoint4d *)malloc(sizeof(VuoPoint4d) * vertexCount);
    textureCoordinates[0] = VuoPoint4d_make(0,0,0,1);
    textureCoordinates[1] = VuoPoint4d_make(1,0,0,1);
    textureCoordinates[2] = VuoPoint4d_make(0,1,0,1);
    textureCoordinates[3] = VuoPoint4d_make(1,1,0,1);
 
    unsigned int elementCount = 6;
    unsigned int *elements = (unsigned int *)malloc(sizeof(unsigned int) * elementCount);
    // Order the elements so that the diagonal edge of each triangle
    // is last, so that vuo.shader.make.wireframe can optionally omit them.
    elements[0] = 2;
    elements[1] = 0;
    elements[2] = 1;
    elements[3] = 1;
    elements[4] = 3;
    elements[5] = 2;
 
    float horizontal = VuoAnchor_getHorizontal(anchor) == VuoHorizontalAlignment_Left ? .5f : (VuoAnchor_getHorizontal(anchor) == VuoHorizontalAlignment_Right ? -.5f : 0.f);
    float vertical = VuoAnchor_getVertical(anchor) == VuoVerticalAlignment_Top ? -.5f : (VuoAnchor_getVertical(anchor) == VuoVerticalAlignment_Bottom ? .5f : 0.f);
 
    for(int i = 0; i < vertexCount; i++)
    {
        positions[i].x += horizontal;
        positions[i].y += vertical;
    }
 
    VuoSubmesh sm = VuoSubmesh_makeFromBuffers(vertexCount,
                                               positions, NULL, NULL, NULL, textureCoordinates,
                                               elementCount, elements, VuoMesh_IndividualTriangles);
    return VuoMesh_makeFromSingleSubmesh(sm);
}
 
VuoSceneObject VuoSceneText_make(const VuoText text, const VuoFont font, const VuoBoolean scaleWithScene, const VuoReal wrapWidth, const VuoAnchor anchor)
{
    VuoSceneObject so = VuoSceneObject_makeText(text, font, scaleWithScene, wrapWidth);
    so.mesh = makeAnchoredQuad(anchor);
    return so;
}
 
VuoAnchor VuoSceneText_getAnchor(VuoSceneObject so)
{
    VuoPoint2d mesh0 = (VuoPoint2d){ so.mesh->submeshes[0].positions[0].x, so.mesh->submeshes[0].positions[0].y };
    VuoHorizontalAlignment h;
    VuoVerticalAlignment v;
 
    // (We know from VuoSceneText_make() that the mesh's first coordinate
    // is 0.0, -0.5, or -1.0, depending on whether the anchor is left/top, center, or right/bottom, respectively.)
    if (VuoReal_areEqual(mesh0.x, 0))
        h = VuoHorizontalAlignment_Left;
    else if (VuoReal_areEqual(mesh0.x, -.5))
        h = VuoHorizontalAlignment_Center;
    else //if (VuoReal_areEqual(mesh0.x, -1))
        h = VuoHorizontalAlignment_Right;
 
    if (VuoReal_areEqual(mesh0.y, -1))
        v = VuoVerticalAlignment_Top;
    else if (VuoReal_areEqual(mesh0.y, -.5))
        v = VuoVerticalAlignment_Center;
    else //if (VuoReal_areEqual(mesh0.y, 0))
        v = VuoVerticalAlignment_Bottom;
 
    return VuoAnchor_make(h, v);
}
 
VuoPoint2d VuoSceneText_getAnchorOffset(VuoSceneObject so, float verticalScale, float rotationZ, float wrapWidth, int viewportWidth, int backingScaleFactor)
{
    VuoAnchor a = VuoSceneText_getAnchor(so);
    if (a == VuoAnchor_make(VuoHorizontalAlignment_Center, VuoVerticalAlignment_Center))
        // Already in center.
        return (VuoPoint2d){0, 0};
 
    VuoImageTextData td = VuoImage_getTextImageData(so.text, so.font, backingScaleFactor, verticalScale, rotationZ, false);
    VuoLocal(td);
    VuoPoint2d *corners = td->transformedCorners;
 
    // Convert the corner pixel coodrinates to scene coordinates.
    for (int i = 0; i < 4; ++i)
    {
        corners[i].x *= -2. / viewportWidth;
        corners[i].y *= -2. / viewportWidth;
    }
 
    // Move the origin to the anchor point.
    double width  = fmax(fabs(corners[2].x - corners[0].x), fabs(corners[3].x - corners[1].x));
    double height = fmax(fabs(corners[2].y - corners[0].y), fabs(corners[3].y - corners[1].y));
    if (a == VuoAnchor_make(VuoHorizontalAlignment_Left, VuoVerticalAlignment_Top))
        return (VuoPoint2d){
            corners[0].x,
            -corners[0].y
        };
    else if (a == VuoAnchor_make(VuoHorizontalAlignment_Left, VuoVerticalAlignment_Center))
        return (VuoPoint2d){
            (corners[0].x + corners[3].x)/2,
            -((corners[0].y + corners[3].y)/2 + height/2.)
        };
    else if (a == VuoAnchor_make(VuoHorizontalAlignment_Left, VuoVerticalAlignment_Bottom))
        return (VuoPoint2d){
            corners[3].x,
            -(corners[3].y + height)
        };
    else if (a == VuoAnchor_make(VuoHorizontalAlignment_Center, VuoVerticalAlignment_Top))
        return (VuoPoint2d){
            (corners[0].x + corners[1].x)/2 + width/2.,
            -(corners[0].y + corners[1].y)/2
        };
    else if (a == VuoAnchor_make(VuoHorizontalAlignment_Center, VuoVerticalAlignment_Bottom))
        return (VuoPoint2d){
            (corners[2].x + corners[3].x)/2 + width/2.,
            -((corners[2].y + corners[3].y)/2 + height)
        };
    else if (a == VuoAnchor_make(VuoHorizontalAlignment_Right, VuoVerticalAlignment_Top))
        return (VuoPoint2d){
            corners[1].x + width,
            -corners[1].y
        };
    else if (a == VuoAnchor_make(VuoHorizontalAlignment_Right, VuoVerticalAlignment_Center))
        return (VuoPoint2d){
            (corners[1].x + corners[2].x)/2 + width,
            -((corners[1].y + corners[2].y)/2 + height/2.)
        };
    else //if (a == VuoAnchor_make(VuoHorizontalAlignment_Right, VuoVerticalAlignment_Bottom))
        return (VuoPoint2d){
            corners[2].x + width,
            -(corners[2].y + height)
        };
}