I got "trunk" built/working with MinGW-64 1.0, any

[Destructavator]

EDIT: The forum software happily clipped off part of the subject line, it was originally "I got "trunk" built/working with MinGW-64 1.0, anyone else had luck with this?"

Hi,

I did a quick forum search and didn't find much as far as other people that have tried this*, but after downloading and setting up the newly released version of MinGW-64, the one that is considered to be the "stable" 1.0 release (according to their website), I was able to build the trunk SVN version of Irrlicht in Code::Blocks and get a working DLL.

The resulting DLL seems to be working when building and running the SDK example programs, in 64 bits. On my Windows 7 machine it runs without malfunction and it runs FAST.

I wouldn't call it a complete success though, as I had to comment out and tweak a few things in the Irrlicht SDK source code.

I'm posting this here (hopefully in the right place in the forum, if not I apologize) because I wanted to know if anyone else has tried this and what their results were, by comparison.

Here is what I had to do to re-build the SDK in 64 bits without (apparent) errors and such:

- In the C::B project settings, I changed the WIN32 define to WIN64
- In "os.cpp" I had to add a " = 0" to the end of line 108 to overcome a compile error. So the code:

Code: Select all

#if !defined(_WIN32_WCE) && !defined (_IRR_XBOX_PLATFORM_)
			// Avoid potential timing inaccuracies across multiple cores by
			// temporarily setting the affinity of this process to one core.
			DWORD_PTR affinityMask;
			if(MultiCore)
				affinityMask = SetThreadAffinityMask(GetCurrentThread(), 1);
#endif

...became:

Code: Select all

#if !defined(_WIN32_WCE) && !defined (_IRR_XBOX_PLATFORM_)
			// Avoid potential timing inaccuracies across multiple cores by
			// temporarily setting the affinity of this process to one core.
			DWORD_PTR affinityMask = 0;
			if(MultiCore)
				affinityMask = SetThreadAffinityMask(GetCurrentThread(), 1);
#endif

I haven't yet done extensive testing to see if this broke any programs yet or not. **

- In "CIrrDeviceWin32.cpp" I had to comment out all the lines of #defines for PRODUCT_* which were lines 1058 to about 1077. MinGW 64 really complained about these being already defined.

- I had to tweak the compile config header to build withOUT the console device. This one I tried to find a better solution for, but I couldn't make anything else I tried work. ** This is one of the bigger reasons I'm posting this, to see if someone else has a better solution.

BTW, I also have the compiler options:

-m64
-static-libgcc

... and the linker options:

-m64
-static-libstdc++
-static-libgcc

...set in the C::B global compiler settings.

So, anyone else have better luck or advice?


* I did see one older post where someone posted a diff, but it looked like they had other issues trying to make it work.

** As I'm sure you can tell I'm a bit of a novice programmer, and I don't claim to be an expert. I'm one of those "self-taught" types from a few books and Internet, and still learning.

[Destructavator]

