Hello,
Je voulais savoir si il était possible, à la création de la fenêtre de rendu, de pouvoir la positionner ou l'on veut. Car par défaut, elle se créer toujours au centre de l'écran, mais est-il possible de modifier ça ? (par exemple, toujours en haut à gauche)

si bien sur on peut, code perso

        void moveDevice(irr::IrrlichtDevice *device, irr::core::dimension2du pos)
        {
            irr::video::SExposedVideoData evd = device->getVideoDriver()->getExposedVideoData();
            #if defined(_WIN32) || defined(_WIN64) || defined(WIN32) || defined(WIN64)
                if(device->getType() != EIDT_WIN32) return;
                HWND handle;
                switch(device->getVideoDriver()->getdevice->getVideoDriver()Type())
                {
                    EDT_DIRECT3D8: handle = (HWND)evd.D3D8.HWnd; break;
                    EDT_DIRECT3D9: handle = (HWND)evd.D3D9.HWnd; break;
                    default: handle = (HWND)evd.OpenGLWin32.HWnd; break;
                }
                ShowWindow(handle, SW_SHOW);
                UpdateWindow(handle);
                MoveWindow(handle, pos.Width, pos.Height, device->getVideoDriver()->getScreenSize().Width, device->getVideoDriver()->getScreenSize().Height, FALSE);
            #elif defined __linux
                if(device->getType() != irr::EIDT_X11) return;
                if(evd.OpenGLLinux.X11Display && evd.OpenGLLinux.X11Window)
                    XMoveWindow((Display*)evd.OpenGLLinux.X11Display, (Window)evd.OpenGLLinux.X11Window, pos.Width, pos.Height);
            #endif
        }

Merci Magun, c'est nickel
Sinon, quand tu parle de fullscreen, est ce que tu veux dire "en gardant la barre en haut de la fenêtre avec les boutons "fermer" "agrandir"..."
ou carrément fullscreen ?
Parce que ça m'intéresserais bien , mais en gardant les boutons en haut si tu vois ce que je veux dire.
Merci.

edit:
et j'aimerais même, changer de résolution en cours de route, a priori, ce n'est possible direct avec Irrlicht mais possible en utilisant le handle Windows (ou un truc comme ça mais que je ne maitrise absolument pas).
Car mon problème enfaite est que: je créer un fenêtre avec IrrDevice, puis je la déplace avec le bout de code que tu ma filé, ça marche impec sauf que, la fenêtre s'affiche d'abord au milieu, puis se déplace, mais sa premier position reste imprimer à l'ecran en arriere plan !
la solution (la bricole plutôt) que j'ai trouvé pour solutionner ça, c'est de créer un fenêtre de taille (0,0) puis de la déplacer. Ca marche, mais je suis obliger de la redimensionner avec ma souris par la suite donc l'idée était plutôt de ensuite la redimensionner en (1024, 100) par exemple.
(ho là là là, je ne sais pas si c'est bien compréhensible tout ça).

edit2:
En plus de ça, j'aimerais récupérer la position de la fenêtre (dans Windows) , parce que du coup, le but pour moi était donc de la placer où je voulais, mais que si on la déplace, au moment ou on la ferme, ça enregistre sa position afin de la faire réapparaitre au même endroit à la prochaine ouverture du logiciel.

pour un fullscreen windowed il faut juste changer la grandeur de la fenetre à la taille de l'écran moins la taille des decorations (minus, close, ...)
BorderX = GetSystemMetrics(SM_CXDLGFRAME);

BorderY = GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYDLGFRAME);

par contre j'est le code pour changer la taille de la fentre a la voler pour irrlicht, tout comme pouvoire changer en fullscreen également a la voler, a ce que je sache je suis le seul utilisant irrlicht qui les pondues
maintenant y a rien de compliquer ...
bref, le fait que le device ne change pas de place directement (sous windows), c'est surment qu'il faut faire un update du Handle après le code que je t'est passer

pour récupéré la position de la fenêtre la malheureusement je ne c'est pas, je suis pro linux, et chercher dans les doc c'est reloue, tu me préviens si tu trouve a la rigeur ?

