SDL_Texture *CreateTexture( Renderer * renderer, SDL_Surface * surface )
{
  SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer->GetRenderingContext(), surface);
  SDL_assert_release(texture != nullptr);
  SDL_FreeSurface(surface);
  return texture;
}
示例#2
0
FIBITMAP *GraphicsHelps::loadImageRC(const char *file)
{
    unsigned char *memory = nullptr;
    size_t fileSize = 0;
    SDL_assert_release(RES_getMem(file, memory, fileSize));
    //{
        //pLogCritical("Resource file \"%s\" is not found!", file);
        //return nullptr;
    //}

    FIMEMORY *imgMEM = FreeImage_OpenMemory(memory, static_cast<FI_DWORD>(fileSize));
    FREE_IMAGE_FORMAT formato = FreeImage_GetFileTypeFromMemory(imgMEM);

    if(formato == FIF_UNKNOWN)
        return nullptr;

    FIBITMAP *img = FreeImage_LoadFromMemory(formato, imgMEM, 0);
    FreeImage_CloseMemory(imgMEM);

    if(!img)
        return nullptr;

    FIBITMAP *temp;
    temp = FreeImage_ConvertTo32Bits(img);

    if(!temp)
        return nullptr;

    FreeImage_Unload(img);
    img = temp;
    return img;
}
示例#3
0
static Value methodCall(Context *ctx, const List<Value>& args)
{
    if (args.getCount() < 1)
    {
        ctx->throwException(createException(ExcType::ValueError, "Method call requires at least 1 argument."));
    }

    if (args[0].type != ValueType::Object)
    {
        ctx->throwException(createException(ExcType::TypeError, "Method call requires (method) object as first parameter."));
    }

    HashMap<Str, Value>& members = ((ObjectData *)args[0].p)->members;

    Value func;
    Value obj;

    try
    {
        func = members.get("__func__");
        obj = members.get("__obj__");
    } catch (LookupException& e)
    {
        ctx->throwException(createException(ExcType::ValueError, "Invalid method object."));

        SDL_assert_release(false);
    }

    List<Value> args2;
    args2.append(obj);
    args2.append(args.getCount()-1, args.getData()+1);

    return call(ctx, func, args2);
}
    void *Manageable::callocPulled(size_t size)
    {
        void *mem = lite3d_calloc_pooled(LITE3D_POOL_NO2, size);
        SDL_assert_release(mem);

        return mem;
    }
示例#5
0
static Value mathAbs(Context *ctx, const List<Value>& args)
{
    if (args.getCount() != 1)
    {
        ctx->throwException(createException(ExcType::ValueError, "abs takes only one argument."));
    }

    switch (args[0].type)
    {
    case ValueType::Float:
    {
        return createFloat(std::abs(args[0].f));
    }
    case ValueType::Int:
    {
        return createInt(std::llabs(args[0].i));
    }
    default:
    {
        ctx->throwException(createException(ExcType::TypeError, "Value is not convertable to float."));
    }
    }

    SDL_assert_release(false);
    return createInt(0);
}
    void *Manageable::calloc(size_t size)
    {
        void *mem = lite3d_calloc(size);
        SDL_assert_release(mem);

        return mem;
    }