I noticed the changes in the SVN for the 1.7 branch just now, and yes, those parts of the SDK seem to compile OK now. (Don't tell me my inexperienced programming skills got to the point where I was actually *right* about something?)

I probably should have posted this info as well in my first post, but here is the remaining issue with the console device and MinGW 64:

The compiler is complaining about this section in CIrrDeviceConsole.cpp:

Code: Select all

#ifdef _IRR_WINDOWS_NT_CONSOLE_
	MouseButtonStates = 0;

	WindowsSTDIn  = GetStdHandle(STD_INPUT_HANDLE);
	WindowsSTDOut = GetStdHandle(STD_OUTPUT_HANDLE);
	PCOORD Dimensions = 0;

	if (CreationParams.Fullscreen)
	{
		if (SetConsoleDisplayMode(WindowsSTDOut, CONSOLE_FULLSCREEN_MODE, Dimensions))
		{
			CreationParams.WindowSize.Width = Dimensions->X;
			CreationParams.WindowSize.Width = Dimensions->Y;
		}
	}
	else
	{
		COORD ConsoleSize;
		ConsoleSize.X = CreationParams.WindowSize.Width;
		ConsoleSize.X = CreationParams.WindowSize.Height;
		SetConsoleScreenBufferSize(WindowsSTDOut, ConsoleSize);
	}

	// catch windows close/break signals
	SetConsoleCtrlHandler((PHANDLER_ROUTINE)ConsoleHandler, TRUE);

Specifically, it points to line 80:

Code: Select all

		if (SetConsoleDisplayMode(WindowsSTDOut, CONSOLE_FULLSCREEN_MODE, Dimensions))

With the errors:

E:\irrlicht-export\irrlicht\branches\releases\1.7\source\Irrlicht\CIrrDeviceConsole.cpp|80|error: 'CONSOLE_FULLSCREEN_MODE' was not declared in this scope|
E:\irrlicht-export\irrlicht\branches\releases\1.7\source\Irrlicht\CIrrDeviceConsole.cpp|80|error: 'SetConsoleDisplayMode' was not declared in this scope|

PLEASE NOTE that this is with the 1.7 branch now, my first post detailed what I experienced with the trunk. (I went over to the 1.7 branch because that is where the latest SVN fixes were applied.)

BTW, In C::B I right-clicked on "CONSOLE_FULLSCREEN_MODE" and went through three options, one to "Find declaration of CONSOLE_FULLSCREEN_MODE", one to "Find implementation of CONSOLE_FULLSCREEN_MODE", and one to "Find occurrences of CONSOLE_FULLSCREEN_MODE". In the first two cases I got zero results. In the third I only got one, just the occurrence in the source code file generating the error, CIrrDeviceConsole.cpp.

Looking at the surrounding code I notice what look like possible references to STD (standard library?) files, which I know for a fact from the MinGW 64 docs are a little different than the "normal" MinGW stuff.

If I had to guess, I'd say that CONSOLE_FULLSCREEN_MODE either isn't in MinGW 64 or is simply called something else.

If I'm totally on the wrong track, please correct me.

[Destructavator]

Wait a sec... I did a search on the actual function name, which wasn't understood by the compiler either (the second error).

I got popups about missing source code files!

Specifically, missing "jchuff.h" and "jdhuff.h" which were expected in Irrlicht/jpeglib/*.*

Perhaps these two files have the missing declarations and such, and were accidentally left out?

[Destructavator]

OK, I did some more research. (Isn't Google nice?)

The errors have to do with stuff from windows.h and console.h. Apparently when calling stuff from console.h, sometimes "#define _WIN32_WINNT 0x500" needs to be done before "#include <windows.h>" is called. I found a short discussion on it, along with similar compile errors, here:

http://cboard.cprogramming.com/cplusplu ... error.html

Now, granted this link goes to posts from 2006, but I'm guessing part of it *might* be relevant to stuff in MinGW 64 that's different from the regular 32-bit version.

Hang on, I'm going to check a few things and do a little more research...

[Destructavator]

Well, here's the wincon.h file in the stable 1.0 of MinGW 64, although I'm still not sure I'm even on the right track here:

Code: Select all

/**
 * This file has no copyright assigned and is placed in the Public Domain.
 * This file is part of the w64 mingw-runtime package.
 * No warranty is given; refer to the file DISCLAIMER.PD within this package.
 */
#ifndef _WINCON_
#define _WINCON_

#ifdef __cplusplus
extern "C" {
#endif

  typedef struct _COORD {
    SHORT X;
    SHORT Y;
  } COORD,*PCOORD;

  typedef struct _SMALL_RECT {
    SHORT Left;
    SHORT Top;
    SHORT Right;
    SHORT Bottom;
  } SMALL_RECT,*PSMALL_RECT;

  typedef struct _KEY_EVENT_RECORD {
    WINBOOL bKeyDown;
    WORD wRepeatCount;
    WORD wVirtualKeyCode;
    WORD wVirtualScanCode;
    union {
      WCHAR UnicodeChar;
      CHAR AsciiChar;
    } uChar;
    DWORD dwControlKeyState;
  } KEY_EVENT_RECORD,*PKEY_EVENT_RECORD;

#define RIGHT_ALT_PRESSED 0x1
#define LEFT_ALT_PRESSED 0x2
#define RIGHT_CTRL_PRESSED 0x4
#define LEFT_CTRL_PRESSED 0x8
#define SHIFT_PRESSED 0x10
#define NUMLOCK_ON 0x20
#define SCROLLLOCK_ON 0x40
#define CAPSLOCK_ON 0x80
#define ENHANCED_KEY 0x100
#define NLS_DBCSCHAR 0x10000
#define NLS_ALPHANUMERIC 0x0
#define NLS_KATAKANA 0x20000
#define NLS_HIRAGANA 0x40000
#define NLS_ROMAN 0x400000
#define NLS_IME_CONVERSION 0x800000
#define NLS_IME_DISABLE 0x20000000

  typedef struct _MOUSE_EVENT_RECORD {
    COORD dwMousePosition;
    DWORD dwButtonState;
    DWORD dwControlKeyState;
    DWORD dwEventFlags;
  } MOUSE_EVENT_RECORD,*PMOUSE_EVENT_RECORD;

#define FROM_LEFT_1ST_BUTTON_PRESSED 0x1
#define RIGHTMOST_BUTTON_PRESSED 0x2
#define FROM_LEFT_2ND_BUTTON_PRESSED 0x4
#define FROM_LEFT_3RD_BUTTON_PRESSED 0x8
#define FROM_LEFT_4TH_BUTTON_PRESSED 0x10

#define MOUSE_MOVED 0x1
#define DOUBLE_CLICK 0x2
#define MOUSE_WHEELED 0x4

  typedef struct _WINDOW_BUFFER_SIZE_RECORD {
    COORD dwSize;
  } WINDOW_BUFFER_SIZE_RECORD,*PWINDOW_BUFFER_SIZE_RECORD;

  typedef struct _MENU_EVENT_RECORD {
    UINT dwCommandId;
  } MENU_EVENT_RECORD,*PMENU_EVENT_RECORD;

  typedef struct _FOCUS_EVENT_RECORD {
    WINBOOL bSetFocus;
  } FOCUS_EVENT_RECORD,*PFOCUS_EVENT_RECORD;

  typedef struct _INPUT_RECORD {
    WORD EventType;
    union {
      KEY_EVENT_RECORD KeyEvent;
      MOUSE_EVENT_RECORD MouseEvent;
      WINDOW_BUFFER_SIZE_RECORD WindowBufferSizeEvent;
      MENU_EVENT_RECORD MenuEvent;
      FOCUS_EVENT_RECORD FocusEvent;
    } Event;
  } INPUT_RECORD,*PINPUT_RECORD;

#define KEY_EVENT 0x1
#define MOUSE_EVENT 0x2
#define WINDOW_BUFFER_SIZE_EVENT 0x4
#define MENU_EVENT 0x8
#define FOCUS_EVENT 0x10

  typedef struct _CHAR_INFO {
    union {
      WCHAR UnicodeChar;
      CHAR AsciiChar;
    } Char;
    WORD Attributes;
  } CHAR_INFO,*PCHAR_INFO;

#define FOREGROUND_BLUE 0x1
#define FOREGROUND_GREEN 0x2
#define FOREGROUND_RED 0x4
#define FOREGROUND_INTENSITY 0x8
#define BACKGROUND_BLUE 0x10
#define BACKGROUND_GREEN 0x20
#define BACKGROUND_RED 0x40
#define BACKGROUND_INTENSITY 0x80
#define COMMON_LVB_LEADING_BYTE 0x100
#define COMMON_LVB_TRAILING_BYTE 0x200
#define COMMON_LVB_GRID_HORIZONTAL 0x400
#define COMMON_LVB_GRID_LVERTICAL 0x800
#define COMMON_LVB_GRID_RVERTICAL 0x1000
#define COMMON_LVB_REVERSE_VIDEO 0x4000
#define COMMON_LVB_UNDERSCORE 0x8000

#define COMMON_LVB_SBCSDBCS 0x300

  typedef struct _CONSOLE_SCREEN_BUFFER_INFO {
    COORD dwSize;
    COORD dwCursorPosition;
    WORD wAttributes;
    SMALL_RECT srWindow;
    COORD dwMaximumWindowSize;
  } CONSOLE_SCREEN_BUFFER_INFO,*PCONSOLE_SCREEN_BUFFER_INFO;

  typedef struct _CONSOLE_CURSOR_INFO {
    DWORD dwSize;
    WINBOOL bVisible;
  } CONSOLE_CURSOR_INFO,*PCONSOLE_CURSOR_INFO;

  typedef struct _CONSOLE_FONT_INFO {
    DWORD nFont;
    COORD dwFontSize;
  } CONSOLE_FONT_INFO,*PCONSOLE_FONT_INFO;

  typedef struct _CONSOLE_SELECTION_INFO {
    DWORD dwFlags;
    COORD dwSelectionAnchor;
    SMALL_RECT srSelection;
  } CONSOLE_SELECTION_INFO,*PCONSOLE_SELECTION_INFO;

#define CONSOLE_NO_SELECTION 0x0
#define CONSOLE_SELECTION_IN_PROGRESS 0x1
#define CONSOLE_SELECTION_NOT_EMPTY 0x2
#define CONSOLE_MOUSE_SELECTION 0x4
#define CONSOLE_MOUSE_DOWN 0x8

  typedef WINBOOL (WINAPI *PHANDLER_ROUTINE)(DWORD CtrlType);

#define CTRL_C_EVENT 0
#define CTRL_BREAK_EVENT 1
#define CTRL_CLOSE_EVENT 2

#define CTRL_LOGOFF_EVENT 5
#define CTRL_SHUTDOWN_EVENT 6

#define ENABLE_PROCESSED_INPUT 0x1
#define ENABLE_LINE_INPUT 0x2
#define ENABLE_ECHO_INPUT 0x4
#define ENABLE_WINDOW_INPUT 0x8
#define ENABLE_MOUSE_INPUT 0x10

#define ENABLE_PROCESSED_OUTPUT 0x1
#define ENABLE_WRAP_AT_EOL_OUTPUT 0x2

#ifdef UNICODE
#define PeekConsoleInput PeekConsoleInputW
#define ReadConsoleInput ReadConsoleInputW
#define WriteConsoleInput WriteConsoleInputW
#define ReadConsoleOutput ReadConsoleOutputW
#define WriteConsoleOutput WriteConsoleOutputW
#define ReadConsoleOutputCharacter ReadConsoleOutputCharacterW
#define WriteConsoleOutputCharacter WriteConsoleOutputCharacterW
#define FillConsoleOutputCharacter FillConsoleOutputCharacterW
#define ScrollConsoleScreenBuffer ScrollConsoleScreenBufferW
#define GetConsoleTitle GetConsoleTitleW
#define SetConsoleTitle SetConsoleTitleW
#define ReadConsole ReadConsoleW
#define WriteConsole WriteConsoleW
#define AddConsoleAlias AddConsoleAliasW
#define GetConsoleAlias GetConsoleAliasW
#define GetConsoleAliasesLength GetConsoleAliasesLengthW
#define GetConsoleAliasExesLength GetConsoleAliasExesLengthW
#define GetConsoleAliases GetConsoleAliasesW
#define GetConsoleAliasExes GetConsoleAliasExesW
#else
#define PeekConsoleInput PeekConsoleInputA
#define ReadConsoleInput ReadConsoleInputA
#define WriteConsoleInput WriteConsoleInputA
#define ReadConsoleOutput ReadConsoleOutputA
#define WriteConsoleOutput WriteConsoleOutputA
#define ReadConsoleOutputCharacter ReadConsoleOutputCharacterA
#define WriteConsoleOutputCharacter WriteConsoleOutputCharacterA
#define FillConsoleOutputCharacter FillConsoleOutputCharacterA
#define ScrollConsoleScreenBuffer ScrollConsoleScreenBufferA
#define GetConsoleTitle GetConsoleTitleA
#define SetConsoleTitle SetConsoleTitleA
#define ReadConsole ReadConsoleA
#define WriteConsole WriteConsoleA
#define AddConsoleAlias AddConsoleAliasA
#define GetConsoleAlias GetConsoleAliasA
#define GetConsoleAliasesLength GetConsoleAliasesLengthA
#define GetConsoleAliasExesLength GetConsoleAliasExesLengthA
#define GetConsoleAliases GetConsoleAliasesA
#define GetConsoleAliasExes GetConsoleAliasExesA
#endif

  WINBASEAPI WINBOOL WINAPI PeekConsoleInputA(HANDLE hConsoleInput,PINPUT_RECORD lpBuffer,DWORD nLength,LPDWORD lpNumberOfEventsRead);
  WINBASEAPI WINBOOL WINAPI PeekConsoleInputW(HANDLE hConsoleInput,PINPUT_RECORD lpBuffer,DWORD nLength,LPDWORD lpNumberOfEventsRead);
  WINBASEAPI WINBOOL WINAPI ReadConsoleInputA(HANDLE hConsoleInput,PINPUT_RECORD lpBuffer,DWORD nLength,LPDWORD lpNumberOfEventsRead);
  WINBASEAPI WINBOOL WINAPI ReadConsoleInputW(HANDLE hConsoleInput,PINPUT_RECORD lpBuffer,DWORD nLength,LPDWORD lpNumberOfEventsRead);
  WINBASEAPI WINBOOL WINAPI WriteConsoleInputA(HANDLE hConsoleInput,CONST INPUT_RECORD *lpBuffer,DWORD nLength,LPDWORD lpNumberOfEventsWritten);
  WINBASEAPI WINBOOL WINAPI WriteConsoleInputW(HANDLE hConsoleInput,CONST INPUT_RECORD *lpBuffer,DWORD nLength,LPDWORD lpNumberOfEventsWritten);
  WINBASEAPI WINBOOL WINAPI ReadConsoleOutputA(HANDLE hConsoleOutput,PCHAR_INFO lpBuffer,COORD dwBufferSize,COORD dwBufferCoord,PSMALL_RECT lpReadRegion);
  WINBASEAPI WINBOOL WINAPI ReadConsoleOutputW(HANDLE hConsoleOutput,PCHAR_INFO lpBuffer,COORD dwBufferSize,COORD dwBufferCoord,PSMALL_RECT lpReadRegion);
  WINBASEAPI WINBOOL WINAPI WriteConsoleOutputA(HANDLE hConsoleOutput,CONST CHAR_INFO *lpBuffer,COORD dwBufferSize,COORD dwBufferCoord,PSMALL_RECT lpWriteRegion);
  WINBASEAPI WINBOOL WINAPI WriteConsoleOutputW(HANDLE hConsoleOutput,CONST CHAR_INFO *lpBuffer,COORD dwBufferSize,COORD dwBufferCoord,PSMALL_RECT lpWriteRegion);
  WINBASEAPI WINBOOL WINAPI ReadConsoleOutputCharacterA(HANDLE hConsoleOutput,LPSTR lpCharacter,DWORD nLength,COORD dwReadCoord,LPDWORD lpNumberOfCharsRead);
  WINBASEAPI WINBOOL WINAPI ReadConsoleOutputCharacterW(HANDLE hConsoleOutput,LPWSTR lpCharacter,DWORD nLength,COORD dwReadCoord,LPDWORD lpNumberOfCharsRead);
  WINBASEAPI WINBOOL WINAPI ReadConsoleOutputAttribute(HANDLE hConsoleOutput,LPWORD lpAttribute,DWORD nLength,COORD dwReadCoord,LPDWORD lpNumberOfAttrsRead);
  WINBASEAPI WINBOOL WINAPI WriteConsoleOutputCharacterA(HANDLE hConsoleOutput,LPCSTR lpCharacter,DWORD nLength,COORD dwWriteCoord,LPDWORD lpNumberOfCharsWritten);
  WINBASEAPI WINBOOL WINAPI WriteConsoleOutputCharacterW(HANDLE hConsoleOutput,LPCWSTR lpCharacter,DWORD nLength,COORD dwWriteCoord,LPDWORD lpNumberOfCharsWritten);
  WINBASEAPI WINBOOL WINAPI WriteConsoleOutputAttribute(HANDLE hConsoleOutput,CONST WORD *lpAttribute,DWORD nLength,COORD dwWriteCoord,LPDWORD lpNumberOfAttrsWritten);
  WINBASEAPI WINBOOL WINAPI FillConsoleOutputCharacterA(HANDLE hConsoleOutput,CHAR cCharacter,DWORD nLength,COORD dwWriteCoord,LPDWORD lpNumberOfCharsWritten);
  WINBASEAPI WINBOOL WINAPI FillConsoleOutputCharacterW(HANDLE hConsoleOutput,WCHAR cCharacter,DWORD nLength,COORD dwWriteCoord,LPDWORD lpNumberOfCharsWritten);
  WINBASEAPI WINBOOL WINAPI FillConsoleOutputAttribute(HANDLE hConsoleOutput,WORD wAttribute,DWORD nLength,COORD dwWriteCoord,LPDWORD lpNumberOfAttrsWritten);
  WINBASEAPI WINBOOL WINAPI GetConsoleMode(HANDLE hConsoleHandle,LPDWORD lpMode);
  WINBASEAPI WINBOOL WINAPI GetNumberOfConsoleInputEvents(HANDLE hConsoleInput,LPDWORD lpNumberOfEvents);
  WINBASEAPI WINBOOL WINAPI GetConsoleScreenBufferInfo(HANDLE hConsoleOutput,PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo);
  WINBASEAPI COORD WINAPI GetLargestConsoleWindowSize(HANDLE hConsoleOutput);
  WINBASEAPI WINBOOL WINAPI GetConsoleCursorInfo(HANDLE hConsoleOutput,PCONSOLE_CURSOR_INFO lpConsoleCursorInfo);
  WINBASEAPI WINBOOL WINAPI GetCurrentConsoleFont(HANDLE hConsoleOutput,WINBOOL bMaximumWindow,PCONSOLE_FONT_INFO lpConsoleCurrentFont);
  WINBASEAPI COORD WINAPI GetConsoleFontSize(HANDLE hConsoleOutput,DWORD nFont);
  WINBASEAPI WINBOOL WINAPI GetConsoleSelectionInfo(PCONSOLE_SELECTION_INFO lpConsoleSelectionInfo);
  WINBASEAPI WINBOOL WINAPI GetNumberOfConsoleMouseButtons(LPDWORD lpNumberOfMouseButtons);
  WINBASEAPI WINBOOL WINAPI SetConsoleMode(HANDLE hConsoleHandle,DWORD dwMode);
  WINBASEAPI WINBOOL WINAPI SetConsoleActiveScreenBuffer(HANDLE hConsoleOutput);
  WINBASEAPI WINBOOL WINAPI FlushConsoleInputBuffer(HANDLE hConsoleInput);
  WINBASEAPI WINBOOL WINAPI SetConsoleScreenBufferSize(HANDLE hConsoleOutput,COORD dwSize);
  WINBASEAPI WINBOOL WINAPI SetConsoleCursorPosition(HANDLE hConsoleOutput,COORD dwCursorPosition);
  WINBASEAPI WINBOOL WINAPI SetConsoleCursorInfo(HANDLE hConsoleOutput,CONST CONSOLE_CURSOR_INFO *lpConsoleCursorInfo);
  WINBASEAPI WINBOOL WINAPI ScrollConsoleScreenBufferA(HANDLE hConsoleOutput,CONST SMALL_RECT *lpScrollRectangle,CONST SMALL_RECT *lpClipRectangle,COORD dwDestinationOrigin,CONST CHAR_INFO *lpFill);
  WINBASEAPI WINBOOL WINAPI ScrollConsoleScreenBufferW(HANDLE hConsoleOutput,CONST SMALL_RECT *lpScrollRectangle,CONST SMALL_RECT *lpClipRectangle,COORD dwDestinationOrigin,CONST CHAR_INFO *lpFill);
  WINBASEAPI WINBOOL WINAPI SetConsoleWindowInfo(HANDLE hConsoleOutput,WINBOOL bAbsolute,CONST SMALL_RECT *lpConsoleWindow);
  WINBASEAPI WINBOOL WINAPI SetConsoleTextAttribute(HANDLE hConsoleOutput,WORD wAttributes);
  WINBASEAPI WINBOOL WINAPI SetConsoleCtrlHandler(PHANDLER_ROUTINE HandlerRoutine,WINBOOL Add);
  WINBASEAPI WINBOOL WINAPI GenerateConsoleCtrlEvent(DWORD dwCtrlEvent,DWORD dwProcessGroupId);
  WINBASEAPI WINBOOL WINAPI AllocConsole(VOID);
  WINBASEAPI WINBOOL WINAPI FreeConsole(VOID);
  WINBASEAPI WINBOOL WINAPI AttachConsole(DWORD dwProcessId);

#define ATTACH_PARENT_PROCESS ((DWORD)-1)

  WINBASEAPI DWORD WINAPI GetConsoleTitleA(LPSTR lpConsoleTitle,DWORD nSize);
  WINBASEAPI DWORD WINAPI GetConsoleTitleW(LPWSTR lpConsoleTitle,DWORD nSize);
  WINBASEAPI WINBOOL WINAPI SetConsoleTitleA(LPCSTR lpConsoleTitle);
  WINBASEAPI WINBOOL WINAPI SetConsoleTitleW(LPCWSTR lpConsoleTitle);
  WINBASEAPI WINBOOL WINAPI ReadConsoleA(HANDLE hConsoleInput,LPVOID lpBuffer,DWORD nNumberOfCharsToRead,LPDWORD lpNumberOfCharsRead,LPVOID lpReserved);
  WINBASEAPI WINBOOL WINAPI ReadConsoleW(HANDLE hConsoleInput,LPVOID lpBuffer,DWORD nNumberOfCharsToRead,LPDWORD lpNumberOfCharsRead,LPVOID lpReserved);
  WINBASEAPI WINBOOL WINAPI WriteConsoleA(HANDLE hConsoleOutput,CONST VOID *lpBuffer,DWORD nNumberOfCharsToWrite,LPDWORD lpNumberOfCharsWritten,LPVOID lpReserved);
  WINBASEAPI WINBOOL WINAPI WriteConsoleW(HANDLE hConsoleOutput,CONST VOID *lpBuffer,DWORD nNumberOfCharsToWrite,LPDWORD lpNumberOfCharsWritten,LPVOID lpReserved);

#define CONSOLE_TEXTMODE_BUFFER 1

  WINBASEAPI HANDLE WINAPI CreateConsoleScreenBuffer(DWORD dwDesiredAccess,DWORD dwShareMode,CONST SECURITY_ATTRIBUTES *lpSecurityAttributes,DWORD dwFlags,LPVOID lpScreenBufferData);
  WINBASEAPI UINT WINAPI GetConsoleCP(VOID);
  WINBASEAPI WINBOOL WINAPI SetConsoleCP(UINT wCodePageID);
  WINBASEAPI UINT WINAPI GetConsoleOutputCP(VOID);
  WINBASEAPI WINBOOL WINAPI SetConsoleOutputCP(UINT wCodePageID);

#define CONSOLE_FULLSCREEN 1
#define CONSOLE_FULLSCREEN_HARDWARE 2

  WINBASEAPI WINBOOL WINAPI GetConsoleDisplayMode(LPDWORD lpModeFlags);
  WINBASEAPI HWND WINAPI GetConsoleWindow(VOID);
  WINBASEAPI DWORD WINAPI GetConsoleProcessList(LPDWORD lpdwProcessList,DWORD dwProcessCount);
  WINBASEAPI WINBOOL WINAPI AddConsoleAliasA(LPSTR Source,LPSTR Target,LPSTR ExeName);
  WINBASEAPI WINBOOL WINAPI AddConsoleAliasW(LPWSTR Source,LPWSTR Target,LPWSTR ExeName);
  WINBASEAPI DWORD WINAPI GetConsoleAliasA(LPSTR Source,LPSTR TargetBuffer,DWORD TargetBufferLength,LPSTR ExeName);
  WINBASEAPI DWORD WINAPI GetConsoleAliasW(LPWSTR Source,LPWSTR TargetBuffer,DWORD TargetBufferLength,LPWSTR ExeName);
  WINBASEAPI DWORD WINAPI GetConsoleAliasesLengthA(LPSTR ExeName);
  WINBASEAPI DWORD WINAPI GetConsoleAliasesLengthW(LPWSTR ExeName);
  WINBASEAPI DWORD WINAPI GetConsoleAliasExesLengthA(VOID);
  WINBASEAPI DWORD WINAPI GetConsoleAliasExesLengthW(VOID);
  WINBASEAPI DWORD WINAPI GetConsoleAliasesA(LPSTR AliasBuffer,DWORD AliasBufferLength,LPSTR ExeName);
  WINBASEAPI DWORD WINAPI GetConsoleAliasesW(LPWSTR AliasBuffer,DWORD AliasBufferLength,LPWSTR ExeName);
  WINBASEAPI DWORD WINAPI GetConsoleAliasExesA(LPSTR ExeNameBuffer,DWORD ExeNameBufferLength);
  WINBASEAPI DWORD WINAPI GetConsoleAliasExesW(LPWSTR ExeNameBuffer,DWORD ExeNameBufferLength);

#ifdef __cplusplus
}
#endif
#endif

I don't see any "SetConsoleDisplayMode" function in there.

[Destructavator]

OK, I just checked the wincon.h file from the official 32-bit regular MinGW compiler include files, and compared it with the one I just posted that's in MinGW 64.

Yup, they look totally different, and the 32-bit standard version does indeed have that function listed in there, the 64-bit version does not.

It looks like MinGW-64 has a very different implementation for console, and/or has different function names compared to the standard 32-bit MinGW.

I'd also like to point out that the 64-bit version is a much larger header file, with a lot more stuff in it.

[hybrid]

Thanks for the response. You might want to look into the functionality of the edit button of your latest post, as this reduces the overhead of mass posting.
The changes for Irrlicht go either into SVN/trunk (mostly in cases of API breaking functionality) or the release branches (for bug fixing). Since your changes were only minor bug fixes, they went into the 1.7 branch. These changes are merged from time to time into trunk.

[Destructavator]

Sorry about the posting issue.

I noticed just today that the fixes for MinGW 64 support broke compilation for some of the MS compilers.

I think I can offer some help here in having the Irrlicht SDK code better detect exactly what compiler is being used and how to proceed. Although I'd like to point out a few things first, from what I've gathered. (If any of what I say next is incorrect, anyone is more than welcome to jump in and correct me.)

First, there's two main 64-bit packages of MinGW on Windows (actually more I think, but at least two main ones that are common that I'm familiar with).

