[trevorparscal]

I am working on a derelict style FreeType 2 port, but to be honest, i am feeling like I am in over my head.

I have about 6 hours in, and I only got about 4 of the 77 files done.

Is there an automated way this is done, is there a specific way to get around porting EVERYTHING?

I would really love to have a real freetype binding, but I am getting close to just writing a simple wrapper and binding that.

Let me know if anyone has any advice on porting large libraries like FreeType..

And yes I know thay SDL_ttf is already ported, but I am working with GLFW so SDL doesn't help me.. Or can I run them together?... I don't think I can.

Well, let me know.

Thanks,
Trevor Parscal

[JJR]

[trevorparscal]

I am programing on windows xp using eclipse and writing batch files that use build to compile my programs.

I am trying my hardest to not get stuck in something that is platform dependent, but I also dislike the heavy overhead of SDL, so GLFW seemed like a worthy move. However, now I am suffering without text rendering, and it's really delaying my whole project.

Anyhoo, I couldn't seem to do anything with h2d cause it's for linux only. I hope to get this port done, but I am getting so frustrated with the sheer complexity of FreeType, I am wishing something more simple existed.

Oh, and SDL and SDL_ttf being compiled with GLFW cause the app to be REALLY slow loading, probably cause it's even HEAVIER! I can't get SDL_ttf on it's own, it will complain about SDL.dll cause I never loaded it with the loader.

Maybe I should write a SDL_ttf style library like TrueType for D, and it will have the simplified functionality of FreeType without the excessive overhead. For instance, the freetype DLL is 450k. If I made an SDL_ttf style library, only it was independent of SDL, i would only be using a portion of that code, so it could be even smaller than SDL_ttf's DLL size of 340k. Faster loading, less ram wastage...

But I fear I would have to write the thing in C, which I hate now that I am spoiled with D.

A compiled C++ DLL is incompatible with D? I am unsure on that.. Maybe you could enlighten me there.

Thanks,
Trevor Parscal

[JJR]

[h3r3tic]

Dunno if it'll be of much help but here's what I do to port C libs to be Derelict-compatible:

1. On a remote linux box, I run h2d on the .h files
2. I connect thru WinSCP and dload the .d files to my machine

Now Locally (WinXP):
3. I use a few regexps in gvim to delete stuff that I don't need from the .d files.
4. In jEdit I run a custom macro that converts function definitions to function pointer definitions and their declarations
5. Optionally goto 3
6. I run a python script that scans these function pointers and generates loading code for them
7. I grab common Derelict loading code that uses DerelictUtil and with a few cut-n-paste's and hand-edits I make it all Derelict compatible.

Unless you get zillions of macros or .h files, this technique should work just fine

[JJR]

Excellent! Thanks for sharing, Tom.

Another option for those that don't have a linux system is to use a pc emulator on XP, like virtual pc or vmware workstation, and to install linux on that.

A faster option would be to use cooperative linux: http://www.colinux.org/

Or we could just port h2d to windows and be done with it.

-JJR

[h3r3tic]

[JJR]

[h3r3tic]

[JJR]

[h3r3tic]

<OT>
// About the linux/windows cross platform development:

I've installed Xming (http://freedesktop.org/wiki/Xming) and tunneling X11 throught putty to my FC2 running on VPC, I'm getting around 40fps in my GUI demo. Although it gets as high as 700 fps when running natively on my WinXP, I don't think I need any more to develop cross-platform applications that use OpenGL. Probably coLinux can give more fps, I may check it out later, but that's not the point. If I develop on the Win32 box and get a steady framerate then all I have to do on the linux box is... to ensure if it runs at all. This is just enough for most needs, and occasionally I might check my apps on a "full-blown" linux box to see if the performance is the same as on Win32.

</OT>

[JJR]

Good to know! Thanks, Tom!

So I guess the "remote" X server idea can work well. If this would work on coop linux, it would be just a nice extra, I guess, but not critical. I may give it a try with VPC sometime. I also have VMWare workstation to play with.

-JJR

[JJR]

[h3r3tic]

[trevorparscal]

Maybe if one of you guys could do as much automatic stuff to the freetype headers as possible, and give me the results, I could debug and finish it up.

FreeType unfourtunately has a bunch of macros, but I am unsure if ANY are nesecary for using the library, and the ones I converted so far seemed to be able to be made into functions easy enough..

Also, they use macros to define the kind of export to use, like DLL or static I think, so the beinging of each function has

EXPORT( type ) funcname(params);

The EXPORT can just be stripped. Also there are some definitions that use a macro that converts 4 characters into a 32bit integer. I just used the same technique as their macro in an outside program, and came up with the numbers myself, which would be "hard coding", but to be honest I can't understand why they did this in the first place...

here are those defs..