示例#7
0
文件: texture.c 项目: csusbdt/lua1
// Push texture pointer as userdata, followed by width and height of texture.
// This is currently used only by texture_from_font but could be used by other functions in future.
static int texture_from_surface(lua_State * L, SDL_Surface * surface) {
	SDL_Texture * texture;
	SDL_Texture ** ud;
	int w;
	int h;
	SDL_BlendMode blend_mode;
	
	texture = SDL_CreateTextureFromSurface(renderer, surface);
	SDL_FreeSurface(surface);
	if (!texture) {
		luaL_error(L, "%s", SDL_GetError());
	}

	if (SDL_GetTextureBlendMode(texture, &blend_mode)) {
		luaL_error(L, "%s", SDL_GetError());
	}
	SDL_assert_release(blend_mode == SDL_BLENDMODE_BLEND);

	ud = (SDL_Texture **) lua_newuserdata(L, sizeof(SDL_Texture *));
	if (ud == NULL) {
		luaL_error(L, "Failed to create userdata in texture_from_surface.");
	}

	*ud = texture;
	SDL_QueryTexture(texture, NULL, NULL, &w, &h);
	lua_pushinteger(L, w);
	lua_pushinteger(L, h);
	return 3;
}
示例#8
0
void TtfFont::printText(const std::string &text,
                        int32_t x, int32_t y,
                        float Red, float Green, float Blue, float Alpha,
                        uint32_t fontSize)
{
    SDL_assert_release(g_ft);
    if(text.empty())
        return;

    uint32_t offsetX = 0;
    uint32_t offsetY = 0;

    const char *strIt  = text.c_str();
    const char *strEnd = strIt + text.size();
    for(; strIt < strEnd; strIt++)
    {
        const char &cx = *strIt;
        UTF8 ucx = static_cast<unsigned char>(cx);

        switch(cx)
        {
        case '\n':
            offsetX = 0;
            offsetY += (fontSize * 1.5);
            continue;

        case '\t':
            //Fake tabulation
            offsetX += offsetX + offsetX % uint32_t(fontSize * 1.5);
            continue;
//        case ' ':
//            offsetX += m_spaceWidth + m_interLetterSpace / 2;
//            continue;
        }

        TheGlyph &glyph = getGlyph(fontSize, get_utf8_char(&cx));
        GlRenderer::setTextureColor(Red, Green, Blue, Alpha);
        int32_t glyph_x = x + static_cast<int32_t>(offsetX);
        int32_t glyph_y = y + static_cast<int32_t>(offsetY + fontSize);
        GlRenderer::renderTexture(glyph.tx,
                                  static_cast<float>(glyph_x + glyph.left),
                                  static_cast<float>(glyph_y - glyph.top),
                                  glyph.width,
                                  glyph.height
                                  );
        offsetX += uint32_t(glyph.advance>>6);

        strIt += static_cast<size_t>(trailingBytesForUTF8[ucx]);
    }
}
示例#9
0
bool TtfFont::loadFont(const char *mem, size_t size)
{
    SDL_assert_release(g_ft);
    FT_Error error = FT_New_Memory_Face(g_ft, reinterpret_cast<const FT_Byte *>(mem),
                                        static_cast<FT_Long>(size), 0, &m_face);
    SDL_assert(error == 0);
    if(error)
        return false;
    error = FT_Set_Pixel_Sizes(m_face, 0, m_recentPixelSize);
    SDL_assert(error == 0);
    if(error)
        return false;
    error = FT_Select_Charmap(m_face, ft_encoding_unicode);
    SDL_assert(error == 0);
    if(error)
        return false;
    m_isReady = true;
    return true;
}
示例#10
0
static double asNumber(Context *ctx, const Value& value)
{
    switch (value.type)
    {
    case ValueType::Float:
    {
        return value.f;
    }
    case ValueType::Int:
    {
        return value.i;
    }
    default:
    {
        ctx->throwException(createException(ExcType::TypeError, "Value is not convertable to float."));
    }
    }

    SDL_assert_release(false);
    return 0.0;
}
示例#11
0
bool TtfFont::loadFont(const std::string &path)
{
    SDL_assert_release(g_ft);
    FT_Error error = FT_New_Face(g_ft, path.c_str(), 0, &m_face);
    SDL_assert(error == 0);
    if(error)
        return false;
    error = FT_Set_Pixel_Sizes(m_face, 0, m_recentPixelSize);
    SDL_assert(error == 0);
    if(error)
        return false;
    error = FT_Select_Charmap(m_face, ft_encoding_unicode);
    SDL_assert(error == 0);
    if(error)
        return false;

    m_fontName.append(m_face->family_name);
    m_fontName.push_back(' ');
    m_fontName.append(m_face->style_name);
    m_isReady = true;
    return true;
}
示例#12
0
int main() {
	SDL_Log("%s", "start programm");
	debug_init();
	SDL_Log("%s", "debug init");
	int result = SDL_Init(SDL_INIT_EVERYTHING);
	SDL_assert_release(result >= 0);
	SDL_Log("%s", "sdl init");
	SDL_Surface * screen = SDL_SetVideoMode(640, 480, 32, SDL_OPENGL);
	SDL_assert(NULL != screen);
	SDL_Log("%s", "create window");
	bool loop = true;
	while (loop) {
		SDL_Event event = {0};
		while(SDL_PollEvent(&event))
		{
			if (event.type == SDL_KEYDOWN)
			{
				if (event.key.keysym.sym == SDLK_ESCAPE)
				{
					loop = false;
				} else if (event.key.keysym.sym == SDLK_SPACE)
				{
					int * ptr = 0;
					*ptr = 0; // Make crush! Test debug print stack
				}
			} else if (event.type == SDL_WINDOWEVENT and event.window.event == SDL_WINDOWEVENT_CLOSE)
			{
				loop = false;
			}
		}
		SDL_Delay(0); // do not use all CPU
	}

	SDL_FreeSurface(screen);
	SDL_Log("%s", "destroy window");
	SDL_Quit();

	return EXIT_SUCCESS;
}
LevelScene::LevelScene()
    : Scene(Level),
      m_isInit(false),
      m_isInitFailed(false),
      m_isWarpEntrance(false),
      m_cameraStartDirected(false),
      m_cameraStartDirection(0),
      m_newPlayerID(1),
      /*********Exit*************/
      m_isLevelContinues(true),
      m_warpToLevelFile(""),
      m_lastWarpID(0),
      m_warpToArrayID(0),
      m_warpToWorld(false),
      m_exitLevelDelay(3000),
      m_exitLevelCode(LvlExit::EXIT_Closed),
      /**************************/
      m_characterSwitchers(this),
      m_data(FileFormats::CreateLevelData()),
      /*********Physics**********/
      m_globalGravity(1.0),
      /**************************/
      m_luaEngine(this)
{
    //m_tree.RemoveAll();
    m_qtree.clear();

    m_layers.m_scene = this;
    m_events.m_scene = this;
    m_data.meta.ReadFileValid = false;
    m_zCounter = 0.0L;
    /**************************/
    m_placingMode = false;
    m_placingMode_item_type = 0;
    m_placingMode_block = FileFormats::CreateLvlBlock();
    m_placingMode_bgo  = FileFormats::CreateLvlBgo();
    m_placingMode_npc  = FileFormats::CreateLvlNpc();
    m_placingMode_animatorID = 0;
    m_placingMode_animated = false;
    m_placingMode_sizableBlock = false;
    m_placingMode_rect_draw = false;
    /**************************/
    /*********Default players number*************/
    m_numberOfPlayers = 2;
    /*********Default players number*************/
    /*********Loader*************/
    m_loaderIsWorks = false;
    /*********Loader*************/
    /*********Fader*************/
    m_fader.setFull();
    /*********Fader*************/
    /*********Controller********/
    m_player1Controller = g_AppSettings.openController(1);
    m_player2Controller = g_AppSettings.openController(2);
    SDL_assert_release(m_player1Controller);//At least one controller must be defined
    /*********Controller********/
    /*********Pause menu*************/
    initPauseMenu1();
    /*********Pause menu*************/
    m_frameSkip = g_AppSettings.frameSkip;
    m_messages.m_scene = this;
    m_errorMsg = "";
    m_gameState = nullptr;
    m_debug_player_jumping = false;
    m_debug_player_onground = false;
    m_debug_player_foots = 0;
    m_debug_render_delay = 0;
    m_debug_phys_delay = 0;
    m_debug_event_delay = 0;
}
示例#14
0
bool App::Init( bool bFullScreen, unsigned int displayWidth, unsigned int displayHeight )
{
	if( SDL_Init( SDL_INIT_EVERYTHING ) != 0)
	{
		fprintf( stderr, "SDL failed to initialise: %s\n",SDL_GetError() );
		return false;
	}

	printf( "SDL initialised\n" );

	SDL_version compiledVersion;
	SDL_version linkedVersion;
	SDL_VERSION( &compiledVersion );
	SDL_GetVersion( &linkedVersion );
	print_SDL_version( "Compiled against SDL version", compiledVersion );
	print_SDL_version( "Linking against SDL version", linkedVersion );
	SDL_assert_release( (compiledVersion == linkedVersion) );

	int numDisplays = SDL_GetNumVideoDisplays();
	printf( "%d video displays\n", numDisplays );
	for( int i = 0; i < numDisplays; ++i )
	{
		SDL_DisplayMode displayMode;
		if( SDL_GetCurrentDisplayMode(i, &displayMode) != 0 )
		{
			fprintf( stderr, "Failed to get display mode for video display %d: %s", i, SDL_GetError() );
			continue;
		}

		printf( "Display %d: w=%d, h=%d refresh_rate=%d\n", i, displayMode.w, displayMode.h, displayMode.refresh_rate );
   	}

#ifdef GL_ES_VERSION_2_0
	SetGLAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);
	SetGLAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
	SetGLAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
