Pages: 1 2

 

#0 

08-06-2009 16:45:59

capry
Membre
Date d'inscription: 14-02-2009
Messages: 83

Bonjour,
J'utilise Irrlicht depuis quelque mois, et j'entreprends actuellement de crée une gui, histoire de remplacer la toute moche et peu développée d'Irrlicht, par une autre, personnalisée et plus adapté à mes besoins. Je n'utilise donc que la classe IGUIImage, pour faire apparaitre, disparaitre, bouger, mes éléments gui. Mes voilà, certaines fonction dont j'aurais besoin de sont pas présente en particulier :

- Régler la transparence de l'image
- Faire en sorte qu'une image se répète (par exemple une image qui fait 120*60 si le rectangle dans lequel elle est affiché fais 120*90, il faut qu'elle rajoute en plus les 30 premiers pixels pour compléter).

Bref, si vous aviez des idées concernant ces deux choses, j'ai pourtant fouillé la gui mais impossible de trouver une fonction qui pourrais me permettre ceci ?
Merci d'avance

Capry

Hors ligne


#1 

08-06-2009 18:38:03

tmyke
Administrateur
Date d'inscription: 24-03-2008
Messages: 1025

Ton projet m'interesse, pour plusieurs raisons.

Donc, dès ce WE (moment ou j'ai un peu de temps), j'essaierais de travailler la dessus si je peux t'aider sur les aspect que tu énonces. Si cela t'interesse bien sûr wink

Force et sagesse...

Hors ligne


#2 

08-06-2009 20:33:07

capry
Membre
Date d'inscription: 14-02-2009
Messages: 83

Ah bah oui je veux bien ^^. Si ça intéresse quelqu'un aussi je pourrais toujours donner le code avec le images de la gui à changer ^^.

Hors ligne


#3 

08-06-2009 21:51:26

tmyke
Administrateur
Date d'inscription: 24-03-2008
Messages: 1025

Pour 'appâter' si tu avais une ou deux photo d'écran pour montrer ce donne déjà, cela serait cool wink

Et un petit package sera sympa, comme base de départ pour faire des tests et voir ce qui est possible de faire
pour que cela avance dans les secteur ou cela bloque, non ?

Force et sagesse...

Hors ligne


#4 

08-06-2009 23:19:20

capry
Membre
Date d'inscription: 14-02-2009
Messages: 83

Pour l'instant ça ne donne pas grand chose de vraiment intéressant. Mes boutons sont fais avec paint et je laisserais le soin à mon designer de s'occuper de remplacer le design de la gui tongue . J'ai juste fais un truc basique, avec paint. Je ne m'occupe que de la programmation dans un premier temps. Pour l'instant voici tout ce que l'on peut faire (ma gui se nomme IrrGUI, très original ^^) :

irr::gui::IGUIEnvironnement* mainGui;
IrrGUI* gui(mainGui, driver);
IrrGUIBouton* bouton = gui->addBouton("Le texte",false,450,350,100,50);


Paramètre 1 : texte du bouton.
Paramètre 2 : true : utilise les dimensions données après; false : adapte les dimensions du bouton à la taille du texte
Paramètre 3 : position X du point supérieur gauche.
Paramètre 4 : position Y du point supérieur gauche.
Paramètre 5 : dimensions X du bouton.
Paramètre 6 : dimensions Y du bouton.

Bref d'autre viendront après comme la transparence... Je n'en suis encore qu'au début de la gui, bien qu'ayant fais une bonne partie du côté polymorphisme (les classes bouton, fenêtre, texte, etc... dérive de IrrGUIElement) le côté visuel n'en est qu'au commencement. La transparence n'est pas urgent mais j'ai besoin de faire une image se répétant pour que, admettons que j'ai une image rouge, l'arrière plan du bouton sois entièrement rouge (sans pour autant faire une image rouge gigantesque pour être sûr que tout le bouton sois rouge :S). Donc voilà où en est l'avancement de la gui.

Dernière modification par capry (08-06-2009 23:20:36)

Hors ligne


#5 

09-06-2009 13:24:54

Metallizer
Abonné
Lieu: Région Parisienne
Date d'inscription: 07-01-2007
Messages: 100
Site web

capry :

Bonjour,
Mes voilà, certaines fonction dont j'aurais besoin de sont pas présente en particulier :

- Régler la transparence de l'image


Je peux au moins répondre à ça :
http://irrlicht.sourceforge.net/docu/cl … image.html

On peut trouver une fonction setColor qui permet d'appliquer un changement de couleur à ton image, en gros si tu files une composante ARGB où alpha est entre 0 et 255, tu peux obtenir un effet de semi-transparence.

Un truc dans ce genre :

Code:

monImage->setColor(video::SColor(128,255,255,255));

Hors ligne


#6 

09-06-2009 15:23:04

capry
Membre
Date d'inscription: 14-02-2009
Messages: 83

Oui mais ça ne marche pas dans le cas où l'on veux régler la transparence à 0 par exemple :S.

Hors ligne


#7 

09-06-2009 16:52:29

Aranoth
Abonné
Lieu: Toulouse
Date d'inscription: 25-09-2006
Messages: 242
Site web

0 = invisible, il suffit de ne pas afficher l'image dans ce cas.

Planet-DEV, où on parle d'informatique, de développement et de création de jeux vidéo

Hors ligne


#8 

09-06-2009 18:33:17

capry
Membre
Date d'inscription: 14-02-2009
Messages: 83

Oui d'accord mais en ce que je veux dire c'est que l'on ne peut pas réglé la transparence à 10 si tu veux, mais tu m'as compris ^^. Mais le plus important pour l'instant c'est surtout le moyen d'avoir l'image qui se respecte dans un triangle donné (sans avoir à reproduire soi-même plein de fois la même image si possible :S).

Hors ligne


#9 

09-06-2009 18:49:54

tmyke
Administrateur
Date d'inscription: 24-03-2008
Messages: 1025

capry :

Oui mais ça ne marche pas dans le cas où l'on veux régler la transparence à 0 par exemple :S.


Je ne comprends pas ce que tu veux dire par là, comme le dit Aranoth, si transparence = 0, plus d'image visible, non ?

Force et sagesse...

Hors ligne


#10 

09-06-2009 19:18:33

capry
Membre
Date d'inscription: 14-02-2009
Messages: 83

j'ai mis 10 pas 0 ^^. Si on veut réglé la transparence à 10 l'image blanchira mais on ne verra pas ce q'il y a dessous pour autant, si j'ai bien compris.

Hors ligne


#11 

09-06-2009 19:44:59

Aranoth
Abonné
Lieu: Toulouse
Date d'inscription: 25-09-2006
Messages: 242
Site web

Tu as testé avant ? Je ne vois pas pourquoi le blending ne fonctionnerait pas, même si c'est des quads dans une vue orthogonale, ça reste les même mécanismes qu'en 3D

Planet-DEV, où on parle d'informatique, de développement et de création de jeux vidéo

Hors ligne


#12 

09-06-2009 20:01:49

tmyke
Administrateur
Date d'inscription: 24-03-2008
Messages: 1025

capry :

j'ai mis 10 pas 0 ^^. Si on veut réglé la transparence à 10 l'image blanchira mais on ne verra pas ce q'il y a dessous pour autant, si j'ai bien compris.


Si, cela fonctionne bien à ce niveau. Si tu as des éléments derrière ton image, alors cela sera parfaitement visible, comme derrière une fêntre de verre wink

Force et sagesse...

Hors ligne


#13 

09-06-2009 20:26:00

capry
Membre
Date d'inscription: 14-02-2009
Messages: 83

Ah ? D'accord je testerais alors ^^, autant pour moi. Mais cela ne résous pas mon problème principal qui est la répétition de l'image, quelqu'un aurais une idée ? Entre-temps cet aprem je n'ai eu que le temps de faire en sorte que les bordures se mettent autour du bouton, j'attends encore la résolution du problème avant de passer aux évènements du bouton.

Hors ligne


#14 

12-06-2009 20:39:21

Magun
SleekThink Producer
Lieu: Punakha
Date d'inscription: 18-11-2007
Messages: 910
Corrections: 2
Site web

j'ai déjà un petit code si sa te tente ...

Project: ImmortalGalaxy, portfolio, github, Agence DRIAD

Hors ligne


#15 

12-06-2009 21:33:25

capry
Membre
Date d'inscription: 14-02-2009
Messages: 83

je veux bien ouais ^^, là je sèche un peu sur le truc de répétition :S

Hors ligne


#16 

12-06-2009 21:57:41

Magun
SleekThink Producer
Lieu: Punakha
Date d'inscription: 18-11-2007
Messages: 910
Corrections: 2
Site web

bon alors perso j'ai juste modifier de IGUISkin, pas vraiment dans ton optique si j'ai bien comprit m'enfin j'aime bien se que sa rend wink

le headler :

Code c++ :

#ifndef GameSkin_H_
#define GameSkin_H_

#include <irrlicht/irrlicht.h>
#include "../../externe/file/ReadConfig.h"
#include "../../externe/file/ReadColor.h"
#include "../../externe/file/ReadFont.h"

namespace irr
{
    namespace video
    {
        class IVideoDriver;
        class ITexture;
    }
    namespace gui
    {
        struct SImageGUIElementStyle
        {
            struct SBorder
            {
                s32 Top, Left, Bottom, Right;
                SBorder() : Top(0), Left(0), Bottom(0), Right(0) {}
            };
            SBorder SrcBorder;
            SBorder DstBorder;
            irr::video::ITexture* Texture;
            irr::video::SColor Color;

            SImageGUIElementStyle() : Texture(0), Color(255,255,255,255) {}
        };
        struct SImageGUISkinConfig
        {
            SImageGUIElementStyle SunkenPane, Window, Button, ButtonPressed, ProgressBar, ProgressBarFilled;
        };
        class GameSkin : public IGUISkin
        {
        public:
            GameSkin( irr::video::IVideoDriver* videoDriver, IGUISkin* fallbackSkin );
            virtual ~GameSkin();

            void loadConfig(externe::file::ReadColor*,externe::file::ReadFont*);

            virtual void setColor(EGUI_DEFAULT_COLOR which, irr::video::SColor newColor);
            virtual void setDefaultText(EGUI_DEFAULT_TEXT which, const wchar_t* newText);
            virtual void setSize(EGUI_DEFAULT_SIZE which, s32 size);
            virtual void setFont(IGUIFont* font, EGUI_DEFAULT_FONT defaultFont);
            virtual void setIcon(EGUI_DEFAULT_ICON icon, u32 index);
            virtual void setSpriteBank(IGUISpriteBank* bank);

            virtual irr::video::SColor getColor(EGUI_DEFAULT_COLOR color) const;
            virtual const wchar_t* getDefaultText(EGUI_DEFAULT_TEXT text) const;
            virtual s32 getSize(EGUI_DEFAULT_SIZE size) const;
            virtual IGUIFont* getFont(EGUI_DEFAULT_FONT defaultFont) const;
            virtual u32 getIcon(EGUI_DEFAULT_ICON icon) const;
            virtual IGUISpriteBank* getSpriteBank() const;

            virtual void draw3DButtonPaneStandard(IGUIElement*,const irr::core::rect<s32>&,const irr::core::rect<s32>*clip=0);
            virtual void draw3DButtonPanePressed(IGUIElement*,const irr::core::rect<s32>&,const irr::core::rect<s32>* clip=0);
            virtual void draw3DSunkenPane(IGUIElement*,irr::video::SColor , bool, bool,const irr::core::rect<s32>&,const irr::core::rect<s32>* clip=0);
            virtual irr::core::rect<s32> draw3DWindowBackground(IGUIElement*,bool, irr::video::SColor,const irr::core::rect<s32>&,const irr::core::rect<s32>* clip=0);
            virtual void draw3DMenuPane(IGUIElement*,const irr::core::rect<s32>&,const irr::core::rect<s32>* clip=0);
            virtual void draw3DToolBar(IGUIElement*,const irr::core::rect<s32>&,const irr::core::rect<s32>* clip=0);
            virtual void draw3DTabButton(IGUIElement*,bool,const irr::core::rect<s32>&, const irr::core::rect<s32>* clip=0, EGUI_ALIGNMENT alignment=EGUIA_UPPERLEFT);
            virtual void draw3DTabBody(IGUIElement*,bool,bool,const irr::core::rect<s32>&, const irr::core::rect<s32>* clip=0, s32 tabHeight=-1, EGUI_ALIGNMENT alignment=EGUIA_UPPERLEFT);
            virtual void drawIcon(IGUIElement*,EGUI_DEFAULT_ICON,const irr::core::position2di, u32 starttime=0, u32 currenttime=0,bool loop=false, const irr::core::rect<s32>* clip=0);
            virtual void drawHorizontalProgressBar( IGUIElement*,const irr::core::rect<s32>&, const irr::core::rect<s32>* clip,f32, irr::video::SColor);
            virtual void draw2DRectangle(IGUIElement*, const irr::video::SColor&,const irr::core::rect<s32>&, const irr::core::rect<s32>* clip = 0);
            irr::core::dimension2d<s32> titreBorder;
        private:
            void drawElementStyle( const SImageGUIElementStyle& elem, const irr::core::rect<s32>& rect, const irr::core::rect<s32>* clip, irr::video::SColor* color=0 );
            externe::file::ReadColor *color;
            externe::file::ReadFont  *XML;
            irr::video::IVideoDriver* VideoDriver;
            IGUISkin* FallbackSkin;
            SImageGUISkinConfig Config;
        };
    }
}

#endif


et la source :

Code c++ :

#include "GameSkin.h"
#include <irrlicht/IVideoDriver.h>
#include <irrlicht/ITexture.h>

using namespace irr;
using namespace core;
using namespace video;
//! murder under night

namespace irr
{
    namespace gui
    {
        GameSkin::GameSkin( IVideoDriver* driver, IGUISkin* fallbackSkin )
        {
            VideoDriver = driver;
            FallbackSkin = fallbackSkin;
            FallbackSkin->grab();
            //Type = EGST_WINDOWS_CLASSIC;
            setSize(EGDS_MESSAGE_BOX_WIDTH, 400);
            setSize(EGDS_TEXT_DISTANCE_X, 10);
            SImageGUIElementStyle* currentElement = 0;

            currentElement = &Config.Button;
            currentElement->Texture = VideoDriver->getTexture("monde/images/skin/button.tga");
            currentElement->SrcBorder.Top = 4;
            currentElement->SrcBorder.Left = 4;
            currentElement->SrcBorder.Bottom = 4;
            currentElement->SrcBorder.Right = 4;
            currentElement->DstBorder.Top = 4;
            currentElement->DstBorder.Left = 4;
            currentElement->DstBorder.Bottom = 4;
            currentElement->DstBorder.Right = 4;

            currentElement = &Config.ButtonPressed;
            currentElement->Texture = VideoDriver->getTexture("monde/images/skin/button.tga");
            currentElement->SrcBorder.Top = 0;
            currentElement->SrcBorder.Left = 0;
            currentElement->SrcBorder.Bottom = 0;
            currentElement->SrcBorder.Right = 0;
            currentElement->DstBorder.Top = 0;
            currentElement->DstBorder.Left = 0;
            currentElement->DstBorder.Bottom = 0;
            currentElement->DstBorder.Right = 0;

            currentElement = &Config.SunkenPane;
            currentElement->Texture = VideoDriver->getTexture("monde/images/skin/sunkenpane.tga");
            currentElement->SrcBorder.Top = 32;
            currentElement->SrcBorder.Left = 32;
            currentElement->SrcBorder.Bottom = 32;
            currentElement->SrcBorder.Right = 32;
            currentElement->DstBorder.Top = 10;
            currentElement->DstBorder.Left = 10;
            currentElement->DstBorder.Bottom = 10;
            currentElement->DstBorder.Right = 10;

            currentElement = &Config.Window;
            currentElement->Texture = VideoDriver->getTexture("monde/images/skin/window.tga");
            currentElement->SrcBorder.Top = 25;
            currentElement->SrcBorder.Left = 5;
            currentElement->SrcBorder.Bottom = 5;
            currentElement->SrcBorder.Right = 5;
            currentElement->DstBorder.Top = 25;
            currentElement->DstBorder.Left = 6;
            currentElement->DstBorder.Bottom = 6;
            currentElement->DstBorder.Right = 6;

            currentElement = &Config.ProgressBar;
            currentElement->Texture = VideoDriver->getTexture("monde/images/skin/gaugefilled.tga");
            currentElement->SrcBorder.Top = 30;
            currentElement->SrcBorder.Left = 64;
            currentElement->SrcBorder.Bottom = 30;
            currentElement->SrcBorder.Right = 64;
            currentElement->DstBorder.Top = 30;
            currentElement->DstBorder.Left = 64;
            currentElement->DstBorder.Bottom = 30;
            currentElement->DstBorder.Right = 64;

            currentElement = &Config.ProgressBarFilled;
            currentElement->Texture = VideoDriver->getTexture("monde/images/skin/gauge.tga");
            currentElement->SrcBorder.Top = 30;
            currentElement->SrcBorder.Left = 64;
            currentElement->SrcBorder.Bottom = 0;
            currentElement->SrcBorder.Right = 0;
            currentElement->DstBorder.Top = 30;
            currentElement->DstBorder.Left = 64;
            currentElement->DstBorder.Bottom = 0;
            currentElement->DstBorder.Right = 0;
        }
        GameSkin::~GameSkin()
        {
            FallbackSkin->drop();
        }
        void GameSkin::loadConfig(externe::file::ReadColor *cl,externe::file::ReadFont*xlm)
        {
            color = cl;
            XML = xlm;
        }
        SColor GameSkin::getColor(EGUI_DEFAULT_COLOR color) const
        {
            return this->color->getColor(color);
            return FallbackSkin->getColor(color);
        }
        void GameSkin::setColor( EGUI_DEFAULT_COLOR which,SColor newColor )
        {
            return color->setColor(which,newColor);
            FallbackSkin->setColor(which,newColor);
        }
        s32 GameSkin::getSize(EGUI_DEFAULT_SIZE size) const
        {
            return FallbackSkin->getSize(size);
        }
        const wchar_t* GameSkin::getDefaultText(EGUI_DEFAULT_TEXT text) const
        {
            return FallbackSkin->getDefaultText(text);
        }
        void GameSkin::setDefaultText(EGUI_DEFAULT_TEXT which, const wchar_t* newText)
        {
            FallbackSkin->setDefaultText(which, newText);
        }
        void GameSkin::setSize(EGUI_DEFAULT_SIZE which, s32 size)
        {
            FallbackSkin->setSize(which, size);
        }
        IGUIFont* GameSkin::getFont(EGUI_DEFAULT_FONT defaultFont) const
        {
            return FallbackSkin->getFont(defaultFont);
        }
        void GameSkin::setFont(IGUIFont* font, EGUI_DEFAULT_FONT defaultFont)
        {
            if(font) FallbackSkin->setFont(font, defaultFont);
        }
        IGUISpriteBank* GameSkin::getSpriteBank() const
        {
            return FallbackSkin->getSpriteBank();
        }
        void GameSkin::setSpriteBank( IGUISpriteBank* bank )
        {
            FallbackSkin->setSpriteBank(bank);
        }
        u32 GameSkin::getIcon( EGUI_DEFAULT_ICON icon ) const
        {
            return FallbackSkin->getIcon(icon);
        }
        void GameSkin::setIcon( EGUI_DEFAULT_ICON icon, u32 index )
        {
            FallbackSkin->setIcon(icon, index);
        }
        void GameSkin::draw3DButtonPaneStandard( IGUIElement* element, const core::rect<s32>& rect, const core::rect<s32>* clip )
        {
            if ( !Config.Button.Texture )
            {
                FallbackSkin->draw3DButtonPaneStandard( element, rect, clip );
                return;
            }
            drawElementStyle( Config.Button, rect, clip );
        }
        void GameSkin::draw3DButtonPanePressed( IGUIElement* element, const core::rect<s32>& rect, const core::rect<s32>* clip )
        {
            if ( !Config.Button.Texture )
            {
                FallbackSkin->draw3DButtonPanePressed( element, rect, clip );
                return;
            }
            drawElementStyle( Config.ButtonPressed, rect, clip );
        }
        void GameSkin::draw3DSunkenPane(IGUIElement* element,SColor bgcolor, bool flat, bool fillBackGround,const core::rect<s32>& rect,const core::rect<s32>* clip)
        {
            if ( !Config.SunkenPane.Texture )
            {
                FallbackSkin->draw3DSunkenPane(element, bgcolor, flat, fillBackGround, rect, clip);
                return;
            }
            drawElementStyle( Config.SunkenPane, rect, clip );
        }
        core::rect<s32> GameSkin::draw3DWindowBackground(IGUIElement* element,bool drawTitleBar, SColor titleBarColor,const core::rect<s32>& rect,const core::rect<s32>* clip)
        {
            if ( !Config.Window.Texture )
            {
                return FallbackSkin->draw3DWindowBackground(element, drawTitleBar, titleBarColor, rect, clip );
            }
            drawElementStyle( Config.Window, rect, clip );

            return core::rect<s32>( rect.UpperLeftCorner.X+Config.Window.DstBorder.Left, rect.UpperLeftCorner.Y, rect.LowerRightCorner.X-Config.Window.DstBorder.Right, rect.UpperLeftCorner.Y+Config.Window.DstBorder.Top );
        }
        void GameSkin::draw3DMenuPane(IGUIElement* element,
                    const core::rect<s32>& rect,
                    const core::rect<s32>* clip)
        {
            FallbackSkin->draw3DMenuPane(element,rect,clip);
        }
        void GameSkin::draw3DToolBar(IGUIElement* element,
            const core::rect<s32>& rect,
            const core::rect<s32>* clip)
        {
            FallbackSkin->draw3DToolBar(element,rect,clip);
        }
        void GameSkin::draw3DTabButton(IGUIElement* element, bool active,
                    const core::rect<s32>& rect, const core::rect<s32>* clip, EGUI_ALIGNMENT alignment)
        {
            FallbackSkin->draw3DTabButton(element, active, rect, clip, alignment);
        }
        void GameSkin::draw3DTabBody(IGUIElement* element, bool border, bool background,
                    const core::rect<s32>& rect, const core::rect<s32>* clip, s32 tabHeight, EGUI_ALIGNMENT alignment)
        {
            FallbackSkin->draw3DTabBody(element, border, background, rect, clip, tabHeight, alignment);
        }
        void GameSkin::drawIcon(IGUIElement* element, EGUI_DEFAULT_ICON icon,
            const core::position2di position, u32 starttime, u32 currenttime,
            bool loop, const core::rect<s32>* clip)
        {
            FallbackSkin->drawIcon(element,icon,position,starttime,currenttime,loop,clip);
        }
        void GameSkin::drawHorizontalProgressBar( IGUIElement* element, const core::rect<s32>& rectangle, const core::rect<s32>* clip,
                    f32 filledRatio, SColor fillColor )
        {
            if ( !Config.ProgressBar.Texture || !Config.ProgressBarFilled.Texture )
            {
                return;
            }
            drawElementStyle( Config.ProgressBar, rectangle, clip );

                s32 filledPixels = (s32)( filledRatio * rectangle.getSize().Width );
                s32 height = rectangle.getSize().Height;

                core::rect<s32> clipRect = clip? *clip:rectangle;
                if ( filledPixels < height )
                {
                    if ( clipRect.LowerRightCorner.X > rectangle.UpperLeftCorner.X + filledPixels )
                        clipRect.LowerRightCorner.X = rectangle.UpperLeftCorner.X + filledPixels;

                    filledPixels = height;
                }

                core::rect<s32> filledRect = core::rect<s32>(
                    rectangle.UpperLeftCorner.X,
                    rectangle.UpperLeftCorner.Y,
                    rectangle.UpperLeftCorner.X + filledPixels,
                    rectangle.LowerRightCorner.Y + filledPixels);

                drawElementStyle( Config.ProgressBarFilled, filledRect, &clipRect, &fillColor );
        }
        void GameSkin::drawElementStyle( const SImageGUIElementStyle& elem, const core::rect<s32>& rect, const core::rect<s32>* clip, SColor* pcolor  )
        {
            core::rect<s32> srcRect;
            core::rect<s32> dstRect;
            core::dimension2di tsize = (core::dimension2di)elem.Texture->getSize();
            ITexture* texture = elem.Texture;

            SColor color = elem.Color;
            if ( pcolor )
                color = *pcolor;

            SColor faceColor = getColor(EGDC_APP_WORKSPACE);
            color.setRed( (u8)(color.getRed() * faceColor.getRed() / 255) );
            color.setGreen( (u8)(color.getGreen() * faceColor.getGreen() / 255 ) );
            color.setBlue( (u8)(color.getBlue() * faceColor.getBlue() / 255) );
            color.setAlpha( (u8)(color.getAlpha() * faceColor.getAlpha() / 255 ) );

            SColor colors [4] = { color, color, color, color };
            core::dimension2di dstSize = rect.getSize();

            SImageGUIElementStyle::SBorder dst = elem.DstBorder;
            f32 scale = 1.0f;
            if ( dstSize.Width < dst.Left + dst.Right )
            {
                scale = dstSize.Width / (f32)( dst.Left + dst.Right );
            }
            if ( dstSize.Height < dst.Top + dst.Bottom )
            {
                f32 x = dstSize.Height / (f32)( dst.Top + dst.Bottom );
                if ( x < scale )
                {
                    scale = x;
                }
            }
            if ( scale < 1.0f )
            {
                dst.Left = (s32)( dst.Left * scale );
                dst.Right = (s32)( dst.Right * scale );
                dst.Top = (s32)( dst.Top * scale );
                dst.Bottom = (s32)( dst.Bottom * scale );
            }

            const SImageGUIElementStyle::SBorder& src = elem.SrcBorder;

            // Draw the top left corner
            srcRect = core::rect<s32>( 0, 0, src.Left, src.Top );
            dstRect = core::rect<s32>( rect.UpperLeftCorner.X, rect.UpperLeftCorner.Y, rect.UpperLeftCorner.X+dst.Left, rect.UpperLeftCorner.Y+dst.Top );
        //    if ( !clip || clipRects( dstRect, srcRect, *clip ) )
                VideoDriver->draw2DImage( texture, dstRect, srcRect, clip, colors, true );

            // Draw the top right corner
            srcRect = core::rect<s32>( tsize.Width-src.Right, 0, tsize.Width, src.Top );
            dstRect = core::rect<s32>( rect.LowerRightCorner.X-dst.Right, rect.UpperLeftCorner.Y, rect.LowerRightCorner.X, rect.UpperLeftCorner.Y+dst.Top );
        //    if ( !clip || clipRects( dstRect, srcRect, *clip ) )
                VideoDriver->draw2DImage( texture, dstRect, srcRect, clip, colors, true );

            // Draw the top border
            srcRect = core::rect<s32>( src.Left, 0, tsize.Width-src.Right, src.Top );
            dstRect = core::rect<s32>( rect.UpperLeftCorner.X+dst.Left, rect.UpperLeftCorner.Y, rect.LowerRightCorner.X-dst.Right, rect.UpperLeftCorner.Y+dst.Top );
        //    if ( !clip || clipRects( dstRect, srcRect, *clip ) )
                VideoDriver->draw2DImage( texture, dstRect, srcRect, clip, colors, true );

            // Draw the left border
            srcRect = core::rect<s32>( 0, src.Top, src.Left, tsize.Height-src.Bottom );
            dstRect = core::rect<s32>( rect.UpperLeftCorner.X, rect.UpperLeftCorner.Y+dst.Top, rect.UpperLeftCorner.X+dst.Left, rect.LowerRightCorner.Y-dst.Bottom );
        //    if ( !clip || clipRects( dstRect, srcRect, *clip ) )
                VideoDriver->draw2DImage( texture, dstRect, srcRect, clip, colors, true );

            // Draw the right border
            srcRect = core::rect<s32>( tsize.Width-src.Right, src.Top, tsize.Width, tsize.Height-src.Bottom );
            dstRect = core::rect<s32>( rect.LowerRightCorner.X-dst.Right, rect.UpperLeftCorner.Y+dst.Top, rect.LowerRightCorner.X, rect.LowerRightCorner.Y-dst.Bottom );
        //    if ( !clip || clipRects( dstRect, srcRect, *clip ) )
                VideoDriver->draw2DImage( texture, dstRect, srcRect, clip, colors, true );

            // Draw the middle section
            srcRect = core::rect<s32>( src.Left, src.Top, tsize.Width-src.Right, tsize.Height-src.Bottom );
            dstRect = core::rect<s32>( rect.UpperLeftCorner.X+dst.Left, rect.UpperLeftCorner.Y+dst.Top, rect.LowerRightCorner.X-dst.Right, rect.LowerRightCorner.Y-dst.Bottom );
        //    if ( !clip || clipRects( dstRect, srcRect, *clip ) )
                VideoDriver->draw2DImage( texture, dstRect, srcRect, clip, colors, true );

            // Draw the bottom left corner
            srcRect = core::rect<s32>( 0, tsize.Height-src.Bottom, src.Left, tsize.Height );
            dstRect = core::rect<s32>( rect.UpperLeftCorner.X, rect.LowerRightCorner.Y-dst.Bottom, rect.UpperLeftCorner.X+dst.Left, rect.LowerRightCorner.Y );
        //    if ( !clip || clipRects( dstRect, srcRect, *clip ) )
                VideoDriver->draw2DImage( texture, dstRect, srcRect, clip, colors, true );

            // Draw the bottom right corner
            srcRect = core::rect<s32>( tsize.Width-src.Right, tsize.Height-src.Bottom, tsize.Width, tsize.Height );
            dstRect = core::rect<s32>( rect.LowerRightCorner.X-dst.Right, rect.LowerRightCorner.Y-dst.Bottom, rect.LowerRightCorner.X, rect.LowerRightCorner.Y );
        //    if ( !clip || clipRects( dstRect, srcRect, *clip ) )
                VideoDriver->draw2DImage( texture, dstRect, srcRect, clip, colors, true );

            // Draw the bottom border
            srcRect = core::rect<s32>( src.Left, tsize.Height-src.Bottom, tsize.Width-src.Right, tsize.Height );
            dstRect = core::rect<s32>( rect.UpperLeftCorner.X+dst.Left, rect.LowerRightCorner.Y-dst.Bottom, rect.LowerRightCorner.X-dst.Right, rect.LowerRightCorner.Y );
        //    if ( !clip || clipRects( dstRect, srcRect, *clip ) )
                VideoDriver->draw2DImage( texture, dstRect, srcRect, clip, colors, true );
        }
        void GameSkin::draw2DRectangle(IGUIElement* element, const SColor &color,const core::rect<s32>& pos, const core::rect<s32>* clip)
        {
//            FallbackSkin->draw2DRectangle(element, color, pos, clip);
            if(pos.UpperLeftCorner.X  >= element->getAbsolutePosition().UpperLeftCorner.X  && pos.UpperLeftCorner.Y  >= element->getAbsolutePosition().UpperLeftCorner.Y)
            if(pos.LowerRightCorner.X <= element->getAbsolutePosition().LowerRightCorner.X && pos.LowerRightCorner.Y <= element->getAbsolutePosition().LowerRightCorner.Y)
            {
                SImageGUIElementStyle tmp = *&Config.SunkenPane;
                tmp.Color = color;
                drawElementStyle(tmp,pos,clip);
            }
        }
    } // namespace gui
} // namespace irr


répétition ? fait des essaye avec le clipRect si tu utilise un driver->draw2dImage wink
en récupérent le clipRect de guienv->getRootGUIElement()->AbsoluteClippingRect sa marche je croix ... enfin ses vieux, quand je l'avais fait
seulement il est en protected ....

ta de la chance tu va être le premier du forum a voir un extré de mon projet

Dernière modification par Magun (16-08-2009 10:45:52)

Project: ImmortalGalaxy, portfolio, github, Agence DRIAD

Hors ligne


#17 

13-06-2009 01:18:11

capry
Membre
Date d'inscription: 14-02-2009
Messages: 83

Ouah ! ça rend carrément chouette ^^ ! Je vais étudier ton code ce week-end et l'adapter ! Merci beaucoup !

Hors ligne


#18 

13-06-2009 01:35:19

Magun
SleekThink Producer
Lieu: Punakha
Date d'inscription: 18-11-2007
Messages: 910
Corrections: 2
Site web

copie pas tout tout de même !
j'ai poster le code pour que tu t'en inspire ... tu trouve un code similaire sans mes modif dans les codes snifer du forum off
ne me fait pas regretter mon geste tongue

Dernière modification par Magun (13-06-2009 01:40:14)

Project: ImmortalGalaxy, portfolio, github, Agence DRIAD

Hors ligne


#19 

13-06-2009 11:56:02

capry
Membre
Date d'inscription: 14-02-2009
Messages: 83

ok, mais après réflexion ce n'est pas tout-à-fais ce que je recherche. Je ne veux pas seulement changer l'interface, mais crée un nouvelle gui, de façon à rajouter des choses comme les textes défilant ou les cliqué-glissé, qui ne sont pas dans la gui standard d'Irrlicht ^^

Hors ligne


#20 

13-06-2009 12:38:03

Magun
SleekThink Producer
Lieu: Punakha
Date d'inscription: 18-11-2007
Messages: 910
Corrections: 2
Site web

ben la faut que tu dérive de IGUIElement et non de IImage, mais sa t'empêche pas d'en utiliser dans ta nouvelle class ...
le truc ses qu'avec ma méthode j'ai pas besoins de tout recrée, et sa s'applique aussi si je crée des élément gui wink

Project: ImmortalGalaxy, portfolio, github, Agence DRIAD

Hors ligne


#21 

13-06-2009 13:32:02

tmyke
Administrateur
Date d'inscription: 24-03-2008
Messages: 1025

Pas mal ton message d'ailleurs sur le forum off (Ovan wink  )

Force et sagesse...

Hors ligne


#22 

13-06-2009 13:42:55

Magun
SleekThink Producer
Lieu: Punakha
Date d'inscription: 18-11-2007
Messages: 910
Corrections: 2
Site web

merci wink
ses que j'ai pas trop l'habitude de poster en anglais ... donc voila tongue

Dernière modification par Magun (13-06-2009 13:45:22)

Project: ImmortalGalaxy, portfolio, github, Agence DRIAD

Hors ligne


#23 

13-06-2009 14:58:41

capry
Membre
Date d'inscription: 14-02-2009
Messages: 83

Donc finalement toujours le même problème de fond :S, je continue les recherches

Hors ligne


#24 

13-06-2009 15:09:39

Magun
SleekThink Producer
Lieu: Punakha
Date d'inscription: 18-11-2007
Messages: 910
Corrections: 2
Site web

je suis pas sur que tu a tout comprit le principe de ma class ...
en fait sa modifie le IGUISkin du moteur, après j'ai juste a faire guienv->addTrucMuch(...); , et il aqui directement sont "skin"
après si tu crée tes propre élément gui, il acquis directement le skin ... sans rien modifier

Project: ImmortalGalaxy, portfolio, github, Agence DRIAD

Hors ligne


 

Pages: 1 2

Options Liens officiels Caractéristiques Statistiques Communauté
Corrections
 irrlicht
irrklang
irredit
irrxml
 xhtml 1.0
css 2.1
Propulsé par FluxBB
Traduit par FluxBB.fr
 883 membres
1429 sujets
11121 messages
 Dernier membre inscrit: Saidov17
58 invités en ligne
Aucun membre connecté
RSS Feed