/* Hardcoded 32bit Integers */
alias ulong FT_Encoding_;
const FT_Encoding_ FT_ENCODING_NONE = 0;
const FT_Encoding_ FT_ENCODING_MS_SYMBOL = 1937337698;
const FT_Encoding_ FT_ENCODING_UNICODE = 1970170211;
const FT_Encoding_ FT_ENCODING_SJIS = 1936353651;
const FT_Encoding_ FT_ENCODING_GB2312 = 1734484000;
const FT_Encoding_ FT_ENCODING_BIG5 = 1651074869;
const FT_Encoding_ FT_ENCODING_WANSUNG = 2002873971;
const FT_Encoding_ FT_ENCODING_JOHAB = 1785686113;
const FT_Encoding_ FT_ENCODING_ADOBE_STANDARD = 1094995778;
const FT_Encoding_ FT_ENCODING_ADOBE_EXPERT = 1094992453;
const FT_Encoding_ FT_ENCODING_ADOBE_CUSTOM = 1094992451;
const FT_Encoding_ FT_ENCODING_ADOBE_LATIN_1 = 1818326065;
const FT_Encoding_ FT_ENCODING_OLD_LATIN_2 = 1818326066;
const FT_Encoding_ FT_ENCODING_APPLE_ROMAN = 1634889070;

and I think I have all the functions, just not ALL the prototypes. here are the functions...

/* Functions */

/* Fucntions */
extern (C)
{
// Function Types
typedef FT_Error function(FT_Library *alibrary) pfFT_Init_FreeType;
typedef void function(FT_Library library, FT_Int *amajor, FT_Int *aminor, FT_Int *apatch ) pfFT_Library_Version;
typedef FT_Error function(FT_Library library) pfFT_Done_FreeType;
typedef FT_Error function(FT_Library library, char* filepathname, FT_Long face_index, FT_Face *aface) pfFT_New_Face;
typedef FT_Error function(FT_Library library, FT_Byte* file_base, FT_Long file_size, FT_Long face_index, FT_Face *aface) pfFT_New_Memory_Face;
typedef FT_Error function(FT_Library library, FT_Open_Args* args, FT_Long face_index, FT_Face *aface ) pfFT_Open_Face;
typedef FT_Error function(FT_Face face, char* filepathname) pfFT_Attach_File;
typedef FT_Error function(FT_Face face, FT_Open_Args* parameters) pfFT_Attach_Stream;
typedef FT_Error function(FT_Face face) pfFT_Done_Face;
typedef FT_Error function(FT_Face face, FT_F26Dot6 char_width, FT_F26Dot6 char_height, FT_UInt horz_resolution, FT_UInt vert_resolution) pfFT_Set_Char_Size;
typedef FT_Error function(FT_Face face, FT_UInt pixel_width, FT_UInt pixel_height) pfFT_Set_Pixel_Sizes;
typedef FT_Error function(FT_Face face, FT_UInt glyph_index, FT_Int32 load_flags) pfFT_Load_Glyph;
typedef FT_Error function(FT_Face face, FT_ULong char_code, FT_Int32 load_flags) pfFT_Load_Char;
typedef void function(FT_Face face, FT_Matrix* matrix, FT_Vector* delta) pfFT_Set_Transform;
typedef FT_Error function(FT_GlyphSlot slot, FT_Render_Mode render_mode) pfFT_Render_Glyph;
typedef FT_Error function(FT_Face face, FT_UInt left_glyph, FT_UInt right_glyph, FT_UInt kern_mode, FT_Vector *akerning) pfFT_Get_Kerning;
typedef FT_Error function(FT_Face face, FT_UInt glyph_index, FT_Pointer buffer, FT_UInt buffer_max) pfFT_Get_Glyph_Name;
typedef const char* function(FT_Face face) pfFT_Get_Postscript_Name;
typedef FT_Error function(FT_Face face, FT_Encoding encoding) pfFT_Select_Charmap;
typedef FT_Error function(FT_Face face, FT_CharMap charmap) pfFT_Set_Charmap;
typedef FT_UInt function(FT_Face face, FT_ULong charcode) pfFT_Get_Char_Index;
typedef FT_ULong function(FT_Face face, FT_UInt *agindex) pfFT_Get_First_Char;
typedef FT_ULong function(FT_Face face, FT_ULong char_code, FT_UInt *agindex) pfFT_Get_Next_Char;
typedef FT_UInt function(FT_Face face, FT_String* glyph_name) pfFT_Get_Name_Index;
typedef FT_Long function(FT_Long a, FT_Long b, FT_Long c) pfFT_MulDiv;
typedef FT_Long function(FT_Long a, FT_Long b) pfFT_MulFix;
typedef FT_Long function(FT_Long a, FT_Long b) pfFT_DivFix;
typedef FT_Fixed function(FT_Fixed a) pfFT_RoundFix;
typedef FT_Fixed function(FT_Fixed a) pfFT_CeilFix;
typedef FT_Fixed function(FT_Fixed a) pfFT_FloorFix;
typedef void function(FT_Vector* vec, FT_Matrix* matrix) pfFT_Vector_Transform;

// Function Pointers
pfFT_Init_FreeType FT_Init_FreeType;
pfFT_Library_Version FT_Library_Version;
pfFT_Done_FreeType FT_Done_FreeType;
pfFT_New_Face FT_New_Face;
pfFT_New_Memory_Face FT_New_Memory_Face;
pfFT_Open_Face FT_Open_Face;
pfFT_Attach_File FT_Attach_File;
pfFT_Attach_Stream FT_Attach_Stream;
pfFT_Done_Face FT_Done_Face;
pfFT_Set_Char_Size FT_Set_Char_Size;
pfFT_Set_Pixel_Sizes FT_Set_Pixel_Sizes;
pfFT_Load_Glyph FT_Load_Glyph;
pfFT_Load_Char FT_Load_Char;
pfFT_Set_Transform FT_Set_Transform;
pfFT_Render_Glyph FT_Render_Glyph;
pfFT_Get_Kerning FT_Get_Kerning;
pfFT_Get_Glyph_Name FT_Get_Glyph_Name;
pfFT_Get_Postscript_Name FT_Get_Postscript_Name;
pfFT_Select_Charmap FT_Select_Charmap;
pfFT_Set_Charmap FT_Set_Charmap;
pfFT_Get_Char_Index FT_Get_Char_Index;
pfFT_Get_First_Char FT_Get_First_Char;
pfFT_Get_Next_Char FT_Get_Next_Char;
pfFT_Get_Name_Index FT_Get_Name_Index;
pfFT_MulDiv FT_MulDiv;
pfFT_MulFix FT_MulFix;
pfFT_DivFix FT_DivFix;
pfFT_RoundFix FT_RoundFix;
pfFT_CeilFix FT_CeilFix;
pfFT_FloorFix FT_FloorFix;
pfFT_Vector_Transform FT_Vector_Transform;
}