#endif

	const char* title = "SDL Window";
	if( bFullScreen )
	{
	  HP_FATAL_ERROR("Just checking");
		m_pWindow = SDL_CreateWindow( title, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 0, 0, SDL_WINDOW_FULLSCREEN_DESKTOP );
	}
	else
	{
	  m_pWindow = SDL_CreateWindow( title, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, displayWidth, displayHeight, SDL_WINDOW_SHOWN /*| SDL_WINDOW_OPENGL*/ );
	}

	if( !m_pWindow )
	{
		printf( "Failed to create SDL window: %s\n", SDL_GetError() );
		return false;
	}

#ifdef GL_ES_VERSION_2_0
	// Let's see if we can use OpenGL ES 2 on Raspberry Pi
	SDL_GLContext gl_context = SDL_GL_CreateContext(m_pWindow);
	printf("GL_VERSION: "); 
	PrintGLString(GL_VERSION);
	printf("GL_RENDERER: ");
	PrintGLString(GL_RENDERER);
	printf("GL_SHADING_LANGUAGE_VERSION: ");
	PrintGLString(GL_SHADING_LANGUAGE_VERSION);
	printf("GL_EXTENSIONS: ");
	PrintGLString(GL_EXTENSIONS);
	SDL_GL_DeleteContext(gl_context);
