gFont.h

Go to the documentation of this file.

/*
 * Copyright (C) 2016 Nitra Games Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef ENGINE_GRAPHICS_GFONT_H_
#define ENGINE_GRAPHICS_GFONT_H_
 
#include "gNode.h"
#include "gEventHook.h"
#include <map>
#include <vector>
#ifdef EMSCRIPTEN
#include "ft2build.h"
#include FT_FREETYPE_H
#else
#include "freetype2/ft2build.h"
#endif
#ifdef ANDROID
#include "freetype2/freetype/freetype.h"
#include <android/asset_manager.h>
#endif
#if TARGET_OS_IPHONE || TARGET_OS_SIMULATOR
#include "freetype2/freetype/freetype.h"
#endif
#if defined(WIN32) || defined(LINUX) || TARGET_OS_OSX
#include FT_FREETYPE_H
#endif
 
 
#include "gMesh.h"
#include "gTexture.h"
#include <unordered_map>
 
 
class gFont : public gNode, public gEventHook {
public:
    enum class TextAlign {LEFT, CENTER, RIGHT, JUSTIFY};
 
    gFont();
    virtual ~gFont();
 
    bool load(const std::string& fullPath, int size, bool isAntialiased = true, int dpi = 96);
 
    bool loadFont(const std::string& fontPath, int size, bool isAntialiased = true, int dpi = 96);
 
    void drawText(const std::string& text, float x, float y);
 
 
    void drawTextVerticallyFlipped(const std::string& text, float x, float y);
 
    void drawTextHorizontallyFlipped(const std::string& text, float x, float y);
 
    float getStringWidth(const std::string& text);
 
 
    float getStringHeight(const std::string& text);
 
    float getLineHeight() const;
 
    const std::string& getPath() const;
 
    int getSize() const;
 
    bool isLoaded() const;
 
    bool isAntialised() const;
 
    int getDpi() const;
    /*
     * Wraps text into multiple lines based on font width.
     *
     * @param text The input text to be wrapped
     * @param maxWidth The maximum visual width of a line
     *
     * @return A list of lines that fit within the given width
     */
    std::vector<std::string> wrapSentenceByWidth(const std::string& text, float maxWidth, TextAlign align = TextAlign::LEFT);
 
    void onEvent(gEvent& event) override;
 
    void getVisualBoundsX(const std::string& text, float& xmin, float& xmax);
 
 
private:
    void reloadFont();
 
    bool isloaded = false;
    std::string fullpath;
    bool isantialiased = false;
    int dpi = 0;
    float fontsize = 0.0f;
    int characternumlimit = 0;
    int border = 3;
    bool iskerning = false;
 
    FT_Library ftlib = nullptr;
    FT_Face fontface = nullptr;
 
    float lineheight = 0.0f;
    float letterspacing = 1.0f;
    float spacesize = 1.0f;
    float scale = 1.0f;
 
    void loadChar(int charCode);
 
    struct CharProperties {
        float height = 0.0f, width = 0.0f;
        float topmargin = 0.0f, leftmargin = 0.0f;
        float advance = 0.0f;
        float texturewidth = 0.0f, textureheight = 0.0f;
        float dxleft = 0.0f, dxright = 0.0f, dytop = 0.0f, dybottom = 0.0f;
    };
 
    std::unordered_map<int, CharProperties> charproperties;
    std::unordered_map<int, gTexture*> chartextures;
 
    float getKerning(int c, int prevC) const;
    void resizeVectors(int num);
    bool insertData(const unsigned char* srcData, int srcWidth, int srcHeight, int componentNum,
                    unsigned char* dstData, int dstWidth, int dstHeight, int dstComponentNum,
                    size_t dstFirstX, size_t dstFirstY) const;
    std::wstring s2ws(const std::string& s) const;
    float roundIfRequired(float val);
};
 
#endif /* ENGINE_GRAPHICS_GFONT_H_ */