- There's the "official" 1.0 MinGW w64 release (which just a few days ago reached what they call 1.0 stable).

- There's the TDM (Twilight Dragon Media) builds, which are based upon MinGW w64, and as of the time of this post are still using 4.5.1 but are expecting a 4.5.2 release any day now.

Both builds are available from SourceForge.

The FAQ for the official project actually recommends the TDM builds, especially for the inexperienced, and I've seen elsewhere on the net that newcomer programmers getting started have an easier time with TDM builds because they don't require as much setup work, they pretty much run "out of the box" unlike the official MinGW w64 project (sometimes, depending on what type of code one is building).

From what I've heard, some people use the official one, some use TDM. What the exact ratio is I'm not sure of, but the point is that there are more than one major and commonly used versions of a 64 bit version of MinGW floating around.

According to the TDM page:

As with most other compilers, GCC is a command-line tool that uses named options to control its operation. An introduction to GCC command-line compilation is beyond the scope of this discussion, but there are a few MinGW and MinGW-w64 specifics that should be mentioned.

In the MinGW-w64/TDM64 edition, use "-m32" and "-m64" to control whether 32-bit or 64-bit binaries are generated.
By default (if neither -m32 nor -m64 is specified), this edition will generate 64-bit binaries. In a 64-bit binary, all pointer math is 64-bit by default, and the built-in "size_t" and "ptrdiff_t" types are 64 bits in size (some other types are larger also). Additionally, the following preprocessor definitions will be in effect:

* #define _WIN64 1 (also WIN64, __WIN64, and __WIN64__)
* #define __MINGW64__ 1
* #define __x86_64 1 (also __x86_64__)
* #define __amd64 1 (also __amd64__)

Be sure to use "-m32" or "-m64" at both the compile stage and the link stage.

...So if the SDK code checks for those defines from that list, it could be set up to be aware that MinGW 64 is being used, and build without error.

I'll wait for a few more updates to SVN, then I'll try downloading the TDM 64 build and compare results building Irrlicht with both of them, to see if one or both do or don't work.

One other, related point: If the variable sizes are different in both builds, will that mess up any of the Irrlicht data types (Such as u32, f16, s8, and all the other custom types)?

[hybrid]

Well, the defines are probably not really related to mingw, and as it seems they are missing in variable amounts also in other headers. So we need those defines enabled/disabled in a different way, which I tried to fix today. Just to make it as simple as possible, but working with all common compilers.

The sizes of the types are not changed. This is only a problem for 64bit types, which we are currently investigating at another place. You might want to check those types once we have added them (to SVN/trunk then, though).

[Destructavator]

OK. I think I understand now.

Will there ever be any options, perhaps in the SDK compiile configuration header, to "force" or override detection of the compiler, so that when a new version of some compiler comes out and has issues building the SDK the programmer could un-comment a line to, say, force building Irrlciht as if a specific Microsoft compiler is being used, or a specific release of MinGW is being used?