#endif

	// SDL2_ttf

	if( TTF_Init() == -1 )
	{
		fprintf( stderr, "Failed to initialise SDL2_ttf: %s\n", TTF_GetError() );
		return false;
	}

	printf( "SDL_ttf initialised\n" );

	SDL_TTF_VERSION( &compiledVersion );
	const SDL_version *pLinkedVersion = TTF_Linked_Version();
	print_SDL_version( "Compiled against SDL_ttf version", compiledVersion );
	print_SDL_version( "Linking against SDL_ttf version", *pLinkedVersion );

	unsigned int logicalWidth = 1280;
	unsigned int logicalHeight = 720;
	m_pRenderer = new Renderer( *m_pWindow, logicalWidth, logicalHeight );

	m_pGame = new Game();

	if( !m_pGame->Init() )
	{
		fprintf( stderr, "ERROR - Game failed to initialise\n" );
		return false;
	}

	return true;
}
示例#15
0
TtfFont::TtfFont() : BaseFontEngine()
{
    SDL_assert_release(g_ft);
}
示例#16
0
bool initializeFreeType()
{
    FT_Error error = FT_Init_FreeType(&g_ft);
    SDL_assert_release(error == 0);
    return true;
}
示例#17
0
lite3d_mesh_chunk *lite3d_mesh_append_chunk(lite3d_mesh *mesh,
    const lite3d_mesh_layout *layout,
    uint32_t layoutCount,
    uint32_t stride,
    uint16_t componentType,
    uint32_t indexesCount,
    size_t indexesSize,
    size_t indexesOffset,
    uint32_t verticesCount,
    size_t verticesSize,
    size_t verticesOffset)
{
    lite3d_mesh_chunk *meshChunk;
    uint32_t attribIndex = 0, i = 0;
    size_t vOffset = verticesOffset;

    meshChunk = (lite3d_mesh_chunk *) lite3d_malloc_pooled(LITE3D_POOL_NO1, sizeof (lite3d_mesh_chunk));
    SDL_assert_release(meshChunk);

    if (!lite3d_mesh_chunk_init(meshChunk, LITE3D_TRUE))
    {
        lite3d_free_pooled(LITE3D_POOL_NO1, meshChunk);
        return NULL;
    }

    meshChunk->mesh = mesh;
    meshChunk->layout = (lite3d_mesh_layout *) lite3d_malloc(sizeof (lite3d_mesh_layout) * layoutCount);
    SDL_assert_release(meshChunk->layout);

    /* VAO set current */
    glBindVertexArray(meshChunk->vao.vaoID);
    /* use single VBO to store all data */
    glBindBuffer(mesh->vertexBuffer.role, mesh->vertexBuffer.vboID);
    /* bind all arrays and attribs into the current VAO */
    for (; i < layoutCount; ++i)
    {
        glEnableVertexAttribArray(attribIndex);
        glVertexAttribPointer(attribIndex++, layout[i].count, GL_FLOAT,
            GL_FALSE, stride, LITE3D_BUFFER_OFFSET(vOffset));

        vOffset += layout[i].count * sizeof (GLfloat);
        meshChunk->layout[i] = layout[i];
    }

    // setup buffers for instancing rendering 
    if (mesh->auxBuffer)
    {
        glBindBuffer(mesh->vertexBuffer.role, mesh->auxBuffer->vboID);
        for(i = 0; i < 4; ++i)
        {
            glEnableVertexAttribArray(attribIndex);
            glVertexAttribPointer(attribIndex, 4, GL_FLOAT, GL_FALSE, sizeof(kmMat4), LITE3D_BUFFER_OFFSET(i * sizeof(kmVec4)));
            glVertexAttribDivisor(attribIndex++, 1);
        }
    }

    if (indexesCount > 0 && indexesSize > 0)
    {
        glBindBuffer(mesh->indexBuffer.role, mesh->indexBuffer.vboID);
        meshChunk->hasIndexes = LITE3D_TRUE;
    }
    else
    {
        meshChunk->hasIndexes = LITE3D_FALSE;
    }

    /* end VAO binding */
    glBindVertexArray(0);

    meshChunk->vao.indexesOffset = indexesOffset;
    meshChunk->vao.indexType = componentType;
    meshChunk->vao.indexesCount = indexesCount;
    meshChunk->vao.indexesSize = indexesSize;
    meshChunk->vao.verticesCount = verticesCount;
    meshChunk->vao.verticesSize = verticesSize;
    meshChunk->vao.verticesOffset = verticesOffset;
    meshChunk->layoutEntriesCount = layoutCount;
    meshChunk->vao.elementsCount = (indexesCount > 0 ? indexesCount : verticesCount) / 3;

    memset(&meshChunk->boundingVol, 0, sizeof (meshChunk->boundingVol));

    lite3d_list_add_last_link(&meshChunk->node, &mesh->chunks);
    mesh->chunkCount++;

    SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, "MESH: %p: chunk %p: %s, cv/ov/sv %d/%ldb/%udb, ci/oi %d/%ldb",
        (void *) mesh, (void *) meshChunk, "TRIANGLES",
        meshChunk->vao.verticesCount, meshChunk->vao.verticesOffset, stride, meshChunk->vao.indexesCount, meshChunk->vao.indexesOffset);

    return meshChunk;
}
示例#18
0
SDL_Surface *CreateSurface(int width, int height)
{
  auto surface =  SDL_CreateRGBSurface(0, width, height, 32, RMASK, GMASK, BMASK, AMASK);
  SDL_assert_release(surface != nullptr);
  return surface;
}
示例#19
0
int initGraphics( int w, int h, int fullscreen )
{
	int result = SDL_Init( /*SDL_INIT_TIMER |*/ SDL_INIT_AUDIO | SDL_INIT_VIDEO );

	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES);
	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 2);

	g_window = SDL_CreateWindow(NULL, 100, 100, w, h, SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN/* | SDL_WINDOW_BORDERLESS*/ | (fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0));

