| /* | |
| * Copyright (C) 2009 The Android Open Source Project | |
| * | |
| * 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. | |
| */ | |
| #include "rsContext.h" | |
| #include "rs.h" | |
| #include "rsFont.h" | |
| #include "rsProgramFragment.h" | |
| #include "rsMesh.h" | |
| #ifdef HAVE_ANDROID_OS | |
| #include <cutils/properties.h> | |
| #endif | |
| #ifndef ANDROID_RS_SERIALIZE | |
| #include <ft2build.h> | |
| #include FT_FREETYPE_H | |
| #include FT_BITMAP_H | |
| #endif //ANDROID_RS_SERIALIZE | |
| using namespace android; | |
| using namespace android::renderscript; | |
| Font::Font(Context *rsc) : ObjectBase(rsc), mCachedGlyphs(NULL) { | |
| mInitialized = false; | |
| mHasKerning = false; | |
| mFace = nullptr; | |
| } | |
| bool Font::init(const char *name, float fontSize, uint32_t dpi, const void *data, uint32_t dataLen) { | |
| #ifndef ANDROID_RS_SERIALIZE | |
| if (mInitialized) { | |
| ALOGE("Reinitialization of fonts not supported"); | |
| return false; | |
| } | |
| FT_Error error = 0; | |
| if (data != nullptr && dataLen > 0) { | |
| error = FT_New_Memory_Face(mRSC->mStateFont.getLib(), (const FT_Byte*)data, dataLen, 0, &mFace); | |
| } else { | |
| error = FT_New_Face(mRSC->mStateFont.getLib(), name, 0, &mFace); | |
| } | |
| if (error) { | |
| ALOGE("Unable to initialize font %s", name); | |
| return false; | |
| } | |
| mFontName = rsuCopyString(name); | |
| mFontSize = fontSize; | |
| mDpi = dpi; | |
| error = FT_Set_Char_Size(mFace, (FT_F26Dot6)(fontSize * 64.0f), 0, dpi, 0); | |
| if (error) { | |
| ALOGE("Unable to set font size on %s", name); | |
| return false; | |
| } | |
| mHasKerning = FT_HAS_KERNING(mFace); | |
| mInitialized = true; | |
| #endif //ANDROID_RS_SERIALIZE | |
| return true; | |
| } | |
| void Font::preDestroy() const { | |
| for (uint32_t ct = 0; ct < mRSC->mStateFont.mActiveFonts.size(); ct++) { | |
| if (mRSC->mStateFont.mActiveFonts[ct] == this) { | |
| mRSC->mStateFont.mActiveFonts.removeAt(ct); | |
| break; | |
| } | |
| } | |
| } | |
| void Font::invalidateTextureCache() { | |
| for (uint32_t i = 0; i < mCachedGlyphs.size(); i ++) { | |
| mCachedGlyphs.valueAt(i)->mIsValid = false; | |
| } | |
| } | |
| void Font::drawCachedGlyph(CachedGlyphInfo *glyph, int32_t x, int32_t y) { | |
| FontState *state = &mRSC->mStateFont; | |
| int32_t nPenX = x + glyph->mBitmapLeft; | |
| int32_t nPenY = y - glyph->mBitmapTop + glyph->mBitmapHeight; | |
| float u1 = glyph->mBitmapMinU; | |
| float u2 = glyph->mBitmapMaxU; | |
| float v1 = glyph->mBitmapMinV; | |
| float v2 = glyph->mBitmapMaxV; | |
| int32_t width = (int32_t) glyph->mBitmapWidth; | |
| int32_t height = (int32_t) glyph->mBitmapHeight; | |
| state->appendMeshQuad(nPenX, nPenY, 0, u1, v2, | |
| nPenX + width, nPenY, 0, u2, v2, | |
| nPenX + width, nPenY - height, 0, u2, v1, | |
| nPenX, nPenY - height, 0, u1, v1); | |
| } | |
| void Font::drawCachedGlyph(CachedGlyphInfo* glyph, int32_t x, int32_t y, | |
| uint8_t* bitmap, uint32_t bitmapW, uint32_t bitmapH) { | |
| int32_t nPenX = x + glyph->mBitmapLeft; | |
| int32_t nPenY = y + glyph->mBitmapTop; | |
| uint32_t endX = glyph->mBitmapMinX + glyph->mBitmapWidth; | |
| uint32_t endY = glyph->mBitmapMinY + glyph->mBitmapHeight; | |
| FontState *state = &mRSC->mStateFont; | |
| uint32_t cacheWidth = state->getCacheTextureType()->getDimX(); | |
| const uint8_t* cacheBuffer = state->mCacheBuffer; | |
| uint32_t cacheX = 0, cacheY = 0; | |
| int32_t bX = 0, bY = 0; | |
| for (cacheX = glyph->mBitmapMinX, bX = nPenX; cacheX < endX; cacheX++, bX++) { | |
| for (cacheY = glyph->mBitmapMinY, bY = nPenY; cacheY < endY; cacheY++, bY++) { | |
| if (bX < 0 || bY < 0 || bX >= (int32_t) bitmapW || bY >= (int32_t) bitmapH) { | |
| ALOGE("Skipping invalid index"); | |
| continue; | |
| } | |
| uint8_t tempCol = cacheBuffer[cacheY * cacheWidth + cacheX]; | |
| bitmap[bY * bitmapW + bX] = tempCol; | |
| } | |
| } | |
| } | |
| void Font::measureCachedGlyph(CachedGlyphInfo *glyph, int32_t x, int32_t y, Rect *bounds) { | |
| int32_t nPenX = x + glyph->mBitmapLeft; | |
| int32_t nPenY = y - glyph->mBitmapTop + glyph->mBitmapHeight; | |
| int32_t width = (int32_t) glyph->mBitmapWidth; | |
| int32_t height = (int32_t) glyph->mBitmapHeight; | |
| // 0, 0 is top left, so bottom is a positive number | |
| if (bounds->bottom < nPenY) { | |
| bounds->bottom = nPenY; | |
| } | |
| if (bounds->left > nPenX) { | |
| bounds->left = nPenX; | |
| } | |
| if (bounds->right < nPenX + width) { | |
| bounds->right = nPenX + width; | |
| } | |
| if (bounds->top > nPenY - height) { | |
| bounds->top = nPenY - height; | |
| } | |
| } | |
| void Font::renderUTF(const char *text, uint32_t len, int32_t x, int32_t y, | |
| uint32_t start, int32_t numGlyphs, | |
| RenderMode mode, Rect *bounds, | |
| uint8_t *bitmap, uint32_t bitmapW, uint32_t bitmapH) { | |
| if (!mInitialized || numGlyphs == 0 || text == nullptr || len == 0) { | |
| return; | |
| } | |
| if (mode == Font::MEASURE) { | |
| if (bounds == nullptr) { | |
| ALOGE("No return rectangle provided to measure text"); | |
| return; | |
| } | |
| // Reset min and max of the bounding box to something large | |
| bounds->set(1e6, -1e6, 1e6, -1e6); | |
| } | |
| int32_t penX = x, penY = y; | |
| int32_t glyphsLeft = 1; | |
| if (numGlyphs > 0) { | |
| glyphsLeft = numGlyphs; | |
| } | |
| size_t index = start; | |
| size_t nextIndex = 0; | |
| while (glyphsLeft > 0) { | |
| int32_t utfChar = utf32_from_utf8_at(text, len, index, &nextIndex); | |
| // Reached the end of the string or encountered | |
| if (utfChar < 0) { | |
| break; | |
| } | |
| // Move to the next character in the array | |
| index = nextIndex; | |
| CachedGlyphInfo *cachedGlyph = getCachedUTFChar(utfChar); | |
| // If it's still not valid, we couldn't cache it, so we shouldn't draw garbage | |
| if (cachedGlyph->mIsValid) { | |
| switch (mode) { | |
| case FRAMEBUFFER: | |
| drawCachedGlyph(cachedGlyph, penX, penY); | |
| break; | |
| case BITMAP: | |
| drawCachedGlyph(cachedGlyph, penX, penY, bitmap, bitmapW, bitmapH); | |
| break; | |
| case MEASURE: | |
| measureCachedGlyph(cachedGlyph, penX, penY, bounds); | |
| break; | |
| } | |
| } | |
| penX += (cachedGlyph->mAdvanceX >> 6); | |
| // If we were given a specific number of glyphs, decrement | |
| if (numGlyphs > 0) { | |
| glyphsLeft --; | |
| } | |
| } | |
| } | |
| Font::CachedGlyphInfo* Font::getCachedUTFChar(int32_t utfChar) { | |
| CachedGlyphInfo *cachedGlyph = mCachedGlyphs.valueFor((uint32_t)utfChar); | |
| if (cachedGlyph == nullptr) { | |
| cachedGlyph = cacheGlyph((uint32_t)utfChar); | |
| } | |
| // Is the glyph still in texture cache? | |
| if (!cachedGlyph->mIsValid) { | |
| updateGlyphCache(cachedGlyph); | |
| } | |
| return cachedGlyph; | |
| } | |
| void Font::updateGlyphCache(CachedGlyphInfo *glyph) { | |
| #ifndef ANDROID_RS_SERIALIZE | |
| FT_Error error = FT_Load_Glyph( mFace, glyph->mGlyphIndex, FT_LOAD_RENDER ); | |
| if (error) { | |
| ALOGE("Couldn't load glyph."); | |
| return; | |
| } | |
| glyph->mAdvanceX = mFace->glyph->advance.x; | |
| glyph->mAdvanceY = mFace->glyph->advance.y; | |
| glyph->mBitmapLeft = mFace->glyph->bitmap_left; | |
| glyph->mBitmapTop = mFace->glyph->bitmap_top; | |
| FT_Bitmap *bitmap = &mFace->glyph->bitmap; | |
| // Now copy the bitmap into the cache texture | |
| uint32_t startX = 0; | |
| uint32_t startY = 0; | |
| // Let the font state figure out where to put the bitmap | |
| FontState *state = &mRSC->mStateFont; | |
| glyph->mIsValid = state->cacheBitmap(bitmap, &startX, &startY); | |
| if (!glyph->mIsValid) { | |
| return; | |
| } | |
| uint32_t endX = startX + bitmap->width; | |
| uint32_t endY = startY + bitmap->rows; | |
| glyph->mBitmapMinX = startX; | |
| glyph->mBitmapMinY = startY; | |
| glyph->mBitmapWidth = bitmap->width; | |
| glyph->mBitmapHeight = bitmap->rows; | |
| uint32_t cacheWidth = state->getCacheTextureType()->getDimX(); | |
| uint32_t cacheHeight = state->getCacheTextureType()->getDimY(); | |
| glyph->mBitmapMinU = (float)startX / (float)cacheWidth; | |
| glyph->mBitmapMinV = (float)startY / (float)cacheHeight; | |
| glyph->mBitmapMaxU = (float)endX / (float)cacheWidth; | |
| glyph->mBitmapMaxV = (float)endY / (float)cacheHeight; | |
| #endif //ANDROID_RS_SERIALIZE | |
| } | |
| Font::CachedGlyphInfo *Font::cacheGlyph(uint32_t glyph) { | |
| CachedGlyphInfo *newGlyph = new CachedGlyphInfo(); | |
| mCachedGlyphs.add(glyph, newGlyph); | |
| #ifndef ANDROID_RS_SERIALIZE | |
| newGlyph->mGlyphIndex = FT_Get_Char_Index(mFace, glyph); | |
| newGlyph->mIsValid = false; | |
| #endif //ANDROID_RS_SERIALIZE | |
| updateGlyphCache(newGlyph); | |
| return newGlyph; | |
| } | |
| Font * Font::create(Context *rsc, const char *name, float fontSize, uint32_t dpi, | |
| const void *data, uint32_t dataLen) { | |
| rsc->mStateFont.checkInit(); | |
| Vector<Font*> &activeFonts = rsc->mStateFont.mActiveFonts; | |
| for (uint32_t i = 0; i < activeFonts.size(); i ++) { | |
| Font *ithFont = activeFonts[i]; | |
| if (ithFont->mFontName == name && ithFont->mFontSize == fontSize && ithFont->mDpi == dpi) { | |
| return ithFont; | |
| } | |
| } | |
| Font *newFont = new Font(rsc); | |
| bool isInitialized = newFont->init(name, fontSize, dpi, data, dataLen); | |
| if (isInitialized) { | |
| activeFonts.push(newFont); | |
| rsc->mStateFont.precacheLatin(newFont); | |
| return newFont; | |
| } | |
| ObjectBase::checkDelete(newFont); | |
| return nullptr; | |
| } | |
| Font::~Font() { | |
| #ifndef ANDROID_RS_SERIALIZE | |
| if (mFace) { | |
| FT_Done_Face(mFace); | |
| } | |
| #endif | |
| for (uint32_t i = 0; i < mCachedGlyphs.size(); i ++) { | |
| CachedGlyphInfo *glyph = mCachedGlyphs.valueAt(i); | |
| delete glyph; | |
| } | |
| } | |
| FontState::FontState() { | |
| mInitialized = false; | |
| mMaxNumberOfQuads = 1024; | |
| mCurrentQuadIndex = 0; | |
| mRSC = nullptr; | |
| #ifndef ANDROID_RS_SERIALIZE | |
| mLibrary = nullptr; | |
| #endif //ANDROID_RS_SERIALIZE | |
| float gamma = DEFAULT_TEXT_GAMMA; | |
| int32_t blackThreshold = DEFAULT_TEXT_BLACK_GAMMA_THRESHOLD; | |
| int32_t whiteThreshold = DEFAULT_TEXT_WHITE_GAMMA_THRESHOLD; | |
| #ifdef HAVE_ANDROID_OS | |
| // Get the renderer properties | |
| char property[PROPERTY_VALUE_MAX]; | |
| // Get the gamma | |
| if (property_get(PROPERTY_TEXT_GAMMA, property, nullptr) > 0) { | |
| gamma = atof(property); | |
| } | |
| // Get the black gamma threshold | |
| if (property_get(PROPERTY_TEXT_BLACK_GAMMA_THRESHOLD, property, nullptr) > 0) { | |
| blackThreshold = atoi(property); | |
| } | |
| // Get the white gamma threshold | |
| if (property_get(PROPERTY_TEXT_WHITE_GAMMA_THRESHOLD, property, nullptr) > 0) { | |
| whiteThreshold = atoi(property); | |
| } | |
| #endif | |
| mBlackThreshold = (float)(blackThreshold) / 255.0f; | |
| mWhiteThreshold = (float)(whiteThreshold) / 255.0f; | |
| // Compute the gamma tables | |
| mBlackGamma = gamma; | |
| mWhiteGamma = 1.0f / gamma; | |
| setFontColor(0.1f, 0.1f, 0.1f, 1.0f); | |
| } | |
| FontState::~FontState() { | |
| for (uint32_t i = 0; i < mCacheLines.size(); i ++) { | |
| delete mCacheLines[i]; | |
| } | |
| rsAssert(!mActiveFonts.size()); | |
| } | |
| #ifndef ANDROID_RS_SERIALIZE | |
| FT_Library FontState::getLib() { | |
| if (!mLibrary) { | |
| FT_Error error = FT_Init_FreeType(&mLibrary); | |
| if (error) { | |
| ALOGE("Unable to initialize freetype"); | |
| return nullptr; | |
| } | |
| } | |
| return mLibrary; | |
| } | |
| #endif //ANDROID_RS_SERIALIZE | |
| void FontState::init(Context *rsc) { | |
| mRSC = rsc; | |
| } | |
| void FontState::flushAllAndInvalidate() { | |
| if (mCurrentQuadIndex != 0) { | |
| issueDrawCommand(); | |
| mCurrentQuadIndex = 0; | |
| } | |
| for (uint32_t i = 0; i < mActiveFonts.size(); i ++) { | |
| mActiveFonts[i]->invalidateTextureCache(); | |
| } | |
| for (uint32_t i = 0; i < mCacheLines.size(); i ++) { | |
| mCacheLines[i]->mCurrentCol = 0; | |
| } | |
| } | |
| #ifndef ANDROID_RS_SERIALIZE | |
| bool FontState::cacheBitmap(FT_Bitmap *bitmap, uint32_t *retOriginX, uint32_t *retOriginY) { | |
| // If the glyph is too tall, don't cache it | |
| if ((uint32_t)bitmap->rows > mCacheLines[mCacheLines.size()-1]->mMaxHeight) { | |
| ALOGE("Font size to large to fit in cache. width, height = %i, %i", (int)bitmap->width, (int)bitmap->rows); | |
| return false; | |
| } | |
| // Now copy the bitmap into the cache texture | |
| uint32_t startX = 0; | |
| uint32_t startY = 0; | |
| bool bitmapFit = false; | |
| for (uint32_t i = 0; i < mCacheLines.size(); i ++) { | |
| bitmapFit = mCacheLines[i]->fitBitmap(bitmap, &startX, &startY); | |
| if (bitmapFit) { | |
| break; | |
| } | |
| } | |
| // If the new glyph didn't fit, flush the state so far and invalidate everything | |
| if (!bitmapFit) { | |
| flushAllAndInvalidate(); | |
| // Try to fit it again | |
| for (uint32_t i = 0; i < mCacheLines.size(); i ++) { | |
| bitmapFit = mCacheLines[i]->fitBitmap(bitmap, &startX, &startY); | |
| if (bitmapFit) { | |
| break; | |
| } | |
| } | |
| // if we still don't fit, something is wrong and we shouldn't draw | |
| if (!bitmapFit) { | |
| ALOGE("Bitmap doesn't fit in cache. width, height = %i, %i", (int)bitmap->width, (int)bitmap->rows); | |
| return false; | |
| } | |
| } | |
| *retOriginX = startX; | |
| *retOriginY = startY; | |
| uint32_t endX = startX + bitmap->width; | |
| uint32_t endY = startY + bitmap->rows; | |
| uint32_t cacheWidth = getCacheTextureType()->getDimX(); | |
| uint8_t *cacheBuffer = mCacheBuffer; | |
| uint8_t *bitmapBuffer = bitmap->buffer; | |
| uint32_t cacheX = 0, bX = 0, cacheY = 0, bY = 0; | |
| for (cacheX = startX, bX = 0; cacheX < endX; cacheX ++, bX ++) { | |
| for (cacheY = startY, bY = 0; cacheY < endY; cacheY ++, bY ++) { | |
| uint8_t tempCol = bitmapBuffer[bY * bitmap->width + bX]; | |
| cacheBuffer[cacheY*cacheWidth + cacheX] = tempCol; | |
| } | |
| } | |
| // This will dirty the texture and the shader so next time | |
| // we draw it will upload the data | |
| mRSC->mHal.funcs.allocation.data2D(mRSC, mTextTexture.get(), 0, 0, 0, | |
| RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X, mCacheWidth, mCacheHeight, | |
| mCacheBuffer, mCacheWidth*mCacheHeight, mCacheWidth); | |
| mFontShaderF->bindTexture(mRSC, 0, mTextTexture.get()); | |
| // Some debug code | |
| /*for (uint32_t i = 0; i < mCacheLines.size(); i ++) { | |
| ALOGE("Cache Line: H: %u Empty Space: %f", | |
| mCacheLines[i]->mMaxHeight, | |
| (1.0f - (float)mCacheLines[i]->mCurrentCol/(float)mCacheLines[i]->mMaxWidth)*100.0f); | |
| }*/ | |
| return true; | |
| } | |
| #endif //ANDROID_RS_SERIALIZE | |
| void FontState::initRenderState() { | |
| const char *shaderString = "varying vec2 varTex0;\n" | |
| "void main() {\n" | |
| " lowp vec4 col = UNI_Color;\n" | |
| " col.a = texture2D(UNI_Tex0, varTex0.xy).a;\n" | |
| " col.a = pow(col.a, UNI_Gamma);\n" | |
| " gl_FragColor = col;\n" | |
| "}\n"; | |
| const char *textureNames[] = { "Tex0" }; | |
| const size_t textureNamesLengths[] = { 4 }; | |
| size_t numTextures = sizeof(textureNamesLengths)/sizeof(*textureNamesLengths); | |
| ObjectBaseRef<const Element> colorElem = Element::createRef(mRSC, RS_TYPE_FLOAT_32, | |
| RS_KIND_USER, false, 4); | |
| ObjectBaseRef<const Element> gammaElem = Element::createRef(mRSC, RS_TYPE_FLOAT_32, | |
| RS_KIND_USER, false, 1); | |
| const char *ebn1[] = { "Color", "Gamma" }; | |
| const Element *ebe1[] = {colorElem.get(), gammaElem.get()}; | |
| ObjectBaseRef<const Element> constInput = Element::create(mRSC, 2, ebe1, ebn1); | |
| ObjectBaseRef<Type> inputType = Type::getTypeRef(mRSC, constInput.get(), 1); | |
| uintptr_t tmp[4]; | |
| tmp[0] = RS_PROGRAM_PARAM_CONSTANT; | |
| tmp[1] = (uintptr_t)inputType.get(); | |
| tmp[2] = RS_PROGRAM_PARAM_TEXTURE_TYPE; | |
| tmp[3] = RS_TEXTURE_2D; | |
| mFontShaderFConstant.set(Allocation::createAllocation(mRSC, inputType.get(), | |
| RS_ALLOCATION_USAGE_SCRIPT | | |
| RS_ALLOCATION_USAGE_GRAPHICS_CONSTANTS)); | |
| ProgramFragment *pf = new ProgramFragment(mRSC, shaderString, strlen(shaderString), | |
| textureNames, numTextures, textureNamesLengths, | |
| tmp, 4); | |
| mFontShaderF.set(pf); | |
| mFontShaderF->bindAllocation(mRSC, mFontShaderFConstant.get(), 0); | |
| mFontSampler.set(Sampler::getSampler(mRSC, RS_SAMPLER_NEAREST, RS_SAMPLER_NEAREST, | |
| RS_SAMPLER_CLAMP, RS_SAMPLER_CLAMP, | |
| RS_SAMPLER_CLAMP).get()); | |
| mFontShaderF->bindSampler(mRSC, 0, mFontSampler.get()); | |
| mFontProgramStore.set(ProgramStore::getProgramStore(mRSC, true, true, true, true, | |
| false, false, | |
| RS_BLEND_SRC_SRC_ALPHA, | |
| RS_BLEND_DST_ONE_MINUS_SRC_ALPHA, | |
| RS_DEPTH_FUNC_ALWAYS).get()); | |
| mFontProgramStore->init(); | |
| } | |
| void FontState::initTextTexture() { | |
| ObjectBaseRef<const Element> alphaElem = Element::createRef(mRSC, RS_TYPE_UNSIGNED_8, | |
| RS_KIND_PIXEL_A, true, 1); | |
| // We will allocate a texture to initially hold 32 character bitmaps | |
| mCacheHeight = 256; | |
| mCacheWidth = 1024; | |
| ObjectBaseRef<Type> texType = Type::getTypeRef(mRSC, alphaElem.get(), mCacheWidth, mCacheHeight); | |
| mCacheBuffer = new uint8_t[mCacheWidth * mCacheHeight]; | |
| Allocation *cacheAlloc = Allocation::createAllocation(mRSC, texType.get(), | |
| RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE); | |
| mTextTexture.set(cacheAlloc); | |
| // Split up our cache texture into lines of certain widths | |
| int32_t nextLine = 0; | |
| mCacheLines.push(new CacheTextureLine(16, texType->getDimX(), nextLine, 0)); | |
| nextLine += mCacheLines.top()->mMaxHeight; | |
| mCacheLines.push(new CacheTextureLine(24, texType->getDimX(), nextLine, 0)); | |
| nextLine += mCacheLines.top()->mMaxHeight; | |
| mCacheLines.push(new CacheTextureLine(24, texType->getDimX(), nextLine, 0)); | |
| nextLine += mCacheLines.top()->mMaxHeight; | |
| mCacheLines.push(new CacheTextureLine(32, texType->getDimX(), nextLine, 0)); | |
| nextLine += mCacheLines.top()->mMaxHeight; | |
| mCacheLines.push(new CacheTextureLine(32, texType->getDimX(), nextLine, 0)); | |
| nextLine += mCacheLines.top()->mMaxHeight; | |
| mCacheLines.push(new CacheTextureLine(40, texType->getDimX(), nextLine, 0)); | |
| nextLine += mCacheLines.top()->mMaxHeight; | |
| mCacheLines.push(new CacheTextureLine(texType->getDimY() - nextLine, texType->getDimX(), nextLine, 0)); | |
| } | |
| // Avoid having to reallocate memory and render quad by quad | |
| void FontState::initVertexArrayBuffers() { | |
| // Now lets write index data | |
| ObjectBaseRef<const Element> indexElem = Element::createRef(mRSC, RS_TYPE_UNSIGNED_16, RS_KIND_USER, false, 1); | |
| ObjectBaseRef<Type> indexType = Type::getTypeRef(mRSC, indexElem.get(), mMaxNumberOfQuads * 6); | |
| Allocation *indexAlloc = Allocation::createAllocation(mRSC, indexType.get(), | |
| RS_ALLOCATION_USAGE_SCRIPT | | |
| RS_ALLOCATION_USAGE_GRAPHICS_VERTEX); | |
| uint16_t *indexPtr = (uint16_t*)mRSC->mHal.funcs.allocation.lock1D(mRSC, indexAlloc); | |
| // Four verts, two triangles , six indices per quad | |
| for (uint32_t i = 0; i < mMaxNumberOfQuads; i ++) { | |
| int32_t i6 = i * 6; | |
| int32_t i4 = i * 4; | |
| indexPtr[i6 + 0] = i4 + 0; | |
| indexPtr[i6 + 1] = i4 + 1; | |
| indexPtr[i6 + 2] = i4 + 2; | |
| indexPtr[i6 + 3] = i4 + 0; | |
| indexPtr[i6 + 4] = i4 + 2; | |
| indexPtr[i6 + 5] = i4 + 3; | |
| } | |
| indexAlloc->sendDirty(mRSC); | |
| ObjectBaseRef<const Element> posElem = Element::createRef(mRSC, RS_TYPE_FLOAT_32, RS_KIND_USER, false, 3); | |
| ObjectBaseRef<const Element> texElem = Element::createRef(mRSC, RS_TYPE_FLOAT_32, RS_KIND_USER, false, 2); | |
| const char *ebn1[] = { "position", "texture0" }; | |
| const Element *ebe1[] = {posElem.get(), texElem.get()}; | |
| ObjectBaseRef<const Element> vertexDataElem = Element::create(mRSC, 2, ebe1, ebn1); | |
| ObjectBaseRef<Type> vertexDataType = Type::getTypeRef(mRSC, vertexDataElem.get(), mMaxNumberOfQuads * 4); | |
| Allocation *vertexAlloc = Allocation::createAllocation(mRSC, vertexDataType.get(), | |
| RS_ALLOCATION_USAGE_SCRIPT); | |
| mTextMeshPtr = (float*)mRSC->mHal.funcs.allocation.lock1D(mRSC, vertexAlloc); | |
| mMesh.set(new Mesh(mRSC, 1, 1)); | |
| mMesh->setVertexBuffer(vertexAlloc, 0); | |
| mMesh->setPrimitive(indexAlloc, RS_PRIMITIVE_TRIANGLE, 0); | |
| mMesh->init(); | |
| mRSC->mHal.funcs.allocation.unlock1D(mRSC, indexAlloc); | |
| mRSC->mHal.funcs.allocation.unlock1D(mRSC, vertexAlloc); | |
| } | |
| // We don't want to allocate anything unless we actually draw text | |
| void FontState::checkInit() { | |
| if (mInitialized) { | |
| return; | |
| } | |
| initTextTexture(); | |
| initRenderState(); | |
| initVertexArrayBuffers(); | |
| // We store a string with letters in a rough frequency of occurrence | |
| mLatinPrecache = " eisarntolcdugpmhbyfvkwzxjq" | |
| "EISARNTOLCDUGPMHBYFVKWZXJQ" | |
| ",.?!()-+@;:`'0123456789"; | |
| mInitialized = true; | |
| } | |
| void FontState::issueDrawCommand() { | |
| Context::PushState ps(mRSC); | |
| mRSC->setProgramVertex(mRSC->getDefaultProgramVertex()); | |
| mRSC->setProgramRaster(mRSC->getDefaultProgramRaster()); | |
| mRSC->setProgramFragment(mFontShaderF.get()); | |
| mRSC->setProgramStore(mFontProgramStore.get()); | |
| if (mConstantsDirty) { | |
| mFontShaderFConstant->data(mRSC, 0, 0, 1, &mConstants, sizeof(mConstants)); | |
| mConstantsDirty = false; | |
| } | |
| if (!mRSC->setupCheck()) { | |
| return; | |
| } | |
| mMesh->renderPrimitiveRange(mRSC, 0, 0, mCurrentQuadIndex * 6); | |
| } | |
| void FontState::appendMeshQuad(float x1, float y1, float z1, | |
| float u1, float v1, | |
| float x2, float y2, float z2, | |
| float u2, float v2, | |
| float x3, float y3, float z3, | |
| float u3, float v3, | |
| float x4, float y4, float z4, | |
| float u4, float v4) { | |
| const uint32_t vertsPerQuad = 4; | |
| const uint32_t floatsPerVert = 6; | |
| float *currentPos = mTextMeshPtr + mCurrentQuadIndex * vertsPerQuad * floatsPerVert; | |
| if (x1 > mSurfaceWidth || y1 < 0.0f || x2 < 0 || y4 > mSurfaceHeight) { | |
| return; | |
| } | |
| /*LOGE("V0 x: %f y: %f z: %f", x1, y1, z1); | |
| ALOGE("V1 x: %f y: %f z: %f", x2, y2, z2); | |
| ALOGE("V2 x: %f y: %f z: %f", x3, y3, z3); | |
| ALOGE("V3 x: %f y: %f z: %f", x4, y4, z4);*/ | |
| (*currentPos++) = x1; | |
| (*currentPos++) = y1; | |
| (*currentPos++) = z1; | |
| (*currentPos++) = 0; | |
| (*currentPos++) = u1; | |
| (*currentPos++) = v1; | |
| (*currentPos++) = x2; | |
| (*currentPos++) = y2; | |
| (*currentPos++) = z2; | |
| (*currentPos++) = 0; | |
| (*currentPos++) = u2; | |
| (*currentPos++) = v2; | |
| (*currentPos++) = x3; | |
| (*currentPos++) = y3; | |
| (*currentPos++) = z3; | |
| (*currentPos++) = 0; | |
| (*currentPos++) = u3; | |
| (*currentPos++) = v3; | |
| (*currentPos++) = x4; | |
| (*currentPos++) = y4; | |
| (*currentPos++) = z4; | |
| (*currentPos++) = 0; | |
| (*currentPos++) = u4; | |
| (*currentPos++) = v4; | |
| mCurrentQuadIndex ++; | |
| if (mCurrentQuadIndex == mMaxNumberOfQuads) { | |
| issueDrawCommand(); | |
| mCurrentQuadIndex = 0; | |
| } | |
| } | |
| uint32_t FontState::getRemainingCacheCapacity() { | |
| uint32_t remainingCapacity = 0; | |
| uint32_t totalPixels = 0; | |
| for (uint32_t i = 0; i < mCacheLines.size(); i ++) { | |
| remainingCapacity += (mCacheLines[i]->mMaxWidth - mCacheLines[i]->mCurrentCol); | |
| totalPixels += mCacheLines[i]->mMaxWidth; | |
| } | |
| remainingCapacity = (remainingCapacity * 100) / totalPixels; | |
| return remainingCapacity; | |
| } | |
| void FontState::precacheLatin(Font *font) { | |
| // Remaining capacity is measured in % | |
| uint32_t remainingCapacity = getRemainingCacheCapacity(); | |
| uint32_t precacheIdx = 0; | |
| const size_t l = strlen(mLatinPrecache); | |
| while ((remainingCapacity > 25) && (precacheIdx < l)) { | |
| font->getCachedUTFChar((int32_t)mLatinPrecache[precacheIdx]); | |
| remainingCapacity = getRemainingCacheCapacity(); | |
| precacheIdx ++; | |
| } | |
| } | |
| void FontState::renderText(const char *text, uint32_t len, int32_t x, int32_t y, | |
| uint32_t startIndex, int32_t numGlyphs, | |
| Font::RenderMode mode, | |
| Font::Rect *bounds, | |
| uint8_t *bitmap, uint32_t bitmapW, uint32_t bitmapH) { | |
| checkInit(); | |
| // Render code here | |
| Font *currentFont = mRSC->getFont(); | |
| if (!currentFont) { | |
| if (!mDefault.get()) { | |
| char fullPath[1024]; | |
| const char * root = getenv("ANDROID_ROOT"); | |
| rsAssert(strlen(root) < 256); | |
| strcpy(fullPath, root); | |
| strcat(fullPath, "/fonts/Roboto-Regular.ttf"); | |
| mDefault.set(Font::create(mRSC, fullPath, 8, mRSC->getDPI())); | |
| } | |
| currentFont = mDefault.get(); | |
| } | |
| if (!currentFont) { | |
| ALOGE("Unable to initialize any fonts"); | |
| return; | |
| } | |
| // Cull things that are off the screen | |
| mSurfaceWidth = (float)mRSC->getCurrentSurfaceWidth(); | |
| mSurfaceHeight = (float)mRSC->getCurrentSurfaceHeight(); | |
| currentFont->renderUTF(text, len, x, y, startIndex, numGlyphs, | |
| mode, bounds, bitmap, bitmapW, bitmapH); | |
| if (mCurrentQuadIndex != 0) { | |
| issueDrawCommand(); | |
| mCurrentQuadIndex = 0; | |
| } | |
| } | |
| void FontState::measureText(const char *text, uint32_t len, Font::Rect *bounds) { | |
| renderText(text, len, 0, 0, 0, -1, Font::MEASURE, bounds); | |
| bounds->bottom = - bounds->bottom; | |
| bounds->top = - bounds->top; | |
| } | |
| void FontState::setFontColor(float r, float g, float b, float a) { | |
| mConstants.mFontColor[0] = r; | |
| mConstants.mFontColor[1] = g; | |
| mConstants.mFontColor[2] = b; | |
| mConstants.mFontColor[3] = a; | |
| mConstants.mGamma = 1.0f; | |
| const float luminance = (r * 2.0f + g * 5.0f + b) / 8.0f; | |
| if (luminance <= mBlackThreshold) { | |
| mConstants.mGamma = mBlackGamma; | |
| } else if (luminance >= mWhiteThreshold) { | |
| mConstants.mGamma = mWhiteGamma; | |
| } | |
| mConstantsDirty = true; | |
| } | |
| void FontState::getFontColor(float *r, float *g, float *b, float *a) const { | |
| *r = mConstants.mFontColor[0]; | |
| *g = mConstants.mFontColor[1]; | |
| *b = mConstants.mFontColor[2]; | |
| *a = mConstants.mFontColor[3]; | |
| } | |
| void FontState::deinit(Context *rsc) { | |
| mInitialized = false; | |
| mFontShaderFConstant.clear(); | |
| mMesh.clear(); | |
| mFontShaderF.clear(); | |
| mFontSampler.clear(); | |
| mFontProgramStore.clear(); | |
| mTextTexture.clear(); | |
| for (uint32_t i = 0; i < mCacheLines.size(); i ++) { | |
| delete mCacheLines[i]; | |
| } | |
| mCacheLines.clear(); | |
| mDefault.clear(); | |
| #ifndef ANDROID_RS_SERIALIZE | |
| if (mLibrary) { | |
| FT_Done_FreeType( mLibrary ); | |
| mLibrary = nullptr; | |
| } | |
| #endif //ANDROID_RS_SERIALIZE | |
| } | |
| #ifndef ANDROID_RS_SERIALIZE | |
| bool FontState::CacheTextureLine::fitBitmap(FT_Bitmap_ *bitmap, uint32_t *retOriginX, uint32_t *retOriginY) { | |
| if ((uint32_t)bitmap->rows > mMaxHeight) { | |
| return false; | |
| } | |
| if (mCurrentCol + (uint32_t)bitmap->width < mMaxWidth) { | |
| *retOriginX = mCurrentCol; | |
| *retOriginY = mCurrentRow; | |
| mCurrentCol += bitmap->width; | |
| mDirty = true; | |
| return true; | |
| } | |
| return false; | |
| } | |
| #endif //ANDROID_RS_SERIALIZE | |
| namespace android { | |
| namespace renderscript { | |
| RsFont rsi_FontCreateFromFile(Context *rsc, | |
| char const *name, size_t name_length, | |
| float fontSize, uint32_t dpi) { | |
| Font *newFont = Font::create(rsc, name, fontSize, dpi); | |
| if (newFont) { | |
| newFont->incUserRef(); | |
| } | |
| return newFont; | |
| } | |
| RsFont rsi_FontCreateFromMemory(Context *rsc, | |
| char const *name, size_t name_length, | |
| float fontSize, uint32_t dpi, | |
| const void *data, size_t data_length) { | |
| Font *newFont = Font::create(rsc, name, fontSize, dpi, data, data_length); | |
| if (newFont) { | |
| newFont->incUserRef(); | |
| } | |
| return newFont; | |
| } | |
| } // renderscript | |
| } // android |