le code est similaire pour changer la résolution

        void resizeDevice(irr::IrrlichtDevice *device, irr::core::dimension2du size)
        {
            irr::video::SExposedVideoData evd = device->getVideoDriver()->getExposedVideoData();

            #if defined(_WIN32) || defined(_WIN64) || defined(WIN32) || defined(WIN64)
                if(device->getType() != EIDT_WIN32) return;
                irr::core::dimension2du pos = device->getVideoModeList()->getDesktopResolution();
                    pos -= size;
                    pos /= 2;
                HWND handle;
                switch(device->getVideoDriver()->getdevice->getVideoDriver()Type())
                {
                    EDT_DIRECT3D8: handle = (HWND)evd.D3D8.HWnd; break;
                    EDT_DIRECT3D9: handle = (HWND)evd.D3D9.HWnd; break;
                    default: handle = (HWND)evd.OpenGLWin32.HWnd; break;
                }
                ShowWindow(handle, SW_SHOW);
                UpdateWindow(handle);
                MoveWindow(handle, pos.Width, pos.Height, size.Width, size.Height, FALSE);
            #elif defined __linux
                if(device->getType() != irr::EIDT_X11) return;
                if(evd.OpenGLLinux.X11Display && evd.OpenGLLinux.X11Window)
                {
                    XResizeWindow((Display*)evd.OpenGLLinux.X11Display, (Window)evd.OpenGLLinux.X11Window, size.Width, size.Height);
                    XRaiseWindow((Display*)evd.OpenGLLinux.X11Display, (Window)evd.OpenGLLinux.X11Window);
                    XFlush((Display*)evd.OpenGLLinux.X11Display);
                }
            #endif
            device->getVideoDriver()->OnResize(irr::core::dimension2du(size.Width, size.Height));
            device->getVideoDriver()->setViewPort(irr::core::recti(0,0,size.Width, size.Height));
            printf("resize device to %dx%d\
", size.Width, size.Height);
        }

Heu sinon il existe aussi tout simplement le device->setResizable(true);

oui mais le "device->setResizable(true)" te sert juste à autoriser le redimensionnement de la fenêtre, mais ensuite tu dois la redimensionner à la taille que tu veux à la mano avec ta souris.

Sinon merci encore Magun pour ton bout de code pour passer en fullscreen, ça marche impec pour ce qui est du "GetClientRect(HWnd, &r)" ça me renvois en gros la taille de la fenêtre un peu comme un "device->getVideoDriver()->getViewPort()". Et non la position de la fenêtre.
Mais je suis en pleine recherche dans la doc, je vais finir par trouver.

En fait pour être plus clair, je travaille sur un petit projet "IrrEditWorld" un peu dans le genre IrrEdit, sauf que plutôt que de créer une fenêtre principal avec divers fenêtre de paramètre, view, menu... dedans. Je créer plusieurs "IrrlichtDevice" qui ont chacune leurs rôles, une pour la gestion de l’Edition avec barre de menu et barre d'outil, une de propriété, une de tree model, de une à quatre pour les vue (3d, top, left...) ...
Le but étant de pouvoir placer chacune d'elle ou l'on veut dans son environnement et à la taille désiré (ce qui en plus à l'avantage d'être particulièrement utile pour ceux qui aime bosser en double écran) . Au moment où l'utilisateur quitte le logiciel j'enregistre les positions et tailles de chaque fenêtre afin qu'elle puisse être remise en place à l'identique à la prochaine ouverture du logiciel.

Mais avant les bout de code de Magun, je n'avais jamais pensé à aller taper direct dans la lib Windows

Edit: je vous redis dès que je trouve, en attendant si quelqu'un trouve avant, je suis preneur aussi

Si tu veux taper dans la mfc, regarde du côté de GetWindowRect plustôt

J'ai le même problème problème donc je me permet de déterrer le topic^^.
En fait, j'ai réussi à récupérer la position de la fenetre et j'ai aussi réussi à la positionner.

Seulement sous windows, désolé pour les autres, je n'ai pas linux.

Pour récupérer la position : (il est possible de récupérer le cadre de la fenetre avec quelques modifs)