#ifdef GJ_OS_WINDOWS
	SDL_SysWMinfo info; 
	SDL_VERSION(&info.version); // initialize info structure with SDL version info 
	SDL_bool get_win_info = SDL_GetWindowWMInfo(g_window, &info); 
	SDL_assert_release(get_win_info); 
	EGLNativeWindowType hWnd = info.info.win.window; 

	g_context = new ESContext(); 

	g_context->width = w;
	g_context->height = h;
	g_context->hWnd = hWnd; 

	EGLint configAttribList[] = 
	{ 
		EGL_RED_SIZE,       8, 
		EGL_GREEN_SIZE,     8, 
		EGL_BLUE_SIZE,      8, 
		EGL_ALPHA_SIZE,     8 /*: EGL_DONT_CARE*/, 
		EGL_DEPTH_SIZE,     EGL_DONT_CARE, 
		EGL_STENCIL_SIZE,   EGL_DONT_CARE, 
		EGL_SAMPLE_BUFFERS, 0, 
		EGL_NONE 
	}; 
	EGLint surfaceAttribList[] = 
	{ 
		// attribute, value
		EGL_NONE, EGL_NONE 
	}; 

	if ( !g_context ) 
	{ 
		//throw std::runtime_error("can't create opengl es 2.0 context, NULL es_context"); 
	} 

	EGLBoolean is_context_created = CreateEGLContext(g_context->hWnd, 
		&g_context->eglDisplay, 
		&g_context->eglContext, 
		&g_context->eglSurface, 
		configAttribList, 
		surfaceAttribList); 

	if (is_context_created == 0) 
	{ 
		//throw std::runtime_error("can't create opengl es 2.0 context"); 
	} 