/* Loader */
private SharedLib libFreeType;

private void* getProc(char[] procName)
{
return _GetProc(libFreeType, procName);
}

private void load()
{
FT_Init_FreeType = cast(pfFT_Init_FreeType)getProc("FT_Init_FreeType");
FT_Library_Version = cast(pfFT_Library_Version)getProc("FT_Library_Version");
FT_Done_FreeType = cast(pfFT_Done_FreeType)getProc("FT_Done_FreeType");
FT_New_Face = cast(pfFT_New_Face)getProc("FT_New_Face");
FT_New_Memory_Face = cast(pfFT_New_Memory_Face)getProc("FT_New_Memory_Face");
FT_Open_Face = cast(pfFT_Open_Face)getProc("FT_Open_Face");
FT_Attach_File = cast(pfFT_Attach_File)getProc("FT_Attach_File");
FT_Attach_Stream = cast(pfFT_Attach_Stream)getProc("FT_Attach_Stream");
FT_Done_Face = cast(pfFT_Done_Face)getProc("FT_Done_Face");
FT_Set_Char_Size = cast(pfFT_Set_Char_Size)getProc("FT_Set_Char_Size");
FT_Set_Pixel_Sizes = cast(pfFT_Set_Pixel_Sizes)getProc("FT_Set_Pixel_Sizes");
FT_Load_Glyph = cast(pfFT_Load_Glyph)getProc("FT_Load_Glyph");
FT_Load_Char = cast(pfFT_Load_Char)getProc("FT_Load_Char");
FT_Set_Transform = cast(pfFT_Set_Transform)getProc("FT_Set_Transform");
FT_Render_Glyph = cast(pfFT_Render_Glyph)getProc("FT_Render_Glyph");
FT_Get_Kerning = cast(pfFT_Get_Kerning)getProc("FT_Get_Kerning");
FT_Get_Glyph_Name = cast(pfFT_Get_Glyph_Name)getProc("FT_Get_Glyph_Name");
FT_Get_Postscript_Name = cast(pfFT_Get_Postscript_Name)getProc("FT_Get_Postscript_Name");
FT_Select_Charmap = cast(pfFT_Select_Charmap)getProc("FT_Select_Charmap");
FT_Set_Charmap = cast(pfFT_Set_Charmap)getProc("FT_Set_Charmap");
FT_Get_Char_Index = cast(pfFT_Get_Char_Index)getProc("FT_Get_Char_Index");
FT_Get_First_Char = cast(pfFT_Get_First_Char)getProc("FT_Get_First_Char");
FT_Get_Next_Char = cast(pfFT_Get_Next_Char)getProc("FT_Get_Next_Char");
FT_Get_Name_Index = cast(pfFT_Get_Name_Index)getProc("FT_Get_Name_Index");
FT_MulDiv = cast(pfFT_MulDiv)getProc("FT_MulDiv");
FT_MulFix = cast(pfFT_MulFix)getProc("FT_MulFix");
FT_DivFix = cast(pfFT_DivFix)getProc("FT_DivFix");
FT_RoundFix = cast(pfFT_RoundFix)getProc("FT_RoundFix");
FT_CeilFix = cast(pfFT_CeilFix)getProc("FT_CeilFix");
FT_FloorFix = cast(pfFT_FloorFix)getProc("FT_FloorFix");
FT_Vector_Transform = cast(pfFT_Vector_Transform)getProc("FT_Vector_Transform");
}


I think that will save time having that done, even if we throw all my other code out.

Thanks,
Trevor Parscal