Just an idea, feel free to use it if you think it would be a good one.

[hybrid]

Well, this is the idea behind this 'only as much as necessary' approach. In general, most compilers will behave the same. If some compiler is missing a thing, we add it for that specific compiler. If it is only missing is a specific version, we add it only for that version. This should reduce the impact of such conditionals and make the code work with all conforming compilers. But there's no way that 'faking' a compiler detection would make the engine's code become more acceptable to a different compiler. We simply have to work around issues in newer compilers, and hope that all will be standard conforming at some day.

[JonathanFrisch]

I'd like to make a contribution to compiling Irrlicht on a x64 machine.
Operating system: Vista Home Premium 64-bit.

First, I set up MinGW according to: http://puredata.info/docs/developer/Win ... itMinGWX64 using
Note: used "c:\mingw-w64" instead of "c:\mingw_w64" and fstab mounts for /mingw32 and /mingw64. (just my prefs.)

Second, I installed Code::Blocks without included MinGW.
Note: set up the global toolchain executables as gcc, g++, g++, ar, gdb, windres, mingw32-make and unchecked all compiler flags. (just my prefs.)

Third, from the Irrlicht project properties duplicate the Win32 Accurate Math (or Debug) dll (or static) build targets and name it something like "Win64 - Release - dll".
Change the output file name to something like "..\..\lib\Win64-gcc\Irrlicht.dll" and the objects... like "..\obj\win64-gcc-release-dll".
Then under build options -> compiler options -> #defines, change WIN32 to WIN64 and __GNUWIN32__ to __GNUWIN64__.
::edited from here down
Add
-m64
-fpermissive (to get around precision loss errors in CColladaMeshWriter.cpp -> uniqueNameFor[Mesh/Light/Node])
to other compiler options.
And add
-m64
to linker settings.
Change post build steps to:
cmd /c del ..\..\bin\Win64-gcc\libIrrlicht.dll
cmd /c cp ..\..\lib\Win64-gcc\libIrrlicht.dll ..\..\bin\Win64-gcc\libIrrlicht.dll

No need to edit Headers/include/IrrCompileConfig.h

That's it.