#else 
	g_context = SDL_GL_CreateContext(g_window); 
	//int result = SDL_GL_SetSwapInterval(0); 
	//SDL_assert(0 == result); 
#endif 

	initGLESExtensions();

	return 0;
}
示例#20
0
PGE_Size TtfFont::textSize(std::string &text,
                           uint32_t max_line_lenght,
                           bool cut, uint32_t fontSize)
{
    SDL_assert_release(g_ft);
    if(text.empty())
        return PGE_Size(0, 0);

    size_t lastspace = 0; //!< index of last found space character
    size_t count     = 1; //!< Count of lines
    uint32_t maxWidth     = 0; //!< detected maximal width of message

    uint32_t widthSumm    = 0;
    uint32_t widthSummMax = 0;

    if(cut)
    {
        std::string::size_type i = text.find('\n');
        if(i != std::string::npos)
            text.erase(i, text.size() - i);
    }

    /****************Word wrap*********************/
    uint32_t x = 0;
    for(size_t i = 0; i < text.size(); i++, x++)
    {
        char &cx = text[i];
        UTF8 uch = static_cast<unsigned char>(cx);

        switch(cx)
        {
        case '\r':
            break;

        case '\t':
        {
            //Fake tabulation
            size_t space = (4 * fontSize);
            widthSumm += (space - ((widthSumm / space) % 4));
            if(widthSumm > widthSummMax)
                widthSummMax = widthSumm;
            break;
        }

        case '\n':
        {
            lastspace = 0;
            if((maxWidth < x) && (maxWidth < max_line_lenght))
                maxWidth = x;
            x = 0;
            widthSumm = 0;
            count++;
            break;
        }

        default:
        {
            if(' ' == cx)
                lastspace = x;
            TheGlyph &glyph = getGlyph(fontSize, get_utf8_char(&cx));
            widthSumm += uint32_t(glyph.advance>>6);
            if(widthSumm > widthSummMax)
                widthSummMax = widthSumm;
            break;
        }

        }//Switch

        if((max_line_lenght > 0) && (x >= max_line_lenght)) //If lenght more than allowed
        {
            maxWidth = x;
            if(lastspace > 0)
            {
                text[lastspace] = '\n';
                i = lastspace - 1;
                lastspace = 0;
            }
            else
            {
                text.insert(i, 1, '\n');
                x = 0;
                count++;
            }
        }
        i += static_cast<size_t>(trailingBytesForUTF8[uch]);
    }

    if(count == 1)
        maxWidth = static_cast<uint32_t>(text.length());

    /****************Word wrap*end*****************/
    return PGE_Size(static_cast<int32_t>(widthSummMax), static_cast<int32_t>((fontSize * 1.5) * count));
}
示例#21
0
TtfFont::TheGlyph &TtfFont::loadGlyph(uint32_t fontSize, char32_t character)
{
    FT_Error     error = 0;
    TheGlyph     t_glyph;

    if(m_recentPixelSize != fontSize)
    {
        error = FT_Set_Pixel_Sizes(m_face, 0, fontSize);
        SDL_assert_release(error == 0);
        m_recentPixelSize = fontSize;
    }

    error = FT_Load_Char(m_face, character, FT_LOAD_RENDER);
    SDL_assert_release(error == 0); //FIXME: return dummy glypg instead

    FT_GlyphSlot glyph  = m_face->glyph;
    FT_Bitmap &bitmap   = glyph->bitmap;
    uint32_t width      = bitmap.width;
    uint32_t height     = bitmap.rows;

    uint8_t *image = new uint8_t[4 * width * height];
    if(bitmap.pitch >= 0)
    {
        for(uint32_t w = 0; w < width; w++)
        {
            for(uint32_t h = 0; h < height; h++)
            {
                uint8_t color = bitmap.buffer[static_cast<uint32_t>(bitmap.pitch) * ((height - 1) - h) + w];
                image[(4 * width) * (height - 1 - h) + (4 * w)] = color;
                image[(4 * width) * (height - 1 - h) + (4 * w + 1)] = color;
                image[(4 * width) * (height - 1 - h) + (4 * w + 2)] = color;
                image[(4 * width) * (height - 1 - h) + (4 * w + 3)] = color;
            }
        }
    }
    else if(bitmap.pitch < 0)
    {
        for(uint32_t w = 0; w < width; w++)
        {
            for(uint32_t h = 0; h < height; h++)
            {
                uint8_t color = *(bitmap.buffer - (static_cast<uint32_t>(bitmap.pitch) * (h)) + w);
                image[(4 * width)*h + (4 * w)] = color;
                image[(4 * width)*h + (4 * w + 1)] = color;
                image[(4 * width)*h + (4 * w + 2)] = color;
                image[(4 * width)*h + (4 * w + 3)] = color;
            }
        }
    }

    m_texturesBank.emplace_back();
    PGE_Texture &texture = m_texturesBank.back();
    texture.nOfColors   = GL_RGBA;
    texture.format      = GL_BGRA;

    GlRenderer::loadRawTextureP(texture, image, width, height);
    t_glyph.tx      = &texture;
    t_glyph.width   = width;
    t_glyph.height  = height;
    t_glyph.left    = glyph->bitmap_left;
    t_glyph.top     = glyph->bitmap_top;
    t_glyph.advance = glyph->advance.x;
    t_glyph.glyph_width = glyph->advance.x;

    delete [] image;

    SizeCharMap::iterator fSize = m_charMap.find(fontSize);
    if(fSize == m_charMap.end())
    {
        m_charMap.insert({fontSize, CharMap()});
        fSize = m_charMap.find(fontSize);
        SDL_assert_release(fSize != m_charMap.end());
    }

    fSize->second.insert({character, t_glyph});
    CharMap::iterator rc = fSize->second.find(character);
    SDL_assert_release(rc != fSize->second.end());

    return rc->second;
}