position2di getWindowPos()
{
    #ifdef _DEBUG
    printf("Preparation pour la recuperation de la position de la fenetre\
");
    #endif
    SExposedVideoData evd = mDriver->getExposedVideoData();
    if(mDevice->getType() != EIDT_WIN32) return position2di(0,0);
    HWND handle=NULL;
    #ifdef _DEBUG
    printf("Recuperation du handle de la fenetre\
");
    #endif
    switch(mDriver->getDriverType())
    {
        case EDT_DIRECT3D8: handle = (HWND)evd.D3D8.HWnd; break;
        case EDT_DIRECT3D9: handle = (HWND)evd.D3D9.HWnd; break;
        default: handle = (HWND)evd.OpenGLWin32.HWnd; break;
    }
    #ifdef _DEBUG
    printf("Handle %s\
", handle?"valide":"invalide");
    printf("Recuperation de la position de la fenetre\
");
    #endif
    WINDOWPLACEMENT lpwndpl;
    lpwndpl.length = sizeof(WINDOWPLACEMENT);
    if( GetWindowPlacement(handle, &lpwndpl) )
    {
        #ifdef _DEBUG
        printf("Position de la fenetre : %ld; %ld\
", lpwndpl.rcNormalPosition.left, lpwndpl.rcNormalPosition.top);
        #endif
        return position2di( lpwndpl.rcNormalPosition.left, lpwndpl.rcNormalPosition.top );
    }
    else
    {
        #ifdef _DEBUG
        printf("La recuperation a echouee\
");
        #endif
        return position2di(0,0);
    }
}

void setWindowPos(position2di pos)
{
    #ifdef _DEBUG
    printf("Preparation pour la modification de la position de la fenetre\
");
    #endif
    SExposedVideoData evd = mDriver->getExposedVideoData();
    if(mDevice->getType() != EIDT_WIN32) return;
    HWND handle=NULL;
    #ifdef _DEBUG
    printf("Recuperation du handle de la fenetre\
");
    #endif
    switch(mDriver->getDriverType())
    {
        case EDT_DIRECT3D8: handle = (HWND)evd.D3D8.HWnd; break;
        case EDT_DIRECT3D9: handle = (HWND)evd.D3D9.HWnd; break;
        default: handle = (HWND)evd.OpenGLWin32.HWnd; break;
    }
    #ifdef _DEBUG
    printf("Handle %s\
", handle?"valide":"invalide");
    printf("Recuperation de la taille de la fenetre\
");
    #endif
    dimension2di windowsize(-1,-1);
    WINDOWPLACEMENT lpwndpl;
    lpwndpl.length = sizeof(WINDOWPLACEMENT);
    if( GetWindowPlacement(handle, &lpwndpl) )
        windowsize = dimension2di( (lpwndpl.rcNormalPosition.right - lpwndpl.rcNormalPosition.left), (lpwndpl.rcNormalPosition.bottom - lpwndpl.rcNormalPosition.top) );
    #ifdef _DEBUG
    printf("Position actuelle de la fenetre : %ld; %ld\
", lpwndpl.rcNormalPosition.left, lpwndpl.rcNormalPosition.top);
    printf("Taille de la fenetre : %ix%i\
", windowsize.Width, windowsize.Height);
    printf("Changement de la position de la fenetre a la position : %ix%i\
", pos.X, pos.Y);
    #endif
    POINT min; min.x = min.y = 0;
    POINT max; max.x = max.y = 10000;
    RECT rect; rect.left = pos.X; rect.top = pos.Y; rect.right = pos.X+windowsize.Width; rect.bottom = pos.Y+windowsize.Height;
    lpwndpl.length = sizeof(WINDOWPLACEMENT);
    lpwndpl.flags = WPF_SETMINPOSITION;
    lpwndpl.showCmd = SW_SHOW;
    lpwndpl.ptMinPosition = min;
    lpwndpl.ptMaxPosition = max;
    lpwndpl.rcNormalPosition = rect;
    SetWindowPlacement(handle, &lpwndpl);
}

cf: http://irrlicht-fr.org/viewtopic.php?pid=10617#p10617